feat(perturbation-sim): probe 2 — witness arc as a standing wave (METHODS §11)

Proves the particle == wave identity §11 asserts: a witness arc (a Markov #1
reference chain over the SoA) read by walking it (particle, O(hops) pointer-chase)
equals its standing-wave evaluation via Parseval on the Walsh-Hadamard pyramid
(Hᵀ H = N·I, the fwht involution-up-to-N already in sketch.rs):
⟨field, arc⟩ = (1/N)·⟨Ĥfield, Ĥarc⟩.

- witness_particle: the pointer-chase walk (∑ field·arc).
- field_spectrum: the standing wave, computed ONCE (O(N log N)).
- witness_from_spectrum: read any arc off the spectrum (O(N)) — the amortization
  win (one transform, q arcs) vs q independent particle walks.
- witness_wave / particle_equals_wave: convenience + the probe's pass predicate.

Self-contained in perturbation-sim; the contract witness_table evaluator is the
separate gated step (SoA spine = additive-only behind the iron rules). Example
`witness` runs it on the inertia-buffer field (ties §11's "inertia field on power
grids" to the promoted member) — particle vs wave agree to 0.00e0.

Tests: +4 (Parseval identity, one-transform-many-arcs amortization, non-pow2 +
ragged-arc padding, degenerate-safe). fmt + clippy --all-targets -D warnings clean;
86 tests.

Author: claude

crates/perturbation-sim/Cargo.toml

@@ -104,3 +104,7 @@ path = "examples/hhtl_grid.rs"
 [[example]]
 name = "chaoda"
 path = "examples/chaoda.rs"
+
+[[example]]
+name = "witness"
+path = "examples/witness.rs"

crates/perturbation-sim/examples/witness.rs

@@ -0,0 +1,70 @@
+//! The witness arc as a standing wave (METHODS §11) — particle (pointer-chase) vs
+//! wave (Walsh-pyramid Parseval), on a real grid inertia field.
+//!
+//! Builds the per-bus inertia-buffer field, then reads three witness arcs both ways:
+//! the particle walk (`O(hops)` per arc) and the standing wave (one `field_spectrum`
+//! transform, then `O(N)` per arc). They agree to floating point — and the wave form
+//! amortizes one transform across all arcs.
+//!
+//! Run: cargo run --release --manifest-path crates/perturbation-sim/Cargo.toml \
+//!        --example witness
+
+use perturbation_sim::{
+    field_spectrum, inertia_buffer_column, witness_from_spectrum, witness_particle,
+};
+
+fn proxy_inertia(n: usize) -> Vec<f64> {
+    (0..n).map(|i| 2.0 + (i % 5) as f64).collect()
+}
+
+fn main() {
+    // The field: a per-bus inertia-buffer field over a 16-bus line (METHODS §11's
+    // "inertia field on power grids"; the promoted additive member as the carrier).
+    let n = 16;
+    let field = inertia_buffer_column(&proxy_inertia(n), 0.2);
+    let field: Vec<f64> = field.iter().map(|&x| x as f64).collect();
+
+    // Three witness arcs (Markov #1 reference chains over the buses):
+    //   - a single-hop witness (read one bus),
+    //   - a coarse dyadic arc (the first half — a Raumgewinn-scale reference),
+    //   - an alternating signed chain (a fine-scale infight reference).
+    let mut single = vec![0.0; n];
+    single[5] = 1.0;
+    let mut coarse = vec![0.0; n];
+    for c in coarse.iter_mut().take(n / 2) {
+        *c = 1.0;
+    }
+    let alt: Vec<f64> = (0..n)
+        .map(|i| if i % 2 == 0 { 1.0 } else { -1.0 })
+        .collect();
+    let arcs: [(&str, &[f64]); 3] = [
+        ("single-hop", &single),
+        ("coarse dyadic", &coarse),
+        ("alternating", &alt),
+    ];
+
+    // Wave view: transform the field ONCE; every arc is then an O(N) read off it.
+    let spectrum = field_spectrum(&field);
+
+    println!("witness arc as a standing wave — particle (walk) vs wave (Parseval)\n");
+    println!("  field: {n}-bus inertia-buffer field; one Walsh transform reused by all arcs\n");
+    println!(
+        "  {:>14}  {:>14}  {:>14}  {:>10}",
+        "arc", "particle", "wave", "Δ"
+    );
+    let mut max_err = 0.0_f64;
+    for (name, arc) in arcs {
+        let p = witness_particle(&field, arc);
+        let w = witness_from_spectrum(&spectrum, arc);
+        let d = (p - w).abs();
+        max_err = max_err.max(d);
+        println!("  {name:>14}  {p:>14.9}  {w:>14.9}  {d:>10.2e}");
+    }
+    println!(
+        "\n  max |particle − wave| = {max_err:.2e} (Parseval: Hᵀ H = N·I, exact up to fp).\n  \
+         particle = O(hops) pointer-chase per arc; wave = O(N log N) once + O(N) per arc.\n  \
+         The standing wave IS the witness arc — evaluated all at once, no chain walk.\n  \
+         (Demonstration in perturbation-sim; the contract witness_table evaluator is the\n  \
+         separate gated step — the SoA spine is additive-only behind the iron rules.)"
+    );
+}

crates/perturbation-sim/src/lib.rs

@@ -68,6 +68,7 @@ pub mod sketch;
 pub mod splat;
 pub mod stats;
 pub mod timing;
+pub mod witness;
 
 pub use acflow::{AcBus, AcLine, AcSystem, BusKind, PowerFlowResult};
 pub use basin::{
@@ -102,3 +103,6 @@ pub use timing::{
     cascade_wall_time, collapse_number, implied_dt_per_hop, mechanism_from_timescale, meta_cascade,
     meta_cascade_phase, per_hop_time, rocof_hz_per_s, tier_composite, MetaHop, HHTL_WEIGHTS,
 };
+pub use witness::{
+    field_spectrum, particle_equals_wave, witness_from_spectrum, witness_particle, witness_wave,
+};

crates/perturbation-sim/src/witness.rs

@@ -0,0 +1,140 @@
+//! Probe 2 — the **witness arc as a standing wave** (METHODS §11).
+//!
+//! A *witness arc* is a Markov #1 reference chain over the SoA — a path that reads
+//! a field by accumulating it along the chain. METHODS §11 says the same arc can be
+//! evaluated two ways, and they must agree:
+//!
+//! - **Particle view (pointer chasing).** Walk the arc hop by hop, accumulating the
+//!   field along it: `∑ field[i]·arc[i]`. One dependent load per hop — `O(hops)`
+//!   sequential dereferences (the `CausalEdge64` W-slot → witness chain walk).
+//! - **Wave view (standing wave).** The arc's reading IS an inner product against
+//!   the field, and by **Parseval for the Walsh–Hadamard transform** (`Hᵀ H = N·I`,
+//!   the involution-up-to-`N` the pyramid already provides via [`fwht`]):
+//!   `⟨field, arc⟩ = (1/N)·⟨Ĥfield, Ĥarc⟩`. Transform the field **once**
+//!   (`O(N log N)`); then every witness arc is an `O(N)` dot against its spectrum —
+//!   the whole arc is evaluated at once, no walk.
+//!
+//! **The identity `particle == wave` is what this probe proves** ([`particle_equals_wave`]).
+//! The payoff is amortization: [`field_spectrum`] computes the standing wave once,
+//! and [`witness_from_spectrum`] reads many arcs off it — `O(N log N) + q·O(N)` for
+//! `q` arcs, vs the particle view's `q` independent pointer-chasing walks.
+//!
+//! Self-contained, in perturbation-sim — this demonstrates the pyramid/field
+//! mechanism on a grid field (e.g. the [`crate::inertia_buffer_column`] field).
+//! Wiring it as the *actual* `witness_table` evaluator in the contract is a separate,
+//! gated step: the witness/SoA types are the cognitive spine — additive only, behind
+//! the iron rules.
+
+use crate::sketch::fwht;
+
+/// Pad a field to the next power-of-two length (zero-filled), the length [`fwht`]
+/// requires. Returns the padded buffer.
+fn pad_pow2(v: &[f64]) -> Vec<f64> {
+    let mut n = 1usize;
+    while n < v.len().max(1) {
+        n <<= 1;
+    }
+    let mut a = vec![0.0; n];
+    a[..v.len()].copy_from_slice(v);
+    a
+}
+
+/// **Particle view.** The witness arc read by walking it: `∑ field[i]·arc[i]`, the
+/// pointer-chase accumulation (`O(len)` sequential). `field` and `arc` are read up to
+/// their shared length.
+pub fn witness_particle(field: &[f64], arc: &[f64]) -> f64 {
+    field.iter().zip(arc).map(|(f, a)| f * a).sum()
+}
+
+/// The field's **standing-wave spectrum** — the Walsh–Hadamard pyramid of the field,
+/// computed ONCE. Reuse across many witness arcs via [`witness_from_spectrum`].
+pub fn field_spectrum(field: &[f64]) -> Vec<f64> {
+    let mut a = pad_pow2(field);
+    fwht(&mut a);
+    a
+}
+
+/// Read a witness arc off a precomputed field spectrum: `(1/N)·⟨spectrum, Ĥarc⟩`
+/// (Parseval). Equals [`witness_particle`] up to floating-point. `spectrum` must come
+/// from [`field_spectrum`] (length `N`, a power of two).
+pub fn witness_from_spectrum(spectrum: &[f64], arc: &[f64]) -> f64 {
+    let n = spectrum.len();
+    if n == 0 {
+        return 0.0;
+    }
+    let mut a = vec![0.0; n];
+    let take = arc.len().min(n);
+    a[..take].copy_from_slice(&arc[..take]);
+    fwht(&mut a);
+    spectrum.iter().zip(&a).map(|(x, y)| x * y).sum::<f64>() / n as f64
+}
+
+/// **Wave view.** The same reading as [`witness_particle`], via Parseval on the Walsh
+/// pyramid — transform field + arc, then `(1/N)·∑ Ĥfield·Ĥarc`. Self-contained
+/// (transforms both); for many arcs prefer [`field_spectrum`] + [`witness_from_spectrum`].
+pub fn witness_wave(field: &[f64], arc: &[f64]) -> f64 {
+    witness_from_spectrum(&field_spectrum(field), arc)
+}
+
+/// Convenience: does the wave view reproduce the particle view for this `(field,
+/// arc)` within `tol`? The probe's pass/fail predicate.
+pub fn particle_equals_wave(field: &[f64], arc: &[f64], tol: f64) -> bool {
+    (witness_particle(field, arc) - witness_wave(field, arc)).abs() <= tol
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Parseval: the standing wave reproduces the pointer-chase walk exactly (fp).
+    #[test]
+    fn particle_equals_wave_parseval() {
+        let field = [0.3, -1.2, 0.7, 2.1, -0.4, 0.9, 1.5, -0.8];
+        // A witness arc: a signed Markov reference chain over the nodes.
+        let arc = [1.0, 0.0, -1.0, 1.0, 0.0, 0.0, -1.0, 1.0];
+        let p = witness_particle(&field, &arc);
+        let w = witness_wave(&field, &arc);
+        assert!((p - w).abs() < 1e-9, "particle {p} vs wave {w}");
+        assert!(particle_equals_wave(&field, &arc, 1e-9));
+    }
+
+    /// The amortization claim: ONE field transform, then many arcs read off it — each
+    /// matching its particle walk.
+    #[test]
+    fn standing_wave_reuses_one_transform() {
+        let field = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        let spectrum = field_spectrum(&field); // computed once
+        let arcs = [
+            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], // single-hop witness
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], // coarse dyadic arc
+            [0.0, 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, -1.0], // alternating chain
+        ];
+        for arc in &arcs {
+            let p = witness_particle(&field, arc);
+            let w = witness_from_spectrum(&spectrum, arc);
+            assert!(
+                (p - w).abs() < 1e-9,
+                "arc {arc:?}: particle {p} vs wave {w}"
+            );
+        }
+    }
+
+    /// Non-power-of-two fields are padded transparently; the identity still holds.
+    #[test]
+    fn handles_non_power_of_two_and_ragged_arc() {
+        let field = [0.5, -0.5, 2.0, 1.0, -1.0]; // length 5 → pads to 8
+        let arc = [1.0, 1.0, -1.0]; // shorter arc → zero-extended
+        let p = witness_particle(&field, &arc);
+        let w = witness_wave(&field, &arc);
+        assert!((p - w).abs() < 1e-9, "ragged: particle {p} vs wave {w}");
+    }
+
+    /// Degenerate inputs never panic / never NaN.
+    #[test]
+    fn degenerate_is_safe() {
+        assert_eq!(witness_particle(&[], &[]), 0.0);
+        assert_eq!(witness_wave(&[], &[]), 0.0);
+        assert!(field_spectrum(&[]).len().is_power_of_two());
+        assert_eq!(witness_from_spectrum(&[], &[1.0]), 0.0);
+    }
+}