Feature/sumcheck

Cargo.toml

@@ -28,6 +28,7 @@ ark-vesta = {version="0.4.0"}
 ark-bn254 = "0.4.0"
 tracing = { version = "0.1", default-features = false, features = [ "attributes" ] }
 tracing-subscriber = { version = "0.2" }
+criterion = "0.5.1"
 
 [features]
 default = ["parallel", "nova", "hypernova"]
@@ -47,3 +48,7 @@ parallel = [
 # changes done between v0.4.0 and this fix which would break compatibility.
 [patch.crates-io]
 ark-r1cs-std = { git = "https://github.com/arnaucube/ark-r1cs-std-cherry-picked/" }
+
+[[bench]]
+name = "bench_sumcheck"
+harness = false

benches/bench_sumcheck.rs

@@ -0,0 +1,87 @@
+use ark_crypto_primitives::sponge::poseidon::{find_poseidon_ark_and_mds, PoseidonConfig};
+use ark_ff::Field;
+use ark_ff::PrimeField;
+use ark_pallas::{Fr, Projective};
+use ark_poly::{DenseMultilinearExtension, MultilinearExtension};
+use folding_schemes::utils::sum_check::SumCheckGeneric;
+use folding_schemes::{
+    sum_check_unstable,
+    transcript::{poseidon::PoseidonTranscript, Transcript},
+    utils::virtual_polynomial::VirtualPolynomial,
+};
+use std::sync::Arc;
+use std::time::Duration;
+
+pub fn poseidon_test_config<F: PrimeField>() -> PoseidonConfig<F> {
+    let full_rounds = 8;
+    let partial_rounds = 31;
+    let alpha = 5;
+    let rate = 2;
+
+    let (ark, mds) = find_poseidon_ark_and_mds::<F>(
+        F::MODULUS_BIT_SIZE as u64,
+        rate,
+        full_rounds,
+        partial_rounds,
+        0,
+    );
+
+    PoseidonConfig::new(
+        full_rounds as usize,
+        partial_rounds as usize,
+        alpha,
+        mds,
+        ark,
+        rate,
+        1,
+    )
+}
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut rng = ark_std::test_rng();
+    let transcript_config = poseidon_test_config();
+    let n_vars = 20;
+    let poly = DenseMultilinearExtension::<Fr>::rand(n_vars, &mut rng);
+    let virtual_poly = VirtualPolynomial::new_from_mle(&Arc::new(poly.clone()), Fr::ONE);
+
+    c.bench_with_input(
+        BenchmarkId::new("sumcheck unstable [prove]", "some polynomial"),
+        &poly,
+        |b, poly| {
+            b.iter(|| {
+                let mut prover_transcript =
+                    PoseidonTranscript::<Projective>::new(&transcript_config);
+                let mut sumcheck = sum_check_unstable::SumCheck::<Projective>::new(poly);
+                sumcheck.prove(&mut prover_transcript).unwrap()
+            })
+        },
+    );
+
+    c.bench_with_input(
+        BenchmarkId::new("sumcheck hyperplonk [prove]", "some polynomial"),
+        &virtual_poly,
+        |b, virtual_poly| {
+            b.iter(|| {
+                let mut poseidon_transcript_prove: PoseidonTranscript<Projective> =
+                    PoseidonTranscript::<Projective>::new(&transcript_config);
+                let _sum_check =
+                    folding_schemes::sum_check::SumCheck::<
+                        Projective,
+                        PoseidonTranscript<Projective>,
+                    >::prove(virtual_poly, &mut poseidon_transcript_prove)
+                    .unwrap();
+            })
+        },
+    );
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default()
+        .measurement_time(Duration::from_secs(30))
+        .sample_size(100);
+    targets = criterion_benchmark
+);
+criterion_main!(benches);

src/lib.rs

@@ -14,6 +14,8 @@ pub mod decider;
 pub mod folding;
 pub mod frontend;
 pub mod pedersen;
+pub mod sum_check;
+pub mod sum_check_unstable;
 pub mod utils;
 
 #[derive(Debug, Error, PartialEq)]

src/sum_check.rs

@@ -0,0 +1,145 @@
+use crate::transcript::Transcript;
+use crate::utils::sum_check::structs::{
+    IOPProof, IOPProverMessage, IOPProverState, IOPVerifierStateGeneric,
+};
+use crate::utils::sum_check::{
+    SumCheckGeneric, SumCheckProver, SumCheckSubClaim, SumCheckVerifierGeneric,
+};
+use crate::utils::virtual_polynomial::{VPAuxInfo, VirtualPolynomial};
+use ark_crypto_primitives::sponge::Absorb;
+use ark_ec::{CurveGroup, Group};
+use ark_poly::DenseMultilinearExtension;
+use ark_std::fmt::Debug;
+use espresso_subroutines::PolyIOPErrors;
+use std::marker::PhantomData;
+use std::sync::Arc;
+
+#[derive(Clone, Debug, Default, Copy, PartialEq, Eq)]
+pub struct SumCheck<C: CurveGroup, T: Transcript<C>> {
+    #[doc(hidden)]
+    phantom: PhantomData<C>,
+    #[doc(hidden)]
+    phantom2: PhantomData<T>,
+}
+
+impl<C: CurveGroup, T: Transcript<C>> SumCheckGeneric<C> for SumCheck<C, T>
+where
+    <C as ark_ec::Group>::ScalarField: Absorb,
+{
+    type VirtualPolynomial = VirtualPolynomial<C::ScalarField>;
+    type VPAuxInfo = VPAuxInfo<C::ScalarField>;
+    type MultilinearExtension = Arc<DenseMultilinearExtension<C::ScalarField>>;
+    type SumCheckProof = IOPProof<C::ScalarField>;
+    type SumCheckSubClaim = SumCheckSubClaim<C::ScalarField>;
+
+    /// Generate a proof of the sum of polynomial over {0,1}^`num_vars`
+    /// Mutates the transcript in the process
+    fn prove(
+        poly: &VirtualPolynomial<C::ScalarField>,
+        transcript: &mut impl Transcript<C>,
+    ) -> Result<IOPProof<C::ScalarField>, PolyIOPErrors> {
+        transcript.absorb(&<C as Group>::ScalarField::from(
+            poly.aux_info.num_variables as u64,
+        ));
+        transcript.absorb(&<C as Group>::ScalarField::from(
+            poly.aux_info.max_degree as u64,
+        ));
+        let mut prover_state: IOPProverState<C::ScalarField> = IOPProverState::prover_init(poly)?;
+        let mut challenge: Option<C::ScalarField> = None;
+        let mut prover_msgs: Vec<IOPProverMessage<C::ScalarField>> =
+            Vec::with_capacity(poly.aux_info.num_variables);
+        for _ in 0..poly.aux_info.num_variables {
+            let prover_msg: IOPProverMessage<C::ScalarField> =
+                IOPProverState::prove_round_and_update_state(&mut prover_state, &challenge)?;
+            transcript.absorb_vec(&prover_msg.evaluations);
+            prover_msgs.push(prover_msg);
+            challenge = Some(transcript.get_challenge());
+        }
+        if let Some(p) = challenge {
+            prover_state.challenges.push(p)
+        };
+        Ok(IOPProof {
+            point: prover_state.challenges,
+            proofs: prover_msgs,
+        })
+    }
+
+    fn verify(
+        claimed_sum: C::ScalarField,
+        proof: &IOPProof<C::ScalarField>,
+        aux_info: &VPAuxInfo<C::ScalarField>,
+        transcript: &mut impl Transcript<C>,
+    ) -> Result<SumCheckSubClaim<C::ScalarField>, PolyIOPErrors> {
+        transcript.absorb(&<C as Group>::ScalarField::from(
+            aux_info.num_variables as u64,
+        ));
+        transcript.absorb(&<C as Group>::ScalarField::from(aux_info.max_degree as u64));
+        let mut verifier_state = IOPVerifierStateGeneric::verifier_init(aux_info);
+        for i in 0..aux_info.num_variables {
+            let prover_msg = proof.proofs.get(i).expect("proof is incomplete");
+            transcript.absorb_vec(&prover_msg.evaluations);
+            IOPVerifierStateGeneric::verify_round_and_update_state(
+                &mut verifier_state,
+                prover_msg,
+                transcript,
+            )?;
+        }
+
+        IOPVerifierStateGeneric::check_and_generate_subclaim(&verifier_state, &claimed_sum)
+    }
+
+    fn extract_sum(proof: &Self::SumCheckProof) -> C::ScalarField {
+        proof.proofs[0].evaluations[0] + proof.proofs[0].evaluations[1]
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use std::sync::Arc;
+
+    use ark_ff::Field;
+    use ark_pallas::Fr;
+    use ark_pallas::Projective;
+    use ark_poly::DenseMultilinearExtension;
+    use ark_poly::MultilinearExtension;
+    use ark_std::test_rng;
+
+    use crate::transcript::poseidon::tests::poseidon_test_config;
+    use crate::transcript::poseidon::PoseidonTranscript;
+    use crate::transcript::Transcript;
+    use crate::utils::sum_check::SumCheckGeneric;
+    use crate::utils::virtual_polynomial::VirtualPolynomial;
+
+    use super::SumCheck;
+
+    #[test]
+    pub fn sumcheck_poseidon() {
+        let mut rng = test_rng();
+        let poly_mle = DenseMultilinearExtension::rand(5, &mut rng);
+        let virtual_poly = VirtualPolynomial::new_from_mle(&Arc::new(poly_mle), Fr::ONE);
+        let poseidon_config = poseidon_test_config::<Fr>();
+
+        // sum-check prove
+        let mut poseidon_transcript_prove: PoseidonTranscript<Projective> =
+            PoseidonTranscript::<Projective>::new(&poseidon_config);
+        let sum_check = SumCheck::<Projective, PoseidonTranscript<Projective>>::prove(
+            &virtual_poly,
+            &mut poseidon_transcript_prove,
+        )
+        .unwrap();
+
+        // sum-check verify
+        let claimed_sum =
+            SumCheck::<Projective, PoseidonTranscript<Projective>>::extract_sum(&sum_check);
+        let mut poseidon_transcript_verify: PoseidonTranscript<Projective> =
+            PoseidonTranscript::<Projective>::new(&poseidon_config);
+        let res_verify = SumCheck::<Projective, PoseidonTranscript<Projective>>::verify(
+            claimed_sum,
+            &sum_check,
+            &virtual_poly.aux_info,
+            &mut poseidon_transcript_verify,
+        );
+
+        assert!(res_verify.is_ok());
+    }
+}