From 05c3c4d9076e9c6fa0ba24861cd80468f9eb5d32 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 26 Aug 2022 10:12:45 +0200 Subject: [PATCH 1/3] First pass --- evm/src/all_stark.rs | 24 +++++++-------------- evm/src/cross_table_lookup.rs | 30 ++++++++++++-------------- evm/src/generation/mod.rs | 13 +++++++++--- evm/src/get_challenges.rs | 40 +++++++++++++++++------------------ evm/src/proof.rs | 23 ++++++++------------ evm/src/prover.rs | 10 +++------ evm/src/recursive_verifier.rs | 3 +-- 7 files changed, 64 insertions(+), 79 deletions(-) diff --git a/evm/src/all_stark.rs b/evm/src/all_stark.rs index 68ffe86f..15d0a6f8 100644 --- a/evm/src/all_stark.rs +++ b/evm/src/all_stark.rs @@ -41,28 +41,24 @@ impl, const D: usize> Default for AllStark { } impl, const D: usize> AllStark { - pub(crate) fn nums_permutation_zs(&self, config: &StarkConfig) -> Vec { - let ans = vec![ + pub(crate) fn nums_permutation_zs(&self, config: &StarkConfig) -> [usize; NUM_TABLES] { + [ self.cpu_stark.num_permutation_batches(config), self.keccak_stark.num_permutation_batches(config), self.keccak_memory_stark.num_permutation_batches(config), self.logic_stark.num_permutation_batches(config), self.memory_stark.num_permutation_batches(config), - ]; - debug_assert_eq!(ans.len(), Table::num_tables()); - ans + ] } - pub(crate) fn permutation_batch_sizes(&self) -> Vec { - let ans = vec![ + pub(crate) fn permutation_batch_sizes(&self) -> [usize; NUM_TABLES] { + [ self.cpu_stark.permutation_batch_size(), self.keccak_stark.permutation_batch_size(), self.keccak_memory_stark.permutation_batch_size(), self.logic_stark.permutation_batch_size(), self.memory_stark.permutation_batch_size(), - ]; - debug_assert_eq!(ans.len(), Table::num_tables()); - ans + ] } } @@ -75,11 +71,7 @@ pub enum Table { Memory = 4, } -impl Table { - pub(crate) fn num_tables() -> usize { - Table::Memory as usize + 1 - } -} +pub(crate) const NUM_TABLES: usize = Table::Memory as usize + 1; #[allow(unused)] // TODO: Should be used soon. pub(crate) fn all_cross_table_lookups() -> Vec> { @@ -695,7 +687,7 @@ mod tests { &mut memory_trace, ); - let traces = vec![ + let traces = [ cpu_trace, keccak_trace, keccak_memory_trace, diff --git a/evm/src/cross_table_lookup.rs b/evm/src/cross_table_lookup.rs index e4c2cccb..37a8b5a6 100644 --- a/evm/src/cross_table_lookup.rs +++ b/evm/src/cross_table_lookup.rs @@ -13,7 +13,7 @@ use plonky2::iop::target::Target; use plonky2::plonk::circuit_builder::CircuitBuilder; use plonky2::plonk::config::GenericConfig; -use crate::all_stark::Table; +use crate::all_stark::{Table, NUM_TABLES}; use crate::config::StarkConfig; use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer}; use crate::permutation::{ @@ -216,12 +216,12 @@ impl CtlData { pub fn cross_table_lookup_data, const D: usize>( config: &StarkConfig, - trace_poly_values: &[Vec>], + trace_poly_values: &[Vec>; NUM_TABLES], cross_table_lookups: &[CrossTableLookup], challenger: &mut Challenger, -) -> Vec> { +) -> [CtlData; NUM_TABLES] { let challenges = get_grand_product_challenge_set(challenger, config.num_challenges); - let mut ctl_data_per_table = vec![CtlData::default(); trace_poly_values.len()]; + let mut ctl_data_per_table = [0; NUM_TABLES].map(|_| CtlData::default()); for CrossTableLookup { looking_tables, looked_table, @@ -337,12 +337,11 @@ impl<'a, F: RichField + Extendable, const D: usize> CtlCheckVars<'a, F, F::Extension, F::Extension, D> { pub(crate) fn from_proofs>( - proofs: &[StarkProof], + proofs: &[StarkProof; NUM_TABLES], cross_table_lookups: &'a [CrossTableLookup], ctl_challenges: &'a GrandProductChallengeSet, - num_permutation_zs: &[usize], - ) -> Vec> { - debug_assert_eq!(proofs.len(), num_permutation_zs.len()); + num_permutation_zs: &[usize; NUM_TABLES], + ) -> [Vec; NUM_TABLES] { let mut ctl_zs = proofs .iter() .zip(num_permutation_zs) @@ -354,7 +353,7 @@ impl<'a, F: RichField + Extendable, const D: usize> }) .collect::>(); - let mut ctl_vars_per_table = vec![vec![]; proofs.len()]; + let mut ctl_vars_per_table = [0; NUM_TABLES].map(|_| vec![]); for CrossTableLookup { looking_tables, looked_table, @@ -441,12 +440,11 @@ pub struct CtlCheckVarsTarget<'a, F: Field, const D: usize> { impl<'a, F: Field, const D: usize> CtlCheckVarsTarget<'a, F, D> { pub(crate) fn from_proofs( - proofs: &[StarkProofTarget], + proofs: &[StarkProofTarget; NUM_TABLES], cross_table_lookups: &'a [CrossTableLookup], ctl_challenges: &'a GrandProductChallengeSet, - num_permutation_zs: &[usize], - ) -> Vec> { - debug_assert_eq!(proofs.len(), num_permutation_zs.len()); + num_permutation_zs: &[usize; NUM_TABLES], + ) -> [Vec; NUM_TABLES] { let mut ctl_zs = proofs .iter() .zip(num_permutation_zs) @@ -458,7 +456,7 @@ impl<'a, F: Field, const D: usize> CtlCheckVarsTarget<'a, F, D> { }) .collect::>(); - let mut ctl_vars_per_table = vec![vec![]; proofs.len()]; + let mut ctl_vars_per_table = [0; NUM_TABLES].map(|_| vec![]); for CrossTableLookup { looking_tables, looked_table, @@ -559,7 +557,7 @@ pub(crate) fn verify_cross_table_lookups< const D: usize, >( cross_table_lookups: Vec>, - proofs: &[StarkProof], + proofs: &[StarkProof; NUM_TABLES], challenges: GrandProductChallengeSet, config: &StarkConfig, ) -> Result<()> { @@ -617,7 +615,7 @@ pub(crate) fn verify_cross_table_lookups_circuit< >( builder: &mut CircuitBuilder, cross_table_lookups: Vec>, - proofs: &[StarkProofTarget], + proofs: &[StarkProofTarget; NUM_TABLES], challenges: GrandProductChallengeSet, inner_config: &StarkConfig, ) { diff --git a/evm/src/generation/mod.rs b/evm/src/generation/mod.rs index 67b65c31..5a1d0786 100644 --- a/evm/src/generation/mod.rs +++ b/evm/src/generation/mod.rs @@ -4,7 +4,7 @@ use plonky2::field::polynomial::PolynomialValues; use plonky2::field::types::Field; use plonky2::hash::hash_types::RichField; -use crate::all_stark::AllStark; +use crate::all_stark::{AllStark, NUM_TABLES}; use crate::cpu::bootstrap_kernel::generate_bootstrap_kernel; use crate::cpu::columns::NUM_CPU_COLUMNS; use crate::cpu::kernel::global_metadata::GlobalMetadata; @@ -45,7 +45,7 @@ pub struct GenerationInputs { pub(crate) fn generate_traces, const D: usize>( all_stark: &AllStark, inputs: GenerationInputs, -) -> (Vec>>, PublicValues) { +) -> ([Vec>; NUM_TABLES], PublicValues) { let mut state = GenerationState::::default(); generate_bootstrap_kernel::(&mut state); @@ -90,9 +90,16 @@ pub(crate) fn generate_traces, const D: usize>( let cpu_trace = trace_rows_to_poly_values(cpu_rows); let keccak_trace = all_stark.keccak_stark.generate_trace(keccak_inputs); + let keccak_memory_trace = all_stark.keccak_memory_stark.generate_trace(vec![], 16); // TODO let logic_trace = all_stark.logic_stark.generate_trace(logic_ops); let memory_trace = all_stark.memory_stark.generate_trace(memory.log); - let traces = vec![cpu_trace, keccak_trace, logic_trace, memory_trace]; + let traces = [ + cpu_trace, + keccak_trace, + keccak_memory_trace, + logic_trace, + memory_trace, + ]; let public_values = PublicValues { trie_roots_before, diff --git a/evm/src/get_challenges.rs b/evm/src/get_challenges.rs index 52c2b796..6545a1af 100644 --- a/evm/src/get_challenges.rs +++ b/evm/src/get_challenges.rs @@ -1,4 +1,3 @@ -use itertools::izip; use plonky2::field::extension::Extendable; use plonky2::fri::proof::{FriProof, FriProofTarget}; use plonky2::hash::hash_types::RichField; @@ -32,16 +31,18 @@ impl, C: GenericConfig, const D: usize> A let ctl_challenges = get_grand_product_challenge_set(&mut challenger, config.num_challenges); + let num_permutation_zs = all_stark.nums_permutation_zs(config); + let num_permutation_batch_sizes = all_stark.permutation_batch_sizes(); + AllProofChallenges { - stark_challenges: izip!( - &self.stark_proofs, - all_stark.nums_permutation_zs(config), - all_stark.permutation_batch_sizes() - ) - .map(|(proof, num_perm, batch_size)| { - proof.get_challenges(&mut challenger, num_perm > 0, batch_size, config) - }) - .collect(), + stark_challenges: std::array::from_fn(|i| { + self.stark_proofs[i].get_challenges( + &mut challenger, + num_permutation_zs[i] > 0, + num_permutation_batch_sizes[i], + config, + ) + }), ctl_challenges, } } @@ -66,22 +67,19 @@ impl AllProofTarget { let ctl_challenges = get_grand_product_challenge_set_target(builder, &mut challenger, config.num_challenges); + let num_permutation_zs = all_stark.nums_permutation_zs(config); + let num_permutation_batch_sizes = all_stark.permutation_batch_sizes(); + AllProofChallengesTarget { - stark_challenges: izip!( - &self.stark_proofs, - all_stark.nums_permutation_zs(config), - all_stark.permutation_batch_sizes() - ) - .map(|(proof, num_perm, batch_size)| { - proof.get_challenges::( + stark_challenges: std::array::from_fn(|i| { + self.stark_proofs[i].get_challenges::( builder, &mut challenger, - num_perm > 0, - batch_size, + num_permutation_zs[i] > 0, + num_permutation_batch_sizes[i], config, ) - }) - .collect(), + }), ctl_challenges, } } diff --git a/evm/src/proof.rs b/evm/src/proof.rs index 81512c78..a5bc61a7 100644 --- a/evm/src/proof.rs +++ b/evm/src/proof.rs @@ -13,38 +13,33 @@ use plonky2::iop::ext_target::ExtensionTarget; use plonky2::iop::target::Target; use plonky2::plonk::config::GenericConfig; +use crate::all_stark::NUM_TABLES; use crate::config::StarkConfig; use crate::permutation::GrandProductChallengeSet; #[derive(Debug, Clone)] pub struct AllProof, C: GenericConfig, const D: usize> { - pub stark_proofs: Vec>, + pub stark_proofs: [StarkProof; NUM_TABLES], pub public_values: PublicValues, } impl, C: GenericConfig, const D: usize> AllProof { - pub fn degree_bits(&self, config: &StarkConfig) -> Vec { - self.stark_proofs - .iter() - .map(|proof| proof.recover_degree_bits(config)) - .collect() + pub fn degree_bits(&self, config: &StarkConfig) -> [usize; NUM_TABLES] { + std::array::from_fn(|i| self.stark_proofs[i].recover_degree_bits(config)) } - pub fn nums_ctl_zs(&self) -> Vec { - self.stark_proofs - .iter() - .map(|proof| proof.openings.ctl_zs_last.len()) - .collect() + pub fn nums_ctl_zs(&self) -> [usize; NUM_TABLES] { + std::array::from_fn(|i| self.stark_proofs[i].openings.ctl_zs_last.len()) } } pub(crate) struct AllProofChallenges, const D: usize> { - pub stark_challenges: Vec>, + pub stark_challenges: [StarkProofChallenges; NUM_TABLES], pub ctl_challenges: GrandProductChallengeSet, } pub struct AllProofTarget { - pub stark_proofs: Vec>, + pub stark_proofs: [StarkProofTarget; NUM_TABLES], pub public_values: PublicValuesTarget, } @@ -99,7 +94,7 @@ pub struct BlockMetadataTarget { } pub(crate) struct AllProofChallengesTarget { - pub stark_challenges: Vec>, + pub stark_challenges: [StarkProofChallengesTarget; NUM_TABLES], pub ctl_challenges: GrandProductChallengeSet, } diff --git a/evm/src/prover.rs b/evm/src/prover.rs index 75152d61..5a23297a 100644 --- a/evm/src/prover.rs +++ b/evm/src/prover.rs @@ -17,7 +17,7 @@ use plonky2::util::timing::TimingTree; use plonky2::util::transpose; use plonky2_util::{log2_ceil, log2_strict}; -use crate::all_stark::{AllStark, Table}; +use crate::all_stark::{AllStark, Table, NUM_TABLES}; use crate::config::StarkConfig; use crate::constraint_consumer::ConstraintConsumer; use crate::cpu::cpu_stark::CpuStark; @@ -61,7 +61,7 @@ where pub(crate) fn prove_with_traces( all_stark: &AllStark, config: &StarkConfig, - trace_poly_values: Vec>>, + trace_poly_values: [Vec>; NUM_TABLES], public_values: PublicValues, timing: &mut TimingTree, ) -> Result> @@ -75,9 +75,6 @@ where [(); LogicStark::::COLUMNS]:, [(); MemoryStark::::COLUMNS]:, { - let num_starks = Table::num_tables(); - debug_assert_eq!(num_starks, trace_poly_values.len()); - let rate_bits = config.fri_config.rate_bits; let cap_height = config.fri_config.cap_height; @@ -163,14 +160,13 @@ where timing, )?; - let stark_proofs = vec![ + let stark_proofs = [ cpu_proof, keccak_proof, keccak_memory_proof, logic_proof, memory_proof, ]; - debug_assert_eq!(stark_proofs.len(), num_starks); Ok(AllProof { stark_proofs, diff --git a/evm/src/recursive_verifier.rs b/evm/src/recursive_verifier.rs index 217a07f7..800ee461 100644 --- a/evm/src/recursive_verifier.rs +++ b/evm/src/recursive_verifier.rs @@ -280,7 +280,7 @@ pub fn add_virtual_all_proof, const D: usize>( degree_bits: &[usize], nums_ctl_zs: &[usize], ) -> AllProofTarget { - let stark_proofs = vec![ + let stark_proofs = [ add_virtual_stark_proof( builder, all_stark.cpu_stark, @@ -317,7 +317,6 @@ pub fn add_virtual_all_proof, const D: usize>( nums_ctl_zs[Table::Memory as usize], ), ]; - assert_eq!(stark_proofs.len(), Table::num_tables()); let public_values = add_virtual_public_values(builder); AllProofTarget { From a1941308eb9ea3eed3785767349d44b57f5486a2 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 26 Aug 2022 11:07:16 +0200 Subject: [PATCH 2/3] Minor --- evm/src/generation/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/evm/src/generation/mod.rs b/evm/src/generation/mod.rs index 5a1d0786..5803d12c 100644 --- a/evm/src/generation/mod.rs +++ b/evm/src/generation/mod.rs @@ -90,7 +90,7 @@ pub(crate) fn generate_traces, const D: usize>( let cpu_trace = trace_rows_to_poly_values(cpu_rows); let keccak_trace = all_stark.keccak_stark.generate_trace(keccak_inputs); - let keccak_memory_trace = all_stark.keccak_memory_stark.generate_trace(vec![], 16); // TODO + let keccak_memory_trace = all_stark.keccak_memory_stark.generate_trace(vec![], 0); // TODO let logic_trace = all_stark.logic_stark.generate_trace(logic_ops); let memory_trace = all_stark.memory_stark.generate_trace(memory.log); let traces = [ From e7edfdd6a30d08fb7a0b2702c8b3795c9a126036 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 26 Aug 2022 18:30:26 +0200 Subject: [PATCH 3/3] Minor --- evm/src/generation/mod.rs | 7 ++++++- evm/src/prover.rs | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/evm/src/generation/mod.rs b/evm/src/generation/mod.rs index 5803d12c..5b0b3c8f 100644 --- a/evm/src/generation/mod.rs +++ b/evm/src/generation/mod.rs @@ -5,6 +5,7 @@ use plonky2::field::types::Field; use plonky2::hash::hash_types::RichField; use crate::all_stark::{AllStark, NUM_TABLES}; +use crate::config::StarkConfig; use crate::cpu::bootstrap_kernel::generate_bootstrap_kernel; use crate::cpu::columns::NUM_CPU_COLUMNS; use crate::cpu::kernel::global_metadata::GlobalMetadata; @@ -45,6 +46,7 @@ pub struct GenerationInputs { pub(crate) fn generate_traces, const D: usize>( all_stark: &AllStark, inputs: GenerationInputs, + config: &StarkConfig, ) -> ([Vec>; NUM_TABLES], PublicValues) { let mut state = GenerationState::::default(); @@ -83,6 +85,7 @@ pub(crate) fn generate_traces, const D: usize>( current_cpu_row, memory, keccak_inputs, + keccak_memory_inputs, logic_ops, .. } = state; @@ -90,7 +93,9 @@ pub(crate) fn generate_traces, const D: usize>( let cpu_trace = trace_rows_to_poly_values(cpu_rows); let keccak_trace = all_stark.keccak_stark.generate_trace(keccak_inputs); - let keccak_memory_trace = all_stark.keccak_memory_stark.generate_trace(vec![], 0); // TODO + let keccak_memory_trace = all_stark + .keccak_memory_stark + .generate_trace(keccak_memory_inputs, 1 << config.fri_config.cap_height); let logic_trace = all_stark.logic_stark.generate_trace(logic_ops); let memory_trace = all_stark.memory_stark.generate_trace(memory.log); let traces = [ diff --git a/evm/src/prover.rs b/evm/src/prover.rs index 5a23297a..31e76a1c 100644 --- a/evm/src/prover.rs +++ b/evm/src/prover.rs @@ -53,7 +53,7 @@ where [(); LogicStark::::COLUMNS]:, [(); MemoryStark::::COLUMNS]:, { - let (traces, public_values) = generate_traces(all_stark, inputs); + let (traces, public_values) = generate_traces(all_stark, inputs, config); prove_with_traces(all_stark, config, traces, public_values, timing) }