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

.github/workflows/ci.yml

@@ -187,6 +187,9 @@ jobs:
           shared-key: ci-test-all-schedules-drift
           add-job-id-key: false
           cache-on-failure: true
+      - name: Committed catalog coverage guard
+        run: |
+          cargo test --release -p akita-config --features all-schedules generated_catalogs_cover_emitted_keys
       - name: Generate schedule tables
         run: scripts/generate-schedule-tables.sh
       - name: Drift guard (all-schedules)

.github/workflows/profile-bench.yml

@@ -64,7 +64,9 @@ jobs:
         group:
           - name: 1-fp128-dense
             cases: |
-              dense_fp128:24:1
+              dense_fp32_d128:26:1
+              dense_fp64_d128:26:1
+              dense_fp128:26:1
           - name: 3-flat-onehot-suite
             cases: |
               onehot_fp32_d128:28:1

book/src/how/security.md

@@ -22,20 +22,24 @@ Module-SIS projection:
 where `width[r - 1] = cutoff_m(B, n = r * d) / d`.
 
 The shipped policy is `Quantum128BitADPS16`. It accepts a row only when the
-exhaustive ADPS16 quantum certificate reports a finite score or a classified
-above-target lower bound of at least 128 bits. A lookup for an unsupported
-policy, exact modulus profile, role, or scalar cell fails closed.
+complete ADPS16 quantum certificate reports a finite score or a classified
+above-target lower bound of at least 128 bits. The beta search checks values
+from 40 through the capped Euclidean baseline and stops once the monotone
+ADPS16 lower bound exceeds the best complete candidate. For each visited beta,
+the LGSA profile transition proves that the checked zeta endpoints cover the
+full zeta domain. A lookup for an unsupported policy, exact modulus profile,
+role, or scalar cell fails closed.
 
 The checked-in policy table may use `local-minimum` only to discover a candidate
 boundary. Every emitted boundary and its immediate rejected successor are
-certified by exhaustive search over the configured beta and zeta domain.
-Parallel generation parallelizes independent rows and does not change the
-certificate domain or output ordering.
+certified under the proven-pruned beta and zeta domain. Parallel generation
+parallelizes independent rows and does not change the certificate domain or
+output ordering.
 
 CSV table-generation artifacts include the certified accepted and rejected
 successor witnesses, cutoff kind, cap provenance, and role provenance. These
-are audit inputs, not verifier-visible state, and are committed separately from
-the runtime table digest.
+are audit inputs, not verifier-visible state. The shared table digest commits
+to the compact runtime table and its policy audit files together.
 
 The planner derives role bounds as coefficient-`L∞` values because those are the
 values enforced by the protocol. It does not convert production role bounds
@@ -61,8 +65,8 @@ implementation acceptance criteria live in
 - `crates/akita-types/src/sis/mod.rs`, `ajtai_key.rs`, `generated_sis_table/`, `norm_bound.rs`.
 - Paper §2.2 `def:msis`, §3.12 `sec:batched-soundness` ("MSIS targets", "Two norm models").
 - `docs/security-posture.md`, `specs/sis-quantum128-scalar-n-table.md`.
-- `scripts/sis_golden/infinity_width_table.csv` (generation provenance for the
-  infinity-width golden grid).
+- `crates/akita-types/src/sis/generated_sis_table/policy_audit.csv` (canonical
+  production table certificate).
 
 ## Norm bounds and weak binding
 

crates/akita-challenges/src/config.rs

@@ -35,13 +35,17 @@ macro_rules! production_fold_challenge_ring_dims {
 
 production_fold_challenge_ring_dims!(64, 128, 256, 512, 1024, 2048);
 
-const PRODUCTION_FOLD_CHALLENGE_LADDER: &[(usize, usize, usize)] = &[
-    (64, D64_PRODUCTION_PM1_COUNT, D64_PRODUCTION_PM2_COUNT),
-    (128, 31, 0),
-    (256, 23, 0),
-    (512, 19, 0),
-    (1024, 16, 0),
-    (2048, 14, 0),
+// The last coordinate is floor(log2(support)). It lets the verifier and the
+// offline planner validate the fixed production families without repeatedly
+// evaluating dozens of floating-point logarithms. The tests below recompute
+// every value from the canonical support formula.
+const PRODUCTION_FOLD_CHALLENGE_LADDER: &[(usize, usize, usize, u32)] = &[
+    (64, D64_PRODUCTION_PM1_COUNT, D64_PRODUCTION_PM2_COUNT, 128),
+    (128, 31, 0, 129),
+    (256, 23, 0, 131),
+    (512, 19, 0, 132),
+    (1024, 16, 0, 131),
+    (2048, 14, 0, 131),
 ];
 
 /// Fixed-weight sparse ring fold challenge family.
@@ -70,8 +74,8 @@ impl SparseChallengeConfig {
     pub fn production_for_ring_dim(ring_d: usize) -> Option<Self> {
         PRODUCTION_FOLD_CHALLENGE_LADDER
             .iter()
-            .find(|(d, _, _)| *d == ring_d)
-            .map(|(_, pm1, pm2)| Self {
+            .find(|(d, _, _, _)| *d == ring_d)
+            .map(|(_, pm1, pm2, _)| Self {
                 count_pm1: *pm1,
                 count_pm2: *pm2,
             })
@@ -160,6 +164,19 @@ impl SparseChallengeConfig {
         ring_dim: usize,
         required_bits: u32,
     ) -> Result<(), &'static str> {
+        if let Some((_, _, _, support_floor_bits)) =
+            PRODUCTION_FOLD_CHALLENGE_LADDER
+                .iter()
+                .find(|(d, pm1, pm2, _)| {
+                    *d == ring_dim && *pm1 == self.count_pm1 && *pm2 == self.count_pm2
+                })
+        {
+            return if required_bits <= *support_floor_bits {
+                Ok(())
+            } else {
+                Err("sparse challenge family has insufficient min-entropy for security floor")
+            };
+        }
         __dispatch_fold_challenge_ring_dim!(self, ring_dim, required_bits)
     }
 
@@ -203,9 +220,32 @@ mod entropy_tests {
 
     #[test]
     fn production_ladder_matches_proof_optimized_dims() {
-        for &d in PRODUCTION_FOLD_CHALLENGE_RING_DIMS {
+        for (&d, &(_, _, _, support_floor_bits)) in PRODUCTION_FOLD_CHALLENGE_RING_DIMS
+            .iter()
+            .zip(PRODUCTION_FOLD_CHALLENGE_LADDER)
+        {
             let cfg = SparseChallengeConfig::production_for_ring_dim(d).expect("ladder entry");
             assert!(cfg.validate_for_ring_dim(d).is_ok(), "d={d}");
+            let computed_floor = match d {
+                64 => cfg.log2_support_bits::<64>().floor() as u32,
+                128 => cfg.log2_support_bits::<128>().floor() as u32,
+                256 => cfg.log2_support_bits::<256>().floor() as u32,
+                512 => cfg.log2_support_bits::<512>().floor() as u32,
+                1024 => cfg.log2_support_bits::<1024>().floor() as u32,
+                2048 => cfg.log2_support_bits::<2048>().floor() as u32,
+                _ => unreachable!("production dimension list is exhaustive"),
+            };
+            assert_eq!(computed_floor, support_floor_bits, "d={d}");
+            assert!(
+                cfg.validate_min_entropy_for_ring_dim(d, support_floor_bits)
+                    .is_ok(),
+                "d={d}"
+            );
+            assert!(
+                cfg.validate_min_entropy_for_ring_dim(d, support_floor_bits + 1)
+                    .is_err(),
+                "d={d}"
+            );
         }
     }
 
@@ -260,7 +300,7 @@ mod entropy_tests {
         assert_eq!(uni256.challenge_l2_sq_max(), 23);
         assert_eq!(uni256.nonzero_count_max(), 23);
 
-        for (d, pm1, pm2) in PRODUCTION_FOLD_CHALLENGE_LADDER {
+        for (d, pm1, pm2, _) in PRODUCTION_FOLD_CHALLENGE_LADDER {
             if *d >= 512 {
                 let cfg = SparseChallengeConfig {
                     count_pm1: *pm1,

crates/akita-config/Cargo.toml

@@ -23,6 +23,7 @@ schedules-default = [
   "schedules-fp128-onehot",
   "schedules-fp128-dense",
   "schedules-fp32-d128-onehot",
+  "schedules-fp32-d128-dense",
   "schedules-fp32-d256-onehot",
   "schedules-fp64-d128-dense",
   "schedules-fp64-d128-onehot",
@@ -55,6 +56,7 @@ schedules-fp128-onehot-multi-chunk-w4r2 = [
 schedules-fp128-dense-multi-chunk = ["akita-schedules/fp128-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"]
@@ -84,5 +86,10 @@ name = "generated_tables"
 path = "tests/generated_tables.rs"
 required-features = ["all-schedules"]
 
+[[test]]
+name = "dense_inner_basis"
+path = "tests/dense_inner_basis.rs"
+required-features = ["all-schedules"]
+
 [lints]
 workspace = true

crates/akita-config/src/lib.rs

@@ -64,8 +64,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()
@@ -104,9 +107,7 @@ pub mod setup_prefix_slots;
 pub mod test_support;
 mod transcript_binding;
 pub use akita_schedules::ResolvedScheduleRow;
-pub use precommitted_commitment::{
-    committed_group_params, committed_group_profile, PrecommittedCommitmentConfig,
-};
+pub use precommitted_commitment::committed_group_profile;
 pub use proof_optimized::{
     ensure_prover_schedule_fits_setup, ensure_verifier_schedule_fits_setup,
     setup_level_params_from_schedule,
@@ -138,7 +139,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,
     }
@@ -276,9 +278,15 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static {
         Self::D
     }
 
-    /// Inclusive `(min, max)` log-basis search range.
+    /// Inclusive `(min, max)` B/D opening and folded-response basis range.
     #[doc(hidden)]
-    fn basis_range() -> (u32, u32);
+    fn opening_basis_range() -> (u32, u32);
+
+    /// Inclusive `(min, max)` A/source decomposition basis range.
+    #[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;
@@ -325,14 +333,6 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static {
         None
     }
 
-    /// Whether multi-group `commit_final_group` may run under this config adapter.
-    ///
-    /// Precommit adapters return `false`; multi-group final commits
-    /// require the regular preset config.
-    fn supports_multi_group_final_commit() -> bool {
-        true
-    }
-
     /// Build the runtime [`FoldSchedule`] for `key`.
     ///
     /// Scalar openings use `AkitaScheduleLookupKey::single(group_key)` with an
@@ -471,7 +471,7 @@ mod tests {
             Ok(SetupMatrixCapacity::minimum())
         }
 
-        fn basis_range() -> (u32, u32) {
+        fn opening_basis_range() -> (u32, u32) {
             (3, 3)
         }
 
@@ -738,14 +738,8 @@ mod precommit_tests {
     fn exact_precommit_params_freeze_standalone_metadata() {
         let group = PolynomialGroupLayout::new(16, 1);
         group.validate().expect("group layout");
-        let singleton =
-            OpeningClaimsLayout::new(group.num_vars(), group.num_polynomials()).expect("singleton");
-        let params =
-            <PrecommittedCommitmentConfig<fp128::OneHot> as CommitmentConfig>::get_params_for_batched_commitment(
-                &singleton,
-            )
-            .expect("precommitted group params");
-        let precommitted = akita_types::CommittedGroupProfile::from_params(group, &params);
+        let precommitted =
+            committed_group_profile::<fp128::OneHot>(&group).expect("precommitted group profile");
         assert_eq!(
             precommitted.inner_commit_matrix.ring_dimension(),
             64,
@@ -756,21 +750,10 @@ mod precommit_tests {
             64,
             "adaptive precommits use the uniform suffix dimension for B"
         );
-        let root_basis = fp128::OneHot::basis_range().0;
+        let root_basis = fp128::OneHot::opening_basis_range().0;
         assert_eq!(precommitted.log_basis_inner, root_basis);
         assert_eq!(precommitted.log_basis_outer, root_basis);
         assert_ne!(precommitted.inner_commit_matrix.output_rank(), 0);
         assert_ne!(precommitted.outer_commit_matrix.output_rank(), 0);
     }
-
-    #[test]
-    fn precommit_config_rejects_prove_schedule() {
-        let layout = OpeningClaimsLayout::new(2, 1).expect("opening layout");
-        let err =
-            <PrecommittedCommitmentConfig<fp128::OneHot> as CommitmentConfig>::get_params_for_prove(
-                &layout,
-            )
-            .expect_err("precommit config must not prove");
-        assert!(matches!(err, AkitaError::InvalidSetup(_)));
-    }
 }