From 0bc3f20479a734af1c25ff8b3757b4dc0433b480 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Thu, 6 Oct 2022 16:32:35 +0200 Subject: [PATCH] PR feedback --- evm/src/all_stark.rs | 5 +- evm/src/recursive_verifier.rs | 94 ++--------------------------------- 2 files changed, 7 insertions(+), 92 deletions(-) diff --git a/evm/src/all_stark.rs b/evm/src/all_stark.rs index 82c19fc2..177591fd 100644 --- a/evm/src/all_stark.rs +++ b/evm/src/all_stark.rs @@ -205,7 +205,7 @@ mod tests { use crate::prover::prove_with_traces; use crate::recursive_verifier::{ add_virtual_recursive_all_proof, all_verifier_data_recursive_stark_proof, - recursively_verify_all_proof, set_recursive_all_proof_target, + recursively_verify_all_proof, set_recursive_all_proof_target, RecursiveAllProof, }; use crate::stark::Stark; use crate::util::{limb_from_bits_le, trace_rows_to_poly_values}; @@ -360,6 +360,7 @@ mod tests { let row: &mut cpu::columns::CpuColumnsView = cpu_trace_rows[clock].borrow_mut(); row.clock = F::from_canonical_usize(clock); + dbg!(channel, row.mem_channels.len()); let channel = &mut row.mem_channels[channel]; channel.used = F::ONE; channel.is_read = memory_trace[memory::columns::IS_READ].values[i]; @@ -788,7 +789,7 @@ mod tests { &recursive_all_proof, &verifier_data, ); - recursive_all_proof.verify_circuit( + RecursiveAllProof::verify_circuit( &mut builder, recursive_all_proof_target, &verifier_data, diff --git a/evm/src/recursive_verifier.rs b/evm/src/recursive_verifier.rs index 766382e4..1ef493a0 100644 --- a/evm/src/recursive_verifier.rs +++ b/evm/src/recursive_verifier.rs @@ -164,7 +164,6 @@ impl, C: GenericConfig, const D: usize> /// Recursively verify every recursive proof. pub fn verify_circuit( - self, builder: &mut CircuitBuilder, recursive_all_proof_target: RecursiveAllProofTargetWithData, verifier_data: &[VerifierCircuitData; NUM_TABLES], @@ -243,97 +242,11 @@ impl, C: GenericConfig, const D: usize> ); } } - - /// Verifier data to recursively verify every recursive proof. - pub fn verifier_data_verify_circuit( - self, - builder: &mut CircuitBuilder, - pw: &mut W, - verifier_data: &[VerifierCircuitData; NUM_TABLES], - cross_table_lookups: Vec>, - inner_config: &StarkConfig, - ) where - W: Witness, - [(); C::Hasher::HASH_SIZE]:, - >::Hasher: AlgebraicHasher, - { - let proofs_target: [_; NUM_TABLES] = std::array::from_fn(|i| { - let verifier_data = &verifier_data[i]; - let proof = &self.recursive_proofs[i]; - let pt = builder.add_virtual_proof_with_pis(&verifier_data.common); - pw.set_proof_with_pis_target(&pt, proof); - let inner_data = VerifierCircuitTarget { - constants_sigmas_cap: builder - .add_virtual_cap(verifier_data.common.config.fri_config.cap_height), - }; - pw.set_cap_target( - &inner_data.constants_sigmas_cap, - &verifier_data.verifier_only.constants_sigmas_cap, - ); - (pt, inner_data) - }); - - let pis: [_; NUM_TABLES] = std::array::from_fn(|i| { - PublicInputs::from_vec(&proofs_target[i].0.public_inputs, inner_config) - }); - - let mut challenger = RecursiveChallenger::::new(builder); - for pi in &pis { - for h in &pi.trace_cap { - challenger.observe_elements(h); - } - } - let ctl_challenges = get_grand_product_challenge_set_target( - builder, - &mut challenger, - inner_config.num_challenges, - ); - // Check that the correct CTL challenges are used in every proof. - for pi in &pis { - for i in 0..inner_config.num_challenges { - builder.connect( - ctl_challenges.challenges[i].beta, - pi.ctl_challenges.challenges[i].beta, - ); - builder.connect( - ctl_challenges.challenges[i].gamma, - pi.ctl_challenges.challenges[i].gamma, - ); - } - } - - let state = challenger.compact(builder); - for k in 0..SPONGE_WIDTH { - builder.connect(state[k], pis[0].challenger_state_before[k]); - } - // Check that the challenger state is consistent between proofs. - for i in 1..NUM_TABLES { - for k in 0..SPONGE_WIDTH { - builder.connect( - pis[i].challenger_state_before[k], - pis[i - 1].challenger_state_after[k], - ); - } - } - - // Verify the CTL checks. - let degrees_bits = std::array::from_fn(|i| verifier_data[i].common.degree_bits); - verify_cross_table_lookups_circuit::( - builder, - cross_table_lookups, - pis.map(|p| p.ctl_zs_last), - degrees_bits, - ctl_challenges, - inner_config, - ); - for (i, (proof_target, inner_data)) in proofs_target.into_iter().enumerate() { - builder.verify_proof(proof_target, &inner_data, &verifier_data[i].common); - } - } } /// Recursively verify a Stark proof. /// Outputs the recursive proof and the associated verifier data. +#[cfg(test)] fn recursively_verify_stark_proof< F: RichField + Extendable, C: GenericConfig, @@ -576,6 +489,7 @@ where } /// Recursively verify every Stark proof in an `AllProof`. +#[cfg(test)] pub fn recursively_verify_all_proof< F: RichField + Extendable, C: GenericConfig, @@ -934,12 +848,12 @@ pub fn add_virtual_stark_proof, S: Stark, con trace_cap: builder.add_virtual_cap(cap_height), permutation_ctl_zs_cap: permutation_zs_cap, quotient_polys_cap: builder.add_virtual_cap(cap_height), - openings: add_stark_opening_set::(builder, stark, num_ctl_zs, config), + openings: add_virtual_stark_opening_set::(builder, stark, num_ctl_zs, config), opening_proof: builder.add_virtual_fri_proof(&num_leaves_per_oracle, &fri_params), } } -fn add_stark_opening_set, S: Stark, const D: usize>( +fn add_virtual_stark_opening_set, S: Stark, const D: usize>( builder: &mut CircuitBuilder, stark: &S, num_ctl_zs: usize,