stage 6

Author: moodlezoup

jolt-core/src/subprotocols/booleanity.rs

@@ -24,12 +24,55 @@ use crate::{
     },
     transcripts::Transcript,
     utils::{expanding_table::ExpandingTable, thread::drop_in_background_thread},
-    zkvm::witness::{CommittedPolynomial, VirtualPolynomial},
+    zkvm::witness::CommittedPolynomial,
 };
 
 /// Degree bound of the sumcheck round polynomials in [`BooleanitySumcheckVerifier`].
 const DEGREE_BOUND: usize = 3;
 
+pub struct BooleanitySumcheckParams<F: JoltField> {
+    /// Number of address chunks
+    pub d: usize,
+    /// Log of chunk size
+    pub log_k_chunk: usize,
+    /// Log of trace length
+    pub log_t: usize,
+    /// Batching challenges
+    pub gammas: Vec<F::Challenge>,
+    /// Address binding point
+    pub r_address: Vec<F::Challenge>,
+    /// Cycle binding point
+    pub r_cycle: Vec<F::Challenge>,
+    /// Polynomial types for opening accumulator
+    pub polynomial_types: Vec<CommittedPolynomial>,
+    /// Sumcheck ID for opening accumulator
+    pub sumcheck_id: SumcheckId,
+}
+
+impl<F: JoltField> SumcheckInstanceParams<F> for BooleanitySumcheckParams<F> {
+    fn degree(&self) -> usize {
+        DEGREE_BOUND
+    }
+
+    fn num_rounds(&self) -> usize {
+        self.log_k_chunk + self.log_t
+    }
+
+    fn input_claim(&self, _accumulator: &dyn OpeningAccumulator<F>) -> F {
+        F::zero()
+    }
+
+    fn normalize_opening_point(
+        &self,
+        sumcheck_challenges: &[F::Challenge],
+    ) -> OpeningPoint<BIG_ENDIAN, F> {
+        let mut opening_point = sumcheck_challenges.to_vec();
+        opening_point[..self.log_k_chunk].reverse();
+        opening_point[self.log_k_chunk..].reverse();
+        opening_point.into()
+    }
+}
+
 /// Unified Booleanity Sumcheck implementation for RAM, Bytecode, and Instruction lookups
 #[derive(Allocative)]
 pub struct BooleanitySumcheckProver<F: JoltField> {
@@ -280,15 +323,13 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceVerifier<F, T> for BooleanityS
             })
             .collect::<Vec<F>>();
 
-        let r_cycle = self.params.get_r_cycle(accumulator);
-
         let combined_r: Vec<F::Challenge> = self
             .params
             .r_address
             .iter()
             .cloned()
             .rev()
-            .chain(r_cycle.iter().cloned().rev())
+            .chain(self.params.r_cycle.iter().cloned().rev())
             .collect();
 
         EqPolynomial::<F>::mle(sumcheck_challenges, &combined_r)
@@ -312,69 +353,3 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceVerifier<F, T> for BooleanityS
         );
     }
 }
-
-impl<F: JoltField> SumcheckInstanceParams<F> for BooleanitySumcheckParams<F> {
-    fn degree(&self) -> usize {
-        DEGREE_BOUND
-    }
-
-    fn num_rounds(&self) -> usize {
-        self.log_k_chunk + self.log_t
-    }
-
-    fn input_claim(&self, _accumulator: &dyn OpeningAccumulator<F>) -> F {
-        F::zero()
-    }
-
-    fn normalize_opening_point(
-        &self,
-        sumcheck_challenges: &[F::Challenge],
-    ) -> OpeningPoint<BIG_ENDIAN, F> {
-        let mut opening_point = sumcheck_challenges.to_vec();
-        opening_point[..self.log_k_chunk].reverse();
-        opening_point[self.log_k_chunk..].reverse();
-        opening_point.into()
-    }
-}
-
-pub struct BooleanitySumcheckParams<F: JoltField> {
-    /// Number of address chunks
-    pub d: usize,
-    /// Log of chunk size
-    pub log_k_chunk: usize,
-    /// Log of trace length
-    pub log_t: usize,
-    /// Batching challenges
-    pub gammas: Vec<F::Challenge>,
-    /// Address binding point
-    pub r_address: Vec<F::Challenge>,
-    /// Cycle binding point
-    pub r_cycle: Vec<F::Challenge>,
-    /// Polynomial types for opening accumulator
-    pub polynomial_types: Vec<CommittedPolynomial>,
-    /// Sumcheck ID for opening accumulator
-    pub sumcheck_id: SumcheckId,
-    /// Optional virtual polynomial for r_cycle
-    pub virtual_poly: Option<VirtualPolynomial>,
-}
-
-impl<F: JoltField> BooleanitySumcheckParams<F> {
-    pub fn num_rounds(&self) -> usize {
-        self.log_k_chunk + self.log_t
-    }
-
-    fn get_r_cycle(&self, accumulator: &dyn OpeningAccumulator<F>) -> Vec<F::Challenge> {
-        if !self.r_cycle.is_empty() {
-            self.r_cycle.clone()
-        } else {
-            let virtual_poly = self
-                .virtual_poly
-                .expect("virtual_poly must be set when r_cycle is empty");
-            accumulator
-                .get_virtual_polynomial_opening(virtual_poly, SumcheckId::SpartanOuter)
-                .0
-                .r
-                .clone()
-        }
-    }
-}

jolt-core/src/subprotocols/hamming_weight.rs

@@ -16,7 +16,8 @@ use crate::{
         unipoly::UniPoly,
     },
     subprotocols::{
-        sumcheck_prover::SumcheckInstanceProver, sumcheck_verifier::SumcheckInstanceVerifier,
+        sumcheck_prover::SumcheckInstanceProver,
+        sumcheck_verifier::{SumcheckInstanceParams, SumcheckInstanceVerifier},
     },
     transcripts::Transcript,
     zkvm::witness::{CommittedPolynomial, VirtualPolynomial},
@@ -25,6 +26,44 @@ use crate::{
 /// Degree bound of the sumcheck round polynomials in [`HammingWeightSumcheckVerifier`].
 const DEGREE_BOUND: usize = 1;
 
+pub struct HammingWeightSumcheckParams<F: JoltField> {
+    pub d: usize,
+    pub num_rounds: usize,
+    pub gamma_powers: Vec<F>,
+    pub polynomial_types: Vec<CommittedPolynomial>,
+    pub sumcheck_id: SumcheckId,
+    pub r_cycle: Vec<F::Challenge>,
+}
+
+impl<F: JoltField> SumcheckInstanceParams<F> for HammingWeightSumcheckParams<F> {
+    fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    fn input_claim(&self, accumulator: &dyn OpeningAccumulator<F>) -> F {
+        if self.sumcheck_id == SumcheckId::RamHammingWeight {
+            let (_, hamming_booleanity_claim) = accumulator.get_virtual_polynomial_opening(
+                VirtualPolynomial::RamHammingWeight,
+                SumcheckId::RamHammingBooleanity,
+            );
+            hamming_booleanity_claim * self.gamma_powers.iter().sum::<F>()
+        } else {
+            self.gamma_powers.iter().sum()
+        }
+    }
+
+    fn degree(&self) -> usize {
+        DEGREE_BOUND
+    }
+
+    fn normalize_opening_point(
+        &self,
+        challenges: &[<F as JoltField>::Challenge],
+    ) -> OpeningPoint<BIG_ENDIAN, F> {
+        OpeningPoint::<LITTLE_ENDIAN, F>::new(challenges.to_vec()).match_endianness()
+    }
+}
+
 #[derive(Allocative)]
 pub struct HammingWeightSumcheckProver<F: JoltField> {
     ra: Vec<MultilinearPolynomial<F>>,
@@ -40,16 +79,8 @@ impl<F: JoltField> HammingWeightSumcheckProver<F> {
 }
 
 impl<F: JoltField, T: Transcript> SumcheckInstanceProver<F, T> for HammingWeightSumcheckProver<F> {
-    fn degree(&self) -> usize {
-        DEGREE_BOUND
-    }
-
-    fn num_rounds(&self) -> usize {
-        self.params.num_rounds
-    }
-
-    fn input_claim(&self, accumulator: &ProverOpeningAccumulator<F>) -> F {
-        self.params.input_claim(accumulator)
+    fn get_params(&self) -> Box<&dyn SumcheckInstanceParams<F>> {
+        Box::new(&self.params)
     }
 
     #[tracing::instrument(skip_all, name = "HammingWeightProver::compute_message")]
@@ -87,17 +118,15 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceProver<F, T> for HammingWeight
         transcript: &mut T,
         sumcheck_challenges: &[F::Challenge],
     ) {
-        let opening_point = get_opening_point::<F>(sumcheck_challenges);
+        let opening_point = self.params.normalize_opening_point(sumcheck_challenges);
         let claims: Vec<F> = self.ra.iter().map(|ra| ra.final_sumcheck_claim()).collect();
 
-        let r_cycle = self.params.get_r_cycle(accumulator);
-
         accumulator.append_sparse(
             transcript,
             self.params.polynomial_types.clone(),
             self.params.sumcheck_id,
             opening_point.r,
-            r_cycle,
+            self.params.r_cycle.clone(),
             claims,
         );
     }
@@ -121,16 +150,8 @@ impl<F: JoltField> HammingWeightSumcheckVerifier<F> {
 impl<F: JoltField, T: Transcript> SumcheckInstanceVerifier<F, T>
     for HammingWeightSumcheckVerifier<F>
 {
-    fn degree(&self) -> usize {
-        DEGREE_BOUND
-    }
-
-    fn num_rounds(&self) -> usize {
-        self.params.num_rounds
-    }
-
-    fn input_claim(&self, accumulator: &VerifierOpeningAccumulator<F>) -> F {
-        self.params.input_claim(accumulator)
+    fn get_params(&self) -> Box<&dyn SumcheckInstanceParams<F>> {
+        Box::new(&self.params)
     }
 
     fn expected_output_claim(
@@ -159,12 +180,13 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceVerifier<F, T>
         transcript: &mut T,
         sumcheck_challenges: &[F::Challenge],
     ) {
-        let r_cycle = self.params.get_r_cycle(accumulator);
-        let r = get_opening_point::<F>(sumcheck_challenges)
+        let r = self
+            .params
+            .normalize_opening_point(sumcheck_challenges)
             .r
             .iter()
             .cloned()
-            .chain(r_cycle.iter().cloned())
+            .chain(self.params.r_cycle.iter().cloned())
             .collect::<Vec<_>>();
 
         accumulator.append_sparse(
@@ -175,47 +197,3 @@ impl<F: JoltField, T: Transcript> SumcheckInstanceVerifier<F, T>
         );
     }
 }
-
-pub struct HammingWeightSumcheckParams<F: JoltField> {
-    pub d: usize,
-    pub num_rounds: usize,
-    pub gamma_powers: Vec<F>,
-    pub polynomial_types: Vec<CommittedPolynomial>,
-    pub sumcheck_id: SumcheckId,
-    pub virtual_poly: Option<VirtualPolynomial>,
-    pub r_cycle_sumcheck_id: SumcheckId,
-}
-
-impl<F: JoltField> HammingWeightSumcheckParams<F> {
-    pub fn num_rounds(&self) -> usize {
-        self.num_rounds
-    }
-
-    pub fn input_claim(&self, accumulator: &dyn OpeningAccumulator<F>) -> F {
-        if self.sumcheck_id == SumcheckId::RamHammingWeight {
-            let (_, hamming_booleanity_claim) = accumulator.get_virtual_polynomial_opening(
-                VirtualPolynomial::RamHammingWeight,
-                SumcheckId::RamHammingBooleanity,
-            );
-            hamming_booleanity_claim * self.gamma_powers.iter().sum::<F>()
-        } else {
-            self.gamma_powers.iter().sum()
-        }
-    }
-
-    fn get_r_cycle(&self, accumulator: &dyn OpeningAccumulator<F>) -> Vec<F::Challenge> {
-        let virtual_poly = self
-            .virtual_poly
-            .expect("virtual_poly must be set for hamming weight");
-        accumulator
-            .get_virtual_polynomial_opening(virtual_poly, self.r_cycle_sumcheck_id)
-            .0
-            .r
-    }
-}
-
-fn get_opening_point<F: JoltField>(
-    sumcheck_challenges: &[F::Challenge],
-) -> OpeningPoint<BIG_ENDIAN, F> {
-    OpeningPoint::<LITTLE_ENDIAN, F>::new(sumcheck_challenges.to_vec()).match_endianness()
-}