Minor refactor

src/circuit_data.rs

@@ -1,4 +1,3 @@
-use crate::constraint_polynomial::{EvaluationTargets, EvaluationVars};
 use crate::field::field::Field;
 use crate::gates::gate::GateRef;
 use crate::generator::WitnessGenerator;
@@ -7,6 +6,7 @@ use crate::prover::prove;
 use crate::target::Target;
 use crate::verifier::verify;
 use crate::witness::PartialWitness;
+use crate::circuit_builder::CircuitBuilder;
 
 #[derive(Copy, Clone)]
 pub struct CircuitConfig {
@@ -97,6 +97,7 @@ pub(crate) struct CommonCircuitData<F: Field> {
     /// The types of gates used in this circuit.
     pub(crate) gates: Vec<GateRef<F>>,
 
+    /// The largest number of constraints imposed by any gate.
     pub(crate) num_gate_constraints: usize,
 
     /// A commitment to each constant polynomial.
@@ -137,19 +138,4 @@ impl<F: Field> CommonCircuitData<F> {
         // 2 constraints for each Z check.
         self.config.num_checks * 2 + self.num_gate_constraints
     }
-
-    pub fn evaluate(&self, vars: EvaluationVars<F>) -> Vec<F> {
-        let mut constraints = vec![F::ZERO; self.num_gate_constraints];
-        for gate in &self.gates {
-            let gate_constraints = gate.0.eval_filtered(vars);
-            for (i, c) in gate_constraints.into_iter().enumerate() {
-                constraints[i] += c;
-            }
-        }
-        constraints
-    }
-
-    pub fn evaluate_recursive(&self, vars: EvaluationTargets) -> Vec<Target> {
-        todo!()
-    }
 }

src/constraint_polynomial.rs

@@ -9,6 +9,7 @@ pub struct EvaluationVars<'a, F: Field> {
     pub(crate) next_wires: &'a [F],
 }
 
+#[derive(Copy, Clone)]
 pub struct EvaluationTargets<'a> {
     pub(crate) local_constants: &'a [Target],
     pub(crate) next_constants: &'a [Target],

src/gates/gate.rs

@@ -24,6 +24,15 @@ pub trait Gate<F: Field>: 'static + Send + Sync {
         self.eval_unfiltered(vars)
     }
 
+    fn eval_filtered_recursively(
+        &self,
+        builder: &mut CircuitBuilder<F>,
+        vars: EvaluationTargets,
+    ) -> Vec<Target> {
+        // TODO: Filter
+        self.eval_unfiltered_recursively(builder, vars)
+    }
+
     fn generators(
         &self,
         gate_index: usize,

src/plonk_common.rs

@@ -1,6 +1,39 @@
 use crate::circuit_builder::CircuitBuilder;
 use crate::field::field::Field;
 use crate::target::Target;
+use crate::constraint_polynomial::{EvaluationTargets, EvaluationVars};
+use crate::gates::gate::GateRef;
+
+pub fn evaluate_gate_constraints<F: Field>(
+    gates: &[GateRef<F>],
+    num_gate_constraints: usize,
+    vars: EvaluationVars<F>,
+) -> Vec<F> {
+    let mut constraints = vec![F::ZERO; num_gate_constraints];
+    for gate in gates {
+        let gate_constraints = gate.0.eval_filtered(vars);
+        for (i, c) in gate_constraints.into_iter().enumerate() {
+            constraints[i] += c;
+        }
+    }
+    constraints
+}
+
+pub fn evaluate_gate_constraints_recursively<F: Field>(
+    builder: &mut CircuitBuilder<F>,
+    gates: &[GateRef<F>],
+    num_gate_constraints: usize,
+    vars: EvaluationTargets,
+) -> Vec<Target> {
+    let mut constraints = vec![builder.zero(); num_gate_constraints];
+    for gate in gates {
+        let gate_constraints = gate.0.eval_filtered_recursively(builder, vars);
+        for (i, c) in gate_constraints.into_iter().enumerate() {
+            constraints[i] = builder.add(constraints[i], c);
+        }
+    }
+    constraints
+}
 
 /// Evaluate the polynomial which vanishes on any multiplicative subgroup of a given order `n`.
 pub(crate) fn eval_zero_poly<F: Field>(n: usize, x: F) -> F {

src/prover.rs

@@ -10,7 +10,7 @@ use crate::field::field::Field;
 use crate::generator::generate_partial_witness;
 use crate::hash::merkle_root_bit_rev_order;
 use crate::plonk_challenger::Challenger;
-use crate::plonk_common::{eval_l_1, reduce_with_powers_multi};
+use crate::plonk_common::{eval_l_1, reduce_with_powers_multi, evaluate_gate_constraints};
 use crate::polynomial::division::divide_by_z_h;
 use crate::polynomial::polynomial::{PolynomialCoeffs, PolynomialValues};
 use crate::proof::Proof;
@@ -190,7 +190,8 @@ fn compute_vanishing_poly_entry<F: Field>(
     gamma: F,
     alphas: &[F],
 ) -> Vec<F> {
-    let constraint_terms = common_data.evaluate(vars);
+    let constraint_terms = evaluate_gate_constraints(
+        &common_data.gates, common_data.num_gate_constraints, vars);
 
     // The L_1(x) (Z(x) - 1) vanishing terms.
     let mut vanishing_z_1_terms = Vec::new();