pillar: bit-exact i128 lattice signature lane + Hambly-Lyons Thm 2/3 certificate

New src/hpc/pillar/lattice_signature.rs (feature `pillar`). For unit-step
lattice walks every level-k signature coefficient has denominator k!, so
the lane stores k!·S_k as i128: identity is `==`, no tolerance anywhere.
Chen composition with a unit step is a binomial convolution against a
tensor supported on (a,…,a) only. Depth policy is integer:
theorem2_depth(L) = ceil(23959·L/10000) ≥ floor(e·ln(1+√2)·L), the
constant re-read from math/0507536v2 p.11/p.14; theorem3_factor(d) =
2·ceil(log3(d/2))+3 by integer loop. Overflow contract: len^depth < 2^126,
checked arithmetic, never wrapped.

Pinned: 484/484 reduced d=2 words of length ≤ 5 separated at the theorem
depth; 64/64 tree-like words exactly the identity; 64 reduced length-8
words share S^(2)=1 with the constant path (the paper's figure-of-8 class)
and all separate at level 3; d=1 collapses the 64 length-6 words to exactly
7 tensors; parity with the f32 signature_d2_deg3 lane on every lattice word
of length ≤ 6; FNV bit-exactness digest 0xBFAB3E55601E4E41;
prove_pillar_11_lattice() deterministic PillarReport.

signature.rs stays the f32 kernel-stability battery; this is the uniqueness
half, the ndarray twin of lance-graph jc::hambly_lyons W6 (lance-graph
#1133) with the f64 tolerance replaced by integer equality. Scalar integer
reference lane by design; the W1.5 vectorised lane must reproduce these
tensors bit-for-bit. Gates: 11/11 lane tests + doctest, clippy -D warnings,
fmt. Blackboard entry added.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QHVUi6Q9XtmKgxh6pDRayP

Author: claude

.claude/blackboard.md

@@ -3,7 +3,41 @@
 > **Read this first.** The "Polyglot Notebook" architecture below is a
 > separate/older program, not the current epoch.
 
-## 2026-08-31 (latest) — W1a-#9 masking primitives SHIPPED on every dispatch arm (PR #285)
+## 2026-09-01 (latest) — Pillar-11 lattice lane: BIT-EXACT i128 lattice signature + Hambly–Lyons Thm 2/3 certificate
+
+`src/hpc/pillar/lattice_signature.rs` (feature `pillar`). For unit-step
+lattice walks every level-`k` signature coefficient is a rational with
+denominator `k!`, so the lane stores `k!·S_k` as `i128` and the whole
+computation is bit-exact — identity is `==`, no tolerance. Chen composition
+with a unit step is a binomial convolution against a tensor supported on
+`(a,…,a)` only, so each step costs `O(Σ_k d^k·k)`. Depth policy is INTEGER:
+`theorem2_depth(L) = ⌈23959·L/10000⌉ ≥ ⌊e·ln(1+√2)·L⌋` (constant re-read
+from math/0507536v2 p.11/p.14 on the main thread; the float never enters
+the kernel), `theorem3_factor(d) = 2⌈log₃(d/2)⌉+3` by integer loop.
+Measured (debug, 3.2 s): 484/484 reduced `d=2` words of length ≤ 5 separated
+at the theorem depth; 64/64 tree-like words EXACTLY the identity; 64
+reduced length-8 words share `S^(2) = 1` with the constant path (the
+paper's §1.6 figure-of-8 class) and every one separates at level 3
+(`3!·S_xxy = 6` for the canonical one); `d = 1` collapses the 64 length-6
+words to exactly 7 tensors (net increment only — the `d ≥ 2` precondition
+is now a pin, not prose). Parity pin against the existing f32 lane
+`signature_d2_deg3` on every lattice word of length ≤ 6 (exact small
+integers). Bit-exactness pin: FNV digest `0xBFAB3E55601E4E41` over all
+words of length ≤ 4 at theorem depth. `prove_pillar_11_lattice()` reports
+`psd_rate` = separated fraction (1.0), `n_paths` = 484, `n_hops` = 64
+false merges, `lognorm_concentration` = deepest separation level (3).
+**Disambiguation:** `signature.rs` stays the f32 depth-3 kernel-STABILITY
+battery; this lane is the UNIQUENESS half, and it is the ndarray twin of
+lance-graph `jc::hambly_lyons` W6 (PR #1133) with the f64 tolerance
+replaced by integer equality. **SIMD:** scalar integer reference lane on
+purpose; the W1.5 sigker vectorised lane (now unblocked) must reproduce
+these `i128` tensors bit-for-bit. Loose ends: an `i128` lane in
+`ndarray::simd` does not exist; the `d ≥ 3` arm of Theorem 3 is
+implemented (depth formula) but not exercised by a test beyond the factor
+pins; `crates/sigker-parity` should gain a W1b test comparing this lane
+against `sigker::signature_truncated` on lattice words (exact ints vs f64).
+
+## 2026-08-31 — W1a-#9 masking primitives SHIPPED on every dispatch arm (PR #285)
 
 `U64x8`/`U32x16` gained `andnot` (set difference, `self & !other` — argument
 order deliberately differs from the raw Intel intrinsic, same direction on