cleanup

Author: zlangley

crates/stark-backend/src/gkr/prover.rs

@@ -104,25 +104,22 @@ impl<F: Field> MultivariatePolyOracle<F> for GkrMultivariatePolyOracle<'_, F> {
         self.input_layer.n_variables() - 1
     }
 
-    fn marginalize_first(&self, claim: F) -> UnivariatePolynomial<F> {
+    fn partial_hypercube_sum(&self, claim: F) -> UnivariatePolynomial<F> {
         let n_variables = self.arity();
         assert_ne!(n_variables, 0);
         let n_terms = 1 << (n_variables - 1);
-        // Vector used to generate evaluations of `eq(x, y)` for `x` in the boolean hypercube.
-        let y = &self.eq_evals.y;
-        let lambda = self.lambda;
 
         let (mut eval_at_0, mut eval_at_2) = match &self.input_layer {
             Layer::GrandProduct(col) => eval_grand_product_sum(self.eq_evals, col, n_terms),
             Layer::LogUpGeneric {
                 numerators,
                 denominators,
-            } => eval_logup_sum(self.eq_evals, numerators, denominators, n_terms, lambda),
+            } => eval_logup_sum(self.eq_evals, numerators, denominators, n_terms, self.lambda),
         };
 
         eval_at_0 *= self.eq_fixed_var_correction;
         eval_at_2 *= self.eq_fixed_var_correction;
-        correct_sum_as_poly_in_first_variable(eval_at_0, eval_at_2, claim, y, n_variables)
+        correct_sum_as_poly_in_first_variable(eval_at_0, eval_at_2, claim, self.eq_evals.y, n_variables)
     }
 
     fn fix_first_in_place(&mut self, alpha: F) {
@@ -440,12 +437,13 @@ pub fn correct_sum_as_poly_in_first_variable<F: Field>(
     //      = 1 - y[n - k] - t(1 - 2 * y[n - k])
     // => t = (1 - y[n - k]) / (1 - 2 * y[n - k])
     //      = b
-    let b_const = (F::ONE - y[n - k]) / (F::ONE - y[n - k].double());
+    let one_minus_y = F::ONE - y[n - k];
+    let b_const = one_minus_y / (F::ONE - y[n - k].double());
 
     // We get that `r(t) = f(t) * eq(t, y[n - k]) * a`.
-    let r_at_0 = f_at_0 * (F::ONE - y[n - k]) * a_const;
+    let r_at_0 = f_at_0 * one_minus_y * a_const;
     let r_at_1 = claim - r_at_0;
-    let r_at_2 = f_at_2 * (F::from_canonical_u8(3) * y[n - k] - F::ONE) * a_const;
+    let r_at_2 = f_at_2 * (y[n - k].double() - one_minus_y) * a_const;
 
     // Interpolate.
     UnivariatePolynomial::from_points(&[

crates/stark-backend/src/interaction/gkr_log_up/prove.rs

@@ -174,25 +174,22 @@ where
             .unwrap();
         let gamma_pows = gamma.powers().take(2 * max_interactions).collect_vec();
 
-        let (interactions_per_air_filtered, trace_view_per_air_filtered): (Vec<_>, Vec<_>) =
+        let trace_view_per_air_filtered =
             interactions_per_air
                 .iter()
                 .zip(trace_view_per_air.iter())
                 .filter_map(|(interactions, view)| {
                     if interactions.is_empty() {
                         None
                     } else {
-                        Some((interactions, view))
+                        Some(view)
                     }
-                })
-                .unzip();
+                }).collect_vec();
 
-        let results: Vec<_> = interactions_per_air_filtered
-            .par_iter()
-            .zip(trace_view_per_air_filtered.par_iter())
+        let results: Vec<_> = trace_view_per_air_filtered.par_iter()
             .zip(gkr_instances.par_iter())
             .zip(gkr_artifact.n_variables_by_instance.par_iter())
-            .map(|(((interactions, trace_view), gkr_instance), &n_vars)| {
+            .map(|((trace_view, gkr_instance), &n_vars)| {
                 let height = trace_view.partitioned_main[0].height();
                 let log_height = log2_strict_usize(height);
 

crates/stark-backend/src/poly/multi.rs

@@ -16,7 +16,7 @@ pub trait MultivariatePolyOracle<F>: Send + Sync {
     fn arity(&self) -> usize;
 
     /// Returns the sum of `g(x_1, x_2, ..., x_n)` over all `(x_2, ..., x_n)` in `{0, 1}^(n-1)` as a polynomial in `x_1`.
-    fn marginalize_first(&self, claim: F) -> UnivariatePolynomial<F>;
+    fn partial_hypercube_sum(&self, claim: F) -> UnivariatePolynomial<F>;
 
     /// Returns the multivariate polynomial `h(x_2, ..., x_n) = g(alpha, x_2, ..., x_n)`.
     fn fix_first_in_place(&mut self, alpha: F);
@@ -75,7 +75,7 @@ impl<F: Field> MultivariatePolyOracle<F> for Mle<F> {
         self.evals.len().ilog2() as usize
     }
 
-    fn marginalize_first(&self, claim: F) -> UnivariatePolynomial<F> {
+    fn partial_hypercube_sum(&self, claim: F) -> UnivariatePolynomial<F> {
         let mut y0 = F::ZERO;
         for i in 0..self.len() / 2 {
             y0 += self[i];
@@ -232,7 +232,7 @@ mod test {
         // (1 - x_1)(1 - x_2) + 2 (1 - x_1) x_2 + 3 x_1 (1 - x_2) + 4 x_1 x_2
         let mle = Mle::from_vec(evals);
         // (1 - x_1) + 2 (1 - x_1) + 3 x_1 + 4 x_1
-        let poly = mle.marginalize_first(sum);
+        let poly = mle.partial_hypercube_sum(sum);
 
         assert_eq!(
             poly.evaluate(BabyBear::ZERO),

crates/stark-backend/src/sumcheck.rs

@@ -80,7 +80,7 @@ where
             .enumerate()
             .map(|(i, (multivariate_poly, &claim))| {
                 let round_poly = if n_remaining_rounds == multivariate_poly.arity() {
-                    multivariate_poly.marginalize_first(claim)
+                    multivariate_poly.partial_hypercube_sum(claim)
                 } else {
                     claim.halve().into()
                 };