Implement svo

Cargo.toml

@@ -104,6 +104,10 @@ harness = false
 name = "sumcheck"
 harness = false
 
+[[bench]]
+name = "sumcheck_svo"
+harness = false
+
 [[bench]]
 name = "stir_queries"
 harness = false

benches/sumcheck_svo.rs

@@ -0,0 +1,82 @@
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use p3_challenger::{DuplexChallenger, FieldChallenger, GrindingChallenger};
+use p3_field::extension::BinomialExtensionField;
+use p3_koala_bear::{KoalaBear, Poseidon2KoalaBear};
+use rand::{Rng, SeedableRng, rngs::StdRng};
+use whir::{
+    fiat_shamir::{domain_separator::DomainSeparator, prover::ProverState},
+    poly::{evals::EvaluationsList, multilinear::MultilinearPoint},
+    sumcheck::sumcheck_single::SumcheckSingle,
+    whir::constraints::{evaluator::Constraint, statement::EqStatement},
+};
+use whir_p3 as whir;
+
+type F = KoalaBear;
+type EF = BinomialExtensionField<F, 8>;
+type Poseidon16 = Poseidon2KoalaBear<16>;
+type MyChallenger = DuplexChallenger<F, Poseidon16, 16, 8>;
+
+const NUM_CONSTRAINTS: usize = 1;
+const FOLDING_FACTOR: usize = 5;
+const POW_BITS: usize = 0;
+
+fn setup_prover() -> ProverState<F, EF, MyChallenger> {
+    let mut rng = StdRng::seed_from_u64(0);
+    let poseidon = Poseidon16::new_from_rng_128(&mut rng);
+    let challenger = MyChallenger::new(poseidon);
+    DomainSeparator::new(vec![]).to_prover_state(challenger)
+}
+
+fn generate_poly(num_vars: usize) -> EvaluationsList<F> {
+    let mut rng = StdRng::seed_from_u64(1 + num_vars as u64);
+    EvaluationsList::new((0..1 << num_vars).map(|_| rng.random()).collect())
+}
+
+/// Helper to generate an initial statement with a few constraints.
+fn generate_statement<C>(
+    prover: &mut ProverState<F, EF, C>,
+    num_vars: usize,
+    poly: &EvaluationsList<F>,
+    num_constraints: usize,
+) -> EqStatement<EF>
+where
+    C: FieldChallenger<F> + GrindingChallenger<Witness = F>,
+{
+    let mut statement = EqStatement::initialize(num_vars);
+    for _ in 0..num_constraints {
+        let point = MultilinearPoint::expand_from_univariate(prover.sample(), num_vars);
+        statement.add_unevaluated_constraint_hypercube(point, poly);
+    }
+    statement
+}
+
+fn bench_sumcheck_prover_svo(c: &mut Criterion) {
+    let mut group = c.benchmark_group("SumcheckProver");
+    // Use a smaller sample size for long-running benchmarks
+    group.sample_size(10);
+
+    // Define the range of variable counts to benchmark.
+    for num_vars in &[16, 18, 20, 22, 24] {
+        // Generate a large polynomial to use for this set of benchmarks.
+        let poly = generate_poly(*num_vars);
+
+        let mut prover = setup_prover();
+        let statement = generate_statement(&mut prover, *num_vars, &poly, 3);
+        let constraint = Constraint::new_eq_only(prover.sample(), statement.clone());
+
+        group.bench_with_input(BenchmarkId::new("Classic", *num_vars), &poly, |b, poly| {
+            b.iter(|| {
+                SumcheckSingle::from_base_evals(poly, &mut prover, *num_vars, 0, &constraint);
+            });
+        });
+        group.bench_with_input(BenchmarkId::new("SVO", *num_vars), &poly, |b, poly| {
+            b.iter(|| {
+                SumcheckSingle::from_base_evals_svo(poly, &mut prover, *num_vars, 0, &constraint);
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_sumcheck_prover_svo);
+criterion_main!(benches);

src/poly/evals.rs

@@ -255,6 +255,32 @@ where
         }
     }
 
+    #[inline]
+    pub fn compress_svo(&mut self, r: F) {
+        assert_ne!(self.num_variables(), 0);
+        let mid = self.num_evals() / 2;
+        // For large inputs, we use a parallel, out-of-place strategy.
+        if self.num_evals() >= PARALLEL_THRESHOLD {
+            let (left, right) = self.0.split_at_mut(mid);
+            left.par_iter_mut()
+                .zip(right.par_iter())
+                .for_each(|(p0_mut, &p1)| {
+                    // Read the original p0 value
+                    let p0 = *p0_mut;
+                    // Compute the new value and write it back to the left half.
+                    *p0_mut = r * (p1 - p0) + p0;
+                });
+        } else {
+            // For smaller inputs, we use a sequential, in-place strategy.
+            for i in 0..mid {
+                let p0 = self.0[i];
+                let p1 = self.0[mid + i];
+                self.0[i] = r * (p1 - p0) + p0;
+            }
+        }
+        self.0.truncate(mid);
+    }
+
     /// Folds a list of evaluations from a base field `F` into an extension field `EF`.
     ///
     /// ## Arguments

src/sumcheck/mod.rs

@@ -1,6 +1,8 @@
 pub mod sumcheck_polynomial;
 pub mod sumcheck_single;
 pub mod sumcheck_single_skip;
+pub mod sumcheck_single_svo;
+pub mod sumcheck_small_value;
 #[cfg(test)]
 mod tests;
 pub mod utils;

src/sumcheck/sumcheck_single.rs

@@ -47,6 +47,7 @@ where
 {
     // Compute the quadratic sumcheck polynomial for the current variable.
     let sumcheck_poly = compute_sumcheck_polynomial(evals, weights, *sum);
+
     prover_state.add_extension_scalar(sumcheck_poly.evaluations()[0]);
     prover_state.add_extension_scalar(sumcheck_poly.evaluations()[1]);
     prover_state.add_extension_scalar(sumcheck_poly.evaluations()[2]);
@@ -227,6 +228,14 @@ where
     F: Field + Ord,
     EF: ExtensionField<F>,
 {
+    pub const fn new(evals: EvaluationsList<EF>, weights: EvaluationsList<EF>, sum: EF) -> Self {
+        Self {
+            evals,
+            weights,
+            sum,
+            phantom: std::marker::PhantomData,
+        }
+    }
     /// Constructs a new `SumcheckSingle` instance from evaluations in the extension field.
     ///
     /// This function:

src/sumcheck/sumcheck_single_svo.rs

@@ -0,0 +1,67 @@
+use p3_challenger::{FieldChallenger, GrindingChallenger};
+use p3_field::{ExtensionField, Field, TwoAdicField};
+
+use crate::{
+    fiat_shamir::prover::ProverState,
+    poly::{evals::EvaluationsList, multilinear::MultilinearPoint},
+    sumcheck::{
+        sumcheck_single::SumcheckSingle,
+        sumcheck_small_value::{algorithm_5, fold_evals_with_challenges, svo_three_rounds},
+    },
+    whir::constraints::evaluator::Constraint,
+};
+
+impl<F, EF> SumcheckSingle<F, EF>
+where
+    F: Field + Ord,
+    EF: ExtensionField<F>,
+{
+    /// Compute a Sumcheck using the Small Value Optimization (SVO) for the first three rounds and
+    /// Algorithm 5 (page 18) for the remaining rounds.
+    /// See Algorithm 6 (page 19) in <https://eprint.iacr.org/2025/1117>.
+    pub fn from_base_evals_svo<Challenger>(
+        evals: &EvaluationsList<F>,
+        prover_state: &mut ProverState<F, EF, Challenger>,
+        folding_factor: usize,
+        pow_bits: usize,
+        constraint: &Constraint<F, EF>,
+    ) -> (Self, MultilinearPoint<EF>)
+    where
+        F: TwoAdicField,
+        EF: TwoAdicField,
+        Challenger: FieldChallenger<F> + GrindingChallenger<Witness = F>,
+    {
+        assert_ne!(folding_factor, 0);
+        let mut challenges = Vec::with_capacity(folding_factor);
+
+        // Here we are assuming the the equality statement has only one constraint.
+        // TODO: Handle multiple constraints for a general WHIR implementation.
+        let mut sum = constraint.eq_statement.evaluations[0];
+        let w = &constraint.eq_statement.points[0];
+
+        let (r_1, r_2, r_3) = svo_three_rounds(prover_state, evals, w, &mut sum, pow_bits);
+        #[allow(clippy::tuple_array_conversions)]
+        challenges.extend([r_1, r_2, r_3]);
+
+        // We fold to obtaind p(r1, r2, r3, x).
+        let mut folded_evals = fold_evals_with_challenges(evals, &challenges);
+
+        algorithm_5(
+            prover_state,
+            &mut folded_evals,
+            w,
+            &mut challenges,
+            &mut sum,
+            pow_bits,
+        );
+
+        let challenge_point = MultilinearPoint::new(challenges);
+
+        // Final weight: eq(w, r)
+        let weights = EvaluationsList::new(vec![w.eq_poly(&challenge_point)]);
+
+        let sumcheck = Self::new(folded_evals, weights, sum);
+
+        (sumcheck, challenge_point)
+    }
+}