remove unused code

Author: zlangley

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

@@ -119,14 +119,7 @@ impl<F: Field> MultivariatePolyOracle<F> for GkrMultivariatePolyOracle<'_, F> {
             Layer::LogUpGeneric {
                 numerators,
                 denominators,
-            }
-            | Layer::LogUpMultiplicities {
-                numerators,
-                denominators,
             } => eval_logup_sum(self.eq_evals, numerators, denominators, n_terms, lambda),
-            Layer::LogUpSingles { denominators } => {
-                eval_logup_singles_sum(self.eq_evals, denominators, n_terms, lambda)
-            }
         };
 
         eval_at_0 *= self.eq_fixed_var_correction;
@@ -236,47 +229,6 @@ fn eval_logup_sum<F: Field>(
         )
 }
 
-/// Evaluates `sum_x eq(({0}^|r|, 0, x), y) * (inp_denom(r, t, x, 1) + inp_denom(r, t, x, 0) +
-/// lambda * inp_denom(r, t, x, 0) * inp_denom(r, t, x, 1))` at `t=0` and `t=2`.
-///
-/// Output of the form: `(eval_at_0, eval_at_2)`.
-fn eval_logup_singles_sum<F: Field>(
-    eq_evals: &FixedFirstHypercubeEqEvals<F>,
-    input_denominators: &Mle<F>,
-    n_terms: usize,
-    lambda: F,
-) -> (F, F) {
-    let mut eval_at_0 = F::ZERO;
-    let mut eval_at_2 = F::ZERO;
-
-    for i in 0..n_terms {
-        // Input denominator values at (r, {0, 1, 2}, bits(i), {0, 1})
-        let (inp_denom_r0_0, inp_denom_r0_1) =
-            (input_denominators[i * 2], input_denominators[i * 2 + 1]);
-        let (inp_denom_r1_0, inp_denom_r1_1) = (
-            input_denominators[(n_terms + i) * 2],
-            input_denominators[(n_terms + i) * 2 + 1],
-        );
-
-        // Calculate values at t = 2
-        let inp_denom_r2_0 = inp_denom_r1_0.double() - inp_denom_r0_0;
-        let inp_denom_r2_1 = inp_denom_r1_1.double() - inp_denom_r0_1;
-
-        // Fraction addition polynomials at t = 0 and t = 2
-        let numer_at_r0i = inp_denom_r0_0 + inp_denom_r0_1;
-        let denom_at_r0i = inp_denom_r0_0 * inp_denom_r0_1;
-        let numer_at_r2i = inp_denom_r2_0 + inp_denom_r2_1;
-        let denom_at_r2i = inp_denom_r2_0 * inp_denom_r2_1;
-
-        // Accumulate evaluated terms
-        let eq_eval_at_0i = eq_evals[i];
-        eval_at_0 += eq_eval_at_0i * (numer_at_r0i + lambda * denom_at_r0i);
-        eval_at_2 += eq_eval_at_0i * (numer_at_r2i + lambda * denom_at_r2i);
-    }
-
-    (eval_at_0, eval_at_2)
-}
-
 impl<F: Field> GkrMultivariatePolyOracle<'_, F> {
     fn has_zero_arity(&self) -> bool {
         self.arity() == 0
@@ -307,13 +259,6 @@ impl<F: Field> GkrMultivariatePolyOracle<'_, F> {
                 let denominators = denominators.as_ref().try_into().unwrap();
                 vec![numerators, denominators]
             }
-            // Should never get called.
-            Layer::LogUpMultiplicities { .. } => unimplemented!(),
-            Layer::LogUpSingles { denominators } => {
-                let numerators = [F::ONE; 2];
-                let denominators = denominators.as_ref().try_into().unwrap();
-                vec![numerators, denominators]
-            }
         };
 
         Ok(GkrMask::new(columns))

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

@@ -113,25 +113,13 @@ pub enum Layer<F> {
         numerators: Mle<F>,
         denominators: Mle<F>,
     },
-    LogUpMultiplicities {
-        numerators: Mle<F>,
-        denominators: Mle<F>,
-    },
-    /// All numerators implicitly equal "1".
-    LogUpSingles {
-        denominators: Mle<F>,
-    },
 }
 
 impl<F: Field> Layer<F> {
     /// Returns the number of variables used to interpolate the layer's gate values.
     pub fn n_variables(&self) -> usize {
         match self {
             Self::GrandProduct(mle)
-            | Self::LogUpSingles { denominators: mle }
-            | Self::LogUpMultiplicities {
-                denominators: mle, ..
-            }
             | Self::LogUpGeneric {
                 denominators: mle, ..
             } => mle.arity(),
@@ -156,14 +144,7 @@ impl<F: Field> Layer<F> {
             Layer::LogUpGeneric {
                 numerators,
                 denominators,
-            }
-            | Layer::LogUpMultiplicities {
-                numerators,
-                denominators,
-            } => Self::next_logup_layer(MleExpr::Mle(numerators), denominators),
-            Layer::LogUpSingles { denominators } => {
-                Self::next_logup_layer(MleExpr::Constant(F::ONE), denominators)
-            }
+            } => Self::next_logup_layer(numerators, denominators),
         };
         Some(next_layer)
     }
@@ -176,7 +157,7 @@ impl<F: Field> Layer<F> {
         Layer::GrandProduct(Mle::from_vec(res))
     }
 
-    fn next_logup_layer(numerators: MleExpr<'_, F>, denominators: &Mle<F>) -> Layer<F> {
+    fn next_logup_layer(numerators: &Mle<F>, denominators: &Mle<F>) -> Layer<F> {
         let (next_numerators, next_denominators): (Vec<_>, Vec<_>) = (0..denominators.len() / 2)
             .into_par_iter()
             .map(|i| {
@@ -201,18 +182,9 @@ impl<F: Field> Layer<F> {
         }
 
         Ok(match self {
-            Layer::LogUpSingles { denominators } => {
-                let numerator = F::ONE;
-                let denominator = denominators[0];
-                vec![numerator, denominator]
-            }
             Layer::LogUpGeneric {
                 numerators,
                 denominators,
-            }
-            | Layer::LogUpMultiplicities {
-                numerators,
-                denominators,
             } => {
                 let numerator = numerators[0];
                 let denominator = denominators[0];
@@ -235,36 +207,13 @@ impl<F: Field> Layer<F> {
             Self::LogUpGeneric {
                 numerators,
                 denominators,
-            }
-            | Self::LogUpMultiplicities {
-                numerators,
-                denominators,
             } => Self::LogUpGeneric {
                 numerators: numerators.partial_evaluation(x0),
                 denominators: denominators.partial_evaluation(x0),
             },
-            Self::LogUpSingles { denominators } => Self::LogUpSingles {
-                denominators: denominators.partial_evaluation(x0),
-            },
         }
     }
 }
 
 #[derive(Debug)]
 pub struct NotOutputLayerError;
-
-enum MleExpr<'a, F: Field> {
-    Constant(F),
-    Mle(&'a Mle<F>),
-}
-
-impl<F: Field> Index<usize> for MleExpr<'_, F> {
-    type Output = F;
-
-    fn index(&self, index: usize) -> &F {
-        match self {
-            Self::Constant(v) => v,
-            Self::Mle(mle) => &mle[index],
-        }
-    }
-}