feat(planner)!: decouple source and opening commitment bases

.github/workflows/profile-bench.yml

@@ -76,7 +76,9 @@ jobs:
         group:
           - name: 1-fp128-dense
             cases: |
-              dense_fp128_d64:24:1
+              dense_fp32_d128:26:1
+              dense_fp64_d128:26:1
+              dense_fp128_d64:26:1
           - name: 2-fp128-tensor
             cases: |
               onehot_fp128_d64_tensor:26:1

crates/akita-config/Cargo.toml

@@ -26,6 +26,7 @@ schedules-default = [
   "schedules-fp128-d128-dense",
   "schedules-fp128-d256-onehot",
   "schedules-fp32-d128-onehot",
+  "schedules-fp32-d128-dense",
   "schedules-fp32-d256-onehot",
   "schedules-fp64-d128-dense",
   "schedules-fp64-d128-onehot",
@@ -69,6 +70,7 @@ schedules-fp128-d64-dense-multi-chunk = [
 ]
 
 schedules-fp32-d128-onehot = ["akita-schedules/fp32-d128-onehot"]
+schedules-fp32-d128-dense = ["akita-schedules/fp32-d128-dense"]
 schedules-fp32-d256-onehot = ["akita-schedules/fp32-d256-onehot"]
 schedules-fp64-d128-dense = ["akita-schedules/fp64-d128-dense"]
 schedules-fp64-d128-onehot = ["akita-schedules/fp64-d128-onehot"]

crates/akita-config/src/lib.rs

@@ -70,8 +70,11 @@ macro_rules! impl_multi_chunk_companion {
                     max_num_batched_polys,
                 )
             }
-            fn basis_range() -> (u32, u32) {
-                <$base as $crate::CommitmentConfig>::basis_range()
+            fn opening_basis_range() -> (u32, u32) {
+                <$base as $crate::CommitmentConfig>::opening_basis_range()
+            }
+            fn inner_basis_range() -> (u32, u32) {
+                <$base as $crate::CommitmentConfig>::inner_basis_range()
             }
             fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec {
                 <$base as $crate::CommitmentConfig>::root_honest_fold_policy()
@@ -145,7 +148,8 @@ pub fn policy_of<Cfg: CommitmentConfig>() -> PlannerPolicy {
         ring_subfield_norm_bound: Cfg::ring_subfield_embedding_norm_bound(),
         claim_ext_degree: Cfg::EXT_DEGREE,
         chal_ext_degree: Cfg::EXT_DEGREE,
-        basis_range: Cfg::basis_range(),
+        inner_basis_range: Cfg::inner_basis_range(),
+        opening_basis_range: Cfg::opening_basis_range(),
         witness_chunk: Cfg::chunked_witness_cfg(),
         recursive_setup_planning,
     }
@@ -296,7 +300,13 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static {
 
     /// Inclusive `(min, max)` log-basis search range.
     #[doc(hidden)]
-    fn basis_range() -> (u32, u32);
+    fn opening_basis_range() -> (u32, u32);
+
+    /// Inclusive A/source decomposition basis range at every fold level.
+    #[doc(hidden)]
+    fn inner_basis_range() -> (u32, u32) {
+        Self::opening_basis_range()
+    }
 
     /// Group-owned honest sizing rule used only during offline planning.
     fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec;
@@ -321,16 +331,17 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static {
 
     /// Catalog-bound schedule selection objective.
     ///
-    /// Uniform/direct presets minimize proof payload. Recursive setup presets
-    /// minimize the first remaining direct setup footprint before payload.
+    /// Uniform/direct presets minimize the next recursive witness before proof
+    /// payload. Recursive setup presets minimize the first remaining direct
+    /// setup footprint, then the next witness, before payload.
     /// Mixed-dimension catalogs may opt into the physical setup-field objective
     /// explicitly; the policy is part of catalog identity and never inferred
     /// from a ring dimension.
     fn selection_policy() -> akita_schedules::SelectionPolicyId {
         if Self::recursive_setup_planning() {
             akita_schedules::SelectionPolicyId::MinFirstDirectSetupThenPayload
         } else {
-            akita_schedules::SelectionPolicyId::MinEstimatedProofPayload
+            akita_schedules::SelectionPolicyId::MinNextWitnessThenPayload
         }
     }
 
@@ -492,7 +503,7 @@ mod tests {
             Ok(SetupMatrixCapacity::minimum())
         }
 
-        fn basis_range() -> (u32, u32) {
+        fn opening_basis_range() -> (u32, u32) {
             (3, 3)
         }
 
@@ -745,7 +756,7 @@ mod precommit_tests {
             )
             .expect("precommitted group params");
         let precommitted = akita_types::CommittedGroupProfile::from_params(group, &params);
-        let root_basis = fp128::D64OneHot::basis_range().0;
+        let root_basis = fp128::D64OneHot::opening_basis_range().0;
         assert_eq!(precommitted.log_basis_inner, root_basis);
         assert_eq!(precommitted.log_basis_outer, root_basis);
         assert_eq!(precommitted.num_positions_per_block, 256);

crates/akita-config/src/precommitted_commitment.rs

@@ -73,8 +73,8 @@ impl<Cfg: CommitmentConfig> CommitmentConfig for PrecommittedCommitmentConfig<Cf
         })
     }
 
-    fn basis_range() -> (u32, u32) {
-        Cfg::basis_range()
+    fn opening_basis_range() -> (u32, u32) {
+        Cfg::opening_basis_range()
     }
 
     fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec {

crates/akita-config/src/proof_optimized.rs

@@ -19,13 +19,15 @@ use std::sync::{LazyLock, Mutex};
 /// Minimum proof-optimized log-basis.
 ///
 /// This is also the fixed **root-fold** basis: `log_basis_search_range_at_level(0)`
-/// collapses the root to `basis_range.0`. Pinning the root to `3` (rather than the
+/// collapses the root to `opening_basis_range.0`. Pinning the root to `3` (rather than the
 /// smallest reachable `2`) keeps the shrink strong enough that every preset — dense
 /// and small-field included — supports the full `nv` range, and matches the value
 /// the unpinned planner already favored at the root.
 pub(crate) const PROOF_OPTIMIZED_LOG_BASIS_MIN: u32 = 3;
 /// Maximum proof-optimized log-basis.
 pub(crate) const PROOF_OPTIMIZED_LOG_BASIS_MAX: u32 = 6;
+/// Maximum A/source log basis supported by the signed-i16 commitment path.
+pub(crate) const PROOF_OPTIMIZED_INNER_LOG_BASIS_MAX: u32 = 16;
 /// Explicit sparse-binary chunk size used by standard one-hot presets.
 ///
 /// Smaller/nonstandard chunking is represented by a separately named preset
@@ -408,7 +410,7 @@ macro_rules! impl_proof_optimized_preset {
             if Self::recursive_setup_planning() {
                 akita_schedules::SelectionPolicyId::MinFirstDirectSetupThenPayload
             } else {
-                akita_schedules::SelectionPolicyId::MinEstimatedProofPayload
+                akita_schedules::SelectionPolicyId::MinNextWitnessThenPayload
             }
         }
     };
@@ -503,13 +505,20 @@ macro_rules! impl_proof_optimized_preset {
                 )
             }
 
-            fn basis_range() -> (u32, u32) {
+            fn opening_basis_range() -> (u32, u32) {
                 (
                     $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MIN,
                     $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MAX,
                 )
             }
 
+            fn inner_basis_range() -> (u32, u32) {
+                (
+                    $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MIN,
+                    $crate::proof_optimized::PROOF_OPTIMIZED_INNER_LOG_BASIS_MAX,
+                )
+            }
+
             fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec {
                 let legacy_witness = $fold_norms;
                 if $log_commit_bound == 1 {
@@ -580,13 +589,21 @@ macro_rules! impl_proof_optimized_preset {
                 )
             }
 
-            fn basis_range() -> (u32, u32) {
+            fn opening_basis_range() -> (u32, u32) {
                 (
                     $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MIN,
                     $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MAX,
                 )
             }
 
+
+            fn inner_basis_range() -> (u32, u32) {
+                (
+                    $crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MIN,
+                    $crate::proof_optimized::PROOF_OPTIMIZED_INNER_LOG_BASIS_MAX,
+                )
+            }
+
             fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec {
                 let legacy_witness = $fold_norms;
                 if $log_commit_bound == 1 {

crates/akita-config/src/proof_optimized/fp32.rs

@@ -59,7 +59,12 @@ impl_proof_optimized_preset!(
     128,
     32,
     32,
-    fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 128)
+    fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 128),
+    schedules = (
+        "schedules-fp32-d128-dense",
+        "fp32_d128_dense",
+        fp32_d128_dense_table
+    )
 );
 impl_proof_optimized_preset!(
     D128OneHot,

crates/akita-config/src/recursive_commitment.rs

@@ -55,8 +55,8 @@ impl<Cfg: CommitmentConfig> CommitmentConfig for RecursiveCommitmentConfig<Cfg>
         )
     }
 
-    fn basis_range() -> (u32, u32) {
-        Cfg::basis_range()
+    fn opening_basis_range() -> (u32, u32) {
+        Cfg::opening_basis_range()
     }
 
     fn root_honest_fold_policy() -> akita_types::sis::HonestFoldPolicySpec {

crates/akita-config/src/tensor_verifier.rs

@@ -66,7 +66,7 @@ pub mod fp128 {
             )
         }
 
-        fn basis_range() -> (u32, u32) {
+        fn opening_basis_range() -> (u32, u32) {
             (
                 crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MIN,
                 crate::proof_optimized::PROOF_OPTIMIZED_LOG_BASIS_MAX,

crates/akita-config/tests/generated_tables.rs

@@ -100,6 +100,7 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool {
         "fp64_d128_dense" => fp64::D128Dense::schedule_catalog().is_some(),
         "fp64_d128_onehot" => fp64::D128OneHot::schedule_catalog().is_some(),
         "fp64_d256_onehot" => fp64::D256OneHot::schedule_catalog().is_some(),
+        "fp32_d128_dense" => fp32::D128Dense::schedule_catalog().is_some(),
         "fp32_d128_onehot" => fp32::D128OneHot::schedule_catalog().is_some(),
         "fp32_d256_onehot" => fp32::D256OneHot::schedule_catalog().is_some(),
         other => panic!("unknown generated family for catalog guard: {other}"),
@@ -373,6 +374,7 @@ fn family_catalog(
         "fp64_d128_dense" => prepare_family_catalog::<fp64::D128Dense>(family, keys),
         "fp64_d128_onehot" => prepare_family_catalog::<fp64::D128OneHot>(family, keys),
         "fp64_d256_onehot" => prepare_family_catalog::<fp64::D256OneHot>(family, keys),
+        "fp32_d128_dense" => prepare_family_catalog::<fp32::D128Dense>(family, keys),
         "fp32_d128_onehot" => prepare_family_catalog::<fp32::D128OneHot>(family, keys),
         "fp32_d256_onehot" => prepare_family_catalog::<fp32::D256OneHot>(family, keys),
         other => panic!("unknown generated family for catalog guard: {other}"),
@@ -455,6 +457,9 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro
         "fp64_d256_onehot" => {
             assert_group_batch_table_hits::<fp64::D256OneHot>(family.module_name, requests)
         }
+        "fp32_d128_dense" => {
+            assert_group_batch_table_hits::<fp32::D128Dense>(family.module_name, requests)
+        }
         "fp32_d128_onehot" => {
             assert_group_batch_table_hits::<fp32::D128OneHot>(family.module_name, requests)
         }
@@ -537,6 +542,7 @@ fn resolve_family_group_batch_schedule(
         "fp64_d128_dense" => table_backed_group_batch_schedule::<fp64::D128Dense>(request),
         "fp64_d128_onehot" => table_backed_group_batch_schedule::<fp64::D128OneHot>(request),
         "fp64_d256_onehot" => table_backed_group_batch_schedule::<fp64::D256OneHot>(request),
+        "fp32_d128_dense" => table_backed_group_batch_schedule::<fp32::D128Dense>(request),
         "fp32_d128_onehot" => table_backed_group_batch_schedule::<fp32::D128OneHot>(request),
         "fp32_d256_onehot" => table_backed_group_batch_schedule::<fp32::D256OneHot>(request),
         other => panic!("unknown generated family for multi-group schedule guard: {other}"),
@@ -956,3 +962,112 @@ fn generated_schedule_tables_match_key_planner() {
         hint = regen_hint(),
     );
 }
+
+#[test]
+fn dense_nv26_independent_inner_basis_snapshots() {
+    #[derive(Debug, PartialEq, Eq)]
+    struct Snapshot {
+        inner_basis: u32,
+        opening_basis: u32,
+        positions: usize,
+        blocks: usize,
+        inner_digits: usize,
+        n_a: usize,
+        n_b: usize,
+        n_d: usize,
+        a_input_raw: usize,
+        a_output_raw: usize,
+        b_input_raw: usize,
+        b_output_raw: usize,
+        d_input_raw: usize,
+        d_output_raw: usize,
+        next_witness: usize,
+    }
+
+    fn snapshot<Cfg: CommitmentConfig>() -> Snapshot {
+        let schedule = Cfg::runtime_schedule(AkitaScheduleLookupKey::single(
+            PolynomialGroupLayout::singleton(26),
+        ))
+        .expect("generated dense nv=26 schedule");
+        let root = &schedule.root.params.final_group.commitment;
+        let dims = root.role_dims();
+        Snapshot {
+            inner_basis: root.log_basis_inner,
+            opening_basis: root.log_basis_open,
+            positions: root.num_positions_per_block,
+            blocks: root.num_live_blocks,
+            inner_digits: root.num_digits_inner,
+            n_a: root.inner_commit_matrix.output_rank(),
+            n_b: root.outer_commit_matrix.output_rank(),
+            n_d: root.open_commit_matrix.output_rank(),
+            a_input_raw: root.inner_commit_matrix.input_width() * dims.d_a(),
+            a_output_raw: root.inner_commit_matrix.output_rank() * dims.d_a(),
+            b_input_raw: root.outer_commit_matrix.input_width() * dims.d_b(),
+            b_output_raw: root.outer_commit_matrix.output_rank() * dims.d_b(),
+            d_input_raw: root.open_commit_matrix.input_width() * dims.d_d(),
+            d_output_raw: root.open_commit_matrix.output_rank() * dims.d_d(),
+            next_witness: schedule.root.output_witness_len,
+        }
+    }
+
+    assert_eq!(
+        snapshot::<fp32::D128Dense>(),
+        Snapshot {
+            inner_basis: 11,
+            opening_basis: 3,
+            positions: 2048,
+            blocks: 256,
+            inner_digits: 3,
+            n_a: 15,
+            n_b: 2,
+            n_d: 2,
+            a_input_raw: 786_432,
+            a_output_raw: 1_920,
+            b_input_raw: 5_406_720,
+            b_output_raw: 256,
+            d_input_raw: 360_448,
+            d_output_raw: 256,
+            next_witness: 11_323_008,
+        }
+    );
+    assert_eq!(
+        snapshot::<fp64::D128Dense>(),
+        Snapshot {
+            inner_basis: 11,
+            opening_basis: 3,
+            positions: 2048,
+            blocks: 256,
+            inner_digits: 6,
+            n_a: 9,
+            n_b: 1,
+            n_d: 1,
+            a_input_raw: 1_572_864,
+            a_output_raw: 1_152,
+            b_input_raw: 6_488_064,
+            b_output_raw: 128,
+            d_input_raw: 720_896,
+            d_output_raw: 128,
+            next_witness: 18_275_456,
+        }
+    );
+    assert_eq!(
+        snapshot::<fp128::D64Dense>(),
+        Snapshot {
+            inner_basis: 11,
+            opening_basis: 3,
+            positions: 2048,
+            blocks: 512,
+            inner_digits: 12,
+            n_a: 9,
+            n_b: 1,
+            n_d: 1,
+            a_input_raw: 1_572_864,
+            a_output_raw: 576,
+            b_input_raw: 12_681_216,
+            b_output_raw: 64,
+            d_input_raw: 1_409_024,
+            d_output_raw: 64,
+            next_witness: 25_155_904,
+        }
+    );
+}