feat(riemann): P40 - chi-twisted node-aware gauge sweep

Structural extension of P20 (node-aware gauge sweep) to primitive real Dirichlet L-functions. Sweeps alpha_chi(sigma; f, g) = W_chi[sigma; f] / E_TNFR^chi[sigma; f, g] across DEFAULT_TEST_FAMILIES (P19, 3 admissible Schwartz-even families) crossed with DEFAULT_NODEAWARE_GAUGES (P20, 4 node-aware gauges activating per-node normalised nu_f and log p channels). W_chi computed once per (family, sigma) via P35 enumerator; canonical TNFR test state built via build_twisted_test_state_nodeaware on P34 chi-twisted bundle.

Empirical verification: 3/3 PASS for chi_3, chi_4, chi_5 across 3 families x 4 node-aware gauges x 5 widths (180 cells per character). alpha_min at (sigma=1.0, gaussian, nuf_phase) for chi_3 (+1.25e-14) and chi_4 (+2.69e-08); at (sigma=1.0, gaussian, nuf_pressure) for chi_5 (+2.60e-10).

Honest scope: does NOT prove GRH for any L(s, chi) and does NOT advance G4 = RH. Closes node-aware canonical-mapping robustness gap on the L-function track, achieving structural parity with the zeta-track through P20.

Files: src/tnfr/riemann/twisted_nodeaware_gauge_sweep.py (~330 lines), src/tnfr/riemann/__init__.py (docstring + import + __all__), examples/67_twisted_nodeaware_gauge_sweep_demo.py (~220 lines), theory/TNFR_RIEMANN_RESEARCH_NOTES.md (section 13noniesdecies + section 19.1 P40 row).

Author: TNFR AI Agent

examples/67_twisted_nodeaware_gauge_sweep_demo.py

@@ -0,0 +1,219 @@
+"""Demo 67: P40 chi-twisted node-aware gauge sweep for primitive real
+Dirichlet L-functions.
+
+Structural analogue of Demo 49 (P20 node-aware gauge sweep for zeta)
+extended to L(s, chi) via the P34 chi-twisted prime-ladder
+Hamiltonian, the P35 chi-twisted Weil-Guinand zero-side enumerator,
+and the P37 chi-twisted Weil-TNFR positivity bridge.
+
+Whereas Demo 66 (P39) audited the canonical scalar-h gauges
+DEFAULT_GAUGES (P18), Demo 67 (P40) sweeps the **node-aware** gauges
+DEFAULT_NODEAWARE_GAUGES (P20) -- gauges of the form
+``(d, phi, eps) = g(h(E_n), hat nu_f(n), hat w(n))`` --
+across the same three admissible Schwartz-even test families
+(gaussian, gaussian_mixture, hermite2_gaussian, inherited from P19).
+
+The demo executes:
+
+1. **Detailed (family, node_gauge) chart for chi_3 at sigma=2.0**.
+
+2. **Aggregate sweep across chi_3, chi_4, chi_5** -- reports
+   aggregate positivity flags and the [alpha_min, alpha_max] range
+   for each character together with the (sigma, family, node_gauge)
+   coordinates of the minimum.
+
+3. **Certificate summaries and honest scope**.
+
+Honest scope
+------------
+This demo numerically probes alpha_chi(sigma; f, g) > 0 across three
+admissible Schwartz-even test families, four canonical node-aware
+gauges, and a finite Gaussian-width grid for three primitive real
+characters.  Positive results strengthen the P37 / P38 / P39
+numerical evidence under joint test-profile + node-aware mapping
+ambiguity but **do not prove** GRH for any L(s, chi).  This demo
+also does NOT advance G4 = RH or the arithmetic obstruction of GRH.
+"""
+
+from __future__ import annotations
+
+import sys
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
+except AttributeError:
+    pass
+
+from tnfr.riemann import (
+    build_twisted_prime_ladder_hamiltonian,
+    real_character_mod_3,
+    real_character_mod_4,
+    real_character_mod_5,
+    sweep_twisted_nodeaware_gauge,
+)
+
+# --------------------------------------------------------------------
+# Configuration
+# --------------------------------------------------------------------
+
+SIGMAS = (1.0, 1.5, 2.0, 2.5, 3.0)
+
+N_PRIMES = 25
+MAX_POWER = 6
+COUPLING = 0.0
+
+CHARACTERS = (
+    ("chi_3", real_character_mod_3),
+    ("chi_4", real_character_mod_4),
+    ("chi_5", real_character_mod_5),
+)
+
+
+def banner(title: str, char: str = "=") -> None:
+    print(char * 72)
+    print(title)
+    print(char * 72)
+
+
+def fmt_signed(x: float, width: int = 12, prec: int = 4) -> str:
+    if x != x:  # NaN
+        return f"{'nan':>{width}}"
+    if x == float("inf"):
+        return f"{'+inf':>{width}}"
+    if x == float("-inf"):
+        return f"{'-inf':>{width}}"
+    return f"{x:+{width}.{prec}e}"
+
+
+# --------------------------------------------------------------------
+# Block 1: detailed chart for chi_3
+# --------------------------------------------------------------------
+
+
+def block_detailed_chi3() -> None:
+    banner(
+        "BLOCK 1: detailed (family, node_gauge) chart for chi_3 "
+        "across sigma grid"
+    )
+    chi = real_character_mod_3()
+    bundle = build_twisted_prime_ladder_hamiltonian(
+        chi,
+        n_primes=N_PRIMES,
+        max_power=MAX_POWER,
+        coupling=COUPLING,
+    )
+    cert = sweep_twisted_nodeaware_gauge(chi, bundle, SIGMAS)
+
+    print(f"  character   : {cert.character_name} "
+          f"(q={cert.character_modulus})")
+    print(f"  n_sigma     : {len(cert.sigmas)}")
+    print(f"  families    : {cert.families}")
+    print(f"  node_gauges : {cert.node_gauges}")
+    print()
+
+    print("  W_chi[sigma; family] (gauge-independent):")
+    header = "    " + f"{'family':<22}" + " ".join(
+        f"sigma={s:>5.2f}" for s in cert.sigmas
+    )
+    print(header)
+    for i, fname in enumerate(cert.families):
+        row = "    " + f"{fname:<22}" + " ".join(
+            fmt_signed(float(cert.weil_table[i, j]), width=11, prec=3)
+            for j in range(len(cert.sigmas))
+        )
+        print(row)
+    print()
+
+    j_target = len(cert.sigmas) // 2
+    sigma_target = float(cert.sigmas[j_target])
+    print(f"  alpha_chi(sigma={sigma_target:.3f}; family, node_gauge):")
+    header = "    " + f"{'family\\node_gauge':<22}" + " ".join(
+        f"{gn[:13]:>14}" for gn in cert.node_gauges
+    )
+    print(header)
+    for i, fname in enumerate(cert.families):
+        row = "    " + f"{fname:<22}" + " ".join(
+            fmt_signed(float(cert.alpha_table[i, k, j_target]),
+                       width=14, prec=4)
+            for k in range(len(cert.node_gauges))
+        )
+        print(row)
+    print()
+
+
+# --------------------------------------------------------------------
+# Block 2: aggregate sweep
+# --------------------------------------------------------------------
+
+
+def block_aggregate_sweep() -> list:
+    banner("BLOCK 2: aggregate sweep across chi_3, chi_4, chi_5")
+    certs = []
+    print(
+        f"  {'character':<12} {'q':>3}  {'W>=0':>6}  {'a>0':>6}  "
+        f"{'alpha_min':>14}  {'@(sigma,fam,node_gauge)':<48}  "
+        f"{'alpha_max':>14}"
+    )
+    print("  " + "-" * 116)
+    for name, factory in CHARACTERS:
+        chi = factory()
+        bundle = build_twisted_prime_ladder_hamiltonian(
+            chi,
+            n_primes=N_PRIMES,
+            max_power=MAX_POWER,
+            coupling=COUPLING,
+        )
+        cert = sweep_twisted_nodeaware_gauge(chi, bundle, SIGMAS)
+        certs.append(cert)
+        loc = (
+            f"({cert.alpha_min_sigma:.3f}, "
+            f"{cert.alpha_min_family}, "
+            f"{cert.alpha_min_node_gauge})"
+        )
+        print(
+            f"  {cert.character_name:<12} "
+            f"{cert.character_modulus:>3}  "
+            f"{str(cert.weil_all_positive):>6}  "
+            f"{str(cert.alpha_all_positive):>6}  "
+            f"{fmt_signed(cert.alpha_min, width=14, prec=4)}  "
+            f"{loc:<48}  "
+            f"{fmt_signed(cert.alpha_max, width=14, prec=4)}"
+        )
+    print()
+    return certs
+
+
+# --------------------------------------------------------------------
+# Block 3: summaries + scope
+# --------------------------------------------------------------------
+
+
+def block_summaries(certs: list) -> None:
+    banner("BLOCK 3: certificate summaries")
+    for cert in certs:
+        print("  " + cert.summary())
+    print()
+    banner("HONEST SCOPE", char="-")
+    print(
+        "  P40 numerically verifies alpha_chi(sigma; f, g) > 0\n"
+        "  across a finite Gaussian-width grid, three admissible\n"
+        "  Schwartz-even test families (P19) and four canonical\n"
+        "  node-aware gauges DEFAULT_NODEAWARE_GAUGES (P20) for three\n"
+        "  primitive real Dirichlet characters (chi_3, chi_4, chi_5).\n"
+        "  Positive results strengthen the P37 / P38 / P39 numerical\n"
+        "  evidence under joint test-profile + node-aware mapping\n"
+        "  ambiguity but do NOT prove GRH for any L(s, chi) and do\n"
+        "  NOT advance G4 = RH.  Like P20 / P39, this is an\n"
+        "  RH-equivalent robustness audit on a finite grid, not a\n"
+        "  theorem on family-uniform positivity."
+    )
+
+
+def main() -> None:
+    block_detailed_chi3()
+    certs = block_aggregate_sweep()
+    block_summaries(certs)
+
+
+if __name__ == "__main__":
+    main()

src/tnfr/riemann/__init__.py

@@ -265,6 +265,21 @@
     Implemented for primitive real characters (chi_3, chi_4, chi_5).
     Diagnostic only; does NOT prove GRH for any L(s, chi) and does
     NOT advance G4 = RH.
+twisted_nodeaware_gauge_sweep
+    P40 chi-twisted node-aware gauge sweep of
+        alpha_chi(sigma; f, g) = W_chi[sigma; f] / E_TNFR_chi[sigma; f, g]
+    where g varies over the node-aware gauges DEFAULT_NODEAWARE_GAUGES
+    inherited unchanged from the zeta-track P20 (nuf_pressure,
+    nuf_phase, weight_pressure, mixed_affine). Each gauge depends on
+    the per-node normalised structural frequency hat nu_f(n) and
+    normalised node-weight hat w(n) = log p / max log p of the P34
+    chi-twisted prime-ladder graph. Structural analogue of P20 for
+    primitive real Dirichlet L-functions: probes robustness of the
+    P37 chi-twisted positivity bridge under node-aware canonical-
+    mapping ambiguity crossed with the admissible-family sweep (P19).
+    Implemented for primitive real characters (chi_3, chi_4, chi_5).
+    Diagnostic only; does NOT prove GRH for any L(s, chi) and does
+    NOT advance G4 = RH.
 oscillatory_correction
     P31 Branch B1 retry: prime-ladder oscillatory correction of the
     P28 / P30 smooth targets. Reconstructs S(T) = pi^{-1} arg zeta(1/2
@@ -766,6 +781,12 @@
     build_twisted_test_state_from_test_function,
     sweep_twisted_admissible_family,
 )
+from .twisted_nodeaware_gauge_sweep import (
+    # P40: chi-twisted node-aware gauge sweep (diagnostic)
+    TwistedNodeAwareGaugeSweepCertificate,
+    build_twisted_test_state_nodeaware,
+    sweep_twisted_nodeaware_gauge,
+)
 from .spectral_emergence import (
     # P29: Spectral universality emergence under canonical UM+RA coupling
     CANONICAL_COUPLING_LAWS,
@@ -1144,6 +1165,10 @@
     "TwistedAdmissibleFamilySweepCertificate",
     "build_twisted_test_state_from_test_function",
     "sweep_twisted_admissible_family",
+    # P40: chi-twisted node-aware gauge sweep (diagnostic)
+    "TwistedNodeAwareGaugeSweepCertificate",
+    "build_twisted_test_state_nodeaware",
+    "sweep_twisted_nodeaware_gauge",
     # P29: Spectral universality emergence under canonical UM+RA coupling
     "CANONICAL_COUPLING_LAWS",
     "InterPrimeCoupling",