logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-08 16:53:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use generic hasher in Challenger

Browse Source
This commit is contained in:
wborgeaud 2021-11-05 12:02:33 +01:00
parent 943e1f4b0f
commit d4c8caa208
5 changed files with 34 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/fri/commitment.rs
View File

@ -159,7 +159,7 @@ impl<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
);
challenger.observe_opening_set(&os);
let alpha = challenger.get_extension_challenge::<C, D>();
let alpha = challenger.get_extension_challenge::<D>();
let mut alpha = ReducingFactor::new(alpha);
// Final low-degree polynomial that goes into FRI.

6
src/fri/prover.rs
View File

@ -41,7 +41,7 @@ pub fn fri_proof<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
);
// PoW phase
let current_hash = challenger.get_hash::<C, D>();
let current_hash = challenger.get_hash();
let pow_witness = timed!(
timing,
"find proof-of-work witness",
@ -88,7 +88,7 @@ fn fri_committed_trees<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: us
challenger.observe_cap(&tree.cap);
trees.push(tree);
let beta = challenger.get_extension_challenge::<C, D>();
let beta = challenger.get_extension_challenge::<D>();
// P(x) = sum_{i<r} x^i * P_i(x^r) becomes sum_{i<r} beta^i * P_i(x).
coeffs = PolynomialCoeffs::new(
coeffs
@ -153,7 +153,7 @@ fn fri_prover_query_round<F: Extendable<D>, C: GenericConfig<D, F = F>, const D:
common_data: &CommonCircuitData<F, C, D>,
) -> FriQueryRound<F, C::Hasher, D> {
let mut query_steps = Vec::new();
let x = challenger.get_challenge::<C, D>();
let x = challenger.get_challenge();
let mut x_index = x.to_canonical_u64() as usize % n;
let initial_proof = initial_merkle_trees
.iter()

50
src/iop/challenger.rs
View File

@ -105,15 +105,12 @@ impl<F: RichField, H: AlgebraicHasher<F>> Challenger<F, H> {
}
}
pub fn get_challenge<C: GenericConfig<D, F = F>, const D: usize>(&mut self) -> F {
self.absorb_buffered_inputs::<C, D>();
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 =
<<C as GenericConfig<D>>::InnerHasher as AlgebraicHasher<F>>::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<F: RichField, H: AlgebraicHasher<F>> Challenger<F, H> {
.expect("Output buffer should be non-empty")
}
pub fn get_n_challenges<C: GenericConfig<D, F = F>, const D: usize>(
&mut self,
n: usize,
) -> Vec<F> {
(0..n).map(|_| self.get_challenge::<C, D>()).collect()
pub fn get_n_challenges(&mut self, n: usize) -> Vec<F> {
(0..n).map(|_| self.get_challenge()).collect()
}
pub fn get_hash<C: GenericConfig<D, F = F>, const D: usize>(&mut self) -> HashOut<F> {
pub fn get_hash(&mut self) -> HashOut<F> {
HashOut {
elements: [
self.get_challenge::<C, D>(),
self.get_challenge::<C, D>(),
self.get_challenge::<C, D>(),
self.get_challenge::<C, D>(),
self.get_challenge(),
self.get_challenge(),
self.get_challenge(),
self.get_challenge(),
],
}
}
pub fn get_extension_challenge<C: GenericConfig<D, F = F>, const D: usize>(
&mut self,
) -> F::Extension
pub fn get_extension_challenge<const D: usize>(&mut self) -> F::Extension
where
F: Extendable<D>,
{
let mut arr = [F::ZERO; D];
arr.copy_from_slice(&self.get_n_challenges::<C, D>(D));
arr.copy_from_slice(&self.get_n_challenges(D));
F::Extension::from_basefield_array(arr)
}
pub fn get_n_extension_challenges<C: GenericConfig<D, F = F>, const D: usize>(
&mut self,
n: usize,
) -> Vec<F::Extension>
pub fn get_n_extension_challenges<const D: usize>(&mut self, n: usize) -> Vec<F::Extension>
where
F: Extendable<D>,
{
(0..n)
.map(|_| self.get_extension_challenge::<C, D>())
.map(|_| self.get_extension_challenge::<D>())
.collect()
}
/// Absorb any buffered inputs. After calling this, the input buffer will be empty.
fn absorb_buffered_inputs<C: GenericConfig<D, F = F>, const D: usize>(&mut self) {
fn absorb_buffered_inputs(&mut self) {
if self.input_buffer.is_empty() {
return;
}
@ -178,10 +167,7 @@ impl<F: RichField, H: AlgebraicHasher<F>> Challenger<F, H> {
}
// Apply the permutation.
self.sponge_state =
<<C as GenericConfig<D>>::InnerHasher as AlgebraicHasher<F>>::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::<C, D>(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<F>> = Vec::new();
for (r, inputs) in inputs_per_round.iter().enumerate() {
challenger.observe_elements(inputs);
outputs_per_round.push(challenger.get_n_challenges::<C, D>(num_outputs_per_round[r]));
outputs_per_round.push(challenger.get_n_challenges(num_outputs_per_round[r]));
}
let config = CircuitConfig::standard_recursion_config();

16
src/plonk/get_challenges.rs
View File

@ -37,26 +37,26 @@ fn get_challenges<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
challenger.observe_hash::<C::InnerHasher>(public_inputs_hash);
challenger.observe_cap(wires_cap);
let plonk_betas = challenger.get_n_challenges::<C, D>(num_challenges);
let plonk_gammas = challenger.get_n_challenges::<C, D>(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::<C, D>(num_challenges);
let plonk_alphas = challenger.get_n_challenges(num_challenges);
challenger.observe_cap(quotient_polys_cap);
let plonk_zeta = challenger.get_extension_challenge::<C, D>();
let plonk_zeta = challenger.get_extension_challenge::<D>();
challenger.observe_opening_set(openings);
// Scaling factor to combine polynomials.
let fri_alpha = challenger.get_extension_challenge::<C, D>();
let fri_alpha = challenger.get_extension_challenge::<D>();
// 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::<C, D>()
challenger.get_extension_challenge::<D>()
})
.collect();
@ -64,7 +64,7 @@ fn get_challenges<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
let fri_pow_response = C::InnerHasher::hash(
challenger
.get_hash::<C, D>()
.get_hash()
.elements
.iter()
.copied()
@ -75,7 +75,7 @@ fn get_challenges<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
.elements[0];
let fri_query_indices = (0..num_fri_queries)
.map(|_| challenger.get_challenge::<C, D>().to_canonical_u64() as usize % lde_size)
.map(|_| challenger.get_challenge().to_canonical_u64() as usize % lde_size)
.collect();
Ok(ProofChallenges {

8
src/plonk/prover.rs
View File

@ -82,8 +82,8 @@ pub(crate) fn prove<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize
challenger.observe_hash::<C::InnerHasher>(public_inputs_hash);
challenger.observe_cap(&wires_commitment.merkle_tree.cap);
let betas = challenger.get_n_challenges::<C, D>(num_challenges);
let gammas = challenger.get_n_challenges::<C, D>(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<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize
challenger.observe_cap(&zs_partial_products_commitment.merkle_tree.cap);
let alphas = challenger.get_n_challenges::<C, D>(num_challenges);
let alphas = challenger.get_n_challenges(num_challenges);
let quotient_polys = timed!(
timing,
@ -173,7 +173,7 @@ pub(crate) fn prove<F: Extendable<D>, C: GenericConfig<D, F = F>, const D: usize
challenger.observe_cap(&quotient_polys_commitment.merkle_tree.cap);
let zeta = challenger.get_extension_challenge::<C, D>();
let zeta = challenger.get_extension_challenge::<D>();
let (opening_proof, openings) = timed!(
timing,