Reused Eq tables

Author: wu-s-john

src/lagrange_accumulator/accumulator_builder.rs

@@ -16,7 +16,7 @@ use super::{
 };
 use crate::{
   big_num::{DelayedReduction, SmallValue, SmallValueEngine},
-  polys::{eq::EqPolynomial, eq::compute_suffix_eq_pyramid, multilinear::MultilinearPolynomial},
+  polys::{eq::build_eq_pyramid, eq::compute_suffix_eq_pyramid, multilinear::MultilinearPolynomial},
 };
 use ff::PrimeField;
 use num_traits::Zero;
@@ -28,12 +28,14 @@ use super::index::compute_idx4;
 /// For Spartan's cubic relation (A·B - C), D=2 yields quadratic t_i.
 pub const SPARTAN_T_DEGREE: usize = 2;
 
-/// Precomputed eq polynomial tables with balanced split.
+/// Precomputed eq polynomial pyramids with balanced split.
 struct EqSplitTables<F: PrimeField> {
-  /// eq(τ[l0..l0+in_vars], ·) evaluations, size 2^in_vars
-  e_in: Vec<F>,
-  /// eq(τ[l0+in_vars..], ·) evaluations, size 2^xout_vars
-  e_xout: Vec<F>,
+  /// Full pyramid for inner variables: eq(τ[l0..l0+in_vars], ·)
+  /// Layer k has size 2^k, layer in_vars is the full table (size 2^in_vars)
+  e_in_pyramid: Vec<Vec<F>>,
+  /// Full pyramid for outer variables: eq(τ[l0+in_vars..], ·)
+  /// Layer k has size 2^k, layer xout_vars is the full table (size 2^xout_vars)
+  e_xout_pyramid: Vec<Vec<F>>,
   /// Suffix eq pyramid for prefix variables, Vec per round
   e_y: Vec<Vec<F>>,
 }
@@ -44,25 +46,37 @@ pub(crate) struct BetaPrefixCache {
   num_betas: usize,
 }
 
-/// Precompute eq polynomial tables with balanced split for e_in and e_xout.
+/// Precompute eq polynomial pyramids with balanced split for e_in and e_xout.
 ///
 /// Returns (tables, in_vars, xout_vars) where:
 /// - in_vars = ceil((l - l0) / 2) - variables for inner loop (e_in)
 /// - xout_vars = floor((l - l0) / 2) - variables for outer loop (e_xout)
 ///
 /// The balanced split reduces precomputation cost by ~33% compared to the
 /// asymmetric l/2 split, and enables odd number of rounds.
+///
+/// Both e_in and e_xout are returned as full pyramids (not just top layers),
+/// enabling reuse by EqSumCheckInstance for the remaining sumcheck rounds.
 fn precompute_eq_tables<F: PrimeField>(taus: &[F], l0: usize) -> (EqSplitTables<F>, usize, usize) {
   let l = taus.len();
   let suffix_vars = l - l0;
   let in_vars = suffix_vars.div_ceil(2); // ceiling: e_in larger (inner loop, sequential access)
   let xout_vars = suffix_vars - in_vars; // floor: e_xout smaller (outer loop, reused)
 
-  let e_in = EqPolynomial::evals_from_points(&taus[l0..l0 + in_vars]); // 2^in_vars entries
-  let e_xout = EqPolynomial::evals_from_points(&taus[l0 + in_vars..]); // 2^xout_vars entries
+  // Build full pyramids (not just top layers) for reuse by EqSumCheckInstance
+  let e_in_pyramid = build_eq_pyramid(&taus[l0..l0 + in_vars]); // in_vars+1 layers
+  let e_xout_pyramid = build_eq_pyramid(&taus[l0 + in_vars..]); // xout_vars+1 layers
   let e_y = compute_suffix_eq_pyramid(&taus[..l0], l0); // Vec per round, total 2^l0 - 1
 
-  (EqSplitTables { e_in, e_xout, e_y }, in_vars, xout_vars)
+  (
+    EqSplitTables {
+      e_in_pyramid,
+      e_xout_pyramid,
+      e_y,
+    },
+    in_vars,
+    xout_vars,
+  )
 }
 
 /// Build beta → prefix index cache for O(1) scatter access.
@@ -90,6 +104,16 @@ pub(crate) fn build_beta_cache<const D: usize>(l0: usize) -> BetaPrefixCache {
 /// - `F`: Field type with small-value and delayed reduction support
 /// - `SV`: Witness value type (i32 or i64)
 ///
+/// # Returns
+///
+/// A tuple of (accumulators, e_in_pyramid, e_xout_pyramid) where:
+/// - accumulators: The computed Lagrange accumulators for small-value rounds
+/// - e_in_pyramid: Full eq pyramid for inner variables τ[l0..l0+in_vars], has in_vars+1 layers
+/// - e_xout_pyramid: Full eq pyramid for outer variables τ[l0+in_vars..ℓ], has xout_vars+1 layers
+///
+/// The pyramids can be reused by EqSumCheckInstance for the remaining sumcheck rounds,
+/// avoiding redundant eq polynomial computation.
+///
 /// # Parallelism strategy
 ///
 /// - Outer parallel loop over x_out values (using Rayon fold-reduce)
@@ -105,7 +129,7 @@ pub fn build_accumulators_spartan<F, SV>(
   bz: &MultilinearPolynomial<SV>,
   taus: &[F],
   l0: usize,
-) -> LagrangeAccumulators<F, 2>
+) -> (LagrangeAccumulators<F, 2>, Vec<Vec<F>>, Vec<Vec<F>>)
 where
   F: SmallValueEngine<SV>,
   SV: SmallValue,
@@ -120,10 +144,16 @@ where
   let suffix_vars = l - l0;
   let prefix_size = 1usize << l0;
 
-  // Precompute eq tables with balanced split
-  let (eq_tables, _in_vars, xout_vars) = precompute_eq_tables(taus, l0);
+  // Precompute eq pyramids with balanced split
+  let (eq_tables, in_vars, xout_vars) = precompute_eq_tables(taus, l0);
   let num_x_out = 1usize << xout_vars;
 
+  // Get top layers (full eq tables) for accumulator computation
+  let e_in = eq_tables.e_in_pyramid.last().expect("e_in_pyramid non-empty");
+  let e_xout = eq_tables.e_xout_pyramid.last().expect("e_xout_pyramid non-empty");
+  debug_assert_eq!(e_in.len(), 1 << in_vars);
+  debug_assert_eq!(e_xout.len(), 1 << xout_vars);
+
   // Build beta → prefix index cache
   let BetaPrefixCache {
     cache: beta_prefix_cache,
@@ -145,8 +175,7 @@ where
     .e_y
     .iter()
     .map(|round_ey| {
-      eq_tables
-        .e_xout
+      e_xout
         .iter()
         .flat_map(|ex| round_ey.iter().map(|ey| *ex * *ey))
         .collect()
@@ -156,9 +185,6 @@ where
   // Precompute num_y per round for transposed access
   let num_y_per_round: Vec<usize> = eq_tables.e_y.iter().map(|ey| ey.len()).collect();
 
-  // Borrow e_in directly (no clone needed)
-  let e_in = &eq_tables.e_in;
-
   // Parallel over x_out with thread-local state (zero per-iteration allocations)
   type State<F2, SV2> = SpartanThreadState<F2, SV2, 2>;
 
@@ -249,9 +275,16 @@ where
     .expect("num_x_out > 0 guarantees non-empty fold results");
 
   // Finalize: reduce each bucket from wide 9-limb to field element
-  merged
+  let accumulators = merged
     .acc
-    .map(|acc| <F as DelayedReduction<F>>::reduce(acc))
+    .map(|acc| <F as DelayedReduction<F>>::reduce(acc));
+
+  // Return accumulators along with full pyramids for EqSumCheckInstance reuse
+  (
+    accumulators,
+    eq_tables.e_in_pyramid,
+    eq_tables.e_xout_pyramid,
+  )
 }
 
 #[cfg(test)]
@@ -283,7 +316,7 @@ mod tests {
 
     let taus: Vec<Scalar> = vec![Scalar::from(3u64), Scalar::from(5u64)];
 
-    let acc = build_accumulators_spartan(&az, &bz, &taus, l0);
+    let (acc, _, _) = build_accumulators_spartan(&az, &bz, &taus, l0);
 
     // Only round 0 exists (v is empty). β ranges over U_d with binary {0,1} and non-binary {∞}.
     // Buckets for u = 0 should be zero (binary β), bucket for u = ∞ should be non-zero.
@@ -331,8 +364,8 @@ mod tests {
     ];
 
     // Build accumulators twice
-    let acc1 = build_accumulators_spartan(&az, &bz, &taus, l0);
-    let acc2 = build_accumulators_spartan(&az, &bz, &taus, l0);
+    let (acc1, _, _) = build_accumulators_spartan(&az, &bz, &taus, l0);
+    let (acc2, _, _) = build_accumulators_spartan(&az, &bz, &taus, l0);
 
     // Compare all buckets
     for round in 0..l0 {
@@ -369,8 +402,8 @@ mod tests {
     let taus: Vec<Scalar> = (0..l).map(|i| Scalar::from((i * 7 + 3) as u64)).collect();
 
     // Build accumulators twice to verify consistency
-    let acc1 = build_accumulators_spartan(&az, &bz, &taus, l0);
-    let acc2 = build_accumulators_spartan(&az, &bz, &taus, l0);
+    let (acc1, _, _) = build_accumulators_spartan(&az, &bz, &taus, l0);
+    let (acc2, _, _) = build_accumulators_spartan(&az, &bz, &taus, l0);
 
     for round in 0..l0 {
       let num_v = (D + 1).pow(round as u32);

src/polys/eq.rs

@@ -85,6 +85,57 @@ impl<Scalar: PrimeField> FromIterator<Scalar> for EqPolynomial<Scalar> {
   }
 }
 
+/// Build a full eq polynomial pyramid from tau values.
+///
+/// Given taus = [τ₀, τ₁, ..., τ_{n-1}], builds a pyramid where:
+/// - Layer 0: [1]
+/// - Layer 1: [1-τ_{n-1}, τ_{n-1}]
+/// - Layer k: eq([τ_{n-k}, ..., τ_{n-1}], ·), size 2^k
+/// - Layer n: eq([τ₀, ..., τ_{n-1}], ·), size 2^n (the full eq table)
+///
+/// The pyramid has n+1 layers total. This structure matches EqSumCheckInstance's
+/// internal representation, enabling pyramid reuse between accumulator building
+/// and sumcheck evaluation.
+///
+/// The taus are processed in reverse order (last tau first) to match the
+/// standard multilinear indexing convention where the first tau corresponds
+/// to the most significant bit of the index.
+///
+/// Each layer is stored as [lo_0, lo_1, ..., lo_n, hi_0, hi_1, ..., hi_n]
+/// where lo values are multiplied by (1-τ) and hi values by τ.
+pub fn build_eq_pyramid<S: PrimeField>(taus: &[S]) -> Vec<Vec<S>> {
+  use rayon::prelude::*;
+
+  let n = taus.len();
+  let mut pyramid = Vec::with_capacity(n + 1);
+
+  // Layer 0: base case [1]
+  pyramid.push(vec![S::ONE]);
+
+  // Build layers 1..n by adding one tau at a time (in reverse order)
+  // Uses the same parallel pattern as EqSumCheckInstance::new
+  for i in 0..n {
+    let tau = taus[n - 1 - i]; // Process taus in reverse
+    let prev = &pyramid[i];
+
+    // Build next layer: [lo_0, ..., lo_n, hi_0, ..., hi_n]
+    // First, copy prev and extend with hi values (prev * tau)
+    let mut next = prev.to_vec();
+    next.par_extend(prev.par_iter().map(|v| *v * tau));
+
+    // Then subtract hi from lo: lo = prev - hi = prev * (1 - tau)
+    let (first, last) = next.split_at_mut(prev.len());
+    first
+      .par_iter_mut()
+      .zip(last)
+      .for_each(|(a, b)| *a -= *b);
+
+    pyramid.push(next);
+  }
+
+  pyramid
+}
+
 /// Compute suffix eq tables for small-value sumcheck optimization.
 ///
 /// Given τ = (τ₀, τ₁, ..., τ_{l-1}) and `l0` (the number of small-value rounds),

src/small_sumcheck.rs

@@ -243,13 +243,13 @@ where
 
   // ===== Pre-computation Phase =====
   // Build accumulators A_i(v, u) for all i ∈ [ℓ₀] using small-value arithmetic.
+  // Also builds eq pyramids for reuse by EqSumCheckInstance.
   // Internally computes eq tables with balanced split and precomputed eq_cache.
   // Uses: small × small → intermediate (for Az·Bz products),
   // then intermediate × field (for eq weighting via DelayedReduction).
-  let accumulators = build_accumulators_spartan(poly_A_small, poly_B_small, &taus, l0);
+  let (accumulators, mut e_in_pyramid, e_xout_pyramid) =
+    build_accumulators_spartan(poly_A_small, poly_B_small, &taus, l0);
 
-  // Create EqSumCheckInstance for suffix variables (used in remaining rounds).
-  let mut eq_instance = eq_sumcheck::EqSumCheckInstance::<E>::new(&taus[l0..]);
   let mut small_value_sumcheck =
     SmallValueSumCheck::<E::Scalar, SPARTAN_T_DEGREE>::from_accumulators(accumulators);
 
@@ -306,11 +306,21 @@ where
   );
 
   // ===== Remaining Rounds (ℓ₀ to ℓ-1) =====
-  // Inject the accumulated eq factor from small-value rounds into eq_instance.
-  // This incorporates eq(τ_{0..l0}, r_{0..l0}) so the pyramid results are correct.
-  eq_instance.set_eval_eq_left(small_value_sumcheck.eq_alpha());
+  // Pop the top layer from e_in_pyramid. The top layer was used by the accumulator;
+  // EqSumCheckInstance needs the remaining layers (without the first suffix tau τ[l₀]).
+  // This matches the Nova optimization where τ[l₀] is tracked in eval_eq_left.
+  e_in_pyramid.pop();
+
+  // Create EqSumCheckInstance from precomputed pyramids, avoiding redundant eq computation.
+  // The accumulated eq factor from small-value rounds is passed directly.
+  let mut eq_instance = eq_sumcheck::EqSumCheckInstance::<E>::from_pyramids(
+    e_in_pyramid,
+    e_xout_pyramid,
+    &taus[l0..],
+    small_value_sumcheck.eq_alpha(),
+  );
 
-  // Continue with the remaining rounds using the REUSED eq instance.
+  // Continue with the remaining rounds using the eq instance built from pyramids.
   // The eq_instance was created with taus[l0..], so its internal round counter tracks
   // local rounds. We pass global round index for the round_idx parameter since
   // eval_one_case_cubic_three_inputs uses it for a round-0 optimization.
@@ -421,7 +431,7 @@ mod tests {
     let mut claim = F::ZERO;
 
     // Build accumulators using the simplified API
-    let accs = build_accumulators_spartan(&az_poly, &bz_poly, &taus, SMALL_VALUE_ROUNDS);
+    let (accs, _, _) = build_accumulators_spartan(&az_poly, &bz_poly, &taus, SMALL_VALUE_ROUNDS);
     let mut small_value = SmallValueSumCheck::from_accumulators(accs);
 
     // Full eq_instance for verification against standard sumcheck

src/sumcheck.rs

@@ -957,14 +957,81 @@ pub(crate) mod eq_sumcheck {
       }
     }
 
-    /// Sets the accumulated eq evaluation factor from previous rounds.
+    /// Creates an EqSumCheckInstance from precomputed eq pyramids.
     ///
-    /// This allows reusing an EqSumCheckInstance created for suffix variables
-    /// while incorporating the eq factor from prefix rounds (small-value rounds).
-    /// Call this before starting the remaining rounds to inject the factor
-    /// `eq(τ_{0..l0}, r_{0..l0})` accumulated during small-value rounds.
-    pub fn set_eval_eq_left(&mut self, factor: E::Scalar) {
-      self.eval_eq_left = factor;
+    /// This constructor enables reuse of pyramids already computed during accumulator
+    /// building, avoiding redundant eq polynomial computation.
+    ///
+    /// # Arguments
+    ///
+    /// - `e_in_pyramid`: Pyramid for inner variables (ALREADY POPPED by caller).
+    ///   Has `in_vars` layers where layer k has size 2^k.
+    ///   Built from τ[l₀+1 : l₀+in_vars] (first suffix tau τ[l₀] is excluded).
+    /// - `e_xout_pyramid`: Full pyramid for outer variables.
+    ///   Has `xout_vars+1` layers where layer k has size 2^k.
+    ///   Built from τ[l₀+in_vars : ℓ].
+    /// - `taus`: The suffix tau values τ[l₀:ℓ] (needed for `bound()` and `eq_tau_0_2_3`).
+    /// - `eval_eq_left`: Accumulated eq factor from prefix rounds, eq(τ[0:l₀], r[0:l₀]).
+    ///
+    /// # Factorization
+    ///
+    /// The eq polynomial factors as:
+    /// ```text
+    /// eq(τ[l₀:ℓ], x) = eq(τ[l₀], x₀) × eq(τ[l₀+1:l₀+in_vars], x_in) × eq(τ[l₀+in_vars:ℓ], x_out)
+    ///                  └─ tracked in eval_eq_left ─┘   └── e_in_pyramid ──┘   └── e_xout_pyramid ──┘
+    /// ```
+    ///
+    /// The first suffix tau τ[l₀] is handled via `eval_eq_left` and `bound()`,
+    /// matching the Nova optimization where the first variable is tracked separately.
+    pub fn from_pyramids(
+      e_in_pyramid: Vec<Vec<E::Scalar>>,
+      e_xout_pyramid: Vec<Vec<E::Scalar>>,
+      taus: &[E::Scalar],
+      eval_eq_left: E::Scalar,
+    ) -> Self {
+      // in_vars = number of layers in popped pyramid (one less than original)
+      // After pop: e_in_pyramid has in_vars layers for in_vars-1 taus
+      // But first_half should equal in_vars (the number of rounds for left side)
+      let in_vars = e_in_pyramid.len();
+      let xout_vars = e_xout_pyramid.len().saturating_sub(1);
+
+      debug_assert_eq!(
+        in_vars + xout_vars,
+        taus.len(),
+        "Pyramid sizes must match taus length: in_vars={}, xout_vars={}, taus.len()={}",
+        in_vars,
+        xout_vars,
+        taus.len()
+      );
+
+      // Compute eq_tau_0_2_3 for all suffix taus (same logic as new())
+      // These are precomputed eq evaluations at points 0, 2, 3:
+      //   eq(τ, 0) = 1 - τ
+      //   eq(τ, 2) = 3τ - 1
+      //   eq(τ, 3) = 5τ - 2
+      let f2 = E::Scalar::ONE.double();
+      let f1 = E::Scalar::ONE;
+      let eq_tau_0_2_3 = taus
+        .par_iter()
+        .map(|tau| {
+          let tau2 = tau.double();
+          let tau3 = tau2 + tau;
+          let tau5 = tau3 + tau2;
+          (f1 - tau, tau3 - f1, tau5 - f2)
+        })
+        .collect::<Vec<_>>();
+
+      Self {
+        init_num_vars: in_vars + xout_vars,
+        first_half: in_vars,
+        second_half: xout_vars,
+        round: 1,
+        taus: taus.to_vec(),
+        eval_eq_left,
+        poly_eq_left: e_in_pyramid,
+        poly_eq_right: e_xout_pyramid,
+        eq_tau_0_2_3,
+      }
     }
 
     /// Evaluate poly_A * poly_B - poly_C