Parse AnfPolynomial from string

Author: thomasarmel

src/anf_polynom.rs

@@ -6,6 +6,7 @@ use itertools::Itertools;
 use num_bigint::BigUint;
 use num_traits::{One, Zero};
 use std::fmt::Display;
+use crate::BooleanFunctionError;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 enum PolynomialFormat {
@@ -122,6 +123,70 @@ impl AnfPolynomial {
             .join(" + ")
     }
 
+    /// Computes the ANF polynomial from string representation
+    ///
+    /// Representation must be in the form "`x0*x2*x3 + x2*x3 + x1 + 1`".
+    ///
+    /// X's index start at 0, meaning the maximum index is variable count - 1.
+    ///
+    /// # Parameters:
+    /// - `anf_polynomial`: The string representation of the ANF form
+    /// - `num_variables`: Variable count of the polynomial
+    ///
+    /// # Returns:
+    /// The ANF polynomial, or an error if the input string doesn't respect the format and `unsafe_disable_safety_checks` feature is not activated.
+    pub fn from_str(anf_polynomial: &str, num_variables: usize) -> Result<Self, BooleanFunctionError> {
+        let anf_polynomial_filtered = anf_polynomial.chars().filter(|c| !c.is_whitespace()).collect::<String>();
+
+        let mut anf_polynomial_obj = Self {
+            polynomial: if num_variables <= 6 {
+                PolynomialFormat::Small(0u64)
+            } else {
+                PolynomialFormat::Big(BigUint::zero())
+            },
+            num_variables,
+        };
+
+        for monomial_string in anf_polynomial_filtered.split('+') {
+            if monomial_string == "1" {
+                anf_polynomial_obj.flip_bit_pos(0)?;
+                continue;
+            }
+            let mut bit_position_to_flip = 0u64;
+            for factor in monomial_string.split('*') {
+                #[cfg(not(feature = "unsafe_disable_safety_checks"))]
+                if factor.chars().nth(0).ok_or(BooleanFunctionError::ErrorParsingAnfString)? != 'x' {
+                    return Err(BooleanFunctionError::ErrorParsingAnfString);
+                }
+                let factor_index = factor[1..].parse::<u64>().map_err(|_| BooleanFunctionError::ErrorParsingAnfString)?;
+                #[cfg(not(feature = "unsafe_disable_safety_checks"))]
+                if factor_index as usize >= num_variables {
+                    return Err(BooleanFunctionError::AnfFormNVariableTooBigFactor(num_variables, factor_index as usize));
+                }
+                bit_position_to_flip |= 1 << factor_index;
+            }
+            anf_polynomial_obj.flip_bit_pos(bit_position_to_flip)?;
+        }
+
+        Ok(anf_polynomial_obj)
+    }
+
+    fn flip_bit_pos(&mut self, bit_position: u64) -> Result<(), BooleanFunctionError> {
+        #[cfg(not(feature = "unsafe_disable_safety_checks"))]
+        if bit_position >= 1 << self.num_variables {
+            return Err(BooleanFunctionError::UnexpectedError);
+        }
+        match &mut self.polynomial {
+            PolynomialFormat::Small(anf) => {
+                *anf ^= 1u64 << bit_position
+            },
+            PolynomialFormat::Big(anf) => {
+                anf.set_bit(bit_position, !anf.bit(bit_position))
+            }
+        }
+        Ok(())
+    }
+
     /// Monomial and number of variables in the monomial
     fn bit_monomial_to_string(&self, bit_position: u64) -> (String, usize) {
         if bit_position == 0 {
@@ -133,6 +198,17 @@ impl AnfPolynomial {
             .collect();
         (monomial_coefs_list.join("*"), monomial_coefs_list.len())
     }
+
+    /// Returns Boolean function internal storage type:
+    ///
+    /// - [Small](crate::BooleanFunctionType::Small) for `u64` internal storage (less or equal than 6 variables Boolean function)
+    /// - [Big](crate::BooleanFunctionType::Big) for `BigUInt` internal storage (more than 6 variables Boolean function)
+    pub fn get_boolean_function_type(&self) -> crate::BooleanFunctionType {
+        match self.polynomial {
+            PolynomialFormat::Small(_) => crate::BooleanFunctionType::Small,
+            PolynomialFormat::Big(_) => crate::BooleanFunctionType::Big
+        }
+    }
 }
 
 /// Display implementation for `AnfPolynomial`.
@@ -149,6 +225,7 @@ mod tests {
     use crate::anf_polynom::AnfPolynomial;
     use num_bigint::BigUint;
     use num_traits::{Num, One, Zero};
+    use crate::BooleanFunctionError;
 
     #[test]
     fn test_get_polynomial_small() {
@@ -237,4 +314,47 @@ mod tests {
         let anf_polynomial = AnfPolynomial::from_anf_big(&BigUint::one(), 3);
         assert_eq!(anf_polynomial.to_string(), "1");
     }
+
+    #[test]
+    fn test_from_str() {
+        let anf_str = "x0*x1 + x0 + x0 + x0 + 1";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 3).unwrap();
+        assert_eq!(anf_polynomial.to_string(), "x0*x1 + x0 + 1");
+        assert_eq!(anf_polynomial.get_boolean_function_type(), crate::BooleanFunctionType::Small);
+
+        let anf_str = "x2 + x0*x1 + x0";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 3).unwrap();
+        assert_eq!(anf_polynomial.to_string(), "x0*x1 + x0 + x2");
+        assert_eq!(anf_polynomial.get_boolean_function_type(), crate::BooleanFunctionType::Small);
+
+        let anf_str = "x0*x1 + x2 + x0 + 1";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 2);
+        assert!(anf_polynomial.is_err());
+        assert_eq!(anf_polynomial.unwrap_err(), BooleanFunctionError::AnfFormNVariableTooBigFactor(2, 2));
+
+        let anf_str = "x0*y1 + x2 + x0 + 1";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 3);
+        assert!(anf_polynomial.is_err());
+        assert_eq!(anf_polynomial.unwrap_err(), BooleanFunctionError::ErrorParsingAnfString);
+
+        let anf_str = "x0*xy1 + x2 + x0 + 1";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 3);
+        assert!(anf_polynomial.is_err());
+        assert_eq!(anf_polynomial.unwrap_err(), BooleanFunctionError::ErrorParsingAnfString);
+
+        let anf_str = "x0*x1*x2*x3*x4*x5*x6 + x7 + x6 + x6 + 1";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 8).unwrap();
+        assert_eq!(anf_polynomial.to_string(), "x0*x1*x2*x3*x4*x5*x6 + x7 + 1");
+        assert_eq!(anf_polynomial.get_boolean_function_type(), crate::BooleanFunctionType::Big);
+
+        let anf_str = "x0*x1*x2*x3*x4*x5*x6 + x7";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 8).unwrap();
+        assert_eq!(anf_polynomial.to_string(), "x0*x1*x2*x3*x4*x5*x6 + x7");
+        assert_eq!(anf_polynomial.get_boolean_function_type(), crate::BooleanFunctionType::Big);
+
+        let anf_str = "x0x1*x2*x3*x4*x5*x6 + x7";
+        let anf_polynomial = AnfPolynomial::from_str(anf_str, 8);
+        assert!(anf_polynomial.is_err());
+        assert_eq!(anf_polynomial.unwrap_err(), BooleanFunctionError::ErrorParsingAnfString);
+    }
 }

src/boolean_function_error.rs

@@ -3,7 +3,7 @@
 use thiserror::Error;
 
 /// Possible errors for the boolean function library.
-#[derive(Error, Debug, PartialEq)]
+#[derive(Error, Debug, PartialEq, Clone)]
 pub enum BooleanFunctionError {
     /// Error parsing hex string: the string length must be a power of 2 to represent a truth table.
     #[error("Hex truth table length must be a power of 2")]
@@ -30,6 +30,12 @@ pub enum BooleanFunctionError {
     /// Cannot generate close balanced Boolean function iterator, as the given function is already balanced
     #[error("This Boolean function is already balanced")]
     AlreadyBalanced,
+    /// Error parsing ANF string, should be in the form "x0*x2*x3 + x2*x3 + x1 + 1"
+    #[error("Error parsing ANF string, should be in the form \"x0*x2*x3 + x2*x3 + x1 + 1\"")]
+    ErrorParsingAnfString,
+    /// The given factor is too big for the variable count. For example, x4 cannot exist if variable count = 4
+    #[error("There are {0} variables in this ANF form, x{1} factor shouldn't appear")]
+    AnfFormNVariableTooBigFactor(usize, usize),
 }
 
 pub(crate) const XOR_DIFFERENT_VAR_COUNT_PANIC_MSG: &'static str =