[Experiment] new crates subprotocols

Cargo.toml

@@ -11,6 +11,7 @@ members = [
   "multilinear_extensions",
   "sumcheck_macro",
   "poseidon",
+  "subprotocols",
   "sumcheck",
   "transcript",
   "whir",

subprotocols/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+categories.workspace = true
+description = "Subprotocols"
+edition.workspace = true
+keywords.workspace = true
+license.workspace = true
+name = "subprotocols"
+readme.workspace = true
+repository.workspace = true
+version.workspace = true
+
+[dependencies]
+ark-std = { version = "0.5" }
+ff_ext = { path = "../ff_ext" }
+itertools.workspace = true
+multilinear_extensions = { version = "0.1.0", path = "../multilinear_extensions" }
+p3-field.workspace = true
+rand.workspace = true
+rayon.workspace = true
+serde.workspace = true
+thiserror = "1"
+transcript = { path = "../transcript" }
+
+[dev-dependencies]
+criterion.workspace = true
+p3-goldilocks.workspace = true
+
+[[bench]]
+harness = false
+name = "expr_based_logup"

subprotocols/benches/expr_based_logup.rs

@@ -0,0 +1,144 @@
+use std::{array, time::Duration};
+
+use ark_std::test_rng;
+use criterion::*;
+use ff_ext::FromUniformBytes;
+use itertools::Itertools;
+use p3_field::extension::BinomialExtensionField;
+use p3_goldilocks::Goldilocks;
+use subprotocols::{
+    expression::{Constant, Expression, Witness},
+    sumcheck::SumcheckProverState,
+    test_utils::{random_point, random_poly},
+    zerocheck::ZerocheckProverState,
+};
+use transcript::BasicTranscript as Transcript;
+
+criterion_group!(benches, zerocheck_fn, sumcheck_fn);
+criterion_main!(benches);
+
+const NUM_SAMPLES: usize = 10;
+const NV: [usize; 2] = [25, 26];
+
+fn sumcheck_fn(c: &mut Criterion) {
+    type E = BinomialExtensionField<Goldilocks, 2>;
+
+    for nv in NV {
+        // expand more input size once runtime is acceptable
+        let mut group = c.benchmark_group(format!("logup_sumcheck_nv_{}", nv));
+        group.sample_size(NUM_SAMPLES);
+
+        // Benchmark the proving time
+        group.bench_function(
+            BenchmarkId::new("prove_sumcheck", format!("sumcheck_nv_{}", nv)),
+            |b| {
+                b.iter_custom(|iters| {
+                    let mut time = Duration::new(0, 0);
+                    for _ in 0..iters {
+                        let mut rng = test_rng();
+                        // Initialize logup expression.
+                        let eq = Expression::Wit(Witness::EqPoly(0));
+                        let beta = Expression::Const(Constant::Challenge(0));
+                        let [d0, d1, n0, n1] =
+                            array::from_fn(|i| Expression::Wit(Witness::ExtPoly(i)));
+                        let expr = eq * (d0.clone() * d1.clone() + beta * (d0 * n1 + d1 * n0));
+
+                        // Randomly generate point and witness.
+                        let point = random_point(&mut rng, nv);
+
+                        let d0 = random_poly(&mut rng, nv);
+                        let d1 = random_poly(&mut rng, nv);
+                        let n0 = random_poly(&mut rng, nv);
+                        let n1 = random_poly(&mut rng, nv);
+                        let mut ext_mles = [d0.clone(), d1.clone(), n0.clone(), n1.clone()];
+
+                        let challenges = vec![E::random(&mut rng)];
+
+                        let ext_mle_refs =
+                            ext_mles.iter_mut().map(|v| v.as_mut_slice()).collect_vec();
+
+                        let mut prover_transcript = Transcript::new(b"test");
+                        let prover = SumcheckProverState::new(
+                            expr,
+                            &[&point],
+                            ext_mle_refs,
+                            vec![],
+                            &challenges,
+                            &mut prover_transcript,
+                        );
+
+                        let instant = std::time::Instant::now();
+                        let _ = black_box(prover.prove());
+                        let elapsed = instant.elapsed();
+                        time += elapsed;
+                    }
+
+                    time
+                });
+            },
+        );
+
+        group.finish();
+    }
+}
+
+fn zerocheck_fn(c: &mut Criterion) {
+    type E = BinomialExtensionField<Goldilocks, 2>;
+
+    for nv in NV {
+        // expand more input size once runtime is acceptable
+        let mut group = c.benchmark_group(format!("logup_sumcheck_nv_{}", nv));
+        group.sample_size(NUM_SAMPLES);
+
+        // Benchmark the proving time
+        group.bench_function(
+            BenchmarkId::new("prove_sumcheck", format!("sumcheck_nv_{}", nv)),
+            |b| {
+                b.iter_custom(|iters| {
+                    let mut time = Duration::new(0, 0);
+                    for _ in 0..iters {
+                        // Initialize logup expression.
+                        let mut rng = test_rng();
+                        let beta = Expression::Const(Constant::Challenge(0));
+                        let [d0, d1, n0, n1] =
+                            array::from_fn(|i| Expression::Wit(Witness::ExtPoly(i)));
+                        let expr = d0.clone() * d1.clone() + beta * (d0 * n1 + d1 * n0);
+
+                        // Randomly generate point and witness.
+                        let point = random_point(&mut rng, nv);
+
+                        let d0 = random_poly(&mut rng, nv);
+                        let d1 = random_poly(&mut rng, nv);
+                        let n0 = random_poly(&mut rng, nv);
+                        let n1 = random_poly(&mut rng, nv);
+                        let mut ext_mles = [d0.clone(), d1.clone(), n0.clone(), n1.clone()];
+
+                        let challenges = vec![E::random(&mut rng)];
+
+                        let ext_mle_refs =
+                            ext_mles.iter_mut().map(|v| v.as_mut_slice()).collect_vec();
+
+                        let mut prover_transcript = Transcript::new(b"test");
+                        let prover = ZerocheckProverState::new(
+                            vec![expr],
+                            &[&point],
+                            ext_mle_refs,
+                            vec![],
+                            &challenges,
+                            &mut prover_transcript,
+                        );
+
+                        let instant = std::time::Instant::now();
+                        let _ = black_box(prover.prove());
+                        let elapsed = instant.elapsed();
+                        time += elapsed;
+                    }
+
+                    time
+                });
+            },
+        );
+
+        group.finish();
+    }
+}

subprotocols/examples/zerocheck_logup.rs

@@ -0,0 +1,93 @@
+use std::array;
+
+use ff_ext::{ExtensionField, FromUniformBytes};
+use itertools::{Itertools, izip};
+use p3_field::{PrimeCharacteristicRing, extension::BinomialExtensionField};
+use p3_goldilocks::Goldilocks as F;
+use rand::thread_rng;
+use subprotocols::{
+    expression::{Constant, Expression, Witness},
+    sumcheck::{SumcheckProof, SumcheckProverOutput},
+    test_utils::{random_point, random_poly},
+    utils::eq_vecs,
+    zerocheck::{ZerocheckProverState, ZerocheckVerifierState},
+};
+use transcript::BasicTranscript;
+
+type E = BinomialExtensionField<F, 2>;
+
+fn run_prover<E: ExtensionField>(
+    point: &[E],
+    ext_mles: &mut [Vec<E>],
+    expr: Expression,
+    challenges: Vec<E>,
+) -> SumcheckProof<E> {
+    let timer = std::time::Instant::now();
+    let ext_mle_refs = ext_mles.iter_mut().map(|v| v.as_mut_slice()).collect_vec();
+
+    let mut prover_transcript = BasicTranscript::new(b"test");
+    let prover = ZerocheckProverState::new(
+        vec![expr],
+        &[point],
+        ext_mle_refs,
+        vec![],
+        &challenges,
+        &mut prover_transcript,
+    );
+
+    let SumcheckProverOutput { proof, .. } = prover.prove();
+    println!("Proving time: {:?}", timer.elapsed());
+    proof
+}
+
+fn run_verifier<E: ExtensionField>(
+    proof: SumcheckProof<E>,
+    ans: &E,
+    point: &[E],
+    expr: Expression,
+    challenges: Vec<E>,
+) {
+    let mut verifier_transcript = BasicTranscript::new(b"test");
+    let verifier = ZerocheckVerifierState::new(
+        vec![*ans],
+        vec![expr],
+        vec![],
+        vec![point],
+        proof,
+        &challenges,
+        &mut verifier_transcript,
+    );
+
+    verifier.verify().expect("verification failed");
+}
+
+fn main() {
+    let num_vars = 20;
+    let mut rng = thread_rng();
+
+    // Initialize logup expression.
+    let beta = Expression::Const(Constant::Challenge(0));
+    let [d0, d1, n0, n1] = array::from_fn(|i| Expression::Wit(Witness::ExtPoly(i)));
+    let expr = d0.clone() * d1.clone() + beta * (d0 * n1 + d1 * n0);
+
+    // Randomly generate point and witness.
+    let point = random_point(&mut rng, num_vars);
+
+    let d0 = random_poly(&mut rng, num_vars);
+    let d1 = random_poly(&mut rng, num_vars);
+    let n0 = random_poly(&mut rng, num_vars);
+    let n1 = random_poly(&mut rng, num_vars);
+    let mut ext_mles = [d0.clone(), d1.clone(), n0.clone(), n1.clone()];
+
+    let challenges = vec![E::random(&mut rng)];
+
+    let proof = run_prover(&point, &mut ext_mles, expr.clone(), challenges.clone());
+
+    let eqs = eq_vecs([point.as_slice()].into_iter(), &[E::ONE]);
+
+    let ans: E = izip!(&eqs[0], &d0, &d1, &n0, &n1)
+        .map(|(eq, d0, d1, n0, n1)| *eq * (*d0 * *d1 + challenges[0] * (*d0 * *n1 + *d1 * *n0)))
+        .sum();
+
+    run_verifier(proof, &ans, &point, expr, challenges);
+}

subprotocols/src/error.rs

@@ -0,0 +1,9 @@
+use thiserror::Error;
+
+use crate::expression::Expression;
+
+#[derive(Clone, Debug, Error)]
+pub enum VerifierError<E> {
+    #[error("Claim not match: expr: {0:?}\n (expr name: {3:?})\n expect: {1:?}, got: {2:?}")]
+    ClaimNotMatch(Expression, E, E, String),
+}