From d4c8caa208bfb901de8f378204758916e6371c0f Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 5 Nov 2021 12:02:33 +0100 Subject: [PATCH] Use generic hasher in Challenger --- src/fri/commitment.rs | 2 +- src/fri/prover.rs | 6 ++--- src/iop/challenger.rs | 50 +++++++++++++------------------------ src/plonk/get_challenges.rs | 16 ++++++------ src/plonk/prover.rs | 8 +++--- 5 files changed, 34 insertions(+), 48 deletions(-) diff --git a/src/fri/commitment.rs b/src/fri/commitment.rs index 1032d2b0..64643283 100644 --- a/src/fri/commitment.rs +++ b/src/fri/commitment.rs @@ -159,7 +159,7 @@ impl, C: GenericConfig, const D: usize> ); challenger.observe_opening_set(&os); - let alpha = challenger.get_extension_challenge::(); + let alpha = challenger.get_extension_challenge::(); let mut alpha = ReducingFactor::new(alpha); // Final low-degree polynomial that goes into FRI. diff --git a/src/fri/prover.rs b/src/fri/prover.rs index 56040682..ac55be41 100644 --- a/src/fri/prover.rs +++ b/src/fri/prover.rs @@ -41,7 +41,7 @@ pub fn fri_proof, C: GenericConfig, const D: usize>( ); // PoW phase - let current_hash = challenger.get_hash::(); + let current_hash = challenger.get_hash(); let pow_witness = timed!( timing, "find proof-of-work witness", @@ -88,7 +88,7 @@ fn fri_committed_trees, C: GenericConfig, const D: us challenger.observe_cap(&tree.cap); trees.push(tree); - let beta = challenger.get_extension_challenge::(); + let beta = challenger.get_extension_challenge::(); // P(x) = sum_{i, C: GenericConfig, const D: common_data: &CommonCircuitData, ) -> FriQueryRound { let mut query_steps = Vec::new(); - let x = challenger.get_challenge::(); + let x = challenger.get_challenge(); let mut x_index = x.to_canonical_u64() as usize % n; let initial_proof = initial_merkle_trees .iter() diff --git a/src/iop/challenger.rs b/src/iop/challenger.rs index 80451fe5..1a838b39 100644 --- a/src/iop/challenger.rs +++ b/src/iop/challenger.rs @@ -105,15 +105,12 @@ impl> Challenger { } } - pub fn get_challenge, const D: usize>(&mut self) -> F { - self.absorb_buffered_inputs::(); + pub fn get_challenge(&mut self) -> F { + self.absorb_buffered_inputs(); if self.output_buffer.is_empty() { // Evaluate the permutation to produce `r` new outputs. - self.sponge_state = - <>::InnerHasher as AlgebraicHasher>::Permutation::permute( - self.sponge_state, - ); + self.sponge_state = H::Permutation::permute(self.sponge_state); self.output_buffer = self.sponge_state[0..SPONGE_RATE].to_vec(); } @@ -122,49 +119,41 @@ impl> Challenger { .expect("Output buffer should be non-empty") } - pub fn get_n_challenges, const D: usize>( - &mut self, - n: usize, - ) -> Vec { - (0..n).map(|_| self.get_challenge::()).collect() + pub fn get_n_challenges(&mut self, n: usize) -> Vec { + (0..n).map(|_| self.get_challenge()).collect() } - pub fn get_hash, const D: usize>(&mut self) -> HashOut { + pub fn get_hash(&mut self) -> HashOut { HashOut { elements: [ - self.get_challenge::(), - self.get_challenge::(), - self.get_challenge::(), - self.get_challenge::(), + self.get_challenge(), + self.get_challenge(), + self.get_challenge(), + self.get_challenge(), ], } } - pub fn get_extension_challenge, const D: usize>( - &mut self, - ) -> F::Extension + pub fn get_extension_challenge(&mut self) -> F::Extension where F: Extendable, { let mut arr = [F::ZERO; D]; - arr.copy_from_slice(&self.get_n_challenges::(D)); + arr.copy_from_slice(&self.get_n_challenges(D)); F::Extension::from_basefield_array(arr) } - pub fn get_n_extension_challenges, const D: usize>( - &mut self, - n: usize, - ) -> Vec + pub fn get_n_extension_challenges(&mut self, n: usize) -> Vec where F: Extendable, { (0..n) - .map(|_| self.get_extension_challenge::()) + .map(|_| self.get_extension_challenge::()) .collect() } /// Absorb any buffered inputs. After calling this, the input buffer will be empty. - fn absorb_buffered_inputs, const D: usize>(&mut self) { + fn absorb_buffered_inputs(&mut self) { if self.input_buffer.is_empty() { return; } @@ -178,10 +167,7 @@ impl> Challenger { } // Apply the permutation. - self.sponge_state = - <>::InnerHasher as AlgebraicHasher>::Permutation::permute( - self.sponge_state, - ); + self.sponge_state = H::Permutation::permute(self.sponge_state); } self.output_buffer = self.sponge_state[0..SPONGE_RATE].to_vec(); @@ -354,7 +340,7 @@ mod tests { let mut challenges = Vec::new(); for i in 1..10 { - challenges.extend(challenger.get_n_challenges::(i)); + challenges.extend(challenger.get_n_challenges(i)); challenger.observe_element(F::rand()); } @@ -388,7 +374,7 @@ mod tests { let mut outputs_per_round: Vec> = Vec::new(); for (r, inputs) in inputs_per_round.iter().enumerate() { challenger.observe_elements(inputs); - outputs_per_round.push(challenger.get_n_challenges::(num_outputs_per_round[r])); + outputs_per_round.push(challenger.get_n_challenges(num_outputs_per_round[r])); } let config = CircuitConfig::standard_recursion_config(); diff --git a/src/plonk/get_challenges.rs b/src/plonk/get_challenges.rs index 99436512..65d67c9d 100644 --- a/src/plonk/get_challenges.rs +++ b/src/plonk/get_challenges.rs @@ -37,26 +37,26 @@ fn get_challenges, C: GenericConfig, const D: usize>( challenger.observe_hash::(public_inputs_hash); challenger.observe_cap(wires_cap); - let plonk_betas = challenger.get_n_challenges::(num_challenges); - let plonk_gammas = challenger.get_n_challenges::(num_challenges); + let plonk_betas = challenger.get_n_challenges(num_challenges); + let plonk_gammas = challenger.get_n_challenges(num_challenges); challenger.observe_cap(plonk_zs_partial_products_cap); - let plonk_alphas = challenger.get_n_challenges::(num_challenges); + let plonk_alphas = challenger.get_n_challenges(num_challenges); challenger.observe_cap(quotient_polys_cap); - let plonk_zeta = challenger.get_extension_challenge::(); + let plonk_zeta = challenger.get_extension_challenge::(); challenger.observe_opening_set(openings); // Scaling factor to combine polynomials. - let fri_alpha = challenger.get_extension_challenge::(); + let fri_alpha = challenger.get_extension_challenge::(); // Recover the random betas used in the FRI reductions. let fri_betas = commit_phase_merkle_caps .iter() .map(|cap| { challenger.observe_cap(cap); - challenger.get_extension_challenge::() + challenger.get_extension_challenge::() }) .collect(); @@ -64,7 +64,7 @@ fn get_challenges, C: GenericConfig, const D: usize>( let fri_pow_response = C::InnerHasher::hash( challenger - .get_hash::() + .get_hash() .elements .iter() .copied() @@ -75,7 +75,7 @@ fn get_challenges, C: GenericConfig, const D: usize>( .elements[0]; let fri_query_indices = (0..num_fri_queries) - .map(|_| challenger.get_challenge::().to_canonical_u64() as usize % lde_size) + .map(|_| challenger.get_challenge().to_canonical_u64() as usize % lde_size) .collect(); Ok(ProofChallenges { diff --git a/src/plonk/prover.rs b/src/plonk/prover.rs index 69f89dea..f2a85214 100644 --- a/src/plonk/prover.rs +++ b/src/plonk/prover.rs @@ -82,8 +82,8 @@ pub(crate) fn prove, C: GenericConfig, const D: usize challenger.observe_hash::(public_inputs_hash); challenger.observe_cap(&wires_commitment.merkle_tree.cap); - let betas = challenger.get_n_challenges::(num_challenges); - let gammas = challenger.get_n_challenges::(num_challenges); + let betas = challenger.get_n_challenges(num_challenges); + let gammas = challenger.get_n_challenges(num_challenges); assert!( common_data.quotient_degree_factor < common_data.config.num_routed_wires, @@ -123,7 +123,7 @@ pub(crate) fn prove, C: GenericConfig, const D: usize challenger.observe_cap(&zs_partial_products_commitment.merkle_tree.cap); - let alphas = challenger.get_n_challenges::(num_challenges); + let alphas = challenger.get_n_challenges(num_challenges); let quotient_polys = timed!( timing, @@ -173,7 +173,7 @@ pub(crate) fn prove, C: GenericConfig, const D: usize challenger.observe_cap("ient_polys_commitment.merkle_tree.cap); - let zeta = challenger.get_extension_challenge::(); + let zeta = challenger.get_extension_challenge::(); let (opening_proof, openings) = timed!( timing,