implement field idiv and rem ops

Zokrates · Sep 26, 2023 · afdb931 · afdb931
1 parent c7e4e29
commit afdb931
Show file tree

Hide file tree

Showing 33 changed files with 602 additions and 39 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -25,4 +25,4 @@ members = [
 ]
 
 [profile.dev]
-opt-level = 1
+# opt-level = 1
diff --git a/zokrates_analysis/src/expression_validator.rs b/zokrates_analysis/src/expression_validator.rs
@@ -44,7 +44,7 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for ExpressionValidator {
             | FieldElementExpression::Xor(_)
             | FieldElementExpression::LeftShift(_)
             | FieldElementExpression::RightShift(_) => Err(Error(format!(
-                "Found non-constant bitwise operation in field element expression `{}`",
+                "Field element expression `{}` must be a constant expression",
                 e
             ))),
             FieldElementExpression::Pow(e) => {

diff --git a/zokrates_analysis/src/flatten_complex_types.rs b/zokrates_analysis/src/flatten_complex_types.rs
@@ -1101,6 +1101,12 @@ fn fold_field_expression<'ast, T: Field>(
         typed::FieldElementExpression::Div(e) => {
             zir::FieldElementExpression::Div(f.fold_binary_expression(statements_buffer, e))
         }
+        typed::FieldElementExpression::IDiv(e) => {
+            zir::FieldElementExpression::IDiv(f.fold_binary_expression(statements_buffer, e))
+        }
+        typed::FieldElementExpression::Rem(e) => {
+            zir::FieldElementExpression::Rem(f.fold_binary_expression(statements_buffer, e))
+        }
         typed::FieldElementExpression::Pow(e) => {
             zir::FieldElementExpression::Pow(f.fold_binary_expression(statements_buffer, e))
         }

diff --git a/zokrates_analysis/src/panic_extractor.rs b/zokrates_analysis/src/panic_extractor.rs
@@ -89,6 +89,25 @@ impl<'ast, T: Field> Folder<'ast, T> for PanicExtractor<'ast, T> {
                 );
                 FieldElementExpression::div(n, d)
             }
+            FieldElementExpression::IDiv(e) => {
+                let n = self.fold_field_expression(*e.left);
+                let d = self.fold_field_expression(*e.right);
+                self.panic_buffer.push(
+                    ZirStatement::assertion(
+                        BooleanExpression::not(
+                            BooleanExpression::field_eq(
+                                d.clone().span(span),
+                                FieldElementExpression::value(T::zero()).span(span),
+                            )
+                            .span(span),
+                        )
+                        .span(span),
+                        RuntimeError::DivisionByZero,
+                    )
+                    .span(span),
+                );
+                FieldElementExpression::idiv(n, d)
+            }
             e => fold_field_expression_cases(self, e),
         }
     }

diff --git a/zokrates_analysis/src/propagation.rs b/zokrates_analysis/src/propagation.rs
@@ -42,14 +42,12 @@ impl fmt::Display for Error {
             Error::Type(s) => write!(f, "{}", s),
             Error::AssertionFailed(err) => write!(f, "Assertion failed ({})", err),
             Error::InvalidValue(s) => write!(f, "{}", s),
-            Error::OutOfBounds(index, size) => write!(
-                f,
-                "Out of bounds index ({} >= {}) found during static analysis",
-                index, size
-            ),
+            Error::OutOfBounds(index, size) => {
+                write!(f, "Out of bounds index ({} >= {})", index, size)
+            }
             Error::VariableLength(message) => write!(f, "{}", message),
             Error::DivisionByZero => {
-                write!(f, "Division by zero detected during static analysis",)
+                write!(f, "Division by zero detected",)
             }
         }
     }
@@ -856,6 +854,22 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
                     Ok(UExpression::and(e1.annotate(bitwidth), e2.annotate(bitwidth)).into_inner())
                 }
             },
+            UExpressionInner::Or(e) => match (
+                self.fold_uint_expression(*e.left)?.into_inner(),
+                self.fold_uint_expression(*e.right)?.into_inner(),
+            ) {
+                (UExpressionInner::Value(v1), UExpressionInner::Value(v2)) => {
+                    Ok(UExpression::value(v1.value | v2.value))
+                }
+                (UExpressionInner::Value(v), e) | (e, UExpressionInner::Value(v))
+                    if v.value == 0 =>
+                {
+                    Ok(e)
+                }
+                (e1, e2) => {
+                    Ok(UExpression::or(e1.annotate(bitwidth), e2.annotate(bitwidth)).into_inner())
+                }
+            },
             UExpressionInner::Not(e) => {
                 let e = self.fold_uint_expression(*e.inner)?.into_inner();
                 match e {
@@ -939,6 +953,35 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
                     (e1, e2) => Ok(e1 / e2),
                 }
             }
+            FieldElementExpression::IDiv(e) => {
+                let left = self.fold_field_expression(*e.left)?;
+                let right = self.fold_field_expression(*e.right)?;
+
+                Ok(match (left, right) {
+                    (FieldElementExpression::Value(n1), FieldElementExpression::Value(n2)) => {
+                        FieldElementExpression::value(
+                            T::try_from(n1.value.to_biguint().div(n2.value.to_biguint())).unwrap(),
+                        )
+                    }
+                    (e1, e2) => FieldElementExpression::idiv(e1, e2),
+                })
+            }
+            FieldElementExpression::Rem(e) => {
+                let left = self.fold_field_expression(*e.left)?;
+                let right = self.fold_field_expression(*e.right)?;
+
+                Ok(match (left, right) {
+                    (_, FieldElementExpression::Value(n)) if n.value == T::from(1) => {
+                        FieldElementExpression::value(T::zero())
+                    }
+                    (FieldElementExpression::Value(n1), FieldElementExpression::Value(n2)) => {
+                        FieldElementExpression::value(
+                            T::try_from(n1.value.to_biguint().rem(n2.value.to_biguint())).unwrap(),
+                        )
+                    }
+                    (e1, e2) => e1 % e2,
+                })
+            }
             FieldElementExpression::Neg(e) => match self.fold_field_expression(*e.inner)? {
                 FieldElementExpression::Value(n) => {
                     Ok(FieldElementExpression::value(T::zero() - n.value))
@@ -1606,6 +1649,48 @@ mod tests {
                 );
             }
 
+            #[test]
+            fn idiv() {
+                let e = FieldElementExpression::idiv(
+                    FieldElementExpression::value(Bn128Field::from(7)),
+                    FieldElementExpression::value(Bn128Field::from(2)),
+                );
+
+                assert_eq!(
+                    Propagator::default().fold_field_expression(e),
+                    Ok(FieldElementExpression::value(Bn128Field::from(3)))
+                );
+            }
+
+            #[test]
+            fn rem() {
+                let mut propagator = Propagator::default();
+
+                assert_eq!(
+                    propagator.fold_field_expression(FieldElementExpression::rem(
+                        FieldElementExpression::value(Bn128Field::from(5)),
+                        FieldElementExpression::value(Bn128Field::from(2)),
+                    )),
+                    Ok(FieldElementExpression::value(Bn128Field::from(1)))
+                );
+
+                assert_eq!(
+                    propagator.fold_field_expression(FieldElementExpression::rem(
+                        FieldElementExpression::value(Bn128Field::from(2)),
+                        FieldElementExpression::value(Bn128Field::from(5)),
+                    )),
+                    Ok(FieldElementExpression::value(Bn128Field::from(2)))
+                );
+
+                assert_eq!(
+                    propagator.fold_field_expression(FieldElementExpression::rem(
+                        FieldElementExpression::identifier("a".into()),
+                        FieldElementExpression::value(Bn128Field::from(1)),
+                    )),
+                    Ok(FieldElementExpression::value(Bn128Field::from(0)))
+                );
+            }
+
             #[test]
             fn pow() {
                 let e = FieldElementExpression::pow(

diff --git a/zokrates_analysis/src/zir_propagation.rs b/zokrates_analysis/src/zir_propagation.rs
@@ -30,13 +30,11 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Error::OutOfBounds(index, size) => write!(
-                f,
-                "Out of bounds index ({} >= {}) found in zir during static analysis",
-                index, size
-            ),
+            Error::OutOfBounds(index, size) => {
+                write!(f, "Out of bounds index ({} >= {})", index, size)
+            }
             Error::DivisionByZero => {
-                write!(f, "Division by zero detected in zir during static analysis",)
+                write!(f, "Division by zero detected",)
             }
             Error::AssertionFailed(err) => write!(f, "Assertion failed ({})", err),
         }
@@ -343,6 +341,42 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for ZirPropagator<'ast, T> {
                     (e1, e2) => Ok(FieldElementExpression::div(e1, e2).span(e.span)),
                 }
             }
+            FieldElementExpression::IDiv(e) => {
+                let left = self.fold_field_expression(*e.left)?;
+                let right = self.fold_field_expression(*e.right)?;
+
+                match (left, right) {
+                    (_, FieldElementExpression::Value(n)) if n.value == T::from(0) => {
+                        Err(Error::DivisionByZero)
+                    }
+                    (e, FieldElementExpression::Value(n)) if n.value == T::from(1) => Ok(e),
+                    (FieldElementExpression::Value(n1), FieldElementExpression::Value(n2)) => {
+                        Ok(FieldElementExpression::value(
+                            T::try_from(n1.value.to_biguint().div(n2.value.to_biguint())).unwrap(),
+                        ))
+                    }
+                    (e1, e2) => Ok(FieldElementExpression::idiv(e1, e2).span(e.span)),
+                }
+            }
+            FieldElementExpression::Rem(e) => {
+                let left = self.fold_field_expression(*e.left)?;
+                let right = self.fold_field_expression(*e.right)?;
+
+                match (left, right) {
+                    (_, FieldElementExpression::Value(n)) if n.value == T::from(0) => {
+                        Err(Error::DivisionByZero)
+                    }
+                    (_, FieldElementExpression::Value(n)) if n.value == T::from(1) => {
+                        Ok(FieldElementExpression::value(T::zero()))
+                    }
+                    (FieldElementExpression::Value(n1), FieldElementExpression::Value(n2)) => {
+                        Ok(FieldElementExpression::value(
+                            T::try_from(n1.value.to_biguint().rem(n2.value.to_biguint())).unwrap(),
+                        ))
+                    }
+                    (e1, e2) => Ok(FieldElementExpression::rem(e1, e2).span(e.span)),
+                }
+            }
             FieldElementExpression::Pow(e) => {
                 let exponent = self.fold_uint_expression(*e.right)?;
                 match (self.fold_field_expression(*e.left)?, exponent.into_inner()) {
@@ -1099,6 +1133,72 @@ mod tests {
             );
         }
 
+        #[test]
+        fn idiv() {
+            let mut propagator = ZirPropagator::default();
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::idiv(
+                    FieldElementExpression::value(Bn128Field::from(7)),
+                    FieldElementExpression::value(Bn128Field::from(2)),
+                )),
+                Ok(FieldElementExpression::value(Bn128Field::from(3)))
+            );
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::idiv(
+                    FieldElementExpression::identifier("a".into()),
+                    FieldElementExpression::value(Bn128Field::from(1)),
+                )),
+                Ok(FieldElementExpression::identifier("a".into()))
+            );
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::idiv(
+                    FieldElementExpression::identifier("a".into()),
+                    FieldElementExpression::value(Bn128Field::from(0)),
+                )),
+                Err(Error::DivisionByZero)
+            );
+        }
+
+        #[test]
+        fn rem() {
+            let mut propagator = ZirPropagator::default();
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::rem(
+                    FieldElementExpression::value(Bn128Field::from(5)),
+                    FieldElementExpression::value(Bn128Field::from(2)),
+                )),
+                Ok(FieldElementExpression::value(Bn128Field::from(1)))
+            );
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::rem(
+                    FieldElementExpression::value(Bn128Field::from(2)),
+                    FieldElementExpression::value(Bn128Field::from(5)),
+                )),
+                Ok(FieldElementExpression::value(Bn128Field::from(2)))
+            );
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::rem(
+                    FieldElementExpression::identifier("a".into()),
+                    FieldElementExpression::value(Bn128Field::from(1)),
+                )),
+                Ok(FieldElementExpression::value(Bn128Field::from(0)))
+            );
+
+            assert_eq!(
+                propagator.fold_field_expression(FieldElementExpression::div(
+                    FieldElementExpression::identifier("a".into()),
+                    FieldElementExpression::value(Bn128Field::from(0)),
+                )),
+                Err(Error::DivisionByZero)
+            );
+        }
+
         #[test]
         fn pow() {
             let mut propagator = ZirPropagator::<Bn128Field>::default();

diff --git a/zokrates_ast/src/common/operators.rs b/zokrates_ast/src/common/operators.rs
@@ -37,6 +37,13 @@ impl OperatorStr for OpDiv {
     const STR: &'static str = "/";
 }
 
+#[derive(Clone, PartialEq, Debug, Hash, Eq, PartialOrd, Ord)]
+pub struct OpIDiv;
+
+impl OperatorStr for OpIDiv {
+    const STR: &'static str = "\\";
+}
+
 #[derive(Clone, PartialEq, Debug, Hash, Eq, PartialOrd, Ord)]
 pub struct OpRem;
 

diff --git a/zokrates_ast/src/ir/check.rs b/zokrates_ast/src/ir/check.rs
@@ -4,6 +4,7 @@ use crate::ir::Parameter;
 use crate::ir::ProgIterator;
 use crate::ir::Statement;
 use crate::ir::Variable;
+use crate::Solver;
 use std::collections::HashSet;
 use zokrates_field::Field;
 
@@ -46,7 +47,10 @@ impl<'ast, T: Field> Folder<'ast, T> for UnconstrainedVariableDetector {
         &mut self,
         d: DirectiveStatement<'ast, T>,
     ) -> Vec<Statement<'ast, T>> {
-        self.variables.extend(d.outputs.iter());
+        match d.solver {
+            Solver::Zir(_) => {} // we do not check variables introduced by assembly
+            _ => self.variables.extend(d.outputs.iter()), // this is not necessary, but we keep it as a sanity check
+        };
         vec![Statement::Directive(d)]
     }
 }
diff --git a/zokrates_ast/src/ir/serialize.rs b/zokrates_ast/src/ir/serialize.rs
@@ -222,10 +222,10 @@ impl<'ast, T: Field, I: IntoIterator<Item = Statement<'ast, T>>> ProgIterator<'a
                 if matches!(s, Statement::Constraint(..)) {
                     count += 1;
                 }
-                let s: Vec<Statement<T>> = solver_indexer
+                let s: Vec<Statement<T>> = unconstrained_variable_detector
                     .fold_statement(s)
                     .into_iter()
-                    .flat_map(|s| unconstrained_variable_detector.fold_statement(s))
+                    .flat_map(|s| solver_indexer.fold_statement(s))
                     .collect();
                 for s in s {
                     serde_cbor::to_writer(&mut w, &s)?;

diff --git a/zokrates_ast/src/typed/folder.rs b/zokrates_ast/src/typed/folder.rs
@@ -1073,6 +1073,14 @@ pub fn fold_field_expression_cases<'ast, T: Field, F: Folder<'ast, T>>(
             BinaryOrExpression::Binary(e) => Div(e),
             BinaryOrExpression::Expression(u) => u,
         },
+        IDiv(e) => match f.fold_binary_expression(&Type::FieldElement, e) {
+            BinaryOrExpression::Binary(e) => IDiv(e),
+            BinaryOrExpression::Expression(u) => u,
+        },
+        Rem(e) => match f.fold_binary_expression(&Type::FieldElement, e) {
+            BinaryOrExpression::Binary(e) => Rem(e),
+            BinaryOrExpression::Expression(u) => u,
+        },
         Pow(e) => match f.fold_binary_expression(&Type::FieldElement, e) {
             BinaryOrExpression::Binary(e) => Pow(e),
             BinaryOrExpression::Expression(u) => u,