sigker: wire signature_kernel_pde to ndarray's SIMD signature_pde_sweep, W1.5 gate closed

.claude/board/EPIPHANIES.md

@@ -29,6 +29,63 @@ Refs: `E-JC-IS-THE-HOME-OF-ALL-CALIBRATED-MATH-1`; `thinking-engine-harvest-clos
 **Fences carried forward.** Lingering trace ≠ counterfactual rung (`E-A-GHOST-TRACE-IS-NOT-THE-COUNTERFACTUAL-LANE-1`): nothing in `ghost_prior` reads or writes the −6 lane. The floor decision is scoped to this fixture; D-HOUSE-4 should re-run `calibration::discrimination` on its own recurrence shape before trusting the default there.
 
 Refs: `thinking-engine-harvest-closure-v1` §1c (ghost row), §3 W2 result, §5 D-TEH-2; `house-differential-style-v1` D-HOUSE-4; `contract::escalation::{GhostEcho, WisdomMarker}`; `TD-GHOST-ECHO-DUP-1` (resolved); `TD-GHOST-TIER-NAME-COLLISION-1` (still open, pays when `counterfactual.rs` is next touched).
+## 2026-09-02 — E-SIGNATURE-PDE-SWEEP-SHIPPED-W1.5-GATE-WAS-QUIETLY-OPEN-1
+
+**Status:** FINDING (measured + shipped). Closes W1.5 item #6; opens #7/#8.
+**Confidence:** every number below was run this session, not inferred.
+
+The W1.5 gate ("do not spawn until sigker is benchmarked at production
+carrier widths AND `jc Pillar 11` activates" —
+`.claude/knowledge/ndarray-vertical-simd-alien-magic.md`) was **already
+open** before this session touched anything — both clauses were
+independently true, just never checked together. `jc`'s own `src/lib.rs`
+records Pillar 11 activated since PR #348; `sigker/examples/
+cubature_vs_randomized.rs` already exercises production-carrier widths
+(PATH_DIM=4, PATH_LEN=64, N_PATHS=256, "OSINT-typical") — it had simply
+never been *run*. Both doc sites that said otherwise
+(`crates/sigker/src/lib.rs:50`, the ndarray-vertical-simd-alien-magic.md
+W1.5 section) were stale relative to jc's own status and are corrected in
+this same pass.
+
+**What shipped:** `jc`'s `goursat_substrate_probe` example — a throwaway
+falsifier that hardcoded path dimension = 2 to prove the SIMD wavefront
+(A2) matches the shipped scalar recurrence (A0/A1) within a predeclared
+tolerance — is promoted into a real, general-dimension primitive:
+`ndarray::hpc::signature_pde::signature_pde_sweep` (ndarray PR #293),
+matching `sigker::signature_kernel_pde`'s exact `(x: &[Vec<f64>], y: &
+[Vec<f64>]) -> f64` signature. Built entirely on `crate::simd::F64x8`'s
+already-parity-confirmed public methods, so it gets AVX-512/AVX2/NEON/
+wasm/scalar dispatch for free — zero new arch-specific code, satisfying
+the W1a acceptance criterion "all three backends" without writing any of
+them by hand. `sigker::signature_kernel_pde` now delegates to it directly
+(`crates/sigker/Cargo.toml` gains a plain, mandatory `ndarray` path dep,
+matching the operator ruling from earlier this session that ndarray is
+mandatory everywhere numeric/computational code runs — sigker's "zero
+deps" self-description is now scoped to its non-PDE modules only).
+
+**Measured** (release, this host): ~9x speedup over row-major scalar at
+the probe's shapes (256/1024/2048/4096, dim=2) and at dim=5; the exact jc
+Pillar-11 leg shape (8 pairs, len=4609, dim=2) completes in 0.24s total —
+against the ~25-26s this same leg shape cost the scalar path (measured
+earlier this session, see the entry below). All 40 `sigker` lib tests
+pass unchanged with the new backing implementation, including every
+`kernel::tests::pde_kernel_*` numerical-convergence test.
+
+**Distinguish from W5:** W5 (the PowerSig scalability wave) stays firmly
+HOLD — its trigger is real-workload memory/time pressure (1 GiB / 10s),
+unaffected by how fast the Goursat kernel runs. W1.5 is a *scientific
+certification + benchmark-exists* gate, architecturally independent of
+W5's *measured-workload-pressure* gate; opening one says nothing about
+the other. Both gates were checked LITERALLY against their recorded
+conditions this session, not against restated prose — the discipline
+this workspace's `Reading-Depth-Ladder` demands.
+
+**Remaining W1.5 items #7 (`TD-NDARRAY-SIMD-RANDOMIZED-PROJECTION`) and
+#8 (`TD-NDARRAY-SIMD-LYNDON-PACK`)** are now unblocked by the same open
+gate but not yet built — next in the shopping list, not scoped this
+session.
+
+---
 
 ## 2026-09-02 — E-PILLAR-11-PUBLISHED-BOUND-NEEDS-ITS-OWN-NUMERIC-GUARD-1
 

.claude/board/TECH_DEBT.md

@@ -1672,15 +1672,17 @@ multi-antecedent path for real.
 
 ---
 
-### TD-NDARRAY-SIMD-SIGNATURE-PDE-SWEEP (W1.5-#6, DEFERRED)
+### TD-NDARRAY-SIMD-SIGNATURE-PDE-SWEEP (W1.5-#6, SHIPPED)
 
 - **Severity:** P3 (deferred; activates when sigker is benchmarked at production carrier widths)
 - **Surfaced in:** sigker architectural review 2026-05-16; `.claude/knowledge/ndarray-vertical-simd-alien-magic.md` §W1.5
-- **Status:** Deferred (gated on `jc Pillar 11` activation per `crates/sigker/src/lib.rs:42-47`)
-- **Description:** sigker computes signature kernel `〈S(X), S(Y)〉` via Goursat PDE (depth-∞ in O(T₁·T₂) flops, no signature materialization). This is a 2D banded grid sweep over `F32x16` state with a kernel-eval closure per step — the dominant primitive for any path-signature workload. Currently scalar Rust in `sigker::kernel`. Activation requires `jc Pillar 11` (Hambly-Lyons signature uniqueness) certification.
-- **Required API surface (when activated):**
+- **Status:** ~~Deferred~~ **SHIPPED 2026-09-02.** Both activation clauses measured true: sigker's `cubature_vs_randomized` example already exercises production carrier widths (PATH_DIM=4/PATH_LEN=64/N_PATHS=256), and `jc`'s own `src/lib.rs` records Pillar 11 activated since PR #348 (`crates/jc/src/lib.rs`'s header, not the stale prose that used to sit at `crates/sigker/src/lib.rs:42-47` — that doc comment is now corrected too, same commit). Shipped as `ndarray::hpc::signature_pde::signature_pde_sweep` (ndarray PR #293), generalized to arbitrary path dimension rather than the `F32x16`-fixed sketch originally specified below (that sketch predates the discovery that `sigker`'s carrier is `f64`/`Vec<Vec<f64>>`, not `f32`/`F32x16` — the shipped API is a deliberate, better-fitted deviation from the sketch, not a shortfall against it). `sigker::signature_kernel_pde` now delegates to it directly.
+- **Description (as originally scoped, kept for the historical shape):** sigker computes signature kernel `〈S(X), S(Y)〉` via Goursat PDE (depth-∞ in O(T₁·T₂) flops, no signature materialization). This is a 2D banded grid sweep over `F32x16` state with a kernel-eval closure per step — the dominant primitive for any path-signature workload. Currently scalar Rust in `sigker::kernel`. Activation requires `jc Pillar 11` (Hambly-Lyons signature uniqueness) certification.
+- **Required API surface (as originally scoped):**
   - `pub fn signature_pde_sweep<F>(x: &[F32x16], y: &[F32x16], kernel_fn: F) -> f32 where F: Fn(F32x16, F32x16) -> F32x16;` — Goursat 2D sweep, closure-parameterized kernel, banded update.
-- **Cross-ref:** `crates/sigker/src/lib.rs:42-47`; `crates/sigker/src/kernel.rs`; CLAUDE.md `I-NOISE-FLOOR-JIRAK` (sigker bypasses).
+- **Shipped API surface (what actually landed):**
+  - `pub fn signature_pde_sweep(x: &[Vec<f64>], y: &[Vec<f64>]) -> f64` in `ndarray::hpc::signature_pde` — matches `sigker::signature_kernel_pde`'s exact signature for drop-in use, arbitrary dimension via per-axis SoA arrays, `F64x8::mul_add`-based anti-diagonal wavefront (not closure-parameterized — the kernel here is fixed as the Euclidean inner product, not user-supplied).
+- **Cross-ref:** `crates/sigker/src/lib.rs`; `crates/sigker/src/kernel.rs`; `crates/jc/examples/w5_trigger_check.rs`; `crates/jc/examples/goursat_substrate_probe.rs` (the dim=2 probe this generalizes); `ndarray/src/hpc/signature_pde.rs`; `ndarray/examples/signature_pde_bench.rs`; CLAUDE.md `I-NOISE-FLOOR-JIRAK` (sigker bypasses).
 
 ---
 

.claude/knowledge/ndarray-vertical-simd-alien-magic.md

@@ -93,24 +93,24 @@ Each consumer crate migrates separately, one PR per crate. The `simd-savant` run
 
 ### W1.5 — sigker primitives (gated on `jc Pillar 11` activation)
 
-Three deferred ndarray PRs for path-signature workloads. **Do not spawn until sigker is benchmarked at production carrier widths and `jc Pillar 11 (Hambly-Lyons signature uniqueness)` activates.** When that gate trips:
+Three ndarray PRs for path-signature workloads, gated on **sigker benchmarked at production carrier widths AND `jc Pillar 11 (Hambly-Lyons signature uniqueness)` activates.** Both clauses are now measured TRUE (2026-09-02): `sigker`'s `cubature_vs_randomized` example exercises PATH_DIM=4/PATH_LEN=64/N_PATHS=256 ("OSINT-typical" widths), and `jc`'s own `src/lib.rs` records Pillar 11 as activated since PR #348. The gate is open:
 
-6. **`TD-NDARRAY-SIMD-SIGNATURE-PDE-SWEEP`** — banded 2D PDE solver kernel for signature inner-product `〈S(X), S(Y)〉` via Goursat (O(T₁·T₂) flops, no signature materialization).
-7. **`TD-NDARRAY-SIMD-RANDOMIZED-PROJECTION`** — fixed-width random-matrix-vector for Cuchiero-Schmocker-Teichmann randomized signatures.
-8. **`TD-NDARRAY-SIMD-LYNDON-PACK`** — Lyndon-basis packing/unpacking for log-signatures (7-13× compression, lossless).
+6. **`TD-NDARRAY-SIMD-SIGNATURE-PDE-SWEEP` — SHIPPED.** `ndarray::hpc::signature_pde::signature_pde_sweep` (ndarray PR #293): the anti-diagonal SIMD wavefront for the Goursat-PDE signature inner-product `〈S(X), S(Y)〉` (O(T₁·T₂·dim) flops, no signature materialization), generalized to arbitrary path dimension. `sigker::signature_kernel_pde` now delegates to it directly — sigker is no longer zero-dep (see the sigker positioning section below, corrected in the same pass).
+7. **`TD-NDARRAY-SIMD-RANDOMIZED-PROJECTION`** — gate open, not yet built: fixed-width random-matrix-vector for Cuchiero-Schmocker-Teichmann randomized signatures.
+8. **`TD-NDARRAY-SIMD-LYNDON-PACK`** — gate open, not yet built: Lyndon-basis packing/unpacking for log-signatures (7-13× compression, lossless).
 
 ---
 
 ## sigker positioning — the Index-regime third lane
 
 `crates/sigker` is the workspace's path-signature codec. Read its `lib.rs` once; key properties:
 
-- **Pure scalar Rust, zero raw intrinsics, zero `ndarray` dep today.** Cleanest exemplar of the "domain crate composes via closures" pattern.
+- **Now a plain, mandatory `ndarray` dependency** (corrected 2026-09-02 — this section previously said "zero `ndarray` dep today", true only until `signature_kernel_pde` was wired to `ndarray::hpc::signature_pde::signature_pde_sweep`, per the operator ruling that ndarray is mandatory everywhere numeric/computational code runs). The rest of sigker (`shuffle`, `signature`, `randomized`, `cubature`) is still pure scalar Rust — the "domain crate composes via closures" pattern applies to those, just not to the PDE kernel path anymore.
 - **Algebraic peer to bgz17 (palette-distance) and deepnsm (NSM tiling).** Third encoding lane in the codec routing table.
 - **Index regime**, not Argmax — by Hambly-Lyons 2010 uniqueness, path signatures are EXACT on tree-quotient classes of paths. **Bypasses the Jirak 2016 noise floor** (`I-NOISE-FLOOR-JIRAK` iron rule in CLAUDE.md) that hits VSA bundling.
-- **Certification gate:** `jc Pillar 11` (Hambly-Lyons signature uniqueness on lance-graph paths) — currently DEFERRED. Activates once sigker is benchmarked at production carrier widths.
+- **Certification gate:** `jc Pillar 11` (Hambly-Lyons signature uniqueness on lance-graph paths) — **ACTIVATED**. Both gate clauses measured true 2026-09-02: sigker's `cubature_vs_randomized` benchmark already exercises production carrier widths, and `jc`'s own source records Pillar 11 active since PR #348.
 
-When `jc Pillar 11` activates, sigker becomes a first-class consumer of ndarray vertical SIMD. The W1.5 wave catalogue above is its primitive shopping list.
+Since `jc Pillar 11` is activated, sigker is now a first-class consumer of ndarray vertical SIMD. Item #6 above shipped; the W1.5 wave catalogue's remaining two items (#7, #8) are its next primitive shopping list.
 
 **Architectural implication:** the W1a primitives must be designed broad enough that the W1.5 primitives compose naturally with them. Specifically, `F32x16` + `BF16x16` operations (already in ndarray) plus the closure-batch primitive shape (introduced in W1a-#1) are the foundation that signature kernels build on. The randomized projection in W1.5-#7 is a `batch_packed<E, F>` over an `F32x16` state with a Gaussian-random closure — same shape as W1a-#1, different lane type.
 

crates/jc/examples/goursat_substrate_probe.rs

@@ -1,18 +1,32 @@
 //! A0/A1/A2 — the Goursat solve on the canonical ndarray substrate.
 //!
-//! The falsifier recorded in `TD-PILLAR11-SCIENTIFIC-LOOPS-BYPASS-NDARRAY-SIMD-1`:
+//! The falsifier recorded in `TD-PILLAR11-SCIENTIFIC-LOOPS-BYPASS-NDARRAY-SIMD-1`,
+//! **as originally run** (2026-09-02, before `signature_kernel_pde` was wired
+//! to the SIMD substrate):
 //!
 //! | arm | storage | traversal | arithmetic |
 //! |---|---|---|---|
-//! | A0 | `Vec<Vec<f64>>` | row-major | scalar (the shipped `signature_kernel_pde`) |
+//! | A0 | `Vec<Vec<f64>>` | row-major | scalar (`signature_kernel_pde` AT THE TIME) |
 //! | A1 | flat `Vec<f64>` | row-major, SAME order | scalar |
 //! | A2 | three rolling anti-diagonals | wavefront | `ndarray::simd::F64x8::mul_add` |
 //!
-//! Contract: A0 = A1 **bit-exact** (only storage changes). A1 <-> A2 under a
-//! predeclared tolerance: the wavefront's `mul_add(c, diag, u)` fuses the
-//! `c·diag + u` rounding the scalar path performs as two roundings, so the two
-//! arms legitimately differ in the last bits. No consumer intrinsics; every
-//! lane op is `ndarray::simd::method()`.
+//! At that time: A0 = A1 bit-exact (only storage changed); A1 <-> A2 differed
+//! under a predeclared tolerance (fused vs. separate rounding of `c·diag`).
+//! That result is what justified promoting A2 into
+//! `ndarray::hpc::signature_pde::signature_pde_sweep` (ndarray PR #293) and
+//! wiring `signature_kernel_pde` to call it directly
+//! (`E-SIGNATURE-PDE-SWEEP-SHIPPED-W1.5-GATE-WAS-QUIETLY-OPEN-1`).
+//!
+//! **Consequence for this probe:** A0 (`signature_kernel_pde`) is now itself
+//! SIMD-backed, so A0 and A1 no longer agree bit-exact — A0 has effectively
+//! become a second, independent implementation of the wavefront (A2 here is
+//! the probe's own from-scratch dim=2 copy; ndarray's shipped primitive is a
+//! separate, general-dimension implementation of the identical algorithm).
+//! The contract below is therefore restated in terms of what is actually
+//! true post-promotion: **A1 is the untouched scalar oracle; A0 and A2 each
+//! agree with A1 within the predeclared tolerance, and with each other** —
+//! three independent codings of the same recurrence, cross-checked.
+//! No consumer intrinsics; every lane op is `ndarray::simd::method()`.
 //!
 //! Run: `cargo run --release --manifest-path crates/jc/Cargo.toml \
 //!       --features hambly-lyons --example goursat_substrate_probe`
@@ -147,14 +161,21 @@ fn goursat_wavefront(x: &[Vec<f64>], y: &[Vec<f64>]) -> f64 {
     prev1[n - 1]
 }
 
+/// Predeclared tolerance for a SIMD-wavefront arm vs. the untouched scalar
+/// oracle (A1): fused vs. separate rounding of `c·diag`, not a post-hoc fit.
+/// Matches `ndarray::hpc::signature_pde`'s own parity-test tolerance.
+const TOLERANCE: f64 = 1e-9;
+
 fn main() {
     println!(
         "{:>6} {:>10} {:>10} {:>10} {:>9} {:>9} {:>12} {:>12}",
-        "len", "A0 secs", "A1 secs", "A2 secs", "A0/A1", "A1/A2", "A0==A1", "|A1-A2|/A1"
+        "len", "A0 secs", "A1 secs", "A2 secs", "A0/A1", "A1/A2", "|A0-A1|/A1", "|A2-A1|/A1"
     );
     for &n in &[256usize, 1024, 2048, 4096] {
         let (x, y) = (path(n), path(n));
         let t = Instant::now();
+        // A0 is now itself SIMD-backed (ndarray::hpc::signature_pde::signature_pde_sweep,
+        // general-dimension) — see the module doc for why this arm's identity changed.
         let a0 = signature_kernel_pde(&x, &y);
         let s0 = t.elapsed().as_secs_f64();
         let t = Instant::now();
@@ -163,22 +184,27 @@ fn main() {
         let t = Instant::now();
         let a2 = goursat_wavefront(&x, &y);
         let s2 = t.elapsed().as_secs_f64();
-        let exact = a0.to_bits() == a1.to_bits();
-        let rel = ((a1 - a2) / a1).abs();
+        let rel_a0 = ((a0 - a1) / a1).abs();
+        let rel_a2 = ((a2 - a1) / a1).abs();
         println!(
-            "{:>6} {s0:>10.4} {s1:>10.4} {s2:>10.4} {:>8.2}x {:>8.2}x {:>12} {rel:>12.3e}",
+            "{:>6} {s0:>10.4} {s1:>10.4} {s2:>10.4} {:>8.2}x {:>8.2}x {rel_a0:>12.3e} {rel_a2:>12.3e}",
             n + 1,
             s0 / s1,
             s1 / s2,
-            if exact { "bit-exact" } else { "DIFFERS" }
         );
         assert!(
-            exact,
-            "A0 != A1 at n={n}: {a0:e} vs {a1:e} — storage change altered the result"
+            rel_a0 <= TOLERANCE,
+            "A0 vs A1 at n={n}: {a0:e} vs {a1:e} — exceeds predeclared tolerance {TOLERANCE:e}"
+        );
+        assert!(
+            rel_a2 <= TOLERANCE,
+            "A2 vs A1 at n={n}: {a2:e} vs {a1:e} — exceeds predeclared tolerance {TOLERANCE:e}"
         );
     }
-    println!("\nA0 = A1 bit-exact at every size (only storage changed).");
     println!(
-        "A1 <-> A2 differ by fused vs. separate rounding of c·diag — the predeclared tolerance."
+        "\nA1 is the untouched scalar oracle. A0 (shipped, general-dimension SIMD) and A2 \
+         (this probe's own dim=2 SIMD copy) each agree with A1 within the predeclared \
+         tolerance ({TOLERANCE:e}) — two independent codings of the same recurrence, \
+         cross-checked against one reference."
     );
 }

crates/sigker/Cargo.toml

@@ -6,9 +6,15 @@ license = "Apache-2.0"
 publish = false
 description = "Path-signature representations: Chen-Lyons signatures, randomized signatures, signature kernels — algebraic peer to bgz17/deepnsm for sequential/path-structured data."
 
-# Zero deps in production — same constitution as bgz17, deepnsm, jc.
-# Standalone, opt-in build via --manifest-path.
+# ndarray is a plain, mandatory dependency (operator ruling: ndarray is
+# mandatory everywhere numeric/computational code runs in the Ada stack —
+# see lance-graph CLAUDE.md and crates/jc/Cargo.toml). signature_kernel_pde
+# is backed by ndarray::hpc::signature_pde::signature_pde_sweep, the SIMD
+# wavefront that replaced the hand-rolled row-major scalar loop
+# (TD-PILLAR11-SCIENTIFIC-LOOPS-BYPASS-NDARRAY-SIMD-1). Otherwise standalone,
+# opt-in build via --manifest-path — same constitution as bgz17, deepnsm, jc.
 [dependencies]
+ndarray = { path = "../../../ndarray" }
 
 [dev-dependencies]