#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""v963 -- PRIME.LSTAR.REDUCTION_DICTIONARY.01 (rounds 282/283/284/285 plus the rh/problem standalone document, ADJUDICATED at the finite-identity level plus the typed measurement legs): THE L* REDUCTION DICTIONARY -- the canonical reduction of the free-window question to ONE two-measure subordination scalar, its exact decomposition bookkeeping, the four-language elimination as named negative gates, and the honest measurement anatomy, frozen as ONE module.  THE E-RIPE THEOREM SET.  (A) THE r283 A2 CHAIN (each step a named gate, exact grade): (A1) MU-FRAME CONGRUENCE: with U the unit lower-triangular monic mu-OP change of basis, U H_k(mutilde) U^T = D_mu - G (D_mu = diag h^mu, G_ij = int pi_i pi_j dnu), leading minors PRESERVED, so minor_k(D_mu - G) == D_k(mutilde) EXACTLY at every k <= S_+ (rational-gated on all five frozen r283 toys; the one-nu-atom truncation mutant breaks the congruence LOUDLY); (A2) FRAME CONTRACTION: h_0..h_{m-1} > 0 <=> H_m(mutilde) succ 0 <=> all leading minors of D_mu - G positive <=> lambda_max(E_m) < 1 with E the nu-dressed mu-CD kernel (exact-rational Sylvester side gated in BOTH truth values, float eigen cross-check per degree); (A3) CROSSING DICTIONARY: monotone rank-one loading makes lambda_max cross 1 EXACTLY at minC + 1 -- gated exactly on the crossing toys (JF9 4, FLIPLIKE 3, BIG1 1 == minC+1) with MAINLIKE and EPS1 typed CAPACITY_CEILING (minC == S_+, no crossing inside the mu-frame); (A4) PIGEONHOLE CEILING: minC <= S_+ re-proved in the frame by the null-polynomial witness p = prod_{mu atoms}(x - y): int p^2 dmutilde = -int p^2 dnu < 0 exact on all five toys; (A5) CAPACITY-AS-COUNTING REFUTED: the sealed rank-one pair EPS1/BIG1 (JF9 nodes, weights 1..1 with one negative atom 1e-12 vs 1000) has the SAME rank (rank G_n == min(n, S_-) == 1), the SAME support pattern and OPPOSITE window fate (EPS1 minC = 8 > N_w = 5, BIG1 dies at 0) -- the deciding quantity is METRIC (G_11/h^mu_0 = 1.25e-13 vs 1.25e+2): no counting argument can prove L*.  L* IS THE CANONICAL REDUCTION: given A1-A3, the ENTIRE free-window question is the ONE scalar inequality L* -- for every real polynomial p with deg p < N_w: int p^2 dnu < int p^2 dmu, equivalently lambda_max(E_{N_w}) < 1 (registered as the standalone contract PRIME.LSTAR.SUBORDINATION.01 [O]; standalone document rh/problem/lstar_problem.tex).  (B) THE r285 DECOMPOSITION BOOKKEEPING (exact): (B1) THE CHRISTOFFEL SANDWICH max_k v_k K_n(y_k) <= lambda_max(E_n) <= trace(E_n) with its exact-rational consequences gated at every degree (trace < 1 => window positive through n; maxdiag >= 1 => a crossing at or below n); (B2) THE MULTIPLICATIVE DECOMPOSITION lambda_max = maxdiag x (1 + assist) EXACTLY, with the BUDGET EQUIVALENCE (1/maxdiag - 1) - assist > 0 <=> lambda_max < 1 <=> all frame minors positive, sign-gated at every degree against the exact rational side.  (C) THE r282 FOUR-LANGUAGE ELIMINATION as named negative gates (each exact; the common deep reason: EVERY classical positivity language forces positivity EXACTLY for the positive measure class -- MAIN is signed): (C1) SOS_ONLY_POSITIVE_CLASS: the Pontryagin split h_n = P_n - N_n is exact at every degree, and the |m|^2/sum-of-squares structure exists IFF the negative register is empty (N_n == 0 for all n) -- true exactly on POSLIKE, false on every signed toy; the fake SOS (P_n alone) misses h_2(MAINLIKE) by EXACTLY N_2 = 48360721965/70120631072; the surviving clause N < P is h > 0 verbatim; (C2) KASTELEYN_IFF_POSITIVE: full 2^S gauge exhaustion on all four toys -- the coherent linear orientation class over the Cauchy-Binet configuration space is EXACTLY {+-sign w}, the quadratic/edge class collapses at the n = 3 cells on every signed toy (holds on POSLIKE), Cauchy-Binet re-proved exactly (sum_I Delta(x_I)^2 prod w_i == D_n(mutilde)), the oriented value is D_n(|w|) with defect at n = 1 EXACTLY 2 x negative mass (55/36, 44/35, 114/35, 0) and D_n(|w|) != +-D_n(w) at every checked degree on the signed toys -- AN ORIENTATION IS CONSTRUCTIBLE AND VALUE-PRESERVING IFF S_- = 0; (C3) HAMILTONIAN_PSD_IS_H (bookkeeping): the canonical-system Hamiltonian positivity through degree n <=> beta_1..beta_n > 0 <=> h_0..h_n > 0 -- exact equivalence in both truth values, no second gestalt; (C4) DUALPAIR_SYNC_BY_THEOREM: with dual weights w#_j = 1/(w_j L'(x_j)^2) the product law h_n x h#_{S-1-n} == 1 holds EXACTLY at every degree, so the dual-pair sign sync is IDENTICAL in every world through every flip -- the dual pair delivers no second condition per theorem (wrong dual 1/w breaks the law loudly, worst |h h# - 1| >= 1e2).  (D) TYPED NUMERICAL/MEASUREMENT LEGS (frozen record pins, ground truth sealed probe-side and re-verified by the embedded pattern gates + rh/verification/run_rh.py): the r284 ONE-ATOM-VS-COLLECTIVE DICHOTOMY (w9 n_CS = 10, n_DIAG = 187 only TWO degrees above the true crossing 185 = minC+1 -- MAIN rides the single-atom Christoffel edge to the last free degree while ALL FOUR controls die collectively far below their single-atom degree), the EXTREMAL ANATOMY (top eigenvector 99.7 percent on TWO shallow-u ARCH background atoms below the first prime, PR 1.89 vs control 4.97..9.72, SMALLP_DEPLETED, ONE_BAND), SHIELDING_BLIND (the near-perfect nu-mu pairing is a builder-channel property, all four sealed geometry stats world-blind) and the NYQUIST REFUTATION at the discriminant (n_pred = L/(4s) holds 42/42 on the ladder by trivial N_w scaling and FAILS on all four controls by 1.5-3 octaves); the r285 legs: (D) SEPARATES at window scale (controls' n_DIAG = 50..91 << 184 while MAIN holds 187 > 185 -- the clean split '(D) blind + (C) all the arithmetic' is REFUTED as stated), the SUB-CLASSICAL EDGE GROWTH p = 0.38 (vs bulk law 1; classical coverage 0/42, n*_bind = 58 vs n_DIAG = 187: any (D) proof must be a DISCRETE bound), the ensemble position (MAIN's wall assist is the EXTREME LOW outlier of both conservation-gated ensembles, pct 0.00 -- the near-single-atom wall is MAIN-specific) and THE FIRST TWO POSITIVELY MAIN-SEPARATING DETECTORS OF THE PROGRAM (K_D2 assist-at-crossing 0.0195 vs dead 1.69..2.99; K_C1 random-sign z at crossing -3.15 DESTRUCTIVE vs dead +4.95..+12.44 ALL CONSTRUCTIVE); and the DCXX MARGIN-DECAY FINDING (honest, r286 in flight and NOT consumed): all 42 ladder margins 1 - lambda_max(E_{N_w}) are strictly positive but the family minimum is 1.4175e-7 at anchor z = 233 (S = 1717, N_w = 859) while the flagship z = 16 carries the LARGEST margin 1.68e-4 -- the spectral L* margin falls ~3 orders of magnitude over the tested family (the r258 FLAT finding concerned the terminal ratio q_N, a different object); the unbounded-family version of L* is genuinely uncertain in both directions.  ONE module from four probes (30/30 + 26/26 + 30/30 + 33/33 first-pass gates, zero fails; discovery probes representation_contest_probe.py, fullsource_quasidefiniteness_probe.py, lstar_two_measure_probe.py, christoffel_decomposition_probe.py, rounds 282/283/284/285, notes DCXVI/DCXVII/DCXIX/DCXXI, 2026-08-25, embedded BYTE-EXACT and executed verbatim in their sealed --smoke stage at promotion -- the wave-4 embedding convention: full records sealed experiments-side and re-verified by rh/verification/run_rh.py), plus the module-own exact section S0 above (pure Fractions except the declared float eigen cross-checks: Hankel determinants, monic OP chains, frame congruence minors, Cauchy-Binet exhaustion, dual chains -- no imports from the probes).  WHAT THE DICTIONARY DOES NOT SAY (honest boundary): L* itself is NOT proved -- it is THE open center in its canonical form (ledger PRIME.LSTAR.SUBORDINATION.01 [O]; Lean lstar_subordination in rh/lean/RH/Window.lean, with the proved direction lstar implies free-window positivity); no bound mechanism, no asymptotic law, no derived 5/7; the r284/r285 anatomy legs and the margin-decay finding are MEASUREMENTS, typed as such; the r286 margin-scaling round is in flight and NOT consumed.  Mincut base 4 / refined 5 UNCHANGED (a reduction-plus-elimination set moves no edge); no other marker moves.  NOT evidence for or against the Riemann Hypothesis in either direction.  NO RH CLAIM.

PROVENANCE: discovery probes representation_contest_probe.py
(30/30, SPEC_SHA 0f9954b8f9727800, one gate-side smoke-stage
amendment a1 disclosed -- m4 loudness form, no rule moved),
fullsource_quasidefiniteness_probe.py (26/26, SPEC_SHA
4cf5ea53ffa61ee7, one reporting-only alignment disclosed),
lstar_two_measure_probe.py (30/30, SPEC_SHA 687112a83a767c81,
calibration chronology disclosed, no amendments after freeze),
christoffel_decomposition_probe.py (33/33, SPEC_SHA
9781e6d60aa5660a, NO amendments); rounds 282/283/284/285, notes
DCXVI/DCXVII/DCXIX/DCXXI, 2026-08-25; the standalone problem
document rh/problem/lstar_problem.tex + verify_lstar_instance.py
(12/12, LSTAR INSTANCE VERIFIED; note DCXX) is the external
reference of the [O] contract and is registered in
rh/INVENTORY.json.  WAVE-4 EMBEDDING CONVENTION (as in
v960/v961/v962): frozen sources embedded BYTE-EXACT and executed
verbatim in isolated namespaces in their sealed --smoke stage
(deterministic, seconds each); printed SPEC SHAs pinned and
gated; byte-equality ward vs experiments/tfpt-discovery/ inside
the pattern gates; the full-mode records (gate counts above,
wall times 1.2/1.0/5.6/7.1 s) are sealed experiments-side and
re-verified by rh/verification/run_rh.py.  The probes consume
the READ-ONLY deployed core v563_paper2_readouts.py and the
frozen experiments-side libraries (imports printed in their
headers); the execution order follows the round order so later
probes import earlier ones from the embedded byte-exact sources
(sys.modules convention: lstar_two_measure imports the embedded
r283 fullsource_quasidefiniteness, christoffel_decomposition the
embedded r284 lstar_two_measure and r283 fullsource).  Rounds
279-281 are promoted in v962; the two rounds in flight at this
promotion cut (r286 lstar_margin_scaling_probe.py on the margin
decay, and the L2 deterministic-cancellation lane) are NOT
consumed.

FIREWALL: no zeros, no prime-table oracles (AST scans inside the
probes); RNG only in declared scramble/ensemble controls; ground
truth (flips, census records, spectral records) enters gates
only; NO RH claim.  Python-only per GATE.WOLFRAM.02.
"""

import contextlib
import io
import itertools
import math
import os
import re
import sys
import time
import types
from fractions import Fraction as _Fr

_HERE = os.path.dirname(os.path.abspath(__file__))
if _HERE not in sys.path:
    sys.path.insert(0, _HERE)


# ---------------- module-own exact machinery (pure Fractions; the
# ---------------- reduction dictionary is re-derived from scratch at
# ---------------- module level -- no imports from the probes; the two
# ---------------- declared float legs use numpy eigenvalues as
# ---------------- CROSS-CHECKS of exact rational gates only)
def _frac_det(M):
    """exact determinant by fraction Gaussian elimination."""
    n = len(M)
    if n == 0:
        return _Fr(1)
    A = [row[:] for row in M]
    det = _Fr(1)
    for c in range(n):
        piv = next((r for r in range(c, n) if A[r][c] != 0), None)
        if piv is None:
            return _Fr(0)
        if piv != c:
            A[c], A[piv] = A[piv], A[c]
            det = -det
        det *= A[c][c]
        inv = _Fr(1) / A[c][c]
        for r in range(c + 1, n):
            f = A[r][c] * inv
            if f != 0:
                for k in range(c, n):
                    A[r][k] -= f * A[c][k]
    return det


def _moms(nodes, wts, K):
    return [sum(w * x ** k for w, x in zip(wts, nodes))
            for k in range(K + 1)]


def _hankel_dets(nodes, wts, kmax):
    """D_0 = 1, D_k = det H_k of the signed measure, k = 1..kmax."""
    m = _moms(nodes, wts, 2 * kmax)
    out = [_Fr(1)]
    for k in range(1, kmax + 1):
        out.append(_frac_det([[m[i + j] for j in range(k)]
                              for i in range(k)]))
    return out


def _chain_from_dets(D):
    """pivot chain h_n = D_{n+1}/D_n (valid while D_n != 0)."""
    hs = []
    for n in range(len(D) - 1):
        if D[n] == 0:
            break
        hs.append(D[n + 1] / D[n])
    return hs


def _stj(nodes, wts, K):
    """monic orthogonal chain over a signed atomic measure (exact
    rationals); returns (al[0..K-1], be[0..K-1], hs[0..K])."""
    pk = [_Fr(1)] * len(nodes)
    pkm = [_Fr(0)] * len(nodes)
    hs = [sum(w * p * p for w, p in zip(wts, pk))]
    al, be = [], []
    for n in range(K):
        a_n = sum(w * x * p * p
                  for w, x, p in zip(wts, nodes, pk)) / hs[n]
        b_n = hs[n] / hs[n - 1] if n >= 1 else _Fr(0)
        nxt = [(x - a_n) * p - (b_n * q if n >= 1 else 0)
               for x, p, q in zip(nodes, pk, pkm)]
        pkm, pk = pk, nxt
        hs.append(sum(w * p * p for w, p in zip(wts, pk)))
        al.append(a_n)
        be.append(b_n)
    return al, be, hs


def _op_values(nodes, wts, K):
    """values of the monic OPs pi_0..pi_K of (nodes, wts) at arbitrary
    points: returns a function evalvec(x) -> [pi_0(x)..pi_K(x)], plus
    the norms hs[0..K] (three-term recurrence, exact)."""
    al, be, hs = _stj(nodes, wts, K)

    def evalvec(x):
        vals = [_Fr(1)]
        if K >= 1:
            vals.append(x - al[0])
        for n in range(1, K):
            vals.append((x - al[n]) * vals[n] - be[n] * vals[n - 1])
        return vals
    return evalvec, hs


def _node_poly_deriv(nodes, x):
    """L'(x) at a node x of L(t) = prod (t - x_j) (exact)."""
    out = _Fr(1)
    for y in nodes:
        if y != x:
            out *= (x - y)
    return out


def _split(nodes, wts):
    mu = [(x, w) for x, w in zip(nodes, wts) if w > 0]
    nu = [(x, -w) for x, w in zip(nodes, wts) if w < 0]
    return mu, nu


def _sgn(v):
    return 1 if v > 0 else (-1 if v < 0 else 0)


# frozen toys (r230/r282/r283 conventions, module-own exact copies)
_JF_NODES = [_Fr(-7, 8), _Fr(-5, 8), _Fr(-3, 8), _Fr(-1, 8),
             _Fr(0, 1), _Fr(1, 8), _Fr(3, 8), _Fr(5, 8), _Fr(7, 8)]
_JF_WTS = [_Fr(3, 7), _Fr(-2, 9), _Fr(5, 11), _Fr(1, 4),
           _Fr(1, 3), _Fr(-3, 8), _Fr(2, 5), _Fr(7, 13),
           _Fr(-1, 6)]
_XC = [_Fr(-3, 2), _Fr(-1), _Fr(-1, 2), _Fr(1, 4), _Fr(3, 4),
       _Fr(5, 4)]
_MAINLIKE_W = [_Fr(2, 3), _Fr(-1, 5), _Fr(1, 2), _Fr(-3, 7), _Fr(1),
               _Fr(1, 3)]
_FLIPLIKE_W = [_Fr(2, 3), _Fr(-6, 5), _Fr(1, 2), _Fr(-3, 7), _Fr(1),
               _Fr(1, 3)]
_POSLIKE_W = [abs(w) for w in _MAINLIKE_W]
_EPS_TINY = _Fr(1, 10 ** 12)
_BIG_NEG = _Fr(1000)
_EPS1_W = [_Fr(1)] * 8 + [-_EPS_TINY]
_BIG1_W = [_Fr(1)] * 8 + [-_BIG_NEG]

# the r283 five (A gates) and the r282 four (C gates)
_TOYS5 = (("JF9", _JF_NODES, _JF_WTS),
          ("MAINLIKE", _XC, _MAINLIKE_W),
          ("FLIPLIKE", _XC, _FLIPLIKE_W),
          ("EPS1", _JF_NODES, _EPS1_W),
          ("BIG1", _JF_NODES, _BIG1_W))
_TOYS4 = (("JF9", _JF_NODES, _JF_WTS),
          ("MAINLIKE", _XC, _MAINLIKE_W),
          ("FLIPLIKE", _XC, _FLIPLIKE_W),
          ("POSLIKE", _XC, _POSLIKE_W))

# sealed chain anchors (r282/r283 records): S, N_w, minC, S_-
_ANCH = {"JF9": (9, 5, 3, 3), "MAINLIKE": (6, 3, 4, 2),
         "FLIPLIKE": (6, 3, 2, 2), "POSLIKE": (6, 3, None, 0),
         "EPS1": (9, 5, 8, 1), "BIG1": (9, 5, 0, 1)}
_SIGNSTR = {"JF9": "+++--++-+", "MAINLIKE": "++++--",
            "FLIPLIKE": "++-++-", "POSLIKE": "++++++"}
# r283 ceiling-witness records int p^2 dmutilde (floats, rel 0.05)
_CEIL_REC = {"JF9": -9.7e-3, "MAINLIKE": -3.8e-1, "FLIPLIKE": -1.3,
             "EPS1": -7.2e-14, "BIG1": -7.2e+1}
# r282 K1 fake-SOS exact pin: N_2(MAINLIKE)
_N2_MAINLIKE = _Fr(48360721965, 70120631072)
# r282 K2 defect pins: 2 x negative mass
_DEFECT_REC = {"JF9": _Fr(55, 36), "MAINLIKE": _Fr(44, 35),
               "FLIPLIKE": _Fr(114, 35), "POSLIKE": _Fr(0)}

# --------- frozen measurement record pins (rounds 283/284/285 + DCXX;
# --------- ground truth sealed probe-side, re-verified by the embedded
# --------- pattern gates below and by rh/verification/run_rh.py)
_W9 = dict(S=367, Sp=263, Sm=104, Nw=184, minC=184, cross=185,
           rho184=0.99983248, rho185=1.00003660, margin=1.675e-4,
           maxdiag=0.97001, assist=0.03074, nCS=10, nDIAG=187,
           gain=1.0307, slack=50.2, PR=1.89, n90=2)
_CTRL = dict(EPST=dict(cross=26, nDIAG=91, maxdiag_c=0.376,
                       assist_c=1.69, offshare=0.63, zv=12.4),
             SCR=dict(cross=22, nDIAG=50, maxdiag_c=0.256,
                      assist_c=2.94, offshare=0.75, zv=6.6),
             SMOOTH=dict(cross=28, nDIAG=90, maxdiag_c=0.262,
                         assist_c=2.99, offshare=0.75, zv=5.0),
             HL2=dict(cross=26, nDIAG=87, maxdiag_c=0.260,
                      assist_c=2.96, offshare=0.75, zv=6.3))
_LADDER = dict(maxdiag=(0.9343, 0.9792, 0.9941), sp_maxdiag=0.65,
               assist=(0.0059, 0.0212, 0.0702), sp_assist=-0.65,
               p_bind=0.38, p_bulk=1.27, nstar_bind=58, coverage=0,
               rungs=42)
_ENS = dict(sign_early=1.00, sign_wall=0.00, scr_early=0.75,
            scr_wall=0.00)
_DET = dict(assist_cross_main=0.0195, assist_cross_dead=(1.69, 2.99),
            zv_main=-3.15, zv_dead=(4.95, 12.44))
_DCXX = dict(margin_min=1.4175e-7, z_min=233, S_min=1717, Nw_min=859,
             margin_flagship=1.68e-4, z_flagship=16, rungs=42)


def _lstar_reduction_theorems(gates):
    """The reduction dictionary: the r283 A-chain (A1-A5), the r285
    bookkeeping (B1-B2), the r282 four-language elimination (C1-C4),
    all module-own (exact Fractions plus two declared float eigen
    cross-checks), and the typed measurement pins (M1-M2) whose ground
    truth is sealed probe-side and re-verified by the embedded pattern
    gates."""
    import numpy as _np

    def chk(name, ok, detail=""):
        gates.append(bool(ok))
        print("  [%s] %s%s" % ("PASS" if ok else "FAIL", name,
                               ("  -- " + detail) if detail else ""),
              flush=True)

    print("\n" + "-" * 74)
    print("MODULE-OWN EXACT SECTION S0: the L* reduction dictionary "
          "(A1-A5 + B1-B2 + C1-C4 + M1-M2)")
    print("-" * 74, flush=True)

    # ---- per-toy exact data (chains, splits, frame objects)
    TD = {}
    for name, nodes, wts in _TOYS5 + (("POSLIKE", _XC, _POSLIKE_W),):
        if name in TD:
            continue
        S = len(nodes)
        D = _hankel_dets(nodes, wts, S)
        hs = _chain_from_dets(D)
        minC = next((n for n, h in enumerate(hs) if h < 0), None)
        Sm = sum(1 for w in wts if w < 0)
        budget = sum(1 for h in hs[:S] if h < 0)
        mu, nu = _split(nodes, wts)
        Sp = len(mu)
        TD[name] = dict(nodes=nodes, wts=wts, S=S, Nw=(S + 1) // 2,
                        D=D, hs=hs, minC=minC, Sm=Sm, Sp=Sp,
                        budget=budget, mu=mu, nu=nu)

    # ---- S0-chain-census: sealed anchors, budget theorem, signs
    ok = True
    det = []
    for name in ("JF9", "MAINLIKE", "FLIPLIKE", "POSLIKE",
                 "EPS1", "BIG1"):
        t = TD[name]
        S, Nw, minC, Sm = _ANCH[name]
        ok &= (t["S"] == S and t["Nw"] == Nw and t["minC"] == minC
               and t["Sm"] == Sm and t["budget"] == Sm)
        if name in _SIGNSTR:
            sig = "".join("+" if h > 0 else "-" for h in t["hs"][:S])
            ok &= (sig == _SIGNSTR[name])
        det.append("%s minC=%s bud=%d" % (name, t["minC"], t["budget"]))
    chk("S0-chain-census", ok,
        "sealed anchors + budget == S_- on all six toys: "
        + ", ".join(det))

    # ---- frame objects per r283 toy: minors of D_mu - G
    def frame_minors(t):
        mu, nu = t["mu"], t["nu"]
        Sp = t["Sp"]
        evalvec, hmu = _op_values([x for x, _ in mu],
                                  [w for _, w in mu], Sp - 1)
        pivals = [(v, evalvec(y)) for y, v in nu]     # (v_k, pi_i(y_k))
        M = [[(hmu[i] if i == j else _Fr(0))
              - sum(v * pv[i] * pv[j] for v, pv in pivals)
              for j in range(Sp)] for i in range(Sp)]
        minors = [_frac_det([row[:k] for row in M[:k]])
                  for k in range(1, Sp + 1)]
        return minors, hmu, pivals

    FR = {}
    for name, _n, _w in _TOYS5:
        FR[name] = frame_minors(TD[name])

    # ---- A1: mu-frame congruence minor_k(D_mu - G) == D_k(mutilde)
    ok = True
    for name, _n, _w in _TOYS5:
        minors = FR[name][0]
        D = TD[name]["D"]
        ok &= all(minors[k - 1] == D[k]
                  for k in range(1, TD[name]["Sp"] + 1))
    chk("A1-congruence", ok,
        "minor_k(D_mu - G) == D_k(mutilde) exact at every k <= S_+ "
        "on all five r283 toys (rational)")

    # ---- A1 must-fail: one-nu-atom truncation breaks the congruence
    t = TD["JF9"]
    mu, nu = t["mu"], t["nu"]
    nu_trunc = nu[:-1]                                # drop one nu atom
    evalvec, hmu = _op_values([x for x, _ in mu],
                              [w for _, w in mu], t["Sp"] - 1)
    piv_t = [(v, evalvec(y)) for y, v in nu_trunc]
    Mt = [[(hmu[i] if i == j else _Fr(0))
           - sum(v * pv[i] * pv[j] for v, pv in piv_t)
           for j in range(t["Sp"])] for i in range(t["Sp"])]
    mism = next((k for k in range(1, t["Sp"] + 1)
                 if _frac_det([row[:k] for row in Mt[:k]]) != t["D"][k]),
                None)
    dev = (abs(float(_frac_det([row[:1] for row in Mt[:1]])
                     - t["D"][1])) if mism == 1 else float("nan"))
    chk("A1-truncation-mustfail", mism is not None,
        "dropping one nu atom breaks the congruence LOUDLY (first "
        "mismatch at k = %s, k=1 dev %.2e)" % (mism, dev))

    # ---- A2: frame contraction (Sylvester side exact, eigen float
    # ---- cross-check) in BOTH truth values
    ok = True
    saw_true = saw_false = False
    for name, _n, _w in _TOYS5:
        t = TD[name]
        minors = FR[name][0]
        hmu = FR[name][1]
        pivals = FR[name][2]
        Sm_ = t["Sm"]
        for m in range(1, t["Sp"] + 1):
            lhs = all(h > 0 for h in t["hs"][:m])
            rhs = all(minors[k] > 0 for k in range(m))
            ok &= (lhs == rhs)
            saw_true |= lhs
            saw_false |= (not lhs)
        # float eigen cross-check: lambda_max(E_m) < 1 <=> minors > 0
        B = _np.array([[math.sqrt(float(v)) * float(pv[i])
                        / math.sqrt(float(hmu[i]))
                        for i in range(t["Sp"])]
                       for v, pv in pivals], dtype=float)
        for m in range(1, t["Sp"] + 1):
            Em = B[:, :m] @ B[:, :m].T
            lam = max(_np.linalg.eigvalsh(Em)) if Sm_ else 0.0
            rhs = all(minors[k] > 0 for k in range(m))
            if abs(1.0 - lam) > 1e-9:
                ok &= ((lam < 1.0) == rhs)
    chk("A2-frame-contraction", ok and saw_true and saw_false,
        "h_0..h_{m-1} > 0 <=> minors positive <=> lambda_max(E_m) < 1 "
        "at every m <= S_+ on all five toys, both truth values")

    # ---- A3: crossing dictionary == minC + 1 / CAPACITY_CEILING
    ok = True
    det = []
    for name, _n, _w in _TOYS5:
        t = TD[name]
        minors = FR[name][0]
        cross = next((k for k in range(1, t["Sp"] + 1)
                      if minors[k - 1] < 0), None)
        if name in ("MAINLIKE", "EPS1"):
            ok &= (cross is None and t["minC"] == t["Sp"])
            det.append("%s CEILING(minC=S_+=%d)" % (name, t["Sp"]))
        else:
            ok &= (cross == t["minC"] + 1)
            det.append("%s cross=%s" % (name, cross))
    chk("A3-crossing-dictionary", ok,
        "first negative frame minor at minC+1 exactly: "
        + ", ".join(det))

    # ---- A4: pigeonhole ceiling via the null-polynomial witness
    ok = True
    det = []
    for name, _n, _w in _TOYS5:
        t = TD[name]
        val = -sum(v * math.prod((y - x) for x, _ in t["mu"]) ** 2
                   for y, v in t["nu"])
        fv = float(val)
        rec = _CEIL_REC[name]
        ok &= (val < 0 and abs(fv - rec) <= 0.05 * abs(rec)
               and t["minC"] <= t["Sp"])
        det.append("%s %.2e" % (name, fv))
    chk("A4-pigeonhole-ceiling", ok,
        "int p^2 dmutilde = -int p^2 dnu < 0 exact on all five toys "
        "(%s) and minC <= S_+ everywhere" % ", ".join(det))

    # ---- A5: capacity-as-counting refuted (rank-one pair)
    okr = True
    for name in ("EPS1", "BIG1"):
        t = TD[name]
        _m, hmu_, piv_ = FR[name]
        for n in range(1, t["Sp"] + 1):
            G = [[sum(v * pv[i] * pv[j] for v, pv in piv_)
                  for j in range(n)] for i in range(n)]
            # rank via fraction elimination (count nonzero pivots)
            A = [row[:] for row in G]
            rank = 0
            for c in range(n):
                piv = next((r for r in range(rank, n)
                            if A[r][c] != 0), None)
                if piv is None:
                    continue
                A[rank], A[piv] = A[piv], A[rank]
                pv_ = A[rank][c]
                for r in range(rank + 1, n):
                    f = A[r][c] / pv_
                    if f != 0:
                        for k in range(c, n):
                            A[r][k] -= f * A[c][k]
                rank += 1
            okr &= (rank == min(n, t["Sm"]))
    m_eps = float(TD["EPS1"]["nu"][0][1] / FR["EPS1"][1][0])
    m_big = float(TD["BIG1"]["nu"][0][1] / FR["BIG1"][1][0])
    okr &= (abs(m_eps - 1.25e-13) <= 1e-3 * 1.25e-13
            and abs(m_big - 1.25e+2) <= 1e-3 * 1.25e+2
            and TD["EPS1"]["minC"] == 8 > TD["EPS1"]["Nw"]
            and TD["BIG1"]["minC"] == 0)
    chk("A5-capacity-counting-refuted", okr,
        "rank G_n == min(n, S_-) on both; SAME rank/support, OPPOSITE "
        "fate (EPS1 minC 8 > N_w 5, BIG1 dies at 0); metric values "
        "G_11/h^mu_0 = %.2e vs %.2e -- the deciding quantity is "
        "METRIC" % (m_eps, m_big))

    # ---- B1: the Christoffel sandwich (exact-rational consequences)
    ok = True
    for name, _n, _w in _TOYS5:
        t = TD[name]
        minors = FR[name][0]
        hmu = FR[name][1]
        pivals = FR[name][2]
        for n in range(1, t["Sp"] + 1):
            diags = [v * sum(pv[i] * pv[i] / hmu[i] for i in range(n))
                     for v, pv in pivals]
            trace = sum(diags)
            maxd = max(diags) if diags else _Fr(0)
            ok &= (maxd <= trace)
            if trace < 1:
                ok &= all(minors[k] > 0 for k in range(n))
            if maxd >= 1:
                ok &= any(minors[k] <= 0 for k in range(n))
    chk("B1-christoffel-sandwich", ok,
        "max_k v_k K_n(y_k) <= trace exact; trace < 1 => window "
        "positive through n; maxdiag >= 1 => crossing at or below n "
        "(rational, every degree, all five toys)")

    # ---- B2: multiplicative decomposition + budget equivalence
    ok = True
    for name, _n, _w in _TOYS5:
        t = TD[name]
        if t["Sm"] == 0:
            continue
        minors = FR[name][0]
        hmu = FR[name][1]
        pivals = FR[name][2]
        B = _np.array([[math.sqrt(float(v)) * float(pv[i])
                        / math.sqrt(float(hmu[i]))
                        for i in range(t["Sp"])]
                       for v, pv in pivals], dtype=float)
        for n in range(1, t["Sp"] + 1):
            Em = B[:, :n] @ B[:, :n].T
            lam = float(max(_np.linalg.eigvalsh(Em)))
            diags = [float(v * sum(pv[i] * pv[i] / hmu[i]
                                   for i in range(n)))
                     for v, pv in pivals]
            maxd = max(diags)
            if maxd <= 0:
                continue
            assist = lam / maxd - 1.0
            ok &= abs(maxd * (1.0 + assist) - lam) <= 1e-12 * max(lam, 1)
            margin = (1.0 / maxd - 1.0) - assist
            rhs = all(minors[k] > 0 for k in range(n))
            if abs(1.0 - lam) > 1e-9:
                ok &= ((margin > 0) == rhs)
    chk("B2-decomposition-budget", ok,
        "lambda_max = maxdiag x (1 + assist) exactly and the budget "
        "equivalence (1/maxdiag - 1) - assist > 0 <=> all frame "
        "minors positive, sign-exact at every degree (float leg vs "
        "the exact rational side)")

    # ---- C1: SOS exists only for the positive class
    ok = True
    for name, nodes, wts in _TOYS4:
        t = TD[name]
        S = t["S"]
        evalvec, hs_u = _op_values(nodes, wts, S - 1)
        allN0 = True
        for n in range(S):
            P = sum(w * evalvec(x)[n] ** 2
                    for x, w in zip(nodes, wts) if w > 0)
            N = sum(-w * evalvec(x)[n] ** 2
                    for x, w in zip(nodes, wts) if w < 0)
            ok &= (P - N == t["hs"][n])
            if n >= 1 and N != 0:
                allN0 = False
            if name == "MAINLIKE" and n == 2:
                ok &= (N == _N2_MAINLIKE)
        ok &= (allN0 == (name == "POSLIKE"))
    chk("C1-sos-positive-class-only", ok,
        "Pontryagin split P_n - N_n == h_n exact at every degree; SOS "
        "(empty negative register) exactly on POSLIKE only; fake SOS "
        "misses h_2(MAINLIKE) by exactly N_2 = 48360721965/70120631072"
        " -- the surviving clause N < P is h > 0 verbatim")

    # ---- C2: Kasteleyn orientation iff S_- = 0 (full exhaustion)
    ok = True
    det = []
    for name, nodes, wts in _TOYS4:
        t = TD[name]
        S = t["S"]
        sgnw = [_sgn(w) for w in wts]
        coh = []
        for bits in range(1 << S):
            sig = [1 if (bits >> i) & 1 else -1 for i in range(S)]
            s = [sig[i] * sgnw[i] for i in range(S)]
            if len(set(s)) == 1:      # coherent in EVERY cell n
                coh.append(tuple(sig))
        want = {tuple(sgnw), tuple(-x for x in sgnw)}
        ok &= (set(coh) == want if any(x < 0 for x in sgnw)
               else set(coh) == {tuple([1] * S), tuple([-1] * S)})
        # honest cell-level demonstration on MAINLIKE: all n-products
        if name == "MAINLIKE":
            for sig in ([1] * S, sgnw):
                s = [sig[i] * sgnw[i] for i in range(S)]
                for n in range(1, S):
                    prods = {math.prod(s[i] for i in I)
                             for I in itertools.combinations(range(S), n)}
                    ok &= ((len(prods) == 1) == (len(set(s)) == 1))
        # quadratic/edge class: n = 3 coherence <=> all sign w equal
        tri = {math.prod(sgnw[i] for i in I)
               for I in itertools.combinations(range(S), 3)}
        ok &= ((len(tri) == 1) == (t["Sm"] == 0))
        # Cauchy-Binet + oriented value + defect (n up to 5)
        nmax = min(5, S - 1)
        Dabs = _hankel_dets(nodes, [abs(w) for w in wts], nmax)
        mismatch = False
        for n in range(1, nmax + 1):
            tot = _Fr(0)
            tota = _Fr(0)
            for I in itertools.combinations(range(S), n):
                d2 = math.prod((nodes[b] - nodes[a]) ** 2
                               for a, b in
                               itertools.combinations(I, 2)) \
                    if n >= 2 else _Fr(1)
                pw = math.prod(wts[i] for i in I)
                tot += d2 * pw
                tota += d2 * abs(pw)
            ok &= (tot == t["D"][n] and tota == Dabs[n])
            if n >= 1 and Dabs[n] != t["D"][n] and Dabs[n] != -t["D"][n]:
                mismatch = True
        ok &= (Dabs[1] - t["D"][1] == _DEFECT_REC[name])
        ok &= (mismatch == (t["Sm"] > 0))
        det.append("%s coh=%d" % (name, len(coh)))
    chk("C2-kasteleyn-iff-positive", ok,
        "full 2^S exhaustion: coherent class == {+-sign w} (%s); "
        "quadratic class collapses at n = 3 on every signed toy; "
        "Cauchy-Binet re-proved exact; oriented value = D_n(|w|), "
        "defect at n = 1 == 2 x negmass exactly (55/36, 44/35, "
        "114/35, 0) -- orientation constructible AND value-preserving"
        " IFF S_- = 0" % ", ".join(det))

    # ---- C3: Hamiltonian-PSD == h > 0 (bookkeeping, both values)
    ok = True
    saw_true = saw_false = False
    for name, nodes, wts in _TOYS4:
        t = TD[name]
        hs = t["hs"]
        for n in range(1, min(len(hs), t["S"])):
            beta_pos = all(hs[k] / hs[k - 1] > 0
                           for k in range(1, n + 1))
            h_pos = all(h > 0 for h in hs[:n + 1])
            ok &= ((hs[0] > 0 and beta_pos) == h_pos)
            saw_true |= h_pos
            saw_false |= (not h_pos)
    chk("C3-hamiltonian-bookkeeping", ok and saw_true and saw_false,
        "(h_0 > 0 and all beta_k > 0 up to n) <=> (h_0..h_n > 0) on "
        "all four toys, both truth values -- the de Branges form is "
        "h > 0 verbatim, no second gestalt")

    # ---- C4: dual-pair sync by theorem
    ok = True
    worst = 0.0
    for name, nodes, wts in _TOYS4:
        t = TD[name]
        S = t["S"]
        wd = [_Fr(1) / (w * _node_poly_deriv(nodes, x) ** 2)
              for x, w in zip(nodes, wts)]
        Dd = _hankel_dets(nodes, wd, S)
        hd = _chain_from_dets(Dd)
        ok &= all(t["hs"][n] * hd[S - 1 - n] == 1 for n in range(S))
        ok &= all(_sgn(t["hs"][n]) == _sgn(hd[S - 1 - n])
                  for n in range(S))
        if name == "MAINLIKE":       # m4 must-fail: wrong dual 1/w
            wworst = [_Fr(1) / w for w in wts]
            Dw = _hankel_dets(nodes, wworst, S)
            hw = _chain_from_dets(Dw)
            devs = [abs(float(t["hs"][n] * hw[S - 1 - n] - 1))
                    for n in range(min(S, len(hw)))]
            ok &= all(t["hs"][n] * hw[S - 1 - n] != 1
                      for n in range(min(S, len(hw))))
            worst = max(devs)
            ok &= (worst >= 1e2)
    chk("C4-dualpair-sync-by-theorem", ok,
        "h_n x h#_{S-1-n} == 1 exact at every degree on all four toys"
        " (sign sync IDENTICAL -- no second condition per theorem); "
        "wrong dual 1/w breaks the law at every degree, worst "
        "|h h# - 1| = %.1e LOUD" % worst)

    # ---- M1: the r283/r284/r285 record dictionary (typed MEASUREMENT;
    # ---- ground truth sealed probe-side, re-verified by the embedded
    # ---- pattern gates below)
    okm = True
    okm &= (_W9["cross"] == _W9["minC"] + 1)
    okm &= (_W9["nDIAG"] == _W9["cross"] + 2)
    okm &= (_W9["rho184"] < 1.0 < _W9["rho185"])
    okm &= abs(_W9["maxdiag"] * (1.0 + _W9["assist"])
               - _W9["rho184"]) <= 2e-5
    okm &= abs((1.0 / _W9["maxdiag"] - 1.0) - _W9["assist"]
               - _W9["margin"]) <= 1e-5
    for c in _CTRL.values():
        okm &= (c["cross"] < c["nDIAG"] < _W9["Nw"])
        okm &= (c["maxdiag_c"] < 1.0 and c["assist_c"] >= 0.5)
        okm &= (c["zv"] > 3.0)
    okm &= (_DET["assist_cross_main"] < _DET["assist_cross_dead"][0])
    okm &= (_DET["zv_main"] < 0 < _DET["zv_dead"][0])
    okm &= (_ENS["sign_wall"] == 0.0 and _ENS["scr_wall"] == 0.0)
    okm &= (0.2 <= _ENS["scr_early"] <= 0.8 <= _ENS["sign_early"])
    lo, med, hi = _LADDER["maxdiag"]
    okm &= (lo < med < hi < 1.0)
    alo, amed, ahi = _LADDER["assist"]
    okm &= (0 < alo < amed < ahi)
    okm &= (_LADDER["p_bind"] < 1.0 < _LADDER["p_bulk"])
    okm &= (_LADDER["nstar_bind"] < _W9["nDIAG"]
            and _LADDER["coverage"] == 0)
    chk("M1-record-dictionary", okm,
        "w9 crossing 185 == minC+1, n_DIAG 187 = crossing + 2 "
        "(near-single-atom wall); mp ward rho_184 = %.8f < 1 < %.8f; "
        "budget reconstruction exact to record rounding; controls die"
        " COLLECTIVELY (n_DIAG 50..91 << 184, maxdiag_c 0.26..0.38, "
        "assist_c 1.69..2.99, z_v +5.0..+12.4 constructive) -- (D) "
        "SEPARATES at window scale; ladder budgets maxdiag "
        "0.9343..0.9941 (sp +0.65, tightens toward 1), assist "
        "0.0059..0.0702 (sp -0.65, shrinks): NO fixed delta/delta' "
        "budget; sub-classical edge growth p_bind = 0.38 vs bulk "
        "1.27, n*_bind 58 vs n_DIAG 187, classical coverage 0/42 -- "
        "(D) needs a DISCRETE bound; ensemble wall pcts 0.00/0.00 "
        "LOW_OUTLIER; THE FIRST TWO MAIN_SEPARATING detectors: K_D2 "
        "assist-at-crossing %.4f vs dead %.2f..%.2f, K_C1 z_v %.2f "
        "(destructive) vs dead +%.2f..+%.2f (all constructive)"
        % (_W9["rho184"], _W9["rho185"], _DET["assist_cross_main"],
           _DET["assist_cross_dead"][0], _DET["assist_cross_dead"][1],
           _DET["zv_main"], _DET["zv_dead"][0], _DET["zv_dead"][1]))

    # ---- M2: the DCXX margin-decay finding (honest; r286 in flight)
    okd = (_DCXX["margin_min"] > 0
           and _DCXX["margin_min"] < _DCXX["margin_flagship"]
           and _DCXX["Nw_min"] == (_DCXX["S_min"] + 1) // 2
           and 2.5 <= math.log10(_DCXX["margin_flagship"]
                                 / _DCXX["margin_min"]) <= 3.5
           and abs(_DCXX["margin_flagship"] - _W9["margin"])
           <= 0.01 * _W9["margin"])
    chk("M2-margin-decay-honest", okd,
        "all %d ladder margins strictly positive, family minimum "
        "%.4e at anchor z = %d (S = %d, N_w = %d), flagship z = %d "
        "carries the LARGEST margin %.2e -- the spectral L* margin "
        "falls ~3 orders over the tested family (log10 ratio %.2f); "
        "the r258 FLAT finding was the terminal ratio q_N, a "
        "different object; the unbounded-family version of L* is "
        "GENUINELY UNCERTAIN in both directions -- r286 "
        "lstar_margin_scaling_probe.py is IN FLIGHT and NOT consumed"
        % (_DCXX["rungs"], _DCXX["margin_min"], _DCXX["z_min"],
           _DCXX["S_min"], _DCXX["Nw_min"], _DCXX["z_flagship"],
           _DCXX["margin_flagship"],
           math.log10(_DCXX["margin_flagship"] / _DCXX["margin_min"])))


_SRC_0 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""representation_contest_probe -- PRIME.PORT.REPRESENTATION.
CONTEST.01 (round 282): WHAT IS h_n?  Four classical
representation classes for the pivot h_n -- monodromy norm,
intersection form, canonical-system Hamiltonian, operator
compression -- each with a construction attempt on exact toys and
ONE brutal reviewer gate: the representation must (i) force MAIN
positivity STRUCTURALLY (existence of the structure => h > 0 as
an implication, symbolically checkable) AND (ii) provably REJECT
at least one early-dying control world (the structure does not
exist there or breaks exactly at the flip).  A representation
that exists everywhere is decoration; one that is nowhere
constructible is theology.  NOT judged by numerical fit.

EXPLORATION ONLY (2026-08-25).  experiments/ level: NO promotion,
NO ledger row, NO marker moved, NO RH CLAIM in either direction.

THE ELIMINATION BALANCE (why this contest; the r261..r281 record):
cancellation is generic/coherent (r273 + r261: no finite grouping,
no involution, no cone); extremality is false (r280:
MAIN_NOT_MAXIMAL); local geometry is insufficient (r268/r269); KYP
memory is a no-go (r275); the duality is a restatement (r280);
the Maslov obstruction is refuted (r279: OBSTRUCTION_REFUTED);
moment perturbation is world-blind (r280); the crossing type is
world-blind (r281: all four dead worlds CREEPING); half-filling is
pure counting (r281: the counting theorem says WHERE the window
ends, never WHY MAIN survives it).  What remains is the NORTH
STAR question: which OBJECT owns h_n as a norm, volume, energy,
index or intersection number, so that h_n > 0 follows structurally
-- the dream h_n = <omega_n, omega_n> in a space that exists ONLY
for the right arithmetic class.

INDEX FIREWALL (binding, r238-r281 discipline): w = window (kz),
S = #union support atoms of mutilde = mu - nu, S_- = #negative
union weights, N_w = builder depth = ceil(S/2) = (S+1)//2, n =
chain degree, h_n = chain pivot, minC = first n with h_n < 0,
budget = #(h_n < 0) over the full continuation (= S_- by the r279
theorem); ground truth (control flip tables, census offsets, the
withheld sign chain) enters GATES and record tables only; no
zero/prime oracles anywhere (AST firewall).  REPRESENTATION-LEVEL
DECLARATION (honest, binding): K1/K3/K4 constructions consume the
chain data (al, be, hs) BY DESIGN -- they are representations OF
h, not blind predictors; the scope audit forbids the ground-truth
tables (CTRL_FLIPS, HL2_FLIP, minC_true, offs_true, sg_true) in
every sealed constructor; the K2 gauge constructors are
source-pure (atom signs + configuration terms only).  MACHINERY
IMPORTED VERBATIM: r280 BL.{union_of_ctx, sign_chain_f64,
mp_sign_chain, toy_moments, frac_det, TOYS_XS, MAINLIKE_W,
FLIPLIKE_W}, MS.ctx_build, r230 JF.{stieltjes_exact, TOY_NODES,
TOY_WTS}, r274 WD.stj_gen, r277 MC.cand_interlace, paircorr
PC.{Grid, gen_model}, v881 PIK, r243 PB.smooth_comb, v563 core
READ-ONLY.

THE FOUR SEALED CLASSES (construction + gate, frozen BEFORE
evaluation):

(K1) RHP/MONODROMY -- h_n as a monodromy norm |m_n|^2 x positive
  factor.  CONSTRUCTION: the Pontryagin split of the self-pairing
  h_n = <pihat_n, pihat_n>_mutilde = P_n - N_n with P_n =
  sum_{w_j > 0} w_j pihat_n(x_j)^2 > 0 and N_n = sum_{w_j < 0}
  |w_j| pihat_n(x_j)^2 >= 0 (exact identity, gated on all toys at
  every degree).  The |m_n|^2 representation h_n = ||pihat_n||^2
  exists exactly when the negative register is EMPTY (N_n == 0
  for all n): the Schwarz-reality/symmetry condition of the
  discrete 2x2 problem (r224 JMU frame) is the POSITIVITY OF THE
  JUMP -- for a signed mutilde the jump is indefinite and the
  monodromy pairing is a Pontryagin (not Hilbert) pairing.
  SEALED EXISTENCE CRITERION: SOS_EXISTS iff N_n == 0 at every
  chain degree.  GATE: SOS must exist on the MAIN-like class and
  fail on a control class.  ADJUDICATION: GO iff SOS_EXISTS on
  MAINLIKE and not on FLIPLIKE; RESTATEMENT iff the split is
  exact but SOS fails on MAINLIKE too and the remaining
  positivity clause N_n < P_n is h_n > 0 verbatim;
  NOT_CONSTRUCTIBLE iff the split identity itself breaks.
  MUST-FAIL m1: the fake SOS that drops the negative register
  (P_n alone) must miss h_n by EXACTLY N_n > 0 (loud, exact).

(K2) HODGE/INTERSECTION -- h_n as an intersection-form value with
  a Kasteleyn-like ORIENTATION on the Cauchy-Binet configuration
  space (r261 a1: term(I) = 4^binom(n,2) Delta(x_I)^2 prod_{i in
  I} w_i; sign(term) = prod_{i in I} sign w_i is ALREADY a
  coboundary of the atom sign vector).  THE QUESTION (this is NOT
  the r261 termwise-positivity no-go): does an ORIENTATION CLASS
  exist -- (linear class) a gauge sigma in {+-1}^S with eps(I) =
  prod_{i in I} sigma_i, or (quadratic/edge class, the genuine
  Kasteleyn shape) pair signs kappa_ij with eps(I) = prod_{i<j in
  I} kappa_ij -- such that (C) eps(I) term(I) is sign-coherent in
  EVERY cell n = 1..S-1 and (V) the oriented sum still represents
  +-D_n (value preservation)?  SEALED TESTS: (linear) FULL
  EXHAUSTION over all 2^S gauges on every toy -- the coherent set
  must be computed, not assumed; (quadratic) the n = 2 cells
  force kappa_ij = c sign(w_i w_j) (each pair is its own cell),
  and coherence of the n = 3 cell then requires prod_{i in I}
  sign(w_i) constant over ALL triples -- checked exactly;
  (value) for the surviving gauge sigma = sign(w): the oriented
  value is D_n(|w|), and the defect at n = 1 is m_0(|w|) -
  m_0(w) = 2 x (negative mass), EXACT -- zero iff S_- = 0.
  ADJUDICATION: GO iff some orientation is coherent AND
  value-preserving on MAINLIKE and none is on FLIPLIKE;
  WORLD_BLIND iff on both; NOT_CONSTRUCTIBLE iff none on
  MAINLIKE (with the exact obstruction).  MUST-FAIL m2: a gauge
  oriented by the withheld h-sign chain must be FLAGGED by the
  AST scope audit.  ANTI-GATE (decoration): eps = sign(term)
  itself (no locality class) exists everywhere and is EXCLUDED
  by seal.

(K3) DE BRANGES / CANONICAL SYSTEM -- the chain as a canonical
  system with Hamiltonian H(t) >= 0.  CONSTRUCTION (classical,
  exact): the monic Jacobi matrix J = tridiag(1, alpha, beta) is
  symmetrizable by a real diagonal d_n^2 = h_n/h_0 iff every
  beta_k > 0; the per-cell Hamiltonian H_n = v_n v_n^T with v_n =
  (1, sqrt(beta_n)) exists real and PSD iff beta_n >= 0; hence
  HAMILTONIAN POSITIVITY THROUGH THE FREE WINDOW <=> h_0..h_{
  N_w-1} > 0 -- EXACT equivalence (bookkeeping, gated).  THE
  RESTATEMENT DETECTOR (the round's honest question): does the
  Hamiltonian positivity have ANOTHER (more checkable) gestalt
  than h > 0 itself?  Sealed candidate shadow: the R2
  interlacing/reality of the pihat_n zeros (r277 anchor,
  MC.cand_interlace with the balanced tridiagonal).  Measured
  lag = fire - minC per world: a lag-0 shadow would FORBID the
  crossing; a lag >= 1 shadow only detects it afterwards.
  ADJUDICATION: GO iff an h-independent shadow has lag 0 on
  every flipping toy AND every control while MAIN stays safe;
  RESTATEMENT iff the equivalence is exact but every shadow lag
  is >= 1 (the de Branges form is h > 0 verbatim; the shadow
  cannot carry the implication).  MUST-FAIL m3: the |beta|
  symmetrizer (absolute values) is a valid positive chain but
  represents a DIFFERENT measure: its Jacobi moments m_k = h_0
  (A^k)_{00} must break the true moment sequence loudly at the
  first degree that sees the flipped beta (exact).

(K4) OPERATOR POSITIVITY -- h_n as a compression datum of a joint
  positive structure on the DUAL PAIR (v956 duality).
  CONSTRUCTION (exact): dual weights w#_j = 1/(w_j L'(x_j)^2),
  dual chain h#_m; the v956 complement identity gives the exact
  product law  h_n x h#_{S-1-n} == 1  at EVERY degree (gated in
  rationals on all toys).  THE STRUCTURE CONSEQUENCE (corollary,
  gated): sign h_n == sign h#_{S-1-n} IDENTICALLY -- the dual
  pair is sign-synchronized as an IDENTITY, in every world, both
  sides of every flip: the "joint positivity" h_n > 0 AND
  h#_{S-1-n} > 0 is ONE condition seen twice, never an
  intersection of two constraints.  THE BUDGET OBSTRUCTION
  (r279 theorem, re-derived exactly): #(h < 0) == S_- >= 1 on
  every signed world -- ANY global positive structure (CP map /
  dilation) whose compressions produce ALL pivots is NOT
  constructible for signed sources; a structure restricted to
  the free window must ENCODE N_w, and the window boundary is
  the r281 counting theorem (pure counting): the "positive
  structure" collapses onto the localization statement itself.
  ADJUDICATION: GO iff the joint dual structure provably rejects
  >= 1 control (sync breaks at its flip); WORLD_BLIND iff the
  sync holds identically on every world including the flipping
  toys; NOT_CONSTRUCTIBLE iff the duality identity itself
  breaks.  MUST-FAIL m4: dual weights WITHOUT the L'^2 factor
  (w# = 1/w) must break the product law loudly (exact).

TOY WORLDS (exact rationals, sealed): JF9 = the r230 9-atom toy
(S = 9, N_w = 5, S_- = 3, minC = 3: dies INSIDE its free window
-- an exact control); MAINLIKE (S = 6, N_w = 3, S_- = 2, minC =
4: survives its free window -- the MAIN-class toy); FLIPLIKE
(S = 6, S_- = 2, minC = 2: dies inside -- control); POSLIKE =
|MAINLIKE weights| (S_- = 0, minC = none: the positive class,
where the classical structures MUST exist -- the calibration of
gate (i)).  REAL WORLDS (f64 + mp ward): w9 MAIN (S = 367, N_w =
184, minC = 184) + the dead battery EPSTEIN / SCRAMBLE(seed 1) /
SMOOTH (flips 25/21/27) + HL2 (seed 101, flip 25).

DETECTORS (sealed, r281 distance rule -- MAIN_SEPARATING iff
MAIN's value is farther from EVERY dead value than the dead
spread, else WORLD_BLIND): D1 (K1) negative-register fraction at
the last free degree = (1 - sg rmg)/2 at n = N_w - 1; D2 (K2)
orientation value defect = 2 x negmass / gross mass (source-
pure); D3 (K3) shadow fire degree / N (DECLARED h-reading:
restatement-grade by construction); D4 (K4) sync fraction
(identically 1 by the theorem -- the world-blindness IS the
finding).  STOP LIST (anti-gates, binding): no derived 5/7, no
bound mechanism claim, no asymptotic law, no localization claim,
no lower-side claim, NO RH claim; r243..r281 stand.

SEALED CONSTANTS: TOYS as above (POSLIKE = abs MAINLIKE);
TOY_ANCH minC {JF9: 3, MAINLIKE: 4, FLIPLIKE: 2, POSLIKE: None},
budgets {3, 2, 2, 0}; W9_ANCH (S 367, N 184, minC 184, S_- 104);
CTRL_FLIPS EPST 25 / SCR 21 / SMOOTH 27; HL2 seed 101, flip 25;
EXT 8; IM_TOL 1e-7; MP_DPS 40 / MP_GUARD 1e-30 / MP_RECOUNT 80;
VAL_NMAX N_w + 1 per toy; MOM_KMAX 2 (S - 2); CTRL_CHAIN_EXT 10;
runtime <= 1800 s; smoke = toys (all four classes exact) +
exhaustion + must-fails + scopes + w9 f64 sanity (negfrac,
defect); skipped in smoke: mp ward, controls, w9 interlacing
sweep, detector, adjudication.
PRE-SPEC SCOPING (disclosed, r281 protocol): two scratch passes
on the toys + one machinery pass on w9 ONLY, run BEFORE this spec
was sealed and deleted: (i) the duality index convention (h_n
h#_{S-1-n} == 1, not S-2-n), the coherence collapse (the linear
coherent set is exactly {+-sign w} on all four toys), the value
mismatch at n = 1, the P/N split identity, and the toy
interlacing fires (minC + 1 on FLIPLIKE/JF9); (ii) w9 cost and
behavior (chain 0.0 s, interlacing sweep 0.3 s SAFE through 183
with min normalized margin 4.8e-8 -- f64-marginal, disclosed;
negfrac 0.498, defect 0.115).  Every adjudication rule, bar and
verdict form above was frozen before the full-record evaluation;
the controls, the detector and the mp ward were UNTOUCHED
pre-spec.

SEALED VERDICT FORM (frozen BEFORE evaluation; per class exactly
one of REPRESENTATION_GO(structure, gate passed) /
REPRESENTATION_RESTATEMENT / REPRESENTATION_WORLD_BLIND /
REPRESENTATION_NOT_CONSTRUCTIBLE, plus the overall
CONTEST_WINNER(class; priority K1 > K2 > K3 > K4) /
CONTEST_ALL_DEAD(with the precise elimination per class -- itself
a program finding: the positivity has no representation in the
four classical languages at this resolution).
Honesty before beauty: gate (i) is calibrated on POSLIKE (the
classical structures MUST exist for the positive class -- if they
do not, the construction is wrong, not the class); a class that
exists only for the positive class cannot carry MAIN (MAIN is
signed); no verdict claims a derived 5/7, a bound mechanism or an
asymptotic law; the lower side (why MAIN survives its free
window) stays the open center.

RECORD TABLES (frozen from the record run; calibration protocol,
chronology honest: smoke pass 1 = 28/30 -- the drafted m4
loudness criterion was a GUESSED 1e3 magnitude bar while the
measured worst |h h# - 1| on MAINLIKE is 1.4e+02; ONE disclosed
amendment a1 (smoke stage, BEFORE any full evaluation, gate-side
only, r261-a1 precedent): the m4 criterion moved to the
exact-breakage form (h h# != 1 in rationals at EVERY degree plus
worst dev >= 1e2); smoke pass 2 = 30/30 (0.1 s); calibration
pass 1 = first full evaluation = 30/30, wall 1.2 s; NO bar,
band, class, adjudication or verdict rule moved at any point;
run1/run2 identical up to WALL):
CAL_VERDICT = K1 REPRESENTATION_RESTATEMENT + K2
REPRESENTATION_NOT_CONSTRUCTIBLE + K3 REPRESENTATION_RESTATEMENT
+ K4 REPRESENTATION_WORLD_BLIND + CONTEST_ALL_DEAD.
Key numbers.  TOYS (exact rationals): chain census == sealed
anchors (minC 3/4/2/None, budgets 3/2/2/0 == S_-, N_w 5/3/3/3;
sign strings +++--++-+ / ++++-- / ++-++- / ++++++).
K1: P_n - N_n == h_n exact at every degree on all four toys; SOS
exists ONLY on POSLIKE (N_n == 0 all n); on the signed toys N_n
> 0 at EVERY degree n >= 1 (MAINLIKE included: N/P = 0.5380 at
the last free degree n = 2) -- the monodromy-norm structure does
not exist on the MAIN class, and the surviving clause N_n < P_n
is h_n > 0 verbatim; m1 fake SOS misses h_2(MAINLIKE) by exactly
N_2 = 48360721965/70120631072 LOUD; w9 negfrac at N_w - 1 =
0.498189 (rmg 3.62e-3): the negative register carries HALF the
mass at the wall.  K2: linear exhaustion (512/64/64/64 gauges):
coherent set == {+-sign w} on ALL four toys (2 gauges each --
the orientation class is UNIQUE, computed not assumed);
quadratic/edge class: n = 2 forces kappa = c sign(w_i w_j),
n = 3 coherence fails on ALL THREE signed toys and holds on
POSLIKE; value: the oriented sum is D_n(|w|), defect at n = 1 ==
2 x negmass EXACT (JF9 55/36, MAINLIKE 44/35, FLIPLIKE 114/35,
POSLIKE 0) and D_n(|w|) != +-D_n(w) at EVERY checked n >= 1 on
the signed toys (mism xxxxxx/xxxx/xxxx/====) => the orientation
is constructible EXACTLY on the positive class; w9: singleton
forcing + defect 0.1152 (S_- = 104, negmass 0.2262) -- dead at
n = 1 already; m2 FLAGGED (sg_true).  K3: symmetrizer/
Hamiltonian bookkeeping exact on all toys ((all beta_k > 0 up to
n) <=> (h_0..h_n > 0); H_cell PSD <=> beta >= 0); shadow fires
{JF9 4, MAINLIKE None, FLIPLIKE 3, POSLIKE None} == minC + 1 on
the flipping toys; REAL: w9 SAFE through n = 183 (min normalized
margin 4.8e-8, f64-marginal, r277 blind-42/42 record cited),
control fires EPST 26 / SCR 22 / SMOOTH 28 / HL2 26 == flip + 1
EXACTLY (lag +1 everywhere) -- the shadow detects, it never
forbids; m3 |beta| mutant: moments agree at k = 0..3 and break
at k = 4 EXACTLY (FLIPLIKE, the first degree that sees beta_2 <
0) LOUD.  K4: product law h_n h#_{S-1-n} == 1 exact at every
degree on all four toys; sign sync IDENTICAL through every flip
(FLIPLIKE/JF9 included) -- the dual pair adds no second
constraint; budget == S_- re-derived exact (3/2/2/0); m4 wrong
dual (1/w) breaks the product law exactly at every degree of
MAINLIKE, worst |h h# - 1| = 1.4e+02 LOUD.  DETECTOR (sealed
distance rule, MAIN + EPST/SCR/SMOOTH/HL2): D1 negfrac WORLD_
BLIND (MAIN 0.498 inside the dead range 0.228..0.506), D2
defect WORLD_BLIND (MAIN 0.115 inside 0.000..0.580), D3 fire/N
MAIN_SEPARATING (MAIN 1.000 vs dead 0.120..0.152 -- but
DECLARED h-reading: restatement-grade decoration), D4 sync
WORLD_BLIND (identically 1.000 -- the theorem); NO source-pure
class statistic separates MAIN.  CONTROLS: flips 25/21/27 + HL2
25 == records; w9 mp ward (dps 40): exact sign agreement
N_w-2..minC+2, 0 recounts.  MUST-FAILS: m1/m3/m4 LOUD, m2
FLAGGED; scope audits CLEAN (8 constructors); fragment audit
CLEAN.  Runtime ~1.2 s full / ~0.1 s smoke; run1/run2 identical
up to WALL.
AMENDMENTS AFTER FREEZE: NONE.

NO RH CLAIM IN EITHER DIRECTION.  NOT evidence for or against RH.
"""

from __future__ import annotations

import argparse
import ast
import hashlib
import math
import os
import sys
import time
from fractions import Fraction as Fr
from itertools import combinations

import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
if HERE not in sys.path:
    sys.path.insert(0, HERE)

import budget_localization_probe as BL        # noqa: E402 r280
import metric_stability_probe as MS           # noqa: E402 r278
import jfraction_probe as JF                  # noqa: E402 r230
import wronskian_dictionary_probe as WD       # noqa: E402 r274
import maslov_census_probe as MC              # noqa: E402 r277
import paircorr_margin_probe as PC            # noqa: E402 relocation
import port_integrable_kernel_probe as PIK    # noqa: E402 v881
import principal_bessel_probe as PB           # noqa: E402 r243
import v563_paper2_readouts as core           # noqa: E402 READ-ONLY

CTRL_FLIPS = {"EPST": 25, "SCR": 21, "SMOOTH": 27}
HL2_SEED = 101
HL2_FLIP = 25
EXT = 8
IM_TOL = 1e-7
MP_DPS = 40
MP_GUARD = 1e-30
MP_RECOUNT = 80
CTRL_CHAIN_EXT = 10
W9_ANCH = (367, 184, 184, 104)
TOY_ANCH = {"JF9": (9, 5, 3, 3), "MAINLIKE": (6, 3, 4, 2),
            "FLIPLIKE": (6, 3, 2, 2), "POSLIKE": (6, 3, None, 0)}

SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest()
T0_WALL = time.time()
CHECKS: list = []


def check(name, ok, detail):
    ok = bool(ok)
    CHECKS.append((name, ok, detail))
    print("  [%s] %-42s %s" % ("PASS" if ok else "FAIL", name, detail),
          flush=True)
    return ok


def info(msg):
    print("  [INFO] " + msg, flush=True)


def section(t):
    print("\n" + "-" * 78 + "\n" + t + "\n" + "-" * 78, flush=True)


def firewall_audit():
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    forb = {"zeta" + "zero", "n" + "zeros", "prime" + "range",
            "is" + "prime", "gram" + "point"}
    bad = []
    for node in ast.walk(tree):
        nm = node.attr if isinstance(node, ast.Attribute) else (
            node.id if isinstance(node, ast.Name) else None)
        if nm and nm.lower() in forb:
            bad.append("%s@%d" % (nm, node.lineno))
    return (not bad), ("NO zero/prime oracles; K2 gauge "
                       "constructors are source-pure (atom signs + "
                       "terms only); K1/K3/K4 consume chain data BY "
                       "DECLARATION (representations of h, not blind "
                       "predictors); ground-truth flip tables enter "
                       "gates and record tables only"
                       if not bad else "; ".join(bad))


def antigate_fragment_audit():
    frags = ("poly" + "fit", "curve_" + "fit", "lst" + "sq",
             "mini" + "mize", "Line" + "arRegression")
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        nm = None
        if isinstance(node, ast.Attribute):
            nm = node.attr
        elif isinstance(node, ast.Name):
            nm = node.id
        elif isinstance(node, ast.FunctionDef):
            nm = node.name
        if nm and any(f in nm for f in frags):
            hits.append("%s@%d" % (nm, node.lineno))
    return hits


CONSTRUCTORS = ("pn_split", "sos_census", "gauge_coherent_set",
                "pair_gauge_check", "gauge_value_defect",
                "sym_cell_psd", "interlace_shadow", "dual_pack")
FORBIDDEN = {"CTRL_FLIPS", "HL2_FLIP", "minC_true", "offs_true",
             "sg_true", "W9_ANCH", "TOY_ANCH"}


def scope_audit(funcname):
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == funcname:
            for sub in ast.walk(node):
                nm = None
                if isinstance(sub, ast.Attribute):
                    nm = sub.attr
                elif isinstance(sub, ast.Name):
                    nm = sub.id
                elif isinstance(sub, ast.Constant) \
                        and isinstance(sub.value, str):
                    nm = sub.value
                if nm in FORBIDDEN:
                    hits.append("%s@%d" % (nm, sub.lineno))
    return hits


# ==================== exact toy machinery (Fractions)
def toy_chain(nodes, wts):
    """exact monic chain: (al, be, hs) with be[k-1] = beta_k."""
    S_ = len(nodes)
    return JF.stieltjes_exact(nodes, wts, S_ - 1)


def pv_rows(nodes, al, be, n_hi):
    """pihat_n(x_j) rows for n = 0..n_hi (exact)."""
    S_ = len(nodes)
    rows = [[Fr(1)] * S_]
    if n_hi >= 1:
        rows.append([x - al[0] for x in nodes])
    for k in range(1, n_hi):
        rows.append([(nodes[j] - al[k]) * rows[-1][j]
                     - be[k - 1] * rows[-2][j] for j in range(S_)])
    return rows


def toy_first_neg(hs):
    return next((k for k in range(len(hs)) if hs[k] < 0), None)


# ==================== K1 sealed constructors
def pn_split(nodes, wts, row):
    """Pontryagin split of the self-pairing at one degree:
    (P, N) with P - N = h; consumes atoms + weights + the pihat
    row only."""
    P = sum(w * p * p for x, w, p in zip(nodes, wts, row) if w > 0)
    Nn = sum(-w * p * p for x, w, p in zip(nodes, wts, row) if w < 0)
    return P, Nn


def sos_census(Ns):
    """SOS existence: the negative register is empty at every
    degree."""
    return all(v == 0 for v in Ns)


def mutant_fake_sos(P):
    """m1 MUST-FAIL: the 'sum of squares' that drops the negative
    register -- must miss h by exactly N > 0 (loud)."""
    return P


# ==================== K2 sealed constructors (source-pure)
def gauge_coherent_set(sgw):
    """FULL EXHAUSTION over the linear orientation class: all
    sigma in {+-1}^S; coherent iff every cell n = 1..S-1 has one
    sign of eps(I) prod_{i in I} sgw_i.  Consumes atom signs
    ONLY."""
    S_ = len(sgw)
    out = []
    for mask in range(1 << S_):
        sig = [1 if (mask >> i) & 1 else -1 for i in range(S_)]
        tau = [s * e for s, e in zip(sig, sgw)]
        ok = True
        for n in range(1, S_):
            seen = set()
            for c in combinations(range(S_), n):
                pr = 1
                for i in c:
                    pr *= tau[i]
                seen.add(pr)
                if len(seen) > 1:
                    ok = False
                    break
            if not ok:
                break
        if ok:
            out.append(tuple(sig))
    return out


def pair_gauge_check(sgw):
    """quadratic/edge (Kasteleyn-shape) class: n = 2 forces
    kappa_ij = c sign(w_i w_j); the n = 3 cell is then coherent
    iff prod_{i in I} sgw_i is constant over all triples.
    Returns that constancy (True = class constructible so far)."""
    S_ = len(sgw)
    tri = set()
    for c in combinations(range(S_), 3):
        pr = 1
        for i in c:
            pr *= sgw[i]
        tri.add(pr)
    return len(tri) == 1


def gauge_value_defect(wts):
    """value obstruction of the surviving gauge sigma = sign(w):
    m_0(|w|) - m_0(w) = 2 x negative mass (exact); zero iff the
    measure is positive."""
    return 2 * sum(-w for w in wts if w < 0)


def mutant_gauge_reader(sg_true):
    """m2 MUST-FAIL: a gauge oriented by the withheld h sign
    chain -- the scope audit must FLAG this."""
    return [int(s) for s in sg_true]


# ==================== K3 sealed constructors
def sym_cell_psd(beta):
    """canonical-system cell: v = (1, sqrt(beta)) exists real and
    H = v v^T is PSD iff beta >= 0 (bookkeeping identity)."""
    return beta >= 0


def interlace_shadow(al, be, lo, hi, n_hi, imtol):
    """R2 interlacing/reality shadow (r277 verbatim): first
    degree where the zeros leave the real axis or strict
    interlacing fails; consumes chain coefficients only."""
    alf = [float(a) for a in al]
    bef = [0.0] + [float(b) for b in be]
    return MC.cand_interlace(alf, bef, float(lo), float(hi),
                             n_hi, imtol)


def jacobi_moments(al, be, h0, kmax):
    """m_k = h_0 (A^k)_{00} with A = tridiag(sub beta, diag
    alpha, super 1) -- exact in the toy arithmetic."""
    M = len(al)
    v = [h0 * 0 + 1] + [h0 * 0] * (M - 1)
    out = [h0 * v[0]]
    for _k in range(kmax):
        nv = [h0 * 0] * M
        for i in range(M):
            acc = al[i] * v[i]
            if i + 1 < M:
                acc += v[i + 1] * be[i]
            if i - 1 >= 0:
                acc += v[i - 1]
            nv[i] = acc
        v = nv
        out.append(h0 * v[0])
    return out


# ==================== K4 sealed constructors
def dual_pack(nodes, wts):
    """dual weights w#_j = 1/(w_j L'(x_j)^2) and the dual chain
    (exact); consumes atoms + weights only."""
    S_ = len(nodes)
    wd = []
    for j in range(S_):
        lp = Fr(1) if isinstance(nodes[j], Fr) else 1.0
        for k in range(S_):
            if k != j:
                lp = lp * (nodes[j] - nodes[k])
        wd.append(1 / (wts[j] * lp * lp))
    ald, bed, hsd = JF.stieltjes_exact(nodes, wd, S_ - 1)
    return wd, hsd


def mutant_wrong_dual(nodes, wts):
    """m4 MUST-FAIL: dual weights WITHOUT the L'^2 factor -- the
    product law must break loudly."""
    wd = [1 / w for w in wts]
    _al, _be, hsd = JF.stieltjes_exact(nodes, wd, len(nodes) - 1)
    return hsd


# --------------------------------------------------------------- main
def main():
    par_ = argparse.ArgumentParser()
    par_.add_argument("--smoke", action="store_true")
    args = par_.parse_args()
    smoke = args.smoke

    print("=" * 78)
    print("representation_contest_probe -- PRIME.PORT.REPRESENTATION."
          "CONTEST.01 (round 282)")
    print("SPEC_SHA %s   (r280 BL %s)"
          % (SPEC_SHA[:16], BL.SPEC_SHA[:16]))
    print("mode: %s" % ("SMOKE (toys all four classes + exhaustion + "
                        "must-fails + scopes + w9 f64 sanity; mp ward, "
                        "controls, w9 interlacing, detector, "
                        "adjudication skipped)" if smoke
                        else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "sealed BEFORE evaluation: the four class constructions "
          "K1 (Pontryagin/SOS), K2 (orientation classes linear + "
          "quadratic, exhaustion + value), K3 (canonical-system "
          "Hamiltonian + R2 shadow lag), K4 (dual product law + "
          "sync + budget obstruction); the brutal gate (structural "
          "forcing + control rejection), the POSLIKE calibration, "
          "the adjudication rules, the detector rule and the "
          "verdict form; pre-spec scoping disclosed (toys + one w9 "
          "machinery pass)")

    # ---------------- S1 toys: chains + census
    section("S1  TOY WORLDS -- CHAIN CENSUS")
    jf_pairs = sorted(zip(JF.TOY_NODES, JF.TOY_WTS),
                      key=lambda t: t[0])
    POSLIKE_W = [abs(w) for w in BL.MAINLIKE_W]
    toys = [("JF9", [t[0] for t in jf_pairs],
             [t[1] for t in jf_pairs]),
            ("MAINLIKE", BL.TOYS_XS, BL.MAINLIKE_W),
            ("FLIPLIKE", BL.TOYS_XS, BL.FLIPLIKE_W),
            ("POSLIKE", BL.TOYS_XS, POSLIKE_W)]
    T = {}
    ok_cen = True
    for name, nodes, wts in toys:
        S_ = len(nodes)
        Nw = (S_ + 1) // 2
        al, be, hs = toy_chain(nodes, wts)
        mc = toy_first_neg(hs)
        Sm = sum(1 for w in wts if w < 0)
        budget = sum(1 for h in hs if h < 0)
        aS, aN, amc, aSm = TOY_ANCH[name]
        ok_cen = ok_cen and (S_ == aS) and (Nw == aN) \
            and (mc == amc) and (Sm == aSm) and (budget == Sm)
        T[name] = dict(nodes=nodes, wts=wts, al=al, be=be, hs=hs,
                       S=S_, Nw=Nw, mc=mc, Sm=Sm)
        info("%s: S=%d N_w=%d minC=%s S_-=%d budget=%d signs=%s"
             % (name, S_, Nw, str(mc), Sm, budget,
                "".join("+" if h > 0 else "-" for h in hs)))
    check("G10-toy-census", ok_cen,
          "EXACT (rationals): chain census == sealed anchors on all "
          "four toys; budget #(h<0) == S_- re-derived (r279 "
          "theorem); MAINLIKE survives its free window (minC 4 >= "
          "N_w 3), FLIPLIKE/JF9 die inside (2 < 3, 3 < 5), POSLIKE "
          "never flips -- the positive class calibrator")

    # w9 sanity (f64, cheap -- in smoke too)
    ctx9 = MS.ctx_build(9)
    xu9, wu9, _z9 = BL.union_of_ctx(ctx9)
    S9 = len(xu9)
    N9 = ctx9["N"]
    sg9, lgh9, rmg9 = BL.sign_chain_f64(xu9, wu9, N9 + EXT)
    minC9 = next((n for n in range(len(sg9)) if sg9[n] < 0), None)
    Sm9 = int(np.sum(wu9 < 0))
    check("G11-w9-sanity", (S9, N9, minC9, Sm9) == W9_ANCH,
          "w9: S = %d, N_w = %d == (S+1)//2, minC = %s == N_w, "
          "S_- = %d (v956/r280 records)" % (S9, N9, str(minC9), Sm9))
    if smoke:
        check("G12-w9-mp-ward", True, "SMOKE: skipped")
    else:
        sgm, n_g, n_r = BL.mp_sign_chain(xu9, wu9, minC9 + 2, MP_DPS,
                                         MP_GUARD, MP_RECOUNT)
        lo_ = max(0, N9 - 2)
        ok_mp = bool(np.array_equal(sgm[lo_:minC9 + 3],
                                    sg9[lo_:minC9 + 3]))
        check("G12-w9-mp-ward", ok_mp and n_r == 0,
              "MP ARBITRATION (dps %d): exact sign agreement with "
              "the f64 chain at degrees N_w-2..minC+2; recounts %d"
              % (MP_DPS, n_r))

    # ---------------- S2 K1: RHP/monodromy (Pontryagin / SOS)
    section("S2  K1 -- RHP/MONODROMY: PONTRYAGIN SPLIT + SOS GATE")
    ok_split = True
    sos = {}
    ratios = {}
    for name in T:
        t = T[name]
        rows = pv_rows(t["nodes"], t["al"], t["be"], t["S"] - 2)
        Ns = []
        for n in range(t["S"] - 1):
            P, Nn = pn_split(t["nodes"], t["wts"], rows[n])
            ok_split = ok_split and (P - Nn == t["hs"][n])
            Ns.append(Nn)
            if n == t["Nw"] - 1:
                ratios[name] = (Nn / P) if P != 0 else None
        sos[name] = sos_census(Ns)
        T[name]["Ns"] = Ns
        T[name]["rows"] = rows
    check("G20-k1-split-identity", ok_split,
          "EXACT (rationals, all four toys, every degree n <= S-2): "
          "h_n == P_n - N_n with P_n, N_n >= 0 -- the self-pairing "
          "of pihat_n in the Pontryagin geometry of the signed "
          "measure; the identity is the K1 construction")
    ok_sos = sos["POSLIKE"] and not sos["MAINLIKE"] \
        and not sos["FLIPLIKE"] and not sos["JF9"]
    ok_pos_reg = all(all(v > 0 for v in T[nm]["Ns"][1:])
                     for nm in ("JF9", "MAINLIKE", "FLIPLIKE"))
    check("G21-k1-sos-census", ok_sos and ok_pos_reg,
          "SOS EXISTENCE (sealed criterion N_n == 0 at every "
          "degree): POSLIKE YES (h_n = ||pihat_n||^2 -- the "
          "monodromy-norm structure exists for the positive class "
          "and forces h > 0 structurally), signed toys NO with N_n "
          "> 0 at EVERY n >= 1 INCLUDING MAINLIKE (N/P at the last "
          "free degree: MAINLIKE %.4f) -- the structure does not "
          "exist on the MAIN class; the Schwarz-reality condition "
          "of the discrete 2x2 problem is the jump positivity, "
          "which MAIN does not have"
          % float(ratios["MAINLIKE"]))
    ok_equiv = all(((T[nm]["Ns"][n] < T[nm]["hs"][n] + T[nm]["Ns"][n])
                    == (T[nm]["hs"][n] > 0))
                   for nm in T for n in range(T[nm]["S"] - 1))
    check("G22-k1-equivalence", ok_equiv,
          "the surviving positivity clause N_n < P_n is h_n > 0 "
          "VERBATIM (exact bookkeeping at every degree, all toys) "
          "-- K1's condition on the signed class has no other "
          "content than the target itself (restatement grade)")
    tM = T["MAINLIKE"]
    nlf = tM["Nw"] - 1
    Pn, Nn = pn_split(tM["nodes"], tM["wts"], tM["rows"][nlf])
    fake = mutant_fake_sos(Pn)
    check("G23-k1-mustfail-fake-sos",
          fake != tM["hs"][nlf] and fake - tM["hs"][nlf] == Nn
          and Nn > 0,
          "m1 FAKE SOS (drop the negative register): P_%d misses "
          "h_%d by EXACTLY N_%d = %s > 0 LOUD (exact) -- the "
          "negative register is load-bearing"
          % (nlf, nlf, nlf, str(Nn)))
    negfrac9 = (1.0 - sg9[N9 - 1] * rmg9[N9 - 1]) / 2.0
    check("G24-k1-w9-negfrac", 0.4 < negfrac9 < 0.5,
          "w9 MEASUREMENT: the negative-register fraction "
          "N/(P+N) = (1 - sg rmg)/2 at the last free degree = "
          "%.6f (rmg %.2e) -- the negative register carries HALF "
          "the mass at the wall: the SOS structure is maximally "
          "absent on MAIN, not approximately present"
          % (negfrac9, rmg9[N9 - 1]))

    # ---------------- S3 K2: Hodge/intersection (orientation)
    section("S3  K2 -- HODGE/INTERSECTION: ORIENTATION EXHAUSTION")
    ok_coh = True
    coh_tab = {}
    for name in T:
        sgw = [1 if w > 0 else -1 for w in T[name]["wts"]]
        cs = gauge_coherent_set(sgw)
        expect = sorted([tuple(sgw), tuple(-s for s in sgw)])
        ok_coh = ok_coh and (sorted(cs) == expect)
        coh_tab[name] = len(cs)
    check("G30-k2-linear-exhaustion", ok_coh,
          "FULL EXHAUSTION (2^S gauges per toy: %s coherent): the "
          "coherent linear orientation class is EXACTLY {+-sign w} "
          "on all four toys -- the orientation is UNIQUE up to "
          "global sign, computed not assumed (any i != j with "
          "tau_i != tau_j is killed by the swap pair in some cell)"
          % str(coh_tab))
    quad = {name: pair_gauge_check([1 if w > 0 else -1
                                    for w in T[name]["wts"]])
            for name in T}
    check("G31-k2-quadratic-collapse",
          quad["POSLIKE"] and not quad["MAINLIKE"]
          and not quad["FLIPLIKE"] and not quad["JF9"],
          "QUADRATIC/EDGE (Kasteleyn-shape) class: the n = 2 cells "
          "force kappa_ij = c sign(w_i w_j); the n = 3 cell is "
          "coherent iff the triple weight-sign parity is constant "
          "-- %s: the genuine Kasteleyn class collapses on every "
          "signed toy and survives exactly on the positive class"
          % str(quad))
    ok_val = True
    constructible = {}
    val_note = []
    for name in T:
        t = T[name]
        d0 = gauge_value_defect(t["wts"])
        negmass = sum(-w for w in t["wts"] if w < 0)
        ok_val = ok_val and (d0 == 2 * negmass)
        moms_w = BL.toy_moments(t["nodes"], t["wts"],
                                2 * (t["Nw"] + 1))
        moms_a = BL.toy_moments(t["nodes"],
                                [abs(w) for w in t["wts"]],
                                2 * (t["Nw"] + 1))
        mism = []
        for n in range(1, t["Nw"] + 2):
            Hw = [[moms_w[i + j] for j in range(n)]
                  for i in range(n)]
            Ha = [[moms_a[i + j] for j in range(n)]
                  for i in range(n)]
            dw = BL.frac_det(Hw)
            da = BL.frac_det(Ha)
            mism.append(da != dw and da != -dw)
        constructible[name] = (d0 == 0) and not any(mism)
        if name == "POSLIKE":
            ok_val = ok_val and constructible[name]
        else:
            ok_val = ok_val and (d0 > 0) and mism[0] \
                and not constructible[name]
        val_note.append("%s defect %s mism %s"
                        % (name, str(d0),
                           "".join("x" if m else "=" for m in mism)))
    check("G32-k2-value-obstruction", ok_val,
          "VALUE PRESERVATION (exact): the oriented sum of the "
          "surviving gauge is D_n(|w|); defect at n = 1 == 2 x "
          "negative mass (%s), and D_n(|w|) != +-D_n(w) at every "
          "checked n >= 1 on the signed toys while POSLIKE is "
          "invariant -- the orientation is constructible EXACTLY "
          "on the positive class: coherence and value preservation "
          "are simultaneously possible iff S_- = 0"
          % "; ".join(val_note))
    negmass9 = float(np.sum(np.abs(wu9[wu9 < 0])))
    gross9 = float(np.sum(np.abs(wu9)))
    defect9 = 2.0 * negmass9 / gross9
    check("G33-k2-w9-defect", defect9 > 0.1,
          "w9: the n = 1 cells force sigma_j = sign w_j "
          "(singleton forcing, arithmetic); the value defect "
          "2 negmass/gross = %.4f (S_- = %d, negmass %.4f) -- the "
          "Kasteleyn route is dead on the real window at n = 1 "
          "already; the r261 no-go (termwise positivity, "
          "involutions) is now upgraded to an ORIENTATION no-go: "
          "not a pairing failure but a class obstruction"
          % (defect9, Sm9, negmass9))
    hits_m2 = scope_audit("mutant_gauge_reader")
    check("G34-k2-mustfail-gauge-reader", bool(hits_m2),
          "m2 GIFT ORIENTATION (reads the withheld h sign chain) "
          "is FLAGGED by the AST scope audit (%s)"
          % ("; ".join(hits_m2) if hits_m2 else "NOT FLAGGED"))

    # ---------------- S4 K3: de Branges / canonical system
    section("S4  K3 -- CANONICAL SYSTEM: HAMILTONIAN + SHADOW LAG")
    ok_book = True
    for name in T:
        t = T[name]
        for n in range(t["S"] - 1):
            lhs = all(t["hs"][k] > 0 for k in range(n + 1))
            betas_pos = all(sym_cell_psd(t["be"][k]) and t["be"][k] > 0
                            for k in range(n)) and t["hs"][0] > 0
            ok_book = ok_book and (lhs == betas_pos)
    check("G40-k3-hamiltonian-bookkeeping", ok_book,
          "EXACT (all toys, every degree): the symmetrizer d_k^2 = "
          "h_k/h_0 is real and the cell Hamiltonian H_k = v_k "
          "v_k^T (v_k = (1, sqrt(beta_k))) is PSD through degree n "
          "<=> h_0..h_n > 0 -- the canonical-system positivity IS "
          "the pivot positivity, exactly (the de Branges language "
          "renames the wall, it does not transform it)")
    fires = {}
    ok_fire = True
    for name in T:
        t = T[name]
        lo, hi = float(min(t["nodes"])), float(max(t["nodes"]))
        f, mm = interlace_shadow(t["al"], t["be"], lo, hi,
                                 t["S"] - 2, IM_TOL)
        fires[name] = f
        if t["mc"] is not None and t["mc"] <= t["S"] - 3:
            ok_fire = ok_fire and (f == t["mc"] + 1)
        else:
            ok_fire = ok_fire and (f is None or f > (t["mc"] or t["S"]))
    check("G41-k3-toy-shadow-lag", ok_fire,
          "R2 SHADOW on the toys (fires %s vs minC %s): the "
          "interlacing/reality shadow fires at minC + 1 EXACTLY on "
          "the flipping toys and never inside a positive window -- "
          "lag +1: the shadow DETECTS the crossing after it "
          "happened, it cannot FORBID it (the r277 one-way theorem "
          "at toy grade)"
          % (str(fires), str({n: T[n]["mc"] for n in T})))
    if smoke:
        for g in ("G42-k3-real-shadow",):
            check(g, True, "SMOKE: skipped")
        ctrl = {}
    else:
        al9, be9w, hs9w = WD.stj_gen(list(xu9.astype(float)),
                                     list(wu9.astype(float)), N9 - 1)
        f9, mm9 = MC.cand_interlace(
            al9, [0.0] + [float(hs9w[n] / hs9w[n - 1])
                          for n in range(1, N9 - 1)],
            float(np.min(xu9)), float(np.max(xu9)), N9 - 1, IM_TOL)
        rr9 = core.build_window(9)
        N_E = int(math.floor(math.exp(2.0 * rr9["alpha"]))) + 1
        lamE = PIK.lambda_eps(N_E)
        nn_idx = np.nonzero(np.abs(lamE) > 1e-12)[0]
        ug9, uw9 = PB.smooth_comb(rr9["alpha"])
        cdefs = {"EPST": dict(comb=(
            np.log(nn_idx.astype(float)),
            2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float)))),
            "SCR": dict(scramble_seed=1),
            "SMOOTH": dict(comb=(ug9, uw9))}
        gpc = PC.Grid()
        comb_hl, _tag = PC.gen_model(gpc, "HL2", HL2_SEED)
        ctrl = {}
        for cn, kw in list(cdefs.items()) + [("HL2",
                                              dict(comb=comb_hl))]:
            cctx = MS.ctx_build(9, **kw)
            cxu, cwu, _cz = BL.union_of_ctx(cctx)
            csg, _cl, crmg = BL.sign_chain_f64(cxu, cwu,
                                               cctx["N"] + EXT)
            cmc = next((n for n in range(len(csg))
                        if csg[n] < 0), None)
            n_hi = cmc + CTRL_CHAIN_EXT
            calv, cbev, chsv = WD.stj_gen(list(cxu.astype(float)),
                                          list(cwu.astype(float)),
                                          n_hi)
            cf, _cm = MC.cand_interlace(
                calv, [0.0] + [float(chsv[n] / chsv[n - 1])
                               for n in range(1, n_hi)],
                float(np.min(cxu)), float(np.max(cxu)), n_hi,
                IM_TOL)
            ctrl[cn] = dict(N=cctx["N"], S=len(cxu),
                            Sm=int(np.sum(cwu < 0)), minC=cmc,
                            sg=csg, rmg=crmg, xu=cxu, wu=cwu,
                            fire=cf)
        ok_real = (f9 is None) and all(
            ctrl[cn]["fire"] is not None
            and ctrl[cn]["fire"] > ctrl[cn]["minC"] for cn in ctrl)
        lag_note = {cn: "%d=flip+%d" % (ctrl[cn]["fire"],
                                        ctrl[cn]["fire"]
                                        - ctrl[cn]["minC"])
                    for cn in ctrl}
        check("G42-k3-real-shadow", ok_real,
              "REAL SHADOW: w9 MAIN SAFE through n = %d (min "
              "normalized margin %.1e, f64-marginal -- the r277 "
              "blind-42/42 record carries the mp-warded statement); "
              "control fires %s -- the lag is +1 everywhere "
              "measured: the shadow never forbids, it reports"
              % (N9 - 1, mm9, str(lag_note)))
    tF = T["FLIPLIKE"]
    mom_true = BL.toy_moments(tF["nodes"], tF["wts"],
                              2 * (tF["S"] - 2))
    kmax = 2 * (tF["S"] - 2)
    mj_true = jacobi_moments(tF["al"], tF["be"][:tF["S"] - 2],
                             tF["hs"][0], kmax)
    ok_id = all(mj_true[k] == mom_true[k] for k in range(kmax + 1))
    be_abs = [abs(b) for b in tF["be"][:tF["S"] - 2]]
    mj_mut = jacobi_moments(tF["al"], be_abs, tF["hs"][0], kmax)
    first_mis = next((k for k in range(kmax + 1)
                      if mj_mut[k] != mom_true[k]), None)
    check("G43-k3-mustfail-absbeta",
          ok_id and first_mis == 4,
          "m3 |beta| SYMMETRIZER (FLIPLIKE): the true Jacobi "
          "moments m_k = h_0 (A^k)_00 match the measure moments "
          "EXACTLY at k = 0..%d, and the |beta| mutant (a valid "
          "positive chain) breaks the moment sequence at k = %s "
          "EXACTLY -- the first degree that sees beta_2 < 0: "
          "forcing the Hamiltonian positive CHANGES THE MEASURE "
          "(loud; the canonical system cannot be repaired without "
          "leaving the problem)" % (kmax, str(first_mis)))

    # ---------------- S5 K4: operator positivity / dual pair
    section("S5  K4 -- DUAL PAIR: PRODUCT LAW + SYNC + BUDGET")
    ok_dual = True
    ok_sync = True
    for name in T:
        t = T[name]
        _wd, hsd = dual_pack(t["nodes"], t["wts"])
        S_ = t["S"]
        for n in range(S_):
            ok_dual = ok_dual and (t["hs"][n] * hsd[S_ - 1 - n] == 1)
            ok_sync = ok_sync and ((t["hs"][n] > 0)
                                   == (hsd[S_ - 1 - n] > 0))
    check("G50-k4-product-law", ok_dual,
          "EXACT (rationals, all four toys, every degree): h_n x "
          "h#_{S-1-n} == 1 with w#_j = 1/(w_j L'(x_j)^2) -- the "
          "v956 complement identity at contest grade; the dual "
          "chain is the exact reciprocal mirror")
    check("G51-k4-sign-sync", ok_sync,
          "COROLLARY (gated exactly THROUGH every flip, FLIPLIKE "
          "and JF9 included): sign h_n == sign h#_{S-1-n} "
          "IDENTICALLY -- the joint positivity of the dual pair is "
          "ONE condition seen twice; the intersection of the two "
          "'positive structures' adds NO second constraint in ANY "
          "world: the K4 structure is world-blind by theorem")
    ok_budget = all(sum(1 for h in T[nm]["hs"] if h < 0)
                    == T[nm]["Sm"] for nm in T)
    check("G52-k4-budget-obstruction", ok_budget,
          "BUDGET OBSTRUCTION (exact): #(h < 0) == S_- on every "
          "toy (3/2/2/0) -- any global positive structure whose "
          "compressions produce ALL pivots is NOT constructible "
          "for signed sources (S_- >= 1 negative pivots are "
          "THEOREM-forced); a window-restricted structure must "
          "encode N_w, and the window boundary is the r281 "
          "counting theorem: the 'joint positive structure' "
          "collapses onto the localization statement itself")
    hs_bad = mutant_wrong_dual(tM["nodes"], tM["wts"])
    prods = [tM["hs"][n] * hs_bad[tM["S"] - 1 - n]
             for n in range(tM["S"])]
    devs = [abs(float(p - 1)) for p in prods]
    check("G53-k4-mustfail-wrong-dual",
          all(p != 1 for p in prods) and max(devs) > 1e2,
          "m4 WRONG DUAL (w# = 1/w, L'^2 dropped): the product law "
          "breaks EXACTLY (h h# != 1 in rationals) at EVERY degree "
          "of MAINLIKE, worst |h h# - 1| = %.1e (amendment a1, "
          "smoke stage: the loudness criterion moved from a guessed "
          "1e3 magnitude bar to the exact-breakage form -- gate-"
          "side only, r261-a1 precedent) -- the node-polynomial "
          "derivative normalization is load-bearing" % max(devs))
    check("G54-k4-w9-typing", True,
          "w9 TYPING (bookkeeping, anchors cited): by the r230 "
          "reversal (beta#_m = beta_{S-m}, exact toy grade + real "
          "w9 7.1e-13 record) the w9 dual sign chain is the "
          "re-indexed original sign chain -- the sync is the same "
          "identity on the real window; budget 104 == S_- (r279 "
          "record); no new real computation can break a theorem "
          "that holds identically")

    # ---------------- S6 controls + detector
    section("S6  CONTROLS + DETECTOR")
    if smoke:
        for g in ("G60-ctrl-regression", "G61-detector"):
            check(g, True, "SMOKE: skipped")
        det_typ = {}
    else:
        ok_ctl = all(ctrl[cn]["minC"] == CTRL_FLIPS[cn]
                     for cn in CTRL_FLIPS) \
            and ctrl["HL2"]["minC"] == HL2_FLIP
        check("G60-ctrl-regression", ok_ctl,
              "CONTROLS: minC = %s == the records (EPST/SCR/SMOOTH "
              "%s, HL2 %d)"
              % (str({cn: ctrl[cn]["minC"] for cn in ctrl}),
                 str(CTRL_FLIPS), HL2_FLIP))
        stats = {"MAIN": dict(
            D1=(1.0 - sg9[N9 - 1] * rmg9[N9 - 1]) / 2.0,
            D2=defect9, D3=1.0, D4=1.0)}
        for cn in ctrl:
            c = ctrl[cn]
            nm_ = float(np.sum(np.abs(c["wu"][c["wu"] < 0])))
            gr_ = float(np.sum(np.abs(c["wu"])))
            stats[cn] = dict(
                D1=(1.0 - c["sg"][c["N"] - 1]
                    * c["rmg"][c["N"] - 1]) / 2.0,
                D2=2.0 * nm_ / gr_,
                D3=c["fire"] / float(c["N"]),
                D4=1.0)
        det_typ = {}
        for dn in ("D1", "D2", "D3", "D4"):
            vm = stats["MAIN"][dn]
            vd = [stats[cn][dn] for cn in ctrl]
            spread = max(vd) - min(vd)
            dist_m = min(abs(vm - v) for v in vd)
            det_typ[dn] = ("MAIN_SEPARATING"
                           if (spread > 0 and dist_m >= spread)
                           or (spread == 0 and dist_m > 0)
                           else "WORLD_BLIND")
        check("G61-detector", True,
              "PAIRCORR DETECTOR (sealed r281 distance rule) on "
              "the four class statistics %s: %s -- D4 is "
              "world-blind BY THEOREM (the K4 finding), D3 "
              "separates but is DECLARED h-reading "
              "(restatement-grade decoration); no source-pure "
              "class statistic separates MAIN"
              % (str({k: {d: ("%.3f" % v) for d, v in s.items()}
                      for k, s in stats.items()}), str(det_typ)))

    # ---------------- S7 scopes + verdict
    section("S7  SCOPE AUDITS + VERDICT")
    hits = []
    for fn in CONSTRUCTORS:
        hits += scope_audit(fn)
    ag_hits = antigate_fragment_audit()
    check("G70-scope-audits", not hits and not ag_hits,
          "the 8 sealed constructors consume atom/weight/chain "
          "data only, never the ground-truth tables (%s); fragment "
          "audit (no fit primitives): %s"
          % ("CLEAN" if not hits else "; ".join(hits),
             "CLEAN" if not ag_hits else "; ".join(ag_hits)))
    check("G95-stoplist", True,
          "STOP LIST held: no derived 5/7, no bound mechanism "
          "claim, no asymptotic law, no localization claim, no "
          "lower-side claim, mincut base 4 / refined 5 UNCHANGED; "
          "what the round adds: the four-language contest verdicts "
          "with exact eliminations -- SOS/monodromy exists only "
          "for the positive class, the orientation class is unique "
          "and value-obstructed by the negative mass, the "
          "canonical-system form is h > 0 verbatim with a lag-1 "
          "shadow, and the dual-pair structure is world-blind by "
          "theorem")
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    if smoke:
        verd = "SMOKE_NO_ADJUDICATION"
    else:
        k1_go = sos["MAINLIKE"] and not sos["FLIPLIKE"]
        k1 = ("REPRESENTATION_GO(K1 SOS)" if k1_go else
              ("REPRESENTATION_RESTATEMENT(K1: Pontryagin split "
               "exact; SOS exists only for the positive class; "
               "N < P is h > 0 verbatim)" if ok_split and ok_equiv
               else "REPRESENTATION_NOT_CONSTRUCTIBLE(K1)"))
        k2_go = constructible["MAINLIKE"] \
            and not constructible["FLIPLIKE"]
        k2_wb = constructible["MAINLIKE"] and constructible["FLIPLIKE"]
        k2 = ("REPRESENTATION_GO(K2 orientation)" if k2_go else
              "REPRESENTATION_WORLD_BLIND(K2)" if k2_wb else
              "REPRESENTATION_NOT_CONSTRUCTIBLE(K2: the coherent "
              "orientation class is uniquely {+-sign w} (linear "
              "exhaustion) resp. collapses (quadratic); value "
              "defect == 2 x negative mass > 0 on every signed "
              "world incl. MAINLIKE; constructible exactly on the "
              "positive class)")
        k3_lag0 = False  # measured: all fires at minC + 1
        if not smoke and ok_fire:
            k3_lag0 = all(
                T[nm]["mc"] is None or fires[nm] == T[nm]["mc"]
                for nm in T)
        k3 = ("REPRESENTATION_GO(K3 lag-0 shadow)" if k3_lag0 else
              "REPRESENTATION_RESTATEMENT(K3: Hamiltonian "
              "positivity == h > 0 exactly; the only independent "
              "shadow (R2) lags +1 on every flipping world -- it "
              "detects, it never forbids)")
        k4 = ("REPRESENTATION_WORLD_BLIND(K4: h h# == 1 forces "
              "sign sync identically in every world -- the dual "
              "pair adds no second constraint; global positive "
              "structures are killed by budget == S_-)"
              if ok_sync else
              "REPRESENTATION_NOT_CONSTRUCTIBLE(K4)")
        gos = [v for v in (k1, k2, k3, k4)
               if v.startswith("REPRESENTATION_GO")]
        overall = ("CONTEST_WINNER(%s)" % gos[0] if gos else
                   "CONTEST_ALL_DEAD(K1 restatement, K2 not "
                   "constructible off the positive class, K3 "
                   "restatement with lag-1 shadow, K4 world-blind "
                   "by theorem -- the positivity has no "
                   "representation in the four classical languages "
                   "at this resolution: each language forces "
                   "positivity exactly for the positive class, and "
                   "MAIN is signed)")
        verd = " + ".join((k1, k2, k3, k4, overall))
    check("G96-verdict", npass == len(CHECKS),
          "%s%s -- PROVED (exact, toy grade): the split identity, "
          "the orientation collapse + value obstruction, the "
          "Hamiltonian bookkeeping, the product law + sync + "
          "budget; MEASURED: the shadow lags, the w9 negfrac/"
          "defect, the detector; OPEN: the lower side (why MAIN "
          "survives its free window) -- unchanged; NO RH claim"
          % (verd, " (SMOKE)" if smoke else ""))
    wall = time.time() - T0_WALL
    check("G99-runtime", wall <= 1800.0,
          "WALL %.1f s (bar 1800)" % wall)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    print("\n" + "=" * 78)
    print("RESULT: %d/%d gates PASS%s   SPEC_SHA %s"
          % (npass, len(CHECKS), " (SMOKE)" if smoke else "",
             SPEC_SHA[:16]))
    print("NO RH CLAIM in either direction.")
    print("=" * 78)
    return 0 if npass == len(CHECKS) else 1


if __name__ == "__main__":
    sys.exit(main())
'''

_SRC_1 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""fullsource_quasidefiniteness_probe -- PRIME.PORT.RHP.
FULLSOURCE.QUASIDEFINITENESS.01 (round 283): derive the
quasi-definiteness of the COMPLETE free moment window (forall
n < N_w: h_n > 0) DIRECTLY from the untruncated signed
prime-comb source -- full source -> RHP jump/monodromy property
-> quasi-definiteness, with NO surrogate intermediate.  The r277
bridge is binding: quasi-definiteness through the window <=> R2
(reality + strict interlacing of the Jacobi truncation spectra);
the RHP question of this round is WHICH PROPERTY OF THE FULL COMB
MONODROMY FORCES that reality through the free window.  r281
fixed the window boundary exactly (free pivots = h_0..h_{N_w-1},
counting theorem); v956 fixed that MAIN survives the entire free
window (measurement grade).  This round adjudicates THREE sealed
candidate structures and localizes every break honestly.

EXPLORATION ONLY (2026-08-25).  experiments/ level: NO promotion,
NO ledger row, NO marker moved, NO RH CLAIM in either direction.

INDEX FIREWALL (binding, r238-r281 discipline): w = window (kz),
S = #union entries of mutilde = mu - nu (channel concatenation),
S_+ = #positive union weights (= mu channel), S_- = #negative
union weights (= nu channel), N_w = builder depth = (S+1)//2,
n/k = degree, h_n = chain pivot, minC = first n with h_n < 0;
ground truth (h signs, minC, flips, record offsets) enters GATES
and record tables only; the candidate constructors consume the
SPLIT SOURCE (mu atoms/weights, nu atoms/weights) and passed
chain coefficients ONLY (AST scope audit); no zero/prime oracles
anywhere (AST firewall).  MACHINERY IMPORTED VERBATIM: r278
MS.ctx_build, r280 BL.{union_of_ctx, sign_chain_f64, TOYS_XS,
MAINLIKE_W, FLIPLIKE_W}, r274 WD.{stj_gen, pv_seq}, r230
JF.{TOY_NODES, TOY_WTS}, paircorr PC.{Grid, gen_model}, v881
PIK.lambda_eps, r243 PB.smooth_comb, v563 core READ-ONLY.

THE THREE SEALED CANDIDATES (frozen before evaluation):

(A1) J-SYMMETRY / REALITY OF THE FULL PROBLEM.  Implication
  chain: (a1-s1) the full comb jump data are real (atoms real,
  weights real) => the FIK solution has the Schwarz reflection
  symmetry Y(conj z) = conj(Y(z)) and the recurrence
  coefficients are real -- an arithmetic identity, gated at the
  sealed z0 on EVERY world; (a1-s2) the classical ADDITIONAL
  condition that upgrades reflection symmetry to reality +
  interlacing of the truncation spectra is residue positivity
  (Herglotz: all weights > 0, Nevanlinna dictionary, r227 leg D)
  -- ADJUDICATED on the split source: MAIN itself carries S_-
  negative residues, so the Herglotz condition FAILS ON MAIN
  (the break locus of A1, measured, not hidden); (a1-s3) the
  windowed replacement candidate is measured as anatomy: the
  critical Herglotz height eta* (smallest sealed grid height
  above which Im m > 0 across the hull strip), typed by the
  sealed r281 distance rule.  A1 can only carry if a sub-
  condition separates MAIN from the controls AND implies the
  window positivity -- the detector must show where the
  controls lose it.

(A2) MONODROMY FACTORIZATION OVER THE POSITIVE/NEGATIVE PART
  (the round's core).  mu and nu are INDIVIDUALLY positive; in
  the mu-orthonormal frame the full Hankel form of mutilde
  becomes I - M_n with M_n = B_n^T B_n, B[k, i] = sqrt(v_k)
  P_i(y_k) (mu-orthonormal polynomials on the nu atoms); the
  node Gram E_n = B_n B_n^T is EXACTLY the v881/r224 IIKS
  kernel (mu-CD kernel dressed by the nu weights).  Implication
  chain (each step gated):
  (a2-s1) SPLIT: mutilde = mu - nu from the full source, no
    truncation (union == channel concatenation, gated);
  (a2-s2) SYLVESTER/CONGRUENCE (exact theorem): with U the unit
    lower-triangular monic mu-OP change of basis,
    U H_n(mutilde) U^T = D_mu - G (D_mu = diag h^mu, G_ij =
    int pi_i pi_j dnu); leading minors are PRESERVED, so
    minor_k(D_mu - G) == D_k(mutilde) EXACTLY -- rational-gated
    on the toys, slogdet-gated on w9;
  (a2-s3) FRAME CONTRACTION (exact theorem): h_0..h_{m-1} > 0
    <=> H_m(mutilde) succ 0 <=> lambda_max(E_m) < 1;
  (a2-s4) MONOTONE RANK-ONE LOADING (exact theorem): E_{n+1} =
    E_n + b_n b_n^T, eigenvalues nondecreasing + rank-one
    interlacing => #(eigs > 1) is nondecreasing and jumps by at
    most one => det(I - E_k) > 0 for all k <= m <=>
    lambda_max(E_m) < 1, and lambda_max crosses 1 EXACTLY at
    n = minC + 1 -- THE WORLD TEST: the crossing must land on
    minC+1 = 185/N+3/N+2 on the mains and on flip+1 = 26/22/28/
    26 on EPST/SCR/SMOOTH/HL2;
  (a2-s5) CAPACITY ADJUDICATION: (i) the capacity CEILING is
    re-derived exactly (null-polynomial witness: p = prod over
    mu atoms gives int p^2 dmutilde = -int p^2 dnu < 0, hence
    minC <= S_+ -- the r279/r281 pigeonhole re-proved in the
    frame); (ii) capacity AS A COUNTING ARGUMENT IS REFUTED by
    the sealed rank-one pair (JF9 nodes, weights 1..1 with one
    negative atom of size 1e-12 vs 1000: SAME rank, SAME
    support pattern, OPPOSITE window fate) -- the deciding
    quantity is METRIC, not combinatorial: the contract's hope
    "half capacity => J-contraction" cannot be a counting
    theorem;
  (a2-s6) THE MISSING LEMMA L* (open, formal): for the MAIN
    window, for every real polynomial p with deg p < N_w:
    int p^2 dnu < int p^2 dmu; equivalently lambda_max(E_{N_w})
    < 1 (the mu-Christoffel-Darboux kernel at half-filling
    depth is a strict nu-contraction).  Given s1-s4, L* <=>
    full free-window quasi-definiteness.  s1-s4 are proved /
    machine-gated this round; s6 is the unique open center.

(A3) THE FREE-WINDOW MONODROMY AS A WHOLE (partial jump
  problem / Fredholm determinant).  The r281-delimited free
  window defines the FROZEN kernel E_{N_w} (N_w = (S+1)//2 is
  source-forced by the counting theorem -- NO retroactive
  window choice); quasi-definiteness <=> ABSENCE OF ZEROS of
  the explicit Fredholm determinant det(I - s E_{N_w}) on
  s in (0, 1].  Gates: (a3-s1) the eigen dictionary: the
  smallest zero s* == 1/lambda_max(E_{N_w}) (independent
  slogdet path: sealed s-grid sign scan; sign +1 at s = 1 and
  -1 at the sealed midpoint of the first negative window
  (1/lam_1, 1/lam_2); on the control the check runs at its
  crossing degree, where exactly one eigenvalue exceeds 1);
  (a3-s2) degree-resolved: the first n at
  which the s-grid scan finds a zero inside (0, 1] == the a2
  crossing degree, on MAIN and on a control.  SEALED COLLAPSE
  RULE: if both hold, A3 is typed COLLAPSES_TO_A2 (the
  zero-freeness IS the contraction scalar; the RHP language
  contributes exactly ONE invariant, and "what delivers the
  absence of zeros" is again L*).

FORBIDDEN-LIST DETECTORS (reviewer, binding -- each enforced):
  (f1) NO TRIANGLE BOUND: the sealed Gershgorin/row-sum mutant
    is executed honestly on w9 -- its crossing must land FAR
    BELOW minC+1 (measured TRIANGLE_DEAD: norm bounds cannot
    certify the window; the inherited kill stands);
  (f2) NO TARGET-INVERSE QUANTITY: the criterion consumes eigs
    of E only -- never (I - E)^{-1}, never the h chain; a
    deliberate mutant consuming the withheld sign chain is
    FLAGGED by the AST scope audit;
  (f3) NO LOCAL TRUNCATION: the kernel consumes ALL S_- nu
    atoms and the chain of ALL S_+ mu atoms (dimension gates);
    the toy truncation mutant (one nu atom dropped) must break
    the exact congruence LOUDLY;
  (f4) NO WORLD-BLIND IDENTITY: every candidate runs the world
    test; a candidate whose adjudicating statistic does not
    break exactly at the control flips cannot carry (A1's
    symmetry is EXPECTED to fail this -- typed, that is the
    honest A1 outcome);
  (f5) NO POSTHOC WINDOW CHOICE: N_w == (S+1)//2 == builder
    depth gated on every world; a deliberate mutant consuming
    the withheld minC to set a window is FLAGGED by the scope
    audit.  PAIRCORR DETECTOR (inherited): the sealed r281
    distance rule on the candidate statistics (eta*_rel,
    rho_20, 1/rho_40 -- the A3 stat's functional coupling to
    A2 is disclosed) over the dead battery EPST/SCR/SMOOTH/HL2.

WORLDS: MAIN w9 (S = 367, S_+ = 263, S_- = 104, N_w = 184,
minC = 184, r281 records); extra mains w13 (minC = N+2), kz15
(minC = N+1, razor); controls EPST/SCR(seed 1)/SMOOTH (flips
25/21/27) + HL2(seed 101, flip 25) -- built verbatim through
the r281 channel.  TOYS (exact rationals): JF9 (S = 9, S_- = 3,
minC = 3, within-capacity crossing at 4), MAINLIKE (S = 6,
S_+ = 4, minC = 4 = S_+, capacity-ceiling case), FLIPLIKE
(minC = 2, crossing at 3), the rank-one pair (eps = 1e-12 vs
big = 1000).

SEALED CONSTANTS: MAINS (9, 13, 15); MINC_OFF {9: 0, 13: 2,
15: 1}; CTRL_FLIPS {EPST: 25, SCR: 21, SMOOTH: 27}; HL2 seed
101 flip 25; EXT 8; DEPTH_PAD 6; CTRL_DEPTH 40; WARD_DPS 60;
WARD_DEGS_W9 (50, 120, 184, 185); RHO_WARD_TOL 1e-6;
GUARD_BAND 1e-8 (mp recount band around rho = 1); DICT_DEGS
(50, 120, 184, 185); DICT_TOL 1e-4; SGRID 0.05..1.00 step
0.05; NX_HERG 201; ETA_JS
2^j, j = -20..3 (x hull radius); Z0_FACT 1.5; SCHWARZ_BAR
1e-12; DET_DEG 20; DET_DEG2 40; RANK_DEGS (20, 50, 104, 120,
184); RANK_TOL 1e-10 (x lam_max, reported not hard-gated on
the reals); EPS_TINY 1/10^12; BIG_NEG 1000; MONO_TOL 1e-10;
runtime <= 1800 s; smoke = toys + firewall + scopes + mutants
+ w9 f64 block (w13/kz15, controls, mp ward, A3, A1 real legs,
detector skipped, no adjudication).  PRE-SPEC SCOPING
(disclosed): the r281/v956/r277 record numbers (S counts, minC
offsets, control flips) are consumed as sealed gate anchors;
no machinery pass preceded this spec except the r281 record
reading; no bar, band or typing rule was tuned after any
evaluation of this probe.

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  [exactly one of]
  FULLSOURCE_MECHANISM_GO(candidate; chain; world test) -- ONLY
    if some candidate DERIVES the window positivity from the
    source without an open scalar (sealed honesty rule: the
    equivalence chain alone can never award GO) /
  MECHANISM_PARTIAL(candidate; chain carries to step X exactly;
    the missing lemma as a formal statement) /
  CANDIDATES_DEAD(all three, with break loci)
  + A3 typing (COLLAPSES_TO_A2 / independent)
  + A1 typing (DEAD at the named step / anatomy)
  + DETECTOR_LEDGER(forbidden-list bilanz per candidate)
  [always].
Honesty before beauty: the congruence/contraction chain is an
EQUIVALENT reformulation of the window positivity in split-
source coordinates -- it is NOT new predictive power; the gain
is (i) the proved reduction of the whole free-window question
to ONE scalar inequality L*, (ii) the exact re-derivation of
the pigeonhole ceiling in the frame, (iii) the refutation of
capacity-as-counting, (iv) the localization of A1 and the
collapse of A3.  No verdict claims a derived 5/7, a bound
mechanism, an asymptotic law, or L* itself.  r243..r281 stand.

RECORD TABLES (frozen from the record run; calibration protocol,
chronology honest: smoke pass 1 = 26/26 (0.2 s) at the sealed
rules -- no bar, band, rule or verdict moved at any point; ONE
disclosed reporting-only alignment after the smoke pass: the G22
detail string now prints the measured numerical-rank TABLE
instead of a bare boolean (the equality claim and the sealed
RANK_TOL are unchanged; the rank statement was reported-not-
hard-gated from the start); calibration pass 1 = first full
evaluation = 26/26, wall 1.0 s; the record run below is
numerically identical; run1/run2 identical up to WALL):
CAL_VERDICT = MECHANISM_PARTIAL(A2; s1-s4 exact; L* formal) +
A3_COLLAPSES_TO_A2 + A1_DEAD(residue-positivity step) +
DETECTOR_LEDGER(K_A2_rho20 WORLD_BLIND / K_A3_invrho40
MAIN_SEPARATING / K_A1_etarel WORLD_BLIND; triangle dead at
21 << 185; scopes clean).
Key numbers.  TOYS (exact rationals): congruence minor_k(D_mu -
G) == D_k(mutilde) at EVERY k <= S_+ on all five toys;
within-capacity crossings JF9 4 / FLIPLIKE 3 / BIG1 1 == minC+1;
MAINLIKE and EPS1 typed CAPACITY_CEILING (minC == S_+ == 4/8, no
crossing inside the mu-frame); ceiling witness int p^2 dmutilde
= -int p^2 dnu < 0 exact on all five (JF9 -9.7e-3, MAINLIKE
-3.8e-1, FLIPLIKE -1.3e+0, EPS1 -7.2e-14, BIG1 -7.2e+1) -- the
pigeonhole minC <= S_+ re-proved in the frame; rank G_n ==
min(n, S_-) exact everywhere; the rank-one pair EPS1/BIG1: SAME
rank (1), SAME support, OPPOSITE fate (EPS1 survives its window,
minC = 8 > N_w = 5; BIG1 dies at 0) with metric values
G_11/h^mu_0 = 1.25e-13 vs 1.25e+2 -- counting refuted, the
deciding quantity is metric; truncation mutant LOUD (first
congruence mismatch at k = 1, dev 1.67e-1).  REAL (w9, f64
chain + mp dps-60 ward): S = 367, S_+ = 263, S_- = 104, min
atom gap 3.66e-5 > 0, union == channel concatenation, N_w = 184
== (S+1)//2 == builder depth, minC = 184; CROSSING at n = 185
== minC + 1 (the a2-s4 world test on MAIN); rho_20 = 0.47808,
rho_120 = 0.99898, rho_183 = 0.99983, rho_184 = 0.99983 (margin
1 - rho = 1.68e-4), rho_185 = 1.00004; top-5 eigs of E_{N_w}:
0.99983, 0.99874, 0.99597, 0.98461, 0.96408 (3 eigs above
0.99); diag max 0.9700 < 1; loading strictly increasing (min
one-step increase 2.9e-6); numerical rank table {20: 20, 50:
50, 104: 89, 120: 96, 184: 104} vs min(n, 104): the saturation
value 104 is reached, but at n = 104 fifteen directions sit
below the f64 resolution (measured anatomy -- the deep nu
directions load late); det dictionary max |dev| 3.4e-9 (bar
1e-4), sign at 185 negative == chain sign product; mp ward max
rel rho dev 4.9e-14 (bar 1e-6), 0 guard-band recounts.  EXTRA
MAINS: w13 N = 168, minC = 170, crossing 171 == minC+1; kz15
N = 203, minC = 204, crossing 205 == minC+1 -- the criterion
tracks QUASI-DEFINITENESS (minC+1), not the window edge: no
posthoc window.  CONTROLS (world test): crossings EPST 26 /
SCR 22 / SMOOTH 28 / HL2 26 == flip+1 exactly == the r277 R2
fire degrees (26/22/28) -- the contraction IS the split-source
form of the r277 spectral condition.  A3: MAIN s* = 1/rho_184
= 1.000168 > 1, slogdet signs +1 at s = 1 and -1 at the sealed
midpoint 1.000714, s-grid (0, 1] zero-free; EPST at its
crossing degree 26: s* = 0.9865 < 1, first grid flip at 1.00;
degree-resolved first (0, 1]-zero at 185 (MAIN) / 26 (EPST) ==
the a2 crossings => A3_COLLAPSES_TO_A2.  A1: Schwarz residual
0.0 on ALL SEVEN worlds (arithmetic identity of real jump
data, WORLD_BLIND -- the symmetry cannot carry); Herglotz DEAD
ON MAIN ITSELF (S_- = 104 negative residues, exact; grid Im-m
statistic at the lowest sealed height -3.64e+9); eta*_rel:
MAIN/w13/w15 0.003906, EPST 0.015625, SCR 0.015625, SMOOTH
0.000977, HL2 0.007812 -- MAIN INSIDE the dead spread (sealed
distance rule): the windowed eta* anatomy carries nothing; A1
typed DEAD at the residue-positivity step, the additional
condition collapses onto L*.  FORBIDDEN-LIST: Gershgorin
row-sum crossing at n = 21 << 185 (TRIANGLE_DEAD measured --
triangle bounds lose the window by 164 degrees); scope audits
CLEAN (10 constructors); target-inverse and posthoc-window
mutants FLAGGED; fragment audit CLEAN; full-source dims gated
(B rows == 104, chain atoms == 263, depth 190).  DETECTOR
(sealed r281 distance rule): K_A2_rho20 WORLD_BLIND (MAIN
0.478 inside dead 0.454..0.924 -- honest: the early-degree
contraction VALUE does not separate; the separation lives at
the window scale); K_A3_invrho40 MAIN_SEPARATING (MAIN 1.0688
vs dead 0.685..0.852; coupling to A2 disclosed); K_A1_etarel
WORLD_BLIND.  Runtime 1.0 s full / 0.2 s smoke; run1/run2
identical up to WALL.  AMENDMENTS AFTER FREEZE: NONE.

NO RH CLAIM IN EITHER DIRECTION.  NOT evidence for or against RH.
"""

from __future__ import annotations

import argparse
import ast
import hashlib
import math
import os
import sys
import time
from fractions import Fraction as Fr

import numpy as np
import mpmath as mp

HERE = os.path.dirname(os.path.abspath(__file__))
if HERE not in sys.path:
    sys.path.insert(0, HERE)

import budget_localization_probe as BL        # noqa: E402 r280
import metric_stability_probe as MS           # noqa: E402 r278
import jfraction_probe as JF                  # noqa: E402 r230
import wronskian_dictionary_probe as WD       # noqa: E402 r274
import paircorr_margin_probe as PC            # noqa: E402 relocation
import port_integrable_kernel_probe as PIK    # noqa: E402 v881
import principal_bessel_probe as PB           # noqa: E402 r243
import v563_paper2_readouts as core           # noqa: E402 READ-ONLY

MAINS = (9, 13, 15)
MINC_OFF = {9: 0, 13: 2, 15: 1}
CTRL_FLIPS = {"EPST": 25, "SCR": 21, "SMOOTH": 27}
HL2_SEED = 101
HL2_FLIP = 25
EXT = 8
DEPTH_PAD = 6
CTRL_DEPTH = 40
WARD_DPS = 60
WARD_DEGS_W9 = (50, 120, 184, 185)
RHO_WARD_TOL = 1e-6
GUARD_BAND = 1e-8
DICT_DEGS = (50, 120, 184, 185)
DICT_TOL = 1e-4
SGRID = tuple(round(0.05 * k, 2) for k in range(1, 21))
NX_HERG = 201
ETA_JS = tuple(range(-20, 4))
Z0_FACT = 1.5
SCHWARZ_BAR = 1e-12
DET_DEG = 20
DET_DEG2 = 40
RANK_DEGS = (20, 50, 104, 120, 184)
RANK_TOL = 1e-10
EPS_TINY = Fr(1, 10 ** 12)
BIG_NEG = Fr(1000)
MONO_TOL = 1e-10

SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest()
T0_WALL = time.time()
CHECKS: list = []


def check(name, ok, detail):
    ok = bool(ok)
    CHECKS.append((name, ok, detail))
    print("  [%s] %-42s %s" % ("PASS" if ok else "FAIL", name, detail),
          flush=True)
    return ok


def info(msg):
    print("  [INFO] " + msg, flush=True)


def section(t):
    print("\n" + "-" * 78 + "\n" + t + "\n" + "-" * 78, flush=True)


def firewall_audit():
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    forb = {"zeta" + "zero", "n" + "zeros", "prime" + "range",
            "is" + "prime", "gram" + "point"}
    bad = []
    for node in ast.walk(tree):
        nm = node.attr if isinstance(node, ast.Attribute) else (
            node.id if isinstance(node, ast.Name) else None)
        if nm and nm.lower() in forb:
            bad.append("%s@%d" % (nm, node.lineno))
    return (not bad), ("NO zero/prime oracles; the candidate "
                       "constructors consume the split source "
                       "(mu/nu atoms + weights) and passed chain "
                       "coefficients ONLY; record counts, offsets "
                       "and flips enter gates and record tables "
                       "only" if not bad else "; ".join(bad))


def antigate_fragment_audit():
    frags = ("poly" + "fit", "curve_" + "fit", "lst" + "sq",
             "mini" + "mize", "Line" + "arRegression")
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        nm = None
        if isinstance(node, ast.Attribute):
            nm = node.attr
        elif isinstance(node, ast.Name):
            nm = node.id
        elif isinstance(node, ast.FunctionDef):
            nm = node.name
        if nm and any(f in nm for f in frags):
            hits.append("%s@%d" % (nm, node.lineno))
    return hits


CONSTRUCTORS = ("split_channels", "mu_chain_f64", "b_matrix_f64",
                "mu_chain_mp", "b_matrix_mp", "rho_profile",
                "crossing_from_B", "sfam_grid_flip", "herglotz_eta",
                "gersh_crossing")
SCOPE_FORBIDDEN = {"MINC_OFF", "CTRL_FLIPS", "HL2_FLIP", "sg_true",
                   "lgh_true", "minC_true", "hs_true", "offs_true"}


def scope_audit(funcname):
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == funcname:
            for sub in ast.walk(node):
                nm = None
                if isinstance(sub, ast.Attribute):
                    nm = sub.attr
                elif isinstance(sub, ast.Name):
                    nm = sub.id
                elif isinstance(sub, ast.Constant) \
                        and isinstance(sub.value, str):
                    nm = sub.value
                if nm in SCOPE_FORBIDDEN:
                    hits.append("%s@%d" % (nm, sub.lineno))
    return hits


# ============== sealed source-pure constructors (AST-audited)
def split_channels(xu, wu):
    """the split source: positive part (mu) and negative part
    (nu, weights as |w|) of the full signed union -- consumes
    every atom, no truncation, no threshold."""
    pos = wu > 0
    return (xu[pos], wu[pos], xu[~pos], -wu[~pos])


def mu_chain_f64(x, w, depth):
    """orthonormal Stieltjes chain of the POSITIVE measure
    (x, w): returns (al[0..depth-1], sb[0..depth-1], h0) with
    sb[i] the coupling P_i -> P_{i+1} (sb_{i+1} in math)."""
    h0 = float(np.sum(w))
    u = np.full_like(x, 1.0 / math.sqrt(h0))
    um = np.zeros_like(x)
    al = np.zeros(depth)
    sb = np.zeros(depth)
    for i in range(depth):
        al[i] = float(np.sum(w * x * u * u))
        r = (x - al[i]) * u - (sb[i - 1] * um if i > 0 else 0.0)
        s = math.sqrt(float(np.sum(w * r * r)))
        sb[i] = s
        um, u = u, r / s
    return al, sb, h0


def b_matrix_f64(al, sb, h0, y, v, depth):
    """B[k, i] = sqrt(v_k) P_i(y_k): the mu-orthonormal
    polynomials evaluated on the nu atoms, nu-weight dressed
    (row-scaled recursion, bounded on a contractive world)."""
    u = np.sqrt(v) / math.sqrt(h0)
    um = np.zeros_like(y)
    B = np.zeros((len(y), depth))
    B[:, 0] = u
    for i in range(depth - 1):
        r = (y - al[i]) * u - (sb[i - 1] * um if i > 0 else 0.0)
        um, u = u, r / sb[i]
        B[:, i + 1] = u
    return B


def mu_chain_mp(x, w, depth, dps):
    """mp twin of mu_chain_f64 (sealed dps)."""
    mp.mp.dps = dps
    X = [mp.mpf(float(v_)) for v_ in x]
    W = [mp.mpf(float(v_)) for v_ in w]
    h0 = mp.fsum(W)
    u = [1 / mp.sqrt(h0)] * len(X)
    um = [mp.mpf(0)] * len(X)
    al = []
    sb = []
    for i in range(depth):
        a = mp.fsum(w_ * x_ * q * q for w_, x_, q in zip(W, X, u))
        al.append(a)
        if i > 0:
            r = [(x_ - a) * q - sb[i - 1] * qm
                 for x_, q, qm in zip(X, u, um)]
        else:
            r = [(x_ - a) * q for x_, q in zip(X, u)]
        s = mp.sqrt(mp.fsum(w_ * rr * rr for w_, rr in zip(W, r)))
        sb.append(s)
        um, u = u, [rr / s for rr in r]
    return al, sb, h0


def b_matrix_mp(al, sb, h0, y, v, depth, dps):
    """mp twin of b_matrix_f64; returns an f64 array of the
    mp-computed entries (entries are O(1) on the gated range)."""
    mp.mp.dps = dps
    Y = [mp.mpf(float(v_)) for v_ in y]
    V = [mp.mpf(float(v_)) for v_ in v]
    u = [mp.sqrt(v_) / mp.sqrt(h0) for v_ in V]
    um = [mp.mpf(0)] * len(Y)
    B = np.zeros((len(Y), depth))
    B[:, 0] = [float(q) for q in u]
    for i in range(depth - 1):
        if i > 0:
            r = [(y_ - al[i]) * q - sb[i - 1] * qm
                 for y_, q, qm in zip(Y, u, um)]
        else:
            r = [(y_ - al[i]) * q for y_, q in zip(Y, u)]
        um, u = u, [rr / sb[i] for rr in r]
        B[:, i + 1] = [float(q) for q in u]
    return B


def rho_profile(B, n_hi):
    """lambda_max(E_n), E_n = B_n B_n^T, for n = 1..n_hi."""
    out = np.zeros(n_hi + 1)
    for n in range(1, n_hi + 1):
        Bn = B[:, :n]
        E = Bn @ Bn.T
        out[n] = float(np.linalg.eigvalsh(E)[-1])
    return out


def crossing_from_B(B, n_hi):
    """first degree n with lambda_max(E_n) >= 1 (else None)."""
    rho = rho_profile(B, n_hi)
    for n in range(1, n_hi + 1):
        if rho[n] >= 1.0:
            return n, rho
    return None, rho


def sfam_grid_flip(B, n, sgrid):
    """A3 slogdet path (eigen-free): the first grid s with
    det(I - s E_n) <= 0, via slogdet sign only."""
    Bn = B[:, :n]
    E = Bn @ Bn.T
    for s in sgrid:
        sgn, _ld = np.linalg.slogdet(np.eye(E.shape[0]) - s * E)
        if sgn <= 0:
            return s
    return None


def herglotz_eta(xu, wu, lo, hi, rh):
    """critical Herglotz height on the sealed grids: smallest
    grid height eta = rh 2^j such that min_x g(x, eta') > 0 for
    ALL grid heights eta' >= eta, g = sum w / ((u - x)^2 + y^2);
    returns (eta*_rel, min g at the lowest height)."""
    xg = np.linspace(lo, hi, NX_HERG)
    mins = []
    for j in ETA_JS:
        eta = rh * (2.0 ** j)
        g = np.array([float(np.sum(wu / ((xu - x_) ** 2 + eta ** 2)))
                      for x_ in xg])
        mins.append(float(np.min(g)))
    eta_rel = None
    for idx in range(len(ETA_JS)):
        if all(m > 0.0 for m in mins[idx:]):
            eta_rel = 2.0 ** ETA_JS[idx]
            break
    return eta_rel, mins[0]


def gersh_crossing(B, n_hi):
    """f1 TRIANGLE-BOUND MUTANT (executed honestly): first n at
    which the Gershgorin row-sum bound on E_n reaches 1."""
    for n in range(1, n_hi + 1):
        Bn = B[:, :n]
        E = Bn @ Bn.T
        if float(np.max(np.sum(np.abs(E), axis=1))) >= 1.0:
            return n
    return None


def mutant_target_inverse(sg_true, lgh_true):
    """f2 MUST-FAIL MUTANT: a 'criterion' consuming the withheld
    target chain -- the scope audit must FLAG this."""
    return float(np.sum(sg_true)) + float(np.nansum(lgh_true))


def mutant_posthoc_window(minC_true):
    """f5 MUST-FAIL MUTANT: a 'window choice' oriented by the
    withheld crossing -- the scope audit must FLAG this."""
    return minC_true + 1


# ============== exact toy machinery (Fractions)
def frac_det(M):
    """exact determinant (Fractions, fraction-free elimination)."""
    n = len(M)
    A = [row[:] for row in M]
    det = Fr(1)
    for c in range(n):
        piv = next((r for r in range(c, n) if A[r][c] != 0), None)
        if piv is None:
            return Fr(0)
        if piv != c:
            A[c], A[piv] = A[piv], A[c]
            det = -det
        det *= A[c][c]
        for r in range(c + 1, n):
            f = A[r][c] / A[c][c]
            if f != 0:
                for k in range(c, n):
                    A[r][k] -= f * A[c][k]
    return det


def frac_rank(M):
    """exact rank (Fractions, Gaussian elimination)."""
    if not M:
        return 0
    A = [row[:] for row in M]
    nr, nc = len(A), len(A[0])
    r = 0
    for c in range(nc):
        piv = next((i for i in range(r, nr) if A[i][c] != 0), None)
        if piv is None:
            continue
        A[r], A[piv] = A[piv], A[r]
        for i in range(nr):
            if i != r and A[i][c] != 0:
                f = A[i][c] / A[r][c]
                for k in range(c, nc):
                    A[i][k] -= f * A[r][k]
        r += 1
        if r == nr:
            break
    return r


def toy_block(nodes, wts):
    """exact rational a2 block for one signed toy: chain truth,
    split, monic mu-OPs on the nu atoms, congruence minors,
    crossing, ceiling witness, ranks."""
    S_ = len(nodes)
    Nw = (S_ + 1) // 2
    _alt, _bet, hs_t = WD.stj_gen(nodes, wts, S_ - 1)
    minC = next((k for k in range(len(hs_t)) if hs_t[k] < 0), None)
    xs = [x for x, w in zip(nodes, wts) if w > 0]
    ws = [w for w in wts if w > 0]
    ys = [x for x, w in zip(nodes, wts) if w < 0]
    vs = [-w for w in wts if w < 0]
    Sp, Sm = len(xs), len(ys)
    alm, bem, hsm = WD.stj_gen(xs, ws, Sp - 1)
    ok_mu = all(h > 0 for h in hsm)
    vals = [WD.pv_seq(alm, bem, y, Sp - 1) for y in ys]
    G = [[sum(vs[k] * vals[k][i] * vals[k][j] for k in range(Sm))
          for j in range(Sp)] for i in range(Sp)]
    A = [[(hsm[i] if i == j else Fr(0)) - G[i][j]
          for j in range(Sp)] for i in range(Sp)]
    minors = [frac_det([row[:k] for row in A[:k]])
              for k in range(1, Sp + 1)]
    Dk = []
    p = Fr(1)
    for k in range(Sp):
        p *= hs_t[k]
        Dk.append(p)
    ok_cong = all(minors[k] == Dk[k] for k in range(Sp))
    cross = next((k + 1 for k in range(Sp) if minors[k] <= 0), None)
    # ceiling witness: p = prod (x - xs_j), int p^2 dmutilde < 0
    wit = Fr(0)
    for x_, w_ in zip(nodes, wts):
        pv = Fr(1)
        for xj in xs:
            pv *= (x_ - xj)
        wit += w_ * pv * pv
    ranks_ok = all(
        frac_rank([row[:n] for row in G[:n]]) == min(n, Sm)
        for n in range(1, Sp + 1))
    return dict(S=S_, Nw=Nw, Sp=Sp, Sm=Sm, minC=minC, hs=hs_t,
                ok_mu=ok_mu, ok_cong=ok_cong, minors=minors,
                cross=cross, wit=wit, ranks_ok=ranks_ok, G=G,
                hsm=hsm)


# ============== gate-side world material
def world_pack(tag, ctx):
    """union + truth chain + split + candidate inputs for one
    world (gate-side; constructors receive arrays only)."""
    xu, wu, zones = BL.union_of_ctx(ctx)
    N_ = ctx["N"]
    sg, lgh, rmg = BL.sign_chain_f64(xu, wu, N_ + EXT)
    mc = next((n for n in range(len(sg)) if sg[n] < 0), None)
    xp, wp, yn, vn = split_channels(xu, wu)
    return dict(tag=tag, N=N_, S=len(xu), Sp=len(xp), Sm=len(yn),
                xu=xu, wu=wu, zones=zones, sg=sg, lgh=lgh,
                minC=mc, xp=xp, wp=wp, yn=yn, vn=vn)


# --------------------------------------------------------------- main
def main():
    par_ = argparse.ArgumentParser()
    par_.add_argument("--smoke", action="store_true")
    args = par_.parse_args()
    smoke = args.smoke

    print("=" * 78)
    print("fullsource_quasidefiniteness_probe -- PRIME.PORT.RHP."
          "FULLSOURCE.QUASIDEFINITENESS.01 (round 283)")
    print("SPEC_SHA %s   (r280 BL %s / r278 MS %s)"
          % (SPEC_SHA[:16], BL.SPEC_SHA[:16], MS.SPEC_SHA[:16]))
    print("mode: %s" % ("SMOKE (toys + firewall + scopes + mutants "
                        "+ w9 f64 block; w13/kz15, controls, mp "
                        "ward, A3/A1 real legs, detector skipped)"
                        if smoke else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "sealed BEFORE evaluation: the three candidates A1/A2/A3 "
          "with their implication chains, the forbidden-list "
          "detectors f1..f5, the world set (w9/w13/kz15 + EPST/SCR/"
          "SMOOTH/HL2), the record anchors (S counts, minC offsets, "
          "flips), every bar/grid/tolerance, the collapse rule, the "
          "distance rule and the verdict form; the GO rule is "
          "sealed HONEST: an equivalence chain can never award GO")

    # ---------------- S1 toys (exact rationals)
    section("S1  TOYS -- CONGRUENCE, CROSSING, CEILING, CAPACITY")
    jf_pairs = sorted(zip(JF.TOY_NODES, JF.TOY_WTS),
                      key=lambda t: t[0])
    nodes9 = [t[0] for t in jf_pairs]
    wts9 = [t[1] for t in jf_pairs]
    toys = [("JF9", nodes9, wts9),
            ("MAINLIKE", BL.TOYS_XS, BL.MAINLIKE_W),
            ("FLIPLIKE", BL.TOYS_XS, BL.FLIPLIKE_W),
            ("EPS1", nodes9, [Fr(1)] * 8 + [-EPS_TINY]),
            ("BIG1", nodes9, [Fr(1)] * 8 + [-BIG_NEG])]
    TB = {}
    for name, nds, wt in toys:
        TB[name] = toy_block(nds, wt)
        t = TB[name]
        info("%s: S=%d N_w=%d S_+=%d S_-=%d minC=%s cross=%s "
             "wit=%s" % (name, t["S"], t["Nw"], t["Sp"], t["Sm"],
                         str(t["minC"]), str(t["cross"]),
                         "%.3e" % float(t["wit"])))
    ok_cong = all(TB[n]["ok_cong"] and TB[n]["ok_mu"] for n in TB)
    check("G10-toy-congruence", ok_cong,
          "EXACT (rationals, a2-s2): the unit-triangular monic "
          "congruence U H_n(mutilde) U^T = D_mu - G preserves "
          "leading minors: minor_k(D_mu - G) == D_k(mutilde) == "
          "prod h_0..h_{k-1} at EVERY k <= S_+ on all five toys; "
          "mu-chain positivity h^mu > 0 throughout -- the split-"
          "source frame is exact")
    ok_cr = (TB["JF9"]["cross"] == TB["JF9"]["minC"] + 1
             and TB["FLIPLIKE"]["cross"]
             == TB["FLIPLIKE"]["minC"] + 1
             and TB["BIG1"]["cross"] == TB["BIG1"]["minC"] + 1)
    ok_ceil = (TB["MAINLIKE"]["cross"] is None
               and TB["MAINLIKE"]["minC"] == TB["MAINLIKE"]["Sp"]
               and TB["EPS1"]["cross"] is None
               and TB["EPS1"]["minC"] == TB["EPS1"]["Sp"])
    check("G11-toy-crossing", ok_cr and ok_ceil,
          "EXACT (a2-s3/s4): within-capacity crossings JF9 %s / "
          "FLIPLIKE %s / BIG1 %s == minC+1; MAINLIKE and EPS1 are "
          "the CAPACITY_CEILING cases (minC == S_+ == %d/%d, no "
          "crossing inside the mu-frame -- quasi-definiteness dies "
          "exactly where the mu capacity ends)"
          % (str(TB["JF9"]["cross"]), str(TB["FLIPLIKE"]["cross"]),
             str(TB["BIG1"]["cross"]), TB["MAINLIKE"]["Sp"],
             TB["EPS1"]["Sp"]))
    ok_wit = all(TB[n]["wit"] < 0 for n in TB) \
        and all(TB[n]["minC"] <= TB[n]["Sp"] for n in TB)
    check("G12-toy-capacity-ceiling", ok_wit,
          "EXACT (a2-s5i): the null-polynomial witness p = prod "
          "over mu atoms gives int p^2 dmutilde = -int p^2 dnu < 0 "
          "on all five toys => H_n(mutilde) cannot be positive "
          "definite for n > S_+ => minC <= S_+ -- the r279/r281 "
          "pigeonhole ceiling RE-PROVED in the frame (witness "
          "values %s)" % str({n: "%.1e" % float(TB[n]["wit"])
                              for n in TB}))
    ok_rk = all(TB[n]["ranks_ok"] for n in TB)
    check("G13-toy-rank", ok_rk,
          "EXACT: rank G_n == min(n, S_-) at every n <= S_+ on all "
          "five toys (Gaussian elimination over Q) -- the nu "
          "correction saturates at its atom count, the v956 "
          "capacity picture at the Gram level")
    ok_pair = (TB["EPS1"]["Sm"] == 1 and TB["BIG1"]["Sm"] == 1
               and TB["EPS1"]["minC"] > TB["EPS1"]["Nw"]
               and TB["BIG1"]["minC"] == 0)
    v_eps = float(TB["EPS1"]["G"][0][0] / TB["EPS1"]["hsm"][0])
    v_big = float(TB["BIG1"]["G"][0][0] / TB["BIG1"]["hsm"][0])
    check("G14-toy-capacity-refutation", ok_pair
          and v_eps < 1.0 < v_big,
          "a2-s5ii REFUTATION (exact): the rank-one pair EPS1/BIG1 "
          "has the SAME rank (1), the SAME support pattern, and "
          "OPPOSITE window fate (EPS1 survives its free window, "
          "minC = %d > N_w = %d; BIG1 dies at 0) -- the deciding "
          "quantity is the METRIC value G_11/h^mu_0 = %.2e vs "
          "%.2e: capacity/rank COUNTING can never prove the "
          "free-window survival; the missing lemma must be metric"
          % (TB["EPS1"]["minC"], TB["EPS1"]["Nw"], v_eps, v_big))
    # f3 truncation mutant: drop the last nu atom of JF9
    t9 = TB["JF9"]
    wts_tr = list(wts9)
    drop = max(k for k, w in enumerate(wts_tr) if w < 0)
    wts_tr[drop] = Fr(0)
    nds_tr = [x for x, w in zip(nodes9, wts_tr) if w != 0]
    wt_tr = [w for w in wts_tr if w != 0]
    tb_tr = toy_block(nds_tr, wt_tr)
    kmax = min(tb_tr["Sp"], t9["Sp"])
    mism = next((k for k in range(kmax)
                 if tb_tr["minors"][k] != t9["minors"][k]), None)
    check("G15-toy-truncation-mutant", mism is not None,
          "f3 LOCAL TRUNCATION (one nu atom dropped): the "
          "congruence minors deviate from the TRUE D_k already at "
          "k = %s (dev %.2e) -- the theorem consumes the FULL "
          "source, LOUDLY"
          % (str(None if mism is None else mism + 1),
             0.0 if mism is None else
             abs(float(tb_tr["minors"][mism] - t9["minors"][mism]))))

    # ---------------- S2 w9 (real)
    section("S2  W9 -- SPLIT, CROSSING, PROFILE, DICTIONARY, WARD")
    ctx9 = MS.ctx_build(9)
    W9 = world_pack("w9", ctx9)
    xs_z, ws_z, ys_z, vs_z = W9["zones"]
    zu = np.sort(np.concatenate([xs_z, ys_z]))
    ok_zone = bool(np.allclose(zu, np.sort(W9["xu"]), rtol=0,
                               atol=0.0)) \
        and bool(np.all(ws_z > 0)) and bool(np.all(vs_z > 0))
    gap9 = float(np.min(np.diff(np.sort(W9["xu"]))))
    ok_src = (W9["S"] == 367 and W9["Sp"] == 263
              and W9["Sm"] == 104
              and W9["N"] == (W9["S"] + 1) // 2
              and W9["minC"] == W9["N"] + MINC_OFF[9]
              and gap9 > 0.0)
    check("G20-w9-source-split", ok_src and ok_zone,
          "w9 FULL SOURCE: S = %d entries, S_+ = %d (mu channel), "
          "S_- = %d (nu channel), union == channel concatenation "
          "(all zone weights positive), min atom gap %.2e > 0; "
          "N_w = %d == (S+1)//2 == builder depth (f5: the window "
          "is source-forced, r281 counting theorem); minC = %s == "
          "N_w + %d (record)"
          % (W9["S"], W9["Sp"], W9["Sm"], gap9, W9["N"],
             str(W9["minC"]), MINC_OFF[9]))
    depth9 = min(W9["N"] + DEPTH_PAD, W9["Sp"] - 1)
    al9, sb9, h09 = mu_chain_f64(W9["xp"], W9["wp"], depth9)
    B9 = b_matrix_f64(al9, sb9, h09, W9["yn"], W9["vn"], depth9)
    cross9, rho9 = crossing_from_B(B9, depth9)
    check("G21-w9-crossing", cross9 == W9["minC"] + 1,
          "THE a2-s4 WORLD TEST ON MAIN: lambda_max(E_n) crosses 1 "
          "at n = %s == minC + 1 = %d -- the full-source "
          "contraction adjudicates the wall EXACTLY: quasi-"
          "definiteness through the free window <=> "
          "lambda_max(E_{N_w}) < 1" % (str(cross9), W9["minC"] + 1))
    E184 = B9[:, :W9["N"]] @ B9[:, :W9["N"]].T
    ev184 = np.linalg.eigvalsh(E184)
    top5 = ev184[-5:][::-1]
    n_gt99 = int(np.sum(ev184 > 0.99))
    dmax = float(np.max(np.diag(E184)))
    mono = float(np.max(np.diff(rho9[1:depth9 + 1]) * -1.0))
    rk_tab = {}
    for n in RANK_DEGS:
        Bn = B9[:, :n]
        evn = np.linalg.eigvalsh(Bn @ Bn.T)
        rk_tab[n] = int(np.sum(evn > RANK_TOL * evn[-1]))
    ok_rk9 = all(rk_tab[n] == min(n, W9["Sm"]) for n in RANK_DEGS)
    check("G22-w9-profile", (rho9[W9["N"]] < 1.0)
          and (rho9[W9["N"] + 1] > 1.0) and dmax < 1.0
          and mono <= MONO_TOL,
          "MAIN PROFILE: rho_20 = %.5f, rho_120 = %.5f, rho_183 = "
          "%.5f, rho_184 = %.5f (margin 1 - rho = %.2e), rho_185 = "
          "%.5f; top-5 eigs of E_{N_w}: %s (%d eigs above 0.99 -- "
          "the contraction is BROADLY tight at half-filling); diag "
          "max %.4f < 1; monotone loading: max one-step decrease "
          "%.1e <= %.0e (a2-s4); numerical rank table (RANK_TOL "
          "%.0e x lam_max, reported not hard-gated) vs min(n, %d): "
          "%s -> equality %s"
          % (rho9[20], rho9[120], rho9[183], rho9[184],
             1.0 - rho9[184], rho9[185],
             str([round(float(v_), 5) for v_ in top5]), n_gt99,
             dmax, mono, MONO_TOL, RANK_TOL, W9["Sm"],
             str(rk_tab), str(ok_rk9)))
    if smoke:
        for g in ("G23-w9-det-dictionary", "G24-w9-mp-ward"):
            check(g, True, "SMOKE: skipped")
    else:
        sgm, lgm, _r = BL.sign_chain_f64(W9["xp"], W9["wp"], depth9)
        devs = {}
        ok_dict = True
        for n in DICT_DEGS:
            Mn = B9[:, :n].T @ B9[:, :n]
            sgn, ld = np.linalg.slogdet(np.eye(n) - Mn)
            rhs = float(np.sum(W9["lgh"][:n] - lgm[:n]))
            sgn_chain = float(np.prod(W9["sg"][:n]))
            devs[n] = abs(ld - rhs)
            ok_dict = ok_dict and devs[n] <= DICT_TOL \
                and sgn == sgn_chain
        check("G23-w9-det-dictionary", ok_dict,
              "a2-s2 ON THE REAL SOURCE: slogdet(I - M_n) == "
              "sum_{k<n}(lgh_mutilde - lgh_mu) at n = %s, max |dev| "
              "%.1e (bar %.0e); sign at 185 == chain sign product "
              "(negative) -- the frame determinant IS the wall "
              "determinant ratio D_n(mutilde)/D_n(mu)"
              % (str(DICT_DEGS), max(devs.values()), DICT_TOL))
        alm9, sbm9, h0m9 = mu_chain_mp(W9["xp"], W9["wp"], depth9,
                                       WARD_DPS)
        B9m = b_matrix_mp(alm9, sbm9, h0m9, W9["yn"], W9["vn"],
                          depth9, WARD_DPS)
        ok_ward = True
        wdev = 0.0
        n_guard = 0
        for n in WARD_DEGS_W9:
            Bn = B9m[:, :n]
            rho_m = float(np.linalg.eigvalsh(Bn @ Bn.T)[-1])
            wdev = max(wdev, abs(rho_m - rho9[n])
                       / max(abs(rho_m), 1e-300))
            ok_ward = ok_ward and (abs(rho_m - rho9[n])
                                   <= RHO_WARD_TOL * abs(rho_m))
            if abs(rho9[n] - 1.0) < GUARD_BAND:
                n_guard += 1
        check("G24-w9-mp-ward", ok_ward,
              "MP WARD (dps %d, chain + B recomputed): max rel rho "
              "dev %.1e at the sealed degrees %s (bar %.0e); "
              "guard-band |rho - 1| < %.0e recounts: %d -- the f64 "
              "crossing is arbitration-safe"
              % (WARD_DPS, wdev, str(WARD_DEGS_W9), RHO_WARD_TOL,
                 GUARD_BAND, n_guard))

    # ---------------- S3 extra mains
    section("S3  EXTRA MAINS -- w13 + kz15 (NO POSTHOC WINDOW)")
    if smoke:
        check("G30-mains-crossing", True, "SMOKE: skipped")
        WM = {}
    else:
        WM = {}
        ok_m = True
        txt = []
        for kz in (13, 15):
            ctx = MS.ctx_build(kz)
            Wp = world_pack("w%d" % kz, ctx)
            WM[kz] = Wp
            dep = min(Wp["N"] + DEPTH_PAD, Wp["Sp"] - 1)
            al_, sb_, h0_ = mu_chain_f64(Wp["xp"], Wp["wp"], dep)
            Bm = b_matrix_f64(al_, sb_, h0_, Wp["yn"], Wp["vn"],
                              dep)
            cr, _rp = crossing_from_B(Bm, dep)
            ok_m = ok_m and (Wp["minC"] == Wp["N"] + MINC_OFF[kz]) \
                and (cr == Wp["minC"] + 1) \
                and (Wp["N"] == (Wp["S"] + 1) // 2)
            txt.append("w%d: N=%d minC=%d cross=%s"
                       % (kz, Wp["N"], Wp["minC"], str(cr)))
        check("G30-mains-crossing", ok_m,
              "EXTRA MAINS: %s -- the crossing lands on minC+1 = "
              "N+3 / N+2, NOT on the window edge N_w: the "
              "contraction tracks QUASI-DEFINITENESS itself (f5: "
              "no posthoc window choice; the free-window statement "
              "needs only rho_{N_w} < 1, which these offsets "
              "satisfy a fortiori)" % "; ".join(txt))

    # ---------------- S4 controls (the world test)
    section("S4  CONTROLS -- THE WORLD TEST")
    if smoke:
        check("G40-worlds-test", True, "SMOKE: skipped")
        WC = {}
    else:
        rr9 = core.build_window(9)
        N_E = int(math.floor(math.exp(2.0 * rr9["alpha"]))) + 1
        lamE = PIK.lambda_eps(N_E)
        nn_idx = np.nonzero(np.abs(lamE) > 1e-12)[0]
        ug9, uw9 = PB.smooth_comb(rr9["alpha"])
        gpc = PC.Grid()
        comb_hl, _tag = PC.gen_model(gpc, "HL2", HL2_SEED)
        cdefs = (("EPST", dict(comb=(
            np.log(nn_idx.astype(float)),
            2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
            ("SCR", dict(scramble_seed=1)),
            ("SMOOTH", dict(comb=(ug9, uw9))),
            ("HL2", dict(comb=comb_hl)))
        WC = {}
        ok_c = True
        txt = []
        for cn, kw in cdefs:
            cctx = MS.ctx_build(9, **kw)
            Wp = world_pack(cn, cctx)
            WC[cn] = Wp
            flip = CTRL_FLIPS.get(cn, HL2_FLIP)
            dep = min(CTRL_DEPTH, Wp["Sp"] - 1)
            al_, sb_, h0_ = mu_chain_f64(Wp["xp"], Wp["wp"], dep)
            Bc = b_matrix_f64(al_, sb_, h0_, Wp["yn"], Wp["vn"],
                              dep)
            cr, rp = crossing_from_B(Bc, dep)
            Wp["B"] = Bc
            Wp["rho"] = rp
            Wp["cross"] = cr
            ok_c = ok_c and (Wp["minC"] == flip) \
                and (cr == flip + 1)
            txt.append("%s: minC=%s cross=%s" % (cn, str(Wp["minC"]),
                                                 str(cr)))
        check("G40-worlds-test", ok_c,
              "f4 WORLD TEST: the contraction crossing lands on "
              "flip+1 EXACTLY on every dead world (%s vs flips "
              "EPST/SCR/SMOOTH %s + HL2 %d) -- and these are the "
              "SAME degrees at which the r277 R2 interlacing/"
              "reality rule fires (26/22/28): the contraction IS "
              "the split-source form of the r277 spectral "
              "condition, breaking exactly at the control flips"
              % ("; ".join(txt), str(CTRL_FLIPS), HL2_FLIP))

    # ---------------- S5 A3 (Fredholm s-family)
    section("S5  A3 -- FREDHOLM s-FAMILY OF THE FROZEN WINDOW")
    if smoke:
        for g in ("G50-sfam-dictionary", "G51-sfam-degree"):
            check(g, True, "SMOKE: skipped")
        a3_collapse = False
    else:
        sstar9 = 1.0 / rho9[W9["N"]]
        Emain = E184
        # sealed sign points: s = 1 (inside the zero-free range)
        # and the midpoint of the first negative window
        # (1/lam_1, 1/lam_2) -- robust against a tight top
        # cluster (formula sealed, not tuned)
        s_neg = 0.5 * (1.0 / float(ev184[-1])
                       + 1.0 / float(ev184[-2]))
        ok_flip = True
        for sd, want in ((1.0, 1.0), (s_neg, -1.0)):
            sgn, _ld = np.linalg.slogdet(
                np.eye(Emain.shape[0]) - sd * Emain)
            ok_flip = ok_flip and (sgn == want)
        grid_main = sfam_grid_flip(B9, W9["N"], SGRID)
        We = WC["EPST"]
        n_e = We["cross"]           # exactly ONE eigenvalue >= 1
        rho_e_c = float(We["rho"][n_e])
        sstar_e = 1.0 / rho_e_c
        grid_e = sfam_grid_flip(We["B"], n_e, SGRID)
        ok_dict3 = ok_flip and (grid_main is None) \
            and (grid_e is not None) and (sstar_e < 1.0) \
            and abs(grid_e - sstar_e) <= 0.05 + 1e-12
        check("G50-sfam-dictionary", ok_dict3,
              "a3-s1 EIGEN DICTIONARY: MAIN smallest zero s* = "
              "1/rho_{N_w} = %.6f > 1; slogdet signs +1 at s = 1 "
              "and -1 at the sealed midpoint %.6f of the first "
              "negative window; sealed s-grid (0, 1] ZERO-FREE on "
              "MAIN; EPST at its crossing degree %d: s* = %.4f < "
              "1 with the first grid flip at s = %s (within one "
              "grid step) -- zero-freeness of det(I - s E) on "
              "(0, 1] IS the contraction scalar"
              % (sstar9, s_neg, n_e, sstar_e, str(grid_e)))
        dep_e = min(CTRL_DEPTH, We["Sp"] - 1)
        first_main = next(
            (n for n in range(1, depth9 + 1)
             if sfam_grid_flip(B9, n, (1.0,)) is not None), None)
        first_e = next(
            (n for n in range(1, dep_e + 1)
             if sfam_grid_flip(We["B"], n, (1.0,)) is not None),
            None)
        a3_collapse = (first_main == cross9) \
            and (first_e == We["cross"]) and ok_dict3
        check("G51-sfam-degree", (first_main == cross9)
              and (first_e == We["cross"]),
              "a3-s2 DEGREE-RESOLVED (slogdet path, eigen-free): "
              "the first n with a zero of det(I - s E_n) inside "
              "(0, 1] is %s on MAIN and %s on EPST == the a2 "
              "crossings (%s / %s) => A3 COLLAPSES TO A2: the "
              "partial-monodromy Fredholm formulation carries "
              "exactly the contraction scalar; 'what delivers the "
              "absence of zeros' is again L*"
              % (str(first_main), str(first_e), str(cross9),
                 str(We["cross"])))

    # ---------------- S6 A1 (symmetry + Herglotz)
    section("S6  A1 -- SCHWARZ SYMMETRY + RESIDUE CONDITION")
    if smoke:
        for g in ("G60-schwarz-worldblind", "G61-herglotz"):
            check(g, True, "SMOKE: skipped")
        eta_tab = {}
        a1_sep = False
    else:
        worlds7 = dict([("MAIN", W9)] +
                       [("w%d" % kz, WM[kz]) for kz in (13, 15)] +
                       list(WC.items()))
        res_tab = {}
        for wn, Wp in worlds7.items():
            lo = float(np.min(Wp["xu"]))
            hi = float(np.max(Wp["xu"]))
            x0 = 0.5 * (lo + hi)
            rh = 0.5 * (hi - lo)
            z0 = complex(x0, Z0_FACT * rh)
            m1 = complex(np.sum(Wp["wu"] / (Wp["xu"] - z0)))
            m2 = complex(np.sum(Wp["wu"]
                                / (Wp["xu"] - np.conj(z0))))
            res_tab[wn] = abs(m2 - np.conj(m1)) / max(abs(m1),
                                                      1e-300)
            Wp["hull"] = (lo, hi, rh)
        ok_sch = all(v <= SCHWARZ_BAR for v in res_tab.values())
        check("G60-schwarz-worldblind", ok_sch,
              "a1-s1: the Schwarz reflection identity m(conj z0) "
              "== conj m(z0) holds to %.1e on ALL SEVEN worlds "
              "(max residual %.1e) -- an arithmetic identity of "
              "REAL jump data; it holds on every dead world too, "
              "hence the symmetry alone CANNOT carry the window "
              "positivity (f4, typed WORLD_BLIND)"
              % (SCHWARZ_BAR, max(res_tab.values())))
        eta_tab = {}
        min_g = {}
        for wn, Wp in worlds7.items():
            lo, hi, rh = Wp["hull"]
            er, mg = herglotz_eta(Wp["xu"], Wp["wu"], lo, hi, rh)
            eta_tab[wn] = er
            min_g[wn] = mg
        vm = eta_tab["MAIN"]
        vd = [eta_tab[c] for c in ("EPST", "SCR", "SMOOTH", "HL2")
              if eta_tab[c] is not None]
        spread = (max(vd) - min(vd)) if vd else float("inf")
        dist_m = min(abs(vm - v_) for v_ in vd) if (
            vm is not None and vd) else 0.0
        a1_sep = (vm is not None and spread >= 0.0
                  and dist_m > spread > 0.0) or (
            vm is not None and spread == 0.0 and dist_m > 0.0)
        check("G61-herglotz", W9["Sm"] > 0,
              "a1-s2 ADJUDICATED: the classical additional "
              "condition (residue positivity / Herglotz) FAILS ON "
              "MAIN ITSELF (S_- = %d negative residues -- exact; "
              "grid Im-m statistic at the lowest sealed height: "
              "MAIN %.2e, measured anatomy) -- the break locus of "
              "A1; a1-s3 windowed anatomy eta*_rel per world: %s "
              "=> sealed distance rule: %s -- the additional "
              "condition that DOES decide is the a2 contraction "
              "(collapse onto L*)"
              % (W9["Sm"], min_g["MAIN"],
                 str({k: (None if v_ is None else round(v_, 6))
                      for k, v_ in eta_tab.items()}),
                 "A1_ETA_SEPARATES (anatomy only, no implication "
                 "chain to h > 0)" if a1_sep else
                 "WORLD_BLIND (MAIN inside the dead spread): the "
                 "eta* anatomy carries nothing"))

    # ---------------- S7 forbidden-list enforcement
    section("S7  FORBIDDEN-LIST DETECTORS + SCOPE AUDITS")
    g_cross = gersh_crossing(B9, W9["N"])
    check("G70-triangle-dead", g_cross is not None
          and g_cross < W9["minC"] + 1,
          "f1 TRIANGLE BOUND (executed honestly): the Gershgorin "
          "row-sum bound on E_n reaches 1 already at n = %s << "
          "crossing %d -- norm/triangle bounds lose the window by "
          "%s degrees: TRIANGLE_DEAD measured, the inherited kill "
          "stands" % (str(g_cross), W9["minC"] + 1,
                      str(None if g_cross is None
                          else W9["minC"] + 1 - g_cross)))
    hits_f2 = scope_audit("mutant_target_inverse")
    hits_f5 = scope_audit("mutant_posthoc_window")
    hits = []
    for fn in CONSTRUCTORS:
        hits += scope_audit(fn)
    ag_hits = antigate_fragment_audit()
    check("G71-scope-audits", bool(hits_f2) and bool(hits_f5)
          and not hits and not ag_hits,
          "f2/f5 MUTANTS FLAGGED by the AST scope audit (target-"
          "inverse: %s; posthoc-window: %s); the 10 sealed "
          "constructors consume split-source arrays + passed "
          "chain coefficients ONLY (%s); fragment audit (no fit "
          "primitives): %s"
          % ("; ".join(hits_f2) if hits_f2 else "NOT FLAGGED",
             "; ".join(hits_f5) if hits_f5 else "NOT FLAGGED",
             "CLEAN" if not hits else "; ".join(hits),
             "CLEAN" if not ag_hits else "; ".join(ag_hits)))
    check("G72-full-source", B9.shape[0] == W9["Sm"]
          and len(al9) == depth9 and len(W9["xp"]) == W9["Sp"],
          "f3 FULL-SOURCE DIMS (w9): B carries ALL %d nu atoms, "
          "the mu chain is built on ALL %d mu atoms, depth %d "
          "(= N_w + %d) -- no truncation, no threshold, no "
          "selection anywhere in the candidate path"
          % (W9["Sm"], W9["Sp"], depth9, DEPTH_PAD))

    # ---------------- S8 detector ledger
    section("S8  DETECTOR LEDGER (r281 DISTANCE RULE)")
    if smoke:
        check("G80-detector-ledger", True, "SMOKE: skipped")
        det_typ = {}
    else:
        stats = {"K_A2_rho20": {}, "K_A3_invrho40": {},
                 "K_A1_etarel": {}}
        stats["K_A2_rho20"]["MAIN"] = float(rho9[DET_DEG])
        stats["K_A3_invrho40"]["MAIN"] = 1.0 / float(
            rho9[DET_DEG2])
        stats["K_A1_etarel"]["MAIN"] = eta_tab["MAIN"]
        for cn, Wp in WC.items():
            rp = Wp["rho"]
            stats["K_A2_rho20"][cn] = float(rp[DET_DEG])
            stats["K_A3_invrho40"][cn] = 1.0 / float(
                rp[min(DET_DEG2, len(rp) - 1)])
            stats["K_A1_etarel"][cn] = eta_tab[cn]
        det_typ = {}
        for nm, tab in stats.items():
            vm = tab["MAIN"]
            vd = [tab[c] for c in WC if tab[c] is not None
                  and math.isfinite(tab[c])]
            spread = max(vd) - min(vd) if vd else float("inf")
            dm = min(abs(vm - v_) for v_ in vd) \
                if (vm is not None and vd) else 0.0
            det_typ[nm] = ("MAIN_SEPARATING"
                           if (vm is not None and spread > 0
                               and dm >= spread)
                           else "WORLD_BLIND")
        check("G80-detector-ledger", True,
              "PAIRCORR-STYLE DETECTOR (sealed r281 distance "
              "rule) on the candidate statistics: %s (values %s) "
              "-- the A3 stat's functional coupling to A2 "
              "(1/rho) is disclosed; A1's eta* typing is the f4 "
              "bilanz for candidate A1"
              % (str(det_typ),
                 str({nm: {k: (None if v_ is None
                               else round(v_, 5))
                           for k, v_ in tab.items()}
                      for nm, tab in stats.items()})))

    # ---------------- S9 verdict
    section("S9  VERDICT")
    check("G95-stoplist", True,
          "STOP LIST held: no derived 5/7, no bound mechanism, no "
          "asymptotic law, no triangle bound, no target-inverse "
          "quantity, no truncation, no posthoc window, NO claim "
          "of L*; what the round adds: the exact reduction of the "
          "full free-window question to ONE scalar (L*), the "
          "frame re-proof of the pigeonhole ceiling, the "
          "refutation of capacity-as-counting, the A3 collapse "
          "and the A1 localization; r243..r281 stand")
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    if smoke:
        verd = "SMOKE_NO_ADJUDICATION"
    else:
        a2_ok = all(ok for nm, ok, _d in CHECKS
                    if nm in ("G10-toy-congruence",
                              "G11-toy-crossing",
                              "G12-toy-capacity-ceiling",
                              "G13-toy-rank",
                              "G20-w9-source-split",
                              "G21-w9-crossing",
                              "G22-w9-profile",
                              "G23-w9-det-dictionary",
                              "G24-w9-mp-ward",
                              "G30-mains-crossing",
                              "G40-worlds-test"))
        parts = []
        if a2_ok:
            parts.append(
                "MECHANISM_PARTIAL(A2 monodromy factorization: "
                "steps s1-s4 EXACT (split, congruence, frame "
                "contraction, monotone rank-one loading -- "
                "crossing == minC+1 on ALL seven worlds); s5 "
                "capacity: ceiling re-proved, counting REFUTED; "
                "MISSING LEMMA L* formal: for MAIN, every real "
                "polynomial p with deg p < N_w has int p^2 dnu < "
                "int p^2 dmu, i.e. lambda_max(E_{N_w}) < 1 -- "
                "given s1-s4 this single scalar <=> full "
                "free-window quasi-definiteness; margin measured "
                "1 - rho_184 = %.2e)" % (1.0 - rho9[W9["N"]]))
        else:
            parts.append("CANDIDATES_DEAD(A2 chain broke -- see "
                         "gate table for the break locus)")
        parts.append("A3_%s" % ("COLLAPSES_TO_A2(s* = 1/rho "
                                "dictionary + degree-resolved "
                                "co-location)" if a3_collapse
                                else "INDEPENDENT_OR_BROKEN("
                                "see G50/G51)"))
        parts.append("A1_DEAD(break locus = residue positivity: "
                     "the Schwarz symmetry is world-blind and "
                     "the Herglotz condition fails on MAIN "
                     "itself (S_- = %d); eta* anatomy %s)"
                     % (W9["Sm"],
                        "separates (anatomy only)" if a1_sep
                        else "world-blind"))
        parts.append("DETECTOR_LEDGER(%s; triangle dead at %s << "
                     "%d; f2/f5 mutants flagged; full source "
                     "consumed)"
                     % (str(det_typ), str(g_cross),
                        W9["minC"] + 1))
        verd = " + ".join(parts)
    check("G96-verdict", npass == len(CHECKS),
          "%s%s -- PROVED (exact/toy + machine-gated): the "
          "congruence frame, the contraction equivalence, the "
          "monotone-loading crossing theorem, the ceiling "
          "witness, the counting refutation; MEASURED: the "
          "margin, the spectral profile, the world test; OPEN: "
          "L* itself -- the RHP language holds exactly ONE "
          "invariant on this question and it is the contraction "
          "scalar; NO RH claim"
          % (verd, " (SMOKE)" if smoke else ""))
    wall = time.time() - T0_WALL
    check("G99-runtime", wall <= 1800.0,
          "WALL %.1f s (bar 1800)" % wall)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    print("\n" + "=" * 78)
    print("RESULT: %d/%d gates PASS%s   SPEC_SHA %s"
          % (npass, len(CHECKS), " (SMOKE)" if smoke else "",
             SPEC_SHA[:16]))
    print("NO RH CLAIM in either direction.")
    print("=" * 78)
    return 0 if npass == len(CHECKS) else 1


if __name__ == "__main__":
    sys.exit(main())
'''

_SRC_2 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""lstar_two_measure_probe -- PRIME.PORT.LSTAR.
TWO_MEASURE_ANATOMY.01 (round 284): the TWO-MEASURE GEOMETRY of
the missing lemma L*.  r283 reduced the full free-window question
to ONE scalar inequality (L*: for every real polynomial p with
deg p < N_w, int p^2 dnu < int p^2 dmu, equivalently
lambda_max(E_{N_w}) < 1 with E the nu-dressed mu-CD kernel; margin
measured 1 - rho_184 = 1.68e-4, three eigenvalues above 0.995,
crossing exactly at minC+1 on all seven worlds, Gershgorin dead at
21).  THE NEW COORDINATE of this round: L* is a TWO-MEASURE
SUBORDINATION problem -- nu (104 atoms on w9) strictly
mu-subordinate (263 atoms) on polynomials up to degree N_w - 1.
THE STRUCTURALLY MOTIVATED MECHANISM CANDIDATE (the Nyquist /
shielding hypothesis, connecting the r276/r278 metric lane to L*):
polynomials of degree n have resolution scale ~ (hull length)/n;
as long as that resolution is COARSER than the nu-mu pairing scale
(every nu atom shielded by nearby mu atoms with enough mass), no
admissible p can isolate a nu atom -- the subordination holds
BECAUSE the degree is capped (exactly the half-filling meaning:
degree < S/2 cannot separate S atoms); it breaks when the
resolution reaches the pairing scale.  NOT a proof round: no L*
claim, no bound mechanism, no asymptotic law -- anatomy +
falsifiable crossing formula + honest typing.

EXPLORATION ONLY (2026-08-25).  experiments/ level: NO promotion,
NO ledger row, NO marker moved, NO RH CLAIM in either direction.

INDEX FIREWALL (binding, r238-r283 discipline): w = window (kz),
S = #union entries of mutilde = mu - nu, S_+ = #mu atoms, S_- =
#nu atoms, N_w = builder depth = (S+1)//2, n = degree, minC =
first n with h_n < 0, crossing = minC + 1 (the r283 monotone-
loading theorem: lambda_max(E_n) crosses 1 exactly at minC+1 --
consumed as the crossing dictionary on the ladder WITHOUT
re-running spectra there; re-gated spectrally on w9 + all four
controls this round); f = fold index (union atoms sit EXACTLY on
the uniform theta grid theta_f = 2 pi f / L, f = 0..L/2, grid
step Dth = 2 pi / L -- the natural polynomial-resolution
coordinate: degree-n polynomials on x = cos theta are trigonometric
polynomials of degree n in theta with resolution cell
res(n) = pi / n).  Ground truth (minC, control flips, census
offsets, r283 spectral records) enters GATES and record tables
only; the sealed constructors consume split-source arrays (fold
indices, weights, comb data, L, D) ONLY (AST scope audit); no
zero/prime oracles anywhere (AST firewall; atom classes via the
r254 world-blind integer root extraction ODG.base_exp).
MACHINERY IMPORTED VERBATIM: r283 FS.{split_channels,
mu_chain_f64, b_matrix_f64, mu_chain_mp, b_matrix_mp, rho_profile,
crossing_from_B}, r278 MS.ctx_build, r280 BL.{union_of_ctx,
sign_chain_f64}, v881 PIK.{folded_measure, build_rung,
lambda_eps}, r243 PB.smooth_comb, paircorr PC.{Grid, gen_model},
r254 ODG.base_exp, r244 BH.spearman, r274 WD.{stj_gen, pv_seq},
r230 JF.{TOY_NODES, TOY_WTS}, v563 core READ-ONLY.

LEG A -- THE TWO-MEASURE GEOMETRY (source-pure, pre-spectral):
(a1) w9 anatomy: which fold positions carry nu, which mu; r254
  labels (ARCH / K1 / KHI + primary p, admission bar 1e-9 on the
  matched comb atoms) for BOTH channels; THE PAIRING GEOMETRY:
  pairing step s_k = fold distance of nu atom k to the nearest mu
  atom, local gap g_k = fold distance to the nearest union atom
  of any sign, pairing ratio s_k / g_k; SHIELDING MASS: mu mass
  within R grid steps of each nu atom at the sealed radii
  R in {1, 2, 4, 8}, shield ratio q_k(R) = SM_k(R) / v_k;
  INTERLACING: per nu atom the number of mu atoms among its
  (existing) direct union neighbors, plus the adjacent nu-nu pair
  count (nu clustering census).
(a2) the SAME geometry on the four dead controls (EPST / SCR /
  SMOOTH / HL2, built verbatim through the r281 channel) -- the
  first question of the round: does the shielding geometry
  separate the worlds SOURCE-PURE, before any spectral
  computation?  Sealed scalar statistics K_G1 = median s,
  K_G2 = max s, K_G3 = min_k q_k(2), K_G4 = fraction of nu atoms
  with ALL existing neighbors mu; sealed r281 distance rule
  (MAIN_SEPARATING iff MAIN's value is farther from EVERY dead
  value than the dead spread, else WORLD_BLIND).
  SHIELDING_SEPARATES iff >= 1 of K_G1..K_G4 separates.

LEG B -- THE NYQUIST / RESOLUTION HYPOTHESIS (the core):
(b1) SEALED RESOLUTION CONVENTION (fixed at design time from the
  r283 record geometry L = 734, N_w = 184, S = 367 -- disclosed,
  not fitted): res(n) = pi / n on the theta hull [0, pi]; the
  pair cell of nu atom k is 2 s_k Dth (atom-to-shield DIAMETER);
  predicted crossing where res(n) = pair cell:
      n_pred(s) = L / (4 s).
  The all-adjacent case s == 1 predicts n_pred = L/4 = 183.5 ~
  N_w: THE HYPOTHESIS CONTENT IS that half-filling survival ==
  perfect pairing at grid scale, and early control death ==
  pairing scale of several grid steps.  Sealed pair-scale
  aggregates: MAX = max_k s_k, Q90 = v-weighted 0.9-quantile
  (smallest s with cum weight >= 0.9 sum), MED = median s.
  TEST on 42 frame-A rungs (h <= 900, r281 census channel,
  crossing = minC + 1 by the r283 theorem) + the four controls
  (crossing re-measured spectrally): NYQUIST_LAW iff some sealed
  aggregate holds |log2(n_pred / crossing)| <= 1.0 on ALL 46
  worlds; else NYQUIST_ORDERING iff some aggregate has
  spearman(n_pred, crossing) >= 0.75 over the 46 worlds; else
  NYQUIST_REFUTED (break loci printed).
(b2) THE CHRISTOFFEL QUANTIFICATION (the sharp local-resolution
  version; exact sandwich, each side gated): diag(E_n)_k =
  v_k K_n(y_k) = v_k / lambda_{mu,n}(y_k) (the exact per-atom
  Christoffel form: K_n = mu-CD kernel diagonal), hence
      max_k v_k K_n(y_k)  <=  lambda_max(E_n)  <=
      sum_k v_k K_n(y_k) = trace(E_n)  = the contract's
  Christoffel sum rho_n <= sum_k w_nu(x_k)/lambda_{mu,n}(x_k).
  Measured: n_CS = first n with trace >= 1 (the incoherent
  triangle-class crossing -- expected EARLY, Gershgorin died at
  21), n_DIAG = first n with max diag >= 1 (the pure single-atom
  isolation degree), true crossing in [n_CS, n_DIAG] (theorem);
  COHERENCE PROFILE at the sealed degrees (20, 40, 120, 184):
  gain_n = rho_n / maxdiag_n (the coherent assist over the best
  single atom -- the honest name for WHERE the crossing comes
  from: the nu atoms are coupled through the off-diagonal mu-CD
  kernel, the old cancellation story in the two-measure
  coordinate), slack_n = trace_n / rho_n (the incoherence loss of
  the triangle bound), r_eff = trace^2/||E||_F^2, offdiag
  Frobenius fraction.  On the controls the same range at their
  depth.
(b3) PAIRCORR DETECTOR on the leg-B statistics (sealed r281
  distance rule): B1 = n_CS, B2 = gain_20, plus the leg-A stats
  and C1 = participation ratio of the top eigenvector of E_20.

LEG C -- THE EXTREMAL VECTOR (the almost-subordination-breaking
polynomial): the top eigenvector w of E_{N_w} on w9 (mass profile
m_k = w_k^2 over the nu atoms):
(c1) WHERE it concentrates: participation ratio PR = 1/sum m^2,
  n_90 = #atoms for 90 percent mass, top-10 atom table (fold, u,
  label, primary p, v_k, s_k, q_k(2), m_k), overlap with the
  argmax-diag atom, spearman(m, v) and spearman(m, diag), the
  u-profile: mass-weighted mean u vs the v-weighted mean u; r278
  comparison (small primes carry): SMALLP enrichment factor
  F_sp = (mass share on atoms with primary p <= 13) / (v share),
  typed SMALLP_ENRICHED iff F_sp >= 1.5, SMALLP_DEPLETED iff
  <= 1/1.5, else SMALLP_NEUTRAL.
(c2) the controls at their crossing degree: THEIR breaking
  polynomial's top eigenvector -- PR, top-atom mass, argmax-diag
  overlap; typed contrast vs MAIN (PR ratio).
(c3) the BROAD saturation (three eigenvalues > 0.995): mass
  profiles of the top-3 eigenvectors of E_{N_w}; pairwise
  spearman of the mass profiles + top-20 support overlap; typed
  ONE_BAND iff median pairwise mass spearman >= 0.5 (structurally
  related modes on the same region -- orthogonal by oscillation),
  else INDEPENDENT_MODES.

LEG D -- WARDS / MUST-FAILS (each loud): E-construction gated
against the r283 route (w9: S = 367 / 263 / 104, N_w = 184, minC
= 184, crossing 185 == minC+1, rho records at n = 20/120/183/184/
185, margin 1.68e-4, top-5 eigenvalues, diag max 0.9700; fold
split bitwise == BL.union_of_ctx zones); mp ward (dps 60, chain +
B recomputed) on rho_184 / rho_185 (rel bar 1e-6; the 1.68e-4
margin needs precision care -- mp must confirm rho_184 < 1 <
rho_185); controls minC == flips 25/21/27/25 and spectral
crossing == flip+1 (26/22/28/26); 42-rung census regression
(anchors, offset distribution == r281, half-filling 42/42);
exact toys: (t1) synthetic grid toy (L = 32, mu folds {2, 3, 5}
weights {1, 1/2, 1/4}, nu folds {4, 8} weights {1/3, 1/9}) with
HAND-COMPUTED pairing/shield/interlace/Nyquist expectations gated
exactly; (t2) JF9 rational Christoffel cross-route: the monic
rational K_n (WD chain + pv_seq) must equal the f64 orthonormal
cumulative-row route to 1e-10 rel at every n <= S_+, sandwich +
crossing range gated on the toy (crossing 4 in [n_CS, n_DIAG]).
MUST-FAILS: (m1) WRONG GAP NORMALIZATION: the shielding/pairing
ratio computed in the x coordinate with a GLOBAL mean-gap
normalization must distort the profile LOUDLY (spread inflation
>= 5 vs the theta-grid ratio -- the metric of the hypothesis is
the theta grid, not x); (m2) CHRISTOFFEL WITHOUT WEIGHT: dropping
v_k from the Christoffel sum must break the exact trace identity
by >= 0.1 rel; (m3) EIGENVECTOR ORACLE: a mutant orienting the
extremal degree by the withheld crossing is FLAGGED by the AST
scope audit.  STOP LIST (anti-gates, binding): NO L* claim, NO
bound mechanism, NO asymptotic law, NO derived 5/7, NO triangle
bound as certificate, NO posthoc window, NO RH claim; r243..r283
stand.

SEALED CONSTANTS: MAINS (9, 13, 15); MINC_OFF {9: 0, 13: 2,
15: 1}; ANCHORS {9:0, 12:2, 13:2, 26:3, 40:1, 15:1, 52:0};
R281_DIST {0:18, 1:10, 2:6, 3:6, 4:1, 5:1}; CTRL_FLIPS
{EPST:25, SCR:21, SMOOTH:27}; HL2 seed 101 flip 25; H_CAP 900;
EXT 8 / EXT2 32; DEPTH_PAD 6; CTRL_DEPTH 40; SHIELD_RADII
(1, 2, 4, 8); WQ_Q 0.9; NYQ_BAND 1.0 (log2); SP_BAR 0.75;
ID_TOL 1e-12; SAND_TOL 1e-9; PROF_DEGS (20, 40, 120, 184);
R283_RHO {20: 0.47808, 120: 0.99898, 183: 0.99983, 184: 0.99983,
185: 1.00004} tol 1e-5 abs; R283_TOP5 (0.99983, 0.99874,
0.99597, 0.98461, 0.96408) tol 1e-4; MARGIN_REC 1.68e-4 rel tol
0.01; DIAGMAX_REC 0.9700 tol 5e-3; WARD_DPS 60; RHO_WARD_TOL
1e-6; EV_TOL 1e-10; TOPK 10; TOPSUP 20; BAND_SP 0.5; DET_DEG 20;
SMALLP (2, 3, 5, 7, 11, 13); SP_ENRICH 1.5; M1_BAR 5.0; M2_BAR
0.1; ADMIT 1e-9; TOY_L 32; toy christoffel bar 1e-10; runtime
<= 1800 s; smoke = toys + firewall + scopes + mutants + w9 f64
block (geometry, labels, christoffel, extremal); ladder,
controls, mp ward, detector and adjudication skipped.  PRE-SPEC
SCOPING (disclosed): the r283/r281/v956 record numbers (S counts,
minC offsets, flips, rho records) are consumed as sealed gate
anchors; the theta-resolution convention res(n) = pi/n with pair
cell 2 s Dth (hence n_pred = L/(4s)) was fixed at DESIGN TIME
from the published r283 record geometry -- the all-adjacent case
predicting the half-filling depth is the hypothesis content, not
a fit; no machinery pass preceded this spec except record
reading; no bar, band or typing rule was tuned after any
evaluation of this probe.

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  [exactly one of] SHIELDING_SEPARATES(separating stats) /
    SHIELDING_BLIND
  + [exactly one of] NYQUIST_LAW(aggregate; max band dev) /
    NYQUIST_ORDERING(best spearman) / NYQUIST_REFUTED(break loci)
  + CHRISTOFFEL_RANGE(n_CS, n_DIAG, crossing placement, coherence
    gain profile) [always]
  + EXTREMAL_ANATOMY(PR, concentration, control contrast,
    ONE_BAND / INDEPENDENT_MODES) [always]
  + DETECTOR_LEDGER [always].
Honesty before beauty: the geometry and the Christoffel sandwich
are ANATOMY of the open scalar L*, not a proof; a passing Nyquist
band is a falsifiable crossing FORMULA, not a mechanism theorem;
the coherence gain names where the triangle-class bounds lose
(the off-diagonal nu-nu coupling through the mu frame -- the old
cancellation story in the new coordinate); no verdict claims L*,
a bound mechanism, a derived 5/7 or an asymptotic law.

RECORD TABLES (frozen from the record run; calibration protocol,
chronology honest: smoke pass 1 = 28/30 -- ONE calibration
finding: the G10 toy HAND EXPECTATION miscounted the edge atom
(nu@8 has exactly ONE existing union neighbor, a mu atom, and the
sealed interlace rule counts EXISTING neighbors, so the all-mu
count is 2, not 1; the constructor was correct, the hand value
was corrected to the sealed convention); smoke pass 2 = 30/30
(0.2 s); calibration pass 1 = first full evaluation = 30/30, wall
5.8 s; after it THREE disclosed alignments, no bar, band, rule or
verdict rule moved: (a1) the code constant DIAGMAX_REC carried a
transcription slip (0.96952) and was aligned to the sealed
docstring/r283 print record 0.9700 (gate tol 5e-3 unchanged; both
values pass on the measured 0.97001); (a2) the G41 detail string
now prints the four control band devs (reporting only); (a3) the
ORDERING verdict detail carries the honesty clause on the trivial
N_w scaling (reporting only).  The post-freeze record run =
30/30, wall 5.6 s; run1/run2 identical up to WALL):
CAL_VERDICT = SHIELDING_BLIND + NYQUIST_ORDERING(MAX sp +0.998;
HONEST: carried by the trivial N_w scaling of the ladder -- the
mechanism-relevant discriminant, the four controls, FAILS the
band on every aggregate) + CHRISTOFFEL_RANGE(w9 n_CS = 10,
n_DIAG = 187, crossing 185; gain_Nw = 1.0307, slack_Nw = 50.2;
controls EPST (3, None, 26) / SCR (6, None, 22) / SMOOTH (28,
None, 28) / HL2 (6, None, 26)) + EXTREMAL_ANATOMY(PR 1.89, n90
2, argmax-diag mass 0.625, SMALLP_DEPLETED, ctrl PR 4.97..9.72,
ONE_BAND) + DETECTOR_LEDGER(ALL SEVEN sealed stats WORLD_BLIND).
Key numbers.  W9 GEOMETRY: occupancy 367/368 fold slots (only
f = 0 empty, the theta = 0 weight vanishes); labels mu 263 =
ARCH 178 + K1 71 + KHI 14, nu 104 = ARCH 78 + K1 19 + KHI 7
(admission dev 4.5e-16) -- the nu channel carries 26 comb-tent
folds (net-negative after background subtraction) and 78
background folds; PAIRING: s_k == 1 for ALL 104 nu atoms
(perfect grid-adjacent shielding), local gap 1, ratio 1;
interlacing 100/104 nu atoms with ALL existing neighbors mu, 2
adjacent nu-nu pairs; shield ratios q(1) med 6.73 / min 1.76,
q(2) med 11.9 / min 1.76, q(4) med 23.4 / min 2.82, q(8) med
51.3 / min 4.58.  CONTROLS (same channel): EPST mu/nu 226/141,
s max 2, q2 min 0.685, fullfrac 0.794, nu-nu 16; SCR 273/94,
s max 3, q2 min 0.0, fullfrac 0.351, nu-nu 38; SMOOTH 361/6,
s max 1, q2 min 0.902, fullfrac 1.000, nu-nu 0; HL2 279/88,
s max 2, q2 min 1.05, fullfrac 0.602, nu-nu 19.  SHIELDING
ADJUDICATION: all four sealed geometry stats WORLD_BLIND (the
dead spread swallows MAIN everywhere; SMOOTH sits on MAIN's side
of every stat) => SHIELDING_BLIND: the near-perfect interlacing
is a BUILDER-CHANNEL property (tent + FFT + fold), not the
arithmetic -- the support geometry cannot carry the wall,
consistent with r283 (metric, not combinatorial) and r276
(support exactness matters through the WEIGHTS).  NYQUIST: band
holds on 42/42 rungs (s == 1 and L/4 ~ N_w make the rung
predictions land near minC+1 by construction) and FAILS on all
four controls under every aggregate (MAX devs EPST 1.82 / SCR
1.48 / SMOOTH 2.71 / HL2 1.82 octaves; maxdev MED/Q90 3.06@SCR)
=> the sealed law is NOT awarded; spearman +0.998/+0.987/+0.987
>= 0.75 fires the sealed ORDERING typing, with the honesty
clause: the controls die at 22..28 DESPITE near-perfect pairing
(s <= 3) -- the support-geometry form of the resolution
hypothesis is refuted where it matters; no support-density-
corrected variant was explored (would be posthoc).  CHRISTOFFEL
(w9, the round's core finding): n_CS = 10 (trace crosses 1
early, triangle-class as inherited), n_DIAG = 187 -- the pure
single-atom isolation bound reaches 1 only TWO degrees above the
true crossing 185: MAIN's wall crossing is a NEAR-SINGLE-ATOM
Christoffel event (gain profile rho/maxdiag = 5.25 / 2.74 / 1.39
/ 1.0307 at n = 20/40/120/184 -- the coherent assist shrinks to
3.1 percent at the wall; slack trace/rho = 50.2 at N_w: the
aggregate nu coherence is DESTRUCTIVE, the old cancellation
story in the two-measure coordinate; r_eff 72.5 of 104, offdiag
Frobenius fraction 0.277 at N_w); THE CONTROL CONTRAST: on all
four dead worlds n_DIAG is NOT reached by their crossing depth
(their maxdiag stays far below 1) -- control death is a
COLLECTIVE mode far below the single-atom degree, while MAIN
rides the single-atom edge to the last free degree.  EXTREMAL
(w9): PR = 1.89, n_90 = 2 of 104 -- the near-breaking direction
is 99.7 percent TWO atoms: folds 2 and 4 (u = 0.030 / 0.060,
x = +0.9999 / +0.9994, ARCH class, v ~ 4e-6, s = 1, q2 = 1.76 /
1.97 = the two WEAKEST-shielded nu atoms of the window), i.e.
the SHALLOW-u hull edge BELOW the first prime (u < log 2), not
the small primes: mass-weighted mean u = 0.04 vs v-weighted
3.28, spearman(m, diag) = +0.788, spearman(m, v) = -0.477,
argmax-diag atom (fold 2) carries 0.625; SMALLP_DEPLETED (13
smallp-labeled nu atoms hold 13.5 percent of v but 0.0 percent
of the extremal mass) -- the r278 small-prime CHAIN-sensitivity
profile and the extremal NEAR-NULL direction of E are different
coordinates, honestly typed; controls at their crossing are
MORE diffuse (PR 7.02 / 9.72 / 4.97 / 8.29, top mass 0.21..
0.25) -- MAIN's mode is the sharpest of the five worlds; TOP-3
BAND: eigs 0.99983 / 0.99874 / 0.99597, pairwise mass spearman
+1.00 each, top-20 support overlaps 19/19/20 => ONE_BAND (three
oscillatory modes of ONE shallow-edge band, orthogonal by
oscillation, not by region).  DETECTOR (sealed r281 distance
rule): ALL SEVEN stats WORLD_BLIND (K_G1 all 1.0; K_G2 MAIN 1 vs
1..3; K_G3 MAIN 1.76 above the dead 0..1.05 but dist 0.71 <
spread 1.05; K_G4 MAIN 0.962 inside 0.351..1.000; n_CS MAIN 10
inside 3..28; gain_20 MAIN 5.25 inside 2.95..6.19; PR_20 MAIN
9.20 inside 5.38..10.83) -- honest negative: the round's
separation lives in the RANGE STRUCTURE (n_DIAG placement,
extremal sharpness), not in any sealed scalar.  MUST-FAILS: m1
spread inflation 233.6 >= 5 LOUD; m2 unweighted-Christoffel dev
1.0e+05 >= 0.1 LOUD; m3 flagged by the scope audit; constructors
+ fragment audit CLEAN.  MP WARD (dps 60): rho_184 = 0.99983248
< 1 < 1.00003660 = rho_185, rel devs 8.9e-14 / 1.6e-13 (bar
1e-6); w9 margin re-measured 1.6752e-4 (r283 print 1.68e-4, rel
dev 0.3 percent, inside the sealed 1 percent).  LADDER: 42
rungs, offset distribution == r281 {0:18, 1:10, 2:6, 3:6, 4:1,
5:1}, anchors exact, half-filling 42/42.  Runtime 5.6 s full /
0.2 s smoke; run1/run2 identical up to WALL.  AMENDMENTS AFTER
FREEZE: NONE.

NO RH CLAIM IN EITHER DIRECTION.  NOT evidence for or against RH.
"""

from __future__ import annotations

import argparse
import ast
import hashlib
import math
import os
import sys
import time
from fractions import Fraction as Fr

import numpy as np
import mpmath as mp

HERE = os.path.dirname(os.path.abspath(__file__))
if HERE not in sys.path:
    sys.path.insert(0, HERE)

import fullsource_quasidefiniteness_probe as FS  # noqa: E402 r283
import budget_localization_probe as BL           # noqa: E402 r280
import metric_stability_probe as MS              # noqa: E402 r278
import port_integrable_kernel_probe as PIK       # noqa: E402 v881
import principal_bessel_probe as PB              # noqa: E402 r243
import paircorr_margin_probe as PC               # noqa: E402
import offdiag_gram_probe as ODG                 # noqa: E402 r254
import bordered_hankel_probe as BH               # noqa: E402 r244
import wronskian_dictionary_probe as WD          # noqa: E402 r274
import jfraction_probe as JF                     # noqa: E402 r230
import v563_paper2_readouts as core              # noqa: E402 READ-ONLY

MAINS = (9, 13, 15)
MINC_OFF = {9: 0, 13: 2, 15: 1}
ANCHORS = {9: 0, 12: 2, 13: 2, 26: 3, 40: 1, 15: 1, 52: 0}
R281_DIST = {0: 18, 1: 10, 2: 6, 3: 6, 4: 1, 5: 1}
CTRL_FLIPS = {"EPST": 25, "SCR": 21, "SMOOTH": 27}
HL2_SEED = 101
HL2_FLIP = 25
H_CAP = 900
EXT = 8
EXT2 = 32
DEPTH_PAD = 6
CTRL_DEPTH = 40
SHIELD_RADII = (1, 2, 4, 8)
WQ_Q = 0.9
NYQ_BAND = 1.0
SP_BAR = 0.75
ID_TOL = 1e-12
SAND_TOL = 1e-9
PROF_DEGS = (20, 40, 120, 184)
R283_RHO = {20: 0.47808, 120: 0.99898, 185: 1.00004}
RHO_TOL = 1e-5
R283_TOP5 = (0.99983, 0.99874, 0.99597, 0.98461, 0.96408)
TOP5_TOL = 1e-4
MARGIN_REC = 1.68e-4
MARGIN_TOL = 0.01
DIAGMAX_REC = 0.9700
DIAGMAX_TOL = 5e-3
WARD_DPS = 60
RHO_WARD_TOL = 1e-6
EV_TOL = 1e-10
TOPK = 10
TOPSUP = 20
BAND_SP = 0.5
DET_DEG = 20
SMALLP = (2, 3, 5, 7, 11, 13)
SP_ENRICH = 1.5
M1_BAR = 5.0
M2_BAR = 0.1
ADMIT = 1e-9
TOY_L = 32
TOY_CHR_BAR = 1e-10

SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest()
T0_WALL = time.time()
CHECKS: list = []


def check(name, ok, detail):
    ok = bool(ok)
    CHECKS.append((name, ok, detail))
    print("  [%s] %-42s %s" % ("PASS" if ok else "FAIL", name, detail),
          flush=True)
    return ok


def info(msg):
    print("  [INFO] " + msg, flush=True)


def section(t):
    print("\n" + "-" * 78 + "\n" + t + "\n" + "-" * 78, flush=True)


def firewall_audit():
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    forb = {"zeta" + "zero", "n" + "zeros", "prime" + "range",
            "is" + "prime", "gram" + "point"}
    bad = []
    for node in ast.walk(tree):
        nm = node.attr if isinstance(node, ast.Attribute) else (
            node.id if isinstance(node, ast.Name) else None)
        if nm and nm.lower() in forb:
            bad.append("%s@%d" % (nm, node.lineno))
    return (not bad), ("NO zero/prime oracles; atom classes via the "
                       "r254 integer root extraction; the sealed "
                       "constructors consume split-source arrays "
                       "(fold indices, weights, comb, L, D) ONLY; "
                       "record counts, offsets and flips enter gates "
                       "and record tables only" if not bad
                       else "; ".join(bad))


def antigate_fragment_audit():
    frags = ("poly" + "fit", "curve_" + "fit", "lst" + "sq",
             "mini" + "mize", "Line" + "arRegression")
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        nm = None
        if isinstance(node, ast.Attribute):
            nm = node.attr
        elif isinstance(node, ast.Name):
            nm = node.id
        elif isinstance(node, ast.FunctionDef):
            nm = node.name
        if nm and any(f in nm for f in frags):
            hits.append("%s@%d" % (nm, node.lineno))
    return hits


CONSTRUCTORS = ("split_by_fold", "pair_geometry", "shield_profile",
                "interlace_census", "wquantile", "nyq_predictions",
                "atom_labels", "christoffel_rows", "top_eigvecs")
SCOPE_FORBIDDEN = {"ANCHORS", "MINC_OFF", "CTRL_FLIPS", "HL2_FLIP",
                   "R281_DIST", "minC_true", "sg_true", "offs_true",
                   "cross_true"}


def scope_audit(funcname):
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == funcname:
            for sub in ast.walk(node):
                nm = None
                if isinstance(sub, ast.Attribute):
                    nm = sub.attr
                elif isinstance(sub, ast.Name):
                    nm = sub.id
                elif isinstance(sub, ast.Constant) \
                        and isinstance(sub.value, str):
                    nm = sub.value
                if nm in SCOPE_FORBIDDEN:
                    hits.append("%s@%d" % (nm, sub.lineno))
    return hits


# ============== sealed source-pure constructors (AST-audited)
def split_by_fold(darm, L):
    """fold-resolved split source: (mu folds, mu weights, nu
    folds, nu weights, mu x, nu x) -- the SAME folded_measure
    calls as BL.union_of_ctx (gated bitwise there)."""
    xs, ws, ufp = PIK.folded_measure(darm, L, +1.0)
    ys, vs, ufn = PIK.folded_measure(darm, L, -1.0)
    return ufp, ws, ufn, vs, xs, ys


def pair_geometry(fp, fn):
    """pairing step s_k (fold distance nu -> nearest mu), local
    gap g_k (fold distance nu -> nearest union atom of any sign),
    ratio s_k/g_k -- pure fold-index geometry."""
    fps = np.sort(np.asarray(fp, np.int64))
    fu = np.sort(np.concatenate([fps, np.asarray(fn, np.int64)]))
    s = np.zeros(len(fn), np.int64)
    g = np.zeros(len(fn), np.int64)
    for k, f in enumerate(fn):
        i = int(np.searchsorted(fps, f))
        cand = []
        if i > 0:
            cand.append(f - fps[i - 1])
        if i < len(fps):
            cand.append(fps[i] - f)
        s[k] = min(cand)
        j = int(np.searchsorted(fu, f))
        cu = []
        if j > 0:
            cu.append(f - fu[j - 1])
        if j + 1 < len(fu):
            cu.append(fu[j + 1] - f)
        g[k] = min(cu)
    return s, g, s.astype(float) / g.astype(float)


def shield_profile(fp, wp, fn, vn, radii):
    """shield mass SM_k(R) = mu mass within R fold steps of nu
    atom k, and the shield ratio SM_k(R)/v_k, per sealed R."""
    o = np.argsort(fp)
    fps = np.asarray(fp, np.int64)[o]
    wps = np.asarray(wp, float)[o]
    cw = np.concatenate([[0.0], np.cumsum(wps)])
    out = {}
    for R in radii:
        lo = np.searchsorted(fps, np.asarray(fn) - R, side="left")
        hi = np.searchsorted(fps, np.asarray(fn) + R, side="right")
        sm = cw[hi] - cw[lo]
        out[R] = (sm, sm / np.asarray(vn, float))
    return out


def interlace_census(fp, fn):
    """per nu atom: (#existing direct union neighbors, #mu among
    them); plus the adjacent nu-nu pair count."""
    fps = set(int(f) for f in fp)
    fu = np.sort(np.concatenate([np.asarray(fp, np.int64),
                                 np.asarray(fn, np.int64)]))
    res = []
    for f in fn:
        j = int(np.searchsorted(fu, f))
        nb = []
        if j > 0:
            nb.append(int(fu[j - 1]))
        if j + 1 < len(fu):
            nb.append(int(fu[j + 1]))
        res.append((len(nb), sum(1 for b in nb if b in fps)))
    fns = np.sort(np.asarray(fn, np.int64))
    nunu = int(np.sum(np.diff(fns) == 1))
    return res, nunu


def wquantile(vals, wts, q):
    """sealed weighted quantile: smallest value (ascending sort)
    whose cumulative weight reaches q x total."""
    o = np.argsort(vals)
    v = np.asarray(vals, float)[o]
    w = np.asarray(wts, float)[o]
    cw = np.cumsum(w)
    idx = int(np.searchsorted(cw, q * cw[-1]))
    idx = min(idx, len(v) - 1)
    return float(v[idx])


def nyq_predictions(s, vn, L):
    """the sealed Nyquist crossing predictions n_pred = L/(4 s)
    for the three sealed pair-scale aggregates."""
    smax = float(np.max(s))
    smed = float(np.median(s))
    sq = wquantile(s, vn, WQ_Q)
    return {"MAX": L / (4.0 * smax), "MED": L / (4.0 * smed),
            "Q90": L / (4.0 * sq)}


def atom_labels(folds, D, uu, mm):
    """r254-style world-blind labels per union fold atom:
    (class 0 ARCH / 1 K1 / 2 KHI, primary p, admission dev) via
    tent matching to the comb and integer root extraction."""
    order = np.argsort(uu)
    uus = np.asarray(uu, float)[order]
    mms = np.asarray(mm, float)[order]
    out = []
    for f in folds:
        si = float(f) * D
        lo = int(np.searchsorted(uus, si - D, side="right"))
        hi = int(np.searchsorted(uus, si + D, side="left"))
        best_w, best = -1.0, None
        for t in range(lo, hi):
            v = 1.0 - abs(si - uus[t]) / D
            if v > 0.0 and abs(mms[t]) * v > best_w:
                best_w, best = abs(mms[t]) * v, t
        if best is None:
            out.append((0, 0, 0.0))
            continue
        n = int(round(math.exp(uus[best])))
        dev = abs(math.exp(uus[best]) - n) / max(n, 1)
        p, kk = ODG.base_exp(n)
        out.append((1 if kk == 1 else 2, int(p), float(dev)))
    return out


def christoffel_rows(B):
    """cumulative Christoffel rows: cum[k, n-1] = sum_{i<n}
    B[k,i]^2 = v_k K_n(y_k) = diag(E_n)_k -- the exact per-atom
    Christoffel diagonal; trace and maxdiag profiles follow by
    column aggregation."""
    return np.cumsum(B * B, axis=1)


def top_eigvecs(B, n, kk):
    """eigenvalues + top-kk eigenvectors of E_n = B_n B_n^T."""
    Bn = B[:, :n]
    ev, V = np.linalg.eigh(Bn @ Bn.T)
    return ev, V[:, -kk:][:, ::-1]


# ============== must-fail mutants
def mutant_gap_norm_x(xp, xn):
    """m1 MUST-FAIL: pairing ratio computed in the x coordinate
    with a GLOBAL mean-gap normalization (the wrong metric for
    the theta-grid hypothesis) -- must distort the profile."""
    xu = np.sort(np.concatenate([xp, xn]))
    gg = float(np.mean(np.diff(xu)))
    d = np.array([float(np.min(np.abs(np.asarray(xp) - y)))
                  for y in xn])
    return d / gg


def mutant_unweighted_cs(cum, vn):
    """m2 MUST-FAIL: the Christoffel sum WITHOUT the nu weights
    (sum_k K_n(y_k)) -- must break the exact trace identity."""
    return np.sum(cum / np.asarray(vn, float)[:, None], axis=0)


def mutant_eigvec_oracle(minC_true):
    """m3 MUST-FAIL: an 'extremal degree' oriented by the
    withheld crossing -- the scope audit must FLAG this."""
    return minC_true + 1


# ============== gate-side world material
def world_pack(tag, ctx, D):
    """union + truth chain + fold split + geometry inputs for one
    world (gate-side; constructors receive arrays only)."""
    xu, wu, zones = BL.union_of_ctx(ctx)
    N_ = ctx["N"]
    sg, lgh, rmg = BL.sign_chain_f64(xu, wu, N_ + EXT)
    mc = next((n for n in range(len(sg)) if sg[n] < 0), None)
    if mc is None:
        sg, lgh, rmg = BL.sign_chain_f64(xu, wu, N_ + EXT2)
        mc = next((n for n in range(len(sg)) if sg[n] < 0), None)
    fp, wp, fn, vn, xp, xn = split_by_fold(ctx["darm"], ctx["L"])
    return dict(tag=tag, N=N_, L=int(ctx["L"]), S=len(xu), D=D,
                Sp=len(fp), Sm=len(fn), xu=xu, wu=wu, zones=zones,
                sg=sg, minC=mc, fp=fp, wp=wp, fn=fn, vn=vn,
                xp=xp, xn=xn, uu=ctx["uu"], mm=ctx["mm"])


def geom_block(W):
    """gate-side geometry bundle for one world."""
    s, g, ratio = pair_geometry(W["fp"], W["fn"])
    sh = shield_profile(W["fp"], W["wp"], W["fn"], W["vn"],
                        SHIELD_RADII)
    inter, nunu = interlace_census(W["fp"], W["fn"])
    preds = nyq_predictions(s, W["vn"], W["L"])
    full = sum(1 for ne, nm_ in inter if ne > 0 and nm_ == ne)
    occ = W["Sp"] + W["Sm"]
    stats = dict(
        med_s=float(np.median(s)), max_s=float(np.max(s)),
        min_q2=float(np.min(sh[2][1])),
        full_frac=full / max(len(inter), 1))
    return dict(s=s, g=g, ratio=ratio, sh=sh, inter=inter,
                nunu=nunu, preds=preds, stats=stats, occ=occ)


def spectral_block(W, depth):
    """gate-side spectral bundle: mu chain, B, rho profile,
    christoffel rows, crossings."""
    al, sb, h0 = FS.mu_chain_f64(np.asarray(W["xp"]),
                                 np.asarray(W["wp"]), depth)
    B = FS.b_matrix_f64(al, sb, h0, np.asarray(W["xn"]),
                        np.asarray(W["vn"]), depth)
    cross, rho = FS.crossing_from_B(B, depth)
    cum = christoffel_rows(B)
    trace = np.sum(cum, axis=0)          # trace[n-1] = trace E_n
    maxd = np.max(cum, axis=0)           # maxd[n-1] = max diag E_n
    n_cs = next((n for n in range(1, depth + 1)
                 if trace[n - 1] >= 1.0), None)
    n_diag = next((n for n in range(1, depth + 1)
                   if maxd[n - 1] >= 1.0), None)
    return dict(B=B, rho=rho, cross=cross, cum=cum, trace=trace,
                maxd=maxd, n_cs=n_cs, n_diag=n_diag, depth=depth)


def dist_rule(tab, ctrls):
    """sealed r281 distance rule: MAIN_SEPARATING iff MAIN's
    value is farther from EVERY dead value than the dead spread."""
    vm = tab["MAIN"]
    vd = [tab[c] for c in ctrls
          if tab[c] is not None and math.isfinite(tab[c])]
    if vm is None or not vd:
        return "WORLD_BLIND"
    spread = max(vd) - min(vd)
    dm = min(abs(vm - v) for v in vd)
    return ("MAIN_SEPARATING" if (spread > 0 and dm >= spread)
            else "WORLD_BLIND")


# --------------------------------------------------------------- main
def main():
    par_ = argparse.ArgumentParser()
    par_.add_argument("--smoke", action="store_true")
    args = par_.parse_args()
    smoke = args.smoke

    print("=" * 78)
    print("lstar_two_measure_probe -- PRIME.PORT.LSTAR."
          "TWO_MEASURE_ANATOMY.01 (round 284)")
    print("SPEC_SHA %s   (r283 FS %s / r278 MS %s)"
          % (SPEC_SHA[:16], FS.SPEC_SHA[:16], MS.SPEC_SHA[:16]))
    print("mode: %s" % ("SMOKE (toys + firewall + scopes + mutants "
                        "+ w9 f64 block; ladder, controls, mp ward, "
                        "detector, adjudication skipped)"
                        if smoke else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "sealed BEFORE evaluation: the theta-grid resolution "
          "convention (res = pi/n, pair cell 2 s Dth, n_pred = "
          "L/(4s), fixed at design time from the published r283 "
          "geometry -- disclosed, not fitted), the three pair-scale "
          "aggregates, the shield radii, the geometry statistics, "
          "the distance rule, the Christoffel sandwich gates, the "
          "extremal statistics, every bar/tolerance, the mutants "
          "and the verdict form; the STOP list forbids any L* "
          "claim and any bound-mechanism claim")

    # ---------------- S1 toys
    section("S1  TOYS -- GRID GEOMETRY (exact) + JF9 CHRISTOFFEL")
    tg_mu = np.array([2, 3, 5], np.int64)
    tg_wmu = np.array([1.0, 0.5, 0.25])
    tg_nu = np.array([4, 8], np.int64)
    tg_wnu = np.array([1.0 / 3.0, 1.0 / 9.0])
    s_t, g_t, r_t = pair_geometry(tg_mu, tg_nu)
    sh_t = shield_profile(tg_mu, tg_wmu, tg_nu, tg_wnu,
                          SHIELD_RADII)
    int_t, nunu_t = interlace_census(tg_mu, tg_nu)
    pr_t = nyq_predictions(s_t, tg_wnu, TOY_L)
    full_t = sum(1 for ne, nm_ in int_t if ne > 0 and nm_ == ne)
    ok_geo = (list(s_t) == [1, 3] and list(g_t) == [1, 3]
              and list(r_t) == [1.0, 1.0]
              and abs(sh_t[1][0][0] - 0.75) < 1e-15
              and abs(sh_t[1][0][1] - 0.0) < 1e-15
              and abs(sh_t[4][0][1] - 0.25) < 1e-15
              and abs(sh_t[8][0][0] - 1.75) < 1e-15
              and abs(sh_t[8][0][1] - 1.75) < 1e-15
              and int_t == [(2, 2), (1, 1)] and full_t == 2
              and nunu_t == 0
              and abs(pr_t["MAX"] - TOY_L / 12.0) < 1e-12
              and abs(pr_t["MED"] - TOY_L / 8.0) < 1e-12
              and abs(pr_t["Q90"] - TOY_L / 12.0) < 1e-12)
    check("G10-toy-geometry", ok_geo,
          "SYNTHETIC GRID TOY (L = %d, mu folds {2,3,5} w {1,1/2,"
          "1/4}, nu folds {4,8} v {1/3,1/9}), every value HAND-"
          "COMPUTED: s = %s, g = %s, ratio = %s, shield masses "
          "R=1 (0.75, 0) / R=4 nu@8 0.25 / R=8 (1.75, 1.75), "
          "neighbor census (2,2)/(1,1) -> 2 all-mu (the sealed "
          "rule counts EXISTING neighbors; nu@8 is an edge atom "
          "with one neighbor), nu-nu adjacencies 0, "
          "n_pred MAX/MED/Q90 = %.3f/%.3f/%.3f (= L/12, L/8, "
          "L/12; the sealed Q90 sorts ascending and takes the "
          "smallest s with cum weight >= 0.9 total)"
          % (TOY_L, list(s_t), list(g_t), list(r_t), pr_t["MAX"],
             pr_t["MED"], pr_t["Q90"]))
    # JF9 rational christoffel cross-route
    jf_pairs = sorted(zip(JF.TOY_NODES, JF.TOY_WTS),
                      key=lambda t: t[0])
    nodes9 = [t[0] for t in jf_pairs]
    wts9 = [t[1] for t in jf_pairs]
    xs_r = [x for x, w in zip(nodes9, wts9) if w > 0]
    ws_r = [w for w in wts9 if w > 0]
    ys_r = [x for x, w in zip(nodes9, wts9) if w < 0]
    vs_r = [-w for w in wts9 if w < 0]
    Sp_t = len(xs_r)
    alm, bem, hsm = WD.stj_gen(xs_r, ws_r, Sp_t - 1)
    vals = [WD.pv_seq(alm, bem, y, Sp_t - 1) for y in ys_r]
    al_f, sb_f, h0_f = FS.mu_chain_f64(
        np.array([float(x) for x in xs_r]),
        np.array([float(w) for w in ws_r]), Sp_t)
    B_t = FS.b_matrix_f64(al_f, sb_f, h0_f,
                          np.array([float(y) for y in ys_r]),
                          np.array([float(v) for v in vs_r]), Sp_t)
    cum_t = christoffel_rows(B_t)
    dev_chr = 0.0
    for n in range(1, Sp_t + 1):
        for k in range(len(ys_r)):
            exact = vs_r[k] * sum(vals[k][i] * vals[k][i] / hsm[i]
                                  for i in range(n))
            dev_chr = max(dev_chr,
                          abs(cum_t[k, n - 1] - float(exact))
                          / max(abs(float(exact)), 1e-300))
    tr_t = np.sum(cum_t, axis=0)
    md_t = np.max(cum_t, axis=0)
    _cr_t, rho_t = FS.crossing_from_B(B_t, Sp_t)
    ok_sand_t = all(md_t[n - 1] <= rho_t[n] + SAND_TOL
                    and rho_t[n] <= tr_t[n - 1] + SAND_TOL
                    for n in range(1, Sp_t + 1))
    n_cs_t = next((n for n in range(1, Sp_t + 1)
                   if tr_t[n - 1] >= 1.0), None)
    n_dg_t = next((n for n in range(1, Sp_t + 1)
                   if md_t[n - 1] >= 1.0), None)
    ok_rng_t = (n_cs_t is not None and n_cs_t <= 4
                and (n_dg_t is None or n_dg_t >= 4)
                and _cr_t == 4)
    check("G11-toy-christoffel", dev_chr <= TOY_CHR_BAR
          and ok_sand_t and ok_rng_t,
          "JF9 CROSS-ROUTE: the f64 orthonormal cumulative-row "
          "diagonal equals the exact rational monic route v_k "
          "sum pi_i(y_k)^2/h_i at EVERY n <= S_+ = %d, max rel "
          "dev %.1e (bar %.0e); sandwich maxdiag <= rho <= trace "
          "at every n; crossing range [n_CS, n_DIAG] = [%s, %s] "
          "contains the true crossing 4 (== minC+1, r283 record)"
          % (Sp_t, dev_chr, TOY_CHR_BAR, str(n_cs_t), str(n_dg_t)))

    # ---------------- S2 w9 machinery
    section("S2  W9 -- E-CONSTRUCTION GATED AGAINST THE r283 ROUTE")
    rr9 = core.build_window(9)
    D9 = float(rr9["D"])
    ctx9 = MS.ctx_build(9)
    W9 = world_pack("w9", ctx9, D9)
    xs_z, ws_z, ys_z, vs_z = W9["zones"]
    ok_zone = (np.array_equal(np.asarray(xs_z), np.asarray(W9["xp"]))
               and np.array_equal(np.asarray(ws_z),
                                  np.asarray(W9["wp"]))
               and np.array_equal(np.asarray(ys_z),
                                  np.asarray(W9["xn"]))
               and np.array_equal(np.asarray(vs_z),
                                  np.asarray(W9["vn"])))
    ok_src = (W9["S"] == 367 and W9["Sp"] == 263
              and W9["Sm"] == 104
              and W9["N"] == (W9["S"] + 1) // 2
              and W9["minC"] == W9["N"] + MINC_OFF[9])
    occ9 = W9["Sp"] + W9["Sm"]
    check("G20-w9-source-split", ok_src and ok_zone,
          "w9 FULL SOURCE: S = %d (mu %d / nu %d), N_w = %d == "
          "(S+1)//2, minC = %s == N_w + %d (record); the fold "
          "split is BITWISE the BL.union_of_ctx zone split; "
          "occupancy %d of %d fold slots (L = %d, slots 0..L/2)"
          % (W9["S"], W9["Sp"], W9["Sm"], W9["N"], str(W9["minC"]),
             MINC_OFF[9], occ9, W9["L"] // 2 + 1, W9["L"]))
    depth9 = min(W9["N"] + DEPTH_PAD, W9["Sp"] - 1)
    SP9 = spectral_block(W9, depth9)
    rho9 = SP9["rho"]
    check("G21-w9-crossing", SP9["cross"] == W9["minC"] + 1,
          "lambda_max(E_n) crosses 1 at n = %s == minC + 1 = %d "
          "-- the r283 route reproduced exactly (the crossing "
          "dictionary this round consumes on the ladder)"
          % (str(SP9["cross"]), W9["minC"] + 1))
    E184 = SP9["B"][:, :W9["N"]] @ SP9["B"][:, :W9["N"]].T
    ev184 = np.linalg.eigvalsh(E184)
    top5 = ev184[-5:][::-1]
    margin9 = 1.0 - rho9[W9["N"]]
    dmax184 = float(SP9["maxd"][W9["N"] - 1])
    ok_rec = all(abs(rho9[n] - R283_RHO[n]) <= RHO_TOL
                 for n in R283_RHO)
    ok_top = all(abs(float(top5[i]) - R283_TOP5[i]) <= TOP5_TOL
                 for i in range(5))
    ok_mar = abs(margin9 / MARGIN_REC - 1.0) <= MARGIN_TOL
    ok_dmx = abs(dmax184 - DIAGMAX_REC) <= DIAGMAX_TOL
    check("G22-w9-profile-regression", ok_rec and ok_top
          and ok_mar and ok_dmx and rho9[183] < 1.0
          and rho9[184] < 1.0,
          "r283 RECORDS REPRODUCED: rho_20/120/185 dev <= %.0e of "
          "%s; top-5 eigs %s == r283 within %.0e; margin 1 - "
          "rho_184 = %.4e (record %.2e, rel tol %.2f); diag max "
          "at N_w = %.5f (record %.5f)"
          % (RHO_TOL, str(R283_RHO),
             str([round(float(v), 5) for v in top5]), TOP5_TOL,
             margin9, MARGIN_REC, MARGIN_TOL, dmax184, DIAGMAX_REC))
    if smoke:
        check("G23-w9-mp-ward", True, "SMOKE: skipped")
    else:
        alm9, sbm9, h0m9 = FS.mu_chain_mp(
            np.asarray(W9["xp"]), np.asarray(W9["wp"]), depth9,
            WARD_DPS)
        B9m = FS.b_matrix_mp(alm9, sbm9, h0m9,
                             np.asarray(W9["xn"]),
                             np.asarray(W9["vn"]), depth9, WARD_DPS)
        devs = {}
        rho_mp = {}
        for n in (W9["N"], W9["N"] + 1):
            Bn = B9m[:, :n]
            rmp = float(np.linalg.eigvalsh(Bn @ Bn.T)[-1])
            rho_mp[n] = rmp
            devs[n] = abs(rmp - rho9[n]) / max(abs(rmp), 1e-300)
        ok_ward = (max(devs.values()) <= RHO_WARD_TOL
                   and rho_mp[W9["N"]] < 1.0
                   and rho_mp[W9["N"] + 1] > 1.0)
        check("G23-w9-mp-ward", ok_ward,
              "MP WARD (dps %d, chain + B recomputed): rho_184 = "
              "%.8f < 1 < %.8f = rho_185 at mp, rel devs %.1e / "
              "%.1e (bar %.0e) -- the 1.68e-4 margin is "
              "arbitration-safe"
              % (WARD_DPS, rho_mp[W9["N"]], rho_mp[W9["N"] + 1],
                 devs[W9["N"]], devs[W9["N"] + 1], RHO_WARD_TOL))

    # ---------------- S3 leg A geometry
    section("S3  LEG A -- TWO-MEASURE GEOMETRY (w9 + CONTROLS)")
    lab_mu = atom_labels(W9["fp"], D9, W9["uu"], W9["mm"])
    lab_nu = atom_labels(W9["fn"], D9, W9["uu"], W9["mm"])
    dev_adm = max([d for _c, _p, d in lab_mu + lab_nu
                   if _c != 0] or [0.0])
    cen_mu = {0: 0, 1: 0, 2: 0}
    cen_nu = {0: 0, 1: 0, 2: 0}
    for c, _p, _d in lab_mu:
        cen_mu[c] += 1
    for c, _p, _d in lab_nu:
        cen_nu[c] += 1
    check("G30-w9-labels", dev_adm <= ADMIT,
          "r254 LABELS (ARCH/K1/KHI, admission dev %.1e <= %.0e): "
          "mu %d = ARCH %d + K1 %d + KHI %d; nu %d = ARCH %d + "
          "K1 %d + KHI %d -- THE mu/nu STRUCTURE DISCLOSURE: "
          "which channel carries the comb-tent folds and which "
          "the background surplus"
          % (dev_adm, ADMIT, W9["Sp"], cen_mu[0], cen_mu[1],
             cen_mu[2], W9["Sm"], cen_nu[0], cen_nu[1], cen_nu[2]))
    GB9 = geom_block(W9)
    s9 = GB9["s"]
    q9 = {R: GB9["sh"][R][1] for R in SHIELD_RADII}
    info("w9 pairing: s med/max = %.0f/%.0f, gap med = %.0f, "
         "ratio med/max = %.2f/%.2f"
         % (np.median(s9), np.max(s9), np.median(GB9["g"]),
            np.median(GB9["ratio"]), np.max(GB9["ratio"])))
    for R in SHIELD_RADII:
        info("w9 shield ratio q(R=%d): med %.3g / min %.3g / "
             "max %.3g" % (R, np.median(q9[R]), np.min(q9[R]),
                           np.max(q9[R])))
    info("w9 interlacing: %d/%d nu atoms with ALL existing "
         "neighbors mu; %d adjacent nu-nu pairs"
         % (sum(1 for ne, nm_ in GB9["inter"]
                if ne > 0 and nm_ == ne), W9["Sm"], GB9["nunu"]))
    ok_struct = (bool(np.all(s9 >= 1))
                 and len(set(W9["fp"]) & set(W9["fn"])) == 0
                 and bool(np.all(np.asarray(W9["vn"]) > 0))
                 and bool(np.all(np.asarray(W9["wp"]) > 0)))
    check("G31-w9-pairing-geometry", ok_struct,
          "STRUCTURAL SANITY: mu/nu fold sets disjoint, all "
          "channel weights positive, s_k >= 1 everywhere; the "
          "pairing table and shield profiles printed above are "
          "the round's leg-A deliverable (stats: %s)"
          % str({k: round(v, 4) for k, v in GB9["stats"].items()}))
    if smoke:
        for g in ("G32-ctrl-geometry", "G33-shielding-adjudication"):
            check(g, True, "SMOKE: skipped")
        WC = {}
        GBC = {}
        shield_verdict = None
        geo_typ = {}
    else:
        N_E = int(math.floor(math.exp(2.0 * rr9["alpha"]))) + 1
        lamE = PIK.lambda_eps(N_E)
        nn_idx = np.nonzero(np.abs(lamE) > 1e-12)[0]
        ug9, uw9 = PB.smooth_comb(rr9["alpha"])
        gpc = PC.Grid()
        comb_hl, _tag = PC.gen_model(gpc, "HL2", HL2_SEED)
        cdefs = (("EPST", dict(comb=(
            np.log(nn_idx.astype(float)),
            2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
            ("SCR", dict(scramble_seed=1)),
            ("SMOOTH", dict(comb=(ug9, uw9))),
            ("HL2", dict(comb=comb_hl)))
        WC = {}
        GBC = {}
        ok_c = True
        for cn, kw in cdefs:
            cctx = MS.ctx_build(9, **kw)
            Wp = world_pack(cn, cctx, D9)
            WC[cn] = Wp
            GBC[cn] = geom_block(Wp)
            flip = CTRL_FLIPS.get(cn, HL2_FLIP)
            ok_c = ok_c and (Wp["minC"] == flip)
            st = GBC[cn]["stats"]
            info("%s: S=%d (mu %d/nu %d, occ %d/%d), minC=%s; "
                 "s med/max %.0f/%.0f, q2 med/min %.3g/%.3g, "
                 "fullfrac %.3f, nu-nu adj %d"
                 % (cn, Wp["S"], Wp["Sp"], Wp["Sm"], GBC[cn]["occ"],
                    Wp["L"] // 2 + 1, str(Wp["minC"]),
                    st["med_s"], st["max_s"],
                    np.median(GBC[cn]["sh"][2][1]), st["min_q2"],
                    st["full_frac"], GBC[cn]["nunu"]))
        check("G32-ctrl-geometry", ok_c,
              "CONTROLS built verbatim through the r281 channel: "
              "minC == flips %s + HL2 %d; their two-measure "
              "geometry printed above (the a2 comparison table)"
              % (str(CTRL_FLIPS), HL2_FLIP))
        geo_typ = {}
        for nm, key in (("K_G1_meds", "med_s"), ("K_G2_maxs",
                                                 "max_s"),
                        ("K_G3_minq2", "min_q2"),
                        ("K_G4_fullfrac", "full_frac")):
            tab = {"MAIN": GB9["stats"][key]}
            for cn in WC:
                tab[cn] = GBC[cn]["stats"][key]
            geo_typ[nm] = (dist_rule(tab, list(WC)), tab)
        shield_verdict = ("SHIELDING_SEPARATES"
                          if any(t[0] == "MAIN_SEPARATING"
                                 for t in geo_typ.values())
                          else "SHIELDING_BLIND")
        check("G33-shielding-adjudication", True,
              "THE FIRST QUESTION (source-pure, pre-spectral): %s "
              "-- sealed distance rule per statistic: %s"
              % (shield_verdict,
                 str({nm: (t[0], {k: round(v, 4)
                                  for k, v in t[1].items()})
                      for nm, t in geo_typ.items()})))

    # ---------------- S4 leg B1 nyquist
    section("S4  LEG B1 -- THE NYQUIST TEST (42 RUNGS + CONTROLS)")
    if smoke:
        for g in ("G40-ladder-census", "G41-nyquist-band",
                  "G42-nyquist-ordering"):
            check(g, True, "SMOKE: skipped")
        nyq_verdict = None
        nyq_detail = ""
    else:
        kzs = [kz for kz in core.frame_a_zones()
               if PIK.build_rung(kz)["h"] <= H_CAP]
        cens = {}
        ok_hf = True
        for kz in kzs:
            ctx = ctx9 if kz == 9 else MS.ctx_build(kz)
            Dk = D9 if kz == 9 else float(core.build_window(kz)["D"])
            Wp = W9 if kz == 9 else world_pack("w%d" % kz, ctx, Dk)
            gb = GB9 if kz == 9 else geom_block(Wp)
            ok_hf = ok_hf and (Wp["N"] == (Wp["S"] + 1) // 2)
            cens[kz] = dict(N=Wp["N"], S=Wp["S"], L=Wp["L"],
                            minC=Wp["minC"], off=Wp["minC"] - Wp["N"],
                            preds=gb["preds"],
                            smax=gb["stats"]["max_s"],
                            occ=gb["occ"])
        offs_true = [cens[kz]["off"] for kz in sorted(cens)]
        dist = {}
        for o in offs_true:
            dist[o] = dist.get(o, 0) + 1
        ok_anch = all(cens[kz]["off"] == ANCHORS[kz]
                      for kz in ANCHORS if kz in cens)
        check("G40-ladder-census", len(cens) == 42 and ok_hf
              and ok_anch and dist == R281_DIST,
              "42-rung census (r281 channel): offset distribution "
              "%s == r281 record, anchors exact, half-filling "
              "42/42" % str({("+%d" % k): dist[k]
                             for k in sorted(dist)}))
        # crossing dictionary: rungs minC+1 (r283 theorem);
        # controls: spectral crossing measured below in S5
        worlds_nyq = {}
        for kz in sorted(cens):
            worlds_nyq["kz%d" % kz] = (cens[kz]["preds"],
                                       cens[kz]["minC"] + 1)
        SPC = {}
        for cn, Wp in WC.items():
            dep = min(CTRL_DEPTH, Wp["Sp"] - 1)
            SPC[cn] = spectral_block(Wp, dep)
            worlds_nyq[cn] = (GBC[cn]["preds"], SPC[cn]["cross"])
        band = {}
        for cand in ("MAX", "MED", "Q90"):
            devs = {wn: abs(math.log2(pr[cand] / cr))
                    for wn, (pr, cr) in worlds_nyq.items()}
            wmx = max(devs, key=lambda w: devs[w])
            band[cand] = (devs[wmx], wmx,
                          sum(1 for v in devs.values()
                              if v <= NYQ_BAND), len(devs))
        law = [c for c in band if band[c][0] <= NYQ_BAND]
        ctrl_dev = {cn: round(abs(math.log2(
            worlds_nyq[cn][0]["MAX"] / worlds_nyq[cn][1])), 2)
            for cn in WC}
        check("G41-nyquist-band", True,
              "SEALED BAND TEST |log2(n_pred/crossing)| <= %.1f "
              "on all %d worlds: %s => %s; control devs (MAX): %s"
              % (NYQ_BAND, len(worlds_nyq),
                 str({c: ("maxdev %.2f@%s, %d/%d in band"
                          % (band[c][0], band[c][1], band[c][2],
                             band[c][3])) for c in band}),
                 ("NYQUIST_LAW(%s)" % ",".join(law)) if law
                 else "no aggregate holds the band",
                 str(ctrl_dev)))
        sps = {}
        for cand in ("MAX", "MED", "Q90"):
            xs_ = [worlds_nyq[w][0][cand] for w in worlds_nyq]
            ys_ = [worlds_nyq[w][1] for w in worlds_nyq]
            sps[cand] = BH.spearman(xs_, ys_)
        best_c = max(sps, key=lambda c: abs(sps[c]))
        if law:
            nyq_verdict = "NYQUIST_LAW"
            nyq_detail = "%s, max band dev %.2f" % (law[0],
                                                    band[law[0]][0])
        elif abs(sps[best_c]) >= SP_BAR:
            nyq_verdict = "NYQUIST_ORDERING"
            nyq_detail = ("%s sp %+.3f; HONEST: the ordering is "
                          "carried by the trivial N_w scaling of "
                          "the ladder (n_pred ~ L/4 ~ N_w when "
                          "s == 1) -- the mechanism-relevant "
                          "discriminant, the four controls, FAILS "
                          "the band on every aggregate"
                          % (best_c, sps[best_c]))
        else:
            nyq_verdict = "NYQUIST_REFUTED"
            nyq_detail = ("break loci: " + "; ".join(
                "%s maxdev %.2f@%s" % (c, band[c][0], band[c][1])
                for c in band) + "; best sp %+.3f (%s)"
                % (sps[best_c], best_c))
        check("G42-nyquist-ordering", True,
              "spearman(n_pred, crossing) over the %d worlds: %s "
              "(bar %.2f) => %s(%s) -- controls at crossings %s"
              % (len(worlds_nyq),
                 str({c: round(sps[c], 3) for c in sps}), SP_BAR,
                 nyq_verdict, nyq_detail,
                 str({cn: SPC[cn]["cross"] for cn in SPC})))

    # ---------------- S5 leg B2 christoffel
    section("S5  LEG B2 -- CHRISTOFFEL SANDWICH + COHERENCE")
    dev_id = 0.0
    for n in PROF_DEGS:
        En = SP9["B"][:, :n] @ SP9["B"][:, :n].T
        dev_id = max(dev_id, float(np.max(
            np.abs(np.diag(En) - SP9["cum"][:, n - 1]))
            / max(float(np.max(np.abs(np.diag(En)))), 1e-300)))
        dev_id = max(dev_id, abs(float(np.trace(En))
                                 - float(SP9["trace"][n - 1]))
                     / max(abs(float(np.trace(En))), 1e-300))
    check("G50-diag-trace-identity", dev_id <= ID_TOL,
          "EXACT IDENTITIES on w9 at the sealed degrees %s: "
          "diag(E_n)_k == v_k K_n(y_k) (cumulative Christoffel "
          "rows) and trace(E_n) == the contract's Christoffel sum "
          "sum_k w_nu/lambda_{mu,n} -- max rel dev %.1e (bar %.0e)"
          % (str(PROF_DEGS), dev_id, ID_TOL))
    ok_sand = all(SP9["maxd"][n - 1] <= rho9[n] + SAND_TOL
                  and rho9[n] <= SP9["trace"][n - 1] + SAND_TOL
                  for n in range(1, depth9 + 1))
    sand_c = True
    if not smoke:
        for cn in WC:
            sp = SPC[cn]
            sand_c = sand_c and all(
                sp["maxd"][n - 1] <= sp["rho"][n] + SAND_TOL
                and sp["rho"][n] <= sp["trace"][n - 1] + SAND_TOL
                for n in range(1, sp["depth"] + 1))
    check("G51-sandwich", ok_sand and sand_c,
          "THE SANDWICH THEOREM max_k v_k K_n(y_k) <= "
          "lambda_max(E_n) <= trace(E_n) holds at every n on w9%s "
          "(tol %.0e) -- the per-atom Christoffel bound and the "
          "triangle-class sum bracket the truth"
          % ("" if smoke else " + all four controls", SAND_TOL))
    rng_txt = "w9: n_CS = %s, n_DIAG = %s, crossing %s" \
        % (str(SP9["n_cs"]), str(SP9["n_diag"]), str(SP9["cross"]))
    ok_rng = (SP9["n_cs"] is not None
              and SP9["n_cs"] <= SP9["cross"]
              and (SP9["n_diag"] is None
                   or SP9["n_diag"] >= SP9["cross"]))
    ctrl_rng = {}
    if not smoke:
        for cn in WC:
            sp = SPC[cn]
            ctrl_rng[cn] = (sp["n_cs"], sp["n_diag"], sp["cross"])
            ok_rng = ok_rng and sp["n_cs"] is not None \
                and sp["n_cs"] <= sp["cross"] \
                and (sp["n_diag"] is None
                     or sp["n_diag"] >= sp["cross"])
    check("G52-christoffel-range", ok_rng,
          "CHRISTOFFEL_RANGE measured: %s%s -- the incoherent sum "
          "crosses EARLY (triangle-class, as inherited: Gershgorin "
          "died at 21), the single-atom bound %s"
          % (rng_txt,
             "" if smoke else "; controls (n_CS, n_DIAG, cross) "
             + str(ctrl_rng),
             "never reaches 1 inside the w9 window (the crossing "
             "is NOT a single-atom event)"
             if SP9["n_diag"] is None else
             "reaches 1 at %d" % SP9["n_diag"]))
    prof = {}
    for n in PROF_DEGS:
        En = SP9["B"][:, :n] @ SP9["B"][:, :n].T
        fro2 = float(np.sum(En * En))
        offd = En - np.diag(np.diag(En))
        prof[n] = dict(
            rho=float(rho9[n]), maxd=float(SP9["maxd"][n - 1]),
            tr=float(SP9["trace"][n - 1]),
            gain=float(rho9[n] / SP9["maxd"][n - 1]),
            slack=float(SP9["trace"][n - 1] / rho9[n]),
            reff=float(SP9["trace"][n - 1] ** 2 / fro2),
            offfr=float(math.sqrt(np.sum(offd * offd) / fro2)))
    for n in PROF_DEGS:
        p = prof[n]
        info("w9 n=%3d: rho %.5f, maxdiag %.5f, trace %.3g, "
             "gain %.4f, slack %.3g, r_eff %.1f, offdiag-fro "
             "%.3f" % (n, p["rho"], p["maxd"], p["tr"], p["gain"],
                       p["slack"], p["reff"], p["offfr"]))
    check("G53-coherence-profile", True,
          "COHERENCE ANATOMY (typed, the b2 deliverable): at N_w "
          "the coherent assist over the best single atom is "
          "gain = %.4f (rho %.5f vs maxdiag %.5f) while the "
          "triangle sum overshoots by slack = %.1f -- the nu "
          "atoms interfere DESTRUCTIVELY in the aggregate "
          "(off-diagonal mu-CD coupling, the old cancellation "
          "story in the two-measure coordinate) yet the small "
          "COHERENT assist is exactly what closes the single-atom "
          "gap at the wall"
          % (prof[W9["N"]]["gain"], prof[W9["N"]]["rho"],
             prof[W9["N"]]["maxd"], prof[W9["N"]]["slack"]))

    # ---------------- S6 leg C extremal vector
    section("S6  LEG C -- THE EXTREMAL VECTOR")
    ev_w, V_w = top_eigvecs(SP9["B"], W9["N"], 3)
    w1 = V_w[:, 0]
    rq = float(w1 @ (E184 @ w1))
    ok_ev = (abs(rq - float(ev_w[-1])) <= EV_TOL
             and abs(float(np.linalg.norm(w1)) - 1.0) <= EV_TOL)
    check("G60-eigvec-sanity", ok_ev,
          "top eigenvector of E_{N_w}: Rayleigh quotient == "
          "lambda_max to %.1e, unit norm -- the almost-"
          "subordination-breaking polynomial is well defined"
          % abs(rq - float(ev_w[-1])))
    m1_ = w1 * w1
    pr1 = float(1.0 / np.sum(m1_ * m1_))
    o_desc = np.argsort(m1_)[::-1]
    cmass = np.cumsum(m1_[o_desc])
    n90 = int(np.searchsorted(cmass, 0.9)) + 1
    kstar = int(np.argmax(SP9["cum"][:, W9["N"] - 1]))
    ov_diag = float(m1_[kstar])
    sp_mv = BH.spearman(list(m1_), [float(v) for v in W9["vn"]])
    sp_md = BH.spearman(list(m1_),
                        list(SP9["cum"][:, W9["N"] - 1]))
    u_nu = np.asarray(W9["fn"], float) * D9
    u_mass = float(np.sum(m1_ * u_nu))
    u_base = float(np.sum(np.asarray(W9["vn"]) * u_nu)
                   / np.sum(W9["vn"]))
    smallp_idx = [k for k in range(W9["Sm"])
                  if lab_nu[k][0] != 0 and lab_nu[k][1] in SMALLP]
    v_share = float(np.sum(np.asarray(W9["vn"])[smallp_idx])
                    / np.sum(W9["vn"])) if smallp_idx else 0.0
    m_share = float(np.sum(m1_[smallp_idx])) if smallp_idx else 0.0
    if smallp_idx and v_share > 0:
        f_sp = m_share / v_share
    else:
        f_sp = 1.0
    sp_typ = ("SMALLP_ENRICHED" if f_sp >= SP_ENRICH else
              ("SMALLP_DEPLETED" if f_sp <= 1.0 / SP_ENRICH
               else "SMALLP_NEUTRAL"))
    info("w9 extremal top-%d atoms (fold, u, x, class, p, v, s, "
         "q2, mass):" % TOPK)
    q2_9 = q9[2]
    for t in range(TOPK):
        k = int(o_desc[t])
        cls = ("ARCH", "K1", "KHI")[lab_nu[k][0]]
        info("  f=%4d u=%6.3f x=%+.4f %-4s p=%-4d v=%.2e s=%d "
             "q2=%.3g m=%.4f"
             % (W9["fn"][k], u_nu[k], W9["xn"][k], cls,
                lab_nu[k][1], W9["vn"][k], s9[k], q2_9[k], m1_[k]))
    check("G61-extremal-anatomy", True,
          "c1 CONCENTRATION (typed): PR = %.2f, n_90 = %d of %d, "
          "argmax-diag atom mass %.3f, spearman(m, v) = %+.3f, "
          "spearman(m, diag) = %+.3f; u-profile: mass-weighted "
          "mean u = %.2f vs v-weighted %.2f; r278 comparison: "
          "smallp (p <= 13) mass share %.3f vs v share %.3f => "
          "F_sp = %.2f => %s (nu smallp-labeled atoms: %d)"
          % (pr1, n90, W9["Sm"], ov_diag, sp_mv, sp_md, u_mass,
             u_base, m_share, v_share, f_sp, sp_typ,
             len(smallp_idx)))
    if smoke:
        check("G62-ctrl-extremal", True, "SMOKE: skipped")
        ctrl_ext = {}
    else:
        ctrl_ext = {}
        for cn in WC:
            sp = SPC[cn]
            nc = sp["cross"]
            evc, Vc = top_eigvecs(sp["B"], nc, 1)
            mc_ = Vc[:, 0] ** 2
            prc = float(1.0 / np.sum(mc_ * mc_))
            kst = int(np.argmax(sp["cum"][:, nc - 1]))
            ctrl_ext[cn] = (prc, float(np.max(mc_)),
                            float(mc_[kst]))
        check("G62-ctrl-extremal", True,
              "c2 CONTROL CONTRAST at their crossing degrees: "
              "(PR, top mass, argmax-diag mass) = %s vs MAIN "
              "(%.2f, %.3f, %.3f) -- typed: controls %s "
              "concentrated than MAIN's near-crossing mode"
              % (str({cn: tuple(round(x, 3) for x in v)
                      for cn, v in ctrl_ext.items()}),
                 pr1, float(m1_[o_desc[0]]), ov_diag,
                 "MORE" if all(v[0] < pr1
                               for v in ctrl_ext.values())
                 else "NOT uniformly more"))
    sp12 = BH.spearman(list(V_w[:, 0] ** 2), list(V_w[:, 1] ** 2))
    sp13 = BH.spearman(list(V_w[:, 0] ** 2), list(V_w[:, 2] ** 2))
    sp23 = BH.spearman(list(V_w[:, 1] ** 2), list(V_w[:, 2] ** 2))
    med_sp = float(np.median([sp12, sp13, sp23]))
    sup1 = set(int(i) for i in np.argsort(V_w[:, 0] ** 2)
               [::-1][:TOPSUP])
    sup2 = set(int(i) for i in np.argsort(V_w[:, 1] ** 2)
               [::-1][:TOPSUP])
    sup3 = set(int(i) for i in np.argsort(V_w[:, 2] ** 2)
               [::-1][:TOPSUP])
    band_typ = "ONE_BAND" if med_sp >= BAND_SP \
        else "INDEPENDENT_MODES"
    check("G63-band-structure", True,
          "c3 BROAD SATURATION (top-3 eigs %s): pairwise mass "
          "spearman %+.2f/%+.2f/%+.2f (median %+.2f, bar %.2f), "
          "top-%d support overlaps %d/%d/%d => %s"
          % (str([round(float(v), 5) for v in ev_w[-3:][::-1]]),
             sp12, sp13, sp23, med_sp, BAND_SP, TOPSUP,
             len(sup1 & sup2), len(sup1 & sup3), len(sup2 & sup3),
             band_typ))

    # ---------------- S7 must-fails + scopes
    section("S7  MUST-FAILS + SCOPE AUDITS")
    mut1 = mutant_gap_norm_x(W9["xp"], W9["xn"])
    spread_t = float(np.max(GB9["ratio"]) /
                     max(float(np.min(GB9["ratio"])), 1e-300))
    spread_m = float(np.max(mut1) / max(float(np.min(mut1)),
                                        1e-300))
    infl = spread_m / spread_t
    check("G70-mutant-gapnorm", infl >= M1_BAR,
          "m1 WRONG GAP NORMALIZATION (x coordinate, global mean "
          "gap): ratio spread inflates by %.1f (>= %.0f) -- LOUD: "
          "the hypothesis metric is the theta grid; the x metric "
          "with a global gap fabricates edge-atom exposure"
          % (infl, M1_BAR))
    cs_mut = mutant_unweighted_cs(SP9["cum"], W9["vn"])
    dev_m2 = abs(float(cs_mut[120 - 1])
                 - float(SP9["trace"][120 - 1])) \
        / float(SP9["trace"][120 - 1])
    check("G71-mutant-unweighted", dev_m2 >= M2_BAR,
          "m2 CHRISTOFFEL WITHOUT WEIGHT: dropping v_k breaks the "
          "exact trace identity by %.1e rel at n = 120 (>= %.1f) "
          "-- LOUD: the weight is load-bearing" % (dev_m2, M2_BAR))
    hits_m3 = scope_audit("mutant_eigvec_oracle")
    hits = []
    for fn_ in CONSTRUCTORS:
        hits += scope_audit(fn_)
    ag_hits = antigate_fragment_audit()
    check("G72-scope-audits", bool(hits_m3) and not hits
          and not ag_hits,
          "m3 EIGENVECTOR-ORACLE MUTANT FLAGGED (%s); the %d "
          "sealed constructors consume split-source arrays ONLY "
          "(%s); fragment audit (no fit primitives): %s"
          % ("; ".join(hits_m3) if hits_m3 else "NOT FLAGGED",
             len(CONSTRUCTORS),
             "CLEAN" if not hits else "; ".join(hits),
             "CLEAN" if not ag_hits else "; ".join(ag_hits)))

    # ---------------- S8 detector
    section("S8  DETECTOR LEDGER (r281 DISTANCE RULE)")
    if smoke:
        check("G80-detector-ledger", True, "SMOKE: skipped")
        det_typ = {}
    else:
        stats = {}
        for nm, t in geo_typ.items():
            stats[nm] = dict(t[1])
        stats["K_B1_nCS"] = {"MAIN": float(SP9["n_cs"])}
        stats["K_B2_gain20"] = {"MAIN": float(
            rho9[DET_DEG] / SP9["maxd"][DET_DEG - 1])}
        _e20, V20 = top_eigvecs(SP9["B"], DET_DEG, 1)
        m20 = V20[:, 0] ** 2
        stats["K_C1_PR20"] = {"MAIN": float(
            1.0 / np.sum(m20 * m20))}
        for cn in WC:
            sp = SPC[cn]
            stats["K_B1_nCS"][cn] = float(sp["n_cs"])
            stats["K_B2_gain20"][cn] = float(
                sp["rho"][DET_DEG] / sp["maxd"][DET_DEG - 1])
            _ec, Vc = top_eigvecs(sp["B"], DET_DEG, 1)
            mcc = Vc[:, 0] ** 2
            stats["K_C1_PR20"][cn] = float(
                1.0 / np.sum(mcc * mcc))
        det_typ = {nm: dist_rule(tab, list(WC))
                   for nm, tab in stats.items()}
        check("G80-detector-ledger", True,
              "PAIRCORR-STYLE DETECTOR (sealed r281 distance "
              "rule): %s (values %s)"
              % (str(det_typ),
                 str({nm: {k: round(v, 4) for k, v in tab.items()}
                      for nm, tab in stats.items()})))

    # ---------------- S9 verdict
    section("S9  VERDICT")
    check("G95-stoplist", True,
          "STOP LIST held: NO L* claim, no bound mechanism, no "
          "asymptotic law, no derived 5/7, no triangle bound as "
          "certificate, no posthoc window, no support-density-"
          "corrected Nyquist variant explored posthoc; what the "
          "round adds: the two-measure geometry disclosure, the "
          "sealed Nyquist adjudication, the Christoffel sandwich "
          "range with the coherence profile, and the extremal "
          "anatomy; r243..r283 stand")
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    if smoke:
        verd = "SMOKE_NO_ADJUDICATION"
    else:
        parts = [shield_verdict,
                 "%s(%s)" % (nyq_verdict, nyq_detail),
                 "CHRISTOFFEL_RANGE(w9 n_CS = %s, n_DIAG = %s, "
                 "crossing %s; gain_Nw = %.4f, slack_Nw = %.1f; "
                 "controls %s)"
                 % (str(SP9["n_cs"]), str(SP9["n_diag"]),
                    str(SP9["cross"]), prof[W9["N"]]["gain"],
                    prof[W9["N"]]["slack"], str(ctrl_rng)),
                 "EXTREMAL_ANATOMY(PR %.2f, n90 %d, argmax-diag "
                 "mass %.3f, %s, ctrl PR %s, %s)"
                 % (pr1, n90, ov_diag, sp_typ,
                    str({cn: round(v[0], 2)
                         for cn, v in ctrl_ext.items()}),
                    band_typ),
                 "DETECTOR_LEDGER(%s)" % str(det_typ)]
        verd = " + ".join(parts)
    check("G96-verdict", npass == len(CHECKS),
          "%s%s -- MEASURED anatomy of the open scalar L*; the "
          "sealed crossing formula is adjudicated honestly; NO L* "
          "claim, NO RH claim" % (verd, " (SMOKE)" if smoke else ""))
    wall = time.time() - T0_WALL
    check("G99-runtime", wall <= 1800.0,
          "WALL %.1f s (bar 1800)" % wall)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    print("\n" + "=" * 78)
    print("RESULT: %d/%d gates PASS%s   SPEC_SHA %s"
          % (npass, len(CHECKS), " (SMOKE)" if smoke else "",
             SPEC_SHA[:16]))
    print("NO RH CLAIM in either direction.")
    print("=" * 78)
    return 0 if npass == len(CHECKS) else 1


if __name__ == "__main__":
    sys.exit(main())
'''

_SRC_3 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""christoffel_decomposition_probe -- PRIME.PORT.LSTAR.
CHRISTOFFEL_DECOMPOSITION.01 (round 285): the candidate-wise
DECOMPOSITION of the missing lemma L*.  r283 reduced the full
free-window question to ONE scalar (L*: lambda_max(E_{N_w}) < 1,
E = the nu-dressed mu-CD kernel; margin 1.68e-4); r284 measured
the Christoffel sandwich max_k v_k K_n(y_k) <= lambda_max(E_n)
<= trace(E_n) and found MAIN's crossing to be a NEAR-SINGLE-ATOM
event (n_DIAG = 187 vs crossing 185, coherent assist 3.1 percent,
aggregate coherence destructive slack 50x) while ALL controls die
COLLECTIVELY far below their single-atom degree.  THIS ROUND
adjudicates the decomposition perspective: L* splits into
(D) the PER-ATOM DIAGONAL CONDITION  v_k K_{N_w}(y_k) < 1 - delta
    for ALL nu atoms k (a LOCAL two-measure statement: nu mass at
    the atom against the inverse mu-Christoffel function --
    classical approximation terrain), and
(C) the COHERENCE CONDITION  assist_{N_w} =
    lambda_max/maxdiag - 1 < delta' (on MAIN 3.1 percent; the
    off-diagonal is destructive -- presumably the r272/r273
    generic cancellation);
together (exact bookkeeping) => lambda_max < 1.  On the controls
(C) fails (collective death) -- the arithmetic would then sit in
the spectral coherence of the WEIGHTS while (D) carries the
metric-local half.  NOT a proof round: no L* claim, no bound
mechanism, no asymptotic law -- exact accounting + budget tables
+ classical comparison + honest typing.

EXPLORATION ONLY (2026-08-25).  experiments/ level: NO promotion,
NO ledger row, NO marker moved, NO RH CLAIM in either direction.

INDEX FIREWALL (binding, r238-r284 discipline): w = window (kz),
S = #union entries of mutilde = mu - nu, S_+ = #mu atoms, S_- =
#nu atoms, N_w = builder depth = (S+1)//2, n = degree, minC =
first n with h_n < 0, crossing = minC + 1 (r283 monotone-loading
theorem, consumed as the crossing dictionary; re-gated spectrally
on w9 + mains + all four controls + one replicate per ensemble);
f = fold index (theta_f = 2 pi f / L, x = cos theta_f).  Ground
truth (minC, flips, census offsets, r283/r284 records) enters
GATES and record tables only; the sealed constructors consume
split-source arrays (fold indices, weights, kernel matrices,
vectors, L) ONLY (AST scope audit); no zero/prime oracles
anywhere (AST firewall; atom classes via the r254 world-blind
integer root extraction ODG.base_exp).  MACHINERY IMPORTED
VERBATIM: r284 LS.{split_by_fold, atom_labels, christoffel_rows,
top_eigvecs, dist_rule, world_pack, spectral_block,
shield_profile}, r283 FS.{mu_chain_f64, b_matrix_f64,
mu_chain_mp, b_matrix_mp, crossing_from_B}, r278 MS.ctx_build,
r280 BL.{union_of_ctx, sign_chain_f64}, v881 PIK.{folded_measure,
build_rung, lambda_eps}, r243 PB.smooth_comb, paircorr PC.{Grid,
gen_model}, r254 ODG.base_exp, r244 BH.spearman, r274 WD.{stj_gen,
pv_seq}, r230 JF.{TOY_NODES, TOY_WTS}, v563 core READ-ONLY.

LEG A -- THE EXACT DECOMPOSITION BOOKKEEPING:
(a1) SEALED FORMS (both candidates, frozen): (i) MULTIPLICATIVE
  (definition-exact, trivially honest): with maxdiag_n =
  max_k v_k K_n(y_k) and assist_n = lambda_max(E_n)/maxdiag_n - 1
  we have lambda_max = maxdiag x (1 + assist) EXACTLY, hence the
  BUDGET THEOREM: maxdiag <= 1 - delta AND assist <= delta' with
  (1 - delta)(1 + delta') < 1  =>  lambda_max < 1; equivalence
  lambda_max < 1 <=> assist < 1/maxdiag - 1 (algebraic identity,
  gated at every degree).  (ii) ADDITIVE with exact remainder:
  lambda_max = maxdiag + coh with coh := lambda_max - maxdiag,
  and the Weyl bracket 0 <= coh <= lambda_max(Off(E_n)) (gated;
  its slack vs the exact remainder is the price of the additive
  bookkeeping, reported).  The Rayleigh decomposition rho =
  sum_k u_k^2 d_k + u^T Off u (diagonal part + off-diagonal
  interference of the top eigenvector) is gated exactly -- NO
  give-away sandwich anywhere.
(a2) BUDGETS OVER THE LADDER: maxdiag_{N_w} and assist_{N_w} on
  all 42 frame-A rungs (h <= 900, r281 census channel) + the
  extra mains w13/kz15: is maxdiag_{N_w} uniformly < 1 - delta
  with stable delta (min/med/max, halves medians, spearman vs N);
  is the assist uniformly small; per-rung budget-margin
  (1/maxdiag - 1) - assist > 0 <=> rho_{N_w} < 1 (gated 42/42);
  FINGERPRINT ward: |spearman| of maxdiag/assist vs the withheld
  offset minC - N_w reported, alias bar 0.9.
(a3) THE SAME BOOKKEEPING ON THE CONTROLS (EPST/SCR/SMOOTH/HL2,
  r281 channel verbatim): at their crossing degrees, where
  exactly does the budget rip -- maxdiag still < 1 but assist
  exploded?  The budget split quantified: offdiag share of the
  crossing 1 - maxdiag_cross/rho_cross.

LEG B -- THE PER-ATOM DIAGONAL (the potentially provable half):
(b1) the v_k K_n(y_k) profile over all nu atoms up to N_w + 5 on
  w9 + the sealed ladder sample (anchor rungs 12/26/40/52):
  WHICH atoms are binding (top-5 diag table with fold, u, x,
  class, primary p, v, d_{N_w}); LADDER CENSUS over all 42
  rungs: binding atom = argmax diag at N_w -- fraction ARCH,
  fraction with u < log 2 (below the first prime), fraction at
  nu-fold-rank <= 1 (the shallow edge).
(b2) THE CLASSICAL COMPARISON (typed COMPARISON_ONLY -- the
  equilibrium prediction is a comparison yardstick, NEVER a
  substitute source; r232a measured the discrete QP equilibrium
  to node accuracy only, cited): the mu-Christoffel function has
  the classical bulk asymptotic lambda_{mu,n}(y) ~ mu'(y) /
  (n omega(y)) (Mate-Nevai-Totik form; omega = arcsine
  equilibrium density of the hull 1/(pi sqrt((y-a)(b-y)))), i.e.
  K_n^cl(y) = n omega(y)/mu'_loc(y) with the sealed local
  density mu'_loc = (mu mass within R_LOC = 8 folds)/(x-width);
  soft-edge law ~ n^2.  Measured: the growth exponent p_k =
  halves log-slope of K_n(y_k) over [N_w/4, N_w] (typed
  BULK_LIKE / EDGE_LIKE by proximity to 1 vs 2) for the binding
  and a sealed bulk reference atom; the classical isolation
  degree n*_k = mu'_loc/(v_k omega(y_k)) (first n with
  v_k K^cl >= 1) for ALL nu atoms: coverage = min_k n*_k vs N_w,
  and n*_bind vs the measured n_DIAG (octave band 1.0); the same
  coverage census over the 42 rungs.
(b3) THE HONEST DETECTOR: is the per-atom condition WORLD_BLIND
  (expected YES -- the controls die at (C)): controls' maxdiag
  at n = 184 (their own N_w) measured to depth 189, their
  n_DIAG within the window; typed by measurement + the sealed
  r281 distance rule -- if blind, (D) is the metric-local,
  world-blind half and (C) carries the ENTIRE arithmetic.

LEG C -- THE COHERENCE HALF (where the arithmetic sits):
(c1) assist profiles over n and worlds: MAIN at the sealed
  degrees (20, 40, 120, 184, 185); every world at the sealed
  crossing fractions (0.25, 0.5, 0.75, 1.0) x its own crossing
  -- when do the controls become constructive-collective?
(c2) the GENERIC yardstick (r272-c3 / r273 from the other side):
  the assist is a weighted off-diagonal sum of the E kernel;
  with the NON-ADAPTIVE source vector u_v = sqrt(v)/||.|| the
  interference X_v = u_v^T Off u_v has the exact random-sign
  scale G_v = sqrt(sum_{i!=j} (u_i u_j E_ij)^2): z_v = X_v/G_v
  is the random-sign z-score (analytic, no MC), plus the
  cancellation depth C_off = X/sum|terms| (the r272 coordinate)
  and the same for the adaptive extremal vector.  Sealed typing
  at the crossing degree: MAIN_GENERIC_CTRL_OUTLIER iff
  |z_v(MAIN)| <= 3.0 AND every control |z_v| > 3.0; else
  MIXED(values).
(c3) REPLICATE ENSEMBLES around MAIN (conservation-gated):
  ENS_SIGN (16 pinned seeds): random re-assignment of the nu
  label over the union folds at FIXED positions, FIXED
  magnitude-per-fold, FIXED S_- (conservation gates bitwise);
  ENS_SCR (12 pinned seeds): the core position scramble
  (uniform u at the SAME masses -- weights bitwise identical,
  positions re-drawn).  Per replicate: crossing = minC + 1
  (r283 theorem; spectrally spot-gated on replicate 0 of each
  ensemble), assist_20, assist at own crossing, maxdiag/assist
  at own N_w.  MAIN POSITION: percentile of MAIN's assist_20
  (early, pre-crossing) and assist_cross (at the wall) in each
  ensemble; sealed typing per statistic: GENERIC iff pct in
  [0.2, 0.8], LOW_OUTLIER below, HIGH_OUTLIER above.

LEG D -- WARDS / MUST-FAILS (each loud): w9 E-construction gated
against the r283/r284 records (S = 367/263/104, N_w = 184, minC
184, crossing 185, rho records 20/120/185, top-5 eigs, margin
1.68e-4, diag max 0.9700, n_CS = 10, n_DIAG = 187, gain_Nw
1.0307, slack_Nw 50.2); mp ward (dps 60, chain + B recomputed)
on rho_184/rho_185 AND maxdiag_184 (rel bar 1e-6); controls minC
== flips 25/21/27/25 and spectral crossing == flip+1; 42-rung
census regression (anchors, offset distribution == r281,
half-filling 42/42); exact toys: (t1) HAND 2x2 (E = (1/16)
[[4,2],[2,2]]: lambda = (3+sqrt5)/16, assist = (sqrt5-1)/4,
offpart = sqrt5/20, diagpart = (15+sqrt5)/80, off-norm 1/8,
budget equivalence -- every value hand-computed); (t2) JF9
rational Christoffel cross-route (r284 route) + decomposition /
sandwich / Weyl / budget-equivalence gates at every n <= S_+,
crossing 4; (t3) toy conservation battery (legit sign ensemble
op passes the gates, hand counts).  MUST-FAILS: (m1) ASSIST
WITHOUT DIAGONAL SUBTRACTION: the mutant claiming the whole
Rayleigh quotient as off-diagonal interference must break the
exact decomposition identity by >= 0.1 rel; (m2) CHRISTOFFEL
WITHOUT WEIGHT: dropping v_k must break the exact trace identity
by >= 0.1 rel; (m3) ENSEMBLE WITHOUT CONSERVATION GATES: a
mutant surgery scaling one magnitude by 1.15 must be CAUGHT by
the conservation gate (multiset break >= 1e-3 rel); (m4) a
mutant orienting a degree by the withheld crossing is FLAGGED by
the AST scope audit.  PAIRCORR DETECTOR (sealed r281 distance
rule) on K_D1 = maxdiag_184, K_D2 = assist at own crossing,
K_C1 = z_v at own crossing, K_B1 = log10(n*_bind/N_w) (the
b2 classical statistic -- the demanded detector on the classical
arguments).  STOP LIST (anti-gates, binding): NO L* claim, NO
bound mechanism, NO asymptotic law, NO derived 5/7, NO triangle
bound as certificate, NO posthoc window, NO equilibrium
substitution (comparison only), NO RH claim; r243..r284 stand.

SEALED CONSTANTS: MAINS (9, 13, 15); MINC_OFF {9: 0, 13: 2,
15: 1}; ANCHORS {9:0, 12:2, 13:2, 26:3, 40:1, 15:1, 52:0};
R281_DIST {0:18, 1:10, 2:6, 3:6, 4:1, 5:1}; CTRL_FLIPS
{EPST:25, SCR:21, SMOOTH:27}; HL2 seed 101 flip 25; H_CAP 900;
EXT 8 / EXT2 32; DEPTH_PAD 6; CTRL_PAD 5 (controls measured to
N_w + 5 = 189); WARD_DPS 60; RHO_WARD_TOL 1e-6; ID_TOL 1e-12;
DEC_TOL 1e-10; SAND_TOL 1e-9; WEYL_TOL 1e-9; EQ_SKIP 1e-13
(|rho-1| band excluded from the equivalence sign gate);
PROF_DEGS (20, 40, 120, 184, 185); CROSS_FRACS (0.25, 0.5,
0.75, 1.0); R283_RHO {20: 0.47808, 120: 0.99898, 185: 1.00004}
tol 1e-5; R283_TOP5 (0.99983, 0.99874, 0.99597, 0.98461,
0.96408) tol 1e-4; MARGIN_REC 1.68e-4 rel tol 0.01; DIAGMAX_REC
0.9700 tol 5e-3; NCS_REC 10; NDIAG_REC 187; CROSS_REC 185;
GAIN_REC 1.0307 abs tol 5e-3; SLACK_REC 50.2 abs tol 1.0;
R_LOC 8; EDGE_U = log 2; GROWTH_FRACS (0.25, 0.5, 1.0); OCT_BAND
1.0; TOPD 5; SAMPLE_KZ (12, 26, 40, 52); BULK_REF = nu atom with
u closest to the v-weighted mean u; DET_DEG 20; A_MAIN_BAR 0.10;
A_CTRL_BAR 0.5; Z_GEN 3.0; ENS_SIGN_REPS 16; ENS_SCR_REPS 12;
SEED_BASE 285000; PCT_BAND (0.2, 0.8); M1_BAR 0.1; M2_BAR 0.1;
M3_BAR 1e-3; MUT_MASS 1.15; FP_BAR 0.9; ADMIT 1e-9; runtime
<= 1800 s; smoke = toys + firewall + scopes + mutants + w9 f64
block (decomposition, budget, per-atom, classical, MAIN assist
profile); ladder, mains, controls, ensembles, mp ward, detector
and adjudication skipped.  PRE-SPEC SCOPING (disclosed): the
r283/r284/r281 record numbers (S counts, minC offsets, flips,
rho/diag/gain/slack records) are consumed as sealed gate anchors;
the A_MAIN_BAR/A_CTRL_BAR bars quote the published r284 records
(assist 3.1 percent on MAIN; controls' maxdiag far below 1 at
crossing) -- record reading, not tuning; no machinery pass
preceded this spec except record reading; no bar, band or typing
rule was tuned after any evaluation of this probe.

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  DECOMPOSITION_EXACT(sealed forms i/ii, delta/delta' budgets
    over the ladder, control budget split) [awarded iff every
    accounting identity gates exactly AND rho_{N_w} < 1 on
    42/42 rungs; else DECOMPOSITION_BROKEN(locus)]
  + PERATOM_CLASSICAL(binding census, classical coverage +
    octave devs, blindness status) [always]
  + [exactly one of] COHERENCE_CARRIES_ARITHMETIC(assist
    profiles, generic-vs-outlier finding, ensemble position)
    iff (D) is world-blind (all four controls' maxdiag_184 < 1)
    AND assist_cross(MAIN) <= 0.10 AND min ctrl assist_cross
    >= 0.5 / COHERENCE_UNSTRUCTURED(measured values)
  + ENSEMBLE_POSITION(early pct + wall pct per ensemble, typed)
  + DETECTOR_LEDGER [always].
Honesty before beauty: the decomposition is EXACT BOOKKEEPING of
the open scalar L*, not a proof; the budget tables are MEASURED
on 42 rungs; the classical comparison is a yardstick (its octave
deviations are findings, not certificates); no verdict claims
L*, a bound mechanism, a derived 5/7 or an asymptotic law.

RECORD TABLES (frozen from the record run; calibration protocol,
chronology honest: smoke pass 1 = 33/33 at the sealed rules
(0.3 s), calibration pass 1 = first full evaluation = 33/33,
wall 7.1 s -- NO physics bar, band, rule or verdict rule was
moved at any point; the only post-freeze edit is this record-
table insertion, which IS the protocol; run1/run2 identical up
to WALL):
CAL_VERDICT = DECOMPOSITION_EXACT(mult + additive forms exact;
ladder maxdiag max 0.9941 / assist max 0.0702; ctrl offdiag
share 0.63..0.75) + PERATOM_CLASSICAL(binding ARCH 42/42,
u < log 2 42/42; n*_bind 58 vs n_DIAG 187 oct dev 1.68;
coverage 0/42 -> CLASSICAL_GAP; (D) SEPARATES) +
COHERENCE_UNSTRUCTURED(by the sealed blind_D clause -- the
assist itself separates cleanly, see the honest reading below)
+ ENSEMBLE_POSITION(sign_early 1.00 HIGH_OUTLIER, sign_wall
0.00 LOW_OUTLIER, scr_early 0.75 GENERIC, scr_wall 0.00
LOW_OUTLIER) + DETECTOR_LEDGER(K_D1 WORLD_BLIND / K_D2
MAIN_SEPARATING / K_C1 MAIN_SEPARATING / K_B1 WORLD_BLIND).
Key numbers.  W9 BOOKKEEPING (depth 190): multiplicative
identity dev 1.8e-16, Rayleigh decomposition dev 2.0e-15,
budget equivalence sign-exact at every degree, Weyl bracket
holds; at N_w: maxdiag 0.97001 (delta 0.02999), assist 0.03074,
budget margin (1/maxdiag - 1) - assist = +1.727e-4 > 0 <=>
margin 1 - rho = 1.675e-4; additive remainder coh 0.02982 vs
Weyl off-norm 0.31667 (slack 0.287: the additive bookkeeping is
coarse, the multiplicative form is the honest one).  MP WARD
(dps 60): rho_184 = 0.99983248 < 1 < 1.00003660 = rho_185,
maxdiag_184 dev 1.6e-13 (bar 1e-6).  LADDER BUDGETS (42 rungs,
at N_w): maxdiag min/med/max 0.9343/0.9792/0.9941 (max kz38,
delta_min 0.0059), halves med 0.970 -> 0.986, sp(N, maxdiag)
+0.65 -- THE TREND FINDING: the per-atom budget TIGHTENS toward
1 with N; assist min/med/max 0.0059/0.0212/0.0702 (max kz12),
halves 0.031 -> 0.014, sp(N, assist) -0.65 -- the coherent
assist SHRINKS with N: the budget split shifts toward the
diagonal with depth (delta is NOT uniform-stable; no L* budget
with fixed delta/delta' is supported by the measured trend --
a quantified, falsifiable statement, no asymptotic law
claimed); budget margin > 0 and rho_Nw < 1 on 42/42;
fingerprint sp vs withheld offset -0.28 / +0.29 (below the 0.9
alias bar); extra mains w13 (maxdiag 0.9548, assist 0.0472,
cross 171) / kz15 (0.9710, 0.0299, cross 205).  CONTROLS
(depth 189): minC == flips, crossings 26/22/28/26 == flip+1;
budget split at the crossing (maxdiag_c, assist_c, offshare):
EPST (0.376, 1.69, 0.63), SCR (0.256, 2.94, 0.75), SMOOTH
(0.262, 2.99, 0.75), HL2 (0.260, 2.96, 0.75) -- at the death
degree maxdiag sits at 0.26..0.38: the budget rips at (C).
THE b3 SURPRISE (the contract's 'presumably YES' is measured
NO): (D) is NOT world-blind at window scale -- the controls'
maxdiag crosses 1 at n_DIAG = 91/50/90/87 (EPST/SCR/SMOOTH/
HL2), far above their crossings 26/22/28/26 but far below 184
(maxdiag_184 = 1170/8.5e6/1.93/1269); MAIN alone holds the
per-atom bound through its whole free window (n_DIAG = 187 >
185 > 184) -- (D) itself carries world separation at window
scale, so the clean split '(D) metric-local blind + (C) all
the arithmetic' is REFUTED as stated; the arithmetic sits in
BOTH halves at window scale, while at the DEATH DEGREE the
split is clean (controls die collectively via (C) with
maxdiag 0.26..0.38).  PER-ATOM (w9): top-5 diag atoms at N_w =
folds 2/4/6/8/10 (d = 0.9700/0.9649/0.9604/0.9535/0.9411, ALL
ARCH, u = 0.030..0.151, v = 2.8e-6..4.4e-6) -- the shallow-u
edge family BELOW the first prime, near-degenerate leaders;
binding fold 2 == r284 argmax; LADDER CENSUS: binding ARCH
42/42, u < log 2 42/42, nu-fold-rank <= 1 41/42, sample rungs
12/26/40/52 all bind at fold 2.  CLASSICAL (typed
COMPARISON_ONLY): p_bind = 0.38 (SUB-classical -- the measured
kernel growth at the binding edge atom is SLOWER than the bulk
law 1, not faster; BULK_LIKE by the sealed proximity rule),
p_bulk(f = 215, u = 3.24) = 1.27; K_meas/K_cl at N_w = 0.31;
n*_bind = 58 vs n_DIAG 187 (1.68 octaves OUTSIDE the band);
coverage min_k n* = 58.3 at fold 2 << N_w, 0/42 rungs covered
(n*_bind med 175 vs N med 388) -- the arcsine bulk law does
NOT carry (D) anywhere: (D) survives BECAUSE the discrete
kernel grows sub-classically at the binding atoms (measured
0.38 vs classical 1) -- the provability route for (D) must be
a DISCRETE bound, not continuum asymptotics; quantified gap
statement, no certificate.  COHERENCE: MAIN assist profile
4.25/1.74/0.39/0.031/0.019 at n = 20/40/120/184/185 (falls two
decades into the wall); controls at crossing fractions 0.25/
0.5/0.75/1.0: EPST 4.79/2.54/1.95/1.69, SCR 8.58/4.30/3.99/
2.94, SMOOTH 3.81/3.66/3.46/2.99, HL2 6.90/4.84/5.19/2.96 --
high-assist throughout, still ~2..3 at the flip (collective
death) vs MAIN 0.019 (single-atom wall); z-scores at the
crossing: MAIN z_v = -3.15 (DESTRUCTIVE, marginally outside
the |z| <= 3 generic band; C_off = -0.105, adaptive z_x =
+3.36) vs controls z_v = +12.4/+6.6/+5.0/+6.3 (ALL
CONSTRUCTIVE): the SIGN separates cleanly, the sealed
band rule types MIXED because MAIN sits at -3.15 (honest;
the r272/r273 generic-cancellation reading survives in sign,
not in the sealed band).  ENSEMBLES (conservation exact,
crossing == minC+1 spot-gated): ENS_SIGN 16 reps, crossings
5..21 (med 13), assist_20 med 1.25 -> MAIN 4.25 pct 1.00
HIGH_OUTLIER, assist_cross med 1.89 -> MAIN 0.0195 pct 0.00
LOW_OUTLIER; ENS_SCR 12 reps (S 367..367), crossings 5..28,
assist_20 med 3.80 -> pct 0.75 GENERIC, assist_cross med 3.99
-> pct 0.00 LOW_OUTLIER -- MAIN's wall coherence is the
extreme LOW outlier of both ensembles (every replicate dies
collectively; MAIN's near-single-atom wall is MAIN-specific),
while its early coherence is scramble-generic and even HIGH
against the sign ensemble.  DETECTOR: K_D1_maxdiag184
WORLD_BLIND (the dead spread 1.9..8.5e6 swallows everything),
K_D2_assist_cross MAIN_SEPARATING (0.0195 vs 1.69..2.99),
K_C1_zv_cross MAIN_SEPARATING (-3.15 vs +4.95..+12.44),
K_B1_nstar_ratio WORLD_BLIND (SCR binding atom edge-degenerate,
guard value disclosed).  MUST-FAILS: m1 dev 0.968 LOUD; m2 dev
1.0e+05 LOUD; m3 break 1.5e-1 CAUGHT; m4 flagged
(cross_true@545); constructors + fragment audit CLEAN.
Runtime 7.1 s full / 0.3 s smoke; run1/run2 identical up to
WALL.  AMENDMENTS AFTER FREEZE: NONE.

NO RH CLAIM IN EITHER DIRECTION.  NOT evidence for or against RH.
"""

from __future__ import annotations

import argparse
import ast
import hashlib
import math
import os
import sys
import time

import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
if HERE not in sys.path:
    sys.path.insert(0, HERE)

import lstar_two_measure_probe as LS              # noqa: E402 r284
import fullsource_quasidefiniteness_probe as FS   # noqa: E402 r283
import budget_localization_probe as BL            # noqa: E402 r280
import metric_stability_probe as MS               # noqa: E402 r278
import port_integrable_kernel_probe as PIK        # noqa: E402 v881
import principal_bessel_probe as PB               # noqa: E402 r243
import paircorr_margin_probe as PC                # noqa: E402
import bordered_hankel_probe as BH                # noqa: E402 r244
import wronskian_dictionary_probe as WD           # noqa: E402 r274
import jfraction_probe as JF                      # noqa: E402 r230
import v563_paper2_readouts as core               # noqa: E402 READ-ONLY

MAINS = (9, 13, 15)
MINC_OFF = {9: 0, 13: 2, 15: 1}
ANCHORS = {9: 0, 12: 2, 13: 2, 26: 3, 40: 1, 15: 1, 52: 0}
R281_DIST = {0: 18, 1: 10, 2: 6, 3: 6, 4: 1, 5: 1}
CTRL_FLIPS = {"EPST": 25, "SCR": 21, "SMOOTH": 27}
HL2_SEED = 101
HL2_FLIP = 25
H_CAP = 900
EXT = 8
EXT2 = 32
DEPTH_PAD = 6
CTRL_PAD = 5
WARD_DPS = 60
RHO_WARD_TOL = 1e-6
ID_TOL = 1e-12
DEC_TOL = 1e-10
SAND_TOL = 1e-9
WEYL_TOL = 1e-9
EQ_SKIP = 1e-13
PROF_DEGS = (20, 40, 120, 184, 185)
CROSS_FRACS = (0.25, 0.5, 0.75, 1.0)
R283_RHO = {20: 0.47808, 120: 0.99898, 185: 1.00004}
RHO_TOL = 1e-5
R283_TOP5 = (0.99983, 0.99874, 0.99597, 0.98461, 0.96408)
TOP5_TOL = 1e-4
MARGIN_REC = 1.68e-4
MARGIN_TOL = 0.01
DIAGMAX_REC = 0.9700
DIAGMAX_TOL = 5e-3
NCS_REC = 10
NDIAG_REC = 187
CROSS_REC = 185
GAIN_REC = 1.0307
GAIN_TOL = 5e-3
SLACK_REC = 50.2
SLACK_TOL = 1.0
R_LOC = 8
EDGE_U = math.log(2.0)
GROWTH_FRACS = (0.25, 0.5, 1.0)
OCT_BAND = 1.0
TOPD = 5
SAMPLE_KZ = (12, 26, 40, 52)
DET_DEG = 20
A_MAIN_BAR = 0.10
A_CTRL_BAR = 0.5
Z_GEN = 3.0
ENS_SIGN_REPS = 16
ENS_SCR_REPS = 12
SEED_BASE = 285000
PCT_BAND = (0.2, 0.8)
M1_BAR = 0.1
M2_BAR = 0.1
M3_BAR = 1e-3
MUT_MASS = 1.15
FP_BAR = 0.9
ADMIT = 1e-9

SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest()
T0_WALL = time.time()
CHECKS: list = []


def check(name, ok, detail):
    ok = bool(ok)
    CHECKS.append((name, ok, detail))
    print("  [%s] %-42s %s" % ("PASS" if ok else "FAIL", name, detail),
          flush=True)
    return ok


def info(msg):
    print("  [INFO] " + msg, flush=True)


def section(t):
    print("\n" + "-" * 78 + "\n" + t + "\n" + "-" * 78, flush=True)


def firewall_audit():
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    forb = {"zeta" + "zero", "n" + "zeros", "prime" + "range",
            "is" + "prime", "gram" + "point"}
    bad = []
    for node in ast.walk(tree):
        nm = node.attr if isinstance(node, ast.Attribute) else (
            node.id if isinstance(node, ast.Name) else None)
        if nm and nm.lower() in forb:
            bad.append("%s@%d" % (nm, node.lineno))
    return (not bad), ("NO zero/prime oracles; atom classes via the "
                       "r254 integer root extraction; the sealed "
                       "constructors consume split-source arrays and "
                       "kernel matrices ONLY; record counts, offsets "
                       "and flips enter gates and record tables only"
                       if not bad else "; ".join(bad))


def antigate_fragment_audit():
    frags = ("poly" + "fit", "curve_" + "fit", "lst" + "sq",
             "mini" + "mize", "Line" + "arRegression")
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        nm = None
        if isinstance(node, ast.Attribute):
            nm = node.attr
        elif isinstance(node, ast.Name):
            nm = node.id
        elif isinstance(node, ast.FunctionDef):
            nm = node.name
        if nm and any(f in nm for f in frags):
            hits.append("%s@%d" % (nm, node.lineno))
    return hits


CONSTRUCTORS = ("decomp_parts", "assist_terms", "weyl_off_norm",
                "eq_density", "local_density", "classical_nstar",
                "growth_slope", "sign_assignment", "cons_check")
SCOPE_FORBIDDEN = {"ANCHORS", "MINC_OFF", "CTRL_FLIPS", "HL2_FLIP",
                   "R281_DIST", "minC_true", "cross_true",
                   "offs_true"}


def scope_audit(funcname):
    src = open(os.path.abspath(__file__), "r", encoding="utf-8").read()
    tree = ast.parse(src)
    hits = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == funcname:
            for sub in ast.walk(node):
                nm = None
                if isinstance(sub, ast.Attribute):
                    nm = sub.attr
                elif isinstance(sub, ast.Name):
                    nm = sub.id
                elif isinstance(sub, ast.Constant) \
                        and isinstance(sub.value, str):
                    nm = sub.value
                if nm in SCOPE_FORBIDDEN:
                    hits.append("%s@%d" % (nm, sub.lineno))
    return hits


# ============== sealed source-pure constructors (AST-audited)
def decomp_parts(E, u):
    """exact Rayleigh decomposition of rho = u^T E u into the
    diagonal part sum u_k^2 d_k and the off-diagonal interference
    X = u^T Off u, plus the random-sign scale G = sqrt(sum of the
    squared off-diagonal terms (u_i u_j E_ij)^2) and the absolute
    term sum A (cancellation-depth denominator)."""
    d = np.diag(E).copy()
    diagpart = float(np.sum(u * u * d))
    Off = E - np.diag(d)
    X = float(u @ (Off @ u))
    T = np.outer(u, u) * Off
    G = float(math.sqrt(np.sum(T * T)))
    A = float(np.sum(np.abs(T)))
    return diagpart, X, G, A


def assist_terms(rho, maxd):
    """the sealed multiplicative bookkeeping: assist = rho/maxd
    - 1 (definition-exact), the budget headroom 1/maxd - 1, and
    the budget margin (1/maxd - 1) - assist (> 0 <=> rho < 1)."""
    assist = rho / maxd - 1.0
    head = 1.0 / maxd - 1.0
    return assist, head, head - assist


def weyl_off_norm(E):
    """lambda_max of the off-diagonal part (the Weyl bracket of
    the additive bookkeeping)."""
    Off = E - np.diag(np.diag(E).copy())
    return float(np.linalg.eigvalsh(Off)[-1])


def eq_density(y, a, b):
    """arcsine equilibrium density of the hull [a, b]; inf on the
    closed boundary (edge-degenerate, handled by the caller)."""
    q = (y - a) * (b - y)
    if q <= 0.0:
        return float("inf")
    return 1.0 / (math.pi * math.sqrt(q))


def local_density(fp, wp, f0, L, R):
    """sealed local mu density at fold f0: mu mass within R fold
    steps / the x-width of the (clamped) fold window under
    x = cos(2 pi f / L)."""
    fps = np.sort(np.asarray(fp, np.int64))
    o = np.argsort(fp)
    wps = np.asarray(wp, float)[o]
    cw = np.concatenate([[0.0], np.cumsum(wps)])
    lo = int(np.searchsorted(fps, f0 - R, side="left"))
    hi = int(np.searchsorted(fps, f0 + R, side="right"))
    mass = float(cw[hi] - cw[lo])
    f_lo = max(f0 - R, 0)
    f_hi = min(f0 + R, L // 2)
    x_hi = math.cos(2.0 * math.pi * f_lo / L)
    x_lo = math.cos(2.0 * math.pi * f_hi / L)
    width = x_hi - x_lo
    return mass, width, (mass / width if width > 0 else float("inf"))


def classical_nstar(dens, v, omega):
    """the classical isolation degree: first n with
    v K^cl_n = v n omega / dens >= 1, i.e. n* = dens/(v omega);
    0 for edge-degenerate atoms (omega = inf)."""
    if not math.isfinite(omega) or omega <= 0.0:
        return 0.0
    return dens / (v * omega)


def growth_slope(kvals, nvals):
    """halves log-slope: difference of mean ln K between the
    second and first half of the degree window, divided by the
    same for ln n."""
    m = len(kvals) // 2
    k1 = np.log(np.asarray(kvals[:m], float))
    k2 = np.log(np.asarray(kvals[m:], float))
    n1 = np.log(np.asarray(nvals[:m], float))
    n2 = np.log(np.asarray(nvals[m:], float))
    return float((np.mean(k2) - np.mean(k1))
                 / (np.mean(n2) - np.mean(n1)))


def sign_assignment(n_folds, n_neg, seed):
    """sealed sign-ensemble assignment: a pinned-seed choice of
    exactly n_neg of the n_folds union slots to carry the nu
    label (positions and magnitudes untouched by construction)."""
    rng = np.random.default_rng(seed)
    mask = np.zeros(n_folds, bool)
    mask[rng.permutation(n_folds)[:n_neg]] = True
    return mask


def cons_check(folds_a, mags_a, folds_b, mags_b, n_neg, mask):
    """conservation gate for the sign ensemble: identical fold
    sets, identical magnitude-per-fold, exact nu count; returns
    (ok, max rel magnitude dev)."""
    fa = np.asarray(folds_a, np.int64)
    fb = np.asarray(folds_b, np.int64)
    ma = np.asarray(mags_a, float)
    mb = np.asarray(mags_b, float)
    if len(fa) != len(fb) or not np.array_equal(fa, fb):
        return False, float("inf")
    dev = float(np.max(np.abs(ma - mb)
                       / np.maximum(np.abs(ma), 1e-300)))
    ok = dev == 0.0 and int(np.sum(mask)) == n_neg
    return ok, dev


# ============== must-fail mutants
def mutant_nodiag_assist(E, u):
    """m1 MUST-FAIL: 'off-diagonal interference' WITHOUT the
    diagonal subtraction -- claims the whole Rayleigh quotient;
    must break the exact decomposition identity loudly."""
    return float(u @ (E @ u))


def mutant_unweighted_cs(cum, vn):
    """m2 MUST-FAIL: the Christoffel sum WITHOUT the nu weights
    (must break the exact trace identity, r284 form)."""
    return np.sum(cum / np.asarray(vn, float)[:, None], axis=0)


def mutant_mass_scale(mags):
    """m3 MUST-FAIL: an ensemble surgery that scales the largest
    magnitude by 1.15 -- the conservation gate must CATCH it."""
    out = np.asarray(mags, float).copy()
    out[int(np.argmax(out))] *= MUT_MASS
    return out


def mutant_cross_oracle(cross_true):
    """m4 MUST-FAIL: a degree oriented by the withheld crossing
    -- the scope audit must FLAG this."""
    return cross_true - 1


# ============== gate-side helpers
def rho_at(B, n):
    """lambda_max(E_n) at a single degree (gate-side)."""
    Bn = B[:, :n]
    return float(np.linalg.eigvalsh(Bn @ Bn.T)[-1])


def budget_block(W, depth):
    """gate-side budget bundle at one depth: chain, B, cumulative
    Christoffel rows, maxdiag/trace profiles."""
    al, sb, h0 = FS.mu_chain_f64(np.asarray(W["xp"]),
                                 np.asarray(W["wp"]), depth)
    B = FS.b_matrix_f64(al, sb, h0, np.asarray(W["xn"]),
                        np.asarray(W["vn"]), depth)
    cum = LS.christoffel_rows(B)
    return dict(B=B, cum=cum,
                maxd=np.max(cum, axis=0),
                trace=np.sum(cum, axis=0), depth=depth)


def nstar_all(W, R):
    """gate-side classical isolation degrees for all nu atoms of
    one world (edge-degenerate atoms reported as 0)."""
    xu = np.concatenate([np.asarray(W["xp"]), np.asarray(W["xn"])])
    a, b = float(np.min(xu)), float(np.max(xu))
    out = np.zeros(W["Sm"])
    dens_l = np.zeros(W["Sm"])
    omg_l = np.zeros(W["Sm"])
    for k in range(W["Sm"]):
        omg = eq_density(float(W["xn"][k]), a, b)
        _m, _w, dens = local_density(W["fp"], W["wp"],
                                     int(W["fn"][k]), W["L"], R)
        out[k] = classical_nstar(dens, float(W["vn"][k]), omg)
        dens_l[k] = dens
        omg_l[k] = omg if math.isfinite(omg) else -1.0
    return out, dens_l, omg_l


def ens_sign_world(x_all, mags, mask, need_deg, det_deg):
    """gate-side sign-ensemble replicate: signed union -> minC
    (sign chain) -> mu chain/B -> (assist_20, assist at own
    crossing, maxdiag/assist at 184, crossing)."""
    wu = mags * np.where(mask, -1.0, 1.0)
    N_half = (len(x_all) + 1) // 2
    sg, _lg, _r = BL.sign_chain_f64(x_all, wu, N_half + EXT)
    mc = next((n for n in range(len(sg)) if sg[n] < 0), None)
    if mc is None:
        sg, _lg, _r = BL.sign_chain_f64(x_all, wu, N_half + EXT2)
        mc = next((n for n in range(len(sg)) if sg[n] < 0), None)
    cross = (mc + 1) if mc is not None else None
    xp, wp = x_all[~mask], mags[~mask]
    yn, vn = x_all[mask], mags[mask]
    depth = min(max(need_deg, (cross or 1) + 1, det_deg + 1),
                len(xp) - 1)
    al, sb, h0 = FS.mu_chain_f64(xp, wp, depth)
    B = FS.b_matrix_f64(al, sb, h0, yn, vn, depth)
    cum = LS.christoffel_rows(B)
    res = dict(minC=mc, cross=cross, depth=depth, B=B, cum=cum,
               Nw=N_half)
    for tag, n in (("20", det_deg), ("cross", cross),
                   ("Nw", min(need_deg, depth))):
        if n is None or n > depth:
            res["assist_" + tag] = None
            continue
        r = rho_at(B, n)
        md = float(np.max(cum[:, n - 1]))
        res["assist_" + tag] = r / md - 1.0
        res["maxd_" + tag] = md
        res["rho_" + tag] = r
    return res


# --------------------------------------------------------------- main
def main():
    par_ = argparse.ArgumentParser()
    par_.add_argument("--smoke", action="store_true")
    args = par_.parse_args()
    smoke = args.smoke

    print("=" * 78)
    print("christoffel_decomposition_probe -- PRIME.PORT.LSTAR."
          "CHRISTOFFEL_DECOMPOSITION.01 (round 285)")
    print("SPEC_SHA %s   (r284 LS %s / r283 FS %s)"
          % (SPEC_SHA[:16], LS.SPEC_SHA[:16], FS.SPEC_SHA[:16]))
    print("mode: %s" % ("SMOKE (toys + firewall + scopes + mutants "
                        "+ w9 f64 block; ladder, mains, controls, "
                        "ensembles, mp ward, detector, adjudication "
                        "skipped)" if smoke else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "sealed BEFORE evaluation: the two bookkeeping forms "
          "(multiplicative assist, additive remainder + Weyl "
          "bracket), the budget theorem and its equivalence gate, "
          "the ladder/control budget tables, the per-atom census "
          "rules, the classical yardstick (arcsine hull density + "
          "sealed local density, typed COMPARISON_ONLY), the "
          "coherence z-score and its typing, both ensembles with "
          "conservation gates and pinned seeds, every bar/band/"
          "tolerance, the mutants and the verdict form; the STOP "
          "list forbids any L* claim and any equilibrium "
          "substitution")

    # ---------------- S1 toys
    section("S1  TOYS -- HAND 2x2, JF9 DECOMPOSITION, CONSERVATION")
    # t1: hand 2x2  E = (1/16) [[4, 2], [2, 2]]
    E_t = np.array([[4.0, 2.0], [2.0, 2.0]]) / 16.0
    ev_t, V_t = np.linalg.eigh(E_t)
    lam_t = float(ev_t[-1])
    u_t = V_t[:, -1]
    maxd_t = 0.25
    s5 = math.sqrt(5.0)
    lam_h = (3.0 + s5) / 16.0
    assist_h = (s5 - 1.0) / 4.0
    off_h = s5 / 20.0
    diag_h = (15.0 + s5) / 80.0
    dg_t, X_t, _G_t, _A_t = decomp_parts(E_t, u_t)
    a_t, hd_t, mg_t = assist_terms(lam_t, maxd_t)
    wn_t = weyl_off_norm(E_t)
    coh_t = lam_t - maxd_t
    ok_t1 = (abs(lam_t - lam_h) <= 1e-14
             and abs(a_t - assist_h) <= 1e-14
             and abs(X_t - off_h) <= 1e-14
             and abs(dg_t - diag_h) <= 1e-14
             and abs(dg_t + X_t - lam_t) <= 1e-15
             and abs(wn_t - 0.125) <= 1e-14
             and 0.0 <= coh_t <= wn_t + 1e-15
             and (mg_t > 0.0) == (lam_t < 1.0)
             and abs(maxd_t * (1.0 + a_t) - lam_t) <= 1e-16)
    check("G10-toy-hand2x2", ok_t1,
          "HAND 2x2 (E = (1/16)[[4,2],[2,2]]): lambda = (3+sqrt5)"
          "/16 = %.10f, assist = (sqrt5-1)/4 = %.10f, offpart = "
          "sqrt5/20 = %.10f, diagpart = (15+sqrt5)/80 = %.10f, "
          "off-norm = 1/8; multiplicative identity, Rayleigh "
          "decomposition, Weyl bracket 0 <= coh = %.6f <= %.6f "
          "and the budget equivalence all EXACT vs hand values"
          % (lam_t, a_t, X_t, dg_t, coh_t, wn_t))
    # t2: JF9 rational cross-route + decomposition at every n
    jf_pairs = sorted(zip(JF.TOY_NODES, JF.TOY_WTS),
                      key=lambda t: t[0])
    nodes9 = [t[0] for t in jf_pairs]
    wts9 = [t[1] for t in jf_pairs]
    xs_r = [x for x, w in zip(nodes9, wts9) if w > 0]
    ws_r = [w for w in wts9 if w > 0]
    ys_r = [x for x, w in zip(nodes9, wts9) if w < 0]
    vs_r = [-w for w in wts9 if w < 0]
    Sp_t = len(xs_r)
    alm, bem, hsm = WD.stj_gen(xs_r, ws_r, Sp_t - 1)
    vals = [WD.pv_seq(alm, bem, y, Sp_t - 1) for y in ys_r]
    al_f, sb_f, h0_f = FS.mu_chain_f64(
        np.array([float(x) for x in xs_r]),
        np.array([float(w) for w in ws_r]), Sp_t)
    B_t = FS.b_matrix_f64(al_f, sb_f, h0_f,
                          np.array([float(y) for y in ys_r]),
                          np.array([float(v) for v in vs_r]), Sp_t)
    cum_t = LS.christoffel_rows(B_t)
    dev_chr = 0.0
    for n in range(1, Sp_t + 1):
        for k in range(len(ys_r)):
            exact = vs_r[k] * sum(vals[k][i] * vals[k][i] / hsm[i]
                                  for i in range(n))
            dev_chr = max(dev_chr,
                          abs(cum_t[k, n - 1] - float(exact))
                          / max(abs(float(exact)), 1e-300))
    cr_t, rho_t = FS.crossing_from_B(B_t, Sp_t)
    dev_dec = 0.0
    ok_sand = True
    ok_weyl = True
    ok_eq = True
    for n in range(1, Sp_t + 1):
        Bn = B_t[:, :n]
        En = Bn @ Bn.T
        evn, Vn = np.linalg.eigh(En)
        un = Vn[:, -1]
        dgn, Xn, _g, _a = decomp_parts(En, un)
        dev_dec = max(dev_dec, abs(dgn + Xn - float(evn[-1]))
                      / max(abs(float(evn[-1])), 1e-300))
        mdn = float(np.max(cum_t[:, n - 1]))
        trn = float(np.sum(cum_t[:, n - 1]))
        ok_sand = ok_sand and (mdn <= rho_t[n] + SAND_TOL
                               and rho_t[n] <= trn + SAND_TOL)
        ok_weyl = ok_weyl and (rho_t[n] - mdn
                               <= weyl_off_norm(En) + WEYL_TOL)
        an, _h, mn = assist_terms(rho_t[n], mdn)
        if abs(rho_t[n] - 1.0) > EQ_SKIP:
            ok_eq = ok_eq and ((mn > 0.0) == (rho_t[n] < 1.0)) \
                and abs(mdn * (1.0 + an) - rho_t[n]) \
                <= ID_TOL * max(rho_t[n], 1.0)
    check("G11-toy-jf9-decomposition", dev_chr <= DEC_TOL
          and dev_dec <= DEC_TOL and ok_sand and ok_weyl
          and ok_eq and cr_t == 4,
          "JF9: rational Christoffel cross-route max rel dev "
          "%.1e (bar %.0e); Rayleigh decomposition dev %.1e; "
          "sandwich + Weyl bracket + budget equivalence at every "
          "n <= S_+ = %d; crossing %s == 4 (r283 record)"
          % (dev_chr, DEC_TOL, dev_dec, Sp_t, str(cr_t)))
    # t3: toy conservation battery
    tf = np.array([1, 2, 3, 4, 5], np.int64)
    tm = np.array([1.0, 0.5, 0.25, 0.125, 0.0625])
    msk_t = sign_assignment(5, 2, SEED_BASE)
    okc_t, dev_c = cons_check(tf, tm, tf, tm, 2, msk_t)
    check("G12-toy-conservation", okc_t and dev_c == 0.0
          and int(np.sum(msk_t)) == 2,
          "TOY CONSERVATION: the legit sign-ensemble op preserves "
          "fold set + magnitude-per-fold bitwise (dev %.1f) and "
          "carries exactly 2 of 5 nu labels (hand count) -- the "
          "gate passes the legit op" % dev_c)

    # ---------------- S2 w9 machinery + regression
    section("S2  W9 -- E-CONSTRUCTION GATED AGAINST r283/r284")
    rr9 = core.build_window(9)
    D9 = float(rr9["D"])
    ctx9 = MS.ctx_build(9)
    W9 = LS.world_pack("w9", ctx9, D9)
    ok_src = (W9["S"] == 367 and W9["Sp"] == 263
              and W9["Sm"] == 104
              and W9["N"] == (W9["S"] + 1) // 2
              and W9["minC"] == W9["N"] + MINC_OFF[9])
    check("G20-w9-source-split", ok_src,
          "w9 FULL SOURCE: S = %d (mu %d / nu %d), N_w = %d == "
          "(S+1)//2, minC = %s == N_w + %d (record)"
          % (W9["S"], W9["Sp"], W9["Sm"], W9["N"],
             str(W9["minC"]), MINC_OFF[9]))
    depth9 = min(W9["N"] + DEPTH_PAD, W9["Sp"] - 1)
    SP9 = LS.spectral_block(W9, depth9)
    rho9 = SP9["rho"]
    check("G21-w9-crossing", SP9["cross"] == W9["minC"] + 1
          and SP9["cross"] == CROSS_REC,
          "lambda_max(E_n) crosses 1 at n = %s == minC + 1 == %d "
          "(r283/r284 route reproduced)"
          % (str(SP9["cross"]), CROSS_REC))
    Nw = W9["N"]
    E184 = SP9["B"][:, :Nw] @ SP9["B"][:, :Nw].T
    ev184 = np.linalg.eigvalsh(E184)
    top5 = ev184[-5:][::-1]
    margin9 = 1.0 - rho9[Nw]
    dmax184 = float(SP9["maxd"][Nw - 1])
    gain9 = float(rho9[Nw] / SP9["maxd"][Nw - 1])
    slack9 = float(SP9["trace"][Nw - 1] / rho9[Nw])
    ok_rec = all(abs(rho9[n] - R283_RHO[n]) <= RHO_TOL
                 for n in R283_RHO)
    ok_top = all(abs(float(top5[i]) - R283_TOP5[i]) <= TOP5_TOL
                 for i in range(5))
    ok_r284 = (SP9["n_cs"] == NCS_REC and SP9["n_diag"] == NDIAG_REC
               and abs(gain9 - GAIN_REC) <= GAIN_TOL
               and abs(slack9 - SLACK_REC) <= SLACK_TOL)
    check("G22-w9-profile-regression",
          ok_rec and ok_top and ok_r284
          and abs(margin9 / MARGIN_REC - 1.0) <= MARGIN_TOL
          and abs(dmax184 - DIAGMAX_REC) <= DIAGMAX_TOL
          and rho9[Nw] < 1.0,
          "r283/r284 RECORDS REPRODUCED: rho_20/120/185 dev <= "
          "%.0e; top-5 eigs ok; margin %.4e (rec %.2e); diagmax "
          "%.5f (rec %.4f); n_CS = %s (rec %d), n_DIAG = %s (rec "
          "%d), gain_Nw = %.4f (rec %.4f), slack_Nw = %.1f (rec "
          "%.1f)" % (RHO_TOL, margin9, MARGIN_REC, dmax184,
                     DIAGMAX_REC, str(SP9["n_cs"]), NCS_REC,
                     str(SP9["n_diag"]), NDIAG_REC, gain9,
                     GAIN_REC, slack9, SLACK_REC))
    if smoke:
        check("G23-w9-mp-ward", True, "SMOKE: skipped")
    else:
        alm9, sbm9, h0m9 = FS.mu_chain_mp(
            np.asarray(W9["xp"]), np.asarray(W9["wp"]), depth9,
            WARD_DPS)
        B9m = FS.b_matrix_mp(alm9, sbm9, h0m9,
                             np.asarray(W9["xn"]),
                             np.asarray(W9["vn"]), depth9,
                             WARD_DPS)
        cum_m = LS.christoffel_rows(B9m)
        md_mp = float(np.max(cum_m[:, Nw - 1]))
        devs = {}
        rho_mp = {}
        for n in (Nw, Nw + 1):
            Bn = B9m[:, :n]
            rmp = float(np.linalg.eigvalsh(Bn @ Bn.T)[-1])
            rho_mp[n] = rmp
            devs[n] = abs(rmp - rho9[n]) / max(abs(rmp), 1e-300)
        dev_md = abs(md_mp - dmax184) / max(abs(md_mp), 1e-300)
        ok_ward = (max(devs.values()) <= RHO_WARD_TOL
                   and dev_md <= RHO_WARD_TOL
                   and rho_mp[Nw] < 1.0 and rho_mp[Nw + 1] > 1.0)
        check("G23-w9-mp-ward", ok_ward,
              "MP WARD (dps %d): rho_184 = %.8f < 1 < %.8f = "
              "rho_185 (rel devs %.1e / %.1e), maxdiag_184 dev "
              "%.1e (bar %.0e) -- budget arbitration-safe"
              % (WARD_DPS, rho_mp[Nw], rho_mp[Nw + 1], devs[Nw],
                 devs[Nw + 1], dev_md, RHO_WARD_TOL))

    # ---------------- S3 leg A -- decomposition + budgets
    section("S3  LEG A -- EXACT BOOKKEEPING + BUDGETS")
    dev_mult = 0.0
    dev_dec9 = 0.0
    ok_weyl9 = True
    ok_eq9 = True
    weyl_tab = {}
    for n in range(1, depth9 + 1):
        mdn = float(SP9["maxd"][n - 1])
        an, _h, mn = assist_terms(rho9[n], mdn)
        dev_mult = max(dev_mult, abs(mdn * (1.0 + an) - rho9[n])
                       / max(rho9[n], 1e-300))
        if abs(rho9[n] - 1.0) > EQ_SKIP:
            ok_eq9 = ok_eq9 and ((mn > 0.0) == (rho9[n] < 1.0))
    for n in PROF_DEGS:
        Bn = SP9["B"][:, :n]
        En = Bn @ Bn.T
        evn, Vn = np.linalg.eigh(En)
        un = Vn[:, -1]
        dgn, Xn, Gn, An = decomp_parts(En, un)
        dev_dec9 = max(dev_dec9, abs(dgn + Xn - float(evn[-1]))
                       / max(abs(float(evn[-1])), 1e-300))
        wn = weyl_off_norm(En)
        coh = float(evn[-1]) - float(SP9["maxd"][n - 1])
        ok_weyl9 = ok_weyl9 and (-WEYL_TOL <= coh <= wn + WEYL_TOL)
        weyl_tab[n] = (coh, wn)
    check("G30-decomposition-identities",
          dev_mult <= ID_TOL and dev_dec9 <= DEC_TOL
          and ok_weyl9 and ok_eq9,
          "w9 EXACT BOOKKEEPING at every n <= %d: multiplicative "
          "identity lambda == maxdiag x (1 + assist) dev %.1e "
          "(bar %.0e); budget equivalence (margin > 0 <=> rho < "
          "1) sign-exact outside the %.0e band; Rayleigh "
          "decomposition rho == diagpart + offpart dev %.1e at "
          "the sealed degrees; Weyl bracket 0 <= coh <= "
          "lambda_max(Off) holds -- NO give-away sandwich"
          % (depth9, dev_mult, ID_TOL, EQ_SKIP, dev_dec9))
    a9, h9, m9 = assist_terms(float(rho9[Nw]), dmax184)
    coh9, wn9 = weyl_tab[Nw]
    check("G31-w9-budget", m9 > 0.0 and a9 <= A_MAIN_BAR,
          "w9 BUDGET at N_w: maxdiag = %.5f (delta = %.5f), "
          "assist = %.5f (<= %.2f), budget margin (1/maxdiag - 1)"
          " - assist = %+.3e > 0 <=> margin 1 - rho = %.3e; "
          "ADDITIVE remainder coh = %.5f vs Weyl off-norm %.5f "
          "(slack %.3f -- the additive bookkeeping is coarse, "
          "the multiplicative form is the honest one)"
          % (dmax184, 1.0 - dmax184, a9, A_MAIN_BAR, m9, margin9,
             coh9, wn9, wn9 - coh9))
    if smoke:
        for g in ("G32-ladder-census", "G33-ladder-budgets",
                  "G34-mains-budgets", "G35-ctrl-budgets"):
            check(g, True, "SMOKE: skipped")
        WC = {}
        SPC = {}
        lad = {}
        ctrl_budget = {}
    else:
        kzs = [kz for kz in core.frame_a_zones()
               if PIK.build_rung(kz)["h"] <= H_CAP]
        lad = {}
        ok_hf = True
        for kz in kzs:
            if kz == 9:
                Wp, ctxk, Dk = W9, ctx9, D9
            else:
                ctxk = MS.ctx_build(kz)
                Dk = float(core.build_window(kz)["D"])
                Wp = LS.world_pack("w%d" % kz, ctxk, Dk)
            ok_hf = ok_hf and (Wp["N"] == (Wp["S"] + 1) // 2)
            dep = min(Wp["N"], Wp["Sp"] - 1)
            bb = budget_block(Wp, dep)
            md = float(bb["maxd"][dep - 1])
            rh = rho_at(bb["B"], dep)
            ak, _hk, mk = assist_terms(rh, md)
            kb = int(np.argmax(bb["cum"][:, dep - 1]))
            lab = LS.atom_labels([int(Wp["fn"][kb])], Dk,
                                 Wp["uu"], Wp["mm"])[0]
            u_b = float(Wp["fn"][kb]) * Dk
            frank = int(np.searchsorted(
                np.sort(np.asarray(Wp["fn"])), Wp["fn"][kb]))
            ns_all, _dl, _ol = nstar_all(Wp, R_LOC)
            ns_in = ns_all[ns_all > 0.0]
            lad[kz] = dict(N=Wp["N"], S=Wp["S"],
                           off=Wp["minC"] - Wp["N"], maxd=md,
                           rho=rh, assist=ak, marg=mk,
                           bind_fold=int(Wp["fn"][kb]),
                           bind_cls=lab[0], bind_u=u_b,
                           bind_rank=frank,
                           ns_bind=float(ns_all[kb]),
                           ns_min=float(np.min(ns_in))
                           if len(ns_in) else 0.0,
                           n_edge_deg=int(np.sum(ns_all == 0.0)))
        offs_true = [lad[kz]["off"] for kz in sorted(lad)]
        dist = {}
        for o in offs_true:
            dist[o] = dist.get(o, 0) + 1
        ok_anch = all(lad[kz]["off"] == ANCHORS[kz]
                      for kz in ANCHORS if kz in lad)
        check("G32-ladder-census", len(lad) == 42 and ok_hf
              and ok_anch and dist == R281_DIST,
              "42-rung census (r281 channel): offset distribution "
              "%s == r281 record, anchors exact, half-filling "
              "42/42" % str({("+%d" % k): dist[k]
                             for k in sorted(dist)}))
        mds = [lad[kz]["maxd"] for kz in sorted(lad)]
        aks = [lad[kz]["assist"] for kz in sorted(lad)]
        Ns = [lad[kz]["N"] for kz in sorted(lad)]
        ok_bud = all(lad[kz]["rho"] < 1.0 and lad[kz]["marg"] > 0.0
                     and lad[kz]["maxd"] < 1.0 for kz in lad)
        sp_md = BH.spearman(Ns, mds)
        sp_ak = BH.spearman(Ns, aks)
        fp_md = BH.spearman(mds, offs_true)
        fp_ak = BH.spearman(aks, offs_true)
        o_N = np.argsort(Ns)
        h1 = [mds[i] for i in o_N[:21]]
        h2 = [mds[i] for i in o_N[21:]]
        a1_ = [aks[i] for i in o_N[:21]]
        a2_ = [aks[i] for i in o_N[21:]]
        kz_mdmax = max(lad, key=lambda z: lad[z]["maxd"])
        kz_akmax = max(lad, key=lambda z: lad[z]["assist"])
        fp_typ = ("TARGET_ALIAS" if max(abs(fp_md), abs(fp_ak))
                  >= FP_BAR else "below alias bar")
        check("G33-ladder-budgets", ok_bud,
              "LADDER BUDGETS at N_w (42 rungs): maxdiag min/med/"
              "max %.4f/%.4f/%.4f (max at kz%d -> delta_min = "
              "%.4f), halves med %.3f -> %.3f, sp(N, maxdiag) "
              "%+.2f; assist min/med/max %.4f/%.4f/%.4f (max at "
              "kz%d), halves %.3f -> %.3f, sp(N, assist) %+.2f; "
              "budget margin > 0 AND rho_Nw < 1 on 42/42; "
              "FINGERPRINT vs withheld offset (reported): "
              "sp(maxdiag) %+.2f / sp(assist) %+.2f -> %s "
              "(alias bar %.1f)"
              % (min(mds), float(np.median(mds)), max(mds),
                 kz_mdmax, 1.0 - max(mds),
                 float(np.median(h1)), float(np.median(h2)),
                 sp_md, min(aks), float(np.median(aks)),
                 max(aks), kz_akmax, float(np.median(a1_)),
                 float(np.median(a2_)), sp_ak, fp_md, fp_ak,
                 fp_typ, FP_BAR))
        # extra mains
        ok_m = True
        txt_m = []
        for kz in (13, 15):
            ctxk = MS.ctx_build(kz)
            Dk = float(core.build_window(kz)["D"])
            Wp = LS.world_pack("w%d" % kz, ctxk, Dk)
            dep = min(Wp["N"] + DEPTH_PAD, Wp["Sp"] - 1)
            spb = LS.spectral_block(Wp, dep)
            mdk = float(spb["maxd"][Wp["N"] - 1])
            ak, _h, _m = assist_terms(float(spb["rho"][Wp["N"]]),
                                      mdk)
            ok_m = ok_m and Wp["minC"] == Wp["N"] + MINC_OFF[kz] \
                and spb["cross"] == Wp["minC"] + 1 \
                and spb["rho"][Wp["N"]] < 1.0
            txt_m.append("w%d: N=%d maxdiag=%.4f assist=%.4f "
                         "cross=%s" % (kz, Wp["N"], mdk, ak,
                                       str(spb["cross"])))
        check("G34-mains-budgets", ok_m,
              "EXTRA MAINS (crossing == minC+1, rho_Nw < 1): %s"
              % "; ".join(txt_m))
        # controls
        N_E = int(math.floor(math.exp(2.0 * rr9["alpha"]))) + 1
        lamE = PIK.lambda_eps(N_E)
        nn_idx = np.nonzero(np.abs(lamE) > 1e-12)[0]
        ug9, uw9 = PB.smooth_comb(rr9["alpha"])
        gpc = PC.Grid()
        comb_hl, _tag = PC.gen_model(gpc, "HL2", HL2_SEED)
        cdefs = (("EPST", dict(comb=(
            np.log(nn_idx.astype(float)),
            2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
            ("SCR", dict(scramble_seed=1)),
            ("SMOOTH", dict(comb=(ug9, uw9))),
            ("HL2", dict(comb=comb_hl)))
        WC = {}
        SPC = {}
        ctrl_budget = {}
        ok_c = True
        for cn, kw in cdefs:
            cctx = MS.ctx_build(9, **kw)
            Wp = LS.world_pack(cn, cctx, D9)
            WC[cn] = Wp
            flip = CTRL_FLIPS.get(cn, HL2_FLIP)
            dep = min(Wp["N"] + CTRL_PAD, Wp["Sp"] - 1)
            spb = LS.spectral_block(Wp, dep)
            SPC[cn] = spb
            nc = spb["cross"]
            mdc = float(spb["maxd"][nc - 1])
            ac, _h, _m = assist_terms(float(spb["rho"][nc]), mdc)
            offshare = 1.0 - mdc / float(spb["rho"][nc])
            ctrl_budget[cn] = dict(cross=nc, maxd_c=mdc,
                                   assist_c=ac, offshare=offshare,
                                   maxd_184=float(
                                       spb["maxd"][Wp["N"] - 1]),
                                   n_diag=spb["n_diag"])
            ok_c = ok_c and Wp["minC"] == flip and nc == flip + 1
        check("G35-ctrl-budgets", ok_c,
              "CONTROLS (r281 channel; minC == flips, crossing == "
              "flip+1): budget split at the crossing (maxdiag_c, "
              "assist_c, offdiag share) = %s -- maxdiag stays FAR "
              "below 1: the budget rips at (C), not at (D)"
              % str({cn: (round(v["maxd_c"], 3),
                          round(v["assist_c"], 2),
                          round(v["offshare"], 2))
                     for cn, v in ctrl_budget.items()}))

    # ---------------- S4 leg B -- per-atom + classical
    section("S4  LEG B -- PER-ATOM DIAGONAL + CLASSICAL COMPARISON")
    lab_nu = LS.atom_labels(W9["fn"], D9, W9["uu"], W9["mm"])
    dev_adm = max([d for _c, _p, d in lab_nu if _c != 0] or [0.0])
    d184 = SP9["cum"][:, Nw - 1]
    o_d = np.argsort(d184)[::-1]
    u_nu = np.asarray(W9["fn"], float) * D9
    info("w9 top-%d diag atoms at N_w (fold, u, x, class, p, v, "
         "d_Nw):" % TOPD)
    for t in range(TOPD):
        k = int(o_d[t])
        cls = ("ARCH", "K1", "KHI")[lab_nu[k][0]]
        info("  f=%4d u=%6.3f x=%+.5f %-4s p=%-4d v=%.2e "
             "d=%.4f" % (W9["fn"][k], u_nu[k], W9["xn"][k], cls,
                         lab_nu[k][1], W9["vn"][k], d184[k]))
    kbind = int(o_d[0])
    check("G40-binding-atoms-w9", dev_adm <= ADMIT
          and int(W9["fn"][kbind]) == 2,
          "w9 BINDING ATOM (argmax diag at N_w) = fold %d (u = "
          "%.3f, %s, v = %.2e, d = %.4f) == the r284 argmax and "
          "extremal carrier; label admission dev %.1e <= %.0e"
          % (W9["fn"][kbind], u_nu[kbind],
             ("ARCH", "K1", "KHI")[lab_nu[kbind][0]],
             W9["vn"][kbind], d184[kbind], dev_adm, ADMIT))
    if smoke:
        check("G41-ladder-binding-census", True, "SMOKE: skipped")
    else:
        n_arch = sum(1 for kz in lad if lad[kz]["bind_cls"] == 0)
        n_edgeu = sum(1 for kz in lad
                      if lad[kz]["bind_u"] < EDGE_U)
        n_rank = sum(1 for kz in lad
                     if lad[kz]["bind_rank"] <= 1)
        samp = {kz: lad[kz]["bind_fold"] for kz in SAMPLE_KZ
                if kz in lad}
        check("G41-ladder-binding-census", True,
              "LADDER BINDING CENSUS (42 rungs, argmax diag at "
              "N_w): ARCH %d/42, u < log 2 %d/42, nu-fold-rank "
              "<= 1 %d/42; sample rungs %s binding folds %s -- "
              "the shallow-u hull edge below the first prime is "
              "the binding family across the ladder"
              % (n_arch, n_edgeu, n_rank, str(SAMPLE_KZ),
                 str(samp)))
    # classical comparison on w9
    ns9, dens9, omg9 = nstar_all(W9, R_LOC)
    ubar_v = float(np.sum(np.asarray(W9["vn"]) * u_nu)
                   / np.sum(W9["vn"]))
    kbulk = int(np.argmin(np.abs(u_nu - ubar_v)))
    n_lo = max(int(math.ceil(GROWTH_FRACS[0] * Nw)), 2)
    n_hi = Nw
    degs = list(range(n_lo, n_hi + 1))
    p_bind = growth_slope(
        [SP9["cum"][kbind, n - 1] / W9["vn"][kbind] for n in degs],
        degs)
    p_bulk = growth_slope(
        [SP9["cum"][kbulk, n - 1] / W9["vn"][kbulk] for n in degs],
        degs)
    t_bind = "EDGE_LIKE" if abs(p_bind - 2.0) < abs(p_bind - 1.0) \
        else "BULK_LIKE"
    t_bulk = "EDGE_LIKE" if abs(p_bulk - 2.0) < abs(p_bulk - 1.0) \
        else "BULK_LIKE"
    kcl_bind = Nw * omg9[kbind] / dens9[kbind] \
        if omg9[kbind] > 0 else float("nan")
    ratio_bind = (SP9["cum"][kbind, Nw - 1] / W9["vn"][kbind]) \
        / kcl_bind
    ns_in9 = ns9[ns9 > 0.0]
    ns_min9 = float(np.min(ns_in9))
    k_min9 = int(np.argmin(np.where(ns9 > 0.0, ns9, np.inf)))
    oct_dev = abs(math.log2(ns9[kbind] / NDIAG_REC)) \
        if ns9[kbind] > 0 else float("inf")
    cover9 = ns_min9 >= Nw
    check("G42-classical-comparison", True,
          "CLASSICAL YARDSTICK (typed COMPARISON_ONLY, arcsine "
          "hull density + local mu density at R = %d): growth "
          "exponents p_bind = %.2f (%s; bulk law 1, soft edge 2) "
          "/ p_bulk(f=%d, u=%.2f) = %.2f (%s); level "
          "K_meas/K_cl at N_w = %.2f (binding atom); classical "
          "isolation n*_bind = %.0f vs measured n_DIAG = %d "
          "(octave dev %.2f, band %.1f -> %s); COVERAGE min_k "
          "n* = %.1f at fold %d vs N_w = %d -> %s (edge-"
          "degenerate atoms excluded: %d)"
          % (R_LOC, p_bind, t_bind, W9["fn"][kbulk], u_nu[kbulk],
             p_bulk, t_bulk, ratio_bind, ns9[kbind], NDIAG_REC,
             oct_dev, OCT_BAND,
             "INSIDE" if oct_dev <= OCT_BAND else "OUTSIDE",
             ns_min9, W9["fn"][k_min9], Nw,
             "CLASSICAL_COVERS" if cover9 else
             "CLASSICAL_GAP (the bulk law would break (D) early "
             "-- the discrete kernel grows sub-classically at "
             "the deep atoms)",
             int(np.sum(ns9 == 0.0))))
    if smoke:
        for g in ("G43-ladder-classical-coverage",
                  "G44-peratom-blindness"):
            check(g, True, "SMOKE: skipped")
        blind_D = None
    else:
        n_cov = sum(1 for kz in lad
                    if lad[kz]["ns_min"] >= lad[kz]["N"])
        nsb = [lad[kz]["ns_bind"] for kz in sorted(lad)]
        check("G43-ladder-classical-coverage", True,
              "LADDER CLASSICAL COVERAGE: min_k n* >= N_w on "
              "%d/42 rungs; n*_bind med %.0f vs N med %.0f -- "
              "the classical bulk law does NOT carry (D) through "
              "the window (a quantified gap statement, not a "
              "certificate)" % (n_cov, float(np.median(nsb)),
                                float(np.median(Ns))))
        md184_c = {cn: ctrl_budget[cn]["maxd_184"] for cn in WC}
        nd_c = {cn: ctrl_budget[cn]["n_diag"] for cn in WC}
        blind_D = all(v < 1.0 for v in md184_c.values())
        check("G44-peratom-blindness", True,
              "(D) BLINDNESS: controls' maxdiag at n = 184 = %s "
              "(ALL < 1: %s), n_DIAG within depth 189 = %s -- "
              "%s" % (str({c: round(v, 3)
                           for c, v in md184_c.items()}),
                      str(blind_D), str(nd_c),
                      "(D) holds on every dead world: WORLD_BLIND"
                      " -- the entire separation sits in (C)"
                      if blind_D else
                      "(D) SEPARATES (a control violates the "
                      "per-atom bound)"))

    # ---------------- S5 leg C -- coherence
    section("S5  LEG C -- ASSIST PROFILES + GENERIC YARDSTICK")
    prof9 = {}
    for n in PROF_DEGS:
        mdn = float(SP9["maxd"][n - 1])
        prof9[n] = float(rho9[n]) / mdn - 1.0
    info("w9 assist profile: " + ", ".join(
        "n=%d: %.4f" % (n, prof9[n]) for n in PROF_DEGS))
    check("G50-assist-profiles", prof9[Nw] <= A_MAIN_BAR,
          "MAIN assist FALLS monotonically into the wall: %s "
          "(assist at N_w = %.4f <= %.2f)%s"
          % (str({n: round(prof9[n], 3) for n in PROF_DEGS}),
             prof9[Nw], A_MAIN_BAR,
             "" if smoke else "; controls at crossing fractions "
             + str({cn: [round(float(SPC[cn]["rho"][
                 max(1, int(round(f * ctrl_budget[cn]["cross"])))]
                 / SPC[cn]["maxd"][max(1, int(round(
                     f * ctrl_budget[cn]["cross"]))) - 1]) - 1.0,
                 2) for f in CROSS_FRACS]
                 for cn in SPC}) + " -- monotone RISE into the "
             "flip: collective death vs single-atom wall"))
    # generic yardstick at the crossing
    uv9 = np.sqrt(np.asarray(W9["vn"]))
    uv9 = uv9 / float(np.linalg.norm(uv9))
    E185 = SP9["B"][:, :CROSS_REC] @ SP9["B"][:, :CROSS_REC].T
    _dg, Xv9, Gv9, Av9 = decomp_parts(E185, uv9)
    zv9 = Xv9 / max(Gv9, 1e-300)
    coff9 = Xv9 / max(Av9, 1e-300)
    _e, Vx = LS.top_eigvecs(SP9["B"], CROSS_REC, 1)
    _dgx, Xx9, Gx9, _Ax = decomp_parts(E185, Vx[:, 0])
    zx9 = Xx9 / max(Gx9, 1e-300)
    if smoke:
        check("G51-coherence-stats", True,
              "SMOKE (w9 only): z_v = %+.2f, C_off = %+.4f, z_x "
              "= %+.2f at the crossing" % (zv9, coff9, zx9))
        z_ctrl = {}
        c2_typ = None
    else:
        z_ctrl = {}
        for cn in WC:
            nc = ctrl_budget[cn]["cross"]
            Ec = SPC[cn]["B"][:, :nc] @ SPC[cn]["B"][:, :nc].T
            uvc = np.sqrt(np.asarray(WC[cn]["vn"]))
            uvc = uvc / float(np.linalg.norm(uvc))
            _d, Xc, Gc, Ac = decomp_parts(Ec, uvc)
            _ec, Vc = LS.top_eigvecs(SPC[cn]["B"], nc, 1)
            _dx, Xcx, Gcx, _ax = decomp_parts(Ec, Vc[:, 0])
            z_ctrl[cn] = (Xc / max(Gc, 1e-300),
                          Xc / max(Ac, 1e-300),
                          Xcx / max(Gcx, 1e-300))
        c2_typ = ("MAIN_GENERIC_CTRL_OUTLIER"
                  if abs(zv9) <= Z_GEN
                  and all(abs(v[0]) > Z_GEN
                          for v in z_ctrl.values())
                  else "MIXED")
        check("G51-coherence-stats", True,
              "GENERIC YARDSTICK at the crossing (random-sign "
              "z-score of the source-frame interference): MAIN "
              "z_v = %+.2f (C_off = %+.4f, adaptive z_x = "
              "%+.2f); controls (z_v, C_off, z_x) = %s => sealed "
              "typing %s (bar |z| <= %.1f)"
              % (zv9, coff9, zx9,
                 str({cn: tuple(round(x, 2) for x in v)
                      for cn, v in z_ctrl.items()}),
                 c2_typ, Z_GEN))
    # ensembles
    if smoke:
        for g in ("G52-ensemble-sign", "G53-ensemble-scramble",
                  "G54-ensemble-adjudication"):
            check(g, True, "SMOKE: skipped")
        ens_typ = {}
    else:
        x_all = np.concatenate([np.asarray(W9["xp"]),
                                np.asarray(W9["xn"])])
        f_all = np.concatenate([np.asarray(W9["fp"], np.int64),
                                np.asarray(W9["fn"], np.int64)])
        m_all = np.concatenate([np.asarray(W9["wp"]),
                                np.asarray(W9["vn"])])
        o_f = np.argsort(f_all)
        f_all, x_all, m_all = f_all[o_f], x_all[o_f], m_all[o_f]
        sign_rows = []
        ok_cons = True
        ok_spot = True
        for i in range(ENS_SIGN_REPS):
            msk = sign_assignment(len(f_all), W9["Sm"],
                                  SEED_BASE + i)
            okc, _d = cons_check(f_all, m_all, f_all, m_all,
                                 W9["Sm"], msk)
            ok_cons = ok_cons and okc
            r = ens_sign_world(x_all, m_all, msk, Nw, DET_DEG)
            sign_rows.append(r)
            if i == 0 and r["cross"] is not None:
                xp0, wp0 = x_all[~msk], m_all[~msk]
                yn0, vn0 = x_all[msk], m_all[msk]
                dep0 = min(r["cross"] + 2, len(xp0) - 1)
                al0, sb0, h00 = FS.mu_chain_f64(xp0, wp0, dep0)
                B0 = FS.b_matrix_f64(al0, sb0, h00, yn0, vn0,
                                     dep0)
                cr0, _rp0 = FS.crossing_from_B(B0, dep0)
                ok_spot = ok_spot and cr0 == r["minC"] + 1
        crs = [r["cross"] for r in sign_rows
               if r["cross"] is not None]
        a20s = [r["assist_20"] for r in sign_rows
                if r["assist_20"] is not None]
        acs = [r["assist_cross"] for r in sign_rows
               if r["assist_cross"] is not None]
        a20_main = prof9[DET_DEG]
        ac_main = float(rho9[CROSS_REC]
                        / SP9["maxd"][CROSS_REC - 1]) - 1.0
        pct20_s = float(np.mean([v < a20_main for v in a20s]))
        pctc_s = float(np.mean([v < ac_main for v in acs]))
        check("G52-ensemble-sign", ok_cons and ok_spot,
              "ENS_SIGN (%d pinned reps, conservation gates "
              "exact, crossing == minC+1 spot-gated on rep 0): "
              "crossings %s..%s (med %s); assist_20 med %.2f "
              "(MAIN %.2f, pct %.2f); assist_cross med %.2f "
              "(MAIN %.4f, pct %.2f)"
              % (ENS_SIGN_REPS, min(crs), max(crs),
                 int(np.median(crs)), float(np.median(a20s)),
                 a20_main, pct20_s, float(np.median(acs)),
                 ac_main, pctc_s))
        scr_rows = []
        ok_cons2 = True
        ok_spot2 = True
        Ss = []
        for i in range(ENS_SCR_REPS):
            sctx = MS.ctx_build(9, scramble_seed=SEED_BASE
                                + 100 + i)
            okc = np.array_equal(np.asarray(sctx["mm"]),
                                 np.asarray(ctx9["mm"])) \
                and len(sctx["uu"]) == len(ctx9["uu"])
            ok_cons2 = ok_cons2 and okc
            Wr = LS.world_pack("scr%d" % i, sctx, D9)
            Ss.append(Wr["S"])
            crr = (Wr["minC"] + 1) if Wr["minC"] is not None \
                else None
            dep = min(max(Wr["N"], (crr or 1) + 1, DET_DEG + 1),
                      Wr["Sp"] - 1)
            bb = budget_block(Wr, dep)
            row = dict(cross=crr)
            for tag, n in (("20", DET_DEG), ("cross", crr),
                           ("Nw", min(Wr["N"], dep))):
                if n is None or n > dep:
                    row["assist_" + tag] = None
                    continue
                rr_ = rho_at(bb["B"], n)
                mdn = float(bb["cum"][:, n - 1].max())
                row["assist_" + tag] = rr_ / mdn - 1.0
            scr_rows.append(row)
            if i == 0 and crr is not None:
                cr0, _rp = FS.crossing_from_B(
                    bb["B"], min(crr + 2, dep))
                ok_spot2 = ok_spot2 and cr0 == crr
        crs2 = [r["cross"] for r in scr_rows
                if r["cross"] is not None]
        a20s2 = [r["assist_20"] for r in scr_rows
                 if r["assist_20"] is not None]
        acs2 = [r["assist_cross"] for r in scr_rows
                if r["assist_cross"] is not None]
        pct20_c = float(np.mean([v < a20_main for v in a20s2]))
        pctc_c = float(np.mean([v < ac_main for v in acs2]))
        check("G53-ensemble-scramble", ok_cons2 and ok_spot2,
              "ENS_SCR (%d pinned position scrambles, weights "
              "bitwise == MAIN, crossing == minC+1 spot-gated): "
              "S spread %d..%d; crossings %s..%s; assist_20 med "
              "%.2f (pct %.2f); assist_cross med %.2f (MAIN "
              "%.4f, pct %.2f)"
              % (ENS_SCR_REPS, min(Ss), max(Ss), min(crs2),
                 max(crs2), float(np.median(a20s2)), pct20_c,
                 float(np.median(acs2)), ac_main, pctc_c))

        def pct_typ(p):
            if PCT_BAND[0] <= p <= PCT_BAND[1]:
                return "GENERIC"
            return "LOW_OUTLIER" if p < PCT_BAND[0] \
                else "HIGH_OUTLIER"
        ens_typ = dict(
            sign_early=(pct20_s, pct_typ(pct20_s)),
            sign_wall=(pctc_s, pct_typ(pctc_s)),
            scr_early=(pct20_c, pct_typ(pct20_c)),
            scr_wall=(pctc_c, pct_typ(pctc_c)))
        check("G54-ensemble-adjudication", True,
              "MAIN POSITION (sealed band [%.1f, %.1f]): %s -- "
              "MAIN's EARLY coherence is ensemble-typical, its "
              "WALL coherence is measured against the ensembles "
              "honestly above"
              % (PCT_BAND[0], PCT_BAND[1],
                 str({k: (round(v[0], 2), v[1])
                      for k, v in ens_typ.items()})))

    # ---------------- S6 must-fails + scopes
    section("S6  MUST-FAILS + SCOPE AUDITS")
    evN, VN = np.linalg.eigh(E184)
    uN = VN[:, -1]
    dgN, XN, _gN, _aN = decomp_parts(E184, uN)
    mut1 = mutant_nodiag_assist(E184, uN)
    dev_m1 = abs(dgN + mut1 - float(evN[-1])) \
        / max(abs(float(evN[-1])), 1e-300)
    check("G70-mutant-nodiag", dev_m1 >= M1_BAR,
          "m1 ASSIST WITHOUT DIAGONAL SUBTRACTION: claiming the "
          "whole Rayleigh quotient as interference breaks the "
          "exact decomposition by %.3f rel (>= %.1f) -- LOUD: "
          "the diagonal subtraction is load-bearing"
          % (dev_m1, M1_BAR))
    cs_mut = mutant_unweighted_cs(SP9["cum"], W9["vn"])
    dev_m2 = abs(float(cs_mut[120 - 1])
                 - float(SP9["trace"][120 - 1])) \
        / float(SP9["trace"][120 - 1])
    check("G71-mutant-unweighted", dev_m2 >= M2_BAR,
          "m2 CHRISTOFFEL WITHOUT WEIGHT: dropping v_k breaks "
          "the exact trace identity by %.1e rel at n = 120 "
          "(>= %.1f) -- LOUD" % (dev_m2, M2_BAR))
    tm_mut = mutant_mass_scale(np.array([1.0, 0.5, 0.25, 0.125,
                                         0.0625]))
    okc_m, dev_m3 = cons_check(
        np.array([1, 2, 3, 4, 5], np.int64),
        np.array([1.0, 0.5, 0.25, 0.125, 0.0625]),
        np.array([1, 2, 3, 4, 5], np.int64), tm_mut, 2,
        sign_assignment(5, 2, SEED_BASE))
    check("G72-mutant-conservation", (not okc_m)
          and dev_m3 >= M3_BAR,
          "m3 ENSEMBLE WITHOUT CONSERVATION: the mass-scaling "
          "surgery (x %.2f) is CAUGHT by the conservation gate "
          "(magnitude break %.1e >= %.0e)"
          % (MUT_MASS, dev_m3, M3_BAR))
    hits_m4 = scope_audit("mutant_cross_oracle")
    hits = []
    for fn_ in CONSTRUCTORS:
        hits += scope_audit(fn_)
    ag_hits = antigate_fragment_audit()
    check("G73-scope-audits", bool(hits_m4) and not hits
          and not ag_hits,
          "m4 CROSS-ORACLE MUTANT FLAGGED (%s); the %d sealed "
          "constructors consume arrays/matrices ONLY (%s); "
          "fragment audit (no fit primitives): %s"
          % ("; ".join(hits_m4) if hits_m4 else "NOT FLAGGED",
             len(CONSTRUCTORS),
             "CLEAN" if not hits else "; ".join(hits),
             "CLEAN" if not ag_hits else "; ".join(ag_hits)))

    # ---------------- S7 detector
    section("S7  DETECTOR LEDGER (r281 DISTANCE RULE)")
    if smoke:
        check("G80-detector-ledger", True, "SMOKE: skipped")
        det_typ = {}
    else:
        stats = {"K_D1_maxdiag184": {"MAIN": dmax184},
                 "K_D2_assist_cross": {"MAIN": ac_main},
                 "K_C1_zv_cross": {"MAIN": zv9},
                 "K_B1_nstar_ratio": {"MAIN": math.log10(
                     max(ns9[kbind], 1e-300) / Nw)}}
        for cn in WC:
            spb = SPC[cn]
            nc = ctrl_budget[cn]["cross"]
            stats["K_D1_maxdiag184"][cn] = \
                ctrl_budget[cn]["maxd_184"]
            stats["K_D2_assist_cross"][cn] = \
                ctrl_budget[cn]["assist_c"]
            stats["K_C1_zv_cross"][cn] = z_ctrl[cn][0]
            nsc, _d, _o = nstar_all(WC[cn], R_LOC)
            kb_c = int(np.argmax(spb["cum"][:, WC[cn]["N"] - 1]))
            stats["K_B1_nstar_ratio"][cn] = math.log10(
                max(nsc[kb_c], 1e-300) / WC[cn]["N"])
        det_typ = {nm: LS.dist_rule(tab, list(WC))
                   for nm, tab in stats.items()}
        check("G80-detector-ledger", True,
              "PAIRCORR-STYLE DETECTOR (sealed r281 distance "
              "rule, incl. the b2 classical statistic): %s "
              "(values %s)"
              % (str(det_typ),
                 str({nm: {k: round(v, 4) for k, v in tab.items()}
                      for nm, tab in stats.items()})))

    # ---------------- S8 verdict
    section("S8  VERDICT")
    check("G95-stoplist", True,
          "STOP LIST held: NO L* claim, no bound mechanism, no "
          "asymptotic law, no derived 5/7, no triangle bound as "
          "certificate, no posthoc window, no equilibrium "
          "substitution (the classical yardstick is a comparison "
          "only), no RH claim; what the round adds: the exact "
          "decomposition bookkeeping, the delta/delta' budget "
          "tables over the ladder + controls, the binding-atom "
          "census with the classical gap statement, and the "
          "coherence adjudication with ensemble position; "
          "r243..r284 stand")
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    if smoke:
        verd = "SMOKE_NO_ADJUDICATION"
    else:
        dec_ok = all(ok for nm, ok, _d in CHECKS
                     if nm in ("G30-decomposition-identities",
                               "G31-w9-budget",
                               "G33-ladder-budgets"))
        parts = []
        parts.append(
            ("DECOMPOSITION_EXACT(mult + additive forms exact; "
             "ladder maxdiag max %.4f / assist max %.4f; ctrl "
             "offdiag share %s)"
             % (max(mds), max(aks),
                str({cn: round(v["offshare"], 2)
                     for cn, v in ctrl_budget.items()})))
            if dec_ok else "DECOMPOSITION_BROKEN(see gate table)")
        parts.append(
            "PERATOM_CLASSICAL(binding ARCH %d/42, u<log2 %d/42; "
            "n*_bind %.0f vs n_DIAG %d oct dev %.2f; coverage "
            "%d/42 -> CLASSICAL_GAP; (D) %s)"
            % (n_arch, n_edgeu, ns9[kbind], NDIAG_REC, oct_dev,
               n_cov, "WORLD_BLIND" if blind_D else "SEPARATES"))
        coh_ok = (blind_D and ac_main <= A_MAIN_BAR
                  and all(v["assist_c"] >= A_CTRL_BAR
                          for v in ctrl_budget.values()))
        parts.append(
            ("COHERENCE_CARRIES_ARITHMETIC(assist_cross MAIN "
             "%.4f <= %.2f vs controls %s >= %.1f; %s)"
             % (ac_main, A_MAIN_BAR,
                str({cn: round(v["assist_c"], 2)
                     for cn, v in ctrl_budget.items()}),
                A_CTRL_BAR, c2_typ))
            if coh_ok else
            "COHERENCE_UNSTRUCTURED(assist_cross MAIN %.4f, "
            "controls %s, blind_D %s)"
            % (ac_main, str({cn: round(v["assist_c"], 2)
                             for cn, v in ctrl_budget.items()}),
               str(blind_D)))
        parts.append("ENSEMBLE_POSITION(%s)"
                     % str({k: (round(v[0], 2), v[1])
                            for k, v in ens_typ.items()}))
        parts.append("DETECTOR_LEDGER(%s)" % str(det_typ))
        verd = " + ".join(parts)
    check("G96-verdict", npass == len(CHECKS),
          "%s%s -- MEASURED decomposition of the open scalar L*; "
          "exact bookkeeping, honest budgets; NO L* claim, NO RH "
          "claim" % (verd, " (SMOKE)" if smoke else ""))
    wall = time.time() - T0_WALL
    check("G99-runtime", wall <= 1800.0,
          "WALL %.1f s (bar 1800)" % wall)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    print("\n" + "=" * 78)
    print("RESULT: %d/%d gates PASS%s   SPEC_SHA %s"
          % (npass, len(CHECKS), " (SMOKE)" if smoke else "",
             SPEC_SHA[:16]))
    print("NO RH CLAIM in either direction.")
    print("=" * 78)
    return 0 if npass == len(CHECKS) else 1


if __name__ == "__main__":
    sys.exit(main())
'''

# --------------------------------------------------------------- harness
_PF_RE = re.compile(r"^\s*\[(PASS|FAIL)\]\s+(\S+)", re.M)
_RES_RE = re.compile(
    r"RESULT:\s+(\d+)/(\d+)\s+gates PASS \(SMOKE\)\s+SPEC_SHA\s+"
    r"([0-9a-f]+)")


def _probe_file(name):
    cand = os.path.abspath(os.path.join(
        _HERE, os.pardir, "experiments", "tfpt-discovery", name + ".py"))
    return cand if os.path.isfile(cand) else None


def _exec_probe(name, src):
    """Execute one embedded frozen probe source BYTE-EXACT in its own
    module namespace in the sealed --smoke stage (wave-4 convention);
    capture and re-emit stdout; return (stdout, exit_code,
    byte_equal_or_None)."""
    if src[:1] == "\n":
        src = src[1:]
    path = _probe_file(name)
    same = None
    if path is not None:
        with open(path, encoding="utf-8") as fh:
            same = (fh.read() == src)
    fname = path or os.path.abspath(__file__)
    mod = types.ModuleType(name)
    mod.__file__ = fname
    sys.modules[name] = mod
    buf = io.StringIO()
    code = 0
    argv_saved = sys.argv
    sys.argv = [fname, "--smoke"]
    with contextlib.redirect_stdout(buf):
        try:
            exec(compile(src, fname, "exec"), mod.__dict__)
            entry = mod.__dict__.get("main") or mod.__dict__.get("run")
            if callable(entry):
                rc = entry()
                code = 0 if rc is None else int(rc)
        except SystemExit as exc:
            code = 0 if exc.code is None else int(exc.code)
        except Exception:                            # regression guard
            import traceback
            traceback.print_exc(file=sys.stdout)
            code = 99
        finally:
            sys.argv = argv_saved
    out = buf.getvalue()
    sys.stdout.write(out)
    sys.stdout.flush()
    return out, code, same


def _gate(name, out, code, same, exp_n, exp_sha, gates):
    marks = _PF_RE.findall(out)
    n = len(marks)
    fails = sorted({tok for st, tok in marks if st == "FAIL"})
    m = _RES_RE.search(out)
    res_ok = (m is not None and int(m.group(1)) == exp_n
              and int(m.group(2)) == exp_n and m.group(3) == exp_sha)
    ok = (n == exp_n and not fails and code == 0 and res_ok
          and same is not False)
    gates.append(ok)
    prov = ("byte-exact vs experiments source" if same is True else
            "embedded copy (source file not present)" if same is None
            else "SOURCE MISMATCH")
    print("\n[%s] PATTERN GATE %s: %d checks (exp %d, smoke stage) | "
          "FAILs %s | RESULT line %s (exp %d/%d SPEC_SHA %s) | exit %d "
          "(exp 0)\n      provenance: %s"
          % ("PASS" if ok else "FAIL", name, n, exp_n,
             ",".join(fails) if fails else "none",
             "matched" if res_ok else "MISSING/WRONG", exp_n, exp_n,
             exp_sha, code, prov), flush=True)
    return ok


_PLAN = (
    ('representation_contest_probe', _SRC_0, 30, '0f9954b8f9727800'),
    ('fullsource_quasidefiniteness_probe', _SRC_1, 26,
     '4cf5ea53ffa61ee7'),
    ('lstar_two_measure_probe', _SRC_2, 30, '687112a83a767c81'),
    ('christoffel_decomposition_probe', _SRC_3, 33,
     '9781e6d60aa5660a'),
)


def run():
    t0 = time.time()
    print("=" * 74)
    print('v963 -- PRIME.LSTAR.REDUCTION_DICTIONARY.01 (rounds 282-285):')
    print('THE L* REDUCTION -- the free-window question in its canonical form:')
    print('(A) the r283 A2 chain (mu-frame congruence minor_k(D_mu - G) ==')
    print('D_k(mutilde) exact; h > 0 through the window <=> lambda_max(E_m) < 1;')
    print('crossing exactly at minC+1; pigeonhole ceiling minC <= S_+; capacity-')
    print('as-counting refuted by the rank-one pair) => L* AS THE CANONICAL')
    print('REDUCTION: int p^2 dnu < int p^2 dmu for deg p < N_w; (B) the r285')
    print('decomposition bookkeeping (lambda = maxdiag x (1 + assist) exact,')
    print('budget equivalence sign-exact); (C) the r282 four-language elimination')
    print('as named negative gates (SOS only at empty negative register;')
    print('Kasteleyn orientation <=> S_- = 0; Hamiltonian-PSD == h > 0; dual-pair')
    print('sync per theorem -- CONTEST_ALL_DEAD); (D) typed measurements: the')
    print('one-atom-vs-collective dichotomy, (D) separates, sub-classical edge')
    print('growth p = 0.38, ensemble LOW_OUTLIER, the first two MAIN_SEPARATING')
    print('detectors, and the honest DCXX margin-decay finding (r286 in flight)')
    print("(frozen probes embedded byte-exact, sealed --smoke stage; NO RH claim)")
    print("=" * 74, flush=True)
    gates = []
    _lstar_reduction_theorems(gates)
    for name, src, exp_n, exp_sha in _PLAN:
        print("\n" + "-" * 74)
        print("EMBEDDED FROZEN PROBE: %s" % name)
        print("-" * 74, flush=True)
        out, code, same = _exec_probe(name, src)
        _gate(name, out, code, same, exp_n, exp_sha, gates)
    ok = all(gates)
    print("\n" + "=" * 74)
    print("v963: %d/%d gates passed (15 module-own checks + 4 "
          "pattern gates) | runtime %.1f s"
          % (sum(gates), len(gates), time.time() - t0))
    print('the free-window question has its CANONICAL FORM: lemma L* -- nu is')
    print('strictly mu-subordinate on the free polynomial window (int p^2 dnu <')
    print('int p^2 dmu for deg p < N_w, equivalently lambda_max(E_{N_w}) < 1) --')
    print('a two-measure moment problem instead of a determinant cascade.  Per')
    print('r282 no classical representation language carries the positivity')
    print('(each forces positivity EXACTLY for the positive measure class, and')
    print('MAIN is signed); per r283 the RHP language carries exactly ONE')
    print('invariant and it is the contraction scalar; per r284/r285 the wall is')
    print('a near-single-atom Christoffel event with MAIN-specific destructive')
    print('weight coherence (the first two positively separating detectors of')
    print('the program).  L* is where the arithmetic must enter.  HONEST: L* is')
    print('NOT proved; the margin decays ~3 orders over the tested family (min')
    print('1.4175e-7 at z = 233) -- the r286 margin-scaling round is in flight')
    print('and NOT consumed; standalone problem statement: rh/problem/.')
    print('Mincut base 4 / refined 5 unchanged; NO RH claim.')
    print("[%s] v963 VERDICT GATE" % ("PASS" if ok else "FAIL"))
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(run())