Remove claim from Prover trait

benches/provers.rs

@@ -7,7 +7,6 @@ use efficient_sumcheck::{
     multilinear::TimeProver,
     multilinear_product::TimeProductProver,
     prover::{ProductProverConfig, Prover, ProverConfig},
-    streams::multivariate_product_claim,
     tests::{BenchStream, F128},
     ProductSumcheck, Sumcheck,
 };
@@ -29,9 +28,7 @@ fn time_prover_bench(c: &mut Criterion) {
                 let stream = BenchStream::<F128>::new(num_vars);
                 TimeProver::<F128, BenchStream<F128>>::new(
                     <TimeProver<F128, BenchStream<F128>> as Prover<F128>>::ProverConfig::default(
-                        stream.claimed_sum,
-                        num_vars,
-                        stream,
+                        num_vars, stream,
                     ),
                 )
             },
@@ -54,9 +51,7 @@ fn time_product_prover_bench(c: &mut Criterion) {
                 let stream = BenchStream::<F128>::new(num_vars);
                 let streams: Vec<BenchStream<F128>> = vec![stream.clone(), stream.clone()];
                 TimeProductProver::<F128, BenchStream<F128>>::new(ProductProverConfig::default(
-                    multivariate_product_claim(streams.clone()),
-                    num_vars,
-                    streams,
+                    num_vars, streams,
                 ))
             },
             |mut prover: TimeProductProver<F128, BenchStream<F128>>| {

benches/sumcheck-benches/Cargo.toml

@@ -9,7 +9,7 @@ ark-poly = "0.5.0"
 ark-serialize = "0.5.0"
 ark-std ="0.5.0"
 ark-bn254 = "0.5.0"
-efficient-sumcheck = { path = "../../." }
+efficient-sumcheck = { path = "../../.", default-features = false }
 
 [profile.release]
 debug = true

benches/sumcheck-benches/run_benches.sh

@@ -2,7 +2,7 @@
 
 # We measure (i) wall time; and (ii) maximum resident set size, using the GNU-time facility.
 
-algorithms="Blendy2 VSBW Blendy1 Blendy3 Blendy4 CTY ProductBlendy2 ProductVSBW ProductCTY"
+algorithms="VSBW Blendy2 Blendy1 Blendy3 Blendy4 CTY ProductBlendy2 ProductVSBW ProductCTY"
 fields="Field64 Field128 FieldBn254"
 
 for algorithm in $algorithms; do

benches/sumcheck-benches/src/main.rs

@@ -1,20 +1,16 @@
-use ark_bn254::Fr as BN254Field;
 use ark_ff::Field;
 
 use efficient_sumcheck::{
-    hypercube::Hypercube,
     multilinear::{
-        BlendyProver, BlendyProverConfig, SpaceProver, SpaceProverConfig, TimeProver,
+        BlendyProver, BlendyProverConfig, ReduceMode, SpaceProver, SpaceProverConfig, TimeProver,
         TimeProverConfig,
     },
     multilinear_product::{
-        BlendyProductProver, BlendyProductProverConfig, TimeProductProver, TimeProductProverConfig, SpaceProductProver,
-        SpaceProductProverConfig,
+        BlendyProductProver, BlendyProductProverConfig, SpaceProductProver,
+        SpaceProductProverConfig, TimeProductProver, TimeProductProverConfig,
     },
-    order_strategy::SignificantBitOrder,
     prover::{Prover, ProverConfig},
-    streams::{multivariate_claim, multivariate_product_claim},
-    tests::{BenchStream, F128, F64}, // SmallGoldilocks as F64
+    tests::{BenchStream, F128, F64},
     ProductSumcheck, Sumcheck,
 };
 
@@ -29,24 +25,19 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
     match bench_args.algorithm_label {
         AlgorithmLabel::Blendy => {
             let config: BlendyProverConfig<F, BenchStream<F>> =
-                BlendyProverConfig::<F, BenchStream<F>>::default(
-                    multivariate_claim(s.clone()),
-                    bench_args.num_variables,
-                    s,
-                );
-            let transcript =
-                Sumcheck::<F>::prove::<BenchStream<F>, BlendyProver<F, BenchStream<F>>>(
-                    &mut BlendyProver::<F, BenchStream<F>>::new(config),
-                    &mut rng,
-                );
+                BlendyProverConfig::<F, BenchStream<F>>::default(bench_args.num_variables, s);
+            let transcript = Sumcheck::<F>::prove::<BenchStream<F>, BlendyProver<F, BenchStream<F>>>(
+                &mut BlendyProver::<F, BenchStream<F>>::new(config),
+                &mut rng,
+            );
             assert!(transcript.is_accepted);
         }
         AlgorithmLabel::VSBW => {
             let config: TimeProverConfig<F, BenchStream<F>> =
-                TimeProverConfig::<F, BenchStream<F>>::default(
-                    multivariate_claim(s.clone()),
+                TimeProverConfig::<F, BenchStream<F>>::new(
                     bench_args.num_variables,
                     s,
+                    ReduceMode::Pairwise,
                 );
             let transcript = Sumcheck::<F>::prove::<BenchStream<F>, TimeProver<F, BenchStream<F>>>(
                 &mut TimeProver::<F, BenchStream<F>>::new(config),
@@ -56,11 +47,7 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
         }
         AlgorithmLabel::CTY => {
             let config: SpaceProverConfig<F, BenchStream<F>> =
-                SpaceProverConfig::<F, BenchStream<F>>::default(
-                    multivariate_claim(s.clone()),
-                    bench_args.num_variables,
-                    s,
-                );
+                SpaceProverConfig::<F, BenchStream<F>>::default(bench_args.num_variables, s);
             let transcript = Sumcheck::<F>::prove::<BenchStream<F>, SpaceProver<F, BenchStream<F>>>(
                 &mut SpaceProver::<F, BenchStream<F>>::new(config),
                 &mut rng,
@@ -69,11 +56,10 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
         }
         AlgorithmLabel::ProductVSBW => {
             let config: TimeProductProverConfig<F, BenchStream<F>> =
-                TimeProductProverConfig::<F, BenchStream<F>> {
-                    claim: multivariate_product_claim(vec![s.clone(), s.clone()]),
-                    num_variables: bench_args.num_variables,
-                    streams: vec![s.clone(), s],
-                };
+                TimeProductProverConfig::<F, BenchStream<F>>::new(
+                    bench_args.num_variables,
+                    vec![s.clone(), s],
+                );
             let transcript = ProductSumcheck::<F>::prove::<
                 BenchStream<F>,
                 TimeProductProver<F, BenchStream<F>>,
@@ -85,12 +71,11 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
         }
         AlgorithmLabel::ProductBlendy => {
             let config: BlendyProductProverConfig<F, BenchStream<F>> =
-                BlendyProductProverConfig::<F, BenchStream<F>> {
-                    claim: multivariate_product_claim(vec![s.clone(), s.clone()]),
-                    num_variables: bench_args.num_variables,
-                    num_stages: bench_args.stage_size,
-                    streams: vec![s.clone(), s],
-                };
+                BlendyProductProverConfig::<F, BenchStream<F>>::new(
+                    bench_args.num_variables,
+                    bench_args.stage_size,
+                    vec![s.clone(), s],
+                );
             let transcript = ProductSumcheck::<F>::prove::<
                 BenchStream<F>,
                 BlendyProductProver<F, BenchStream<F>>,
@@ -102,11 +87,10 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
         }
         AlgorithmLabel::ProductCTY => {
             let config: SpaceProductProverConfig<F, BenchStream<F>> =
-                SpaceProductProverConfig::<F, BenchStream<F>> {
-                    claim: multivariate_product_claim(vec![s.clone(), s.clone()]),
-                    num_variables: bench_args.num_variables,
-                    streams: vec![s.clone(), s],
-                };
+                SpaceProductProverConfig::<F, BenchStream<F>>::new(
+                    bench_args.num_variables,
+                    vec![s.clone(), s],
+                );
             let transcript = ProductSumcheck::<F>::prove::<
                 BenchStream<F>,
                 SpaceProductProver<F, BenchStream<F>>,

src/multilinear/mod.rs

@@ -4,6 +4,6 @@ mod sumcheck;
 pub use provers::{
     blendy::{BlendyProver, BlendyProverConfig},
     space::{SpaceProver, SpaceProverConfig},
-    time::{ReduceMode, TimeProver, TimeProverConfig},
+    time::{reductions, ReduceMode, TimeProver, TimeProverConfig},
 };
 pub use sumcheck::Sumcheck;

src/multilinear/provers/blendy/config.rs

@@ -1,4 +1,5 @@
 use ark_ff::Field;
+use ark_std::marker::PhantomData;
 
 use crate::{prover::ProverConfig, streams::Stream};
 
@@ -9,32 +10,32 @@ where
 {
     pub num_stages: usize,
     pub num_variables: usize,
-    pub claim: F,
     pub stream: S,
+    _f: PhantomData<F>,
 }
 
 impl<F, S> BlendyProverConfig<F, S>
 where
     F: Field,
     S: Stream<F>,
 {
-    pub fn new(claim: F, num_stages: usize, num_variables: usize, stream: S) -> Self {
+    pub fn new(num_stages: usize, num_variables: usize, stream: S) -> Self {
         Self {
-            claim,
             num_stages,
             num_variables,
             stream,
+            _f: PhantomData::<F>,
         }
     }
 }
 
 impl<F: Field, S: Stream<F>> ProverConfig<F, S> for BlendyProverConfig<F, S> {
-    fn default(claim: F, num_variables: usize, stream: S) -> Self {
+    fn default(num_variables: usize, stream: S) -> Self {
         Self {
-            claim,
             num_stages: 2, // DEFAULT
             num_variables,
             stream,
+            _f: PhantomData::<F>,
         }
     }
 }

src/multilinear/provers/blendy/core.rs

@@ -16,7 +16,6 @@ where
     F: Field,
     S: Stream<F>,
 {
-    pub claimed_sum: F,
     pub current_round: usize,
     pub evaluation_stream: S,
     pub lag_polys: Vec<F>,

src/multilinear/provers/blendy/prover.rs

@@ -21,7 +21,6 @@ where
     fn new(prover_config: Self::ProverConfig) -> Self {
         let stage_size: usize = prover_config.num_variables / prover_config.num_stages;
         Self {
-            claimed_sum: prover_config.claim,
             current_round: 0,
             evaluation_stream: prover_config.stream,
             num_stages: prover_config.num_stages,
@@ -62,10 +61,6 @@ where
         // Return the computed polynomial sums
         Some(sums)
     }
-
-    fn claim(&self) -> F {
-        self.claimed_sum
-    }
 }
 
 #[cfg(test)]

src/multilinear/provers/space/config.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use ark_ff::Field;
 
 use crate::{
@@ -11,40 +13,40 @@ where
     S: Stream<F>,
 {
     pub num_variables: usize,
-    pub claim: F,
     pub streams: Vec<S>,
+    _f: PhantomData<F>,
 }
 
 impl<F, S> SpaceProverConfig<F, S>
 where
     F: Field,
     S: Stream<F>,
 {
-    pub fn new(claim: F, num_variables: usize, stream: S) -> Self {
+    pub fn new(num_variables: usize, stream: S) -> Self {
         Self {
-            claim,
             num_variables,
             streams: vec![stream],
+            _f: PhantomData::<F>,
         }
     }
 }
 
 impl<F: Field, S: Stream<F>> ProverConfig<F, S> for SpaceProverConfig<F, S> {
-    fn default(claim: F, num_variables: usize, stream: S) -> Self {
+    fn default(num_variables: usize, stream: S) -> Self {
         Self {
-            claim,
             num_variables,
             streams: vec![stream],
+            _f: PhantomData::<F>,
         }
     }
 }
 
 impl<F: Field, S: Stream<F>> BatchProverConfig<F, S> for SpaceProverConfig<F, S> {
-    fn default(claim: F, num_variables: usize, streams: Vec<S>) -> Self {
+    fn default(num_variables: usize, streams: Vec<S>) -> Self {
         Self {
-            claim,
             num_variables,
             streams,
+            _f: PhantomData::<F>,
         }
     }
 }