Add CTL verification

evm/src/cross_table_lookup.rs

@@ -621,18 +621,12 @@ pub(crate) fn verify_cross_table_lookups<
     const D: usize,
 >(
     cross_table_lookups: Vec<CrossTableLookup<F>>,
-    proofs: &[StarkProof<F, C, D>; NUM_TABLES],
+    ctl_zs_lasts: [Vec<F>; NUM_TABLES],
+    degrees_bits: [usize; NUM_TABLES],
     challenges: GrandProductChallengeSet<F>,
     config: &StarkConfig,
 ) -> Result<()> {
-    let degrees_bits = proofs
-        .iter()
-        .map(|p| p.recover_degree_bits(config))
-        .collect::<Vec<_>>();
-    let mut ctl_zs_openings = proofs
-        .iter()
-        .map(|p| p.openings.ctl_zs_last.iter())
-        .collect::<Vec<_>>();
+    let mut ctl_zs_openings = ctl_zs_lasts.iter().map(|v| v.iter()).collect::<Vec<_>>();
     for (
         i,
         CrossTableLookup {

evm/src/get_challenges.rs

@@ -229,7 +229,6 @@ impl<const D: usize> StarkProofTarget<D> {
 
         challenger.observe_cap(quotient_polys_cap);
         let stark_zeta = challenger.get_extension_challenge(builder);
-        dbg!(stark_zeta);
 
         challenger.observe_openings(&openings.to_fri_openings(builder.zero()));
 

evm/src/recursive_verifier.rs

@@ -25,7 +25,8 @@ use crate::config::StarkConfig;
 use crate::constraint_consumer::RecursiveConstraintConsumer;
 use crate::cpu::cpu_stark::CpuStark;
 use crate::cross_table_lookup::{
-    verify_cross_table_lookups_circuit, CrossTableLookup, CtlCheckVarsTarget,
+    verify_cross_table_lookups, verify_cross_table_lookups_circuit, CrossTableLookup,
+    CtlCheckVarsTarget,
 };
 use crate::keccak::keccak_stark::KeccakStark;
 use crate::keccak_memory::keccak_memory_stark::KeccakMemoryStark;
@@ -54,6 +55,7 @@ pub struct RecursiveAllProof<
 > {
     pub recursive_proofs:
         [(ProofWithPublicInputs<F, C, D>, VerifierCircuitData<F, C, D>); NUM_TABLES],
+    pub cross_table_lookups: Vec<CrossTableLookup<F>>,
 }
 
 struct PublicInputs<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {
@@ -131,13 +133,16 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
         let state = challenger.state();
         ensure!(state == pis[0].challenger_state_before);
         for i in 1..NUM_TABLES {
-            dbg!(i);
-            dbg!(
-                pis[i].challenger_state_before,
-                pis[i - 1].challenger_state_after
-            );
             ensure!(pis[i].challenger_state_before == pis[i - 1].challenger_state_after);
         }
+        let degrees_bits = std::array::from_fn(|i| self.recursive_proofs[i].1.common.degree_bits);
+        verify_cross_table_lookups::<F, C, D>(
+            self.cross_table_lookups,
+            pis.map(|p| p.ctl_zs_last),
+            degrees_bits,
+            ctl_challenges,
+            inner_config,
+        )?;
         for (proof, verifier_data) in self.recursive_proofs {
             verifier_data.verify(proof)?;
         }
@@ -344,6 +349,7 @@ where
                 &circuit_config,
             )?,
         ],
+        cross_table_lookups: all_stark.cross_table_lookups.clone(),
     })
 }
 

evm/src/verifier.rs

@@ -95,9 +95,12 @@ where
         config,
     )?;
 
-    verify_cross_table_lookups(
+    let degrees_bits =
+        std::array::from_fn(|i| all_proof.stark_proofs[i].recover_degree_bits(config));
+    verify_cross_table_lookups::<F, C, D>(
         cross_table_lookups,
-        &all_proof.stark_proofs,
+        all_proof.stark_proofs.map(|p| p.openings.ctl_zs_last),
+        degrees_bits,
         ctl_challenges,
         config,
     )