feat: root circuit uses re-introduced DagCommitSubAir (#2602)

Resolves INT-6981 and INT-6982. The PR to remove `DagCommitSubAir` is
[here](https://github.com/openvm-org/openvm/pull/2533/changes).

## Overview

This branch does two primary things:

1. Re-introduces `DagCommitSubAir` into the recursion circuit (reversing
the recursion-side functional removal from
`c6e042f3b8f833dde0222cb48d5c81f04e2274f8`).
2. Moves the root prover path to **no cached trace** mode (`has_cached =
false`), using `CachedTraceCtx::Records` instead of cached PCS data.

Branch commits:
- `a97b89e37` — re-introduce `DagCommitSubAir` into recursion + API
plumbing updates
- `27e1c48d9` — root prover switched to no-cached mode
- `6a25c5b35` — follow-up compile/test/type fixes

## Review Guide
Suggested review order:
1. **Recursion DagCommit reintroduction** (`crates/recursion/**`)
2. **Root prover no-cached flow**
(`crates/continuations/src/prover/root/**`)
3. **Cross-crate API updates** (`continuations` non-root traces,
`guest-libs/verify-stark/circuit`, `sdk`, tests)

---

## 1) Recursion: DagCommitSubAir Reintroduced

### 1.1 New DagCommit sub-AIR implementation
Files:
- `crates/recursion/src/batch_constraint/expr_eval/dag_commit.rs` (new)
- `crates/recursion/src/batch_constraint/expr_eval/mod.rs`

What changed:
- Restores `DagCommitSubAir`, `DagCommitCols`, `DagCommitPvs`, and
helper logic for digest packing/collapse.
- Adds `DagCommitInfo` generation (`commit` + Poseidon2 input stream)
for no-cached mode.

### 1.2 SymbolicExpressionAir dual-mode behavior (cached vs no-cached)
Files:
-
`crates/recursion/src/batch_constraint/expr_eval/symbolic_expression/air.rs`

What changed:
- `SymbolicExpressionAir` now carries `dag_commit_subair:
Option<Arc<DagCommitSubAir<_>>>`.
- In cached mode:
- uses cached main width (`CachedSymbolicExpressionColumns`), zero
public values.
- In no-cached mode:
  - prefixes common main with `DagCommitCols`,
  - exposes `DagCommitPvs` public values,
  - evaluates DagCommit sub-AIR directly from common main prefix.

### 1.3 Trace generation restored for no-cached mode
Files:
-
`crates/recursion/src/batch_constraint/expr_eval/symbolic_expression/trace.rs`

What changed:
- `SymbolicExpressionTraceGenerator` now takes `has_cached`.
- `CachedTraceRecord` again carries optional `dag_commit_info`.
- `build_cached_trace_record(child_vk, has_cached)` computes DagCommit
inputs/commit when `has_cached == false`.
- CPU tracegen writes DagCommit columns + symbolic-expression columns in
no-cached mode.

### 1.4 Batch constraint/system plumbing and explicit cached context API
Files:
- `crates/recursion/src/batch_constraint/mod.rs`
- `crates/recursion/src/system/mod.rs`

What changed:
- `BatchConstraintModule` now stores `has_cached` and configures
`SymbolicExpressionAir` accordingly.
- `VerifierConfig` includes `has_cached`.
- Reintroduces explicit `CachedTraceCtx<PB>` API:
  - `PcsData(CommittedTraceData<PB>)`
  - `Records(CachedTraceRecord)`
- `VerifierTraceGen::generate_proving_ctxs(_base)` now accepts
`CachedTraceCtx` again.
- CPU/GPU verifier tracegen paths now set either:
  - `cached_mains` from `PcsData`, or
  - symbolic-expression public values from `Records` (DagCommit commit).

Note:
- `DagCommitBus` is **not** reintroduced. DagCommit remains folded as
sub-AIR, so bus-level wiring is still intentionally absent.

### 1.5 CUDA symbolic-expression DagCommit path restored
Files:
- `crates/recursion/cuda/src/batch_constraint/expr_eval/dag_commit.cuh`
(new)
-
`crates/recursion/cuda/src/batch_constraint/expr_eval/symbolic_expression.cu`
- `crates/recursion/src/batch_constraint/cuda_abi.rs`
- `crates/recursion/src/batch_constraint/cuda_utils.rs`

What changed:
- Restores DagCommit column writing in CUDA symbolic-expression tracegen
when no-cached mode is used.
- Adds per-row cached metadata (`CachedGpuRecord`) carrying Poseidon2
start state + `is_constraint`.
- `_sym_expr_common_tracegen`/Rust ABI now takes `d_cached_records`
pointer.

---

## 2) Continuations Root Prover: No Cached Trace

Files:
- `crates/continuations/src/prover/root/mod.rs`
- `crates/continuations/src/prover/root/trace.rs`
- `crates/continuations/src/prover/mod.rs`

What changed:
- Root verifier subcircuit is built with `VerifierConfig { has_cached:
false, ... }`.
- Root prover now computes/stores `CachedTraceRecord` and feeds
recursion via:
  - `CachedTraceCtx::Records(self.cached_trace_record.clone())`
- Removed root prover dependency on cached PCS data for recursion
tracegen (`child_vk_pcs_data` removed).
- Removed root cached-commit getter (no longer needed by root path).
- Simplified `RootProver` type shape by removing struct-level `PB`;
backend type is now method-generic.
- Updated root prover aliases accordingly.

---

## 3) Cross-Crate API Compatibility Updates

### 3.1 Continuations non-root prover calls updated to explicit
`CachedTraceCtx`
Files:
- `crates/continuations/src/prover/inner/trace.rs`
- `crates/continuations/src/prover/deferral/inner/trace.rs`
- `crates/continuations/src/prover/deferral/hook/trace.rs`

What changed:
- Calls to recursion `generate_proving_ctxs` now pass
`CachedTraceCtx::PcsData(...)`.

### 3.2 Verify-stark guest lib updated for recursion API changes
Files:
- `guest-libs/verify-stark/circuit/src/prover/mod.rs`
- `guest-libs/verify-stark/circuit/src/prover/trace.rs`

What changed:
- Sets `VerifierConfig.has_cached = true` explicitly where required.
- Uses `CachedTraceCtx::PcsData(...)` for recursion tracegen calls.

### 3.3 SDK/test call-site inference fixes after root prover generic
changes
Files:
- `crates/sdk/src/prover/root.rs`
- `crates/continuations/src/tests/mod.rs`
- `crates/continuations/src/tests/e2e.rs`

What changed:
- Adds explicit PB typing where inference became ambiguous after moving
root prover backend typing to method generics.

---

## 4) Test Updates

Files:
- `crates/recursion/src/tests.rs`

What changed:
- Adds coverage for no-cached DagCommit-subAIR path:
  - `test_recursion_circuit_dag_commit_subair`
  - uses `MixtureFixture::standard(...)`
  - builds verifier with `has_cached: false`
  - runs with `CachedTraceCtx::Records(...)`.
- Existing recursion tests updated to pass
`CachedTraceCtx::PcsData(...)` where appropriate.

---

## Primary Reviewer Focus
If you only review a subset, prioritize:
1. `recursion` symbolic-expression + DagCommit integration (`air.rs`,
`trace.rs`, `dag_commit.rs`, system wiring)
2. root prover no-cached migration (`continuations/prover/root/*`)
3. CUDA DagCommit tracegen plumbing (`symbolic_expression.cu`,
`cuda_abi.rs`, `cuda_utils.rs`)

---------

Co-authored-by: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com>

Author: stephenh-axiom-xyz

Cargo.lock

@@ -2,7 +2,7 @@ use std::iter::once;
 
 use itertools::Itertools;
 use openvm_recursion_circuit::system::{
-    AggregationSubCircuit, VerifierExternalData, VerifierTraceGen,
+    AggregationSubCircuit, CachedTraceCtx, VerifierExternalData, VerifierTraceGen,
 };
 use openvm_stark_backend::{
     proof::Proof,
@@ -58,7 +58,7 @@ where
             .verifier_circuit
             .generate_proving_ctxs(
                 &self.child_vk,
-                self.child_vk_pcs_data.clone(),
+                CachedTraceCtx::PcsData(self.child_vk_pcs_data.clone()),
                 proof_slice,
                 &mut external_data,
                 default_duplex_sponge_recorder(),

crates/continuations/src/prover/deferral/hook/trace.rs

@@ -2,7 +2,7 @@ use std::iter::once;
 
 use itertools::Itertools;
 use openvm_recursion_circuit::system::{
-    AggregationSubCircuit, VerifierExternalData, VerifierTraceGen,
+    AggregationSubCircuit, CachedTraceCtx, VerifierExternalData, VerifierTraceGen,
 };
 use openvm_stark_backend::{
     proof::Proof,
@@ -85,7 +85,7 @@ where
             .verifier_circuit
             .generate_proving_ctxs(
                 child_vk,
-                child_vk_pcs_data,
+                CachedTraceCtx::PcsData(child_vk_pcs_data),
                 proofs,
                 &mut external_data,
                 default_duplex_sponge_recorder(),

crates/continuations/src/prover/deferral/inner/trace.rs

@@ -1,6 +1,6 @@
 use itertools::Itertools;
 use openvm_recursion_circuit::system::{
-    AggregationSubCircuit, VerifierExternalData, VerifierTraceGen,
+    AggregationSubCircuit, CachedTraceCtx, VerifierExternalData, VerifierTraceGen,
 };
 use openvm_stark_backend::{
     proof::Proof,
@@ -70,7 +70,7 @@ where
             .verifier_circuit
             .generate_proving_ctxs(
                 child_vk,
-                child_vk_pcs_data,
+                CachedTraceCtx::PcsData(child_vk_pcs_data),
                 proofs,
                 &mut external_data,
                 default_duplex_sponge_recorder(),

crates/continuations/src/prover/inner/trace.rs

@@ -4,7 +4,7 @@ use openvm_cuda_backend::GpuBackend;
 use openvm_recursion_circuit::system::VerifierSubCircuit;
 
 #[cfg(feature = "root-prover")]
-use crate::{circuit::root::RootTraceGenImpl, RootSC};
+use crate::circuit::root::RootTraceGenImpl;
 use crate::{
     circuit::{
         deferral::{hook::DeferralHookTraceGenImpl, inner::DeferralInnerTraceGenImpl},
@@ -33,13 +33,9 @@ pub type InnerGpuProver<const MAX_NUM_PROOFS: usize> =
     InnerAggregationProver<GpuBackend, VerifierSubCircuit<MAX_NUM_PROOFS>, InnerTraceGenImpl>;
 
 #[cfg(feature = "root-prover")]
-pub type RootCpuProver = RootProver<CpuBackend<RootSC>, VerifierSubCircuit<1>, RootTraceGenImpl>;
+pub type RootCpuProver = RootProver<VerifierSubCircuit<1>, RootTraceGenImpl>;
 #[cfg(all(feature = "cuda", feature = "root-prover"))]
-pub type RootGpuProver = RootProver<
-    <openvm_cuda_backend::BabyBearBn254Poseidon2GpuEngine as openvm_stark_backend::StarkEngine>::PB,
-    VerifierSubCircuit<1>,
-    RootTraceGenImpl,
->;
+pub type RootGpuProver = RootProver<VerifierSubCircuit<1>, RootTraceGenImpl>;
 
 pub type DeferralInnerCpuProver =
     DeferralInnerProver<CpuBackend<SC>, VerifierSubCircuit<2>, DeferralInnerTraceGenImpl>;

crates/continuations/src/prover/mod.rs

@@ -2,11 +2,14 @@ use std::sync::Arc;
 
 use eyre::Result;
 use openvm_circuit::system::memory::dimensions::MemoryDimensions;
-use openvm_recursion_circuit::system::{AggregationSubCircuit, VerifierConfig, VerifierTraceGen};
+use openvm_recursion_circuit::{
+    batch_constraint::expr_eval::CachedTraceRecord,
+    system::{AggregationSubCircuit, VerifierConfig, VerifierTraceGen},
+};
 use openvm_stark_backend::{
     keygen::types::{MultiStarkProvingKey, MultiStarkVerifyingKey},
     proof::Proof,
-    prover::{CommittedTraceData, DeviceDataTransporter, ProverBackend, ProvingContext},
+    prover::{DeviceDataTransporter, ProverBackend, ProvingContext},
     StarkEngine, SystemParams,
 };
 use openvm_stark_sdk::config::baby_bear_poseidon2::{EF, F};
@@ -25,35 +28,28 @@ use crate::{
 
 mod trace;
 
-pub struct RootProver<
-    PB: ProverBackend<Val = F, Challenge = EF>,
-    S: AggregationSubCircuit,
-    T: RootTraceGen<PB>,
-> {
+pub struct RootProver<S: AggregationSubCircuit, T> {
     pk: Arc<MultiStarkProvingKey<RootSC>>,
     vk: Arc<MultiStarkVerifyingKey<RootSC>>,
 
     agg_node_tracegen: T,
 
     child_vk: Arc<MultiStarkVerifyingKey<SC>>,
-    child_vk_pcs_data: CommittedTraceData<PB>,
+    cached_trace_record: CachedTraceRecord,
     circuit: Arc<RootCircuit<S>>,
     trace_heights: Option<Vec<usize>>,
 }
 
-impl<
-        PB: ProverBackend<Val = F, Challenge = EF, Commitment = [Bn254; 1]>,
-        S: AggregationSubCircuit + VerifierTraceGen<PB, RootSC>,
-        T: RootTraceGen<PB>,
-    > RootProver<PB, S, T>
-where
-    PB::Matrix: Clone,
-{
+impl<S: AggregationSubCircuit, T> RootProver<S, T> {
     #[instrument(name = "total_proof", skip_all)]
-    pub fn root_prove_from_ctx<E: StarkEngine<SC = RootSC, PB = PB>>(
-        &self,
-        ctx: ProvingContext<PB>,
-    ) -> Result<Proof<RootSC>> {
+    pub fn root_prove_from_ctx<E>(&self, ctx: ProvingContext<E::PB>) -> Result<Proof<RootSC>>
+    where
+        E: StarkEngine<SC = RootSC>,
+        E::PB: ProverBackend<Val = F, Challenge = EF, Commitment = [Bn254; 1]>,
+        <E::PB as ProverBackend>::Matrix: Clone,
+        S: VerifierTraceGen<E::PB, RootSC>,
+        T: RootTraceGen<E::PB>,
+    {
         if tracing::enabled!(tracing::Level::DEBUG) {
             trace_heights_tracing_info::<_, RootSC>(&ctx.per_trace, &self.circuit.airs());
         }
@@ -68,13 +64,8 @@ where
     }
 }
 
-impl<
-        PB: ProverBackend<Val = F, Challenge = EF, Commitment = [Bn254; 1]>,
-        S: AggregationSubCircuit + VerifierTraceGen<PB, RootSC>,
-        T: RootTraceGen<PB>,
-    > RootProver<PB, S, T>
-{
-    pub fn new<E: StarkEngine<SC = RootSC, PB = PB>>(
+impl<S: AggregationSubCircuit, T> RootProver<S, T> {
+    pub fn new<E>(
         child_vk: Arc<MultiStarkVerifyingKey<SC>>,
         internal_recursive_cached_commit: CommitBytes,
         system_params: SystemParams,
@@ -84,20 +75,24 @@ impl<
         trace_heights: Option<Vec<usize>>,
     ) -> Self
     where
-        E::PD: DeviceDataTransporter<RootSC, PB> + Clone,
-        PB::Val: Field + PrimeField32,
-        PB::Matrix: Clone,
-        PB::Commitment: Into<CommitBytes>,
+        E: StarkEngine<SC = RootSC>,
+        E::PB: ProverBackend<Val = F, Challenge = EF, Commitment = [Bn254; 1]>,
+        S: VerifierTraceGen<E::PB, RootSC>,
+        T: RootTraceGen<E::PB>,
+        E::PD: DeviceDataTransporter<RootSC, E::PB> + Clone,
+        <E::PB as ProverBackend>::Val: Field + PrimeField32,
+        <E::PB as ProverBackend>::Matrix: Clone,
     {
         let verifier_circuit = S::new(
             child_vk.clone(),
             VerifierConfig {
                 continuations_enabled: true,
+                has_cached: false,
                 ..Default::default()
             },
         );
+        let cached_trace_record = verifier_circuit.cached_trace_record(&child_vk);
         let engine = E::new(system_params);
-        let child_vk_pcs_data = verifier_circuit.commit_child_vk(&engine, &child_vk);
         let internal_recursive_dag_commit = DagCommitBytes {
             cached_commit: internal_recursive_cached_commit,
             pre_hash: child_vk.pre_hash.into(),
@@ -115,13 +110,13 @@ impl<
             vk: Arc::new(vk),
             agg_node_tracegen: T::new(def_hook_vk_commit.is_some()),
             child_vk,
-            child_vk_pcs_data,
+            cached_trace_record,
             circuit,
             trace_heights,
         }
     }
 
-    pub fn from_pk<E: StarkEngine<SC = RootSC, PB = PB>>(
+    pub fn from_pk<E>(
         child_vk: Arc<MultiStarkVerifyingKey<SC>>,
         internal_recursive_cached_commit: CommitBytes,
         pk: Arc<MultiStarkProvingKey<RootSC>>,
@@ -131,19 +126,22 @@ impl<
         trace_heights: Option<Vec<usize>>,
     ) -> Self
     where
-        PB::Val: Field + PrimeField32,
-        PB::Matrix: Clone,
-        PB::Commitment: Into<CommitBytes>,
+        E: StarkEngine<SC = RootSC>,
+        E::PB: ProverBackend<Val = F, Challenge = EF, Commitment = [Bn254; 1]>,
+        S: VerifierTraceGen<E::PB, RootSC>,
+        T: RootTraceGen<E::PB>,
+        <E::PB as ProverBackend>::Val: Field + PrimeField32,
+        <E::PB as ProverBackend>::Matrix: Clone,
     {
         let verifier_circuit = S::new(
             child_vk.clone(),
             VerifierConfig {
                 continuations_enabled: true,
+                has_cached: false,
                 ..Default::default()
             },
         );
-        let engine = E::new(pk.params.clone());
-        let child_vk_pcs_data = verifier_circuit.commit_child_vk(&engine, &child_vk);
+        let cached_trace_record = verifier_circuit.cached_trace_record(&child_vk);
         let internal_recursive_dag_commit = DagCommitBytes {
             cached_commit: internal_recursive_cached_commit,
             pre_hash: child_vk.pre_hash.into(),
@@ -161,7 +159,7 @@ impl<
             vk,
             agg_node_tracegen: T::new(def_hook_vk_commit.is_some()),
             child_vk,
-            child_vk_pcs_data,
+            cached_trace_record,
             circuit,
             trace_heights,
         }
@@ -179,10 +177,6 @@ impl<
         self.vk.clone()
     }
 
-    pub fn get_cached_commit(&self) -> <PB as ProverBackend>::Commitment {
-        self.child_vk_pcs_data.commitment
-    }
-
     pub fn get_trace_heights(&self) -> Option<Vec<usize>> {
         self.trace_heights.clone()
     }

crates/continuations/src/prover/root/mod.rs

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use openvm_circuit::system::memory::merkle::public_values::UserPublicValuesProof;
 use openvm_recursion_circuit::system::{
-    AggregationSubCircuit, VerifierExternalData, VerifierTraceGen,
+    AggregationSubCircuit, CachedTraceCtx, VerifierExternalData, VerifierTraceGen,
 };
 use openvm_stark_backend::{
     proof::Proof,
@@ -18,20 +18,19 @@ use crate::{
     RootSC, SC,
 };
 
-impl<
-        PB: ProverBackend<Val = F, Challenge = EF>,
-        S: AggregationSubCircuit + VerifierTraceGen<PB, RootSC>,
-        T: RootTraceGen<PB>,
-    > RootProver<PB, S, T>
-where
-    PB::Matrix: Clone,
-{
-    pub fn generate_proving_ctx(
+impl<S: AggregationSubCircuit, T> RootProver<S, T> {
+    pub fn generate_proving_ctx<PB>(
         &self,
         proof: Proof<SC>,
         user_pvs_proof: &UserPublicValuesProof<DIGEST_SIZE, PB::Val>,
         deferral_merkle_proofs: Option<&DeferralMerkleProofs<PB::Val>>,
-    ) -> Option<ProvingContext<PB>> {
+    ) -> Option<ProvingContext<PB>>
+    where
+        PB: ProverBackend<Val = F, Challenge = EF>,
+        PB::Matrix: Clone,
+        S: VerifierTraceGen<PB, RootSC>,
+        T: RootTraceGen<PB>,
+    {
         assert_eq!(
             user_pvs_proof.public_values.len(),
             self.circuit.num_user_pvs
@@ -71,7 +70,7 @@ where
 
         let subcircuit_ctxs = self.circuit.verifier_circuit.generate_proving_ctxs(
             &self.child_vk,
-            self.child_vk_pcs_data.clone(),
+            CachedTraceCtx::Records(self.cached_trace_record.clone()),
             &[proof],
             &mut external_data,
             default_duplex_sponge_recorder(),
@@ -89,11 +88,17 @@ where
     }
 
     #[instrument(name = "trace_gen", skip_all)]
-    pub fn generate_proving_ctx_no_def(
+    pub fn generate_proving_ctx_no_def<PB>(
         &self,
         proof: Proof<SC>,
         user_pvs_proof: &UserPublicValuesProof<DIGEST_SIZE, PB::Val>,
-    ) -> Option<ProvingContext<PB>> {
+    ) -> Option<ProvingContext<PB>>
+    where
+        PB: ProverBackend<Val = F, Challenge = EF>,
+        PB::Matrix: Clone,
+        S: VerifierTraceGen<PB, RootSC>,
+        T: RootTraceGen<PB>,
+    {
         assert!(
             self.circuit.def_hook_vk_commit.is_none(),
             "deferral-enabled root prover requires generate_proving_ctx_with_deferrals"

crates/continuations/src/prover/root/trace.rs

@@ -739,8 +739,11 @@ fn test_deferral_e2e() -> Result<()> {
         Some(def_hook_vk_commit.into()),
         None,
     );
-    let ctx =
-        root_prover.generate_proving_ctx(combined_proof, &user_pvs_proof, Some(&merkle_proofs));
+    let ctx = root_prover.generate_proving_ctx::<<RootEngine as StarkEngine>::PB>(
+        combined_proof,
+        &user_pvs_proof,
+        Some(&merkle_proofs),
+    );
     warn!("proving root (CPU)");
     let root_proof = root_prover.root_prove_from_ctx::<RootEngine>(ctx.unwrap())?;