Condenser support on complex algebraic expressions to expressions (#1842)

Add support for Binary & Unary operations on AlgebraicExpressions ->
Expressions

Author: onurinanc

pil-analyzer/src/condenser.rs

@@ -13,8 +13,9 @@ use num_traits::sign::Signed;
 
 use powdr_ast::{
     analyzed::{
-        self, AlgebraicExpression, AlgebraicReference, Analyzed, Challenge, DegreeRange,
-        Expression, FunctionValueDefinition, Identity, IdentityKind, PolyID, PolynomialReference,
+        self, AlgebraicBinaryOperation, AlgebraicExpression, AlgebraicReference,
+        AlgebraicUnaryOperation, Analyzed, Challenge, DegreeRange, Expression,
+        FunctionValueDefinition, Identity, IdentityKind, PolyID, PolynomialReference,
         PolynomialType, PublicDeclaration, Reference, SelectedExpressions, StatementIdentifier,
         Symbol, SymbolKind,
     },
@@ -24,8 +25,9 @@ use powdr_ast::{
         display::format_type_scheme_around_name,
         types::{ArrayType, Type},
         visitor::{AllChildren, ExpressionVisitable},
-        ArrayLiteral, BlockExpression, FunctionCall, FunctionKind, LambdaExpression,
-        LetStatementInsideBlock, Number, Pattern, SourceReference, TypedExpression, UnaryOperation,
+        ArrayLiteral, BinaryOperation, BlockExpression, FunctionCall, FunctionKind,
+        LambdaExpression, LetStatementInsideBlock, Number, Pattern, SourceReference,
+        TypedExpression, UnaryOperation,
     },
 };
 use powdr_number::{BigUint, FieldElement};
@@ -939,6 +941,84 @@ fn shift_local_var_refs(e: &mut Expression, shift: u64) {
         .for_each(|e| shift_local_var_refs(e, shift));
 }
 
+fn try_algebraic_expression_to_expression<T: FieldElement>(
+    e: &AlgebraicExpression<T>,
+) -> Result<Expression, EvalError> {
+    Ok(match e {
+        AlgebraicExpression::Reference(AlgebraicReference {
+            name,
+            poly_id: _,
+            next,
+        }) => {
+            let e = Expression::Reference(
+                SourceRef::unknown(),
+                Reference::Poly(PolynomialReference {
+                    name: name.clone(),
+                    type_args: None,
+                }),
+            );
+            if *next {
+                UnaryOperation {
+                    op: parsed::UnaryOperator::Next,
+                    expr: Box::new(e),
+                }
+                .into()
+            } else {
+                e
+            }
+        }
+
+        AlgebraicExpression::BinaryOperation(AlgebraicBinaryOperation { left, op, right }) => {
+            BinaryOperation {
+                left: Box::new(try_algebraic_expression_to_expression(left)?),
+                op: (*op).into(),
+                right: Box::new(try_algebraic_expression_to_expression(right)?),
+            }
+            .into()
+        }
+
+        AlgebraicExpression::UnaryOperation(AlgebraicUnaryOperation { op, expr }) => {
+            UnaryOperation {
+                op: (*op).into(),
+                expr: Box::new(try_algebraic_expression_to_expression(expr)?),
+            }
+            .into()
+        }
+
+        AlgebraicExpression::Challenge(Challenge { id, stage }) => {
+            let function = Expression::Reference(
+                SourceRef::unknown(),
+                Reference::Poly(PolynomialReference {
+                    name: "std::prelude::challenge".to_string(),
+                    type_args: None,
+                }),
+            )
+            .into();
+            let arguments = [*stage as u64, *id]
+                .into_iter()
+                .map(|x| BigUint::from(x).into())
+                .collect();
+            Expression::FunctionCall(
+                SourceRef::unknown(),
+                FunctionCall {
+                    function,
+                    arguments,
+                },
+            )
+        }
+
+        AlgebraicExpression::Number(n) => Number {
+            value: n.to_arbitrary_integer(),
+            type_: Some(Type::Expr),
+        }
+        .into(),
+
+        AlgebraicExpression::PublicReference(s) => {
+            Expression::PublicReference(SourceRef::unknown(), s.clone())
+        }
+    })
+}
+
 /// Tries to convert an evaluator value to an expression with the same value.
 fn try_value_to_expression<T: FieldElement>(value: &Value<'_, T>) -> Result<Expression, EvalError> {
     Ok(match value {
@@ -1021,49 +1101,6 @@ fn try_value_to_expression<T: FieldElement>(value: &Value<'_, T>) -> Result<Expr
                 "Converting builtin functions to expressions not supported.".to_string(),
             ))
         }
-        Value::Expression(e) => match e {
-            AlgebraicExpression::Reference(AlgebraicReference {
-                name,
-                poly_id: _,
-                next: false,
-            }) => Expression::Reference(
-                SourceRef::unknown(),
-                Reference::Poly(PolynomialReference {
-                    name: name.clone(),
-                    type_args: None,
-                }),
-            ),
-            AlgebraicExpression::Challenge(Challenge { id, stage }) => {
-                let function = Expression::Reference(
-                    SourceRef::unknown(),
-                    Reference::Poly(PolynomialReference {
-                        name: "std::prelude::challenge".to_string(),
-                        type_args: None,
-                    }),
-                )
-                .into();
-                let arguments = [*stage as u64, *id]
-                    .into_iter()
-                    .map(|x| BigUint::from(x).into())
-                    .collect();
-                Expression::FunctionCall(
-                    SourceRef::unknown(),
-                    FunctionCall {
-                        function,
-                        arguments,
-                    },
-                )
-            }
-            AlgebraicExpression::Number(n) => Number {
-                value: n.to_arbitrary_integer(),
-                type_: Some(Type::Expr),
-            }
-            .into(),
-            _ => {
-                return Err(EvalError::TypeError(format!(
-                    "Converting complex algebraic expressions to expressions not supported: {e}."
-                )))
-            }
-        },
+        Value::Expression(e) => try_algebraic_expression_to_expression(e)?,
     })
 }

pil-analyzer/tests/condenser.rs

@@ -855,12 +855,11 @@ namespace std::prover;
 }
 
 #[test]
-#[should_panic = "Converting complex algebraic expressions to expressions not supported: std::prover::x + std::prover::y"]
-fn capture_not_supported() {
-    let input = r#"
+fn capture_binary_operations() {
+    let input = r#"namespace std::prelude;
     namespace std::prover;
-        let provide_value = 9;
-        let eval = -1;
+    let provide_value = 9;
+    let eval = -1;
     namespace N(16);
         (constr || {
             let x;
@@ -872,18 +871,15 @@ fn capture_not_supported() {
         })();
 
     "#;
-    let expected = r#"namespace std::prelude;
-    let challenge = 8;
-namespace std::prover;
+    let expected = r#"namespace std::prover;
     let provide_value = 9;
     let eval = -1;
+    col witness x;
     col witness y;
     {
-        let x = std::prelude::challenge(0, 4);
-        let y = std::prover::y;
-        let t = 2;
+        let t = std::prover::x + std::prover::y;
         query |i| {
-            std::prover::provide_value(y, i, std::prover::eval(x) + t);
+            let _: fe = std::prover::eval(t);
         }
     };
 "#;