logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-03 22:33:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

PR feedback

Browse Source
This commit is contained in:
wborgeaud 2022-02-15 08:35:57 +01:00
parent acd62f1221
commit 42d6532120
9 changed files with 21 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
starky/src/config.rs
View File

@ -29,17 +29,6 @@ impl StarkConfig {
}
pub(crate) fn fri_params(&self, degree_bits: usize) -> FriParams {
let fri_config = &self.fri_config;
let reduction_arity_bits = fri_config.reduction_strategy.reduction_arity_bits(
degree_bits,
fri_config.rate_bits,
fri_config.num_query_rounds,
);
FriParams {
config: fri_config.clone(),
hiding: false,
degree_bits,
reduction_arity_bits,
}
self.fri_config.fri_params(degree_bits, false)
}
}

19
starky/src/fibonacci_stark.rs
View File

@ -67,9 +67,9 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for FibonacciStar
yield_constr
.constraint_last_row(vars.local_values[1] - vars.public_inputs[Self::PI_INDEX_RES]);
// x0 <- x1
// x0' <- x1
yield_constr.constraint(vars.next_values[0] - vars.local_values[1]);
// x1 <- x0 + x1
// x1' <- x0 + x1
yield_constr.constraint(vars.next_values[1] - vars.local_values[0] - vars.local_values[1]);
}
@ -89,10 +89,10 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for FibonacciStar
yield_constr.constraint_first_row(builder, pis_constraints[1]);
yield_constr.constraint_last_row(builder, pis_constraints[2]);
// x0 <- x1
// x0' <- x1
let first_col_constraint = builder.sub_extension(vars.next_values[0], vars.local_values[1]);
yield_constr.constraint(builder, first_col_constraint);
// x1 <- x0 + x1
// x1' <- x0 + x1
let second_col_constraint = {
let tmp = builder.sub_extension(vars.next_values[1], vars.local_values[0]);
builder.sub_extension(tmp, vars.local_values[1])
@ -125,11 +125,11 @@ mod tests {
use crate::prover::prove;
use crate::recursive_verifier::{
add_virtual_stark_proof_with_pis, recursively_verify_stark_proof,
set_startk_proof_with_pis_target,
set_stark_proof_with_pis_target,
};
use crate::stark::Stark;
use crate::stark_testing::test_stark_low_degree;
use crate::verifier::verify;
use crate::verifier::verify_stark_proof;
fn fibonacci<F: Field>(n: usize, x0: F, x1: F) -> F {
(0..n).fold((x0, x1), |x, _| (x.1, x.0 + x.1)).1
@ -155,7 +155,7 @@ mod tests {
&mut TimingTree::default(),
)?;
verify(stark, proof, &config)
verify_stark_proof(stark, proof, &config)
}
#[test]
@ -165,7 +165,6 @@ mod tests {
type F = <C as GenericConfig<D>>::F;
type S = FibonacciStark<F, D>;
let config = StarkConfig::standard_fast_config();
let num_rows = 1 << 5;
let stark = S::new(num_rows);
test_stark_low_degree(stark)
@ -191,7 +190,7 @@ mod tests {
public_inputs,
&mut TimingTree::default(),
)?;
verify(stark, proof.clone(), &config)?;
verify_stark_proof(stark, proof.clone(), &config)?;
recursive_proof::<F, C, S, C, D>(stark, proof, &config, true)
}
@ -219,7 +218,7 @@ mod tests {
let mut pw = PartialWitness::new();
let degree_bits = inner_proof.proof.recover_degree_bits(inner_config);
let pt = add_virtual_stark_proof_with_pis(&mut builder, stark, inner_config, degree_bits);
set_startk_proof_with_pis_target(&mut pw, &pt, &inner_proof);
set_stark_proof_with_pis_target(&mut pw, &pt, &inner_proof);
recursively_verify_stark_proof::<F, InnerC, S, D>(&mut builder, stark, pt, inner_config);

8
starky/src/get_challenges.rs
View File

@ -17,7 +17,6 @@ use crate::proof::{
StarkProofWithPublicInputsTarget,
};
#[allow(clippy::too_many_arguments)]
fn get_challenges<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
trace_cap: &MerkleCap<F, C::Hasher>,
quotient_polys_cap: &MerkleCap<F, C::Hasher>,
@ -29,8 +28,6 @@ fn get_challenges<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, cons
degree_bits: usize,
) -> Result<StarkProofChallenges<F, D>> {
let num_challenges = config.num_challenges;
let num_fri_queries = config.fri_config.num_query_rounds;
let lde_size = 1 << (degree_bits + config.fri_config.rate_bits);
let mut challenger = Challenger::<F, C::Hasher>::new();
@ -115,14 +112,11 @@ pub(crate) fn get_challenges_target<
final_poly: &PolynomialCoeffsExtTarget<D>,
pow_witness: Target,
config: &StarkConfig,
degree_bits: usize,
) -> StarkProofChallengesTarget<D>
where
C::Hasher: AlgebraicHasher<F>,
{
let num_challenges = config.num_challenges;
let num_fri_queries = config.fri_config.num_query_rounds;
let lde_size = 1 << (degree_bits + config.fri_config.rate_bits);
let mut challenger = RecursiveChallenger::<F, C::Hasher, D>::new(builder);
@ -152,7 +146,6 @@ impl<const D: usize> StarkProofWithPublicInputsTarget<D> {
&self,
builder: &mut CircuitBuilder<F, D>,
config: &StarkConfig,
degree_bits: usize,
) -> StarkProofChallengesTarget<D>
where
C::Hasher: AlgebraicHasher<F>,
@ -179,7 +172,6 @@ impl<const D: usize> StarkProofWithPublicInputsTarget<D> {
final_poly,
*pow_witness,
config,
degree_bits,
)
}
}

1
starky/src/lib.rs
View File

@ -2,6 +2,7 @@
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(incomplete_features)]
#![allow(clippy::too_many_arguments)]
#![feature(generic_const_exprs)]
pub mod config;

1
starky/src/proof.rs
View File

@ -15,7 +15,6 @@ use rayon::prelude::*;
use crate::config::StarkConfig;
// TODO: Permutation polynomials.
#[derive(Debug, Clone)]
pub struct StarkProof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {
/// Merkle cap of LDEs of trace values.

8
starky/src/recursive_verifier.rs
View File

@ -35,7 +35,7 @@ pub fn recursively_verify_stark_proof<
{
assert_eq!(proof_with_pis.public_inputs.len(), S::PUBLIC_INPUTS);
let degree_bits = proof_with_pis.proof.recover_degree_bits(inner_config);
let challenges = proof_with_pis.get_challenges::<F, C>(builder, inner_config, degree_bits);
let challenges = proof_with_pis.get_challenges::<F, C>(builder, inner_config);
recursively_verify_stark_proof_with_challenges::<F, C, S, D>(
builder,
@ -71,8 +71,6 @@ fn recursively_verify_stark_proof_with_challenges<
proof,
public_inputs,
} = proof_with_pis;
let local_values = &proof.openings.local_values;
let next_values = &proof.openings.local_values;
let StarkOpeningSetTarget {
local_values,
next_values,
@ -181,7 +179,7 @@ pub fn add_virtual_stark_proof<F: RichField + Extendable<D>, S: Stark<F, D>, con
config: &StarkConfig,
degree_bits: usize,
) -> StarkProofTarget<D> {
let fri_params = config.fri_config.fri_params(degree_bits, false);
let fri_params = config.fri_params(degree_bits);
let cap_height = fri_params.config.cap_height;
let num_leaves_per_oracle = &[
@ -214,7 +212,7 @@ fn add_stark_opening_set<F: RichField + Extendable<D>, S: Stark<F, D>, const D:
}
}
pub fn set_startk_proof_with_pis_target<F, C: GenericConfig<D, F = F>, W, const D: usize>(
pub fn set_stark_proof_with_pis_target<F, C: GenericConfig<D, F = F>, W, const D: usize>(
witness: &mut W,
stark_proof_with_pis_target: &StarkProofWithPublicInputsTarget<D>,
stark_proof_with_pis: &StarkProofWithPublicInputs<F, C, D>,

4
starky/src/stark.rs
View File

@ -96,7 +96,7 @@ pub trait Stark<F: RichField + Extendable<D>, const D: usize>: Sync {
};
FriInstanceInfo {
oracles: vec![no_blinding_oracle; 3],
batches: vec![zeta_batch],
batches: vec![zeta_batch, zeta_right_batch],
}
}
@ -124,7 +124,7 @@ pub trait Stark<F: RichField + Extendable<D>, const D: usize>: Sync {
};
FriInstanceInfoTarget {
oracles: vec![no_blinding_oracle; 3],
batches: vec![zeta_batch],
batches: vec![zeta_batch, zeta_right_batch],
}
}
}

8
starky/src/verifier.rs
View File

@ -12,7 +12,7 @@ use crate::proof::{StarkOpeningSet, StarkProofChallenges, StarkProofWithPublicIn
use crate::stark::Stark;
use crate::vars::StarkEvaluationVars;
pub fn verify<
pub fn verify_stark_proof<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
S: Stark<F, D>,
@ -30,10 +30,10 @@ where
ensure!(proof_with_pis.public_inputs.len() == S::PUBLIC_INPUTS);
let degree_bits = proof_with_pis.proof.recover_degree_bits(config);
let challenges = proof_with_pis.get_challenges(config, degree_bits)?;
verify_with_challenges(stark, proof_with_pis, challenges, degree_bits, config)
verify_stark_proof_with_challenges(stark, proof_with_pis, challenges, degree_bits, config)
}
pub(crate) fn verify_with_challenges<
pub(crate) fn verify_stark_proof_with_challenges<
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
S: Stark<F, D>,
@ -54,8 +54,6 @@ where
proof,
public_inputs,
} = proof_with_pis;
let local_values = &proof.openings.local_values;
let next_values = &proof.openings.local_values;
let StarkOpeningSet {
local_values,
next_values,

4
system_zero/src/system_zero.rs
View File

@ -117,7 +117,7 @@ mod tests {
use starky::prover::prove;
use starky::stark::Stark;
use starky::stark_testing::test_stark_low_degree;
use starky::verifier::verify;
use starky::verifier::verify_stark_proof;
use crate::system_zero::SystemZero;
@ -136,7 +136,7 @@ mod tests {
let trace = system.generate_trace();
let proof = prove::<F, C, S, D>(system, &config, trace, public_inputs, &mut timing)?;
verify(system, proof, &config)
verify_stark_proof(system, proof, &config)
}
#[test]