Merge pull request #1378 from scroll-tech/feat/recursion_pcs

recursion-v2: add PCS aggregation checks

Author: hero78119

ceno_recursion_v2/Cargo.lock

@@ -1,5 +1,4 @@
-use openvm_poseidon2_air::POSEIDON2_WIDTH;
-use openvm_stark_sdk::config::baby_bear_poseidon2::D_EF;
+use openvm_stark_sdk::config::baby_bear_poseidon2::{D_EF, DIGEST_SIZE};
 use recursion_circuit::{
     bus as upstream, define_typed_per_proof_lookup_bus, define_typed_per_proof_permutation_bus,
 };
@@ -274,3 +273,249 @@ pub struct TowerMainPointMessage<T> {
 }
 
 define_typed_per_proof_lookup_bus!(TowerMainPointBus, TowerMainPointMessage);
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum PcsBasefoldQueryStage {
+    ReducedOpening = 0,
+    FinalFolded = 1,
+    QueryIndex = 2,
+    FinalCodewordStart = 3,
+}
+
+impl PcsBasefoldQueryStage {
+    pub const fn as_usize(self) -> usize {
+        self as usize
+    }
+}
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBasefoldQueryMessage<T> {
+    pub query_idx: T,
+    pub stage: T,
+    pub round: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsBasefoldQueryBus, PcsBasefoldQueryMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBaseInputOpeningMessage<T> {
+    pub query_idx: T,
+    pub opening_idx: T,
+    pub reduced_index: T,
+    pub value_idx: T,
+    pub elem_idx: T,
+    pub log2_height: T,
+    pub opened_value: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsBaseInputOpeningBus, PcsBaseInputOpeningMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsFinalMessageMessage<T> {
+    pub tidx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsFinalMessageBus, PcsFinalMessageMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsQuerySampleMessage<T> {
+    pub tidx: T,
+    pub value: T,
+}
+
+define_typed_per_proof_lookup_bus!(PcsQuerySampleBus, PcsQuerySampleMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsCommitmentRootMessage<T> {
+    pub commit_major: T,
+    pub commit_minor: T,
+    pub root: [T; DIGEST_SIZE],
+}
+
+define_typed_per_proof_lookup_bus!(PcsCommitmentRootBus, PcsCommitmentRootMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsCommitPhaseLeafMessage<T> {
+    pub query_idx: T,
+    pub round: T,
+    pub leaf_idx: T,
+    pub left: [T; D_EF],
+    pub right: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsCommitPhaseLeafBus, PcsCommitPhaseLeafMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsSumcheckClaimMessage<T> {
+    pub idx: T,
+    pub claim: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsSumcheckClaimBus, PcsSumcheckClaimMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsSumcheckInputMessage<T> {
+    pub idx: T,
+    pub claim: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsSumcheckInputBus, PcsSumcheckInputMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsSumcheckOutputMessage<T> {
+    pub idx: T,
+    pub claim: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsSumcheckOutputBus, PcsSumcheckOutputMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBasefoldFinalExpectedMessage<T> {
+    pub sumcheck_idx: T,
+    pub expected: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(
+    PcsBasefoldFinalExpectedBus,
+    PcsBasefoldFinalExpectedMessage
+);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBasefoldFinalPointMessage<T> {
+    pub sumcheck_idx: T,
+    pub point_idx: T,
+    pub coord_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_permutation_bus!(PcsBasefoldFinalPointBus, PcsBasefoldFinalPointMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsFoldChallengeMessage<T> {
+    pub sumcheck_idx: T,
+    pub round: T,
+    pub challenge: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsFoldChallengeBus, PcsFoldChallengeMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBatchCoeffMessage<T> {
+    pub global_coeff_idx: T,
+    pub coeff: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsBatchCoeffBus, PcsBatchCoeffMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBatchAlphaMessage<T> {
+    pub tidx: T,
+    pub alpha: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsBatchAlphaBus, PcsBatchAlphaMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsBasefoldEvalMessage<T> {
+    pub tidx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsBasefoldEvalBus, PcsBasefoldEvalMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsTranscriptExtMessage<T> {
+    pub tidx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsTranscriptExtBus, PcsTranscriptExtMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsJaggedFEvalMessage<T> {
+    pub sumcheck_idx: T,
+    pub tidx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsJaggedFEvalBus, PcsJaggedFEvalMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsOpeningEvalMessage<T> {
+    pub opening_idx: T,
+    pub commit_kind: T,
+    pub eval_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsOpeningEvalBus, PcsOpeningEvalMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsEqProductMessage<T> {
+    pub kind: T,
+    pub round_idx: T,
+    pub term_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsEqProductBus, PcsEqProductMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsSuffixProductMessage<T> {
+    pub round_idx: T,
+    pub term_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsSuffixProductBus, PcsSuffixProductMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsJaggedAssistHMessage<T> {
+    pub round_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsJaggedAssistHBus, PcsJaggedAssistHMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsJaggedAssistQMessage<T> {
+    pub round_idx: T,
+    pub value: [T; D_EF],
+}
+
+define_typed_per_proof_lookup_bus!(PcsJaggedAssistQBus, PcsJaggedAssistQMessage);
+
+#[repr(C)]
+#[derive(stark_recursion_circuit_derive::AlignedBorrow, Debug, Clone, Copy)]
+pub struct PcsCommitHeightMessage<T> {
+    pub commitment_kind: T,
+    pub height_idx: T,
+    pub value: T,
+}
+
+define_typed_per_proof_lookup_bus!(PcsCommitHeightBus, PcsCommitHeightMessage);

ceno_recursion_v2/src/bus.rs

@@ -70,8 +70,10 @@ impl<SC: StarkProtocolConfig<F = F>, S: AggregationSubCircuit> Circuit<SC> for I
             deferral_enabled,
             instance_public_value_indices: self.instance_public_value_indices.clone(),
         }) as AirRef<SC>;
-        let vm_pvs_cumulative_heights_air =
-            Arc::new(vm_pvs::VmPvsCumulativeHeightsAir { transcript_bus }) as AirRef<SC>;
+        let vm_pvs_cumulative_heights_air = Arc::new(vm_pvs::VmPvsCumulativeHeightsAir {
+            transcript_bus,
+            commit_height_bus: bus_inventory.pcs_commit_height_bus,
+        }) as AirRef<SC>;
         let (idx2_air, post_airs): (AirRef<SC>, Vec<AirRef<SC>>) = if deferral_enabled {
             let def_pvs_air = Arc::new(def_pvs::DeferralPvsAir {
                 public_values_bus,

ceno_recursion_v2/src/circuit/inner/mod.rs

@@ -46,13 +46,13 @@ pub fn generate_proving_ctx(
 
     let mut trace = vec![F::ZERO; rows * width];
 
-    if rows > 0 {
-        let first_row = &mut trace[..width];
+    for proof_idx in 0..proofs.len().max(1) {
+        let row = &mut trace[proof_idx * width..(proof_idx + 1) * width];
         let base_width = VerifierPvsCols::<u8>::width();
-        let (base_row, def_row) = first_row.split_at_mut(base_width);
+        let (base_row, def_row) = row.split_at_mut(base_width);
 
         let cols: &mut VerifierPvsCols<F> = base_row.borrow_mut();
-        cols.proof_idx = F::ZERO;
+        cols.proof_idx = F::from_usize(proof_idx);
         cols.is_valid = F::ONE;
         cols.has_verifier_pvs = F::ZERO;
         for (dst, digest_elem) in cols.child_vk_digest.iter_mut().zip(child_vk_digest) {
@@ -61,7 +61,7 @@ pub fn generate_proving_ctx(
 
         if deferral_enabled {
             let def_cols: &mut VerifierDeferralCols<F> = def_row.borrow_mut();
-            def_cols.is_last = F::ONE;
+            def_cols.is_last = F::from_bool(proof_idx + 1 == proofs.len().max(1));
             def_cols.child_pvs.deferral_flag = F::ZERO;
         }
     }