Use the canonical L_rw/L_sym relaxation spectrum in the conservation/Lyapunov spectral analysis

The structural-conservation theorem characterised the diffusive relaxation rate via the combinatorial Laplacian L = D - A (lyapunov.analyze_spectral_gap, conservation.compute_spectral_conservation, theorem section 8.5), but the canonical TNFR diffusion operator is the random-walk Laplacian L_rw = I - D^-1 W (structural_diffusion; dEPI/dt = -nu_f L_rw EPI). These differ on irregular graphs and by the degree factor 1/d on regular graphs; section 9.1 of the same theorem already defines the divergence as (1/d_i)(L J) = L_rw J, an internal contradiction.

Additive fix (keeps the correctly-named combinatorial algebraic connectivity, which test_complete_graph encodes as K_n: lambda_1 = n): analyze_spectral_gap adds diffusion_gap = lambda_2 of the symmetric normalized Laplacian L_sym = I - D^-1/2 W D^-1/2 (same spectrum as L_rw), while spectral_gap/fiedler_value remain the combinatorial Fiedler value; analyze_operator_convergence bounds the stabiliser convergence rate with diffusion_gap; compute_spectral_conservation decomposes in the L_sym eigenbasis; theorem 8.5 + 9.1 now state L_rw/L_sym as the canonical relaxation operator, resolving the 8.5<->9.1 contradiction; test_effective_rate asserts against diffusion_gap.

Validated: lyapunov 94/94, core_physics 220/220, riemann_topology 88/88; flake8 only pre-existing E302/E305.

Author: TNFR AI Agent

src/tnfr/physics/conservation.py

@@ -1067,7 +1067,9 @@ class SpectralConservation:
     r"""Spectral decomposition of the conservation fields.
 
     Expands charge density ρ and current divergence in the eigenbasis of the
-    graph Laplacian L: ρ(i) = Σ_k ρ̂_k ψ_k(i).
+    symmetric normalized Laplacian L_sym = I − D^{-1/2} W D^{-1/2}, whose
+    spectrum is that of the canonical TNFR diffusion operator L_rw = I − D⁻¹W
+    (the EPI channel of the nodal equation): ρ(i) = Σ_k ρ̂_k ψ_k(i).
 
     The continuity equation mode-by-mode reads:
         dρ̂_k/dt + λ_k Ĵ_k = Ŝ_k
@@ -1078,7 +1080,8 @@ class SpectralConservation:
     Attributes
     ----------
     eigenvalues : np.ndarray
-        Laplacian eigenvalues λ_k (sorted ascending).
+        L_sym eigenvalues λ_k (sorted ascending) — the canonical L_rw
+        relaxation spectrum.
     rho_spectrum : np.ndarray
         Charge density coefficients ρ̂_k in the eigenbasis.
     div_spectrum : np.ndarray
@@ -1102,9 +1105,9 @@ def compute_spectral_conservation(
     G: Any,
     snapshot: ConservationSnapshot | None = None,
 ) -> SpectralConservation:
-    r"""Decompose conservation fields in the graph Laplacian eigenbasis.
+    r"""Decompose conservation fields in the normalized Laplacian eigenbasis.
 
-    Connects TNFR conservation to spectral graph theory.  The Laplacian
+    Connects TNFR conservation to spectral graph theory.  The L_sym
     eigenvalues determine at which structural scales conservation holds
     most precisely:
 
@@ -1131,21 +1134,29 @@ def compute_spectral_conservation(
     nodes = sorted(snapshot.charge_density.keys())
     n = len(nodes)
 
-    # Build graph Laplacian
+    # Build the symmetric normalized Laplacian L_sym = I − D^{-1/2} W D^{-1/2},
+    # whose spectrum is that of the canonical TNFR diffusion operator
+    # L_rw = I − D⁻¹W (the EPI channel; see ``structural_diffusion``).  This is
+    # consistent with the §9.1 normalized divergence (∇·J = L_rw·J).
     if nx is not None and isinstance(G, nx.Graph):
-        L = nx.laplacian_matrix(G).toarray().astype(float)
+        L = nx.normalized_laplacian_matrix(G).toarray().astype(float)
     else:
-        # Fallback: build from adjacency
-        L = np.zeros((n, n))
+        # Fallback: build the combinatorial Laplacian then symmetric-normalize
+        Lc = np.zeros((n, n))
         node_idx = {nd: i for i, nd in enumerate(nodes)}
         for u, v in G.edges():
             i, j = node_idx[u], node_idx[v]
-            L[i, j] = -1.0
-            L[j, i] = -1.0
-            L[i, i] += 1.0
-            L[j, j] += 1.0
-
-    # Eigendecomposition
+            Lc[i, j] -= 1.0
+            Lc[j, i] -= 1.0
+            Lc[i, i] += 1.0
+            Lc[j, j] += 1.0
+        deg = Lc.diagonal().astype(float)
+        with np.errstate(divide="ignore"):
+            d_inv_sqrt = np.where(deg > 0.0, 1.0 / np.sqrt(deg), 0.0)
+        adjacency = np.diag(deg) - Lc
+        L = np.eye(n) - d_inv_sqrt[:, None] * adjacency * d_inv_sqrt[None, :]
+
+    # Eigendecomposition (orthonormal eigenbasis of L_sym)
     eigvals, eigvecs = np.linalg.eigh(L)
 
     # Project charge density and divergence into eigenbasis

src/tnfr/physics/lyapunov.py

@@ -40,15 +40,19 @@
 
 Spectral Gap Characterisation
 -----------------------------
-The algebraic connectivity λ₁ of the graph Laplacian controls the
-*relaxation time* τ = 1/λ₁ for diffusive modes.  This module provides
-``analyze_spectral_gap`` which computes:
+``analyze_spectral_gap`` reports two distinct, both-meaningful quantities:
 
-- λ₁ (algebraic connectivity)
-- Relaxation time τ_relax = 1/λ₁
-- Mixing time estimate t_mix ~ ln(N)/λ₁
-- Cheeger-type lower bound h²/(2d_max) ≤ λ₁
-- Convergence rate for stabiliser-dominated sequences
+- the **combinatorial algebraic connectivity** λ₁ (Fiedler value) of
+  L = D − A — a graph-topology measure; and
+- the **canonical diffusion relaxation gap** λ₂ of the symmetric normalized
+  Laplacian L_sym = I − D^{-1/2} W D^{-1/2}, which shares the spectrum of the
+  canonical TNFR diffusion operator L_rw = I − D⁻¹W (``structural_diffusion``).
+
+The *diffusive* relaxation time-scale is set by the **diffusion gap**: the EPI
+field relaxes as exp(−ν_f·λ₂·t).  The two gaps coincide only up to the degree
+normalisation (λ₁/d on a d-regular graph) and differ on irregular graphs.
+Derived: relaxation time, mixing-time estimate, Cheeger-type bound, and the
+stabiliser convergence rate (which uses the canonical diffusion gap).
 
 References
 ----------
@@ -540,9 +544,18 @@ class SpectralGapAnalysis:
     Attributes
     ----------
     spectral_gap : float
-        λ₁ — algebraic connectivity of the graph Laplacian.
+        λ₁ — combinatorial algebraic connectivity (Fiedler value): the
+        second-smallest eigenvalue of L = D − A.  A graph-topology measure.
     fiedler_value : float
         Same as spectral_gap (alternative name from spectral graph theory).
+    diffusion_gap : float
+        λ₂ of the symmetric normalized Laplacian L_sym = I − D^{-1/2} W D^{-1/2},
+        which shares the spectrum of the canonical TNFR diffusion operator
+        L_rw = I − D⁻¹W.  This is the **canonical structural relaxation rate**
+        (per unit ν_f): the EPI field relaxes as exp(−ν_f·λ₂·t).  Use this — not
+        the combinatorial ``spectral_gap`` — for the diffusive relaxation
+        time-scale.  Equals ``spectral_gap``/d on a d-regular graph; differs on
+        irregular graphs.
     relaxation_time : float
         τ_relax = 1/λ₁ — time for the slowest non-trivial mode to decay
         by factor e.  ``inf`` if graph is disconnected (λ₁ = 0).
@@ -568,6 +581,7 @@ class SpectralGapAnalysis:
 
     spectral_gap: float
     fiedler_value: float
+    diffusion_gap: float
     relaxation_time: float
     convergence_rate: float
     mixing_time_bound: float
@@ -605,6 +619,7 @@ def analyze_spectral_gap(G: Any) -> SpectralGapAnalysis:
         return SpectralGapAnalysis(
             spectral_gap=0.0,
             fiedler_value=0.0,
+            diffusion_gap=0.0,
             relaxation_time=float("inf"),
             convergence_rate=0.0,
             mixing_time_bound=float("inf"),
@@ -633,12 +648,26 @@ def analyze_spectral_gap(G: Any) -> SpectralGapAnalysis:
     eigvals = np.linalg.eigvalsh(L)
     eigvals = np.sort(eigvals)
 
-    # λ₁ = second-smallest eigenvalue
+    # λ₁ = second-smallest eigenvalue (combinatorial algebraic connectivity)
     lambda_1 = float(eigvals[1]) if n > 1 else 0.0
     lambda_1 = max(0.0, lambda_1)  # numerical safety
 
     lambda_max = float(eigvals[-1])
 
+    # Canonical structural relaxation rate: λ₂ of the symmetric normalized
+    # Laplacian L_sym = I − D^{-1/2} W D^{-1/2}, which shares the spectrum of the
+    # canonical TNFR diffusion operator L_rw = I − D⁻¹W (structural_diffusion).
+    if nx is not None and isinstance(G, nx.Graph):
+        L_sym = nx.normalized_laplacian_matrix(G).toarray().astype(float)
+    else:
+        deg = L.diagonal().astype(float)
+        with np.errstate(divide="ignore"):
+            d_inv_sqrt = np.where(deg > 0.0, 1.0 / np.sqrt(deg), 0.0)
+        adjacency = np.diag(deg) - L  # A = D − L recovers the weight matrix
+        L_sym = np.eye(n) - d_inv_sqrt[:, None] * adjacency * d_inv_sqrt[None, :]
+    sym_eigs = np.sort(np.linalg.eigvalsh(L_sym))
+    diffusion_gap = max(0.0, float(sym_eigs[1])) if n > 1 else 0.0
+
     is_connected = lambda_1 > 1e-10
     tau = 1.0 / lambda_1 if is_connected else float("inf")
     mixing = math.log(n) / lambda_1 if is_connected else float("inf")
@@ -652,6 +681,7 @@ def analyze_spectral_gap(G: Any) -> SpectralGapAnalysis:
     return SpectralGapAnalysis(
         spectral_gap=lambda_1,
         fiedler_value=lambda_1,
+        diffusion_gap=diffusion_gap,
         relaxation_time=tau,
         convergence_rate=lambda_1,
         mixing_time_bound=mixing,
@@ -698,7 +728,9 @@ def analyze_operator_convergence(
     r"""Combine per-operator Lyapunov bound with spectral gap analysis.
 
     For stabilisers, the effective convergence rate is the tighter of
-    the operator's contraction rate ρ and the graph's spectral gap λ₁.
+    the operator's contraction rate ρ and the graph's canonical diffusion
+    relaxation gap λ₂(L_sym) (``diffusion_gap``, the structural_diffusion
+    relaxation rate — not the combinatorial algebraic connectivity).
     The number of steps to halve energy is ln(2)/rate.
 
     Parameters
@@ -716,7 +748,10 @@ def analyze_operator_convergence(
     spectral = analyze_spectral_gap(G)
 
     if bound.energy_class == EnergyClass.STABILISER:
-        rate = min(bound.contraction_rate, spectral.spectral_gap)
+        # The diffusive relaxation bound is the CANONICAL diffusion gap
+        # λ₂(L_sym) (= the structural_diffusion relaxation rate), not the
+        # combinatorial algebraic connectivity.
+        rate = min(bound.contraction_rate, spectral.diffusion_gap)
         steps = math.log(2) / rate if rate > 1e-15 else float("inf")
     else:
         rate = 0.0

tests/core_physics/test_lyapunov_operators.py

@@ -480,7 +480,7 @@ def test_effective_rate_is_min_of_rho_and_lambda(self, ws_graph):
         summary = analyze_operator_convergence(ws_graph, "IL")
         bound = get_bound("IL")
         spectral = analyze_spectral_gap(ws_graph)
-        expected = min(bound.contraction_rate, spectral.spectral_gap)
+        expected = min(bound.contraction_rate, spectral.diffusion_gap)
         assert abs(summary.effective_convergence_rate - expected) < 1e-12
 
     def test_steps_to_half_uses_ln2(self, ws_graph):

theory/STRUCTURAL_CONSERVATION_THEOREM.md

@@ -599,9 +599,17 @@ $(1 + 6.857) \times (1 - 0.457)^4 = 7.857 \times 0.087 \approx 0.68 < 1$ ✓
 
 ### 8.5 Spectral Gap Characterisation
 
-The **algebraic connectivity** $\lambda_1$ (smallest non-zero eigenvalue of
-the graph Laplacian $L = D - A$) controls the diffusive relaxation time-scale
-and provides a topology-dependent convergence rate.
+The **diffusive relaxation time-scale** is controlled by the canonical TNFR
+diffusion operator $L_{\mathrm{rw}} = I - D^{-1}W$ (the EPI channel of the nodal
+equation; see `structural_diffusion`): the field relaxes as
+$e^{-\nu_f \lambda_2 t}$, where $\lambda_2$ is the spectral gap of the symmetric
+normalized Laplacian $L_{\mathrm{sym}} = I - D^{-1/2} W D^{-1/2}$ (same spectrum as
+$L_{\mathrm{rw}}$, orthonormal eigenbasis).  The **combinatorial algebraic
+connectivity** $\lambda_1$ of $L = D - A$ is the related graph-topology measure;
+the two coincide only up to the degree normalisation ($\lambda_1/d$ on a
+$d$-regular graph) and differ on irregular graphs.  The convergence rate below
+uses the **normalized** (canonical) gap; `analyze_spectral_gap` exposes it as
+`diffusion_gap`.
 
 **Spectral Quantities**
 
@@ -639,10 +647,14 @@ bounds, spectral gap analysis, and sequence contractiveness proofs.
 
 ### 9.1 Graph Laplacian Connection
 
-The discrete divergence used in TNFR conservation relates to the
-**graph Laplacian** $L = D - A$:
+The discrete divergence used in TNFR conservation is the **random-walk graph
+Laplacian** $L_{\mathrm{rw}} = I - D^{-1}W$ — the $1/d_i$ normalisation turns the
+combinatorial Laplacian $L = D - A$ into $L_{\mathrm{rw}}$:
 
-$$(\nabla \cdot \mathbf{J})(i) \approx \frac{1}{d_i} \sum_{j \sim i} [J(j) - J(i)] = \frac{1}{d_i} (L \cdot \mathbf{J})_i$$
+$$(\nabla \cdot \mathbf{J})(i) \approx \frac{1}{d_i} \sum_{j \sim i} [J(j) - J(i)] = \frac{1}{d_i} (L \cdot \mathbf{J})_i = (L_{\mathrm{rw}} \mathbf{J})_i$$
+
+so the relaxation spectrum governing conservation is that of $L_{\mathrm{rw}}$
+(equivalently the symmetric $L_{\mathrm{sym}}$), consistent with §8.5.
 
 This connects conservation on graphs to spectral graph theory.