use existing algexpr->expr conversion, adjust tests

Author: Schaeff

ast/src/parsed/mod.rs

@@ -15,13 +15,13 @@ use std::{
 
 use auto_enums::auto_enum;
 use derive_more::Display;
-use powdr_number::{BigInt, BigUint, DegreeType, FieldElement};
+use powdr_number::{BigInt, BigUint, DegreeType};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use powdr_parser_util::SourceRef;
 
-use crate::analyzed::{AlgebraicExpression, PolynomialReference, Reference};
+use crate::analyzed::Reference;
 
 use self::{
     asm::{Part, SymbolPath},
@@ -739,29 +739,6 @@ impl<Ref> From<u32> for Expression<Ref> {
     }
 }
 
-impl<T: FieldElement> From<AlgebraicExpression<T>> for Expression<Reference> {
-    fn from(e: AlgebraicExpression<T>) -> Self {
-        match e {
-            AlgebraicExpression::Reference(algebraic_reference) => Expression::Reference(
-                SourceRef::unknown(),
-                Reference::Poly(PolynomialReference {
-                    name: algebraic_reference.name,
-                    type_args: None,
-                }),
-            ),
-            AlgebraicExpression::PublicReference(_) => todo!(),
-            AlgebraicExpression::Challenge(_) => todo!(),
-            AlgebraicExpression::Number(n) => Number {
-                value: n.to_arbitrary_integer(),
-                type_: Some(Type::Expr),
-            }
-            .into(),
-            AlgebraicExpression::BinaryOperation(_) => todo!(),
-            AlgebraicExpression::UnaryOperation(_) => todo!(),
-        }
-    }
-}
-
 pub type ExpressionPrecedence = u64;
 
 impl<Ref> Expression<Ref> {

backend/src/plonky3/stark.rs

@@ -474,7 +474,7 @@ mod tests {
             let beta: expr = std::prelude::challenge(0, 42);
             col witness x;
             col witness stage(1) y;
-            x = y + beta * alpha;
+            y = x * x + beta * alpha;
         "#;
         run_test(content);
     }
@@ -498,7 +498,7 @@ mod tests {
 
     #[test]
     fn polynomial_identity() {
-        let content = "namespace Global(8); pol fixed z = [1, 2]*; pol witness a; a = z + 1;";
+        let content = "namespace Global(8); pol fixed z = [1, 2]*; pol witness a; a = z * z + 1;";
         run_test(content);
     }
 

pil-analyzer/src/expressionizer.rs

@@ -58,6 +58,14 @@ pub fn try_value_to_expression<T: FieldElement>(
     Expressionizer { poly_id_to_name }.try_value_to_expression(value)
 }
 
+/// Tries to convert an algebraic expression to an expression.
+pub fn try_algebraic_expression_to_expression<T: FieldElement>(
+    poly_id_to_name: &BTreeMap<(PolynomialType, u64), String>,
+    e: &AlgebraicExpression<T>,
+) -> Result<Expression, EvalError> {
+    Expressionizer { poly_id_to_name }.try_algebraic_expression_to_expression(e)
+}
+
 struct Expressionizer<'a> {
     /// Maps polynomial IDs to their names.
     /// For arrays, this does not include the array elements, just the ID

pil-analyzer/src/lib.rs

@@ -26,6 +26,8 @@ use powdr_ast::{
 
 pub use pil_analyzer::{analyze_ast, analyze_file, analyze_string};
 
+pub use expressionizer::try_algebraic_expression_to_expression;
+
 pub trait AnalysisDriver: Clone + Copy {
     /// Turns a declaration into an absolute name.
     fn resolve_decl(&self, name: &String) -> String {

pilopt/Cargo.toml

@@ -10,14 +10,12 @@ repository = { workspace = true }
 [dependencies]
 powdr-ast.workspace = true
 powdr-number.workspace = true
+powdr-pil-analyzer.workspace = true
 
 log = "0.4.17"
 pretty_assertions = "1.4.0"
 itertools = "0.13.0"
 
-[dev-dependencies]
-powdr-pil-analyzer.workspace = true
-
 [lints]
 workspace = true
 

pilopt/src/lib.rs

@@ -19,6 +19,7 @@ use powdr_number::{BigUint, FieldElement};
 
 pub mod referenced_symbols;
 
+use powdr_pil_analyzer::try_algebraic_expression_to_expression;
 use referenced_symbols::{ReferencedSymbols, SymbolReference};
 
 pub fn optimize<T: FieldElement>(mut pil_file: Analyzed<T>) -> Analyzed<T> {
@@ -30,9 +31,7 @@ pub fn optimize<T: FieldElement>(mut pil_file: Analyzed<T>) -> Analyzed<T> {
         deduplicate_fixed_columns(&mut pil_file);
         simplify_identities(&mut pil_file);
         extract_constant_lookups(&mut pil_file);
-        println!("before {pil_file}");
         replace_linear_witness_columns(&mut pil_file);
-        println!("after {pil_file}");
         remove_constant_witness_columns(&mut pil_file);
         remove_constant_intermediate_columns(&mut pil_file);
         simplify_identities(&mut pil_file);
@@ -545,6 +544,7 @@ fn replace_linear_witness_columns<T: FieldElement>(pil_file: &mut Analyzed<T>) {
                         ..*poly_id
                     };
                     new_symbol.kind = SymbolKind::Poly(PolynomialType::Intermediate);
+                    new_symbol.stage = None;
                     // Add the definition to the intermediate columns
                     pil_file
                         .intermediate_columns
@@ -635,6 +635,10 @@ fn substitute_polynomial_references<T: FieldElement>(
     pil_file: &mut Analyzed<T>,
     substitutions: Vec<((String, PolyID), AlgebraicExpression<T>)>,
 ) {
+    let poly_id_to_name = substitutions
+        .iter()
+        .map(|((name, id), _)| ((id.ptype, id.id), name.clone()))
+        .collect();
     let substitutions_by_id = substitutions
         .iter()
         .map(|((_, id), value)| (*id, value.clone()))
@@ -650,7 +654,7 @@ fn substitute_polynomial_references<T: FieldElement>(
         ) = e
         {
             if let Some(value) = substitutions_by_name.get(name) {
-                *e = value.clone().into();
+                *e = try_algebraic_expression_to_expression(&poly_id_to_name, value).unwrap();
             }
         }
     });