feat: PCS accumulator support for quark grand products (#461)

* feat: PCS accumulator support for quark grand products

* fix evm verifier build

jolt-core/src/jolt/vm/timestamp_range_check.rs

@@ -557,6 +557,7 @@ impl<F: JoltField, PCS: CommitmentScheme<Field = F>> BatchedGrandProduct<F, PCS>
 
     fn prove_grand_product(
         &mut self,
+        _opening_accumulator: Option<&mut ProverOpeningAccumulator<F>>,
         _transcript: &mut ProofTranscript,
         _setup: Option<&PCS::Setup>,
     ) -> (BatchedGrandProductProof<PCS>, Vec<F>) {
@@ -565,6 +566,7 @@ impl<F: JoltField, PCS: CommitmentScheme<Field = F>> BatchedGrandProduct<F, PCS>
     fn verify_grand_product(
         _proof: &BatchedGrandProductProof<PCS>,
         _claims: &Vec<F>,
+        _opening_accumulator: Option<&mut VerifierOpeningAccumulator<F, PCS>>,
         _transcript: &mut ProofTranscript,
         _setup: Option<&PCS::Setup>,
     ) -> (Vec<F>, Vec<F>) {
@@ -601,6 +603,7 @@ where
             TimestampValidityProof::prove_grand_products(
                 polynomials,
                 jolt_polynomials,
+                opening_accumulator,
                 transcript,
                 generators,
             );
@@ -652,6 +655,7 @@ where
     fn prove_grand_products(
         polynomials: &TimestampRangeCheckPolynomials<F>,
         jolt_polynomials: &JoltPolynomials<F>,
+        opening_accumulator: &mut ProverOpeningAccumulator<F>,
         transcript: &mut ProofTranscript,
         setup: &PCS::Setup,
     ) -> (BatchedGrandProductProof<PCS>, MultisetHashes<F>, Vec<F>) {
@@ -688,7 +692,7 @@ where
         multiset_hashes.append_to_transcript(transcript);
 
         let (batched_grand_product, r_grand_product) =
-            batched_circuit.prove_grand_product(transcript, Some(setup));
+            batched_circuit.prove_grand_product(Some(opening_accumulator), transcript, Some(setup));
 
         drop_in_background_thread(batched_circuit);
 
@@ -725,6 +729,7 @@ where
             BatchedDenseGrandProduct::verify_grand_product(
                 &self.batched_grand_product,
                 &concatenated_hashes,
+                Some(opening_accumulator),
                 transcript,
                 Some(generators),
             );

jolt-core/src/lasso/memory_checking.rs

@@ -239,6 +239,7 @@ where
             preprocessing,
             polynomials,
             jolt_polynomials,
+            opening_accumulator,
             transcript,
             pcs_setup,
         );
@@ -268,6 +269,7 @@ where
         preprocessing: &Self::Preprocessing,
         polynomials: &Self::Polynomials,
         jolt_polynomials: &JoltPolynomials<F>,
+        opening_accumulator: &mut ProverOpeningAccumulator<F>,
         transcript: &mut ProofTranscript,
         pcs_setup: &PCS::Setup,
     ) -> (
@@ -295,10 +297,16 @@ where
         Self::check_multiset_equality(preprocessing, &multiset_hashes);
         multiset_hashes.append_to_transcript(transcript);
 
-        let (read_write_grand_product, r_read_write) =
-            read_write_circuit.prove_grand_product(transcript, Some(pcs_setup));
-        let (init_final_grand_product, r_init_final) =
-            init_final_circuit.prove_grand_product(transcript, Some(pcs_setup));
+        let (read_write_grand_product, r_read_write) = read_write_circuit.prove_grand_product(
+            Some(opening_accumulator),
+            transcript,
+            Some(pcs_setup),
+        );
+        let (init_final_grand_product, r_init_final) = init_final_circuit.prove_grand_product(
+            Some(opening_accumulator),
+            transcript,
+            Some(pcs_setup),
+        );
 
         drop_in_background_thread(read_write_circuit);
         drop_in_background_thread(init_final_circuit);
@@ -523,12 +531,14 @@ where
         let (claims_read_write, r_read_write) = Self::ReadWriteGrandProduct::verify_grand_product(
             &proof.read_write_grand_product,
             &read_write_hashes,
+            Some(opening_accumulator),
             transcript,
             Some(pcs_setup),
         );
         let (claims_init_final, r_init_final) = Self::InitFinalGrandProduct::verify_grand_product(
             &proof.init_final_grand_product,
             &init_final_hashes,
+            Some(opening_accumulator),
             transcript,
             Some(pcs_setup),
         );

jolt-core/src/poly/opening_proof.rs

@@ -105,7 +105,7 @@ pub struct VerifierOpeningAccumulator<F: JoltField, PCS: CommitmentScheme<Field
     #[cfg(test)]
     /// In testing, the Jolt verifier may be provided the prover's openings so that we
     /// can detect any places where the openings don't match up.
-    prover_openings: Vec<ProverOpening<F>>,
+    prover_openings: Option<Vec<ProverOpening<F>>>,
     #[cfg(test)]
     pcs_setup: Option<PCS::Setup>,
 }
@@ -449,7 +449,7 @@ impl<F: JoltField, PCS: CommitmentScheme<Field = F>> VerifierOpeningAccumulator<
         Self {
             openings: vec![],
             #[cfg(test)]
-            prover_openings: vec![],
+            prover_openings: None,
             #[cfg(test)]
             pcs_setup: None,
         }
@@ -463,7 +463,7 @@ impl<F: JoltField, PCS: CommitmentScheme<Field = F>> VerifierOpeningAccumulator<
         prover_openings: ProverOpeningAccumulator<F>,
         pcs_setup: &PCS::Setup,
     ) {
-        self.prover_openings = prover_openings.openings;
+        self.prover_openings = Some(prover_openings.openings);
         self.pcs_setup = Some(pcs_setup.clone());
     }
 
@@ -501,8 +501,11 @@ impl<F: JoltField, PCS: CommitmentScheme<Field = F>> VerifierOpeningAccumulator<
         let joint_commitment = PCS::combine_commitments(commitments, &rho_powers);
 
         #[cfg(test)]
-        {
-            let prover_opening = &self.prover_openings[self.openings.len()];
+        'test: {
+            if self.prover_openings.is_none() {
+                break 'test;
+            }
+            let prover_opening = &self.prover_openings.as_ref().unwrap()[self.openings.len()];
             assert_eq!(
                 prover_opening.batch.len(),
                 commitments.len(),

jolt-core/src/subprotocols/grand_product.rs

@@ -3,6 +3,7 @@ use super::sumcheck::{BatchedCubicSumcheck, SumcheckInstanceProof};
 use crate::field::{JoltField, OptimizedMul};
 use crate::poly::commitment::commitment_scheme::CommitmentScheme;
 use crate::poly::eq_poly::EqPolynomial;
+use crate::poly::opening_proof::{ProverOpeningAccumulator, VerifierOpeningAccumulator};
 use crate::poly::{dense_mlpoly::DensePolynomial, unipoly::UniPoly};
 use crate::utils::math::Math;
 use crate::utils::thread::drop_in_background_thread;
@@ -58,6 +59,7 @@ pub trait BatchedGrandProduct<F: JoltField, PCS: CommitmentScheme<Field = F>>: S
     #[tracing::instrument(skip_all, name = "BatchedGrandProduct::prove_grand_product")]
     fn prove_grand_product(
         &mut self,
+        _opening_accumulator: Option<&mut ProverOpeningAccumulator<F>>,
         transcript: &mut ProofTranscript,
         _setup: Option<&PCS::Setup>,
     ) -> (BatchedGrandProductProof<PCS>, Vec<F>) {
@@ -183,6 +185,7 @@ pub trait BatchedGrandProduct<F: JoltField, PCS: CommitmentScheme<Field = F>>: S
     fn verify_grand_product(
         proof: &BatchedGrandProductProof<PCS>,
         claims: &Vec<F>,
+        _opening_accumulator: Option<&mut VerifierOpeningAccumulator<F, PCS>>,
         transcript: &mut ProofTranscript,
         _setup: Option<&PCS::Setup>,
     ) -> (Vec<F>, Vec<F>) {
@@ -1576,12 +1579,17 @@ mod grand_product_tests {
             Fr,
             Zeromorph<Bn254>,
         >>::prove_grand_product(
-            &mut batched_circuit, &mut transcript, None
+            &mut batched_circuit, None, &mut transcript, None
         );
 
         let mut transcript: ProofTranscript = ProofTranscript::new(b"test_transcript");
-        let (_, r_verifier) =
-            BatchedDenseGrandProduct::verify_grand_product(&proof, &claims, &mut transcript, None);
+        let (_, r_verifier) = BatchedDenseGrandProduct::verify_grand_product(
+            &proof,
+            &claims,
+            None,
+            &mut transcript,
+            None,
+        );
         assert_eq!(r_prover, r_verifier);
     }