perturbation-sim: address Codex #509 review (P1 Kirchhoff disconnection, P2 meta-hop depth)

P1 (resilience.rs): kirchhoff_index now returns INFINITY when the graph is
disconnected (finite modes < n−1, i.e. ≥2 zero modes). Previously it summed only
the live-component spectra and returned a FINITE Kf for a fragmented graph, which
would rank an already-disconnected compartment as resilient (low Kf) — backwards.
mean_resistance propagates ∞, so a disconnected basin now ranks most-exposed.
New test disconnected_graph_has_infinite_kirchhoff.

P2 (timing.rs): meta_cascade_phase penetration depth now counts the ARRIVING
contribution |signed_amp| (the front), not the cumulative interference field.
Once a tier absorbs the front (g→0) no deeper tier is reached, even though the
bundled field retains the earlier seed — the old field-based count overstated
reach (synthetic 1,0,0,0 reported depth 4). Front reach is gain-driven and
phase-independent (|±x|=x); phase governs the field interference, reported in the
MetaHop.field column. Test reframed (phase_governs_the_field_not_the_front_depth)
+ PAPER §4.7 corrected to the true ES number (front penetration 3/4, field peak
|Σ|=1.95) EN+DE; meta_hops label fixed.

68 lib tests; clippy -D warnings clean; scorecard/explore numbers unchanged
(connected components).

Author: claude

crates/perturbation-sim/PAPER.md

@@ -333,14 +333,18 @@ tier-to-tier λ₂ change, monotonically rising ⇒ all-`+`):
 | TWIG | 5.65e-6 | 0.392 | + | 3.0 | +0.344 | +1.822 | 0.44 | 1.68 |
 | LEAF | 8.88e-6 | 0.032 | + | 2.0 | +0.130 | +1.951 | 0.36 | 2.04 |
 
-All-aligned phase ⇒ penetration depth 4/4; the coarse→fine inertia ramp puts the
-fast seconds in the leaf tiers (dt 0.68 → 0.36 s), and the cumulative ~2 s lands
-in the **electromechanical / low-inertia** regime — the same mechanism class as
-the 27 s event (the absolute scale depends on `ΔP`, relay band, and the true
-`H`-ramp; this run uses illustrative values). The lesson the model encodes: a
-deep four-tier cascade needs **phase alignment AND low leaf-inertia** — break
-either (a phase flip at one tier, or more synchronous inertia at the leaves) and
-the front self-arrests or slows below the protection window.
+The **front penetration is 3/4** (arriving `|signed_amp|` 1.0 → 0.48 → 0.34 ≥ 0.25,
+then 0.13 at the leaf where the gain `g→0` absorbs it). Front reach is **gain-driven
+and phase-independent** (`|±x|=x`); what the all-aligned phase buys is a *growing
+interference field* (peak `|Σ|=1.95`) — alternating phases would cancel it. The
+coarse→fine inertia ramp puts the fast seconds in the leaf tiers (dt 0.68 → 0.36 s),
+and the cumulative ~2 s lands in the **electromechanical / low-inertia** regime — the
+same mechanism class as the 27 s event (the absolute scale depends on `ΔP`, relay
+band, and the true `H`-ramp; this run uses illustrative values). The lesson the model
+encodes: a deep cascade needs **passing gains (weak field × strong infight) AND low
+leaf-inertia** — break either (more connectivity at a tier, or more synchronous
+inertia at the leaves) and the front self-arrests or slows below the protection
+window; phase separately decides whether the bundled field reinforces or cancels.
 
 *Honest status: CONJECTURE [H]. The gain law is `meta_cascade`; the phase+inertia
 refinement is `meta_cascade_phase`. The structural phase (sign of Δλ₂) and the
@@ -357,11 +361,16 @@ Summe): **Betrag** über die Durchlass-Verstärkung `gᵢ = Infightᵢ·(1−Rau
 **Bündelung (laufende Summe) vorzeichenbehafteter Beiträge** — gleichgerichtete
 Phasen verstärken (tiefe Kaskade), alternierende löschen aus (Selbst-Arrest in
 den oberen Ebenen). **Trägheit** stellt die Uhr `dtᵢ` (Schwinggleichung,
-`H`-Rampe grob→fein). Am realen ES-Kern: alle Phasen `+` ⇒ Eindringtiefe 4/4,
-die schnellen Sekunden in den Blatt-Ebenen (dt 0,68 → 0,36 s), kumulativ ~2 s im
-**elektromechanischen** Regime — dieselbe Mechanismus-Klasse wie die 27 s. Lehre:
-eine tiefe Kaskade braucht **Phasen-Ausrichtung UND niedrige Blatt-Trägheit** —
-bricht eines von beiden, arretiert die Front. Status: Vermutung [H]; Phase (Δλ₂)
+`H`-Rampe grob→fein). Am realen ES-Kern: **Front-Eindringtiefe 3/4** (ankommendes
+`|signed_amp|` 1,0 → 0,48 → 0,34 ≥ 0,25, dann 0,13 am Blatt, wo `g→0` absorbiert).
+Die Front-Reichweite ist **verstärkungs-getrieben und phasen-unabhängig** (`|±x|=x`);
+die gleichgerichtete Phase erzeugt ein *wachsendes Interferenzfeld* (Spitze
+`|Σ|=1,95`), alternierende Phasen würden es auslöschen. Schnelle Sekunden in den
+Blatt-Ebenen (dt 0,68 → 0,36 s), kumulativ ~2 s im **elektromechanischen** Regime —
+dieselbe Mechanismus-Klasse wie die 27 s. Lehre: eine tiefe Kaskade braucht
+**durchlassende Verstärkungen UND niedrige Blatt-Trägheit** — bricht eines von
+beiden, arretiert die Front; die Phase entscheidet separat über Feld-Verstärkung
+oder -Auslöschung. Status: Vermutung [H]; Phase (Δλ₂)
 und Trägheits-Rampe sind Platzhalter, Kalibrierung gegen beobachtete Kaskade ist
 die [H]→[G]-Probe.
 

crates/perturbation-sim/examples/meta_hops.rs

@@ -232,8 +232,10 @@ fn main() {
         );
     }
     let total = trace.last().map(|h| h.t).unwrap_or(0.0);
+    let field_peak = trace.iter().map(|h| h.field.abs()).fold(0.0, f64::max);
     println!(
-        "\n  penetration depth (|field| ≥ 0.25): {depth} tiers\n  \
+        "\n  front penetration (arriving |signed_amp| ≥ 0.25): {depth} tiers\n  \
+         interference field peak |Σ|: {field_peak:.3}  (phase-governed: grows if aligned)\n  \
          cumulative wall-clock: {total:.1} s  →  {}",
         mechanism_from_timescale(total)
     );

crates/perturbation-sim/src/resilience.rs

@@ -41,6 +41,16 @@ pub fn kirchhoff_index(eigenvalues: &[f64], tol: f64) -> f64 {
     if n == 0 {
         return 0.0;
     }
+    // A connected graph has EXACTLY one zero mode ⇒ n−1 finite eigenvalues. If
+    // there are fewer (≥2 zero modes), the graph is disconnected and the
+    // cross-component effective resistance is infinite — so Kf must be ∞, not the
+    // finite sum over the live components. Returning the finite sum here would
+    // rank an already-fragmented compartment as RESILIENT (low Kf), the opposite
+    // of the truth. (Codex #509 P1.)
+    let finite = eigenvalues.iter().filter(|&&l| l > tol).count();
+    if finite < n - 1 {
+        return f64::INFINITY;
+    }
     let inv_sum: f64 = eigenvalues
         .iter()
         .filter(|&&l| l > tol)
@@ -116,6 +126,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn disconnected_graph_has_infinite_kirchhoff() {
+        // Two disjoint edges (0–1, 2–3): 2 components ⇒ 2 zero modes ⇒ Kf = ∞,
+        // NOT the finite sum over each live component. A disconnected compartment
+        // must rank as the LEAST resilient, not the most. (Codex #509 P1.)
+        let g = Grid::new(
+            4,
+            vec![Edge::new(0, 1, 1.0, 1.0), Edge::new(2, 3, 1.0, 1.0)],
+        );
+        let eig = symmetric_eigen(&g.laplacian_of(&vec![true; g.edges.len()]), g.n);
+        let cert = Resilience::from_eigenvalues(&eig.values, 1e-9);
+        assert!(cert.kirchhoff.is_infinite(), "disconnected ⇒ Kf = ∞");
+        assert!(cert.mean_resistance().is_infinite(), "and mean R = ∞");
+        // λ₂ ≈ 0 for the disconnected graph (the second zero mode).
+        assert!(cert.lambda2 < 1e-9, "disconnected ⇒ λ₂ ≈ 0");
+        // The single-edge connected case is finite (n−1 = 1 finite mode): Kf(P₂)=2.
+        let p2 = Grid::new(2, vec![Edge::new(0, 1, 1.0, 1.0)]);
+        let e2 = symmetric_eigen(&p2.laplacian_of(&[true]), 2);
+        assert!(
+            kirchhoff_index(&e2.values, 1e-9).is_finite(),
+            "connected ⇒ finite"
+        );
+    }
+
     #[test]
     fn adding_an_edge_lowers_kirchhoff_and_raises_lambda2() {
         // Path 0–1–2–3 vs the same with a chord 0–3 (more connected = more resilient).

crates/perturbation-sim/src/timing.rs

@@ -181,10 +181,15 @@ pub struct MetaHop {
 /// tell falls out of low inertia (short `dt`) over a few deep hops.
 ///
 /// Returns `(per-tier MetaHop trace, penetration_depth)` where
-/// `penetration_depth` = the number of tiers whose interference field magnitude
-/// stays `≥ threshold` (how deep the phase-aware perturbation actually reaches).
-/// CONJECTURE [H]: a modeling refinement of `meta_cascade`; needs a probe
-/// against an observed multi-tier cascade before promotion to FINDING.
+/// `penetration_depth` = the number of tiers the **arriving** contribution
+/// `|signed_ampᵢ|` stays `≥ threshold` — the front reach. It is **gain-driven and
+/// hence phase-independent** (`|±x| = x`): phase governs the `field` interference
+/// (constructive grows, alternating cancels — read it off the `MetaHop.field`
+/// column), magnitude/gain governs how deep the front propagates. Counting depth
+/// from the cumulative `field` would overstate the reach once a tier absorbs the
+/// front (Codex #509 P2). CONJECTURE [H]: a modeling refinement of `meta_cascade`
+/// (it adds the clock + the interference field); needs a probe against an observed
+/// multi-tier cascade before promotion to FINDING.
 #[allow(clippy::too_many_arguments)]
 pub fn meta_cascade_phase(
     raumgewinn: &[f64],
@@ -233,7 +238,13 @@ pub fn meta_cascade_phase(
             dt,
             t,
         });
-        if field.abs() >= threshold {
+        // Penetration depth follows the ARRIVING contribution `|signed_amp|` (the
+        // front), NOT the cumulative `field`. Once a tier absorbs (g→0) the front
+        // dies and no deeper tier is reached, even though the bundled `field`
+        // retains the earlier seed — counting from `field` would overstate the
+        // reach (Codex #509 P2). The front magnitude is phase-independent (|±x|=x),
+        // so phase governs the `field` interference, not the depth.
+        if signed_amp.abs() >= threshold {
             depth += 1;
         }
 
@@ -315,40 +326,42 @@ mod tests {
     }
 
     #[test]
-    fn phase_alignment_decides_penetration_depth() {
-        // Same magnitudes (gains [1,1,1,0]); only the phase pattern differs.
-        // Aligned phases bundle constructively (field grows 1→2→3→4); alternating
-        // phases cancel (field 1→2→1→0).
+    fn phase_governs_the_field_not_the_front_depth() {
+        // Same magnitudes (gains [1,1,1,0]); only the phase pattern differs. The
+        // arriving front |signed_amp| is identical (phase = ±1 ⇒ |·| unchanged), so
+        // penetration depth is EQUAL — phase does NOT change the front reach. What
+        // phase DOES change is the bundled `field`: aligned phases reinforce
+        // (1→2→3→4), alternating phases cancel (1→2→1→0). (Post Codex #509 P2.)
         let h = [3.0, 3.0, 3.0, 3.0];
-        let (con, deep) = meta_cascade_phase(
+        let (con, depth_con) = meta_cascade_phase(
             &PASS_RAUM,
             &PASS_FIGHT,
             &[1, 1, 1, 1],
             &h,
             0.1,
             0.2,
             0.2,
-            1.5,
+            0.5,
         );
-        let (alt, shallow) = meta_cascade_phase(
+        let (alt, depth_alt) = meta_cascade_phase(
             &PASS_RAUM,
             &PASS_FIGHT,
             &[1, -1, 1, -1],
             &h,
             0.1,
             0.2,
             0.2,
-            1.5,
+            0.5,
         );
-        assert!(
-            deep > shallow,
-            "constructive phase reaches deeper: {deep} > {shallow}"
+        assert_eq!(
+            depth_con, depth_alt,
+            "front reach is phase-independent: {depth_con} == {depth_alt}"
         );
         let con_max = con.iter().map(|hp| hp.field.abs()).fold(0.0, f64::max);
         let alt_max = alt.iter().map(|hp| hp.field.abs()).fold(0.0, f64::max);
         assert!(
             alt_max < con_max,
-            "alternating phase self-arrests: peak field {alt_max} < {con_max}"
+            "alternating phase self-arrests the FIELD: peak {alt_max} < {con_max}"
         );
     }