Generate SmallBooleanFunction and BigBooleanFunction from ANF polynomial and string representation, bump new version

Author: thomasarmel

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "boolean_function"
 description = "Mathematical analysis of Boolean functions"
-version = "0.0.5"
+version = "0.0.6"
 edition = "2021"
 rust-version = "1.56.0"
 authors = ["Thomas Prévost"]
@@ -15,10 +15,10 @@ exclude = [".github/*", "examples"]
 num-traits = "0.2"
 num-integer = "0.1"
 num-bigint = "0.4"
-thiserror = "1.0"
+thiserror = "2.0"
 itertools = "0.13"
 fast-boolean-anf-transform = "0.0.3"
-gen-combinations = "0.1.0"
+gen-combinations = "0.1"
 enum_dispatch = "0.3"
 ouroboros = "0.18"
 

src/big_boolean_function.rs

@@ -9,7 +9,7 @@ use crate::{BooleanFunction, BooleanFunctionError, BooleanFunctionImpl, BooleanF
 use itertools::{enumerate, Itertools};
 use num_bigint::BigUint;
 use num_integer::binomial;
-use num_traits::{One, Zero};
+use num_traits::{FromPrimitive, One, Zero};
 use std::ops::{BitXor, BitXorAssign, Not};
 
 /// Struct representing a boolean function with a big truth table.
@@ -306,6 +306,41 @@ impl BigBooleanFunction {
 
         Ok(BigCloseBalancedFunctionIterator::create(self, flippable_positions, bits_to_flip_count))
     }
+
+    /// Computes BigBooleanFunction from string ANF representation
+    ///
+    /// The ANF string representation must be in exact form "`x0*x2*x3 + x2*x3 + x1 + 1`".
+    ///
+    /// X's index starts 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 BigBooleanFunction corresponding to the ANF string representation, or an error if the input string doesn't respect the format,
+    /// and `unsafe_disable_safety_checks` feature is not activated.
+    pub fn from_anf_polynomial_str_inner(anf_polynomial: &str, num_variables: usize) -> Result<Self, BooleanFunctionError> {
+        Ok(Self::from_anf_polynomial_inner(
+            &AnfPolynomial::from_str(anf_polynomial, num_variables)?
+        ))
+    }
+
+    /// Computes BigBooleanFunction from ANF polynomial
+    ///
+    /// # Parameters:
+    /// - `anf_polynomial`: The polynomial in Algebraic Normal Form
+    ///
+    /// # Returns
+    /// The BigBooleanFunction corresponding to the ANF polynomial
+    pub fn from_anf_polynomial_inner(anf_polynomial: &AnfPolynomial) -> Self {
+        match anf_polynomial.to_boolean_function() {
+            BooleanFunction::Small(small_bf) => BigBooleanFunction::from_truth_table(
+                BigUint::from_u64(small_bf.get_truth_table_u64()).unwrap(), small_bf.variables_count()
+            ),
+            BooleanFunction::Big(big_bf) => big_bf
+        }
+    }
 }
 impl BooleanFunctionImpl for BigBooleanFunction {
     #[inline]
@@ -335,7 +370,7 @@ impl BooleanFunctionImpl for BigBooleanFunction {
     }
 
     fn derivative(&self, direction: u32) -> Result<BooleanFunction, BooleanFunctionError> {
-        Ok((self.derivative_inner(direction)?).into())
+        Ok(self.derivative_inner(direction)?.into())
     }
 
     fn is_linear(&self) -> bool {
@@ -439,7 +474,7 @@ impl Not for BigBooleanFunction {
 
 #[cfg(test)]
 mod tests {
-    use crate::{BigBooleanFunction, BooleanFunctionImpl};
+    use crate::{AnfPolynomial, BigBooleanFunction, BooleanFunctionError, BooleanFunctionImpl};
     use num_bigint::BigUint;
     use num_traits::{Num, One, Zero};
 
@@ -974,4 +1009,32 @@ mod tests {
             assert!(close_balanced_iterator.next().unwrap().is_balanced());
         }
     }
+
+    #[test]
+    fn test_from_anf_polynomial_str_inner() {
+        let rule_30_anf_str = "x0*x1 + x0 + x1 + x2";
+        let rule_30_function = BigBooleanFunction::from_anf_polynomial_str_inner(rule_30_anf_str, 3).unwrap();
+        assert_eq!(rule_30_function.printable_hex_truth_table(), "1e");
+
+        let anf_str = "x7*x6*x0*x1 + x0 + x1 + x2";
+        let boolean_function = BigBooleanFunction::from_anf_polynomial_str_inner(anf_str, 3);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::AnfFormNVariableTooBigFactor(3, 7));
+
+        let anf_str = "x7*x6*x0*x1 + x0 + x1 + x2";
+        let boolean_function = BigBooleanFunction::from_anf_polynomial_str_inner(anf_str, 8).unwrap();
+        assert_eq!(boolean_function.printable_hex_truth_table(), "1e1e1e1e1e1e1e1e969696969696969696969696969696969696969696969696");
+
+        let anf_str = "x0*y1 + x0 + x1 + x2";
+        let boolean_function = BigBooleanFunction::from_anf_polynomial_str_inner(anf_str, 3);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::ErrorParsingAnfString);
+    }
+
+    #[test]
+    fn test_from_anf_polynomial_inner() {
+        let anf = AnfPolynomial::from_str("x7*x6*x0*x1 + x0 + x1 + x2", 8).unwrap();
+        let boolean_function = BigBooleanFunction::from_anf_polynomial_inner(&anf);
+        assert_eq!(boolean_function.printable_hex_truth_table(), "1e1e1e1e1e1e1e1e969696969696969696969696969696969696969696969696");
+    }
 }

src/lib.rs

@@ -954,8 +954,6 @@ impl BooleanFunction {
     }
 }
 
-// TODO from ANF in Small and Big Boolean functions
-
 #[cfg(test)]
 mod tests {
     use crate::BooleanFunctionError::InvalidWalshValuesCount;

src/small_boolean_function.rs

@@ -3,9 +3,7 @@ use crate::anf_polynom::AnfPolynomial;
 use crate::boolean_function_error::XOR_DIFFERENT_VAR_COUNT_PANIC_MSG;
 use crate::iterator::{BooleanFunctionIterator, CloseBalancedFunctionIterator, SmallCloseBalancedFunctionIterator};
 use crate::utils::left_kernel_boolean;
-#[cfg(not(feature = "unsafe_disable_safety_checks"))]
-use crate::BooleanFunctionError::TooBigTruthTableForVarCount;
-use crate::BooleanFunctionError::TooBigVariableCount;
+use crate::BooleanFunctionError::{TooBigTruthTableForVarCount, TooBigVariableCount};
 use crate::{BooleanFunction, BooleanFunctionError, BooleanFunctionImpl, BooleanFunctionType};
 use fast_boolean_anf_transform::fast_bool_anf_transform_unsigned;
 use itertools::{enumerate, Itertools};
@@ -327,6 +325,44 @@ impl SmallBooleanFunction {
 
         Ok(SmallCloseBalancedFunctionIterator::create(self, flippable_positions, bits_to_flip_count))
     }
+
+    /// Computes SmallBooleanFunction from string ANF representation
+    ///
+    /// The ANF string representation must be in exact form "`x0*x2*x3 + x2*x3 + x1 + 1`".
+    ///
+    /// X's index starts 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 SmallBooleanFunction corresponding to the ANF string representation, or an error if:
+    /// - the input string doesn't respect the format and `unsafe_disable_safety_checks` feature is not activated.
+    /// - the polynomial variable count is greater than 6
+    pub fn from_anf_polynomial_str_inner(anf_polynomial: &str, num_variables: usize) -> Result<Self, BooleanFunctionError> {
+        #[cfg(not(feature = "unsafe_disable_safety_checks"))]
+        if num_variables > 6 {
+            return Err(TooBigTruthTableForVarCount);
+        }
+        Ok(Self::from_anf_polynomial_inner(
+            &AnfPolynomial::from_str(anf_polynomial, num_variables)?
+        )?)
+    }
+
+    /// Computes SmallBooleanFunction from ANF polynomial
+    ///
+    /// # Parameters:
+    /// - `anf_polynomial`: The polynomial in Algebraic Normal Form
+    ///
+    /// # Returns
+    /// The SmallBooleanFunction corresponding to the ANF polynomial, or an error if polynomial variable count > 6
+    pub fn from_anf_polynomial_inner(anf_polynomial: &AnfPolynomial) -> Result<Self, BooleanFunctionError> {
+        match anf_polynomial.to_boolean_function() {
+            BooleanFunction::Small(small_bf) => Ok(small_bf),
+            BooleanFunction::Big(_) => Err(TooBigTruthTableForVarCount)
+        }
+    }
 }
 
 impl BooleanFunctionImpl for SmallBooleanFunction {
@@ -461,7 +497,7 @@ impl Not for SmallBooleanFunction {
 
 #[cfg(test)]
 mod tests {
-    use crate::{BooleanFunctionImpl, SmallBooleanFunction};
+    use crate::{AnfPolynomial, BooleanFunctionError, BooleanFunctionImpl, SmallBooleanFunction};
 
     #[test]
     fn test_from_truth_table() {
@@ -862,4 +898,39 @@ mod tests {
         let mut close_balanced_iterator = bent_function.close_balanced_functions_iterator_inner().unwrap();
         assert!(close_balanced_iterator.all(|f| f.is_balanced()));
     }
+
+    #[test]
+    fn test_from_anf_polynomial_str_inner() {
+        let rule_30_anf_str = "x0*x1 + x0 + x1 + x2";
+        let rule_30_function = SmallBooleanFunction::from_anf_polynomial_str_inner(rule_30_anf_str, 3).unwrap();
+        assert_eq!(rule_30_function.printable_hex_truth_table(), "1e");
+        assert_eq!(rule_30_function.get_truth_table_u64(), 30);
+
+        let rule_30_anf_str = "x0*x1 + x0 + x1 + x2";
+        let boolean_function = SmallBooleanFunction::from_anf_polynomial_str_inner(rule_30_anf_str, 8);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::TooBigTruthTableForVarCount);
+
+        let anf_str = "x0*x1*x3 + x0 + x1 + x2";
+        let boolean_function = SmallBooleanFunction::from_anf_polynomial_str_inner(anf_str, 3);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::AnfFormNVariableTooBigFactor(3, 3));
+
+        let anf_str = "x0*y1 + x0 + x1 + x2";
+        let boolean_function = SmallBooleanFunction::from_anf_polynomial_str_inner(anf_str, 3);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::ErrorParsingAnfString);
+    }
+
+    #[test]
+    fn test_from_anf_polynomial_inner() {
+        let rule_30_anf = AnfPolynomial::from_str("x0*x1 + x0 + x1 + x2", 3).unwrap();
+        let rule_30_function = SmallBooleanFunction::from_anf_polynomial_inner(&rule_30_anf).unwrap();
+        assert_eq!(rule_30_function.get_truth_table_u64(), 30);
+
+        let rule_30_anf = AnfPolynomial::from_str("x0*x1 + x0 + x1 + x2", 7).unwrap();
+        let boolean_function = SmallBooleanFunction::from_anf_polynomial_inner(&rule_30_anf);
+        assert!(boolean_function.is_err());
+        assert_eq!(boolean_function.unwrap_err(), BooleanFunctionError::TooBigTruthTableForVarCount);
+    }
 }