Generic type bounds for FS types

src/fs_utils.rs

@@ -5,7 +5,7 @@ pub trait OODIOPattern<F: Field> {
     fn add_ood(self, num_samples: usize) -> Self;
 }
 
-impl<F> OODIOPattern<F> for IOPattern
+impl<F, IOPattern> OODIOPattern<F> for IOPattern
 where
     F: Field,
     IOPattern: FieldIOPattern<F>,
@@ -24,7 +24,7 @@ pub trait WhirPoWIOPattern {
     fn pow(self, bits: f64) -> Self;
 }
 
-impl WhirPoWIOPattern for IOPattern
+impl <IOPattern> WhirPoWIOPattern for IOPattern
 where
     IOPattern: PoWIOPattern,
 {

src/sumcheck/prover_not_skipping.rs

@@ -1,8 +1,5 @@
 use ark_ff::Field;
-use nimue::{
-    plugins::ark::{FieldChallenges, FieldIOPattern, FieldWriter},
-    IOPattern, Merlin, ProofResult,
-};
+use nimue::{plugins::ark::{FieldChallenges, FieldIOPattern, FieldWriter}, IOPattern, ProofResult};
 use nimue_pow::{PoWChallenge, PowStrategy};
 
 use crate::{
@@ -16,7 +13,7 @@ pub trait SumcheckNotSkippingIOPattern<F: Field> {
     fn add_sumcheck(self, folding_factor: usize, pow_bits: f64) -> Self;
 }
 
-impl<F> SumcheckNotSkippingIOPattern<F> for IOPattern
+impl<F, IOPattern> SumcheckNotSkippingIOPattern<F> for IOPattern
 where
     F: Field,
     IOPattern: FieldIOPattern<F> + WhirPoWIOPattern,
@@ -59,14 +56,15 @@ where
         }
     }
 
-    pub fn compute_sumcheck_polynomials<S>(
+    pub fn compute_sumcheck_polynomials<S, Merlin>(
         &mut self,
         merlin: &mut Merlin,
         folding_factor: usize,
         pow_bits: f64,
     ) -> ProofResult<MultilinearPoint<F>>
     where
         S: PowStrategy,
+        Merlin: FieldChallenges<F> + FieldWriter<F> + PoWChallenge,
     {
         let mut res = Vec::with_capacity(folding_factor);
 
@@ -103,10 +101,7 @@ where
 #[cfg(test)]
 mod tests {
     use ark_ff::Field;
-    use nimue::{
-        plugins::ark::{FieldChallenges, FieldIOPattern, FieldReader},
-        IOPattern, ProofResult,
-    };
+    use nimue::{plugins::ark::{FieldChallenges, FieldIOPattern, FieldReader}, IOPattern, Merlin, ProofResult};
     use nimue_pow::blake3::Blake3PoW;
 
     use crate::{
@@ -157,7 +152,7 @@ mod tests {
         );
 
         let folding_randomness_1 =
-            prover.compute_sumcheck_polynomials::<Blake3PoW>(&mut merlin, folding_factor, 0.)?;
+            prover.compute_sumcheck_polynomials::<Blake3PoW, Merlin>(&mut merlin, folding_factor, 0.)?;
 
         // Compute the answers
         let folded_poly_1 = polynomial.fold(&folding_randomness_1);
@@ -243,14 +238,14 @@ mod tests {
         );
 
         let folding_randomness_1 =
-            prover.compute_sumcheck_polynomials::<Blake3PoW>(&mut merlin, folding_factor, 0.)?;
+            prover.compute_sumcheck_polynomials::<Blake3PoW, Merlin>(&mut merlin, folding_factor, 0.)?;
 
         let folded_poly_1 = polynomial.fold(&folding_randomness_1);
         let fold_eval = folded_poly_1.evaluate_at_extension(&fold_point);
         prover.add_new_equality(&[fold_point.clone()], &combination_randomness, &[fold_eval]);
 
         let folding_randomness_2 =
-            prover.compute_sumcheck_polynomials::<Blake3PoW>(&mut merlin, folding_factor, 0.)?;
+            prover.compute_sumcheck_polynomials::<Blake3PoW, Merlin>(&mut merlin, folding_factor, 0.)?;
 
         // Compute the answers
         let folded_poly_1 = polynomial.fold(&folding_randomness_1);

src/whir/committer.rs

@@ -41,13 +41,13 @@ where
         Self(config)
     }
 
-    pub fn commit(
+    pub fn commit<Merlin>(
         &self,
         merlin: &mut Merlin,
         polynomial: CoefficientList<F::BasePrimeField>,
     ) -> ProofResult<Witness<F, MerkleConfig>>
     where
-        Merlin: FieldChallenges<F> + ByteWriter,
+        Merlin: FieldWriter<F> + FieldChallenges<F> + ByteWriter,
     {
         let base_domain = self.0.starting_domain.base_domain.unwrap();
         let expansion = base_domain.size() / polynomial.num_coeffs();

src/whir/iopattern.rs

@@ -20,7 +20,7 @@ pub trait WhirIOPattern<F: FftField> {
     ) -> Self;
 }
 
-impl<F> WhirIOPattern<F> for IOPattern
+impl<F, IOPattern> WhirIOPattern<F> for IOPattern
 where
     F: FftField,
     IOPattern: ByteIOPattern

src/whir/prover.rs

@@ -15,7 +15,8 @@ use ark_crypto_primitives::merkle_tree::{Config, MerkleTree, MultiPath};
 use ark_ff::FftField;
 use ark_poly::EvaluationDomain;
 use nimue::{
-    plugins::ark::{FieldChallenges, FieldWriter}, ByteWriter, Merlin, ProofResult,
+    plugins::ark::{FieldChallenges, FieldWriter},
+    ByteChallenges, ByteWriter, ProofResult,
 };
 use nimue_pow::{self, PoWChallenge};
 
@@ -65,14 +66,14 @@ where
         witness.polynomial.num_variables() == self.0.mv_parameters.num_variables
     }
 
-    pub fn prove(
+    pub fn prove<Merlin>(
         &self,
         merlin: &mut Merlin,
         statement: Statement<F>,
         witness: Witness<F, MerkleConfig>,
     ) -> ProofResult<WhirProof<MerkleConfig, F>>
     where
-        Merlin: FieldChallenges<F> + ByteWriter,
+        Merlin: FieldChallenges<F> + FieldWriter<F> + ByteChallenges + ByteWriter + PoWChallenge,
     {
         assert!(self.validate_parameters());
         assert!(self.validate_statement(&statement));
@@ -118,7 +119,7 @@ where
             sumcheck_prover
                 .as_mut()
                 .unwrap()
-                .compute_sumcheck_polynomials::<PowStrategy>(
+                .compute_sumcheck_polynomials::<PowStrategy, Merlin>(
                     merlin,
                     self.0.folding_factor,
                     self.0.starting_folding_pow_bits,
@@ -147,11 +148,14 @@ where
         self.round(merlin, round_state)
     }
 
-    fn round(
+    fn round<Merlin>(
         &self,
         merlin: &mut Merlin,
         mut round_state: RoundState<F, MerkleConfig>,
-    ) -> ProofResult<WhirProof<MerkleConfig, F>> {
+    ) -> ProofResult<WhirProof<MerkleConfig, F>>
+    where
+        Merlin: FieldChallenges<F> + ByteChallenges + FieldWriter<F> + ByteWriter + PoWChallenge,
+    {
         // Fold the coefficients
         let folded_coefficients = round_state
             .coefficients
@@ -198,7 +202,7 @@ where
                     .unwrap_or_else(|| {
                         SumcheckProverNotSkipping::new(folded_coefficients.clone(), &[], &[], &[])
                     })
-                    .compute_sumcheck_polynomials::<PowStrategy>(
+                    .compute_sumcheck_polynomials::<PowStrategy, Merlin>(
                         merlin,
                         self.0.final_sumcheck_rounds,
                         self.0.final_folding_pow_bits,
@@ -347,7 +351,7 @@ where
                 )
             });
 
-        let folding_randomness = sumcheck_prover.compute_sumcheck_polynomials::<PowStrategy>(
+        let folding_randomness = sumcheck_prover.compute_sumcheck_polynomials::<PowStrategy, Merlin>(
             merlin,
             self.0.folding_factor,
             round_params.folding_pow_bits,

src/whir/verifier.rs

@@ -4,8 +4,8 @@ use ark_crypto_primitives::merkle_tree::Config;
 use ark_ff::FftField;
 use ark_poly::EvaluationDomain;
 use nimue::{
-    plugins::ark::{FieldChallenges, FieldReader},
-    Arthur, ByteReader, ProofError, ProofResult,
+    plugins::ark::{FieldChallenges, FieldReader}
+    , ByteChallenges, ByteReader, ProofError, ProofResult,
 };
 use nimue_pow::{self, PoWChallenge};
 
@@ -15,7 +15,7 @@ use crate::{
     parameters::FoldType,
     poly_utils::{coeffs::CoefficientList, eq_poly_outside, fold::compute_fold, MultilinearPoint},
     sumcheck::proof::SumcheckPolynomial,
-    utils::{expand_randomness},
+    utils::expand_randomness,
 };
 
 pub struct Verifier<F, MerkleConfig, PowStrategy>
@@ -76,10 +76,13 @@ where
         }
     }
 
-    fn parse_commitment(
+    fn parse_commitment<Arthur>(
         &self,
         arthur: &mut Arthur,
-    ) -> ProofResult<ParsedCommitment<F, MerkleConfig::InnerDigest>> {
+    ) -> ProofResult<ParsedCommitment<F, MerkleConfig::InnerDigest>>
+    where
+        Arthur: ByteReader + FieldReader<F> + FieldChallenges<F>,
+    {
         let root: [u8; 32] = arthur.next_bytes()?;
 
         let mut ood_points = vec![F::ZERO; self.params.committment_ood_samples];
@@ -96,13 +99,16 @@ where
         })
     }
 
-    fn parse_proof(
+    fn parse_proof<Arthur>(
         &self,
         arthur: &mut Arthur,
         parsed_commitment: &ParsedCommitment<F, MerkleConfig::InnerDigest>,
         statement: &Statement<F>, // Will be needed later
         whir_proof: &WhirProof<MerkleConfig, F>,
-    ) -> ProofResult<ParsedProof<F>> {
+    ) -> ProofResult<ParsedProof<F>>
+    where
+        Arthur: FieldReader<F> + FieldChallenges<F> + PoWChallenge + ByteReader + ByteChallenges,
+    {
         let mut sumcheck_rounds = Vec::new();
         let mut folding_randomness: MultilinearPoint<F>;
         let initial_combination_randomness;
@@ -457,12 +463,15 @@ where
         result
     }
 
-    pub fn verify(
+    pub fn verify<Arthur>(
         &self,
         arthur: &mut Arthur,
         statement: &Statement<F>,
         whir_proof: &WhirProof<MerkleConfig, F>,
-    ) -> ProofResult<()> {
+    ) -> ProofResult<()>
+    where
+        Arthur: FieldChallenges<F> + FieldReader<F> + ByteChallenges + ByteReader + PoWChallenge,
+    {
         // We first do a pass in which we rederive all the FS challenges
         // Then we will check the algebraic part (so to optimise inversions)
         let parsed_commitment = self.parse_commitment(arthur)?;