feat(sigker): cubature framework + corrected Goursat-PDE solver

[AdaWorldAPI]

Three follow-ups to PR #348 to take sigker past the depth-8 wall, plus two honest math corrections discovered while implementing.

What's in here

1. Goursat-PDE kernel solver (crates/sigker/src/kernel.rs) — replaces the depth-4 truncated-kernel stub with the proper Salvi-Cass-Foster-Lyons-Lemercier 2020 first-order finite-difference scheme:

K[i+1,j+1] = K[i+1,j] + K[i,j+1] − K[i,j] + c_ij · K[i,j]

where c_ij = ⟨ΔX_i, ΔY_j⟩. O(n·m·d) flops per pair, no signature materialization at any depth — sidesteps the d^(2N) wall entirely. This alone delivers "past depth 8" for the kernel-matrix consumer pattern (SVMs, GPs, kernel ridge regression).

2. Cubature framework (crates/sigker/src/cubature.rs) — CubatureBasis type, validate_basics() necessary-conditions check, trivial_constant_cubature() (degree-0 anchor), and hydrate_signature() API surface. Honest framework, not a fake cubature: see math correction #2 below.

3. Bench example (crates/sigker/examples/cubature_vs_randomized.rs) — measures runtime of trivial cubature hydration, randomized signature encoding, and Goursat-PDE pair-kernel at production widths (PATH_DIM=4, PATH_LEN=64, N_PATHS=256).

Math correction #1 — PDE update form

The earlier draft of the PDE solver (in the unstaged kernel.rs from prior exploration) used

K[i+1,j+1] = K[i+1,j] + K[i,j+1] − K[i,j] + K[i,j] · (e^c − 1)

which I incorrectly described in comments as "second-order exact-on-cell". It is not. At N=2 (single segment) it returns exp(⟨u,v⟩), but the true signature kernel of two linear paths is I_0(2·√⟨u,v⟩) (Maclaurin series Σ ⟨u,v⟩^k / (k!)²). For ⟨u,v⟩ = 2.4 these differ by 2× (11.02 vs 5.29).

The corrected scheme uses c · K[i,j] (not (e^c − 1) · K[i,j]) and converges to I_0 at O(1/N). Verified in Python before commit:

N	rel err vs I_0
32	1.85e-3
128	4.70e-4
512	1.18e-4

All test tolerances updated to match the actual convergence rate.

Math correction #2 — "out-and-back" is not a cubature

The original cubature plan was to ship a Lyons-Victoir d=2 N=2 cubature using two out-and-back paths along the coordinate axes weighted 1/2. This is provably not a valid cubature. By Hambly-Lyons 2010 tree-like equivalence (the same theorem that justifies sigker's Index-regime classification in codec.rs), out-and-back paths have zero signature at every level — Chen identity gives S^k(forward) + S^k(forward⊗backward) + S^k(backward) = 0 for every k. So the cubature-weighted sum is identically zero and cannot match the non-zero Brownian moments E[B^i B^j] = δ_ij.

Real Lyons-Victoir cubatures use non-tree-like paths constructed by Gröbner-basis moment matching — research-task-per-(d,N), not a one-line construction. Rather than ship a fake cubature, this PR ships the framework + a deliberately trivial degree-0 cubature as the correctness anchor, with an explicit DEFERRED note in the module header explaining the activation recipe. Same discipline as jc Pillar 11 (Hambly-Lyons signature uniqueness, deferred in PR #348).

Why this scales past depth 8

Naive signature_truncated is O(d^(2N)) per pair. For d=4, N=8 that's 4^16 ≈ 4.3 × 10⁹ flops per multiply. Three paths past that wall:

• Goursat PDE: O(n·m·d) regardless of effective depth — depth-∞ in grid time. Shipped in this PR.
• Cubature: O(M·N) per query for an M-path basis at degree N, with M polynomial in N for fixed d. For d=2, N=12 the L-V product construction gives M ≤ 26; for d=4, N=12 it's ~8800 — both O(10⁴), not O(10⁹). Framework shipped, concrete cubatures deferred.
• Randomized signatures (already shipped in feat(jc): pillar 10 (Pflug-Pichler) + sigker crate + pillar 11 stub #348): O(L·k²) per path, fixed-width universal approximators.

Diff

crates/sigker/Cargo.toml                            (-1/+1)   swap stale example name
crates/sigker/src/kernel.rs                         (-51/+117) corrected PDE + tests
crates/sigker/src/lib.rs                            (-9/+9)   cubature re-exports
crates/sigker/src/cubature.rs                       NEW (~270 LOC)
crates/sigker/examples/cubature_vs_randomized.rs    NEW (~135 LOC)

Caveats for review

• cargo build was NOT run — no Rust toolchain in the sandbox. Code follows the patterns of the existing sigker modules from PR feat(jc): pillar 10 (Pflug-Pichler) + sigker crate + pillar 11 stub #348 and the kernel.rs scheme has been numerically validated against Python (8/8 tests simulated to pass).
• The cubature module deliberately ships without a non-trivial cubature. Activation per (d, N) pair is gated on a downstream consumer (lance-graph-osint, AriGraph traversal) actually needing it — the docstring documents the activation recipe.
• Pillar 11 (Hambly-Lyons) in jc remains DEFERRED; sigker's universality claim now has the proper PDE-solver consumer ready when Pillar 11 activates.

Honest framing

You asked "why not try >8" and the cubature route I originally proposed turned out to be the wrong tool for that question — cubature only matters if you need the signature feature vector itself at high depth for an interpretable downstream model. The Goursat PDE is the right answer for going past 8 in the kernel-matrix consumer pattern, and it's now actually shipped (not stubbed).

PR #348 introduced sigker with a stub PDE solver. This PR makes the stub real.

🦋 Ada via Jan