initial commit

benches/commitments.rs

@@ -0,0 +1,48 @@
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate curve25519_dalek;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use libspartan::commitments::{Commitments, MultiCommitGens};
+use libspartan::math::Math;
+use libspartan::scalar::Scalar;
+use rand::rngs::OsRng;
+
+use criterion::*;
+
+fn commitment_benchmark(c: &mut Criterion) {
+  let mut rng = OsRng;
+  for &s in [20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("commitment_bools");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let gens = MultiCommitGens::new(n, b"test-m");
+    let blind = Scalar::random(&mut rng);
+    let vec: Vec<bool> = vec![true; n];
+    let name = format!("commitment_bools_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| vec.commit(black_box(&blind), black_box(&gens)));
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_commitment;
+config = set_duration();
+targets = commitment_benchmark
+}
+
+criterion_main!(benches_commitment);

benches/dotproduct.rs

@@ -0,0 +1,86 @@
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate curve25519_dalek;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use libspartan::math::Math;
+use libspartan::nizk::DotProductProof;
+use libspartan::scalar::Scalar;
+use libspartan::scalar::ScalarBytes;
+use rand::rngs::OsRng;
+
+use criterion::*;
+
+fn dotproduct_benchmark_dalek(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("dotproduct_benchmark_dalek");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let vec_a = (0..n)
+      .map(|_i| ScalarBytes::random(&mut csprng))
+      .collect::<Vec<ScalarBytes>>();
+    let vec_b = (0..n)
+      .map(|_i| ScalarBytes::random(&mut csprng))
+      .collect::<Vec<ScalarBytes>>();
+
+    let name = format!("dotproduct_dalek_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| compute_dotproduct(black_box(&vec_a), black_box(&vec_b)));
+    });
+    group.finish();
+  }
+}
+
+fn compute_dotproduct(a: &Vec<ScalarBytes>, b: &Vec<ScalarBytes>) -> ScalarBytes {
+  let mut res = ScalarBytes::zero();
+  for i in 0..a.len() {
+    res = &res + &a[i] * &b[i];
+  }
+  res
+}
+
+fn dotproduct_benchmark_opt(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("dotproduct_benchmark_opt");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let vec_a = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    let vec_b = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+
+    let name = format!("dotproduct_opt_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| DotProductProof::compute_dotproduct(black_box(&vec_a), black_box(&vec_b)));
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_dotproduct;
+config = set_duration();
+targets = dotproduct_benchmark_dalek, dotproduct_benchmark_opt
+}
+
+criterion_main!(benches_dotproduct);

benches/polycommit.rs

@@ -0,0 +1,200 @@
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use criterion::*;
+use libspartan::dense_mlpoly::{DensePolynomial, PolyCommitmentGens, PolyEvalProof};
+use libspartan::math::Math;
+use libspartan::scalar::Scalar;
+use libspartan::transcript::ProofTranscript;
+use merlin::Transcript;
+use rand::rngs::OsRng;
+
+fn commit_benchmark(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [4, 8, 12, 14, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("commit_benchmark");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let m = n.square_root();
+    let z = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
+
+    let poly = DensePolynomial::new(z);
+    let gens = PolyCommitmentGens::new(s, b"test-m");
+    let name = format!("polycommit_commit_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| poly.commit(black_box(false), black_box(&gens), black_box(None)));
+    });
+    group.finish();
+  }
+}
+
+fn eval_benchmark(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [4, 8, 12, 14, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("eval_benchmark");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let m = n.square_root();
+    let mut z: Vec<Scalar> = Vec::new();
+    for _ in 0..n {
+      z.push(Scalar::random(&mut csprng));
+    }
+    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
+
+    let poly = DensePolynomial::new(z);
+
+    let mut r: Vec<Scalar> = Vec::new();
+    for _ in 0..s {
+      r.push(Scalar::random(&mut csprng));
+    }
+
+    let name = format!("polycommit_eval_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| poly.evaluate(black_box(&r)));
+    });
+    group.finish();
+  }
+}
+
+fn evalproof_benchmark(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [4, 8, 12, 14, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("evalproof_benchmark");
+    group.plot_config(plot_config);
+
+    let n = (s as usize).pow2();
+    let m = n.square_root();
+    let mut z: Vec<Scalar> = Vec::new();
+    for _ in 0..n {
+      z.push(Scalar::random(&mut csprng));
+    }
+    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
+
+    let poly = DensePolynomial::new(z);
+
+    let gens = PolyCommitmentGens::new(s, b"test-m");
+
+    let mut r: Vec<Scalar> = Vec::new();
+    for _ in 0..s {
+      r.push(Scalar::random(&mut csprng));
+    }
+
+    let eval = poly.evaluate(&r);
+
+    let name = format!("polycommit_evalproof_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut random_tape = {
+          let mut csprng: OsRng = OsRng;
+          let mut tape = Transcript::new(b"proof");
+          tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+          tape
+        };
+        let mut prover_transcript = Transcript::new(b"example");
+        PolyEvalProof::prove(
+          black_box(&poly),
+          black_box(None),
+          black_box(&r),
+          black_box(&eval),
+          black_box(None),
+          black_box(&gens),
+          black_box(&mut prover_transcript),
+          black_box(&mut random_tape),
+        )
+      });
+    });
+    group.finish();
+  }
+}
+
+fn evalproofverify_benchmark(c: &mut Criterion) {
+  let mut csprng: OsRng = OsRng;
+
+  for &s in [4, 8, 12, 14, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("evalproofverify_benchmark");
+    group.plot_config(plot_config);
+
+    let n = s.pow2();
+    let m = n.square_root();
+    let mut z: Vec<Scalar> = Vec::new();
+    for _ in 0..n {
+      z.push(Scalar::random(&mut csprng));
+    }
+    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
+
+    let poly = DensePolynomial::new(z);
+    let gens = PolyCommitmentGens::new(s, b"test-m");
+
+    let mut r: Vec<Scalar> = Vec::new();
+    for _ in 0..s {
+      r.push(Scalar::random(&mut csprng));
+    }
+
+    let (poly_commitment, blinds) = poly.commit(false, &gens, None);
+    let eval = poly.evaluate(&r);
+
+    let mut random_tape = {
+      let mut csprng: OsRng = OsRng;
+      let mut tape = Transcript::new(b"proof");
+      tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+      tape
+    };
+    let mut prover_transcript = Transcript::new(b"example");
+    let (proof, c_zr) = PolyEvalProof::prove(
+      black_box(&poly),
+      black_box(Some(&blinds)),
+      black_box(&r),
+      black_box(&eval),
+      black_box(None),
+      black_box(&gens),
+      black_box(&mut prover_transcript),
+      black_box(&mut random_tape),
+    );
+    let name = format!("polycommit_evalproofverify_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut verifier_transcript = Transcript::new(b"example");
+
+        proof.verify(
+          black_box(&gens),
+          black_box(&mut verifier_transcript),
+          black_box(&r),
+          black_box(&c_zr),
+          black_box(&poly_commitment),
+        )
+      });
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_polycommit;
+config = set_duration();
+targets = commit_benchmark, eval_benchmark, evalproof_benchmark, evalproofverify_benchmark
+}
+
+criterion_main!(benches_polycommit);

benches/r1csproof.rs

@@ -0,0 +1,123 @@
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use libspartan::dense_mlpoly::EqPolynomial;
+use libspartan::math::Math;
+use libspartan::r1csinstance::R1CSInstance;
+use libspartan::r1csproof::{R1CSGens, R1CSProof};
+use libspartan::scalar::Scalar;
+use libspartan::transcript::ProofTranscript;
+use merlin::Transcript;
+use rand::rngs::OsRng;
+
+use criterion::*;
+
+fn prove_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("r1cs_prove_benchmark");
+    group.plot_config(plot_config);
+
+    let num_vars = s.pow2();
+    let num_cons = num_vars;
+    let num_inputs = 10;
+    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
+    let n = inst.get_num_vars();
+
+    let gens = R1CSGens::new(num_cons, num_vars, b"test-m");
+
+    let name = format!("r1cs_prove_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut random_tape = {
+          let mut csprng: OsRng = OsRng;
+          let mut tape = Transcript::new(b"proof");
+          tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+          tape
+        };
+        let mut prover_transcript = Transcript::new(b"example");
+        R1CSProof::prove(
+          black_box(&inst),
+          black_box(vars.clone()),
+          black_box(&input),
+          black_box(&gens),
+          black_box(&mut prover_transcript),
+          black_box(&mut random_tape),
+        )
+      });
+    });
+    group.finish();
+  }
+}
+
+fn verify_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("r1cs_verify_benchmark");
+    group.plot_config(plot_config);
+
+    let num_vars = s.pow2();
+    let num_cons = num_vars;
+    let num_inputs = 10;
+    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
+    let n = inst.get_num_vars();
+    let gens = R1CSGens::new(num_cons, num_vars, b"test-m");
+
+    let mut random_tape = {
+      let mut csprng: OsRng = OsRng;
+      let mut tape = Transcript::new(b"proof");
+      tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+      tape
+    };
+    let mut prover_transcript = Transcript::new(b"example");
+    let (proof, rx, ry) = R1CSProof::prove(
+      &inst,
+      vars,
+      &input,
+      &gens,
+      &mut prover_transcript,
+      &mut random_tape,
+    );
+
+    let eval_table_rx = EqPolynomial::new(rx.clone()).evals();
+    let eval_table_ry = EqPolynomial::new(ry.clone()).evals();
+    let inst_evals = inst.evaluate_with_tables(&eval_table_rx, &eval_table_ry);
+
+    let name = format!("r1cs_verify_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut verifier_transcript = Transcript::new(b"example");
+        assert!(proof
+          .verify(
+            black_box(num_vars),
+            black_box(num_cons),
+            black_box(&input),
+            black_box(&inst_evals),
+            black_box(&mut verifier_transcript),
+            black_box(&gens)
+          )
+          .is_ok());
+      });
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_r1cs;
+config = set_duration();
+targets = prove_benchmark, verify_benchmark
+}
+
+criterion_main!(benches_r1cs);

benches/spartan.rs

@@ -0,0 +1,138 @@
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use libspartan::math::Math;
+use libspartan::r1csinstance::{R1CSCommitmentGens, R1CSInstance};
+use libspartan::r1csproof::R1CSGens;
+use libspartan::spartan::{SpartanGens, SpartanProof};
+use merlin::Transcript;
+
+use criterion::*;
+
+fn encode_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("spartan_encode_benchmark");
+    group.plot_config(plot_config);
+
+    let num_vars = s.pow2();
+    let num_cons = num_vars;
+    let num_inputs = 10;
+    let (inst, _vars, _input) =
+      R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
+    let n = inst.get_num_vars();
+    let m = n.square_root();
+    assert_eq!(n, m * m);
+    let r1cs_size = inst.size();
+    let gens_r1cs = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs");
+
+    let name = format!("spartan_encode_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        SpartanProof::encode(black_box(&inst), black_box(&gens_r1cs));
+      });
+    });
+    group.finish();
+  }
+}
+
+fn prove_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("spartan_prove_benchmark");
+    group.plot_config(plot_config);
+
+    let num_vars = s.pow2();
+    let num_cons = num_vars;
+    let num_inputs = 10;
+
+    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
+    let n = inst.get_num_vars();
+
+    let r1cs_size = inst.size();
+    let gens_r1cs_eval = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs_eval");
+    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
+
+    // produce a proof of satisfiability
+    let (_comm, decomm) = SpartanProof::encode(&inst, &gens_r1cs_eval);
+    let gens = SpartanGens::new(gens_r1cs_sat, gens_r1cs_eval);
+
+    let name = format!("spartan_prove_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut prover_transcript = Transcript::new(b"example");
+        SpartanProof::prove(
+          black_box(&inst),
+          black_box(&decomm),
+          black_box(vars.clone()),
+          black_box(&input),
+          black_box(&gens),
+          black_box(&mut prover_transcript),
+        );
+      });
+    });
+    group.finish();
+  }
+}
+
+fn verify_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("spartan_verify_benchmark");
+    group.plot_config(plot_config);
+
+    let num_vars = s.pow2();
+    let num_cons = num_vars;
+    let num_inputs = 10;
+    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
+    let n = inst.get_num_vars();
+
+    let r1cs_size = inst.size();
+    let gens_r1cs_eval = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs_eval");
+
+    // create a commitment to R1CSInstance
+    let (comm, decomm) = SpartanProof::encode(&inst, &gens_r1cs_eval);
+
+    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
+    let gens = SpartanGens::new(gens_r1cs_sat, gens_r1cs_eval);
+
+    // produce a proof of satisfiability
+    let mut prover_transcript = Transcript::new(b"example");
+    let proof = SpartanProof::prove(&inst, &decomm, vars, &input, &gens, &mut prover_transcript);
+
+    let name = format!("spartan_verify_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut verifier_transcript = Transcript::new(b"example");
+        assert!(proof
+          .verify(
+            black_box(&comm),
+            black_box(&input),
+            black_box(&mut verifier_transcript),
+            black_box(&gens)
+          )
+          .is_ok());
+      });
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_spartan;
+config = set_duration();
+targets = encode_benchmark, prove_benchmark, verify_benchmark
+}
+
+criterion_main!(benches_spartan);

benches/sumcheck.rs

@@ -0,0 +1,162 @@
+#![allow(non_snake_case)]
+
+extern crate byteorder;
+extern crate core;
+extern crate criterion;
+extern crate digest;
+extern crate libspartan;
+extern crate merlin;
+extern crate rand;
+extern crate sha3;
+
+use libspartan::commitments::Commitments;
+use libspartan::commitments::MultiCommitGens;
+use libspartan::dense_mlpoly::DensePolynomial;
+use libspartan::math::Math;
+use libspartan::nizk::DotProductProof;
+use libspartan::scalar::Scalar;
+use libspartan::sumcheck::ZKSumcheckInstanceProof;
+use libspartan::transcript::ProofTranscript;
+use merlin::Transcript;
+use rand::rngs::OsRng;
+
+use criterion::*;
+
+fn prove_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("zksumcheck_prove_benchmark");
+    group.plot_config(plot_config);
+
+    // produce tables
+    let gens_n = MultiCommitGens::new(3, b"test-m");
+    let gens_1 = MultiCommitGens::new(1, b"test-1");
+    let num_rounds = s;
+    let n = s.pow2();
+
+    let mut csprng: OsRng = OsRng;
+
+    let vec_A = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    let vec_B = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    let claim = DotProductProof::compute_dotproduct(&vec_A, &vec_B);
+    let mut poly_A = DensePolynomial::new(vec_A);
+    let mut poly_B = DensePolynomial::new(vec_B);
+
+    let blind_claim = Scalar::random(&mut csprng);
+    let comb_func =
+      |poly_A_comp: &Scalar, poly_B_comp: &Scalar| -> Scalar { poly_A_comp * poly_B_comp };
+
+    let name = format!("zksumcheck_prove_{}", n);
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut random_tape = {
+          let mut csprng: OsRng = OsRng;
+          let mut tape = Transcript::new(b"proof");
+          tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+          tape
+        };
+        let mut prover_transcript = Transcript::new(b"example");
+        ZKSumcheckInstanceProof::prove_quad(
+          black_box(&claim),
+          black_box(&blind_claim),
+          black_box(num_rounds),
+          black_box(&mut poly_A),
+          black_box(&mut poly_B),
+          black_box(comb_func),
+          black_box(&gens_1),
+          black_box(&gens_n),
+          black_box(&mut prover_transcript),
+          black_box(&mut random_tape),
+        )
+      });
+    });
+    group.finish();
+  }
+}
+
+fn verify_benchmark(c: &mut Criterion) {
+  for &s in [10, 12, 16, 20].iter() {
+    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
+    let mut group = c.benchmark_group("zksumcheck_verify_benchmark");
+    group.plot_config(plot_config);
+
+    // produce tables
+    let gens_n = MultiCommitGens::new(3, b"test-m");
+    let gens_1 = MultiCommitGens::new(1, b"test-1");
+    let num_rounds = s;
+    let n = s.pow2();
+
+    let mut csprng: OsRng = OsRng;
+
+    let vec_A = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    let vec_B = (0..n)
+      .map(|_i| Scalar::random(&mut csprng))
+      .collect::<Vec<Scalar>>();
+    let claim = DotProductProof::compute_dotproduct(&vec_A, &vec_B);
+    let mut poly_A = DensePolynomial::new(vec_A);
+    let mut poly_B = DensePolynomial::new(vec_B);
+    let blind_claim = Scalar::random(&mut csprng);
+    let comb_func =
+      |poly_A_comp: &Scalar, poly_B_comp: &Scalar| -> Scalar { poly_A_comp * poly_B_comp };
+
+    let mut random_tape = {
+      let mut csprng: OsRng = OsRng;
+      let mut tape = Transcript::new(b"proof");
+      tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
+      tape
+    };
+
+    let mut prover_transcript = Transcript::new(b"example");
+    let (proof, _r, _v, _blind_post_claim) = ZKSumcheckInstanceProof::prove_quad(
+      &claim,
+      &blind_claim,
+      num_rounds,
+      &mut poly_A,
+      &mut poly_B,
+      comb_func,
+      &gens_1,
+      &gens_n,
+      &mut prover_transcript,
+      &mut random_tape,
+    );
+
+    let name = format!("zksumcheck_verify_{}", n);
+    let degree_bound = 2;
+    let comm_claim = claim.commit(&blind_claim, &gens_1).compress();
+    group.bench_function(&name, move |b| {
+      b.iter(|| {
+        let mut verifier_transcript = Transcript::new(b"example");
+        assert!(proof
+          .verify(
+            black_box(&comm_claim),
+            black_box(num_rounds),
+            black_box(degree_bound),
+            black_box(&gens_1),
+            black_box(&gens_n),
+            black_box(&mut verifier_transcript)
+          )
+          .is_ok())
+      });
+    });
+    group.finish();
+  }
+}
+
+fn set_duration() -> Criterion {
+  Criterion::default().sample_size(10)
+  // .measurement_time(Duration::new(0, 50000000))
+}
+
+criterion_group! {
+name = benches_r1cs;
+config = set_duration();
+targets = verify_benchmark, prove_benchmark
+}
+
+criterion_main!(benches_r1cs);