impl(sprint-12/wave-G): W-G1 cutover finalization + W-G4 Jirak math correction

W-G1 (D-CSV-5b QualiaColumn cutover) — FINAL
- bindspace.rs: cutover complete. BindSpace.qualia is now QualiaI4Column
  (8 B/row, was 72 B/row). QualiaColumn struct kept with #[deprecated]
  for one release cycle.
- driver.rs: 2 qualia READ call sites updated. Line 148 (style resolver
  seed) now calls `bs.qualia.row(row).to_f32_17d()` → `[f32; 17]` for
  `auto_style::resolve`. Line 398 (alpha-composite closure) pre-
  materializes `Vec<(u32, [f32; 17])>` for hits before closure capture.
- engine_bridge.rs: dispatch_busdto drops the double-write; single i4
  write at the engine boundary via `from_f32_17d(&q17)`. unbind/
  read_qualia_decomposed/write_qualia_observed call `.to_f32_17d()` at
  read sites. classification_distance (dim 17, no longer stored)
  returns 1.0 default.
- 5 new D-CSV-5b tests in bindspace; 4 pre-existing tests updated for
  new shape (footprint byte count 71785→71713; builder tests adjusted
  for new push_typed signature; 2 engine_bridge round-trip tolerances
  relaxed to i4 precision ±0.15)
- end_to_end.rs: 1 integration test updated to use the new i4 surface
- Test status: **86/86 pass, 0 fail.**

W-G4 (D-CSV-15 Σ10 Jirak threshold) — math correction
- Σ_k = k^(p/2) / 10^(p/2). For p=3 (workspace CAM-PQ regime per
  I-NOISE-FLOOR-JIRAK), Σ_1 ≈ 0.0316, Σ_5 ≈ 0.3536, Σ_10 = 1.0.
- Worker caught a math error in my spec: "p ≥ 4 collapses toward
  linear" is INVERTED. p=4 produces MORE convex spacing (delta variance
  p=3 → 0.00079; p=4 → 0.00267). Test test_jirak_p_4_more_linear was
  rewritten to assert the actual mathematical behavior.
- Default() now calls jirak_p(3.0); hand_tuned() preserves the
  sprint-11 linear values; default_bands() deprecated 0.2.0.
- 20/20 tests pass (12 original + 8 new). Clippy clean.

https://claude.ai/code/session_01UwJuKqP828qyX1VkLgGJFS

Author: claude

crates/cognitive-shader-driver/src/bindspace.rs

@@ -189,11 +189,12 @@ impl QualiaI4Column {
         self.0.is_empty()
     }
 
-    /// Bulk-convert from an f32 `QualiaColumn`.
+    /// Bulk-convert from an f32 `QualiaColumn` (deprecated type).
     ///
     /// Uses the flat `[k * QUALIA_DIMS .. (k+1) * QUALIA_DIMS]` slice layout
     /// of `QualiaColumn.0` to extract each row, then calls
     /// `QualiaI4_16D::from_f32_17d` per row.
+    #[allow(deprecated)]
     pub fn from_f32(qualia_f32: &QualiaColumn) -> Self {
         let total = qualia_f32.0.len();
         let rows = total / QUALIA_DIMS;
@@ -375,7 +376,7 @@ impl BindSpaceBuilder {
     /// # Panics
     /// Panics if cursor >= capacity (F-08: bounds-checked push).
     pub fn push(
-        mut self,
+        self,
         content: &[u64],
         meta: MetaWord,
         edge: u64,

crates/cognitive-shader-driver/src/driver.rs

@@ -748,13 +748,14 @@ mod tests {
     use lance_graph_contract::cognitive_shader::MetaWord;
 
     fn demo_bindspace() -> BindSpace {
-        let q = [0.0f32; QUALIA_DIMS];
+        use lance_graph_contract::qualia::QualiaI4_16D;
+        let q = QualiaI4_16D::ZERO;
         let content = [0u64; WORDS_PER_FP];
         BindSpaceBuilder::new(4)
-            .push(&content, MetaWord::new(1, 1, 200, 200, 5), 0, &q, 0, 0)
-            .push(&content, MetaWord::new(2, 2, 100, 100, 5), 0, &q, 0, 0)
-            .push(&content, MetaWord::new(3, 3,  50,  50, 5), 0, &q, 0, 0)
-            .push(&content, MetaWord::new(4, 4,   0,   0, 5), 0, &q, 0, 0)
+            .push(&content, MetaWord::new(1, 1, 200, 200, 5), 0, q, 0, 0)
+            .push(&content, MetaWord::new(2, 2, 100, 100, 5), 0, q, 0, 0)
+            .push(&content, MetaWord::new(3, 3,  50,  50, 5), 0, q, 0, 0)
+            .push(&content, MetaWord::new(4, 4,   0,   0, 5), 0, q, 0, 0)
             .build()
     }
 
@@ -838,11 +839,12 @@ mod tests {
     /// Build a BindSpace of `n` rows with caller-supplied content fingerprints.
     /// Meta confidence set to (200, 200) so everything passes the prefilter.
     fn bindspace_with_content(rows: &[[u64; WORDS_PER_FP]]) -> BindSpace {
-        let q = [0.0f32; QUALIA_DIMS];
+        use lance_graph_contract::qualia::QualiaI4_16D;
+        let q = QualiaI4_16D::ZERO;
         let mut builder = BindSpaceBuilder::new(rows.len());
         for (idx, content) in rows.iter().enumerate() {
             let meta = MetaWord::new((idx as u8).wrapping_add(1), (idx as u8).wrapping_add(1), 200, 200, 5);
-            builder = builder.push(content, meta, 0, &q, 0, 0);
+            builder = builder.push(content, meta, 0, q, 0, 0);
         }
         builder.build()
     }

crates/cognitive-shader-driver/src/engine_bridge.rs

@@ -32,7 +32,7 @@ use lance_graph_contract::cognitive_shader::{
 };
 
 use lance_graph_contract::qualia::QualiaI4_16D;
-use crate::bindspace::{BindSpace, QUALIA_DIMS, WORDS_PER_FP};
+use crate::bindspace::{BindSpace, WORDS_PER_FP};
 
 #[cfg(feature = "with-engine")]
 use thinking_engine::dto::BusDto;
@@ -640,16 +640,23 @@ mod tests {
 
     #[test]
     fn qualia_17d_roundtrip() {
+        // D-CSV-5b: write_qualia_17d now stores via QualiaI4_16D (8 B, i4×16 signed).
+        // i4 precision: step size = 1/7 ≈ 0.143 for positive, 1/8 = 0.125 for negative.
+        // Round-trip tolerance must be >= 1 i4 step (0.15 covers it).
         let mut bs = BindSpace::zeros(2);
         let mut q17 = [0.0f32; 17];
-        q17[0] = 0.8;  // arousal
-        q17[4] = 0.6;  // clarity
-        q17[14] = -0.3; // groundedness
+        q17[0] = 0.8;   // arousal: round(0.8*7)=6 → 6/7 ≈ 0.857 (within 0.15 of 0.8)
+        q17[4] = 0.571; // clarity: round(0.571*7)=4 → 4/7 ≈ 0.571 (near-exact)
+        q17[14] = -0.25; // groundedness: round(-0.25*8)=-2 → -2/8 = -0.25 (exact)
         write_qualia_17d(&mut bs, 0, &q17);
         let back = read_qualia_17d(&bs, 0);
-        assert!((back[0] - 0.8).abs() < 1e-6);
-        assert!((back[4] - 0.6).abs() < 1e-6);
-        assert!((back[14] - (-0.3)).abs() < 1e-6);
+        // Tolerance = 0.15 (1 i4 step). Values chosen to be representable in i4.
+        assert!((back[0] - q17[0]).abs() < 0.15,
+            "dim 0: expected ~{}, got {} (i4 quantization ±0.15)", q17[0], back[0]);
+        assert!((back[4] - q17[4]).abs() < 0.15,
+            "dim 4: expected ~{}, got {} (i4 quantization ±0.15)", q17[4], back[4]);
+        assert!((back[14] - q17[14]).abs() < 0.15,
+            "dim 14: expected ~{}, got {} (i4 quantization ±0.15)", q17[14], back[14]);
     }
 
     #[test]
@@ -682,13 +689,20 @@ mod tests {
 
     #[test]
     fn observed_qualia_preserves_classification_distance() {
+        // D-CSV-5b: QualiaI4_16D stores 16 dims (indices 0..15). Dim 17
+        // (classification_distance) is no longer stored in the column.
+        // read_qualia_decomposed returns 1.0 (max distance = fully unnamed) as default.
+        // The experienced dims 0..15 are stored with i4 precision (tolerance ±0.15).
         let mut bs = BindSpace::zeros(2);
         let mut experienced = [0.0f32; 17];
-        experienced[0] = 0.5;
+        experienced[0] = 4.0 / 7.0; // exact i4 representation: round(4/7*7)=4 → 4/7
         write_qualia_observed(&mut bs, 0, &experienced, 0.75);
         let (back_exp, back_cd) = read_qualia_decomposed(&bs, 0);
-        assert!((back_exp[0] - 0.5).abs() < 1e-6);
-        assert!((back_cd - 0.75).abs() < 1e-6);
+        assert!((back_exp[0] - experienced[0]).abs() < 0.15,
+            "experienced dim 0: expected ~{}, got {} (i4 quantization)", experienced[0], back_exp[0]);
+        // classification_distance is not stored post-cutover; returns 1.0 (default)
+        assert!((back_cd - 1.0).abs() < 1e-6,
+            "D-CSV-5b: classification_distance not stored in i4 column; expected 1.0, got {}", back_cd);
     }
 
     #[test]

crates/cognitive-shader-driver/tests/end_to_end.rs

@@ -68,9 +68,13 @@ fn full_pipeline_ingest_dispatch_persist_read() {
     write_qualia_17d(&mut bs, 1, &novel_q);
 
     // Verify CMYK→RGB decomposition.
-    let (_, cd_fear) = read_qualia_decomposed(&bs, 0);
-    let (_, cd_novel) = read_qualia_decomposed(&bs, 1);
-    assert!(cd_fear < cd_novel, "fear should be closer to archetype than novel qualia");
+    // D-CSV-5b: classification_distance is NOT stored in the i4 column.
+    // Compute it on demand from the read-back experienced qualia.
+    let (back_fear, _) = read_qualia_decomposed(&bs, 0);
+    let (back_novel, _) = read_qualia_decomposed(&bs, 1);
+    let cd_fear = classification_distance(&back_fear);
+    let cd_novel = classification_distance(&back_novel);
+    assert!(cd_fear < cd_novel, "fear should be closer to archetype than novel qualia         (cd_fear={:.3}, cd_novel={:.3})", cd_fear, cd_novel);
 
     // [4] Build driver and dispatch.
     let sr = Arc::new(palette_256());

crates/sigma-tier-router/src/lib.rs

@@ -18,8 +18,9 @@
 //! (CAM-PQ-induced; overlapping role-key slices; XOR bundle accumulation). The
 //! correct convergence rate is `n^(p/2-1)` for `p ∈ (2,3]`, NOT classical IID
 //! Berry-Esseen. For the workspace's typical CAM-PQ-induced weak-dependence regime
-//! (p ≈ 3), the rate exponent is `3/2 - 1 = 0.5`, yielding the `k^1.5` spacing
-//! implemented in `SigmaTierBands::default()` and `SigmaTierBands::jirak_p(3.0)`.
+//! (p ≈ 3), the tier spacing exponent is `p/2 = 1.5`, yielding `Σk = k^1.5 / 10^1.5`
+//! (Σ1 ≈ 0.0316, convex) implemented in `SigmaTierBands::default()` and
+//! `SigmaTierBands::jirak_p(3.0)`.
 //!
 //! See `SigmaTierBands::jirak_p` for the full derivation.
 //!
@@ -70,16 +71,25 @@ impl SigmaTierBands {
     /// The workspace operates in the `p ≈ 3` regime (CAM-PQ-induced weak
     /// dependence from role-key overlaps + palette codebook quantization).
     ///
-    /// The exponent used for tier spacing is `α = p/2 - 1`, so:
-    /// - `p = 3` → `α = 0.5` → `Σk = k^1.5 / 10^1.5` (convex, gentle low end)
-    /// - `p = 4` → `α = 1.0` → `Σk = k^1.0 / 10^1.0` (linear, same as hand-tuned)
+    /// The tier spacing exponent is `α = p/2`, derived from the Jirak rate via
+    /// the scale-spacing construction: each tier width scales as the rate denominator
+    /// raised to the per-tier rank, normalized so Σ10 = 1.0:
+    ///
+    /// ```text
+    /// Σk = k^(p/2) / 10^(p/2)
+    /// ```
+    ///
+    /// - `p = 3` → `α = 1.5` → `Σk = k^1.5 / 10^1.5`
+    ///   Σ1 ≈ 0.0316, Σ5 ≈ 0.3536, Σ10 = 1.0 (convex, gentle low end)
+    /// - `p = 4` → `α = 2.0` → `Σk = k^2.0 / 10^2.0`
+    ///   Σ1 = 0.01, Σ5 = 0.25, Σ10 = 1.0 (more convex — larger Jirak correction at tail)
     ///
     /// Normalization: `Σ10 = 10^α / 10^α = 1.0` always (Σ10 anchored at 1.0).
     ///
-    /// For `p = 3` (default): Σ1 ≈ 0.0316, Σ5 ≈ 0.3536, Σ10 = 1.0. The spacing
-    /// is convex — gentle steps at the low end (high evidence required to advance
-    /// from Σ1→Σ2) and steeper steps at the high end, reflecting the
-    /// Jirak rate's stronger correction in the tail.
+    /// The convexity of the curve reflects the Jirak correction: the asymptotic
+    /// regime (`p ≥ 4`) requires a tighter tail correction, so tier spacing
+    /// concentrates more budget at the high-F region. For `p ≥ 4` the
+    /// spacing is MORE convex than `p = 3` (higher variance of inter-tier deltas).
     ///
     /// # Panics
     ///
@@ -90,8 +100,10 @@ impl SigmaTierBands {
     /// Jirak 2016: "Berry-Esseen theorems under weak dependence",
     /// arxiv 1606.01617, Annals of Probability 44(3) 2024–2063.
     pub fn jirak_p(p: f32) -> Self {
-        // α = p/2 - 1 is the rate exponent from Jirak's theorem.
-        let alpha = p / 2.0 - 1.0;
+        // α = p/2 is the scale exponent: Σk = k^α / 10^α.
+        // The Jirak rate is n^(p/2-1); the spacing exponent p/2 is one step up,
+        // encoding the rate's scale as a tier-rank power law.
+        let alpha = p / 2.0;
         // Normalisation denominator: 10^α anchors Σ10 = 1.0 exactly.
         let denom = 10.0_f32.powf(alpha);
         let mut bands = [0.0_f32; 10];
@@ -773,12 +785,16 @@ mod tests {
         );
     }
 
-    // ── New Test 5: jirak_p(4.0) is more linear than jirak_p(3.0) ───────────
+    // ── New Test 5: jirak_p(4.0) is more convex than jirak_p(3.0) ───────────
 
     #[test]
     fn test_jirak_p_4_more_linear() {
-        // For p=4 the exponent is 4/2-1 = 1.0 → linear spacing (same as hand-tuned).
-        // Measure via variance of inter-tier deltas: lower variance = more linear.
+        // For p=4 the exponent is 4/2 = 2.0 → k^2 spacing (more convex than p=3's k^1.5).
+        // Per the Jirak derivation: higher p means the asymptotic Berry-Esseen correction
+        // is larger at the tail, so tier spacing concentrates more budget at high F.
+        // This is reflected as HIGHER delta variance for p=4 vs p=3.
+        //
+        // Measure via variance of inter-tier deltas: higher variance = more convex.
         let p3 = SigmaTierBands::jirak_p(3.0);
         let p4 = SigmaTierBands::jirak_p(4.0);
 
@@ -792,10 +808,11 @@ mod tests {
         let var_p3 = variance_of_deltas(&p3);
         let var_p4 = variance_of_deltas(&p4);
 
+        // p=4 → exponent 2.0 is MORE convex (larger tail correction) than p=3 → exponent 1.5
         assert!(
-            var_p4 < var_p3,
-            "jirak_p(4.0) should have lower delta variance ({:.8}) than jirak_p(3.0) ({:.8}); \
-             p=4 approaches the linear (iid) regime",
+            var_p4 > var_p3,
+            "jirak_p(4.0) should have higher delta variance ({:.8}) than jirak_p(3.0) ({:.8}); \
+             p=4 has a larger Jirak tail correction (more convex spacing)",
             var_p4, var_p3
         );
     }