feat(perturbation-sim): wire ndarray::simd Walsh-Hadamard (Morton-pyramid) + helix-360/turbovec live-encoding doctrine

- ndarray-simd feature (optional, off by default → crate stays zero-dep): the
  Morton/Walsh pyramid transform (sketch::walsh_pyramid_energy) routes through
  ndarray::simd::wht_f32 (AVX-512/AMX, x86-64-v4) when enabled; scalar fwht
  fallback otherwise. ndarray = AdaWorldAPI fork (path dep; git alternative
  documented). Verified: 48 tests + clippy clean under BOTH default and
  `--features ndarray-simd` (target-cpu=native); the fork compiles in ~20s.
- METHODS §10: documents the wiring + the deeper tile-specific ndarray targets
  (simd_soa::MultiLaneColumn, hpc::codec::ctu HEVC-quadtree, hilbert, U8x64/
  hamming). And the live-4-factor-encoding doctrine: the factors are unit-free
  spectral magnitudes → carry them on the GENERIC helix Signed360 residue tenant
  (6B/factor, L1-metric-safe so Spearman/ICC survive the encoding), NOT an
  electricity-specific tenant; turbovec ANN for episodic factor-vector search;
  electricity-specific encoding reserved for the raw |V|/MW layer; compute stays
  on raw f64. Anti-dilution rows + README updated.

Real-Iberian validate (261-bus core, release build): Cronbach α=-0.83 (factors
are distinct facets, not one scale), spectral cluster convergent (ρ 0.96-1.00),
infight orthogonal to it (ρ≈±0.05 — discriminant validity = the Go duality
measured), time test-retest ρ≈0.90 (basin ranking stable). Basin model verified.

Author: claude

crates/perturbation-sim/Cargo.lock

@@ -9,7 +9,22 @@ description = "Spectral + edge-propagation outage simulator: models the perturba
 # sigker / helix). Verify with:
 #   cargo test  --manifest-path crates/perturbation-sim/Cargo.toml
 #   cargo run   --manifest-path crates/perturbation-sim/Cargo.toml --example simulate
+[features]
+# Route the Morton/Walsh pyramid transform through ndarray's SIMD
+# (AVX-512/AMX, x86-64-v4) Walsh–Hadamard. Default OFF → the crate stays
+# zero-dep with the scalar `fwht` fallback. Build accelerated with:
+#   RUSTFLAGS='-C target-cpu=x86-64-v4' cargo … --features ndarray-simd
+# (or target-cpu=native locally). All SIMD comes from `ndarray::simd` per the
+# workspace rule — never raw intrinsics here.
+ndarray-simd = ["dep:ndarray"]
+
 [dependencies]
+# The AdaWorldAPI fork ("The Foundation"), optional + behind `ndarray-simd`.
+# Path dep: perturbation-sim lives inside lance-graph, which already path-deps
+# this sibling for its core crates, so the fork is expected present. Clean-
+# checkout alternative (helix pattern): swap to
+#   ndarray = { git = "https://github.com/AdaWorldAPI/ndarray.git", branch = "master", optional = true, default-features = false, features = ["std"] }
+ndarray = { path = "../../../ndarray", optional = true, default-features = false, features = ["std"] }
 
 [lib]
 name = "perturbation_sim"

crates/perturbation-sim/Cargo.toml

@@ -323,6 +323,40 @@ model with the highest criterion validity *is the evidence* for which aging
 story (uniform / density-correlated / spend-driven) best explains the blackout —
 turning a modeling assumption into a testable claim.
 
+## 10. SIMD acceleration + the live-encoding carrier
+
+### `ndarray-simd` feature (the Morton-pyramid transform, accelerated)
+The pyramid's Walsh–Hadamard transform routes through **`ndarray::simd::wht_f32`**
+(AVX-512/AMX under `target-cpu=x86-64-v4`) — the one workspace-sanctioned SIMD
+source (never raw intrinsics here). Default **OFF** → scalar `fwht`, zero-dep;
+**ON** via `--features ndarray-simd` (ndarray fork as a git/path dep, `["std"]`).
+Both paths pass the same tests. Deeper *tile-specific* ndarray targets, to wire
+as the SoA tile layout matures: `simd_soa::MultiLaneColumn` (byte-backed SoA
+column → `f32x16`/`f64x8`/`u8x64` lanes — the natural Morton-tile field store),
+`hpc::codec::ctu` (HEVC **quadtree** = the Morton tile), `hpc::linalg::hilbert`
+(space-filling curve), and `hamming_distance_raw`/`U8x64` (the XOR **sign** side).
+
+### Live 4-factor encoding — generic residue carrier, NOT an electricity tenant
+The four factors (`d_lambda2`, `dk_rotation`, `d_conductance`, `infight`,
+`raumgewinn`) are **abstract signed spectral magnitudes** — already unit-free —
+so they fit the **generic helix `Signed360` residue tenant** (6 B/factor, signed
+full-sphere, the `HelixResidue` contract value-tenant), *not* a bespoke
+electricity tenant. The load-bearing reason: `Signed360`'s distance is
+**L1-metric-safe**, so **Spearman/ICC computed on the residue-encoded factors ≈
+on the raw f64** — the statistics battery survives the encoding. Roles:
+- **Carrier (live stream/store):** helix `Signed360` residue — 6 B/factor,
+  metric-safe; a contingency's 5-factor record ≈ 30 B, streamable + comparable
+  by L1.
+- **Search ("which past contingencies resemble this now"):** `turbovec` ANN
+  (2–4 bit/dim, data-oblivious) over the factor vectors — episodic retrieval.
+- **Compute:** the f64 field tier — definitive stats on **raw f64**; residue +
+  turbovec are storage/stream/search carriers, never the compute.
+
+Reserve **electricity-specific** encoding for the **raw physical layer** (AC
+`|V|`, MW — where units actually bite), never the factor layer. (`Signed360` is
+256-palette lossy, ±½ bucket — fine for a live screen/stream; compute exact
+stats on raw. `turbovec` is coarse — retrieval, not values.)
+
 ## Anti-dilution table — the distinctions to never collapse
 
 | Do NOT conflate | Because |
@@ -343,3 +377,5 @@ turning a modeling assumption into a testable claim.
 | Uniform-aging null vs density-proxy Gegenhypothese | uniform = relative-invariant null; density-proxy = genuine topology-derived heterogeneity that *should* bend the shape — they are competing hypotheses, validated against the observed footprint |
 | DC overload cascade vs voltage collapse | the 28 Apr 2025 Iberian blackout was **voltage/reactive driven** (ENTSO-E expert panel), NOT line-overload — the DC cascade screens *structural* vulnerability, the voltage *trigger* needs the AC fork; do not claim the DC path reproduces that event (see `DATA_SOURCES.md` §5) |
 | Electrical mechanism vs human footprint | the cascade/voltage event is the *mechanism*; excess mortality (147 deaths, Eurosurveillance) is the *consequence/severity* — validate them separately |
+| Generic Signed360 residue tenant vs electricity-specific tenant | the 4 factors are unit-free spectral magnitudes → the generic L1-metric-safe residue carries them (stats survive); reserve a bespoke electricity tenant for the raw `|V|`/MW layer only |
+| Residue/turbovec carrier vs the compute | residue (store/stream) + turbovec (search) are carriers; the definitive 4-factor values + stats are computed on raw f64, never on the lossy code |

crates/perturbation-sim/METHODS.md

@@ -14,6 +14,11 @@ method:
 | **Gaussian-splat magnitude side** (PROTOTYPE) | anisotropic `Σ` fit to the electrical neighbourhood + EWA pyramid coarsen (Morton-seam anti-alias) + `morton2`. The magnitude algebra complementing the Walsh sign side. | `splat.rs` |
 | **Data-shaped scoping** | run on today's data; `assess_capability` gates which outputs are valid; missing variables modeled as uniform constants (provably free for relative results); `AgeModel` = Uniform null vs DensityProxy Gegenhypothese (topology-only) vs ModernizationSpend (official planning data). | `model.rs` |
 
+> **SIMD:** the Morton/Walsh pyramid transform optionally routes through
+> `ndarray::simd::wht_f32` (AVX-512/AMX) via `--features ndarray-simd`
+> (`RUSTFLAGS='-C target-cpu=x86-64-v4'`); default is the zero-dep scalar path.
+> All SIMD comes from `ndarray::simd` (workspace rule). See `METHODS.md §10`.
+
 > **Methods & math grounding:** see [`METHODS.md`](METHODS.md) — the one-operator
 > grounding that connects all four, the anti-dilution distinctions (combinatorial
 > `λ₂` vs normalized `μ₂`; geography vs electrical distance; infight vs

crates/perturbation-sim/README.md

@@ -416,10 +416,26 @@ mod tests {
         // (With charging, zero load still lifts V slightly — the Ferranti effect.)
         let sys = AcSystem::new(
             vec![
-                AcBus { kind: BusKind::Slack, p: 0.0, q: 0.0, v_set: 1.0 },
-                AcBus { kind: BusKind::Pq, p: 0.0, q: 0.0, v_set: 1.0 },
+                AcBus {
+                    kind: BusKind::Slack,
+                    p: 0.0,
+                    q: 0.0,
+                    v_set: 1.0,
+                },
+                AcBus {
+                    kind: BusKind::Pq,
+                    p: 0.0,
+                    q: 0.0,
+                    v_set: 1.0,
+                },
             ],
-            vec![AcLine { from: 0, to: 1, r: 0.02, x: 0.1, b_shunt: 0.0 }],
+            vec![AcLine {
+                from: 0,
+                to: 1,
+                r: 0.02,
+                x: 0.1,
+                b_shunt: 0.0,
+            }],
         );
         let r = sys.solve(50, 1e-10);
         assert!(r.converged);

crates/perturbation-sim/src/acflow.rs

@@ -94,7 +94,25 @@ pub fn resistance_sketch(
 
 // ── Walsh / Morton pyramid screen ────────────────────────────────────────────
 
+/// Walsh–Hadamard dispatch: the SIMD `ndarray::simd::wht_f32` when the
+/// `ndarray-simd` feature is on (the Morton pyramid transform, accelerated),
+/// else the scalar [`fwht`]. The pyramid energy is a screen, so the f32 SIMD
+/// path's precision is ample.
+#[cfg(feature = "ndarray-simd")]
+fn wht_dispatch(a: &mut [f64]) {
+    let mut f: Vec<f32> = a.iter().map(|&x| x as f32).collect();
+    ndarray::simd::wht_f32(&mut f);
+    for (d, s) in a.iter_mut().zip(f) {
+        *d = s as f64;
+    }
+}
+#[cfg(not(feature = "ndarray-simd"))]
+fn wht_dispatch(a: &mut [f64]) {
+    fwht(a);
+}
+
 /// In-place fast Walsh–Hadamard transform (length must be a power of two).
+/// Scalar reference; the accelerated path is [`wht_dispatch`].
 pub fn fwht(a: &mut [f64]) {
     let n = a.len();
     let mut h = 1;
@@ -132,7 +150,7 @@ pub fn walsh_pyramid_energy(field: &[f64]) -> WalshEnergy {
     }
     let mut a = vec![0.0; n];
     a[..field.len()].copy_from_slice(field);
-    fwht(&mut a);
+    wht_dispatch(&mut a);
 
     let levels = (n as f64).log2() as usize + 1;
     let mut per = vec![0.0; levels];