Integrate finalize_constants in the main flow.

Author: leo-starkware

crates/cairo_verifier/src/statement_test.rs

@@ -261,6 +261,7 @@ fn test_public_logup_sum() {
     assert_eq!(result_value, expected);
 
     // Validate the circuit
+    circuits::finalize_constants::finalize_constants(&mut context);
     context.check_vars_used();
     context.finalize_guessed_vars();
     context.circuit.check_yields();

crates/cairo_verifier/src/test.rs

@@ -140,6 +140,7 @@ fn test_verify() {
 
     let proof_vars = empty_proof.guess(&mut novalue_context);
     verify(&mut novalue_context, &proof_vars, &config, &statement);
+    circuits::finalize_constants::finalize_constants(&mut novalue_context);
     novalue_context.finalize_guessed_vars();
     novalue_context.check_vars_used();
     novalue_context.circuit.check_yields();

crates/cairo_verifier/src/verify.rs

@@ -7,6 +7,7 @@ use cairo_air::air::PublicData;
 use cairo_air::flat_claims::FlatClaim;
 use circuits::blake::HashValue;
 use circuits::context::{Context, TraceContext};
+use circuits::finalize_constants::finalize_constants;
 use circuits::ivalue::{IValue, NoValue};
 use circuits::ops::Guess;
 use circuits_stark_verifier::constraint_eval::CircuitEval;
@@ -124,6 +125,7 @@ pub fn build_fixed_cairo_circuit(
 
     let proof_vars = proof.guess(&mut context);
     verify(&mut context, &proof_vars, config, &statement);
+    finalize_constants(&mut context);
     context.finalize_guessed_vars();
 
     context
@@ -155,6 +157,7 @@ pub fn build_cairo_verifier_circuit(verifier_config: &CairoVerifierConfig) -> Co
 
     let proof_vars = empty_proof(config).guess(&mut context);
     verify(&mut context, &proof_vars, config, &statement);
+    finalize_constants(&mut context);
     context.finalize_guessed_vars();
     context
 }

crates/circuit_common/src/lib.rs

@@ -1,6 +1,9 @@
 pub mod finalize;
 pub mod preprocessed;
 
+// Re-export finalize_constants from circuits crate.
+pub use circuits::finalize_constants;
+
 // TODO(Anat): Take from somewhere stable.
 pub const N_LANES: usize = 16;
 

crates/circuit_prover/src/prover_test.rs

@@ -170,6 +170,7 @@ fn stwo_verify(
 #[test]
 fn test_prove_and_stark_verify_blake_gate_context() {
     let mut blake_gate_context = build_blake_gate_context();
+    circuits::finalize_constants::finalize_constants(&mut blake_gate_context);
     blake_gate_context.finalize_guessed_vars();
     blake_gate_context.validate_circuit();
 
@@ -186,6 +187,7 @@ fn test_prove_and_stark_verify_blake_gate_context() {
 #[test]
 fn test_prove_and_stark_verify_permutation_context() {
     let mut permutation_context = build_permutation_context();
+    circuits::finalize_constants::finalize_constants(&mut permutation_context);
     permutation_context.finalize_guessed_vars();
     permutation_context.validate_circuit();
 
@@ -202,6 +204,7 @@ fn test_prove_and_stark_verify_permutation_context() {
 #[test]
 fn test_prove_and_stark_verify_fibonacci_context() {
     let mut fibonacci_context = build_fibonacci_context();
+    circuits::finalize_constants::finalize_constants(&mut fibonacci_context);
     fibonacci_context.finalize_guessed_vars();
     fibonacci_context.validate_circuit();
 
@@ -218,6 +221,7 @@ fn test_prove_and_stark_verify_fibonacci_context() {
 #[test]
 fn test_prove_and_stark_verify_m31_to_u32_context() {
     let mut m31_to_u32_context = build_m31_to_u32_context();
+    circuits::finalize_constants::finalize_constants(&mut m31_to_u32_context);
     m31_to_u32_context.finalize_guessed_vars();
     m31_to_u32_context.validate_circuit();
 
@@ -261,11 +265,12 @@ fn circuit_verify(
 }
 
 const FIBONACCI_CIRCUIT_PREPROCESSED_ROOT: [u32; 8] =
-    [579827647, 460015323, 2072233139, 709693420, 371952288, 1355707807, 1645091261, 2144587918];
+    [609397099, 1756617193, 1941377268, 2080039112, 2095406638, 3084915, 101776927, 1547274111];
 
 #[test]
 fn test_prove_and_circuit_verify_fibonacci_context() {
     let mut fibonacci_context = build_fibonacci_context();
+    circuits::finalize_constants::finalize_constants(&mut fibonacci_context);
     fibonacci_context.finalize_guessed_vars();
     fibonacci_context.validate_circuit();
 
@@ -280,11 +285,12 @@ fn test_prove_and_circuit_verify_fibonacci_context() {
 }
 
 const M31_TO_U32_CIRCUIT_PREPROCESSED_ROOT: [u32; 8] =
-    [270075619, 790063164, 183255611, 43064901, 229280056, 1717043326, 341216832, 2011011748];
+    [2057150194, 1287539556, 348840330, 1316644708, 1932016463, 1332646262, 1451210563, 700919965];
 
 #[test]
 fn test_prove_and_circuit_verify_m31_to_u32_context() {
     let mut m31_to_u32_context = build_m31_to_u32_context();
+    circuits::finalize_constants::finalize_constants(&mut m31_to_u32_context);
     m31_to_u32_context.finalize_guessed_vars();
     m31_to_u32_context.validate_circuit();
 

crates/circuit_verifier/src/verify.rs

@@ -1,4 +1,7 @@
-use circuits::{blake::HashValue, context::Context, ivalue::IValue, ops::Guess};
+use circuits::{
+    blake::HashValue, context::Context, finalize_constants::finalize_constants, ivalue::IValue,
+    ops::Guess,
+};
 use circuits_stark_verifier::{
     proof::{Proof, ProofConfig},
     statement::Statement,
@@ -46,6 +49,7 @@ pub fn build_verification_circuit<Value: IValue>(
     let proof_vars = proof.guess(&mut context);
 
     verify(&mut context, &proof_vars, &proof_config, &statement);
+    finalize_constants(&mut context);
     context.finalize_guessed_vars();
     #[cfg(test)]
     context.circuit.check_yields();

crates/circuits/src/blake_test.rs

@@ -40,10 +40,10 @@ fn test_blake(#[case] wrong_output: bool) {
     eq(&mut context, output.0, out0);
     eq(&mut context, output.1, out1);
 
-    assert_eq!(context.stats, Stats { blake_updates: 2, guess: 9, equals: 2, ..Stats::default() });
+    assert_eq!(context.stats, Stats { blake_updates: 2, guess: 7, equals: 2, ..Stats::default() });
 
+    crate::finalize_constants::finalize_constants(&mut context);
     context.finalize_guessed_vars();
-    assert_eq!(context.circuit.compute_multiplicities().0, vec![13, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2]);
     context.circuit.check_yields();
 
     assert_eq!(context.is_circuit_valid(), !wrong_output);

crates/circuits/src/context.rs

@@ -4,8 +4,7 @@ use num_traits::{One, Zero};
 use stwo::core::fields::qm31::QM31;
 
 use crate::circuit::{Add, Circuit};
-use crate::ivalue::IValue;
-use crate::ops::guess;
+use crate::ivalue::{IValue, qm31_from_u32s};
 use crate::stats::Stats;
 
 #[cfg(test)]
@@ -50,7 +49,7 @@ pub struct Context<Value: IValue> {
     ///
     /// `None` if the set of guessed variables has already been finalized.
     ///
-    /// See [guess].
+    /// See [crate::ops::guess].
     pub guessed_vars: Option<Vec<usize>>,
     /// Debug only. If true, equality is asserted when adding the `eq` gate; if false, no
     /// assertion is made during construction and equality can be checked later at validation.
@@ -94,7 +93,7 @@ impl<Value: IValue> Context<Value> {
         if let Some(var) = self.constants.get(&value) {
             *var
         } else {
-            let var = guess(self, Value::from_qm31(value));
+            let var = self.new_var(Value::from_qm31(value));
             self.constants.insert(value, var);
             var
         }
@@ -161,9 +160,11 @@ impl<Value: IValue> Default for Context<Value> {
             guessed_vars: Some(vec![]),
             assert_eq_on_eval: false,
         };
-        // Register zero and one as the first constants.
+        // Register zero, one, and u as the first constants.
         res.constant(QM31::zero());
         res.constant(QM31::one());
+        res.constant(qm31_from_u32s(0, 0, 1, 0)); // u at idx 2
+
         res
     }
 }

crates/circuits/src/context_test.rs

@@ -11,14 +11,11 @@ fn test_constants() {
     let c = context.constant(x);
     assert_eq!(a.idx, c.idx);
 
-    assert_eq!(context.values(), &vec![0.into(), 1.into(), x, x + x]);
+    let u = qm31_from_u32s(0, 0, 1, 0);
+    assert_eq!(context.values(), &vec![0.into(), 1.into(), u, x, x + x]);
 
+    crate::finalize_constants::finalize_constants(&mut context);
     context.finalize_guessed_vars();
-    assert_eq!(
-        format!("{:?}", context.circuit),
-        "[0] = [0] + [0]\n[1] = [1] + [0]\n[2] = [2] + [0]\n[3] = [3] + [0]\n"
-    );
-
     context.validate_circuit();
 }
 

crates/circuits/src/finalize_constants.rs

@@ -18,9 +18,7 @@ mod test;
 
 /// Wraps `finalize_constants_with_min_base` and calls it with a default value. The main reason
 /// is to make testing easier by choosing a smaller minimum base.
-// TODO(Leo): remove allow once integrated in the main flow.
-#[allow(unused)]
-fn finalize_constants(context: &mut Context<impl IValue>) {
+pub fn finalize_constants(context: &mut Context<impl IValue>) {
     const DEFAULT_MIN_BASE: usize = 256;
     finalize_constants_with_min_base(context, DEFAULT_MIN_BASE);
 }
@@ -45,7 +43,10 @@ fn finalize_constants(context: &mut Context<impl IValue>) {
 /// rebuilding them, so each distinct M31 value gets at most one yield gate.
 ///
 /// `IndexMap` is used (rather than `HashMap`) so that iteration order is deterministic.
-fn finalize_constants_with_min_base(context: &mut Context<impl IValue>, min_base: usize) {
+pub(crate) fn finalize_constants_with_min_base(
+    context: &mut Context<impl IValue>,
+    min_base: usize,
+) {
     assert!(min_base >= 2);
     let mut m31_constants = IndexMap::<M31, Var>::new();
     let mut qm31_constants = IndexMap::<QM31, Var>::new();