Not working

plonky2/src/gates/gate.rs

@@ -129,11 +129,17 @@ pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + S
         &self,
         builder: &mut CircuitBuilder<F, D>,
         mut vars: EvaluationTargets<D>,
-        prefix: &[bool],
+        selector_index: usize,
+        combination_num: usize,
         combined_gate_constraints: &mut [ExtensionTarget<D>],
     ) {
-        let filter = compute_filter_recursively(builder, prefix, vars.local_constants);
-        vars.remove_prefix(prefix);
+        let filter = compute_filter_recursively(
+            builder,
+            selector_index,
+            combination_num,
+            vars.local_constants[selector_index],
+        );
+        vars.remove_prefix(selector_index);
         let my_constraints = self.eval_unfiltered_recursively(builder, vars);
         for (acc, c) in combined_gate_constraints.iter_mut().zip(my_constraints) {
             *acc = builder.mul_add_extension(filter, c, *acc);
@@ -238,21 +244,17 @@ fn compute_filter<'a, K: Field>(selector_index: usize, combination_num: usize, c
 
 fn compute_filter_recursively<F: RichField + Extendable<D>, const D: usize>(
     builder: &mut CircuitBuilder<F, D>,
-    prefix: &[bool],
-    constants: &[ExtensionTarget<D>],
+    selector_index: usize,
+    combination_num: usize,
+    constant: ExtensionTarget<D>,
 ) -> ExtensionTarget<D> {
-    let one = builder.one_extension();
-    let v = prefix
-        .iter()
-        .enumerate()
-        .map(|(i, &b)| {
-            if b {
-                constants[i]
-            } else {
-                builder.sub_extension(one, constants[i])
-            }
-        })
+    let v = (0..combination_num)
+        .filter(|&i| i != selector_index)
+        .map(|i| builder.constant_extension(F::Extension::from_canonical_usize(i)))
+        .collect::<Vec<_>>();
+    let v = v
+        .into_iter()
+        .map(|x| builder.sub_extension(x, constant))
         .collect::<Vec<_>>();
-
     builder.mul_many_extension(&v)
 }

plonky2/src/gates/gate_testing.rs

@@ -152,7 +152,7 @@ where
     let evals = gate.eval_unfiltered(vars);
 
     let vars_t = EvaluationTargets {
-        local_constants: &constants_t,
+        local_constants: constants_t,
         local_wires: &wires_t,
         public_inputs_hash: &public_inputs_hash_t,
     };

plonky2/src/plonk/recursive_verifier.rs

@@ -53,7 +53,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
     {
         let one = self.one_extension();
 
-        let local_constants = &proof.openings.constants;
+        let local_constants = proof.openings.constants.clone();
         let local_wires = &proof.openings.wires;
         let vars = EvaluationTargets {
             local_constants,
@@ -230,6 +230,7 @@ mod tests {
         let (proof, vd, cd) =
             recursive_proof::<F, C, C, D>(proof, vd, cd, &config, Some(13), false, false)?;
         assert_eq!(cd.degree_bits, 13);
+        test_serialization(&proof, &cd)?;
 
         // Shrink it to 2^12.
         let (proof, _vd, cd) =
@@ -403,7 +404,7 @@ mod tests {
             timing.print();
         }
 
-        data.verify(proof.clone())?;
+        // data.verify(proof.clone())?;
 
         Ok((proof, data.verifier_only, data.common))
     }

plonky2/src/plonk/vanishing_poly.rs

@@ -275,21 +275,21 @@ pub fn evaluate_gate_constraints_recursively<
     common_data: &CommonCircuitData<F, C, D>,
     vars: EvaluationTargets<D>,
 ) -> Vec<ExtensionTarget<D>> {
-    todo!();
-    // let mut all_gate_constraints = vec![builder.zero_extension(); num_gate_constraints];
-    // for gate in gates {
-    //     with_context!(
-    //         builder,
-    //         &format!("evaluate {} constraints", gate.gate.0.id()),
-    //         gate.gate.0.eval_filtered_recursively(
-    //             builder,
-    //             vars,
-    //             &gate.prefix,
-    //             &mut all_gate_constraints
-    //         )
-    //     );
-    // }
-    // all_gate_constraints
+    let mut all_gate_constraints = vec![builder.zero_extension(); common_data.num_gate_constraints];
+    for (i, gate) in common_data.gates.iter().enumerate() {
+        with_context!(
+            builder,
+            &format!("evaluate {} constraints", gate.0.id()),
+            gate.0.eval_filtered_recursively(
+                builder,
+                vars.clone(),
+                common_data.selector_indices[i],
+                common_data.combination_nums[i],
+                &mut all_gate_constraints
+            )
+        );
+    }
+    all_gate_constraints
 }
 
 /// Evaluate the vanishing polynomial at `x`. In this context, the vanishing polynomial is a random
@@ -322,7 +322,7 @@ pub(crate) fn eval_vanishing_poly_recursively<
     let constraint_terms = with_context!(
         builder,
         "evaluate gate constraints",
-        evaluate_gate_constraints_recursively(builder, common_data, vars,)
+        evaluate_gate_constraints_recursively(builder, common_data, vars.clone())
     );
 
     // The L_1(x) (Z(x) - 1) vanishing terms.

plonky2/src/plonk/vars.rs

@@ -218,14 +218,14 @@ impl<'a, P: PackedField> ExactSizeIterator for EvaluationVarsBaseBatchIterPacked
 }
 
 impl<'a, const D: usize> EvaluationTargets<'a, D> {
-    pub fn remove_prefix(&mut self, prefix: &[bool]) {
-        self.local_constants = &self.local_constants[prefix.len()..];
+    pub fn remove_prefix(&mut self, selector_index: usize) {
+        self.local_constants.remove(selector_index);
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct EvaluationTargets<'a, const D: usize> {
-    pub local_constants: &'a [ExtensionTarget<D>],
+    pub local_constants: Vec<ExtensionTarget<D>>,
     pub local_wires: &'a [ExtensionTarget<D>],
     pub public_inputs_hash: &'a HashOutTarget,
 }