make tests pass

ast/src/analyzed/display.rs

@@ -21,18 +21,18 @@ use super::*;
 
 impl<T: Display> Display for Analyzed<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let degree = self.degree.unwrap_or_default();
         let mut current_namespace = AbsoluteSymbolPath::default();
-        let mut update_namespace = |name: &str, f: &mut Formatter<'_>| {
+        let mut update_namespace = |name: &str, degree: Option<DegreeType>, f: &mut Formatter<'_>| {
             let mut namespace =
                 AbsoluteSymbolPath::default().join(SymbolPath::from_str(name).unwrap());
             let name = namespace.pop().unwrap();
             if namespace != current_namespace {
                 current_namespace = namespace;
                 writeln!(
                     f,
-                    "namespace {}({degree});",
-                    current_namespace.relative_to(&Default::default())
+                    "namespace {}({});",
+                    current_namespace.relative_to(&Default::default()),
+                    degree.map(|d| d.to_string()).unwrap_or_default()
                 )?;
             };
             Ok((name, !current_namespace.is_empty()))
@@ -53,7 +53,7 @@ impl<T: Display> Display for Analyzed<T> {
                             // These are printed as part of the enum.
                             continue;
                         }
-                        let (name, is_local) = update_namespace(name, f)?;
+                        let (name, is_local) = update_namespace(name, symbol.degree, f)?;
                         match symbol.kind {
                             SymbolKind::Poly(_) => {
                                 writeln_indented(f, format_poly(&name, symbol, definition))?;
@@ -110,7 +110,7 @@ impl<T: Display> Display for Analyzed<T> {
                         }
                     } else if let Some((symbol, definition)) = self.intermediate_columns.get(name) {
                         assert!(symbol.stage.is_none());
-                        let (name, _) = update_namespace(name, f)?;
+                        let (name, _) = update_namespace(name, symbol.degree, f)?;
                         assert_eq!(symbol.kind, SymbolKind::Poly(PolynomialType::Intermediate));
                         if let Some(length) = symbol.length {
                             writeln_indented(
@@ -130,7 +130,7 @@ impl<T: Display> Display for Analyzed<T> {
                 }
                 StatementIdentifier::PublicDeclaration(name) => {
                     let decl = &self.public_declarations[name];
-                    let (name, is_local) = update_namespace(&decl.name, f)?;
+                    let (name, is_local) = update_namespace(&decl.name, None, f)?;
                     writeln_indented_by(
                         f,
                         format_public_declaration(&name, decl),
@@ -485,6 +485,7 @@ mod test {
             poly_id: super::PolyID {
                 id: 0,
                 ptype: super::PolynomialType::Committed,
+                degree: None,
             },
             next: false,
         });
@@ -493,6 +494,7 @@ mod test {
             poly_id: super::PolyID {
                 id: 1,
                 ptype: super::PolynomialType::Committed,
+                degree: None,
             },
             next: false,
         });
@@ -501,6 +503,7 @@ mod test {
             poly_id: super::PolyID {
                 id: 2,
                 ptype: super::PolynomialType::Committed,
+                degree: None,
             },
             next: false,
         });

ast/src/analyzed/mod.rs

@@ -31,8 +31,6 @@ pub enum StatementIdentifier {
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct Analyzed<T> {
-    /// The degree of all namespaces, which must match if provided. If no degrees are given, then `None`.
-    pub degree: Option<DegreeType>,
     pub definitions: HashMap<String, (Symbol, Option<FunctionValueDefinition>)>,
     pub public_declarations: HashMap<String, PublicDeclaration>,
     pub intermediate_columns: HashMap<String, (Symbol, Vec<AlgebraicExpression<T>>)>,
@@ -45,10 +43,14 @@ pub struct Analyzed<T> {
 }
 
 impl<T> Analyzed<T> {
-    /// @returns the degree if any. Panics if there is none.
-    pub fn degree(&self) -> DegreeType {
-        self.degree.unwrap()
+    pub fn max_degree(&self) -> DegreeType {
+        self.definitions
+            .values()
+            .filter_map(|(symbol, _)| symbol.degree)
+            .max()
+            .unwrap()
     }
+
     /// @returns the number of committed polynomials (with multiplicities for arrays)
     pub fn commitment_count(&self) -> usize {
         self.declaration_type_count(PolynomialType::Committed)
@@ -466,6 +468,7 @@ impl Symbol {
                 PolyID {
                     id: self.id + i,
                     ptype,
+                    degree: self.degree,
                 },
             )
         })
@@ -1152,6 +1155,7 @@ pub struct PolynomialReference {
 pub struct PolyID {
     pub id: u64,
     pub ptype: PolynomialType,
+    pub degree: Option<DegreeType>,
 }
 
 impl From<&Symbol> for PolyID {
@@ -1162,6 +1166,7 @@ impl From<&Symbol> for PolyID {
         PolyID {
             id: symbol.id,
             ptype,
+            degree: symbol.degree,
         }
     }
 }

backend/src/estark/json_exporter/mod.rs

@@ -232,7 +232,7 @@ impl<'a, T: FieldElement> Exporter<'a, T> {
                     polType: None,
                     type_: symbol_kind_to_json_string(symbol.kind).to_string(),
                     id: id as usize,
-                    polDeg: self.analyzed.degree() as usize,
+                    polDeg: self.analyzed.max_degree() as usize,
                     isArray: symbol.is_array(),
                     elementType: None,
                     len: symbol.length.map(|l| l as usize),
@@ -251,7 +251,7 @@ impl<'a, T: FieldElement> Exporter<'a, T> {
                             polType: None,
                             type_: symbol_kind_to_json_string(symbol.kind).to_string(),
                             id: id as usize,
-                            polDeg: self.analyzed.degree() as usize,
+                            polDeg: self.analyzed.max_degree() as usize,
                             isArray: symbol.is_array(),
                             elementType: None,
                             len: symbol.length.map(|l| l as usize),
@@ -369,7 +369,7 @@ impl<'a, T: FieldElement> Exporter<'a, T> {
 
     fn polynomial_reference_to_json(
         &self,
-        PolyID { id, ptype }: PolyID,
+        PolyID { id, ptype, .. }: PolyID,
         next: bool,
     ) -> (u32, StarkyExpr) {
         let id = if ptype == PolynomialType::Intermediate {

backend/src/estark/mod.rs

@@ -76,7 +76,7 @@ fn first_step_fixup<'a, F: FieldElement>(
     pil: &'a Analyzed<F>,
     fixed: &'a [(String, Vec<F>)],
 ) -> (PIL, Option<PatchedConstants<F>>) {
-    let degree = pil.degree();
+    let degree = pil.max_degree();
 
     let mut pil: PIL = json_exporter::export(pil);
 
@@ -161,7 +161,7 @@ impl<'a, F: FieldElement> EStarkFilesCommon<'a, F> {
         let proof_type: ProofType = ProofType::from(options);
 
         Ok(EStarkFilesCommon {
-            degree: analyzed.degree(),
+            degree: analyzed.max_degree(),
             pil,
             patched_constants,
             output_dir,

backend/src/estark/starky_wrapper.rs

@@ -47,7 +47,7 @@ impl<F: FieldElement> BackendFactory<F> for Factory {
 
         let proof_type: ProofType = ProofType::from(options);
 
-        let params = create_stark_struct(pil.degree(), proof_type.hash_type());
+        let params = create_stark_struct(pil.max_degree(), proof_type.hash_type());
 
         let (pil_json, patched_fixed) = first_step_fixup(pil, fixed);
 

backend/src/halo2/circuit_builder.rs

@@ -272,7 +272,7 @@ impl<'a, T: FieldElement, F: PrimeField<Repr = [u8; 32]>> Circuit<F> for PowdrCi
                     let first_row = meta.query_advice(config.advice[name], Rotation::cur());
                     let last_row = meta.query_advice(
                         config.advice[name],
-                        Rotation(analyzed.degree().try_into().unwrap()),
+                        Rotation(analyzed.max_degree().try_into().unwrap()),
                     );
                     let expr = first_step.clone() * (first_row - last_row);
                     (format!("enforce wrapping ({name})"), expr)
@@ -411,7 +411,7 @@ impl<'a, T: FieldElement, F: PrimeField<Repr = [u8; 32]>> Circuit<F> for PowdrCi
                         )?;
                     }
                 }
-                let degree = self.analyzed.degree() as usize;
+                let degree = self.analyzed.max_degree() as usize;
                 for i in 0..(2 * degree) {
                     let value = F::from((i < degree) as u64);
                     region.assign_fixed(

backend/src/halo2/mock_prover.rs

@@ -20,7 +20,7 @@ pub fn mock_prove<T: FieldElement>(
     // double the row count in order to make space for the cells introduced by the backend
     // TODO: use a precise count of the extra rows needed to avoid using so many rows
 
-    let circuit_row_count_log = usize::BITS - pil.degree().leading_zeros();
+    let circuit_row_count_log = usize::BITS - pil.max_degree().leading_zeros();
     let expanded_row_count_log = circuit_row_count_log + 1;
 
     let circuit = PowdrCircuit::new(pil, constants)

backend/src/halo2/prover.rs

@@ -94,10 +94,10 @@ impl<'a, F: FieldElement> Halo2Prover<'a, F> {
         let mut params = setup
             .map(|mut setup| ParamsKZG::<Bn256>::read(&mut setup))
             .transpose()?
-            .unwrap_or_else(|| generate_setup(analyzed.degree()));
+            .unwrap_or_else(|| generate_setup(analyzed.max_degree()));
 
         if matches!(proof_type, ProofType::Poseidon | ProofType::SnarkSingle) {
-            params.downsize(degree_bits(analyzed.degree()));
+            params.downsize(degree_bits(analyzed.max_degree()));
         }
 
         Ok(Self {
@@ -250,7 +250,7 @@ impl<'a, F: FieldElement> Halo2Prover<'a, F> {
         log::info!("Generating VK for app snark...");
 
         let mut params_app = self.params.clone();
-        params_app.downsize(degree_bits(self.analyzed.degree()));
+        params_app.downsize(degree_bits(self.analyzed.max_degree()));
 
         log::info!("Generating circuit for compression snark...");
         let protocol_app = compile(
@@ -375,7 +375,7 @@ impl<'a, F: FieldElement> Halo2Prover<'a, F> {
         };
 
         let mut params_app = self.params.clone();
-        params_app.downsize(degree_bits(self.analyzed.degree()));
+        params_app.downsize(degree_bits(self.analyzed.max_degree()));
 
         let protocol_app = compile(
             &params_app,

executor/src/constant_evaluator/mod.rs

@@ -186,7 +186,7 @@ mod test {
             col fixed LAST(i) { if i == N - 1 { 1 } else { 0 } };
             "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -202,7 +202,7 @@ mod test {
             pol constant EVEN(i) { 2 * (i - 1) + 4 };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -221,7 +221,7 @@ mod test {
             pol constant X(i) { i ^ (i + 17) | 3 };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -245,7 +245,7 @@ mod test {
             } + 1 };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -261,7 +261,7 @@ mod test {
             let X: col = |i| if i < 3 { 7 } else { 9 };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -278,7 +278,7 @@ mod test {
             pol constant EVEN(i) { 2 * minus_one(i) + 2 };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 8);
+        assert_eq!(analyzed.max_degree(), 8);
         let constants = generate(&analyzed);
         assert_eq!(
             constants,
@@ -304,7 +304,7 @@ mod test {
             col fixed doubled_half_nibble(i) { half_nibble_f(i / 2) };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         let constants = generate(&analyzed);
         assert_eq!(constants.len(), 4);
         assert_eq!(
@@ -346,7 +346,7 @@ mod test {
             col fixed ref_other = [n-1, f(1), 8] + [0]*;
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         let constants = generate(&analyzed);
         assert_eq!(constants.len(), 3);
         assert_eq!(
@@ -377,7 +377,7 @@ mod test {
             col fixed arr = [0, 1, 2]* + [7];
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         let constants = generate(&analyzed);
         assert_eq!(constants.len(), 1);
         assert_eq!(
@@ -412,7 +412,7 @@ mod test {
             col fixed greater_eq(i) { if id(i) >= inv(i) { 1 } else { 0 } };
         "#;
         let analyzed = analyze_string(src);
-        assert_eq!(analyzed.degree(), 6);
+        assert_eq!(analyzed.max_degree(), 6);
         let constants = generate(&analyzed);
         assert_eq!(
             constants[0],
@@ -471,7 +471,7 @@ mod test {
             let x: col = |i| w(i) + 1;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         generate(&analyzed);
     }
 
@@ -484,7 +484,7 @@ mod test {
             let x = |i| w(i) + 1;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         generate(&analyzed);
     }
 
@@ -498,7 +498,7 @@ mod test {
             col fixed y = [1, 2, 3]*;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 10);
+        assert_eq!(analyzed.max_degree(), 10);
         generate(&analyzed);
     }
 
@@ -513,7 +513,7 @@ mod test {
             let Y: col = y;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 4);
+        assert_eq!(analyzed.max_degree(), 4);
         let constants = generate(&analyzed);
         assert_eq!(
             constants[0],
@@ -536,7 +536,7 @@ mod test {
             let x: col = |i| (1 << (2000 + i)) >> 2000;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 4);
+        assert_eq!(analyzed.max_degree(), 4);
         let constants = generate(&analyzed);
         assert_eq!(
             constants[0],
@@ -556,7 +556,7 @@ mod test {
             let x: col = |i| 100 + x_arr[i];
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 4);
+        assert_eq!(analyzed.max_degree(), 4);
         let constants = generate(&analyzed);
         // Semantics of p % q involving negative numbers:
         // sgn(p) * |p| % |q|
@@ -576,7 +576,7 @@ mod test {
                 let fe = || fe();
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 4);
+        assert_eq!(analyzed.max_degree(), 4);
         let constants = generate(&analyzed);
         assert_eq!(
             constants[0],
@@ -600,7 +600,7 @@ mod test {
                 let a: col = |i| std::convert::fe(i + seven) + seven;
         "#;
         let analyzed = analyze_string::<GoldilocksField>(src);
-        assert_eq!(analyzed.degree(), 4);
+        assert_eq!(analyzed.max_degree(), 4);
         let constants = generate(&analyzed);
         assert_eq!(
             constants[0],