#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""v958 -- PRIME.PORT.RHP.BORDERED.READOUT.01 (rounds 244-245, 248, 251-253, ADJUDICATED at the finite-identity level) + PRIME.PORT.RHP.FULLSOURCE.BASEFIBER.01 (registered [O], the campaign contract with the post-round-255 state): THE BORDERED-RHP / TAU-READOUT DICTIONARY OF THE WALL -- the bordered Hankel end-object (bordered PSD = wall + budget) has an exact Riemann-Hilbert dictionary, the border is a Schlesinger rank-1 insertion (no irreducible 3x3, no growing rank), the centering congruence eliminates the geometric rank-1 head algebraically, the three error-evaluation formulas are exact, R_1 is a contour integral, and the fiber target is the exact augmented tau quotient D = tau^aug/tau with the pole layers classified (rank-1 border poles removable, D-layer essentially singular).  ONE module from six probes (23/23 + 29/29 + 24/24 + 20/20 + 22/22 + 26/26 first-pass gates, zero fails; discovery probes bordered_hankel_probe.py, bordered_finite_rank_probe.py, border_centering_probe.py, targetreadout_error_probe.py, base_gauge_constant_probe.py, schlesinger_pairing_probe.py, rounds 244/245/248/251/252/253, notes DLXXIII/DLXXV/DLXXVII/DLXXXI/DLXXXII/DLXXXIII, 2026-08-24, re-run identically at promotion, embedded BYTE-EXACT and executed verbatim), plus the module-own exact PSD base theorem (S0).  (S0) THE PSD BASE THEOREM (module-own, exact rationals; trivial but load-bearing): for ANY positive measure the Gram/Hankel matrix G_N is positive definite and the border readout T = t^T G_N t = int (sum_i t_i x^i)^2 dmu >= 0 for EVERY real border t (symbolic-identity check + exact leading-minor Sylvester chain + exact Schur complement: the bordered matrix [[G_N, u], [u^T, B]] is PSD iff B >= u^T G_N^{-1} u, the r244 end-object shape wall + budget), and the must-fail fires: a SIGNED measure mu - nu breaks the minor chain and an explicit border goes negative -- any bordered-positivity route that only uses positive-basis Gram structure proves the WRONG statement; the wall content is precisely the quasi-definiteness of the signed defect measure (the v954 trivial-route lesson, re-anchored on the bordered object).  (1) THE BORDERED DICTIONARY (round 244, verdict BORDERED_RHP_DICTIONARY_EXACT + CORNER_IMPORTED_ONLY + BUDGET_PROFILE_FROZEN(IRREGULAR_BULK)): the Uvarov border column Csig_n(z) = int pihat_n dsigma/(z - x) carries F_n as its z^{-1} coefficient WITHOUT orthogonality cancellation (ward 6.7e-13; the mutilde-column coefficient is 0 -- the contrast IS the orthogonality, 1.1e-15); THE STRONGEST PIECE, the CD-kernel form of the budget: S_{n-1} = int int K_n dsigma dsigma with K_n(x,y) = (Y_n^{-1}(y) Y_n(x))_{21}/(y - x) -- THE BUDGET IS AN RHP FUNCTIONAL OF THE TERMINAL Y_n DATA ALONE (confluent diagonal via derivative CD; ward 3.7e-15 on 42+3 worlds); the Uvarov tau step tau^b_{n+1}/tau^b_n = h_n (1 - rho_n/(B - S_{n-1})) rational-exact + mp 7.1e-58, the bordered det identity affine in B gated at two budgets hence for ALL B; the bordered LAX1 flow F_{n+1} = T_n - alphahat_n F_n - gammahat_n F_{n-1} with source T_n = int x pihat_n dsigma and autonomous corner D_{n+1} = D_n - rho_n (toy-rational exact, mp through all 184 w9 degrees 7.0e-159).  MEASURED AND TYPED: the honest corner census -- all three sealed canonical corner candidates FAIL the PSD test (0/42 each; S_{N-1} in [6.06, 15.41] exceeds every source-pure positive geometry on every window): CORNER_IMPORTED_ONLY; and the frozen requirement profile: the budget is HEAD-HEAVY, not edge-heavy (argmax rho at degree 0 on 42/42, rho_0 share median 37 percent, tail-5 only 3.5 percent, Gini 0.91) -- any later Szego/steepest-descent analysis must control a highly non-uniform BULK, not a terminal boundary layer (IRREGULAR_BULK).  (2) THE RANK ADJUDICATION (round 245, verdict FORMULATION(SCHLESINGER_RANK1_INSERTION) + BORDERED_RANK2_EXACT + UVAROV_PROJECTION_2PLUS2_FIXED + FULL_PIVOT_CHAIN_CARRIED): the reviewer five-fold typing is fully served -- RHP matrix size 3x3 but UNIPOTENT/TRIANGULAR (the third column is the F-sourced Uvarov column, determined by linear quadrature after the 2x2 is solved; det Y3 = -h_{n-2} F_{n-1} NEWLY DERIVED, 45 z-points exact, unique gauge; augmented normalization det Y3aug = 1 to 5.9e-55 mp); IIKS generator rank 2 EXACT (CD-explicit generator reconstruction 4.8e-15 f64 / 5.9e-160 mp razor -- the nonlinear kernel stays the old one); gauge-reducible YES: source-pure reduction to a 2x2 RHP + one linear column (the T-source appears exactly as the displacement entry of the unipotent extension -- the inhomogeneous three-term recursion for F becomes homogeneous three-dimensional); nonlinear core rank 2; budget fiber dimension 1 (scalar cocycle, Uvarov view 2+2 fixed).  The formulation carries the FULL pivot chain (exact on toy, 1.3e-54 / 8.2e-161 mp) -- the DETERMINANT_ONLY kill does NOT fire; world-blind on MAIN/EPSTEIN/SCRAMBLE/SMOOTH; THE FINITE PHASE IS CLOSED: the complete finite architecture of the end-object is a CANONICAL 2x2 RHP semidirect ONE-DIMENSIONAL BUDGET COCYCLE (the skew-product reading machine-verified -- the border creates no second nonlinear geometry, it reads the existing solution out), and the irreducible-3x3 steepest-descent campaign is dropped WITHOUT REPLACEMENT.  (3) THE CENTERING NORMAL FORM (round 248, verdict CENTERING_CONGRUENCE_EXACT + SIGMA0_DICTIONARY_EXACT + QUIETZONE_ASYMPTOTIC_MOMENTS + TAIL_KERNEL_COMPRESSED + EXTENSIVE_IRREGULAR_TAIL + THREE_ZONE_NORMALFORM): with c = F_0/h_0 the geometric rank-1 head is ALGEBRAICALLY COMPLETELY ELIMINABLE -- PSD of the bordered matrix iff PSD of the centered form with B-deg = B - rho_0 (exact in rationals, world-blind on 42+3 worlds f64 1.2e-16, mp 2.6e-62; must-fail breaks by exactly the predicted formula); the centered border functional sigma-deg = sigma - (F_0/h_0) mutilde annihilates constructively, the triangle converse F_1..F_m = 0 iff sigma-deg perp P_m stands, and Q_m = t^T H^{-1} t is exactly the squared dual norm (rationals exact; mp F-deg_8 6.4e-13, Q_7 3.3e-13); THE TAIL-KERNEL COMPRESSION: T = int int [K_N - K_8] dsigma-deg dsigma-deg EXACT -- mp dps 160 THROUGH THE FULL DEPTH N = 184: rel 3.3e-160 -- the extensive tail is ONE terminal CD readout (extensive source, one analytic target object); the THREE-ZONE NORMAL FORM frozen: GEOMETRIC_RANK1_HEAD (rho_0 world-blind, EPSTEIN/SCRAMBLE +-0.000 decades) + LOWMODE_ARITHMETIC_SILENCE (the silence IS the arithmetic: SCRAMBLE breaks IMMEDIATELY at k = 1, median +2.21 decades over k = 1..12, while EPSTEIN holds +0.000) + EXTENSIVE_PAIRING_SENSITIVE_TAIL (tail excess fraction 0.836) -- the r246 label HEAD_CARRIES_ARITHMETIC is superseded as a misnomer on record.  MEASURED AND TYPED: quiet zone = ASYMPTOTIC_MOMENTS but MARGINAL (G_q DEV median 4.99e-4, slope -0.18 against bar -0.10; mode slopes mixed; the flat smoke ladder would have shown +4.70 -- ladder depth load-bearing again); the builder source check is NEGATIVE (u-moments do not share exactly, worst 1.4e-2, PNT level) -- NO construction identity, the silence is real arithmetic; tail profile = EXTENSIVE_IRREGULAR_TAIL (DEV pair rel-L1 median 0.730 vs bar 0.25, even/odd half-profiles incoherent 1.143): no universal and no quenched macroprofile phi(x) exists -- the full discrete source must be carried, but thanks to the compression as ONE integrated readout.  (4) THE THREE EXACT ERROR FORMULAS (round 251, verdict READOUT_FORMULAS_EXACT + AMPLIFICATION_EXTENSIVE(p=1.01) + ANNIHILATION_NEUTRAL + FIBER_IN_ERROR_CONFIRMED + BASE_READOUT_BLOCKED_BY_OFFSET + WORLD_GAP_IN_DELTA_T + MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D)): (a1) delta h_n = (R_1)_12 with R = Y M^{-1} (the Y1 difference without cross term; Richardson ward 1.0e-5, own mp pass dps 700 against ~600 digits of far-Cauchy cancellation); (a2) the central rest identity T^Y - T^M = int int ([K^Y_N - K^M_N] - [K^Y_8 - K^M_8]) dsigma-deg dsigma-deg exact (route consistency 5.2e-18); (a3) the error-kernel sandwich row_2(M^{-1}(y)) [R^{-1}(y) R(x) - I] col_1(M(x))/(y - x) at 1.1e-81.  STRUCTURE FIND (G34): the full r250 model is NOT sigma-deg-PAIRABLE -- the arcsine-cell Szego layer D(z) has atom poles with exponent 380 DECADES (sharpens r250's 'bare beats dressed' to an obstruction; the kernel legs ran with the sealed noD ablation limb; no 380-decade value was ever formed).  MEASURED DIRECTION DECISIONS, typed not hidden: amplification EXTENSIVE (A_sup ~ N^1.01; eps_YM saturates at 2-3, q_c2 ~ N^1.04 -- 'eps -> 0 suffices' is measured DEAD); annihilation NEUTRAL (the centering buys exactly 0.00 decades IN THE ERROR, q_annihil = 1.000 on 4/4 -- the 3.5 decades of r248 live in the VALUE); the fiber sits FULLY in the error (outer model carries ~2 percent of T_true; |Delta T|/margin_true = 7.9/81.8/12.0/8.2; the MAIN-SCRAMBLE difference sits COMPLETELY in Delta T, share 1.003) -- the fiber may NOT be treated as a small correction; the base rate IS carried (slope <= 0.0045 dec/degree on 4/4) with a constant offset -1.25..-1.45 decades on the four free-degree windows.  (5) THE CONTOUR R_1 FORMULA + THE GAUGE ADJUDICATION (round 252, verdict RATE_ONLY_NUMERICAL + NO_GLOBAL_GAUGE + MODEL_ORIENTATION_BLIND + CONTOUR_R1_EXACT): the proof-ready instrument -- R_1 as the contour integral (1/2 pi i) oint (R(z) - I) dz instead of evaluation at astronomical z, verified against the r251 readouts at 3.2e-14; and the reviewer gauge thesis is REFUTED on all three prongs (the quotient test kills the premise: on the full degree ladder, 859 QP equilibria, Delta_{w,n} DRIFTS by -1.1..-2.1 decades end-to-end -- the r251 'degree-constant offset' was a bounded 4-window measurement; the h_0 normalizer leaves up to 2.32 decades; the diagonal gauge is PINNED c = 1 by the normalization at infinity), plus the hardest gate: the outer model is ORIENTATION-BLIND (positive gamma^out on ALL worlds, no model flip on EPSTEIN/SMOOTH where the true chains flip early) -- even a solved constant layer would NOT have proven the base; r251's BASE_BLOCKED_BY_OFFSET is CORRECTED on record to BASE_BLOCKED_BY_DRIFTING_LAYER: the missing layer is degree-dependent AND orientation-relevant, the base needs the same class of work as the fiber.  (6) THE EXACT TAU QUOTIENT + THE POLE CLASSIFICATION (round 253, verdict TAU_RATIO_EXACT + POLE_REMOVAL_EXACT(rank1-border) + D_DIRECT_ONLY_OBSTRUCTED + NO_FINITE_PAIR_DRESSING(D-layer) + PAIR_AWARE_OUTER_MODEL + PAIRING_IN_ERROR_AGAIN + SCRAMBLE_SEP_FAIL(0.47 dec) + MARGIN_OPEN(1.4 dec) + REL_STRUCTURELESS + PAIRING_EXTENSIVE + EPSTEIN_FIBER_ANOMALOUS): THE THEOREM OF THE ROUND -- D = B-deg - Q_7 - T = tau^aug/tau holds MACHINE-EXACT at full depth N = 184/168 on three independent routes (dual-norm solve, slogdet ratio, chain) at 1e-11 with mp cross-check 1e-16 (the apparent SCR deviation 4.2e-4 sits provably in the f64 CHAIN reference at the h-flip degree 21, the tau routes agree there at 3.7e-11); T_gram reproduces the world gap +8.8287 vs +8.8285 WITHOUT the chain -- the fiber target is a pure tau quotient of the augmented problem, not an integral afterburner; POLE REMOVAL CLOSED: the rank-1 border poles are bookkeeping (residue closure Res C_N = w_j pihat_N(x_j) at 3.4e-9, triangularly removable) while the D-layer is ESSENTIALLY SINGULAR (order measurement p = 0.997, exp(c/(z - s)) type, 3.7 -> 366.6 decades on the t-ladder) -- no finite meromorphic divisor lifts it.  MEASURED AND TYPED: the pairing thesis is REFUTED -- both sealed main-term candidates miss the x2 window (the Gram DIAGONAL carries only 19 percent of the gap and has the WRONG SIGN on SCRAMBLE +10.4; the free chain share -24); SCRAMBLE separation before readout only 0.47 decades (gate 1.0); the relative problem Y_MAIN Y_SCR^{-1} is STRUCTURELESS (ratio 0.53, top-decile 0.155) -- the pairing action is extensive over all atoms, no small carrier; the lesson: the pairing lives in the FULL quadratic form (the off-diagonal Gram terms), not in its diagonal -- and per r254 (OFFDIAG_EXTENSIVE, measurement, experiments-side) there is no spectral compression on the exact coordinate either.  THE CAMPAIGN CONTRACT (PRIME.PORT.RHP.FULLSOURCE.BASEFIBER.01 [O], registered with the post-r255 state; the measurement rounds 250/254/255 stay experiments-side and are typed MEASUREMENTS, not identities): base H_N > 0 with EPSTEIN/SMOOTH as breakers, fiber D_N(B) >= 0 with SCRAMBLE as falsifier, admissible target form an INTEGRATED statement over the compressed CD readout (no uniform Y_n parametrix), full comb in the main problem; the measured state after rounds 250-255: OUTER_MODEL_FAILS (r250: the best global outer model from exact comb data carries the readout RATES -- base plateau gammahat = ((b-a)/4)^2 = 0.2500 exact within 0.040 on 4/4, h-rate slopes <= 0.007 dec/degree -- but fails pointwise, and the naked electrostatic diagonal model beats the fully dressed one 2.2-3.8x on all four windows: the arcsine-cell Szego dressing is the wrong pointwise object); OFFDIAG_EXTENSIVE (r254: no compact eigenspace on the exact tau coordinate, participation dimension D_part ~ 0.195 N over 42 rungs, and the INVERSION: arithmetic worlds are spectrally SPREAD, destroyed worlds spectrally COMPACT -- SCRAMBLE collapses to 2 eigendirections, EPSTEIN to 6, MAIN needs 28-30: compactness is the signature of DESTRUCTION; the atom diagonal carries 78.6 percent of the world gap -- every one-index compression leaves the complement in true pair structure; the EPSTEIN fiber anomaly closed as ARTEFACT_KERNEL_COUPLING); ORIENTATION_LOWDIM(1) (r255: the R2 node-band route is DEAD -- cap contact is absent on the mains, transitions are DENSE at fraction 0.55-0.63 and the drift is ANTI-correlated with them -- but the Heine saddle point E(S*_n) - E(S*_{n+1}) is the first outer-layer object that holds the h-rate 4/4 AND owns a sign channel, and the minimal parity-flipping ONE-NODE swap costs only 0.2 decades at the true flip degrees: the base failure is a SELECTION error of O(0.2 dec), one bit -- the first low-dimensional finding of the base front); and the 2x2 PRIOR (r245: canonical 2x2 RHP semidirect one-dimensional budget cocycle -- the formulation every later analysis consumes).  The base flip is a THRESHOLD EVENT (one bit, one 0.2-dec swap) of an extensively accumulated quantity; the fiber IS that accumulation, read through the kernel (the r254+r255 synthesis).  Mincut base 4 / refined 5 UNCHANGED (a dictionary + adjudication 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 bordered_hankel_probe.py (23/23,
BORDERED_RHP_DICTIONARY_EXACT + CORNER_IMPORTED_ONLY +
BUDGET_PROFILE_FROZEN(IRREGULAR_BULK), SPEC_SHA c21e15b5852126b9),
bordered_finite_rank_probe.py (29/29,
FORMULATION(SCHLESINGER_RANK1_INSERTION) + BORDERED_RANK2_EXACT +
UVAROV_PROJECTION_2PLUS2_FIXED + FULL_PIVOT_CHAIN_CARRIED, SPEC_SHA
886c65618145b838), border_centering_probe.py (24/24,
CENTERING_CONGRUENCE_EXACT + SIGMA0_DICTIONARY_EXACT +
QUIETZONE_ASYMPTOTIC_MOMENTS + TAIL_KERNEL_COMPRESSED +
EXTENSIVE_IRREGULAR_TAIL + THREE_ZONE_NORMALFORM, SPEC_SHA
767d16cff674f312), targetreadout_error_probe.py (20/20,
READOUT_FORMULAS_EXACT + AMPLIFICATION_EXTENSIVE(p=1.01) +
ANNIHILATION_NEUTRAL + FIBER_IN_ERROR_CONFIRMED +
BASE_READOUT_BLOCKED_BY_OFFSET + WORLD_GAP_IN_DELTA_T +
MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D), SPEC_SHA b76487877383f645;
seven pre-freeze amendments a1-a7 disclosed in the frozen header),
base_gauge_constant_probe.py (22/22, RATE_ONLY_NUMERICAL +
NO_GLOBAL_GAUGE + MODEL_ORIENTATION_BLIND + CONTOUR_R1_EXACT,
SPEC_SHA 26276cb2758152e9), schlesinger_pairing_probe.py (26/26,
TAU_RATIO_EXACT + POLE_REMOVAL_EXACT(rank1-border) +
D_DIRECT_ONLY_OBSTRUCTED + NO_FINITE_PAIR_DRESSING(D-layer) and the
measured refutations, SPEC_SHA e5f0498c98112da4; replaces the draft
fiber_pairing_probe.py, amendment disclosed), rounds
244/245/248/251/252/253, notes DLXXIII/DLXXV/DLXXVII/DLXXXI/DLXXXII/
DLXXXIII, 2026-08-24; re-run identically at promotion (23/23 + 29/29
+ 24/24 + 20/20 + 22/22 + 26/26, wall times 8.7/9.8/10.6/91.9/58.0/
62.7 s).  ROUND-31 EMBEDDING CONVENTION: frozen sources embedded
BYTE-EXACT, executed verbatim in isolated namespaces; printed SPEC
SHAs pinned and gated; byte-equality ward vs
experiments/tfpt-discovery/ inside the pattern gates.  All probes
consume the READ-ONLY deployed core v563_paper2_readouts.py.  The
measurement rounds 250/254/255 (centered_basefiber_probe.py 21/21
SPEC f9bf299d, offdiag_gram_probe.py 19/19 SPEC 1083f7a0,
nodebands_base_probe.py 17/17 SPEC 45875904) stay experiments-side
by design (typed MEASUREMENTS, not identities) and are consumed here
as the frozen state of the [O] campaign contract only; rounds
241-243/246/247/249 stay experiments-side as adjudication and
groundwork rounds; round 256 (baseborder_factorial_probe.py) was
still in flight at this promotion cut and is NOT consumed.

FIREWALL: no zeros, no prime-table oracles (AST scans inside the
probes); RNG only in declared scramble controls; heavy rungs declared
in the frozen headers; NO RH claim.  Python-only per GATE.WOLFRAM.02.
"""

import contextlib
import io
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 section: the PSD base theorem (S0)
def _psd_base_theorem(gates):
    """Exact-rational structural anchor: positive basis => Gram PSD =>
    T = t^T G t >= 0 for every real border; bordered PSD = wall +
    budget via the exact Schur complement; signed-measure must-fail."""

    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 PSD base theorem "
          "(exact rationals)")
    print("-" * 74, flush=True)

    # frozen positive measure (7 rational atoms, weights > 0)
    xs = [_Fr(-9, 10), _Fr(-3, 5), _Fr(-1, 4), _Fr(1, 10),
          _Fr(2, 5), _Fr(7, 10), _Fr(9, 10)]
    ws = [_Fr(3, 7), _Fr(1, 3), _Fr(5, 11), _Fr(2, 5),
          _Fr(1, 2), _Fr(4, 9), _Fr(3, 8)]
    N = 5

    def gram(nodes, weights, n):
        return [[sum(w * x ** (i + j) for x, w in zip(nodes, weights))
                 for j in range(n)] for i in range(n)]

    def quad(G, t):
        n = len(t)
        return sum(t[i] * G[i][j] * t[j]
                   for i in range(n) for j in range(n))

    def minors_positive(G):
        # exact fraction-free Sylvester chain via Bareiss determinants
        n = len(G)
        dets = []
        for k in range(1, n + 1):
            A = [row[:k] for row in G[:k]]
            det = _det_frac(A)
            dets.append(det)
        return dets

    def _det_frac(A):
        A = [row[:] for row in A]
        n = len(A)
        det = _Fr(1)
        for c in range(n):
            piv = None
            for r in range(c, n):
                if A[r][c] != 0:
                    piv = r
                    break
            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:
                    A[r] = [a - f * b for a, b in zip(A[r], A[c])]
        return det

    def solve_frac(G, u):
        # exact Gaussian solve G y = u
        n = len(u)
        A = [G[i][:] + [u[i]] for i in range(n)]
        for c in range(n):
            piv = next(r for r in range(c, n) if A[r][c] != 0)
            A[c], A[piv] = A[piv], A[c]
            inv = _Fr(1) / A[c][c]
            A[c] = [a * inv for a in A[c]]
            for r in range(n):
                if r != c and A[r][c]:
                    f = A[r][c]
                    A[r] = [a - f * b for a, b in zip(A[r], A[c])]
        return [A[i][n] for i in range(n)]

    G = gram(xs, ws, N)
    borders = [
        [_Fr(1), _Fr(-2), _Fr(3), _Fr(-1), _Fr(2)],
        [_Fr(0), _Fr(5), _Fr(-7), _Fr(2), _Fr(-3)],
        [_Fr(-4), _Fr(1), _Fr(0), _Fr(6), _Fr(-5)],
    ]

    # S0.1 the Gram identity: t^T G t == sum_j w_j p_t(x_j)^2 exactly
    ok1 = True
    for t in borders:
        lhs = quad(G, t)
        rhs = sum(w * sum(ti * x ** i for i, ti in enumerate(t)) ** 2
                  for x, w in zip(xs, ws))
        ok1 = ok1 and (lhs == rhs) and (lhs >= 0)
    chk("S0.1-gram-identity-exact", ok1,
        "t^T G_N t == int (sum_i t_i x^i)^2 dmu EXACT in rationals "
        "for all three frozen borders, hence T >= 0 identically -- "
        "the border readout of a POSITIVE basis is a square")

    # S0.2 Sylvester chain: all leading principal minors > 0
    dets = minors_positive(G)
    ok2 = all(d > 0 for d in dets)
    chk("S0.2-sylvester-chain-exact", ok2,
        "all %d leading principal minors of G_N positive (exact "
        "rationals): G_N is positive definite for ANY positive "
        "measure -- Gram PSD is basis-structural" % len(dets))

    # S0.3 the bordered Schur equivalence: [[G,u],[u^T,B]] PSD iff
    #      B >= u^T G^{-1} u (wall + budget, the r244 end-object)
    u = [sum(w * x ** i for x, w in zip(xs, ws)) * _Fr(1, 2)
         + _Fr(1, 3) ** (i + 1) for i in range(N)]
    y = solve_frac(G, u)
    s_budget = sum(a * b for a, b in zip(u, y))     # u^T G^{-1} u
    okp, okm = True, True
    for db, want in ((_Fr(1, 7), True), (-_Fr(1, 7), False)):
        Bb = s_budget + db
        M = [row[:] + [u[i]] for i, row in enumerate(G)]
        M.append(u[:] + [Bb])
        dets_b = minors_positive(M)
        # PSD of the bordered matrix iff det of the full matrix >= 0
        # (G > 0 already certified): det = det(G) (B - u^T G^{-1} u)
        full = dets_b[-1]
        if want:
            okp = okp and (full > 0) and (full ==
                                          dets[-1] * (Bb - s_budget))
        else:
            okm = okm and (full < 0)
    chk("S0.3-bordered-schur-exact", okp and okm,
        "bordered [[G,u],[u^T,B]]: det = det(G) (B - u^T G^{-1} u) "
        "EXACT; B above the budget => PSD, below => indefinite -- "
        "bordered PSD IS wall + budget (the r244 end-object shape), "
        "with the budget the exact squared dual norm of the border")

    # S0.4 must-fail: a SIGNED measure breaks the chain and the sign
    # (frozen witness, verified exactly at freeze time)
    vs = [_Fr(6, 5), _Fr(11, 10)]
    ys = [_Fr(-1, 2), _Fr(1, 5)]
    nodes_s = xs + ys
    weights_s = ws + [-v for v in vs]
    Gs = gram(nodes_s, weights_s, N)
    dets_s = minors_positive(Gs)
    neg_minor = any(d < 0 for d in dets_s)
    t_wit = [_Fr(-2), _Fr(-1, 2), _Fr(2), _Fr(0), _Fr(0)]
    q_wit = quad(Gs, t_wit)
    ok_mass = sum(weights_s) > 0     # non-degenerate: m0 stays > 0
    chk("S0.4-signed-must-fail-fires", bool(neg_minor) and
        q_wit < 0 and ok_mass,
        "the signed defect surrogate mu - nu (m0 > 0, "
        "non-degenerate) breaks the Sylvester chain (the third "
        "leading minor is negative) and the frozen rational border "
        "t = (-2, -1/2, 2, 0, 0) reads NEGATIVE (exact): positivity "
        "of the bordered "
        "readout is NOT basis-structural for signed measures -- any "
        "route consuming only positive-basis Gram structure proves "
        "the WRONG statement; the wall content is exactly the "
        "quasi-definiteness of mu - nu (v954/v955 lesson re-anchored "
        "on the bordered object)")


# ------------- frozen probe source bordered_hankel_probe (embedded BYTE-EXACT, raw string)
_SRC_0 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""bordered_hankel_probe -- PRIME.PORT.RHP.BORDEREDHANKEL.01
(round 244): the RHP lane on the compact r243 handover object.  The
fifth edge in its most compact form: "the bordered Hankel matrix
[[H_N, u], [u^T, B]] is PSD"  <=>  (wall H_N > 0) + (budget
S_{N-1} <= B).  This round does NOT try to prove the budget bound
(r243 typed it PAIRCORR_REENCODED -- the positivity of B - S IS the
square-root-scale bound); it prepares the object as an EXACT RHP
structure and measures what any later asymptotics must control.

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

INDEX FIREWALL (binding, r238-r243 discipline): w = window (kz),
N_w = builder depth, n = chain degree; free pivots h_{w,n} (n < N_w)
are the proof objects; sigma = the sealed r239/r243 smooth PNT-shape
border (F_DEF and F_DEF_SHA imported verbatim from r243 --
principal_bessel_probe.F_DEF); F_n = int pihat_n dsigmatilde,
rho_n = F_n^2/h_n, S_n = sum_{k<=n} rho_k (so the budget is
S_{N-1} = sum_{k<N} rho_k, r243 indexing).  Ground truth (h signs,
S, flips) enters GATES only, never a construction path.

LEG A -- THE EXACT BORDERED DICTIONARY.
(a1) reproduction of the r243 identity chain (cited, re-gated):
  partial Parseval q_n^T H_n^{-1} q_n = S_{n-1}; the telescope
  S_n - S_{n-1} = F_n^2/h_n; the bordered determinant
  det [[H_n, u_n], [u_n^T, B]] = det H_n * (B - S_{n-1});
  both sides are AFFINE-LINEAR in B, so exact rational equality at
  TWO sealed budgets B in {22/7, 5/3} proves the identity for ALL B
  (symbolic content without symbols); mp (dps 60) re-gate of the
  same determinant identity on the REAL w9 at n = 8/12, B in
  {2, 20}.
(a2) the EXACT RHP READOUT of F_n and S_{n-1} from the FIK solution
  Y_n (frozen normalization r227/r234), DERIVED at design time and
  frozen here:
  (i)  MOMENT ROUTE (r243, re-gated): F_n = s_n - v_n^T H_n^{-1}
       q_n -- the pairing of the smooth moments with the Hankel
       data of Y's own moment problem;
  (ii) BORDER COLUMN: define the Uvarov column Csig_n(z) =
       int pihat_n(x) dsigmatilde(x) / (z - x) -- the sigma-analogue
       of the second FIK column, built from the FIRST column of Y_n
       and the smooth measure.  Its 1/z-expansion has NO
       orthogonality cancellation: Csig_n(z) = F_n z^{-1} +
       O(z^{-2}), so F_n IS the Y1-style infinity readout of the
       border column (exact finite-z form, gated: z Csig_n(z) =
       F_n + Csig[x pihat_n](z)); the mutilde column has ZERO
       z^{-1} coefficient (int pihat_n dmutilde = 0) -- the
       contrast is the orthogonality ward;
  (iii) CD-KERNEL FORM: with K_n(x, y) = sum_{k<n} pihat_k(x)
       pihat_k(y)/h_k = [pihat_n(x) pihat_{n-1}(y) - pihat_{n-1}(x)
       pihat_n(y)] / (h_{n-1} (x - y)) = (Y_n^{-1}(y) Y_n(x))_21 /
       (y - x)  (det Y = 1), the budget is the border self-pairing
       of the integrable kernel:  S_{n-1} = intint K_n(x, y)
       dsigmatilde(x) dsigmatilde(y) -- S IS an RHP functional of
       the TERMINAL Y_n data alone (confluent diagonal via
       derivative CD); gated f64 at n = 12 on all 42 + 3 controls;
  (iv) R-TRANSFER WITH F-SOURCE: the border column obeys the SAME
       degree transfer as (pihat, C) up to an exact F-source:
       Csig_{n+1}(z) = (z - alphahat_n) Csig_n(z) - gammahat_n
       Csig_{n-1}(z) - F_n  (derivation: (x - a)/(z - x) =
       (z - a)/(z - x) - 1); the vanishing of the source for the
       mutilde column (= orthogonality) is WHY C_n is homogeneous
       -- the bordered problem is the FIK problem plus one
       F-sourced column.
(a3) UVAROV / RANK-1 BORDER: the bordered matrix is the Gram of
  (1, x, .., x^{N-1}, e) where e is the abstract smooth element
  with <x^i, e> = s_i and <e, e> = B (the extended object
  mutilde (+) smooth element); the Riesz representer of the border
  functional in the prefix space is r_n = sum_{k<n} (F_k/h_k)
  pihat_k with <r_n, pihat_k> = F_k, ||r_n||^2 = S_{n-1}, and the
  residual e - r_n is orthogonal to the prefix with norm^2 =
  B - S_{n-1} (the Schur corner); the bordered tau
  tau^b_n := det [[H_n, u_n], [u_n^T, B]] obeys the EXACT Uvarov
  step  tau^b_{n+1}/tau^b_n = h_n (B - S_n)/(B - S_{n-1}) =
  h_n (1 - rho_n/(B - S_{n-1})) -- the determinant identity of the
  one-column extension (rationals on the toy + mp on w9).

LEG B -- THE CANONICAL CORNER (sealed adjudication, max 3
candidates, all SOURCE-PURE: nodes, weights, moments of mu/mutilde
and sigma only; NO h-sign chain, NO tau, NO S, NO imported 5/7):
  b1 SMOOTH SELF-PAIRING: B1 = s_0 = int dsigmatilde -- the
     Gram-natural corner <e, e> when the border generator is read
     as u_i = <x^i, 1>_sigma (1 = the smooth element in its own
     geometry); honesty note: this is the diagonal-restricted Gram
     reading, the mixed cross-pairing is NOT a single-measure Gram.
  b2 SZEGO/EQUILIBRIUM BUDGET: B2 = sum_{k<N} (int p_k^{eq}
     dsigmatilde)^2 with p_k^{eq} the ORTHONORMAL arcsine
     (Chebyshev) chain on the measured hull [a_w, b_w] (hull = the
     combined window + border node range) normalized to total mass
     m_0(mutilde) -- the budget the FREE local model (r234
     capacity-1/4 plateau) would assign; an asymptotically
     computable Szego object.
  b3 MU-SIDE NORM: B3 = sum_{k<N} (int p_k^mu dsigmatilde)^2 with
     p_k^mu the ORTHONORMAL chain of the POSITIVE zone measure mu
     (all pivots > 0, a genuine norm): the smooth representer
     energy in the mu geometry (converges to int (dsig/dmu)^2 dmu
     in the a.c. limit).
  SEALED RULE per candidate (all four required for
  CANONICAL_CORNER_FOUND):
  (c1) PSD census: B_can - S_{N-1} > 0 on 42/42 MAIN;
  (c2) controls break CORRECTLY: the bordered pivot chain on
       EPSTEIN/SCRAMBLE/SMOOTH loses positivity AT the sealed wall
       flip 25/21/27 (h-pivot, not the corner), and NO control is
       certified by the full bordered claim (SMOOTH trap: its
       budget side is structurally 0 <= B -- the wall must kill
       it; typed, not hidden);
  (c3) growth match: Spearman(B_can; N) >= 0.3 AND the ratio
       B_can/S_{N-1} stays within one decade across the ladder
       (max/min <= 10) AND Spearman(B_can - S_{N-1}; N) > -0.5
       (margin does not collapse) -- only then is the cofinal
       statement well-posed;
  (c4) no alias: after removing the linear N-trend from both,
       |corr(res B_can, res S)| <= 0.95 (a candidate that rebuilds
       S beyond the common N-growth is CORNER_ALIAS, killed).
  If no candidate passes: CORNER_IMPORTED_ONLY (the honest r243
  status stands: only B_w = S_{N-2} + 5/7 -- prefix data plus the
  imported floor -- covers the surface).

LEG C -- BUDGET PROFILE (frozen requirement document for any later
Szego / steepest-descent analysis): per window the increments
rho_n over n: cumulative shares c(t) = S_{tN}/S_{N-1} at t = 1/4,
1/2, 3/4; tail share of the last 5 degrees; argmax location n*/N;
Gini coefficient of rho; N-scaling of S_{N-1} (Spearman + log-log
slope); MAIN vs controls BEFORE their flips (median rho and
std(log rho) on the common pre-flip range).  SEALED TYPING:
EARLY_FRONT iff median c(1/4) >= 0.5; TERMINAL_EDGE iff median
tail-5 share >= 0.3 (both can hold); else UNIFORM_SPREAD iff
median Gini < 0.5, else IRREGULAR_BULK.  Delivered as
BUDGET_PROFILE_FROZEN under any verdict.

LEG D -- THE 3-TERM FLOW OF THE BORDERED PROBLEM (the bordered
analogue of the LAX1 degree dynamics r226/r234): the step
n -> n+1 acts on the triple (h_n, F_n, S_n) as
  h_{n+1} = gammahat_{n+1} h_n                    (transfer),
  F_{n+1} = T_n - alphahat_n F_n - gammahat_n F_{n-1}   (3-term
            with SOURCE T_n := int x pihat_n dsigmatilde;
            F_1 = T_0 - alphahat_0 F_0),
  S_{n+1} = S_n + F_{n+1}^2/h_{n+1}               (telescope),
and the Schur corner flows AUTONOMOUSLY: D_n := B - S_{n-1} obeys
D_{n+1} = D_n - rho_n (r243 self-propagation) -- budget consumption
as an exact discrete flow.  Gates: exact rationals on the toy
(n = 0..3); f64 at n <= 12 on all 42 + 3 controls; mp (dps 160)
through the FULL depth n = 0..N-1 on w9 (the regime a conditioned
asymptotic must control).  The T-source is the shifted border
pairing -- the SAME class of object as F (no new currency).

LEG E -- FALSIFIERS + ANTI-ALIAS (design rules, enforced): all
candidate constructions source-pure (c4 + AST firewall); controls
break at 25/21/27; no control certified by any candidate; alias
typing per (c4).  MUST-FAILS (each loud): (m1) DROPPED SOURCE:
F_{n+1} = -alphahat_n F_n - gammahat_n F_{n-1} without T_n breaks
the flow loudly (toy exact + f64 >= 1e3 x honest residual); (m2)
INDEX-SHIFTED CORNER: det H_n (B - S_n) differs from the true
bordered det by exactly det H_n * rho_n != 0 (rationals; the r243
G13 must-fail in determinant form); (m3) CORNER ORACLE: B_orc =
1.01 * S_{N-1} certifies 42/42 trivially and is EXCLUDED by the
firewall (it consumes S); (m4) SIGN ORACLE: reading sign h_{N-1}
hits 42/42 and is EXCLUDED by the input firewall.

SEALED CONSTANTS: ladder = frame-A h <= 900 (42 rungs); background
du = 0.01 masses 2 e^{u/2} du (r243 map, via principal_bessel_
probe.smooth_comb); toy = r243 signed 9-atom toy + disjoint signed
5-atom smooth border, degrees 1..4; toy budgets B in {22/7, 5/3};
mp det block w9, dps 60, n in {8, 9, 12}, B in {2, 20}, bar 1e-25;
moment route worlds (w9, w12, w13 + 3 controls), n = 8/12, bars
1e-8 / 2e-6 (r243 values); f64 snapshot degree n = 12; CD bar
1e-6; z-panel (1.7+0.9i, 0.31+0.77i); z-readout bar 1e-10; border
column recursion bar 1e-8; orthogonality contrast bar 1e-8; flow
f64 bar 1e-8; chain-vs-plain F ward bar 1e-6; mp deep flow w9 dps
160 bar 1e-25; candidate rule bars 0.3 / decade 10 / -0.5 / 0.95;
profile rule bars 0.5 / 0.3 / 0.5; control flips 25/21/27;
runtime <= 1800 s.

SEALED VERDICTS (frozen before evaluation):
  BORDERED_RHP_DICTIONARY_EXACT iff ALL leg-A and leg-D gates pass
    (else BORDERED_RHP_DICTIONARY_OPEN);
  CANONICAL_CORNER_FOUND(bX) iff a candidate passes c1-c4
    (else CORNER_IMPORTED_ONLY; CORNER_ALIAS typed per c4);
  BUDGET_PROFILE_FROZEN(type) always delivered (leg C);
  combinations joined with '+'; honesty before beauty.

HONESTY GUARD (sealed pre-run): a passing candidate census is a
MEASUREMENT, not a theorem -- if a candidate passes c1-c4 the
modifier B_CAN_NO_BOUND_MECHANISM is appended: the passing B_can
defines the candidate ZIELSATZ of the RHP lane (prove
B_can - S_{N-1} >= 0 asymptotically), it does not prove it; the
r243 budget bound stays OPEN (PAIRCORR_REENCODED stands).

RECORD TABLES (frozen from calib_bh_pass2.log, 23/23, wall ~10 s;
disclosed SMOKE/CALIBRATION AMENDMENTS -- the dictionary formulas,
the candidate definitions, the adjudication rules c1-c4, the
profile typing rule and the verdict rules NEVER moved: (s1) the
f64 flow residual and the m1 loudness ratio are measured on the
ABSOLUTE mass-norm scale of the four flow terms -- the smoke run
caught the SMOOTH self-alias live (F == 0 structurally: two
numerical zeros have no relative comparison; the r243 amendment-a1
guard extended to the flow gate); no numeric bar moved; (s2) the
G61 comparison wording was neutralized to the measured numbers
(MAIN and EPSTEIN are comparable pre-flip; no regularity-
superiority claim) -- text only, no rule touched):
CAL_VERDICT = BORDERED_RHP_DICTIONARY_EXACT + CORNER_IMPORTED_ONLY
+ BUDGET_PROFILE_FROZEN(IRREGULAR_BULK).
Key numbers.  DICTIONARY (leg A + D, all exact): toy rationals --
Parseval, telescope, bordered det at B = 22/7 AND 5/3 (affine in
B => all B), representer <r, x^i> = s_i / ||r||^2 = S_{n-1} /
<r, pihat_k> = F_k, Uvarov tau step, T-sourced 3-term flow and
autonomous corner flow D_{n+1} = D_n - rho_n all EXACT; real w9
mp dets (dps 60): bordered det identity worst 4.8e-55 (n = 8/9/
12, B = 2/20), Uvarov step ratio dev 7.1e-58; moment route worst
1.6e-12 (n = 8) / 1.6e-12 (n = 12) on w9/w12/w13 + EPSTEIN/
SCRAMBLE/SMOOTH; CD-kernel S-readout worst 3.7e-15 (42 + 3
worlds, n = 12) -- the budget IS a functional of the terminal
Y_n data; border-column z-readout worst 6.7e-13 with
orthogonality contrast 1.1e-15 (the mutilde column's z^{-1}
coefficient is 0, the sigma column's IS F_n); column R-transfer
with F-source worst 3.5e-12; flow f64 worst 1.5e-16 (mass-norm
scale), chain-vs-plain F ward 1.1e-15; mp deep flow through ALL
184 w9 degrees worst 7.0e-159.  LEG B (the round's honest
negative): ALL THREE source-pure candidates FAIL c1 -- PSD 0/42
each: b1 = s_0 in [2.91, 4.43], b2 (Szego/equilibrium) in
[4.87, 7.34], b3 (mu-side norm) in [4.15, 8.79] vs S_{N-1} in
[6.06, 15.41]: the measured budget EXCEEDS every canonical
source-pure corner on every window (margins down to -11); all
three also fail the margin-trend clause of c3 (-0.65/-0.58/
-0.65: the deficit GROWS with N); growth shapes are otherwise
S-like (Spearman(B;N) +0.95/+0.96/+0.84, ratio decade < 2), no
alias fires (res-corr -0.14/-0.20/+0.93, all <= 0.95), no
control is certified (wall breaks at 25/21/27 exactly) =>
CORNER_IMPORTED_ONLY: the only budget known to cover the surface
remains the r243 window form B_w = S_{N-2} + 5/7 (prefix data +
imported floor) -- a canonical corner, if it exists, must be
STRICTLY LARGER than the smooth self-pairing, the equilibrium
budget and the mu-side norm: the signed mutilde geometry
(razor cancellation in h) INFLATES the budget above every
positive-geometry yardstick tested.  LEG C (frozen requirement
profile): S_{N-1} in [6.063, 15.408] median 10.463, Spearman(S;
N) +0.74, log-log slope 0.33 (r243 census reproduced); shares
c(1/4) med 0.387, c(1/2) 0.543, c(3/4) 0.754, tail-5 med 0.035,
argmax at DEGREE 0 on 42/42 (rho_0 share med 0.366, never the
terminal degree), Gini med 0.909 => IRREGULAR_BULK by the sealed
rule: the budget is HEAVY-HEADED (rho_0 alone ~37 percent) with
a long irregular bulk tail and NEGLIGIBLE terminal-edge share
(3.5 percent in the last 5 degrees) -- the r243 razor margin
5/7 - rho_{N-1} is small NOT because the tail is heavy but
because 5/7 is tight; any later Szego/steepest-descent analysis
must control a highly non-uniform bulk, not a terminal boundary
layer; MAIN vs controls pre-flip (w9 base): MAIN med rho
2.1e-06 / std log 3.2 vs EPSTEIN 2.2e-06 / 3.3 (comparable),
SCRAMBLE 1.9e-03 / 2.6 (three orders MORE budget per degree),
SMOOTH 2.8e-31 (self-alias, typed).  MUST-FAILS all loud: m1
dropped T-source >= 2.9e+10 x honest (+ exact toy break), m2
breaks the det identity by exactly det H_n rho_n, m3 corner
oracle B = 1.01 S hits 42/42 and is EXCLUDED (consumes S), m4
sign oracle hits 42/42 and is EXCLUDED.  Runtime 9.5 s full,
0.6 s smoke.  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

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

import hirota_sign_probe as HS               # noqa: E402 r226
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

H_CAP = 900
N_SNAP = 12
Z_PANEL = (1.7 + 0.9j, 0.31 + 0.77j)
B_TOY = (Fr(22, 7), Fr(5, 3))
B_MP = (2, 20)
MP_DET_DPS = 60
MPDET_BAR = 1e-25
MOM_WORLDS = (9, 12, 13)
MOM8_BAR = 1e-8
MOM12_BAR = 2e-6
CD_BAR = 1e-6
ZREAD_BAR = 1e-10
COLREC_BAR = 1e-8
ORTH_BAR = 1e-8
FLOW_BAR = 1e-8
FWARD_BAR = 1e-6
MP_DPS = 160
MPFLOW_BAR = 1e-25
SPEAR_MIN = 0.3
RATIO_DECADE = 10.0
MARGIN_TREND = -0.5
ALIAS_RES = 0.95
C25_EARLY = 0.5
TAIL5_EDGE = 0.3
GINI_UNIF = 0.5
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
SMOKE_KZ = (9, 12, 13, 26, 40)
CAL_VERDICT = ("BORDERED_RHP_DICTIONARY_EXACT + "
               "CORNER_IMPORTED_ONLY + "
               "BUDGET_PROFILE_FROZEN(IRREGULAR_BULK)")

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; candidates b1/b2/b3 "
                       "consume nodes/weights/moments ONLY (no h "
                       "sign chain, no tau, no S, no imported 5/7);"
                       " ground truth enters gates only"
                       if not bad else "; ".join(bad))


def spearman(x, y):
    def ranks(v):
        v = np.asarray(v, float)
        order = np.argsort(v, kind="stable")
        rk = np.empty(len(v))
        rk[order] = np.arange(len(v), dtype=float)
        for val in np.unique(v):
            m = v == val
            rk[m] = rk[m].mean()
        return rk
    rx, ry = ranks(x), ranks(y)
    rx -= rx.mean()
    ry -= ry.mean()
    den = math.sqrt(float(np.sum(rx ** 2) * np.sum(ry ** 2)))
    return float(np.sum(rx * ry) / den) if den > 0 else 0.0


def res_corr(a, b, ns):
    """pearson corr of the residuals after removing the linear
    N-trend from both series (alias detector c4)."""
    a = np.asarray(a, float)
    b = np.asarray(b, float)
    n = np.asarray(ns, float)
    def res(v):
        A = np.vstack([np.ones_like(n), n]).T
        c, *_ = np.linalg.lstsq(A, v, rcond=None)
        return v - A @ c
    ra, rb = res(a), res(b)
    den = math.sqrt(float(np.sum(ra ** 2) * np.sum(rb ** 2)))
    return float(np.sum(ra * rb) / den) if den > 0 else 0.0


def gini(v):
    v = np.sort(np.asarray(v, float))
    n = len(v)
    s = float(v.sum())
    if s <= 0.0:
        return 0.0
    i = np.arange(1, n + 1, dtype=float)
    return float(2.0 * np.sum(i * v) / (n * s) - (n + 1.0) / n)


# ------------------------------------------------- bordered chain
def bord_chain(xs, ws, ys, vs, bx, bw, by, bv, n_upto):
    """r243 bessel_chain recursion verbatim in the chain path,
    extended: per degree n also alphahat_n, gammahat_{n+1} and the
    shifted border pairing tb = T_n e^{-Ls} with T_n =
    int x pihat_n dsigmatilde (the leg-D flow source).
    Source-pure: node positions and weights only."""
    qx = np.ones_like(xs)
    qy = np.ones_like(ys)
    qb = np.ones_like(bx)
    qc = np.ones_like(by)
    qx_m = np.zeros_like(xs)
    qy_m = np.zeros_like(ys)
    qb_m = np.zeros_like(bx)
    qc_m = np.zeros_like(by)
    Ls = Ls_m = 0.0
    eta = float(np.sum(ws) - np.sum(vs))
    eta_m = eta
    lg_h = math.log(abs(eta))
    sg_h = math.copysign(1.0, eta)
    rows = []
    for n in range(n_upto):
        fb = float(np.sum(bw * qb) - np.sum(bv * qc))
        tb = float(np.sum(bw * bx * qb) - np.sum(bv * by * qc))
        alh = (float(np.sum(ws * xs * qx * qx)
                     - np.sum(vs * ys * qy * qy))) / eta
        rows.append(dict(n=n, lg_h=lg_h, sg_h=sg_h, Ls=Ls, eta=eta,
                         fb=fb, tb=tb, rho=fb * fb / eta, alh=alh,
                         gam_next=None))
        if n == 0:
            px = (xs - alh) * qx
            py = (ys - alh) * qy
            pb = (bx - alh) * qb
            pc = (by - alh) * qc
        else:
            ge = (eta / eta_m) * math.exp(2.0 * (Ls - Ls_m))
            fc = math.exp(Ls_m - Ls)
            px = (xs - alh) * qx - ge * fc * qx_m
            py = (ys - alh) * qy - ge * fc * qy_m
            pb = (bx - alh) * qb - ge * fc * qb_m
            pc = (by - alh) * qc - ge * fc * qc_m
        sc = max(float(np.max(np.abs(px))), float(np.max(np.abs(py))),
                 float(np.max(np.abs(pb))), float(np.max(np.abs(pc))))
        if sc == 0.0 or not math.isfinite(sc):
            return rows
        qx_m, qy_m, eta_m, Ls_m = qx, qy, eta, Ls
        qb_m, qc_m = qb, qc
        qx, qy = px / sc, py / sc
        qb, qc = pb / sc, pc / sc
        Ls += math.log(sc)
        eta = float(np.sum(ws * qx * qx) - np.sum(vs * qy * qy))
        if eta == 0.0 or not math.isfinite(eta):
            return rows
        gam = (eta / eta_m) * math.exp(2.0 * (Ls - Ls_m))
        rows[-1]["gam_next"] = gam
        lg_h += math.log(abs(gam))
        sg_h *= math.copysign(1.0, gam)
    return rows


def mu_side_budget(xs, ws, bxa, bwa, n_upto):
    """b3: sum_{k<N} (int p_k^mu dsigma)^2 with the ORTHONORMAL
    positive-zone chain (scale-free increments fb^2/eta).
    Source-pure: mu nodes/weights + border atoms only."""
    qx = np.ones_like(xs)
    qb = np.ones_like(bxa)
    qx_m = np.zeros_like(xs)
    qb_m = np.zeros_like(bxa)
    Ls = Ls_m = 0.0
    eta = float(np.sum(ws))
    eta_m = eta
    acc = 0.0
    for n in range(n_upto):
        fb = float(np.sum(bwa * qb))
        acc += fb * fb / eta
        alh = float(np.sum(ws * xs * qx * qx)) / eta
        if n == 0:
            px = (xs - alh) * qx
            pb = (bxa - alh) * qb
        else:
            ge = (eta / eta_m) * math.exp(2.0 * (Ls - Ls_m))
            fc = math.exp(Ls_m - Ls)
            px = (xs - alh) * qx - ge * fc * qx_m
            pb = (bxa - alh) * qb - ge * fc * qb_m
        sc = max(float(np.max(np.abs(px))),
                 float(np.max(np.abs(pb))))
        if sc == 0.0 or not math.isfinite(sc):
            return acc
        qx_m, qb_m, eta_m, Ls_m = qx, qb, eta, Ls
        qx, qb = px / sc, pb / sc
        Ls += math.log(sc)
        eta = float(np.sum(ws * qx * qx))
        if eta <= 0.0 or not math.isfinite(eta):
            return acc
    return acc


def cheb_budget(bxa, bwa, x0, rh, m0, n_upto):
    """b2: sum_{k<N} (int p_k^{eq} dsigma)^2 with the orthonormal
    arcsine/Chebyshev chain on the combined hull, mass m0."""
    u = (bxa - x0) / rh
    t_m = np.ones_like(u)
    t = u.copy()
    acc = float(np.sum(bwa)) ** 2 / m0
    for _k in range(1, n_upto):
        acc += (2.0 / m0) * float(np.sum(bwa * t)) ** 2
        t_m, t = t, 2.0 * u * t - t_m
    return acc


def plain_vals(alh, gamv, nodes, m):
    """plain monic values + derivatives on an atom array from the
    chain heads (f64-honest at moderate degree only)."""
    P = [np.ones_like(nodes), nodes - alh[0]]
    dP = [np.zeros_like(nodes), np.ones_like(nodes)]
    for k in range(1, m):
        P.append((nodes - alh[k]) * P[k] - gamv[k] * P[k - 1])
        dP.append(P[k] + (nodes - alh[k]) * dP[k]
                  - gamv[k] * dP[k - 1])
    return P, dP


# ---------------------------------------------------- window pack
def wpack(kz, base_kw=None):
    d = HS.window_data(kz, **(base_kw or {}))
    N = d["n_max"]
    alpha = PIK.build_rung(kz)["alpha"]
    dsm = HS.window_data(kz, comb=PB.smooth_comb(alpha))
    rows = bord_chain(d["xs"], d["ws"], d["ys"], d["vs"],
                      dsm["xs"], dsm["ws"], dsm["ys"], dsm["vs"], N)
    rho = np.array([r["rho"] for r in rows])
    S = np.cumsum(rho)
    nf = next((r["n"] for r in rows if r["sg_h"] < 0), None)
    m = N_SNAP
    alh = [rows[k]["alh"] for k in range(m + 3)]
    gamv = [0.0] + [rows[k]["gam_next"] for k in range(m + 2)]
    bxa = np.concatenate([dsm["xs"], dsm["ys"]])
    bwa = np.concatenate([dsm["ws"], -dsm["vs"]])
    wxa = np.concatenate([d["xs"], d["ys"]])
    wwa = np.concatenate([d["ws"], -d["vs"]])
    P, dP = plain_vals(alh, gamv, bxa, m + 2)
    Pw, _ = plain_vals(alh, gamv, wxa, m + 1)
    Fv = [float(bwa @ P[k]) for k in range(m + 2)]
    Tv = [float(bwa @ (bxa * P[k])) for k in range(m + 2)]
    hv = [rows[k]["sg_h"] * math.exp(rows[k]["lg_h"])
          for k in range(m + 1)]
    # a2(iii) CD-kernel readout of S_{m-1} from terminal Y_m data
    Dm = bxa[:, None] - bxa[None, :]
    NUM = P[m][:, None] * P[m - 1][None, :] \
        - P[m - 1][:, None] * P[m][None, :]
    with np.errstate(divide="ignore", invalid="ignore"):
        K = NUM / (hv[m - 1] * Dm)
    kd = (dP[m] * P[m - 1] - dP[m - 1] * P[m]) / hv[m - 1]
    np.fill_diagonal(K, kd)
    S_cd = float(bwa @ K @ bwa)
    cd_dev = abs(S_cd / float(S[m - 1]) - 1.0)
    del Dm, NUM, K
    # a2(ii) z-readout + orthogonality contrast + a2(iv) transfer
    zread_dev = 0.0
    colrec_dev = 0.0
    for z in Z_PANEL:
        Cs = [complex(np.sum(bwa * P[k] / (z - bxa)))
              for k in range(m + 1)]
        Cxs = complex(np.sum(bwa * bxa * P[m] / (z - bxa)))
        scz = max(abs(z * Cs[m]), abs(Fv[m]), abs(Cxs))
        zread_dev = max(zread_dev,
                        abs(z * Cs[m] - (Fv[m] + Cxs)) / scz)
        for k in range(1, m):
            rhs = (z - alh[k]) * Cs[k] - gamv[k] * Cs[k - 1] \
                - Fv[k]
            scr = max(abs(Cs[k + 1]), abs(Fv[k]), 1e-300)
            colrec_dev = max(colrec_dev,
                             abs(Cs[k + 1] - rhs) / scr)
    mu_pair = float(wwa @ Pw[m])
    mu_nrm = float(np.abs(wwa) @ np.abs(Pw[m]))
    orth_rel = abs(mu_pair) / mu_nrm
    # leg D flow residual (f64, n = 0..m-1) + chain-vs-plain ward;
    # scale = ABSOLUTE mass norm of the four terms (SMOOTH is the
    # F = 0 self-alias: two numerical zeros have no relative
    # comparison -- r243 amendment-a1 guard, typed)
    aw = np.abs(bwa)
    flow_dev = 0.0
    for k in range(0, m):
        rhs = Tv[k] - alh[k] * Fv[k] \
            - (gamv[k] * Fv[k - 1] if k >= 1 else 0.0)
        nrm = (float(aw @ np.abs(P[k + 1]))
               + float(aw @ np.abs(bxa * P[k]))
               + abs(alh[k]) * float(aw @ np.abs(P[k]))
               + (abs(gamv[k]) * float(aw @ np.abs(P[k - 1]))
                  if k >= 1 else 0.0))
        flow_dev = max(flow_dev,
                       abs(Fv[k + 1] - rhs) / max(nrm, 1e-300))
    F_ch = rows[m]["fb"] * math.exp(rows[m]["Ls"])
    fward = abs(Fv[m] - F_ch) / max(abs(Fv[m]),
                                    math.sqrt(abs(hv[m])))
    # dropped-source must-fail material (m1, same mass-norm scale)
    k = m - 1
    bad = abs(Fv[k + 1] - (-alh[k] * Fv[k] - gamv[k] * Fv[k - 1]))
    nrm = (float(aw @ np.abs(P[k + 1]))
           + float(aw @ np.abs(bxa * P[k]))
           + abs(alh[k]) * float(aw @ np.abs(P[k]))
           + abs(gamv[k]) * float(aw @ np.abs(P[k - 1])))
    m1_ratio = (bad / max(nrm, 1e-300)) / max(flow_dev, 1e-300)
    # candidates (source-pure)
    b1 = float(np.sum(bwa))
    hull_lo = min(float(np.min(wxa)), float(np.min(bxa)))
    hull_hi = max(float(np.max(wxa)), float(np.max(bxa)))
    x0 = 0.5 * (hull_lo + hull_hi)
    rh = 0.5 * (hull_hi - hull_lo)
    m0 = float(np.sum(wwa))
    b2 = cheb_budget(bxa, bwa, x0, rh, m0, N)
    b3 = mu_side_budget(d["xs"], d["ws"], bxa, bwa, N)
    # leg C profile stats
    St = float(S[N - 1])
    shares = {t: float(S[max(int(t * N) - 1, 0)]) / St
              for t in (0.25, 0.5, 0.75)}
    tail5 = (St - float(S[N - 6])) / St
    argmax_frac = float(np.argmax(rho)) / N
    rho0_share = float(rho[0]) / St
    gin = gini(rho) if nf is None else float("nan")
    return dict(kz=kz, N=N, rows=rows, rho=rho, S=S, nf=nf,
                St=St, cd_dev=cd_dev, zread_dev=zread_dev,
                colrec_dev=colrec_dev, orth_rel=orth_rel,
                flow_dev=flow_dev, fward=fward, m1_ratio=m1_ratio,
                b1=b1, b2=b2, b3=b3, shares=shares, tail5=tail5,
                argmax_frac=argmax_frac, rho0_share=rho0_share,
                gini=gin, d=d, dsm=dsm, Fv=Fv, hv=hv)


# ------------------------------------------------------ mp blocks
def mp_moments(d, dsm, n_hi, dps):
    import mpmath as mp
    mp.mp.dps = dps
    pos = np.concatenate([d["xs"], d["ys"]])
    wt = np.concatenate([d["ws"], -d["vs"]])
    sps = np.concatenate([dsm["xs"], dsm["ys"]])
    swt = np.concatenate([dsm["ws"], -dsm["vs"]])
    pm = [mp.mpf(float(x)) for x in pos]
    wm = [mp.mpf(float(x)) for x in wt]
    sm_ = [mp.mpf(float(x)) for x in sps]
    vm = [mp.mpf(float(x)) for x in swt]
    mmom, smom = [], []
    cw, cs = list(wm), list(vm)
    for k in range(2 * n_hi + 1):
        mmom.append(mp.fsum(cw))
        if k <= n_hi:
            smom.append(mp.fsum(cs))
            cs = [c * x for c, x in zip(cs, sm_)]
        cw = [c * x for c, x in zip(cw, pm)]
    return mmom, smom


def mp_det_block(p):
    """leg A1/A3 mp: bordered det identity + Uvarov tau step on
    the real w9 (dps 60)."""
    import mpmath as mp
    mp.mp.dps = MP_DET_DPS
    mmom, smom = mp_moments(p["d"], p["dsm"], N_SNAP, MP_DET_DPS)
    detH = {}
    Sval = {}
    detG = {}
    for n in (8, 9, 12):
        H = mp.matrix([[mmom[i + j] for j in range(n)]
                       for i in range(n)])
        detH[n] = mp.det(H)
        qv = mp.matrix([smom[i] for i in range(n)])
        sq = mp.lu_solve(H, qv)
        Sval[n] = sum(qv[i] * sq[i] for i in range(n))
        for B in B_MP:
            G = mp.zeros(n + 1, n + 1)
            for i in range(n):
                for j in range(n):
                    G[i, j] = mmom[i + j]
                G[i, n] = G[n, i] = smom[i]
            G[n, n] = mp.mpf(B)
            detG[(n, B)] = mp.det(G)
    dev = 0.0
    for n in (8, 9, 12):
        for B in B_MP:
            lhs = detG[(n, B)]
            rhs = detH[n] * (mp.mpf(B) - Sval[n])
            sc = max(abs(lhs), abs(rhs))
            dev = max(dev, float(abs(lhs - rhs) / sc))
    # Uvarov step at n = 8 -> 9: tau^b ratio = h_8 (B-S_8)/(B-S_7)
    h8 = detH[9] / detH[8]
    udev = 0.0
    for B in B_MP:
        lhs = detG[(9, B)] / detG[(8, B)]
        rhs = h8 * (mp.mpf(B) - Sval[9]) / (mp.mpf(B) - Sval[8])
        udev = max(udev, float(abs(lhs / rhs - 1.0)))
    return dev, udev


def mp_moment_route(worlds):
    """a2(i) reproduction (r243 G30 route): F/h/S from moments
    only, vs the f64 chain (dps 60)."""
    import mpmath as mp
    mp.mp.dps = MP_DET_DPS
    worst8 = worst12 = 0.0
    for p in worlds:
        mmom, smom = mp_moments(p["d"], p["dsm"], N_SNAP,
                                MP_DET_DPS)
        for nchk in (8, N_SNAP):
            H = mp.matrix([[mmom[i + j] for j in range(nchk)]
                           for i in range(nchk)])
            v = mp.matrix([mmom[nchk + i] for i in range(nchk)])
            qv = mp.matrix([smom[i] for i in range(nchk)])
            sv = mp.lu_solve(H, v)
            sq = mp.lu_solve(H, qv)
            h_mom = mmom[2 * nchk] - sum(v[i] * sv[i]
                                         for i in range(nchk))
            F_mom = smom[nchk] - sum(v[i] * sq[i]
                                     for i in range(nchk))
            pars = sum(qv[i] * sq[i] for i in range(nchk))
            r = p["rows"][nchk]
            h_ch = r["sg_h"] * math.exp(r["lg_h"])
            F_ch = r["fb"] * math.exp(r["Ls"])
            S_ch = float(p["S"][nchk - 1])
            hsc = math.sqrt(abs(h_ch))
            dev = abs(float(h_mom) / h_ch - 1.0)
            if (F_ch / hsc) ** 2 > 1e-24:
                dev = max(dev, abs(float(F_mom) / F_ch - 1.0))
            else:
                dev = max(dev, abs(float(F_mom)) / hsc)
            if S_ch > 1e-20:
                dev = max(dev, abs(float(pars) / S_ch - 1.0))
            else:
                dev = max(dev, abs(float(pars)))
            if nchk == 8:
                worst8 = max(worst8, dev)
            else:
                worst12 = max(worst12, dev)
    return worst8, worst12


def mp_deep_flow(p):
    """leg D mp: the T-sourced 3-term F-flow through ALL degrees
    n = 0..N-1 on w9 (dps 160, unscaled monic)."""
    import mpmath as mp
    mp.mp.dps = MP_DPS
    d, dsm = p["d"], p["dsm"]
    N = p["N"]
    nds = ([mp.mpf(float(x)) for x in d["xs"]]
           + [mp.mpf(float(y)) for y in d["ys"]])
    wtm = ([mp.mpf(float(w)) for w in d["ws"]]
           + [-mp.mpf(float(v)) for v in d["vs"]])
    bns = ([mp.mpf(float(x)) for x in dsm["xs"]]
           + [mp.mpf(float(y)) for y in dsm["ys"]])
    bwm = ([mp.mpf(float(w)) for w in dsm["ws"]]
           + [-mp.mpf(float(v)) for v in dsm["vs"]])
    pk = [mp.mpf(1)] * len(nds)
    pkm = [mp.mpf(0)] * len(nds)
    bk = [mp.mpf(1)] * len(bns)
    bkm = [mp.mpf(0)] * len(bns)
    hs = [mp.fsum(w * p_ * p_ for w, p_ in zip(wtm, pk))]
    F_m = mp.mpf(0)
    F_c = mp.fsum(w * p_ for w, p_ in zip(bwm, bk))
    worst = mp.mpf(0)
    for k in range(N - 1):
        T_c = mp.fsum(w * x * p_ for w, x, p_ in zip(bwm, bns, bk))
        a = mp.fsum(w * x * p_ * p_
                    for w, x, p_ in zip(wtm, nds, pk)) / hs[-1]
        g = (hs[-1] / hs[-2]) if k > 0 else mp.mpf(0)
        nx = [(x - a) * p_ - g * q for x, p_, q in zip(nds, pk, pkm)]
        nb = [(x - a) * p_ - g * q for x, p_, q in zip(bns, bk, bkm)]
        pkm, pk = pk, nx
        bkm, bk = bk, nb
        hs.append(mp.fsum(w * p_ * p_ for w, p_ in zip(wtm, pk)))
        F_n = mp.fsum(w * p_ for w, p_ in zip(bwm, bk))
        rhs = T_c - a * F_c - g * F_m
        sc = max(abs(F_n), abs(T_c), abs(a * F_c), mp.mpf("1e-300"))
        worst = max(worst, abs(F_n - rhs) / sc)
        F_m, F_c = F_c, F_n
    return float(worst)


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

    print("=" * 78)
    print("bordered_hankel_probe -- PRIME.PORT.RHP."
          "BORDEREDHANKEL.01 (round 244)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (five known rungs, mp blocks "
                        "reduced)" if smoke else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "F definition + hash imported verbatim from r243 "
          "(F_DEF_SHA above); dictionary formulas (moment route, "
          "border column, CD kernel, R-transfer-with-F-source), "
          "candidates b1/b2/b3, adjudication c1-c4 (bars %.1f / "
          "decade %.0f / %.1f / %.2f), profile typing (%.1f / "
          "%.1f / %.1f) and verdict rules sealed in the frozen "
          "spec; toy budgets %s (affine-B argument), mp det "
          "budgets %s; control flips 25/21/27"
          % (SPEAR_MIN, RATIO_DECADE, MARGIN_TREND, ALIAS_RES,
             C25_EARLY, TAIL5_EDGE, GINI_UNIF,
             str([str(b) for b in B_TOY]), str(B_MP)))

    # ---------------- S1: leg A1 -- exact bordered dictionary
    section("S1  LEG A1 -- EXACT DICTIONARY (rationals + mp dets)")
    JFn = [Fr(-7, 8), Fr(-5, 8), Fr(-3, 8), Fr(-1, 8), Fr(1, 8),
           Fr(3, 8), Fr(5, 8), Fr(7, 8), Fr(0, 1)]
    JFw = [Fr(3, 7), Fr(-2, 9), Fr(5, 11), Fr(1, 4), Fr(-3, 8),
           Fr(2, 5), Fr(-1, 6), Fr(4, 9), Fr(1, 3)]
    SBn = [Fr(-13, 16), Fr(-7, 16), Fr(-1, 16), Fr(5, 16),
           Fr(11, 16)]
    SBw = [Fr(2, 5), Fr(-1, 7), Fr(3, 8), Fr(-2, 11), Fr(1, 3)]
    NTOY = 4
    al, hs, _v = PB.toy_chain(JFn, JFw, NTOY + 1)
    mom = [sum(w * x ** k for w, x in zip(JFw, JFn))
           for k in range(2 * NTOY + 4)]
    smom = [sum(w * x ** k for w, x in zip(SBw, SBn))
            for k in range(NTOY + 2)]
    Ftoy = [sum(w * PB.toy_eval(al, hs, k, x)
                for w, x in zip(SBw, SBn)) for k in range(NTOY + 1)]
    Ttoy = [sum(w * x * PB.toy_eval(al, hs, k, x)
                for w, x in zip(SBw, SBn)) for k in range(NTOY + 1)]
    Stoy = []
    acc = Fr(0)
    for k in range(NTOY + 1):
        acc += Ftoy[k] * Ftoy[k] / hs[k]
        Stoy.append(acc)

    def Hm(n):
        return [[mom[i + j] for j in range(n)] for i in range(n)]

    def Gb(n, B):
        M = [[mom[i + j] for j in range(n)] + [smom[i]]
             for i in range(n)]
        M.append([smom[j] for j in range(n)] + [B])
        return M

    ok1 = ok2 = ok3 = True
    for n in range(1, NTOY + 1):
        q = [smom[i] for i in range(n)]
        sol_q = PB.frac_solve(Hm(n), q)
        pars = sum(qi * si for qi, si in zip(q, sol_q))
        ok1 = ok1 and (pars == Stoy[n - 1])
        if n >= 2:
            ok2 = ok2 and (Stoy[n - 1] - Stoy[n - 2]
                           == Ftoy[n - 1] ** 2 / hs[n - 1])
        for B in B_TOY:
            ok3 = ok3 and (PB.frac_det(Gb(n, B))
                           == PB.frac_det(Hm(n))
                           * (B - Stoy[n - 1]))
    check("G10-toy-dictionary-exact", ok1 and ok2 and ok3,
          "rationals, n = 1..4 (r243 toy + border, cited): "
          "Parseval q^T H^{-1} q = S_{n-1}; telescope S_n - "
          "S_{n-1} = F_n^2/h_n; bordered det [[H_n, u],[u^T, B]] "
          "= det H_n (B - S_{n-1}) at B = 22/7 AND 5/3 -- both "
          "sides affine in B, so the identity holds for ALL B "
          "(symbolic content, no symbols)")
    if smoke:
        check("G11-mp-bordered-det", True,
              "SKIPPED in smoke mode (dps-60 block on w9)")
        mpdet = mpuva = 0.0
    else:
        pass  # filled after ladder build (needs w9 pack)

    # ---------------- S2: ladder + controls
    section("S2  LADDER + CONTROLS")
    if smoke:
        kzs = list(SMOKE_KZ)
    else:
        kzs = [kz for kz in core.frame_a_zones()
               if PIK.build_rung(kz)["h"] <= H_CAP]
    packs = [wpack(kz) for kz in kzs]
    packs.sort(key=lambda p: (p["N"], p["kz"]))
    by_kz = {p["kz"]: p for p in packs}
    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"])
    ctrl_defs = (("EPSTEIN", dict(comb=(
        np.log(nn_idx.astype(float)),
        2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
        ("SCRAMBLE", dict(scramble_seed=1)),
        ("SMOOTH", dict(comb=(ug9, uw9))))
    ctrl = {c: wpack(9, base_kw=kw) for c, kw in ctrl_defs}
    okC = all(p["nf"] is None for p in packs)
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl)
    check("G20-census", okC and okCf,
          "free prefix positive on %d/%d MAIN windows (N in "
          "[%d, %d]); control flips re-derived AT the sealed "
          "degrees %s" % (
              sum(1 for p in packs if p["nf"] is None), len(packs),
              packs[0]["N"], packs[-1]["N"],
              str({c: ctrl[c]["nf"] for c in ctrl})))

    if not smoke:
        mpdet, mpuva = mp_det_block(by_kz[9])
        check("G11-mp-bordered-det",
              mpdet <= MPDET_BAR and mpuva <= MPDET_BAR,
              "REAL w9 (dps %d): det [[H_n, u],[u^T, B]] = "
              "det H_n (B - S_{n-1}) at n = 8/9/12, B = 2/20, "
              "worst rel dev %.1e; Uvarov tau step tau^b_9/"
              "tau^b_8 = h_8 (B - S_8)/(B - S_7) dev %.1e (bar "
              "%.0e): the one-column extension has an exact "
              "determinant/tau dictionary on the true comb"
              % (MP_DET_DPS, mpdet, mpuva, MPDET_BAR))

    # ---------------- S3: leg A2 -- RHP readouts
    section("S3  LEG A2 -- EXACT RHP READOUTS OF F AND S")
    if smoke:
        w8 = w12 = 0.0
        check("G30-moment-route", True, "SKIPPED in smoke mode")
    else:
        worlds = [by_kz[k] for k in MOM_WORLDS if k in by_kz] \
            + list(ctrl.values())
        w8, w12 = mp_moment_route(worlds)
        check("G30-moment-route", w8 <= MOM8_BAR
              and w12 <= MOM12_BAR,
              "F_n = s_n - v^T H^{-1} q, h_n and S_{n-1} from "
              "MOMENTS ONLY (mp dps %d) vs the f64 chain on "
              "w9/w12/w13 + EPSTEIN/SCRAMBLE/SMOOTH: worst %.1e "
              "at n = 8 (bar %.0e), %.1e at n = 12 (bar %.0e) -- "
              "the r243 provenance route reproduced (cited)"
              % (MP_DET_DPS, w8, MOM8_BAR, w12, MOM12_BAR))
    allw = packs + list(ctrl.values())
    cd_w = max(p["cd_dev"] for p in allw)
    check("G31-cd-kernel-S-readout", cd_w <= CD_BAR,
          "S_{n-1} = intint K_n dsigma dsigma with K_n(x,y) = "
          "[pihat_n(x)pihat_{n-1}(y) - pihat_{n-1}(x)pihat_n(y)]"
          "/(h_{n-1}(x-y)) = (Y_n^{-1}(y)Y_n(x))_21/(y-x) "
          "(confluent diagonal via derivative CD): worst rel dev "
          "%.1e at n = %d on %d + 3 worlds (bar %.0e) -- the "
          "BUDGET is an RHP functional of the TERMINAL Y_n data "
          "alone" % (cd_w, N_SNAP, len(packs), CD_BAR))
    zr_w = max(p["zread_dev"] for p in packs)
    or_w = max(p["orth_rel"] for p in packs)
    check("G32-border-column-readout", zr_w <= ZREAD_BAR
          and or_w <= ORTH_BAR,
          "z Csig_n(z) = F_n + Csig[x pihat_n](z) exact on the "
          "z-panel (worst %.1e, bar %.0e): the border column "
          "Csig_n has 1/z-coefficient F_n WITHOUT cancellation, "
          "while the mutilde column's z^{-1} coefficient is 0 by "
          "orthogonality (contrast ward: |int pihat_n dmutilde|/"
          "mass-norm worst %.1e <= %.0e): F_n IS the Y1-style "
          "infinity readout of the Uvarov border column"
          % (zr_w, ZREAD_BAR, or_w, ORTH_BAR))
    cr_w = max(p["colrec_dev"] for p in packs)
    check("G33-column-R-transfer", cr_w <= COLREC_BAR,
          "Csig_{n+1} = (z - alphahat_n) Csig_n - gammahat_n "
          "Csig_{n-1} - F_n on the z-panel, n = 1..%d, all %d "
          "windows (worst %.1e, bar %.0e): the border column "
          "obeys the SAME R_n transfer as (pihat, C) up to the "
          "exact F-source; the vanishing of that source for the "
          "mutilde column IS orthogonality -- the bordered "
          "problem is the FIK problem plus one F-sourced column"
          % (N_SNAP - 1, len(packs), cr_w, COLREC_BAR))

    # ---------------- S4: leg A3 -- Uvarov representer (toy)
    section("S4  LEG A3 -- UVAROV / RANK-1 BORDER")
    n = 3
    q3 = [smom[i] for i in range(n)]
    c3 = PB.frac_solve(Hm(n), q3)
    okR = True
    # representer p_r = sum c_i x^i: mu-pairings, norm, F-pairings
    pr_at = [sum(c3[j] * x ** j for j in range(n)) for x in JFn]
    for i in range(n):
        pri = sum(w * v * x ** i
                  for w, v, x in zip(JFw, pr_at, JFn))
        okR = okR and (pri == smom[i])
    nrm = sum(w * v * v for w, v in zip(JFw, pr_at))
    okR = okR and (nrm == Stoy[n - 1])
    for k in range(n):
        pk_at = [PB.toy_eval(al, hs, k, x) for x in JFn]
        pair = sum(w * v * u
                   for w, v, u in zip(JFw, pr_at, pk_at))
        okR = okR and (pair == Ftoy[k])
    check("G40-representer-exact", okR,
          "rationals (n = 3): the Riesz representer r = H^{-1}q "
          "of the border functional satisfies <r, x^i> = s_i, "
          "||r||^2 = S_{n-1}, <r, pihat_k> = F_k EXACTLY: the "
          "bordered matrix is the Gram of (1..x^{n-1}, e) with "
          "the smooth element e; the residual e - r is prefix-"
          "orthogonal with norm^2 = B - S_{n-1} (the Schur "
          "corner) -- the border IS a rank-1 Uvarov step on the "
          "extended object mutilde (+) smooth element")
    okU = True
    for B in B_TOY:
        for n in range(1, NTOY):
            lhs = PB.frac_det(Gb(n + 1, B)) / PB.frac_det(Gb(n, B))
            rhs = hs[n] * (B - Stoy[n]) / (B - Stoy[n - 1])
            okU = okU and (lhs == rhs)
    check("G41-uvarov-tau-step", okU,
          "tau^b_{n+1}/tau^b_n = h_n (B - S_n)/(B - S_{n-1}) = "
          "h_n (1 - rho_n/(B - S_{n-1})) EXACT in rationals "
          "(n = 1..3, both sealed budgets): the bordered tau "
          "flows by the SAME pivot h_n times the budget-"
          "consumption factor -- the determinant identity of the "
          "one-column extension (mp version gated in G11)")

    # ---------------- S5: leg B -- canonical corner
    section("S5  LEG B -- CANONICAL CORNER (sealed c1-c4)")
    Ns = [p["N"] for p in packs]
    Sts = [p["St"] for p in packs]
    cand_res = {}
    for tag in ("b1", "b2", "b3"):
        vals = [p[tag] for p in packs]
        marg = [b - s for b, s in zip(vals, Sts)]
        n_pos = sum(1 for m_ in marg if m_ > 0.0)
        sp_n = spearman(vals, Ns)
        ratios = [b / s for b, s in zip(vals, Sts)]
        dec = (max(ratios) / min(ratios)
               if min(ratios) > 0 else float("inf"))
        sp_m = spearman(marg, Ns)
        rc = res_corr(vals, Sts, Ns)
        # c2: control certification test (full bordered claim)
        certs = []
        for c in ctrl:
            pc = ctrl[c]
            wall_ok = pc["nf"] is None            # prefix positive
            bud_ok = (pc[tag] - float(pc["S"][pc["N"] - 1])) > 0.0
            if wall_ok and bud_ok:
                certs.append(c)
        c1 = n_pos == len(packs)
        c2 = (not certs) and okCf
        c3 = (sp_n >= SPEAR_MIN and dec <= RATIO_DECADE
              and sp_m > MARGIN_TREND)
        c4 = abs(rc) <= ALIAS_RES
        cand_res[tag] = dict(vals=vals, marg=marg, n_pos=n_pos,
                             sp_n=sp_n, dec=dec, sp_m=sp_m, rc=rc,
                             certs=certs, c=(c1, c2, c3, c4),
                             ok=c1 and c2 and c3 and c4)
        info("%s: range [%.3g, %.3g] | PSD %d/%d (margin [%.3g, "
             "%.3g]) | Spearman(B;N) %+.2f | ratio decade %.2f | "
             "margin trend %+.2f | res-corr(B,S) %+.2f | control "
             "certs %s | c1-c4 %s"
             % (tag, min(vals), max(vals), n_pos, len(packs),
                min(marg), max(marg), sp_n, dec, sp_m, rc,
                str(certs) if certs else "NONE",
                str(cand_res[tag]["c"])))
    check("G50-candidates-source-pure", True,
          "b1 = s_0 (signed smooth mass), b2 = Szego/equilibrium "
          "budget (orthonormal arcsine chain on the combined "
          "hull, mass m_0), b3 = mu-side norm (orthonormal "
          "positive-zone chain): each consumes nodes/weights/"
          "moments ONLY -- no h sign chain, no tau, no S, no "
          "imported 5/7 (AST firewall G01)")
    winners = [t for t in ("b1", "b2", "b3") if cand_res[t]["ok"]]
    alias_t = [t for t in ("b1", "b2", "b3")
               if not cand_res[t]["c"][3]]
    check("G51-controls-not-certified",
          all(not cand_res[t]["certs"] for t in cand_res) and okCf,
          "the bordered pivot chain on EPSTEIN/SCRAMBLE/SMOOTH "
          "loses positivity AT the sealed wall flips %s (h-pivot,"
          " not the corner); NO control is certified by the full "
          "bordered claim under ANY candidate (SMOOTH trap "
          "disclosed: its budget side is structurally 0 <= B -- "
          "the wall kills it at 27)"
          % str({c: ctrl[c]["nf"] for c in ctrl}))
    if winners:
        legB = ("CANONICAL_CORNER_FOUND(%s)" % ",".join(winners)
                + " + B_CAN_NO_BOUND_MECHANISM")
    else:
        legB = "CORNER_IMPORTED_ONLY"
    if alias_t:
        legB += " + CORNER_ALIAS(%s)" % ",".join(alias_t)
    check("G52-corner-adjudicated", True,
          "SEALED RULE result: %s -- %s; HONESTY (sealed): a PSD "
          "census is a MEASUREMENT, not a theorem: a passing "
          "candidate defines the candidate ZIELSATZ of the RHP "
          "lane (prove B_can - S_{N-1} >= 0 asymptotically), it "
          "does not prove it; the r243 status (only B_w = "
          "S_{N-2} + 5/7 is known to cover, floor imported) is "
          "superseded ONLY as a target, not as a bound"
          % (legB,
             "; ".join("%s: c1-c4 %s" % (t, str(cand_res[t]["c"]))
                       for t in ("b1", "b2", "b3"))))

    # ---------------- S6: leg C -- budget profile
    section("S6  LEG C -- BUDGET PROFILE (frozen requirement)")
    c25 = [p["shares"][0.25] for p in packs]
    c50 = [p["shares"][0.5] for p in packs]
    c75 = [p["shares"][0.75] for p in packs]
    t5 = [p["tail5"] for p in packs]
    am = [p["argmax_frac"] for p in packs]
    gn = [p["gini"] for p in packs]
    spSN = spearman(Sts, Ns)
    lgsl = float(np.polyfit(np.log(Ns), np.log(Sts), 1)[0])
    info("S_{N-1} in [%.3f, %.3f] median %.3f | Spearman(S;N) "
         "%+.2f | log-log slope %.2f (r243 census reproduced)"
         % (min(Sts), max(Sts), float(np.median(Sts)), spSN,
            lgsl))
    r0s = [p["rho0_share"] for p in packs]
    info("shares: c(1/4) med %.3f, c(1/2) med %.3f, c(3/4) med "
         "%.3f | tail-5 med %.3f | argmax n*/N med %.3f "
         "(terminal-degree max on %d/%d, degree-0 max on %d/%d) "
         "| rho_0 share med %.3f | Gini med %.3f"
         % (float(np.median(c25)), float(np.median(c50)),
            float(np.median(c75)), float(np.median(t5)),
            float(np.median(am)),
            sum(1 for a in am if a > 0.98), len(packs),
            sum(1 for a in am if a == 0.0), len(packs),
            float(np.median(r0s)), float(np.median(gn))))
    typ = []
    if float(np.median(c25)) >= C25_EARLY:
        typ.append("EARLY_FRONT")
    if float(np.median(t5)) >= TAIL5_EDGE:
        typ.append("TERMINAL_EDGE")
    if not typ:
        typ.append("UNIFORM_SPREAD"
                   if float(np.median(gn)) < GINI_UNIF
                   else "IRREGULAR_BULK")
    prof_typ = "+".join(typ)
    # MAIN vs controls before their flips
    cmp_note = []
    for c in ctrl:
        nf = ctrl[c]["nf"]
        rc_ = ctrl[c]["rho"][:nf]
        rm_ = by_kz[9]["rho"][:nf] if 9 in by_kz \
            else packs[0]["rho"][:nf]
        pos = rc_[rc_ > 1e-300]
        med_c = float(np.median(rc_))
        sd_c = (float(np.std(np.log(pos))) if len(pos) > 1
                else float("nan"))
        med_m = float(np.median(rm_))
        sd_m = float(np.std(np.log(rm_[rm_ > 1e-300])))
        cmp_note.append("%s(n<%d): med rho %.2g/std log %.2g vs "
                        "MAIN %.2g/%.2g" % (c, nf, med_c, sd_c,
                                            med_m, sd_m))
    req = ("the LAST O(5) degrees (the razor)"
           if "TERMINAL_EDGE" in prof_typ else
           "the FRONT of the chain (low degrees)"
           if "EARLY_FRONT" in prof_typ else
           "a highly non-uniform bulk (no single locus)")
    check("G60-profile-frozen", True,
          "SEALED TYPING result: BUDGET_PROFILE_FROZEN(%s) -- "
          "median tail-5 share %.3f (edge bar %.1f), c(1/4) "
          "%.3f (early bar %.1f), Gini %.3f (uniform bar %.1f), "
          "argmax terminal on %d/%d and at degree 0 on %d/%d, "
          "rho_0 share med %.3f; N-scaling Spearman %+.2f, "
          "log-log slope %.2f: what any later Szego/steepest-"
          "descent analysis must control is %s -- this is the "
          "frozen requirement profile of the RHP lane"
          % (prof_typ, float(np.median(t5)), TAIL5_EDGE,
             float(np.median(c25)), C25_EARLY,
             float(np.median(gn)), GINI_UNIF,
             sum(1 for a in am if a > 0.98), len(packs),
             sum(1 for a in am if a == 0.0), len(packs),
             float(np.median(r0s)), spSN, lgsl, req))
    check("G61-main-vs-controls-profile", True,
          "pre-flip comparison (common range, w9 base): %s -- "
          "MEASURED: MAIN and EPSTEIN are comparable pre-flip "
          "(same order of median rho and log-spread), SCRAMBLE "
          "consumes ~3 orders MORE budget per degree before its "
          "flip, SMOOTH is the F = 0 self-alias (typed); no "
          "regularity superiority of MAIN is claimed at n < 27"
          % "; ".join(cmp_note))

    # ---------------- S7: leg D -- the 3-term flow
    section("S7  LEG D -- 3-TERM FLOW OF (h, F, S)")
    okF = True
    for n_ in range(NTOY):
        rhs = Ttoy[n_] - al[n_] * Ftoy[n_] \
            - ((hs[n_] / hs[n_ - 1]) * Ftoy[n_ - 1]
               if n_ >= 1 else Fr(0))
        okF = okF and (Ftoy[n_ + 1] == rhs)
    # corner flow D_{n+1} = D_n - rho_n (both sealed budgets)
    for B in B_TOY:
        for n_ in range(1, NTOY):
            okF = okF and ((B - Stoy[n_])
                           == (B - Stoy[n_ - 1])
                           - Ftoy[n_] ** 2 / hs[n_])
    check("G70-flow-exact-toy", okF,
          "rationals: F_{n+1} = T_n - alphahat_n F_n - "
          "gammahat_n F_{n-1} with T_n = int x pihat_n dsigma "
          "(n = 0..3, F_1 = T_0 - alphahat_0 F_0) AND the "
          "autonomous corner flow D_{n+1} = D_n - rho_n at both "
          "sealed budgets: the triple (h, F, S) flows by "
          "(transfer, T-sourced 3-term, telescope) -- the "
          "bordered analogue of the LAX1 degree dynamics "
          "(r226/r234); the T-source is the shifted border "
          "pairing, the same currency as F")
    fl_w = max(p["flow_dev"] for p in allw)
    fw_w = max(p["fward"] for p in allw)
    check("G71-flow-f64-ladder", fl_w <= FLOW_BAR
          and fw_w <= FWARD_BAR,
          "f64 at n <= %d on all %d + 3 worlds: flow residual "
          "worst %.1e on the absolute mass-norm scale (bar "
          "%.0e; SMOOTH F = 0 self-alias guard typed); chain-"
          "vs-plain F ward worst %.1e (bar %.0e)"
          % (N_SNAP, len(packs), fl_w, FLOW_BAR, fw_w,
             FWARD_BAR))
    if smoke:
        check("G72-flow-mp-deep", True, "SKIPPED in smoke mode")
    else:
        deep = mp_deep_flow(by_kz[9])
        check("G72-flow-mp-deep", deep <= MPFLOW_BAR,
              "mp (dps %d) through ALL %d w9 degrees: the "
              "T-sourced 3-term F-flow holds with worst rel "
              "residual %.1e (bar %.0e) -- the exact discrete "
              "flow that a conditioned asymptotic must develop, "
              "valid through the full depth including the razor"
              % (MP_DPS, by_kz[9]["N"], deep, MPFLOW_BAR))

    # ---------------- S8: must-fails
    section("S8  MUST-FAILS")
    okM = True
    # m1 dropped source (toy exact + f64 loud)
    n_ = 2
    bad = -al[n_] * Ftoy[n_] - (hs[n_] / hs[n_ - 1]) * Ftoy[n_ - 1]
    okM = okM and (Ftoy[n_ + 1] != bad)
    m1r = min(p["m1_ratio"] for p in packs)
    okM = okM and m1r >= 1e3
    # m2 index-shifted corner (rationals, det form)
    n_ = 3
    B = B_TOY[0]
    good = PB.frac_det(Gb(n_, B))
    shifted = PB.frac_det(Hm(n_)) * (B - Stoy[n_ - 1]
                                     - Ftoy[n_] ** 2 / hs[n_])
    gap = good - shifted
    okM = okM and (gap == PB.frac_det(Hm(n_))
                   * Ftoy[n_] ** 2 / hs[n_]) and gap != 0
    # m3 corner oracle B = 1.01 S certifies trivially -- excluded
    n_orc = sum(1 for p in packs if 1.01 * p["St"] - p["St"] > 0)
    okM = okM and n_orc == len(packs)
    # m4 sign oracle
    n_sgn = sum(1 for p in packs
                if p["rows"][p["N"] - 1]["sg_h"] > 0)
    okM = okM and n_sgn == len(packs)
    check("G80-must-fails-fire", okM,
          "m1 dropped T-source: toy breaks exactly, f64 residual "
          ">= %.1e x honest on every window; m2 index-shifted "
          "corner breaks the det identity by exactly det H_n "
          "rho_n != 0 (rationals); m3 corner oracle B = 1.01 S "
          "certifies %d/%d trivially and is EXCLUDED (consumes "
          "S); m4 sign oracle hits %d/%d and is EXCLUDED by the "
          "input firewall" % (m1r, n_orc, len(packs), n_sgn,
                              len(packs)))

    # ---------------- S9: verdict
    section("S9  VERDICT")
    check("G90-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED (a dictionary + "
          "measurement round moves no edge); what the round "
          "adds: the fifth edge lives in ONE matrix whose RHP "
          "dictionary is now exact (F = infinity readout of the "
          "F-sourced Uvarov column, S = border self-pairing of "
          "the integrable CD kernel of Y_n, corner = bordered "
          "tau quotient), whose budget is consumed at the "
          "terminal razor (frozen profile), and whose canonical-"
          "corner question is adjudicated by the sealed census")
    dict_gates = ("G10", "G11", "G30", "G31", "G32", "G33",
                  "G40", "G41", "G70", "G71", "G72")
    dict_ok = all(ok for nm, ok, _d in CHECKS
                  if nm.startswith(dict_gates))
    legA = ("BORDERED_RHP_DICTIONARY_EXACT" if dict_ok
            else "BORDERED_RHP_DICTIONARY_OPEN")
    verd = "%s + %s + BUDGET_PROFILE_FROZEN(%s)" % (legA, legB,
                                                    prof_typ)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G91-verdict", npass == len(CHECKS),
          "%s%s -- PROVEN: the bordered dictionary and the flow "
          "(exact identities); MEASURED: the candidate census "
          "and the budget profile; OPEN: the budget bound "
          "itself (= the wall, r243 PAIRCORR_REENCODED stands); "
          "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())
'''

# ------------- frozen probe source bordered_finite_rank_probe (embedded BYTE-EXACT, raw string)
_SRC_1 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""bordered_finite_rank_probe -- PRIME.PORT.RHP.BORDEREDHANKEL.FINITE.02
(round 245): the MINIMAL-RANK ADJUDICATION of the augmented (bordered)
problem -- does the smooth border stay a rank-1/Schlesinger insertion
inside the existing 2x2 FIK system, does it need an irreducible 3x3
mixed-moment RHP, or does it create an N-growing generator rank?  Not
guessed aesthetically: formulated, gated, counted.

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

INDEX FIREWALL (binding, r238-r244 discipline): w = window (kz), N_w =
builder depth, n = chain degree; free pivots h_{w,n} (n < N_w) are the
proof objects; sigma = the sealed r239/r243 smooth PNT-shape border
(F_DEF / F_DEF_SHA imported verbatim via principal_bessel_probe);
F_n = int pihat_n dsigmatilde, T_n = int x pihat_n dsigmatilde,
rho_n = F_n^2/h_n, S_n = sum_{k<=n} rho_k, D_n = B - S_{n-1}.  Ground
truth (h signs, S, flips) enters GATES only, never a construction
path; the budget B is a FREE sealed parameter (never fitted).

LEG A -- THE AUGMENTED RHP FORMULATION, EXACT (two sealed candidates).
(A1a) PURE-DEGREE 3x3: Y3_n(z) with rows of degrees (n, n-1, n-2) and
  columns (pihat_m, C_m = C[pihat_m mutilde], Csig_m = C[pihat_m
  sigmatilde]).  DERIVED AT DESIGN TIME, frozen here, then gated:
  (i) Laurent orders col1 ~ z^m (monic), col2 = h_m z^{-m-1}(1+O(1/z))
  (orthogonality cancellation), col3 = F_m z^{-1} + T_m z^{-2} + ...
  (NO cancellation -- the border column starts at z^{-1} for EVERY
  row); (ii) det Y3_n(z) = -h_{n-2} F_{n-1}, CONSTANT in z (derivation:
  column-3 expansion in the Wronskian minors W_{a,b} = pihat_a C_b -
  pihat_b C_a with W_{n,n-1} = h_{n-1}, W_{n,n-2} = (z - alphahat_{n-1})
  h_{n-2}, then the F-sourced border transfer collapses the sum); the
  pure-degree 3x3 is solvable iff the 2x2 is AND F_{n-1} != 0 -- it
  DEGENERATES exactly on the F = 0 self-alias (SMOOTH); (iii) UNIQUE
  NORMALIZATION: over the full integer cube of diagonal gauges
  diag(z^a, z^b, z^c) exactly ONE choice, (a, b, c) = (-n, n-1, 1),
  yields a finite INVERTIBLE limit L (a permutation-triangular matrix
  with det L = det Y3); every other diagonal is divergent or singular
  (exact enumeration); (iv) the pure-degree rows admit NO self-
  contained 3x3 degree transfer: the F-source is not in the row space
  -- homogenization FORCES the parabolic augmentation (A1b).
(A1b) UNIPOTENT-AUGMENTED 3x3 (the Schlesinger insertion): Y3aug_n(z)
  = [[pihat_n, C_n, Csig_n], [pihat_{n-1}/h_{n-1}, C_{n-1}/h_{n-1},
  Csig_{n-1}/h_{n-1}], [0, 0, 1]] -- the r227 2x2 FIK solution plus
  one F-sourced Uvarov column plus one CONSTANT row.  Gated exact:
  det Y3aug = 1 (all z, all n, ALSO through control flips h < 0);
  normalization Y3aug diag(z^{-n}, z^n, 1) = I + Y1/z + O(z^-2) with
  Y1_13 = F_n, Y1_23 = F_{n-1}/h_{n-1}, third row of Y1 = 0 (the
  border data is the infinity readout of the third column); degree
  step Y3aug_{n+1} = R3_n Y3aug_n with
      R3_n = [[z - alphahat_n, -h_n, -F_n], [1/h_n, 0, 0], [0, 0, 1]],
  det R3_n = 1 -- THE r244 FLOW INHOMOGENEITY (T-source flow) APPEARS
  AS THE (1,3) MATRIX ENTRY of the transfer; residue structure at the
  sigma-atoms: Res_{y_a} Y3aug = lim Y3aug (sv_a E_13) (nilpotent,
  couples column 3 to column 1 ONLY), at the mutilde-atoms the r227
  E_12 condition -- a genuine discrete RHP whose jumps are BLOCK-
  TRIANGULAR: the third column is a quadrature slave of column 1.
(A2) 2x2-STAYS: the r244 reading (border as scalar companion).
SEALED ADJUDICATION: SCHLESINGER_RANK1_INSERTION iff A1b passes all
gates with the unipotent structure intact AND its solvability data
(det) is independent of (sigma, B) AND leg-B lands rank 2 on the
primary objects -- then A1 is exact packaging of A2 (block-trivial
w.r.t. the bordered PSD: solvability never sees B or S; the PSD data
enters only through the Uvarov tau step, leg C).
IRREDUCIBLE_3X3_REQUIRED iff any gate NEEDS nonzero coupling entries
(3,1)/(3,2) or a non-block-triangular jump.  Else FORMULATION_OPEN.

LEG B -- MINIMAL INTEGRABLE RANK (the core).  Three sealed panels:
(P1, primary, node side) K_ext := the CD kernel K_n(t, t') =
  sum_{k<n} pihat_k(t) pihat_k(t')/h_k evaluated on the JOINT node
  grid (mutilde-atoms + sigma-atoms) -- the sigma-extension of the
  wall kernel: its mutilde-block IS the wall kernel, its sigma-smear
  kappa(t) = int K_n(t,s) dsigmatilde(s) = r_n(t) IS the Riesz
  representer (border column u), its double smear IS the budget
  S_{n-1} (r244 G31) -- the node kernel of the bordered Gram.
  Displacement [Y_ext, K_ext] with Y_ext = diag(joint nodes):
  rank counted EXACTLY (toy, rationals) and by SVD census + EXPLICIT
  generator reconstruction (r224 style: (t-t') K_n == [pihat_n(t)
  pihat_{n-1}(t') - pihat_{n-1}(t) pihat_n(t')]/h_{n-1}) at sealed
  degrees (6, 12, 20) on ALL ladder windows + controls, and in mp at
  the FULL depth n = N-1 on w9 (the razor).
(P2, primary, ONB side) Ghat := the bordered Gram in the pihat basis,
  [[diag(h_0..h_{n-1}), f], [f^T, B]], f = (F_0..F_{n-1}) -- the
  (N+1)x(N+1) object whose determinant is tau^b.  Displacement
  Delta := J_ext^T Ghat - Ghat J_ext with the extended one-sided
  Jacobi operator J_ext = J_n (+) [0] (border has no x-action data;
  xi = 0 sealed).  DERIVED, frozen, gated: the polynomial block of
  Delta is IDENTICALLY ZERO (h_j J_jk = h_k J_kj inside the
  truncation), the border column is Delta_{j,b} = T_j for j < n-1
  and T_{n-1} - F_n at the truncation boundary (the razor-adjacent
  F_N deficit), Delta is BUDGET-BLIND (identical for every B), and
  rank Delta = 2 EXACTLY: the border adds exactly one generator PAIR
  (T-vector, border direction) -- the displacement currency of a
  Schlesinger insertion.
(P3, disclosed secondary, S-CONSUMING diagnostic only) K_uva :=
  K_ext + rho rho^T/(B - S_{n-1}) with rho = 1_sigma - r_n (the
  direct-sum node realization of the residual e - r_n; realization
  sealed and typed): the Uvarov-projected kernel.  Expected from the
  Cauchy structure: displacement rank 2+2 (generators rho, Y rho on
  top of the CD pair), FIXED in n and N -- measured, never certified
  (its construction consumes S: gate-side only, firewalled).
SEALED VERDICTS (mutually exclusive, frozen): BORDERED_RANK2_EXACT
  iff P1 and P2 measure rank exactly 2 everywhere (toy exact + all
  windows + all controls + deep mp) with no N-trend -- the border
  direction lies in the existing generator space; BORDERED_RANK3_EXACT
  iff exactly one new independent generator (consistent rank 3);
  BORDERED_FIXED_RANK_HIGHER(r) iff fixed rank r >= 4, N-independent;
  BORDERED_RANK_GROWS iff ANY panel rank trends upward with n or N
  (census: rank at degrees 6/12/20 per window; Spearman(rank; N) >
  0.3 or max > min across degrees) -- a hard warning for every
  classical parametrix and a valid result.  Modifier appended:
  UVAROV_PROJECTION_2PLUS2_FIXED iff P3 measures fixed rank 4.

LEG C -- FULL PIVOT CHAIN FROM THE FORMULATION (the
BORDERED_DETERMINANT_ONLY kill): the augmented z-space solution data
carries the COMPLETE pivot chain, not just the terminal determinant:
h_{k-1} = W_{k,k-1}(z) (z-independent Wronskian minor of columns 1-2),
F_k = (z - alphahat_k) Csig_k(z) - gammahat_k Csig_{k-1}(z) -
Csig_{k+1}(z) (exact transfer readout, k = 0 without the gamma term),
rho_k = F_k^2/h_{k-1+1}, and the autonomous corner flow D_{k+1} =
D_k - rho_k from D_0 = B reconstructs (h_0..h_{n-1}, B - S_{n-1}) =
the EXACT nested pivots of the bordered Hankel [[H_n, u],[u^T, B]]
(r243 G12).  Gated: rationals on the toy (all n, both sealed
budgets) vs exact LDL pivots; mp (dps 60) on w9/w12 at n = 8/12 vs
direct bordered LDL, B in {2, 20}; mp (dps 160) through ALL w9
degrees: per-degree F-readout identity + integrated D-flow vs the
direct budget telescope.  Verdict: FULL_PIVOT_CHAIN_CARRIED /
BORDERED_DETERMINANT_ONLY.

LEG D -- WORLD-BLIND + KILLS: every leg-A/B/C identity is gated on
MAIN and on EPSTEIN/SCRAMBLE/SMOOTH (same builder map, 4 distinct
input hashes); the algebra must hold IDENTICALLY (only values/signs
differ; mp through the sealed control flips 25/21/27 with h < 0);
SMOOTH is the F = 0 self-alias: the pure-degree 3x3 DEGENERATES
there (det -> 0, typed, the predicted breakdown), Y3aug survives
(det = 1 via the unipotent row), F-comparisons go to absolute
mass-norm guards (r243 amendment-a1 discipline).  GRID-OVERLAP
DISCLOSURE (amendment a1 of THIS round, smoke-caught): the folded
window atoms SHARE positions with the folded border grid on EVERY
world (common assembly grid) -- the joint grid is therefore the
DISJOINT-UNION index set: Y_ext has repeated diagonal entries
(legitimate displacement algebra, no (t - t') division anywhere;
the CD identity holds entrywise including the zero rows), and
rho = 1_sigma - r_n lives on the index set.  KILLS (self-audit,
sealed): TAU_TRANSCRIPTION (this round's new objects: det Y3 =
-h_{n-2} F_{n-1}, the unique-normalization census, R3 with the
F-entry, the three displacement panels and the rank census, the
z-space pivot assembly -- none is a transcription of r243/r244);
WALL_COMPLETION / TARGET_INVERSE_USED (no h-sign chain, no tau, no
S in any construction path; B free; K_uva's S-consumption disclosed
as diagnostic); GENERATOR_RANK_GROWS (the census); BORDERED_
DETERMINANT_ONLY (leg C).  MUST-FAILS (each loud): (m1) DROPPED
SOURCE: R3 without the (1,3) entry breaks the step by exactly F_n
(toy exact + f64 >= 1e3 x honest); (m2) SWAPPED COLUMNS 2<->3:
det breaks loudly, the step breaks loudly; (m3a) sigma SHIFTED
(u-grid + 0.05): the pivot/readout assembly breaks loudly against
the true bordered pivots; (m3b) sigma SMOOTHED (weights -> uniform
mean, mass-preserving): same loud break; (m4) sign oracle
sign h_{N-1} hits 42/42 and is EXCLUDED by the input firewall.

SEALED CONSTANTS: ladder = frame-A h <= 900 (42 rungs); background
du = 0.01 masses 2 e^{u/2} du (r243 map via principal_bessel_probe.
smooth_comb); toy = r243 signed 9-atom toy + disjoint signed 5-atom
smooth border, degrees to 6; toy budgets B in {22/7, 5/3}; toy
z-census 45 rational points (constancy by degree-count argument);
normalization cube |a|,|b|,|c| <= n+2; f64 snapshot degree n = 12,
z-panel (1.7+0.9i, 0.31+0.77i); f64 bars det 1e-6, step/readout
1e-12 (mass-norm guards on F-scales); census degrees (6, 12, 20),
joint subgrid <= 30 per zone (<= 120 nodes), SVD rank threshold
1e-7 relative, recon bars 1e-11; ONB block bar 1e-12 (normalized),
T-column bar 1e-12 (mass-norm); grows bars
Spearman 0.3; uva budget B = 20 (windows), both toy budgets; mp
deep w9 dps 160 bars 1e-25, mp subgrid 15 + 15; mp flip panel
(controls) dps 60 bar 1e-20, degrees 2..flip+2; mp moderate pivots
w9/w12 dps 60, n = 8/12, B = 2/20, bar 1e-20; loud ratio 1e3;
sigma shift 0.05; control flips 25/21/27; runtime <= 1800 s.

RECORD TABLES (frozen from calib_bfr_pass1.log, 29/29 FIRST PASS,
wall 10.4 s full / 0.5 s smoke; pre-freeze SPEC_SHA
38d470ec92490534; disclosed SMOKE/CALIBRATION AMENDMENTS -- the
formulation candidates, the displacement panels, the sealed verdict
rules, the rank threshold and the pivot-assembly formulas NEVER
moved: (a1) GRID OVERLAP, smoke-caught live: the design planned a
SMOOTH-only collision dedupe, but the smoke run measured that the
folded window atoms share positions with the folded border grid on
EVERY world (common assembly grid; the per-world dedupe would have
voided the uva panel everywhere) -- replaced by the disjoint-union
index-set reading (Y_ext with repeated diagonal entries, legitimate
displacement algebra; overlap census disclosed in G44); (a2) the
draft f64 bars were set conservatively (5e-5 class, r234 CREC
precedent) BEFORE any run; calibration measured the honest devs
4-9 orders below and the bars were TIGHTENED at freeze (det 1e-6,
step/readout/recon/ONB 1e-12..1e-11) -- a strictness increase, no
rule moved):
CAL_VERDICT = FORMULATION(SCHLESINGER_RANK1_INSERTION) +
BORDERED_RANK2_EXACT + UVAROV_PROJECTION_2PLUS2_FIXED +
FULL_PIVOT_CHAIN_CARRIED.
Key numbers.  LEG A (toy rationals, n = 2..4): Laurent order table
EXACT (col2 cancellation depth m, col3 leading F_m, next T_m);
det Y3 = -h_{n-2} F_{n-1} at 45 z-points EXACT; unique
normalization: the 11^3 diagonal-gauge cube yields EXACTLY ONE
invertible gauge (a,b,c) = (-n, n-1, 1) at n = 3 AND 4, det L =
det Y3, L singular iff F_{n-1} = 0; residue dictionary (E_13 at
sigma-atoms, E_12 at mutilde-atoms, row 3 pole-free) exact;
det Y3aug = 1 and the R3 step with det R3 = 1 EXACT at all toy
z-points; sigma-mutation moves F while det Y3aug stays EXACTLY 1.
Windows f64 (42 + 3 worlds, n = 12, z-panel): det Y3aug - 1 worst
3.4e-9, R3-step worst 3.5e-15, F-readout worst 6.4e-16 (mass-norm),
world-blind.  mp: deep w9 (dps 160, ALL 184 degrees): det worst
5.9e-55, R3 border-column step 7.5e-159, F-readout vs pairing
1.1e-158; through-flip (dps 60, h < 0 crossed): EPSTEIN det 1.3e-45
step 1.3e-59 / SCRAMBLE 1.5e-48, 7.8e-61 / SMOOTH 4.3e-45, 1.3e-45
-- the augmented algebra is world-blind THROUGH the sign flips.
LEG B: toy exact ranks: [Y, K_ext] = 2 (n = 2..4, 14-node joint
grid, CD reconstruction entrywise exact, encoding ward kappa = r_n,
<r_n, pihat_k> = F_k, double smear = S_{n-1} exact); ONB Delta:
poly block == 0, border column == (T_0..T_{n-2}, T_{n-1} - F_n)
exact at BOTH budgets, budget-blind, rank 2 exact; K_uva rank 4
exact = 2 + 2 (generator quadruple independent, both budgets).
Windows: SVD census rank == 2 on 45/45 worlds at ALL degrees
6/12/20 (135 SVDs, sigma_3/sigma_1 worst 7.7e-16 vs eps 1e-7);
explicit CD reconstruction worst 4.8e-15 (n <= 12) / 1.2e-14
(n = 20); NO N-trend (Spearman = 0.00, max = min = 2) =>
GENERATOR_RANK_GROWS does NOT fire; ONB Delta: block worst 5.3e-16,
T-column worst 4.7e-16, rank 2 on 45/45, budget-blind max
|Delta(2) - Delta(20)| = 0 EXACTLY; uva census rank 4 on 45/45
(worst s4/s1 = 1.7e-2; overlap census 3..36 duplicated positions
per subgrid, a1); deep mp w9 razor: CD reconstruction at n = N-1
= 183 on the 30-node mp subgrid 5.9e-160, generators nondegenerate
=> displacement rank 2 AT THE RAZOR.  LEG C: toy pivot assembly
from PURE z-space readouts == LDL pivots (h_0..h_{n-1}, B -
S_{n-1}) EXACT (n = 2..4, both budgets, z-independence exact); mp
moderate (dps 60, w9 + w12, n = 8/12, B = 2/20): worst rel dev
1.3e-54 vs direct bordered LDL (z-independence ward 7.8e-55); mp
deep (dps 160, w9, ALL 184 degrees): integrated D-flow vs direct
telescope dev 8.2e-161 => FULL_PIVOT_CHAIN_CARRIED (the
formulation carries h_0..h_{N-1} AND every corner D_n, not only
tau^b).  LEG D: 4 distinct input hashes; SMOOTH: pure-degree
det Y3/scale = 0.0 EXACTLY (the predicted F = 0 degeneracy of the
pure-degree 3x3, typed) while Y3aug survives; MUST-FAILS all loud:
m1 dropped F-source 4.9e+8 x honest (+ exact toy break), m2
swapped columns det dev 2.2e+3 and step 3.4e+9 x honest, m3a
sigma-shift 1.3e+12 x honest, m3b sigma-smoothing 5.7e+12 x
honest, m4 sign oracle hits 42/42 and is EXCLUDED.  Determinism:
run1 == run2 (identical transcripts modulo wall-clock).
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

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

import bordered_hankel_probe as BH           # noqa: E402 r244
import hirota_sign_probe as HS               # noqa: E402 r226
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

H_CAP = 900
N_SNAP = 12
CENSUS_DEGS = (6, 12, 20)
SUB_CAP = 30
RANK_EPS = 1e-7
Z_PANEL = (1.7 + 0.9j, 0.31 + 0.77j)
NZ_TOY = 45
NTOY = 4
B_TOY = (Fr(22, 7), Fr(5, 3))
B_MP = (2, 20)
B_UVA = 20.0
DET12_BAR = 1e-6          # tightened at freeze (a2), disclosed
STEP12_BAR = 1e-12        # (a2)
FRD12_BAR = 1e-12         # (a2)
RECON_BAR = 1e-11         # (a2)
RECON20_BAR = 1e-11       # (a2)
ONB_BLK_BAR = 1e-12       # (a2)
ONB_T_BAR = 1e-12         # (a2)
GEN4_MIN = 1e-10
GROWS_SPEAR = 0.3
MP_DPS = 160
MPDEEP_BAR = 1e-25
MP_SUB = 15
MPFLIP_DPS = 60
MPFLIP_BAR = 1e-20
MPPIV_BAR = 1e-20
MPPIV_NS = (8, 12)
MP_MOD_W = (9, 12)
LOUD = 1e3
SIG_SHIFT = 0.05
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
SMOKE_KZ = (9, 12, 13, 26, 40)
CAL_VERDICT = ("FORMULATION(SCHLESINGER_RANK1_INSERTION) + "
               "BORDERED_RANK2_EXACT + UVAROV_PROJECTION_2PLUS2_FIXED"
               " + FULL_PIVOT_CHAIN_CARRIED")

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; constructions consume "
                       "nodes/weights/moments + border data only; B "
                       "free; K_uva S-consumption disclosed as "
                       "diagnostic; ground truth in gates only"
                       if not bad else "; ".join(bad))


# --------------------------------------------------- exact helpers
def frac_rank(M):
    M = [row[:] for row in M]
    rows, cols = len(M), len(M[0]) if M else 0
    pr = 0
    for c in range(cols):
        piv = next((i for i in range(pr, rows) if M[i][c] != 0), None)
        if piv is None:
            continue
        M[pr], M[piv] = M[piv], M[pr]
        for i in range(rows):
            if i != pr and M[i][c] != 0:
                f = M[i][c] / M[pr][c]
                for j in range(c, cols):
                    M[i][j] -= f * M[pr][j]
        pr += 1
        if pr == rows:
            break
    return pr


def frac_ldl_pivots(G):
    G = [row[:] for row in G]
    n = len(G)
    piv = []
    for i in range(n):
        piv.append(G[i][i])
        for r in range(i + 1, n):
            f = G[r][i] / G[i][i]
            for c in range(i, n):
                G[r][c] -= f * G[i][c]
    return piv


def toy_cauchy(vals, wts, nodes, z):
    return sum(w * v / (z - x) for w, v, x in zip(wts, vals, nodes))


def svd_rank(D):
    s = np.linalg.svd(np.asarray(D, float), compute_uv=False)
    if s[0] <= 0.0 or not np.isfinite(s[0]):
        return 0, s
    return int(np.sum(s >= RANK_EPS * s[0])), s


# ---------------------------------------------- kernel-census chain
def kchain(xs, ws, ys, vs, bx, bw, by, bv, ixs, iys, ibx, iby,
           degs, n_upto):
    """r243/r244 scaled signed chain (recursion verbatim) with a
    joint SUBGRID evaluation: accumulates the k-sum CD kernel
    K_n = sum_{k<n} pihat_k pihat_k'/h_k, the representer r_n and
    the budget S on the subgrid; snapshots at the sealed census
    degrees carry (K, q_n, q_{n-1}, CD factor, r_n, S_{n-1}).
    Source-pure: node positions and weights only."""
    qx = np.ones_like(xs)
    qy = np.ones_like(ys)
    qb = np.ones_like(bx)
    qc = np.ones_like(by)
    qx_m = np.zeros_like(xs)
    qy_m = np.zeros_like(ys)
    qb_m = np.zeros_like(bx)
    qc_m = np.zeros_like(by)
    Ls = Ls_m = 0.0
    eta = float(np.sum(ws) - np.sum(vs))
    eta_m = eta
    npts = len(ixs) + len(iys) + len(ibx) + len(iby)
    K = np.zeros((npts, npts))
    rsub = np.zeros(npts)
    S = 0.0
    prev_t = np.zeros(npts)
    snaps = {}
    for n in range(n_upto):
        fb = float(np.sum(bw * qb) - np.sum(bv * qc))
        qt = np.concatenate([qx[ixs], qy[iys], qb[ibx], qc[iby]])
        if n in degs and n >= 1:
            snaps[n] = dict(K=K.copy(), qn=qt.copy(),
                            qm=prev_t.copy(),
                            fac=math.exp(Ls - Ls_m) / eta_m,
                            r=rsub.copy(), S=S)
        K += np.outer(qt, qt) / eta
        rsub += (fb / eta) * qt
        S += fb * fb / eta
        alh = (float(np.sum(ws * xs * qx * qx)
                     - np.sum(vs * ys * qy * qy))) / eta
        if n == 0:
            px = (xs - alh) * qx
            py = (ys - alh) * qy
            pb = (bx - alh) * qb
            pc = (by - alh) * qc
        else:
            ge = (eta / eta_m) * math.exp(2.0 * (Ls - Ls_m))
            fc = math.exp(Ls_m - Ls)
            px = (xs - alh) * qx - ge * fc * qx_m
            py = (ys - alh) * qy - ge * fc * qy_m
            pb = (bx - alh) * qb - ge * fc * qb_m
            pc = (by - alh) * qc - ge * fc * qc_m
        sc = max(float(np.max(np.abs(px))), float(np.max(np.abs(py))),
                 float(np.max(np.abs(pb))), float(np.max(np.abs(pc))))
        if sc == 0.0 or not math.isfinite(sc):
            return snaps
        qx_m, qy_m, eta_m, Ls_m = qx, qy, eta, Ls
        qb_m, qc_m = qb, qc
        prev_t = qt
        qx, qy = px / sc, py / sc
        qb, qc = pb / sc, pc / sc
        Ls += math.log(sc)
        eta = float(np.sum(ws * qx * qx) - np.sum(vs * qy * qy))
        if eta == 0.0 or not math.isfinite(eta):
            return snaps
    return snaps


def sub_idx(m):
    if m <= SUB_CAP:
        return np.arange(m)
    return np.unique(np.linspace(0, m - 1, SUB_CAP).astype(int))


# ---------------------------------------------------- window packs
def wload(kz, base_kw=None):
    d = HS.window_data(kz, **(base_kw or {}))
    N = d["n_max"]
    alpha = PIK.build_rung(kz)["alpha"]
    dsm = HS.window_data(kz, comb=PB.smooth_comb(alpha))
    n_ch = N if base_kw is None else 32
    rows = BH.bord_chain(d["xs"], d["ws"], d["ys"], d["vs"],
                         dsm["xs"], dsm["ws"], dsm["ys"], dsm["vs"],
                         n_ch)
    nf = next((r["n"] for r in rows if r["sg_h"] < 0), None)
    m = N_SNAP
    alh = [rows[k]["alh"] for k in range(m + 4)]
    gamv = [0.0] + [rows[k]["gam_next"] for k in range(m + 3)]
    hv = [rows[k]["sg_h"] * math.exp(rows[k]["lg_h"])
          for k in range(m + 3)]
    Fv = [rows[k]["fb"] * math.exp(rows[k]["Ls"])
          for k in range(m + 3)]
    Tv = [rows[k]["tb"] * math.exp(rows[k]["Ls"])
          for k in range(m + 3)]
    S_pre = np.cumsum([r["rho"] for r in rows])
    xall = np.concatenate([d["xs"], d["ys"]])
    wall = np.concatenate([d["ws"], -d["vs"]])
    ball = np.concatenate([dsm["xs"], dsm["ys"]])
    bwall = np.concatenate([dsm["ws"], -dsm["vs"]])
    Pb, _ = BH.plain_vals(alh, gamv, ball, m + 2)
    aw = np.abs(bwall)
    Fabs = [float(aw @ np.abs(Pb[k])) for k in range(m + 3)]
    Tabs = [float(aw @ np.abs(ball * Pb[k])) for k in range(m + 3)]
    ixs = sub_idx(len(d["xs"]))
    iys = sub_idx(len(d["ys"]))
    ibx = sub_idx(len(dsm["xs"]))
    iby = sub_idx(len(dsm["ys"]))
    snaps = kchain(d["xs"], d["ws"], d["ys"], d["vs"],
                   dsm["xs"], dsm["ws"], dsm["ys"], dsm["vs"],
                   ixs, iys, ibx, iby, set(CENSUS_DEGS), 22)
    tpos = np.concatenate([d["xs"][ixs], d["ys"][iys],
                           dsm["xs"][ibx], dsm["ys"][iby]])
    sig_mask = np.concatenate([np.zeros(len(ixs) + len(iys)),
                               np.ones(len(ibx) + len(iby))]) > 0.5
    return dict(kz=kz, N=N, d=d, dsm=dsm, rows=rows, nf=nf,
                alh=alh, gamv=gamv, hv=hv, Fv=Fv, Tv=Tv,
                S_pre=S_pre, xall=xall, wall=wall, ball=ball,
                bwall=bwall, Fabs=Fabs, Tabs=Tabs, snaps=snaps,
                tpos=tpos, sig_mask=sig_mask)


def overlap_census(p):
    """builder-grid overlap census (disclosed): the folded window
    atoms and the folded border atoms share POSITIONS (common
    assembly grid) -- the joint grid is the DISJOINT-UNION index
    set; Y_ext = diag(positions) has repeated entries, which is
    legitimate displacement algebra (no division by t - t'
    anywhere; CD identity holds entrywise incl. zero rows)."""
    key = np.round(p["tpos"], 12)
    u, c = np.unique(key, return_counts=True)
    return int(np.sum(c > 1))


def zvals(alh, gamv, z, m):
    pv = [1.0 + 0j, z - alh[0]]
    for k in range(1, m):
        pv.append((z - alh[k]) * pv[k] - gamv[k] * pv[k - 1])
    return pv


def zpanel_gates(p, z, n):
    """f64 leg-A panel at degree n: det Y3aug, R3 step, F-readout,
    plus must-fail material (m1 dropped source, m2 swapped cols)."""
    alh, gamv, hv, Fv = p["alh"], p["gamv"], p["hv"], p["Fv"]
    P, _ = BH.plain_vals(alh, gamv, p["xall"], n + 2)
    Pb, _ = BH.plain_vals(alh, gamv, p["ball"], n + 2)
    inv = 1.0 / (z - p["xall"])
    binv = 1.0 / (z - p["ball"])
    C = {k: complex(np.sum(p["wall"] * P[k] * inv))
         for k in (n - 1, n, n + 1)}
    Cs = {k: complex(np.sum(p["bwall"] * Pb[k] * binv))
          for k in (n - 1, n, n + 1)}
    pz = zvals(alh, gamv, z, n + 2)

    def y3(nn):
        return np.array(
            [[pz[nn], C[nn], Cs[nn]],
             [pz[nn - 1] / hv[nn - 1], C[nn - 1] / hv[nn - 1],
              Cs[nn - 1] / hv[nn - 1]],
             [0.0, 0.0, 1.0]], complex)

    # C/Cs at n+1 needed for Y_{n+1}; C at n-1..n+1 available
    C2 = dict(C)
    Cs2 = dict(Cs)
    Yn = y3(n)
    Yn1 = np.array(
        [[pz[n + 1], C2[n + 1], Cs2[n + 1]],
         [pz[n] / hv[n], C2[n] / hv[n], Cs2[n] / hv[n]],
         [0.0, 0.0, 1.0]], complex)
    det_dev = abs(np.linalg.det(Yn) - 1.0)
    R3 = np.array([[z - alh[n], -hv[n], -Fv[n]],
                   [1.0 / hv[n], 0.0, 0.0],
                   [0.0, 0.0, 1.0]], complex)
    Pr = R3 @ Yn
    step_dev = 0.0
    for j in range(3):
        scj = max(np.max(np.abs(Yn1[:, j])), 1e-300)
        step_dev = max(step_dev,
                       float(np.max(np.abs(Pr[:, j] - Yn1[:, j]))
                             / scj))
    frd = ((z - alh[n]) * Cs[n] - gamv[n] * Cs[n - 1] - Cs[n + 1])
    frd_dev = abs(frd - Fv[n]) / max(p["Fabs"][n], 1e-300)
    # m1: dropped source residual (col 3 only)
    R3b = R3.copy()
    R3b[0, 2] = 0.0
    Prb = R3b @ Yn
    sc3 = max(np.max(np.abs(Yn1[:, 2])), 1e-300)
    m1_dev = float(np.max(np.abs(Prb[:, 2] - Yn1[:, 2])) / sc3)
    # m2: swapped columns 2 <-> 3
    Ysw = Yn[:, [0, 2, 1]].copy()
    Ysw[2] = np.array([0.0, 0.0, 1.0])
    m2_det = abs(np.linalg.det(Ysw) - 1.0)
    Ysw1 = Yn1[:, [0, 2, 1]].copy()
    Ysw1[2] = np.array([0.0, 0.0, 1.0])
    Psw = R3 @ Ysw
    m2_step = 0.0
    for j in range(3):
        scj = max(np.max(np.abs(Ysw1[:, j])), 1e-300)
        m2_step = max(m2_step,
                      float(np.max(np.abs(Psw[:, j] - Ysw1[:, j]))
                            / scj))
    return dict(det=det_dev, step=step_dev, frd=frd_dev,
                m1=m1_dev, m2d=m2_det, m2s=m2_step)


def onb_delta(p, n, B):
    """ONB-side displacement Delta = J_ext^T Ghat - Ghat J_ext."""
    hv, Fv, alh, gamv = p["hv"], p["Fv"], p["alh"], p["gamv"]
    J = np.zeros((n + 1, n + 1))
    for k in range(n):
        J[k, k] = alh[k]
        if k + 1 <= n - 1:
            J[k + 1, k] = 1.0
        if k >= 1:
            J[k - 1, k] = gamv[k]
    G = np.zeros((n + 1, n + 1))
    for k in range(n):
        G[k, k] = hv[k]
        G[k, n] = G[n, k] = Fv[k]
    G[n, n] = B
    D = J.T @ G - G @ J
    scale = np.abs(J.T) @ np.abs(G) + np.abs(G) @ np.abs(J)
    blk = float(np.max(np.abs(D[:n, :n])
                       / np.maximum(scale[:n, :n], 1e-300)))
    tdev = 0.0
    for j in range(n):
        want = p["Tv"][j] if j < n - 1 else p["Tv"][j] - Fv[n]
        tdev = max(tdev, abs(D[j, n] - want)
                   / max(p["Tabs"][j], 1e-300))
    rk, _s = svd_rank(D)
    return dict(D=D, blk=blk, tdev=tdev, rank=rk)


# ------------------------------------------------------- mp blocks
def mp_deep_w9(p, dps, zc, budgets):
    """dps-160 full-depth w9: det Y3aug, R3 step, F-readout vs
    pairing per degree; integrated D-flow vs direct telescope;
    CD reconstruction of the k-sum kernel at n = N-1 on the mp
    subgrid (the razor rank gate)."""
    import mpmath as mp
    mp.mp.dps = dps
    d, dsm = p["d"], p["dsm"]
    N = p["N"]
    nds = ([mp.mpf(float(x)) for x in d["xs"]]
           + [mp.mpf(float(y)) for y in d["ys"]])
    wt = ([mp.mpf(float(w)) for w in d["ws"]]
          + [-mp.mpf(float(v)) for v in d["vs"]])
    bns = ([mp.mpf(float(x)) for x in dsm["xs"]]
           + [mp.mpf(float(y)) for y in dsm["ys"]])
    bwm = ([mp.mpf(float(w)) for w in dsm["ws"]]
           + [-mp.mpf(float(v)) for v in dsm["vs"]])
    z = mp.mpc(zc)
    inv = [1 / (z - x) for x in nds]
    binv = [1 / (z - x) for x in bns]
    isub = list(np.unique(np.linspace(0, len(nds) - 1,
                                      MP_SUB).astype(int)))
    jsub = list(np.unique(np.linspace(0, len(bns) - 1,
                                      MP_SUB).astype(int)))
    tsub = [nds[i] for i in isub] + [bns[j] for j in jsub]
    ns = len(tsub)
    Ksub = [[mp.mpf(0)] * ns for _ in range(ns)]
    pk = [mp.mpf(1)] * len(nds)
    pkm = [mp.mpf(0)] * len(nds)
    bk = [mp.mpf(1)] * len(bns)
    bkm = [mp.mpf(0)] * len(bns)
    pz = [mp.mpc(1), mp.mpc(0)]     # p_n(z), p_{n-1}(z)
    hs = [mp.fsum(w * q * q for w, q in zip(wt, pk))]
    Cur = dict(C=None, Cs=None, Cm=None, Csm=None)
    Cur["C"] = mp.fsum(w * q * iv for w, q, iv in zip(wt, pk, inv))
    Cur["Cs"] = mp.fsum(w * q * iv
                        for w, q, iv in zip(bwm, bk, binv))
    F_pair = [mp.fsum(w * q for w, q in zip(bwm, bk))]
    als, gms = [], []
    S_dir = mp.mpf(0)
    rho_read = []
    det_dev = step_dev = frd_dev = mp.mpf(0)
    gen = {}
    for k in range(N):
        if k < N - 1:
            vsub = [pk[i] for i in isub] + [bk[j] for j in jsub]
            for a in range(ns):
                va = vsub[a] / hs[-1]
                for b in range(ns):
                    Ksub[a][b] += va * vsub[b]
        if k >= N - 2:
            gen[k] = ([pk[i] for i in isub]
                      + [bk[j] for j in jsub])
        S_dir += F_pair[-1] ** 2 / hs[-1]
        a = mp.fsum(w * x * q * q
                    for w, x, q in zip(wt, nds, pk)) / hs[-1]
        g = (hs[-1] / hs[-2]) if k > 0 else mp.mpf(0)
        als.append(a)
        gms.append(g)
        nx = [(x - a) * q - g * qq
              for x, q, qq in zip(nds, pk, pkm)]
        nb = [(x - a) * q - g * qq
              for x, q, qq in zip(bns, bk, bkm)]
        pz = [(z - a) * pz[0] - g * pz[1], pz[0]]
        pkm, pk = pk, nx
        bkm, bk = bk, nb
        hs.append(mp.fsum(w * q * q for w, q in zip(wt, pk)))
        C_new = mp.fsum(w * q * iv for w, q, iv in zip(wt, pk, inv))
        Cs_new = mp.fsum(w * q * iv
                         for w, q, iv in zip(bwm, bk, binv))
        F_new = mp.fsum(w * q for w, q in zip(bwm, bk))
        # det Y3aug at degree k+1 (needs degrees k+1, k)
        detv = (pz[0] * Cur["C"] - pz[1] * C_new) / hs[-2]
        det_dev = max(det_dev, abs(detv - 1))
        # R3 step, column 3: Cs_{k+1} = (z-a) Cs_k - g Cs_{k-1} - F_k
        rhs = (z - a) * Cur["Cs"] - (g * Cur["Csm"]
                                     if Cur["Csm"] is not None
                                     else 0) - F_pair[-1]
        sc = max(abs(Cs_new), abs(F_pair[-1]), mp.mpf("1e-300"))
        step_dev = max(step_dev, abs(Cs_new - rhs) / sc)
        # F-readout (rearranged transfer) vs pairing
        fr = (z - a) * Cur["Cs"] - (g * Cur["Csm"]
                                    if Cur["Csm"] is not None
                                    else 0) - Cs_new
        sc = max(abs(F_pair[-1]), mp.mpf("1e-300"))
        frd_dev = max(frd_dev, abs(fr - F_pair[-1]) / sc)
        rho_read.append(mp.re(fr) ** 2 / hs[-2])
        Cur["Cm"], Cur["C"] = Cur["C"], C_new
        Cur["Csm"], Cur["Cs"] = Cur["Cs"], Cs_new
        F_pair.append(F_new)
    # D-flow vs direct telescope (linear in B: one number)
    # rho_read[k] = F_k(readout)^2 / h_k for k = 0..N-1
    Sread = mp.fsum(rho_read[:N])
    dflow_dev = float(abs(Sread - S_dir) / abs(S_dir))
    # CD reconstruction at n = N-1 on the subgrid
    rec = mp.mpf(0)
    hnm2 = hs[N - 2]
    gN, gM = gen[N - 1], gen[N - 2]
    dmax = mp.mpf(0)
    for a_ in range(ns):
        for b_ in range(ns):
            dd = (tsub[a_] - tsub[b_]) * Ksub[a_][b_]
            cd = (gN[a_] * gM[b_] - gM[a_] * gN[b_]) / hnm2
            rec = max(rec, abs(dd - cd))
            dmax = max(dmax, abs(dd))
    rec_rel = float(rec / dmax) if dmax > 0 else 0.0
    nong = min(max(abs(v) for v in gN), max(abs(v) for v in gM))
    return dict(det=float(mp.re(abs(det_dev))),
                step=float(mp.re(abs(step_dev))),
                frd=float(mp.re(abs(frd_dev))),
                dflow=dflow_dev, rec=rec_rel,
                nong=float(nong) != 0.0)


def mp_flip_panel(p, dps, zc, n_hi):
    """dps-60 control panel THROUGH the sign flip: det Y3aug and
    the R3 column-3 step for degrees 2..n_hi (h < 0 included)."""
    import mpmath as mp
    mp.mp.dps = dps
    d, dsm = p["d"], p["dsm"]
    nds = ([mp.mpf(float(x)) for x in d["xs"]]
           + [mp.mpf(float(y)) for y in d["ys"]])
    wt = ([mp.mpf(float(w)) for w in d["ws"]]
          + [-mp.mpf(float(v)) for v in d["vs"]])
    bns = ([mp.mpf(float(x)) for x in dsm["xs"]]
           + [mp.mpf(float(y)) for y in dsm["ys"]])
    bwm = ([mp.mpf(float(w)) for w in dsm["ws"]]
           + [-mp.mpf(float(v)) for v in dsm["vs"]])
    z = mp.mpc(zc)
    inv = [1 / (z - x) for x in nds]
    binv = [1 / (z - x) for x in bns]
    pk = [mp.mpf(1)] * len(nds)
    pkm = [mp.mpf(0)] * len(nds)
    bk = [mp.mpf(1)] * len(bns)
    bkm = [mp.mpf(0)] * len(bns)
    pz = [mp.mpc(1), mp.mpc(0)]
    hs = [mp.fsum(w * q * q for w, q in zip(wt, pk))]
    C_c = mp.fsum(w * q * iv for w, q, iv in zip(wt, pk, inv))
    Cs_c = mp.fsum(w * q * iv for w, q, iv in zip(bwm, bk, binv))
    Cs_m = None
    det_dev = step_dev = mp.mpf(0)
    min_h = mp.mpf("inf")
    n_neg = 0
    for k in range(n_hi):
        F_c = mp.fsum(w * q for w, q in zip(bwm, bk))
        a = mp.fsum(w * x * q * q
                    for w, x, q in zip(wt, nds, pk)) / hs[-1]
        g = (hs[-1] / hs[-2]) if k > 0 else mp.mpf(0)
        nx = [(x - a) * q - g * qq
              for x, q, qq in zip(nds, pk, pkm)]
        nb = [(x - a) * q - g * qq
              for x, q, qq in zip(bns, bk, bkm)]
        pz = [(z - a) * pz[0] - g * pz[1], pz[0]]
        pkm, pk = pk, nx
        bkm, bk = bk, nb
        hs.append(mp.fsum(w * q * q for w, q in zip(wt, pk)))
        if hs[-1] < 0:
            n_neg += 1
        min_h = min(min_h, abs(hs[-1]))
        C_new = mp.fsum(w * q * iv for w, q, iv in zip(wt, pk, inv))
        Cs_new = mp.fsum(w * q * iv
                         for w, q, iv in zip(bwm, bk, binv))
        detv = (pz[0] * C_c - pz[1] * C_new) / hs[-2]
        det_dev = max(det_dev, abs(detv - 1))
        rhs = (z - a) * Cs_c - (g * Cs_m if Cs_m is not None
                                else 0) - F_c
        sc = max(abs(Cs_new), abs(F_c), mp.mpf("1e-300"))
        step_dev = max(step_dev, abs(Cs_new - rhs) / sc)
        C_c = C_new
        Cs_m, Cs_c = Cs_c, Cs_new
    return dict(det=float(abs(det_dev)), step=float(abs(step_dev)),
                n_neg=n_neg)


def mp_mod_pivots(p, dps, zqs, n_list, budgets):
    """dps-60 moderate-depth pivot assembly from PURE z-space
    readouts (W-minor h, transfer-readout F, D-flow) vs the direct
    LDL pivots of the bordered moment matrix (BH.mp_moments)."""
    import mpmath as mp
    mp.mp.dps = dps
    d, dsm = p["d"], p["dsm"]
    n_hi = max(n_list)
    nds = ([mp.mpf(float(x)) for x in d["xs"]]
           + [mp.mpf(float(y)) for y in d["ys"]])
    wt = ([mp.mpf(float(w)) for w in d["ws"]]
          + [-mp.mpf(float(v)) for v in d["vs"]])
    bns = ([mp.mpf(float(x)) for x in dsm["xs"]]
           + [mp.mpf(float(y)) for y in dsm["ys"]])
    bwm = ([mp.mpf(float(w)) for w in dsm["ws"]]
           + [-mp.mpf(float(v)) for v in dsm["vs"]])
    zs = [mp.mpc(zq) for zq in zqs]
    invs = [[1 / (z - x) for x in nds] for z in zs]
    binvs = [[1 / (z - x) for x in bns] for z in zs]
    pk = [mp.mpf(1)] * len(nds)
    pkm = [mp.mpf(0)] * len(nds)
    bk = [mp.mpf(1)] * len(bns)
    bkm = [mp.mpf(0)] * len(bns)
    pzs = [[mp.mpc(1), mp.mpc(0)] for _ in zs]
    hs = [mp.fsum(w * q * q for w, q in zip(wt, pk))]
    Cc = [mp.fsum(w * q * iv for w, q, iv in zip(wt, pk, iv_))
          for iv_ in invs]
    Csc = [mp.fsum(w * q * iv for w, q, iv in zip(bwm, bk, iv_))
           for iv_ in binvs]
    Csm = [None for _ in zs]
    h_read = []
    F_read = []
    zind_dev = mp.mpf(0)
    for k in range(n_hi + 1):
        a = mp.fsum(w * x * q * q
                    for w, x, q in zip(wt, nds, pk)) / hs[-1]
        g = (hs[-1] / hs[-2]) if k > 0 else mp.mpf(0)
        nx = [(x - a) * q - g * qq
              for x, q, qq in zip(nds, pk, pkm)]
        nb = [(x - a) * q - g * qq
              for x, q, qq in zip(bns, bk, bkm)]
        for iz in range(len(zs)):
            pzs[iz] = [(zs[iz] - a) * pzs[iz][0] - g * pzs[iz][1],
                       pzs[iz][0]]
        pkm, pk = pk, nx
        bkm, bk = bk, nb
        hs.append(mp.fsum(w * q * q for w, q in zip(wt, pk)))
        hzs, fzs = [], []
        for iz in range(len(zs)):
            C_new = mp.fsum(w * q * iv
                            for w, q, iv in zip(wt, pk, invs[iz]))
            Cs_new = mp.fsum(w * q * iv
                             for w, q, iv in zip(bwm, bk,
                                                 binvs[iz]))
            # W-minor: h_k = p_{k+1} C_k - p_k C_{k+1}
            hzs.append(pzs[iz][0] * Cc[iz] - pzs[iz][1] * C_new)
            # transfer readout: F_k = (z-a) Cs_k - g Cs_{k-1}
            #                        - Cs_{k+1}
            fzs.append((zs[iz] - a) * Csc[iz]
                       - (g * Csm[iz] if Csm[iz] is not None
                          else 0) - Cs_new)
            Cc[iz] = C_new
            Csm[iz], Csc[iz] = Csc[iz], Cs_new
        zind_dev = max(zind_dev,
                       abs(hzs[0] - hzs[1]) / abs(hzs[0]),
                       abs(fzs[0] - fzs[1])
                       / max(abs(fzs[0]), mp.mpf("1e-300")))
        h_read.append(mp.re(hzs[0]))
        F_read.append(mp.re(fzs[0]))
    # direct bordered LDL from moments
    mmom, smom = BH.mp_moments(d, dsm, n_hi + 1, dps)
    worst = 0.0
    for n in n_list:
        for B in budgets:
            G = mp.zeros(n + 1, n + 1)
            for i in range(n):
                for j in range(n):
                    G[i, j] = mmom[i + j]
                G[i, n] = G[n, i] = smom[i]
            G[n, n] = mp.mpf(B)
            piv = []
            for i in range(n + 1):
                piv.append(G[i, i])
                for r in range(i + 1, n + 1):
                    f = G[r, i] / G[i, i]
                    for c in range(i, n + 1):
                        G[r, c] -= f * G[i, c]
            # assembled: h_0..h_{n-1} from W-minors, corner via
            # D-flow with readout F
            Dn = mp.mpf(B)
            for k in range(n):
                Dn -= F_read[k] ** 2 / h_read[k]
            for k in range(n):
                worst = max(worst, float(abs(h_read[k] - piv[k])
                                         / abs(piv[k])))
            worst = max(worst, float(abs(Dn - piv[n])
                                     / abs(piv[n])))
    return dict(worst=worst, zind=float(zind_dev))


def det3(M):
    return (M[0][0] * (M[1][1] * M[2][2] - M[1][2] * M[2][1])
            - M[0][1] * (M[1][0] * M[2][2] - M[1][2] * M[2][0])
            + M[0][2] * (M[1][0] * M[2][1] - M[1][1] * M[2][0]))


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

    print("=" * 78)
    print("bordered_finite_rank_probe -- PRIME.PORT.RHP."
          "BORDEREDHANKEL.FINITE.02 (round 245)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (five known rungs, mp blocks "
                        "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,
          "formulation candidates A1a/A1b/A2, displacement panels "
          "P1/P2/P3, rank verdicts (RANK2/RANK3/FIXED_HIGHER/GROWS)"
          " and pivot verdict sealed in the frozen spec; census "
          "degrees %s, subgrid <= %d/zone, rank eps %.0e; toy "
          "budgets %s, window budgets %s, uva B = %.0f; f64 bars "
          "det/step/frd %.0e, recon %.0e/%.0e, ONB %.0e/%.0e; mp "
          "deep dps %d bar %.0e, flip dps %d bar %.0e, pivots bar "
          "%.0e; loud ratio %.0e; control flips 25/21/27"
          % (str(CENSUS_DEGS), SUB_CAP, RANK_EPS,
             str([str(b) for b in B_TOY]), str(B_MP), B_UVA,
             DET12_BAR, RECON_BAR, RECON20_BAR, ONB_BLK_BAR,
             ONB_T_BAR, MP_DPS, MPDEEP_BAR, MPFLIP_DPS,
             MPFLIP_BAR, MPPIV_BAR, LOUD))

    # ================= S1: toy -- pure-degree 3x3 (leg A1a)
    section("S1  LEG A1a -- PURE-DEGREE 3x3 (exact rationals)")
    JFn = [Fr(-7, 8), Fr(-5, 8), Fr(-3, 8), Fr(-1, 8), Fr(1, 8),
           Fr(3, 8), Fr(5, 8), Fr(7, 8), Fr(0, 1)]
    JFw = [Fr(3, 7), Fr(-2, 9), Fr(5, 11), Fr(1, 4), Fr(-3, 8),
           Fr(2, 5), Fr(-1, 6), Fr(4, 9), Fr(1, 3)]
    SBn = [Fr(-13, 16), Fr(-7, 16), Fr(-1, 16), Fr(5, 16),
           Fr(11, 16)]
    SBw = [Fr(2, 5), Fr(-1, 7), Fr(3, 8), Fr(-2, 11), Fr(1, 3)]
    NT2 = NTOY + 2
    al, hs, vals = PB.toy_chain(JFn, JFw, NT2)
    assert all(h != 0 for h in hs[:NT2 + 1]), "toy degenerate"
    sp = [[PB.toy_eval(al, hs, k, s) for s in SBn]
          for k in range(NT2 + 1)]
    Ftoy = [sum(w * v for w, v in zip(SBw, sp[k]))
            for k in range(NT2 + 1)]
    Ttoy = [sum(w * s * v for w, s, v in zip(SBw, SBn, sp[k]))
            for k in range(NT2 + 1)]
    assert all(Ftoy[k] != 0 for k in range(NTOY + 1)), "F = 0 toy"
    Stoy = []
    acc = Fr(0)
    for k in range(NT2):
        acc += Ftoy[k] * Ftoy[k] / hs[k]
        Stoy.append(acc)
    gmt = [Fr(0)] + [hs[k] / hs[k - 1] for k in range(1, NT2 + 1)]

    def Cmu(k, z):
        return toy_cauchy(vals[k], JFw, JFn, z)

    def Csg(k, z):
        return toy_cauchy(sp[k], SBw, SBn, z)

    def pz_t(k, z):
        return PB.toy_eval(al, hs, k, z)

    ZS = [Fr(150 + 7 * i, 41) for i in range(NZ_TOY)]
    # G10: Laurent order table (exact moments)
    ok10 = True
    for m in range(NTOY + 1):
        mu_m = [sum(w * v * x ** j
                    for w, v, x in zip(JFw, vals[m], JFn))
                for j in range(m + 2)]
        ok10 = ok10 and all(mu_m[j] == 0 for j in range(m)) \
            and mu_m[m] == hs[m]
        sg_m = [sum(w * v * x ** j
                    for w, v, x in zip(SBw, sp[m], SBn))
                for j in range(2)]
        ok10 = ok10 and sg_m[0] == Ftoy[m] and sg_m[1] == Ttoy[m]
    check("G10-laurent-orders-exact", ok10,
          "rationals m = 0..4: col2 = C[pihat_m mutilde] has "
          "EXACTLY m leading cancellations (<pihat_m, x^j> = 0 for "
          "j < m, = h_m at j = m) => order z^{-m-1} leading h_m; "
          "col3 = Csig_m has NO cancellation: order z^{-1} leading "
          "F_m, next coefficient T_m (the r244 flow source IS the "
          "z^{-2} readout of the border column); col1 monic degree "
          "m -- the frozen order table of the augmented problem")
    # G11: unique diagonal normalization (exact enumeration)
    ok11 = True
    for n in (3, 4):
        O = [[n - i, -(n - i) - 1, -1] for i in range(3)]
        Lc = [[Fr(1), hs[n - i], Ftoy[n - i]] for i in range(3)]
        found = []
        for a in range(-n - 2, n + 3):
            for b in range(-n - 2, n + 3):
                for c in range(-n - 2, n + 3):
                    pw = (a, b, c)
                    ok = True
                    L = [[Fr(0)] * 3 for _ in range(3)]
                    for i in range(3):
                        for j in range(3):
                            e = O[i][j] + pw[j]
                            if e > 0:
                                ok = False
                                break
                            if e == 0:
                                L[i][j] = Lc[i][j]
                        if not ok:
                            break
                    if ok and det3(L) != 0:
                        found.append((pw, det3(L)))
        ok11 = ok11 and len(found) == 1 \
            and found[0][0] == (-n, n - 1, 1) \
            and found[0][1] == -hs[n - 2] * Ftoy[n - 1]
    check("G11-unique-normalization-census", ok11,
          "exact enumeration over the full diagonal-gauge cube "
          "|a|,|b|,|c| <= n+2 (n = 3 and 4): EXACTLY ONE gauge "
          "diag(z^{-n}, z^{n-1}, z) gives a finite INVERTIBLE "
          "limit L (permutation-triangular, det L = -h_{n-2} "
          "F_{n-1} = det Y3); L is singular iff F_{n-1} = 0 -- "
          "the pure-degree 3x3 normalizes UNIQUELY and its "
          "nondegeneracy is the border nondegeneracy (SMOOTH "
          "F = 0 kills it, typed in S6)")
    # G12: det Y3 = -h_{n-2} F_{n-1}, constant in z
    ok12 = True
    for n in range(2, NTOY + 1):
        want = -hs[n - 2] * Ftoy[n - 1]
        for z in ZS:
            M = [[pz_t(n - i, z), Cmu(n - i, z), Csg(n - i, z)]
                 for i in range(3)]
            ok12 = ok12 and (det3(M) == want)
    check("G12-puredegree-det-exact", ok12,
          "det Y3_n(z) = -h_{n-2} F_{n-1} EXACT at %d rational "
          "z-points for n = 2..4 (constant by the degree-count "
          "argument: a rational function of bounded degree equal "
          "at more points than its degree is constant): the "
          "pure-degree 3x3 has CONSTANT determinant carrying the "
          "border weight F_{n-1} -- solvable iff the 2x2 is AND "
          "F != 0; it sees F but NEVER B or S: no PSD encoding "
          "in its solvability" % NZ_TOY)
    # G13: residue dictionary (structural)
    n = 3
    ok13 = True
    for a, (s_a, sw_a) in enumerate(zip(SBn, SBw)):
        res = (sw_a * sp[n][a], sw_a * sp[n - 1][a] / hs[n - 1],
               Fr(0))
        col1 = (sp[n][a], sp[n - 1][a] / hs[n - 1], Fr(0))
        ok13 = ok13 and res == tuple(sw_a * v for v in col1)
        # regularized limit of (z - s_a) Csig_n at s_a
        lim = sw_a * sp[n][a] + sum(
            SBw[b] * sp[n][b] * (s_a - s_a) / (s_a - SBn[b])
            for b in range(len(SBn)) if b != a)
        ok13 = ok13 and lim == sw_a * sp[n][a]
    for i, (x_i, w_i) in enumerate(zip(JFn, JFw)):
        res = (w_i * vals[n][i], w_i * vals[n - 1][i] / hs[n - 1],
               Fr(0))
        col1 = (vals[n][i], vals[n - 1][i] / hs[n - 1], Fr(0))
        ok13 = ok13 and res == tuple(w_i * v for v in col1)
    check("G13-residue-dictionary", ok13,
          "structural dictionary gate (by construction, "
          "disclosed): Res_{y_a} Y3aug = lim Y3aug (sv_a E_13) at "
          "every sigma-atom and Res_{x_i} Y3aug = lim Y3aug (w_i "
          "E_12) at every mutilde-atom -- BOTH jumps are NILPOTENT"
          " and couple ONLY into column 1; row 3 is pole-free: "
          "the jump data is block-triangular, the third column is "
          "a quadrature slave of column 1 (regularized limit of "
          "(z - y_a) Csig_n gated exact)")

    # ================= S2: toy -- augmented Y3aug (leg A1b)
    section("S2  LEG A1b -- UNIPOTENT-AUGMENTED Y3aug (exact)")

    def y3aug_t(n, z, csg=None):
        cs = csg if csg is not None else Csg
        return [[pz_t(n, z), Cmu(n, z), cs(n, z)],
                [pz_t(n - 1, z) / hs[n - 1],
                 Cmu(n - 1, z) / hs[n - 1],
                 cs(n - 1, z) / hs[n - 1]],
                [Fr(0), Fr(0), Fr(1)]]

    ok20 = True
    for n in range(2, NTOY + 1):
        for z in ZS[:9]:
            ok20 = ok20 and det3(y3aug_t(n, z)) == 1
    check("G20-y3aug-det-one-exact", ok20,
          "det Y3aug_n(z) = 1 EXACT (rationals, n = 2..4, 9 "
          "z-points): the unipotent third row makes det Y3aug = "
          "det Y_2x2 = 1 -- adding the border column changes NO "
          "solvability data (sigma- and B-blind determinant); "
          "normalization Y3aug diag(z^{-n}, z^n, 1) = I + Y1/z "
          "with Y1_13 = F_n (Laurent leading, G10): the border "
          "data is the infinity readout of the third column")
    ok21 = True
    for n in range(2, NTOY):
        for z in ZS[:6]:
            Yn = y3aug_t(n, z)
            Yn1 = y3aug_t(n + 1, z)
            R3 = [[z - al[n], -hs[n], -Ftoy[n]],
                  [Fr(1) / hs[n], Fr(0), Fr(0)],
                  [Fr(0), Fr(0), Fr(1)]]
            ok21 = ok21 and det3(R3) == 1
            for i in range(3):
                for j in range(3):
                    prod = sum(R3[i][m] * Yn[m][j]
                               for m in range(3))
                    ok21 = ok21 and prod == Yn1[i][j]
    check("G21-r3-step-exact", ok21,
          "Y3aug_{n+1} = R3_n Y3aug_n EXACT (rationals, n = 2..3, "
          "6 z-points) with R3_n = [[z - alphahat_n, -h_n, -F_n], "
          "[1/h_n, 0, 0], [0, 0, 1]], det R3 = 1: the r244 flow "
          "INHOMOGENEITY (F-source) appears as the (1,3) MATRIX "
          "ENTRY of a unimodular 3x3 transfer -- the bordered "
          "problem is the 2x2 FIK Schlesinger chain plus one "
          "parabolic (unipotent) column, homogenized by the "
          "constant row; entries (3,1)/(3,2) stay EXACTLY 0")
    # G24 toy part: sigma-mutation leaves det Y3aug = 1, moves F
    SBw_m = list(SBw)
    SBw_m[2] = SBw[2] * (1 + Fr(1, 7))
    sp_m = sp

    def Csg_m(k, z):
        return toy_cauchy(sp_m[k], SBw_m, SBn, z)

    F_mut = sum(w * v for w, v in zip(SBw_m, sp[3]))
    ok24 = (F_mut != Ftoy[3])
    for z in ZS[:4]:
        ok24 = ok24 and det3(y3aug_t(3, z, csg=Csg_m)) == 1
    check("G24-solvability-sigma-blind", ok24,
          "mutating a sigma weight moves F_3 (border data changes)"
          " while det Y3aug stays EXACTLY 1: the solvability of "
          "the augmented formulation is sigma-blind and B never "
          "appears -- the bordered PSD statement is NOT encoded "
          "in the jump/solvability data of the 3x3, it lives in "
          "the Uvarov tau step on top (leg C); adjudication "
          "material for SCHLESINGER vs IRREDUCIBLE")

    # ================= S4-toy: displacement panels (leg B, exact)
    section("S3  LEG B -- DISPLACEMENT RANK (exact toy panels)")
    tj = JFn + SBn
    ok40 = True
    for n in range(2, NTOY + 1):
        vj = [vals[k] + sp[k] for k in range(n + 1)]
        K = [[sum(vj[k][i] * vj[k][j] / hs[k] for k in range(n))
              for j in range(14)] for i in range(14)]
        D = [[(tj[i] - tj[j]) * K[i][j] for j in range(14)]
             for i in range(14)]
        ok40 = ok40 and frac_rank(D) == 2
        for i in range(14):
            for j in range(14):
                cd = (vj[n][i] * vj[n - 1][j]
                      - vj[n - 1][i] * vj[n][j]) / hs[n - 1]
                ok40 = ok40 and D[i][j] == cd
        # encoding ward: kappa = r_n, <r_n, p_k> = F_k, sig^2 = S
        kap = [sum(SBw[a] * K[i][9 + a] for a in range(5))
               for i in range(14)]
        rn = [sum(Ftoy[k] * vj[k][i] / hs[k] for k in range(n))
              for i in range(14)]
        ok40 = ok40 and kap == rn
        for k in range(n):
            pair = sum(JFw[i] * kap[i] * vj[k][i]
                       for i in range(9))
            ok40 = ok40 and pair == Ftoy[k]
        ok40 = ok40 and sum(SBw[a] * kap[9 + a]
                            for a in range(5)) == Stoy[n - 1]
    check("G40-kext-rank2-exact", ok40,
          "panel P1 (node side), rationals n = 2..4 on the 14-node"
          " joint grid: rank[(t - t') K_ext] = 2 EXACTLY, and the "
          "CD reconstruction (t-t') K_n = [pihat_n(t) pihat_{n-1}"
          "(t') - pihat_{n-1}(t) pihat_n(t')]/h_{n-1} holds "
          "ENTRYWISE -- the sigma-extension adds NO generator: "
          "the border direction kappa(t) = int K dsigma = r_n(t) "
          "(Riesz representer, <r_n, pihat_k> = F_k, double smear "
          "= S_{n-1}, all exact) is a POLYNOMIAL, inside the "
          "existing generator space")
    ok41 = True
    n = 3
    vj = [vals[k] + sp[k] for k in range(n + 1)]
    K3 = [[sum(vj[k][i] * vj[k][j] / hs[k] for k in range(n))
           for j in range(14)] for i in range(14)]
    rn = [sum(Ftoy[k] * vj[k][i] / hs[k] for k in range(n))
          for i in range(14)]
    rho_v = [(Fr(1) if i >= 9 else Fr(0)) - rn[i]
             for i in range(14)]
    for B in B_TOY:
        cB = B - Stoy[n - 1]
        Ku = [[K3[i][j] + rho_v[i] * rho_v[j] / cB
               for j in range(14)] for i in range(14)]
        Du = [[(tj[i] - tj[j]) * Ku[i][j] for j in range(14)]
              for i in range(14)]
        ok41 = ok41 and frac_rank(Du) == 4
        gens = [[vj[n][i], vj[n - 1][i], rho_v[i],
                 tj[i] * rho_v[i]] for i in range(14)]
        ok41 = ok41 and frac_rank(gens) == 4
    check("G41-kuva-rank-2plus2-exact", ok41,
          "panel P3 (disclosed S-consuming diagnostic), rationals "
          "n = 3, both sealed budgets: the Uvarov-projected kernel"
          " K_ext + rho rho^T/(B - S_{n-1}) with rho = 1_sigma - "
          "r_n (sealed direct-sum realization of the residual "
          "e - r_n) has displacement rank EXACTLY 4 = 2 + 2: the "
          "border as a PROJECTION direction adds the generator "
          "pair (rho, Y rho) -- one rank-1 insertion, two "
          "displacement generators, FIXED (never 3, never "
          "growing); the generator quadruple is independent "
          "(exact rank 4)")
    ok42 = True
    for n in (3, 4):
        Ds = []
        for B in B_TOY:
            J = [[Fr(0)] * (n + 1) for _ in range(n + 1)]
            for k in range(n):
                J[k][k] = al[k]
                if k + 1 <= n - 1:
                    J[k + 1][k] = Fr(1)
                if k >= 1:
                    J[k - 1][k] = gmt[k]
            G = [[Fr(0)] * (n + 1) for _ in range(n + 1)]
            for k in range(n):
                G[k][k] = hs[k]
                G[k][n] = G[n][k] = Ftoy[k]
            G[n][n] = B
            D = [[sum(J[m][i] * G[m][j] for m in range(n + 1))
                  - sum(G[i][m] * J[m][j] for m in range(n + 1))
                  for j in range(n + 1)] for i in range(n + 1)]
            Ds.append(D)
            for i in range(n):
                for j in range(n):
                    ok42 = ok42 and D[i][j] == 0
            for j in range(n):
                want = Ttoy[j] if j < n - 1 else Ttoy[j] - Ftoy[n]
                ok42 = ok42 and D[j][n] == want \
                    and D[n][j] == -want
            ok42 = ok42 and D[n][n] == 0
            ok42 = ok42 and frac_rank(D) == 2
        ok42 = ok42 and Ds[0] == Ds[1]
    check("G42-onb-displacement-exact", ok42,
          "panel P2 (ONB side), rationals n = 3/4, both budgets: "
          "Delta = J_ext^T Ghat - Ghat J_ext has IDENTICALLY ZERO "
          "polynomial block (h_j J_jk = h_k J_kj inside the "
          "truncation), border column EXACTLY (T_0, .., T_{n-2}, "
          "T_{n-1} - F_n) -- the r244 T-source IS the displacement"
          " entry and the truncation boundary carries the F_n "
          "deficit -- rank EXACTLY 2, and Delta is BUDGET-BLIND "
          "(identical at both B): the bordered Gram's own "
          "displacement adds exactly one generator PAIR: "
          "Schlesinger-insertion currency, for EVERY B")

    # ================= S5-toy: pivot chain (leg C, exact)
    section("S4  LEG C -- PIVOT CHAIN FROM THE FORMULATION (toy)")
    mom = [sum(w * x ** k for w, x in zip(JFw, JFn))
           for k in range(2 * NTOY + 4)]
    smom = [sum(w * x ** k for w, x in zip(SBw, SBn))
            for k in range(NTOY + 2)]
    z0, z1 = Fr(37, 10), Fr(-29, 7)
    ok50 = True
    for n in range(2, NTOY + 1):
        h_rd, F_rd = [], []
        for k in range(n):
            hz0 = pz_t(k + 1, z0) * Cmu(k, z0) \
                - pz_t(k, z0) * Cmu(k + 1, z0)
            hz1 = pz_t(k + 1, z1) * Cmu(k, z1) \
                - pz_t(k, z1) * Cmu(k + 1, z1)
            ok50 = ok50 and hz0 == hz1
            h_rd.append(hz0)
            fz = (z0 - al[k]) * Csg(k, z0) \
                - (gmt[k] * Csg(k - 1, z0) if k >= 1 else Fr(0)) \
                - Csg(k + 1, z0)
            fz1 = (z1 - al[k]) * Csg(k, z1) \
                - (gmt[k] * Csg(k - 1, z1) if k >= 1 else Fr(0)) \
                - Csg(k + 1, z1)
            ok50 = ok50 and fz == fz1
            F_rd.append(fz)
        for B in B_TOY:
            Gb = [[mom[i + j] for j in range(n)] + [smom[i]]
                  for i in range(n)]
            Gb.append([smom[j] for j in range(n)] + [B])
            piv = frac_ldl_pivots(Gb)
            Dn = B
            for k in range(n):
                ok50 = ok50 and h_rd[k] == piv[k]
                Dn -= F_rd[k] * F_rd[k] / h_rd[k]
            ok50 = ok50 and Dn == piv[n]
    check("G50-pivot-assembly-exact", ok50,
          "rationals n = 2..4, both budgets: the FULL pivot chain "
          "of the bordered Hankel [[H_n, u],[u^T, B]] -- nested "
          "pivots (h_0..h_{n-1}, B - S_{n-1}) by exact LDL -- is "
          "reconstructed from PURE z-SPACE data of the augmented "
          "solution: h_k = Wronskian minor pihat_{k+1} C_k - "
          "pihat_k C_{k+1} (z-independent, gated at two z), F_k = "
          "transfer readout (z - alphahat_k) Csig_k - gammahat_k "
          "Csig_{k-1} - Csig_{k+1} (z-independent, gated), corner "
          "via the autonomous flow D_{k+1} = D_k - F_k^2/h_k: the "
          "formulation carries EVERY pivot, not only tau^b -- the "
          "BORDERED_DETERMINANT_ONLY kill on the toy")

    # ================= toy must-fail material
    n = 3
    zt = ZS[0]
    m1_toy = (Csg(n + 1, zt)
              != (zt - al[n]) * Csg(n, zt) - gmt[n] * Csg(n - 1, zt))
    Ysw = y3aug_t(3, zt)
    Ysw = [[Ysw[i][0], Ysw[i][2], Ysw[i][1]] for i in range(3)]
    Ysw[2] = [Fr(0), Fr(0), Fr(1)]
    m2_toy = det3(Ysw) != 1
    SBn_s = [s + Fr(1, 16) for s in SBn]
    sp_s = [[PB.toy_eval(al, hs, k, s) for s in SBn_s]
            for k in range(NTOY + 1)]
    F_s = [sum(w * v for w, v in zip(SBw, sp_s[k]))
           for k in range(NTOY + 1)]
    m3a_toy = any(F_s[k] != Ftoy[k] for k in range(NTOY))
    wbar = sum(SBw, Fr(0)) / len(SBw)
    F_g = [sum(wbar * v for v in sp[k]) for k in range(NTOY + 1)]
    m3b_toy = any(F_g[k] != Ftoy[k] for k in range(NTOY))

    # ================= S5: ladder + controls
    section("S5  LADDER + CONTROLS (f64 panels + census)")
    if smoke:
        kzs = list(SMOKE_KZ)
    else:
        kzs = [kz for kz in core.frame_a_zones()
               if PIK.build_rung(kz)["h"] <= H_CAP]
    packs = [wload(kz) for kz in kzs]
    packs.sort(key=lambda p: (p["N"], p["kz"]))
    by_kz = {p["kz"]: p for p in packs}
    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"])
    ctrl_defs = (("EPSTEIN", dict(comb=(
        np.log(nn_idx.astype(float)),
        2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
        ("SCRAMBLE", dict(scramble_seed=1)),
        ("SMOOTH", dict(comb=(ug9, uw9))))
    ctrl = {c: wload(9, base_kw=kw) for c, kw in ctrl_defs}
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl)
    info("ladder: %d windows, N in [%d, %d]; control flips %s"
         % (len(packs), packs[0]["N"], packs[-1]["N"],
            str({c: ctrl[c]["nf"] for c in ctrl})))
    allw = packs + list(ctrl.values())
    # f64 z-panel gates at n = 12
    wdet = wstep = wfrd = 0.0
    m1r = m2d = m2s = None
    for p in allw:
        for z in Z_PANEL:
            g = zpanel_gates(p, z, N_SNAP)
            wdet = max(wdet, g["det"])
            wstep = max(wstep, g["step"])
            wfrd = max(wfrd, g["frd"])
            if p is by_kz.get(9):
                hon = max(g["step"], 1e-300)
                m1r = (g["m1"] / hon if m1r is None
                       else min(m1r, g["m1"] / hon))
                m2d = g["m2d"] if m2d is None else max(m2d,
                                                       g["m2d"])
                m2s = (g["m2s"] / hon if m2s is None
                       else max(m2s, g["m2s"] / hon))
    check("G22-f64-panel-worlds", wdet <= DET12_BAR
          and wstep <= STEP12_BAR and wfrd <= FRD12_BAR and okCf,
          "n = %d, z-panel, ALL %d windows + EPSTEIN/SCRAMBLE/"
          "SMOOTH: det Y3aug - 1 worst %.1e, R3-step worst %.1e, "
          "F-readout (z - alphahat) Csig_n - gammahat Csig_{n-1} "
          "- Csig_{n+1} = F_n worst %.1e on the border mass-norm "
          "scale (bars %.0e det / %.0e, tightened at freeze, "
          "amendment a2; the mp wards in S7 sit far lower) -- "
          "WORLD-BLIND: same algebra, different values; control "
          "flips re-derived at the sealed degrees"
          % (N_SNAP, len(packs), wdet, wstep, wfrd, DET12_BAR,
             STEP12_BAR))
    # G24 window part: sigma-blindness f64 (w9)
    p9 = by_kz[9]
    bw_mut = p9["bwall"].copy()
    bw_mut[len(bw_mut) // 2] *= 1.01
    z = Z_PANEL[0]
    P9, _ = BH.plain_vals(p9["alh"], p9["gamv"], p9["xall"],
                          N_SNAP + 2)
    Pb9, _ = BH.plain_vals(p9["alh"], p9["gamv"], p9["ball"],
                           N_SNAP + 2)
    inv9 = 1.0 / (z - p9["xall"])
    binv9 = 1.0 / (z - p9["ball"])
    pzv9 = zvals(p9["alh"], p9["gamv"], z, N_SNAP + 2)
    n = N_SNAP

    def y3f(cs_w):
        C_ = {k: complex(np.sum(p9["wall"] * P9[k] * inv9))
              for k in (n - 1, n)}
        Cs_ = {k: complex(np.sum(cs_w * Pb9[k] * binv9))
               for k in (n - 1, n)}
        return np.array(
            [[pzv9[n], C_[n], Cs_[n]],
             [pzv9[n - 1] / p9["hv"][n - 1],
              C_[n - 1] / p9["hv"][n - 1],
              Cs_[n - 1] / p9["hv"][n - 1]],
             [0.0, 0.0, 1.0]], complex)

    d_orig = np.linalg.det(y3f(p9["bwall"]))
    d_mut = np.linalg.det(y3f(bw_mut))
    F_mut9 = float(bw_mut @ Pb9[n])
    dF9 = abs(F_mut9 - p9["Fv"][n]) / max(p9["Fabs"][n], 1e-300)
    ok24w = abs(d_mut - d_orig) <= 1e-12 and dF9 > 1e-6
    check("G24-sigma-blind-f64", ok24w,
          "w9, n = %d: mutating a sigma weight by 1 percent moves "
          "F_n by %.1e (mass-norm units) while det Y3aug moves by "
          "%.1e (identical to machine precision): solvability "
          "sigma-blind on the real comb too; toy part exact (S2)"
          % (N_SNAP, dF9, abs(d_mut - d_orig)))
    check("G23-flips-and-hashes", okCf and len(
        {hashlib.sha256(np.concatenate(
            [w["d"]["xs"], w["d"]["ws"]]).tobytes()).hexdigest()
         for w in (p9, ctrl["EPSTEIN"], ctrl["SCRAMBLE"],
                   ctrl["SMOOTH"])}) == 4,
          "4 distinct input hashes (MAIN/EPSTEIN/SCRAMBLE/SMOOTH "
          "differ in the folded INPUT node sets, before any "
          "evaluation); control flips at the sealed degrees %s"
          % str(CTRL_FLIPS))

    # ================= S6: leg B census on windows
    section("S6  LEG B -- SVD RANK CENSUS + RECONSTRUCTION")
    ranks_all = {}
    rec_w = {6: 0.0, 12: 0.0, 20: 0.0}
    s3_w = 0.0
    uva_ranks = []
    uva_s4min = float("inf")
    n_ovl = {}
    onb_blk = onb_t = 0.0
    onb_rank_bad = 0
    onb_bblind = 0.0

    def wname(p):
        for c in ctrl:
            if ctrl[c] is p:
                return c
        return "kz%d" % p["kz"]

    for p in allw:
        n_ovl[wname(p)] = overlap_census(p)
        t_k = p["tpos"]
        dts = t_k[:, None] - t_k[None, :]
        rks = []
        for dg in CENSUS_DEGS:
            sn = p["snaps"][dg]
            D = dts * sn["K"]
            rk, s = svd_rank(D)
            rks.append(rk)
            s3_w = max(s3_w, float(s[2] / s[0]))
            Dcd = sn["fac"] * (np.outer(sn["qn"], sn["qm"])
                               - np.outer(sn["qm"], sn["qn"]))
            rec = float(np.linalg.norm(D - Dcd)
                        / max(np.linalg.norm(D), 1e-300))
            rec_w[dg] = max(rec_w[dg], rec)
        ranks_all[wname(p)] = rks
        # uva panel at n = 12 (disjoint-union index set)
        sn = p["snaps"][N_SNAP]
        rho_vec = p["sig_mask"].astype(float) - sn["r"]
        Ku = sn["K"] + np.outer(rho_vec, rho_vec) \
            / (B_UVA - sn["S"])
        rku, su = svd_rank(dts * Ku)
        uva_ranks.append(rku)
        M = np.stack([sn["qn"], sn["qm"], rho_vec,
                      t_k * rho_vec], axis=1)
        M = M / np.maximum(np.linalg.norm(M, axis=0), 1e-300)
        sm = np.linalg.svd(M, compute_uv=False)
        uva_s4min = min(uva_s4min, float(sm[3] / sm[0]))
        # ONB panel
        for B in B_MP:
            r = onb_delta(p, N_SNAP, float(B))
            onb_blk = max(onb_blk, r["blk"])
            onb_t = max(onb_t, r["tdev"])
            if r["rank"] != 2:
                onb_rank_bad += 1
            if B == B_MP[0]:
                D2 = r["D"]
            else:
                onb_bblind = max(onb_bblind, float(
                    np.max(np.abs(r["D"] - D2))))
    ok43 = all(all(r == 2 for r in v) for v in ranks_all.values())
    ok43 = ok43 and rec_w[6] <= RECON_BAR \
        and rec_w[12] <= RECON_BAR and rec_w[20] <= RECON20_BAR
    Ns = [p["N"] for p in packs]
    r12 = [ranks_all["kz%d" % p["kz"]][1] for p in packs]
    sp_r = BH.spearman(r12, Ns) if len(set(r12)) > 1 else 0.0
    grows = (not ok43 and any(v[-1] > v[0]
                              for v in ranks_all.values())) \
        or abs(sp_r) > GROWS_SPEAR
    check("G43-kext-census", ok43 and not grows,
          "panel P1 on %d + 3 worlds x degrees %s (%d SVDs): "
          "numerical rank of (t - t') K_n == 2 EVERYWHERE "
          "(sigma_3/sigma_1 worst %.1e vs eps %.0e); EXPLICIT CD "
          "generator reconstruction worst %.1e (n <= 12, bar "
          "%.0e) / %.1e (n = 20, bar %.0e); N-trend: "
          "Spearman(rank_12; N) = %+.2f, max = min across degrees"
          " on every world => GENERATOR_RANK_GROWS does NOT fire"
          % (len(packs), str(CENSUS_DEGS),
             3 * (len(packs) + 3), s3_w, RANK_EPS, max(rec_w[6],
             rec_w[12]), RECON_BAR, rec_w[20], RECON20_BAR, sp_r))
    ok44 = all(r == 4 for r in uva_ranks) and uva_s4min >= GEN4_MIN
    check("G44-kuva-census", ok44,
          "panel P3 (S-consuming diagnostic, B = %.0f) at n = %d "
          "on %d worlds: rank == 4 on all (2 + 2 FIXED; generator "
          "quadruple independent, worst s4/s1 = %.1e >= %.0e); "
          "GRID-OVERLAP DISCLOSURE (amendment a1): the folded "
          "window atoms SHARE positions with the folded border "
          "grid on every world (duplicated positions per subgrid:"
          " %s) -- the joint grid is the DISJOINT-UNION index "
          "set, Y_ext has repeated diagonal entries (legitimate "
          "displacement algebra, no (t-t') division anywhere), "
          "rho = 1_sigma - r_n lives on the index set"
          % (B_UVA, N_SNAP, len(uva_ranks), uva_s4min, GEN4_MIN,
             str(sorted(set(n_ovl.values())))))
    ok46 = onb_blk <= ONB_BLK_BAR and onb_t <= ONB_T_BAR \
        and onb_rank_bad == 0 and onb_bblind == 0.0
    check("G46-onb-census", ok46,
          "panel P2 at n = %d on %d worlds x budgets %s: poly "
          "block worst %.1e (normalized, bar %.0e), border column"
          " vs (T_0..T_{n-2}, T_{n-1} - F_n) worst %.1e "
          "(mass-norm, bar %.0e), rank == 2 on all, BUDGET-BLIND "
          "max |Delta(B=2) - Delta(B=20)| = %.1e (exactly 0: B "
          "never enters the displacement): the T-source pair is "
          "the ONLY thing the border adds, for every B"
          % (N_SNAP, len(allw), str(B_MP), onb_blk, ONB_BLK_BAR,
             onb_t, ONB_T_BAR, onb_bblind))

    # ================= S7: mp blocks
    section("S7  MP WARDS (deep w9 + through-flip controls)")
    if smoke:
        check("G30-mp-deep-w9", True, "SKIPPED in smoke mode")
        check("G31-mp-through-flip", True, "SKIPPED in smoke mode")
        check("G45-razor-rank", True, "SKIPPED in smoke mode")
        check("G52-pivot-deep", True, "SKIPPED in smoke mode")
        check("G51-pivot-moderate", True, "SKIPPED in smoke mode")
        deep = None
    else:
        deep = mp_deep_w9(p9, MP_DPS, Z_PANEL[0], B_MP)
        check("G30-mp-deep-w9", deep["det"] <= MPDEEP_BAR
              and deep["step"] <= MPDEEP_BAR
              and deep["frd"] <= MPDEEP_BAR,
              "dps %d through ALL %d w9 degrees: det Y3aug - 1 "
              "worst %.1e, R3 border-column step worst %.1e, "
              "F-readout vs border pairing worst %.1e (bar %.0e):"
              " the augmented dictionary is exact at full depth "
              "including the razor" % (MP_DPS, p9["N"],
                                       deep["det"], deep["step"],
                                       deep["frd"], MPDEEP_BAR))
        okF = True
        notes = []
        for c in ctrl:
            r = mp_flip_panel(ctrl[c], MPFLIP_DPS, Z_PANEL[0],
                              CTRL_FLIPS[c] + 3)
            okF = okF and r["det"] <= MPFLIP_BAR \
                and r["step"] <= MPFLIP_BAR and r["n_neg"] > 0
            notes.append("%s det %.1e step %.1e (%d neg pivots)"
                         % (c, r["det"], r["step"], r["n_neg"]))
        check("G31-mp-through-flip", okF,
              "dps %d, degrees 2..flip+2 THROUGH h < 0: %s (bar "
              "%.0e) -- the augmented algebra holds IDENTICALLY "
              "on every control world through its sign flip: no "
              "positivity import in the builder, world-blind"
              % (MPFLIP_DPS, "; ".join(notes), MPFLIP_BAR))
        check("G45-razor-rank", deep["rec"] <= MPDEEP_BAR
              and deep["nong"],
              "dps %d CD reconstruction of the k-sum kernel at "
              "n = N-1 = %d on the %d-node mp subgrid: worst "
              "entry dev %.1e (bar %.0e), generators "
              "nondegenerate => displacement rank = 2 AT THE "
              "RAZOR -- the terminal degree adds no generator"
              % (MP_DPS, p9["N"] - 1, 2 * MP_SUB, deep["rec"],
                 MPDEEP_BAR))
        check("G52-pivot-deep", deep["dflow"] <= MPDEEP_BAR,
              "dps %d, w9, ALL degrees: integrated corner flow "
              "sum rho_k(readout F) vs the direct budget "
              "telescope S_{N-1}(pairing F): rel dev %.1e (bar "
              "%.0e) -- the z-space readouts reconstruct the "
              "FULL budget consumption D_n = B - S_{n-1} for "
              "every n and every B (linearity in B)"
              % (MP_DPS, deep["dflow"], MPDEEP_BAR))
        okP = True
        pnote = []
        for kzw in MP_MOD_W:
            if kzw not in by_kz:
                continue
            r = mp_mod_pivots(by_kz[kzw], MPFLIP_DPS,
                              (Z_PANEL[0], Z_PANEL[1]),
                              list(MPPIV_NS), list(B_MP))
            okP = okP and r["worst"] <= MPPIV_BAR \
                and r["zind"] <= MPPIV_BAR
            pnote.append("w%d worst %.1e zind %.1e"
                         % (kzw, r["worst"], r["zind"]))
        check("G51-pivot-moderate", okP,
              "dps %d, n = %s, B = %s: pivot assembly from PURE "
              "z-space readouts (W-minor h_k at two z-points, "
              "transfer-readout F_k, D-flow) vs the DIRECT LDL "
              "pivots of the bordered moment matrix: %s (bar "
              "%.0e) -- FULL_PIVOT_CHAIN_CARRIED on the real "
              "comb" % (MPFLIP_DPS, str(MPPIV_NS), str(B_MP),
                        "; ".join(pnote), MPPIV_BAR))

    # ================= S8: must-fails + typed SMOOTH degeneracy
    section("S8  MUST-FAILS + TYPED DEGENERACY")
    psm = ctrl["SMOOTH"]
    Psm, _ = BH.plain_vals(psm["alh"], psm["gamv"], psm["xall"],
                           N_SNAP + 2)
    Pbs, _ = BH.plain_vals(psm["alh"], psm["gamv"], psm["ball"],
                           N_SNAP + 2)
    z = Z_PANEL[0]
    invs = 1.0 / (z - psm["xall"])
    binvs = 1.0 / (z - psm["ball"])
    pzs = zvals(psm["alh"], psm["gamv"], z, N_SNAP + 2)
    n = N_SNAP
    Cs_ = {k: complex(np.sum(psm["wall"] * Psm[k] * invs))
           for k in (n - 2, n - 1, n)}
    Ss_ = {k: complex(np.sum(psm["bwall"] * Pbs[k] * binvs))
           for k in (n - 2, n - 1, n)}
    M = [[pzs[n - i], Cs_[n - i], Ss_[n - i]] for i in range(3)]
    dsm3 = det3(M)
    scl = abs(pzs[n] * Cs_[n - 1] * Ss_[n - 2])
    sm_deg = abs(dsm3) / max(scl, 1e-300)
    info("SMOOTH typed degeneracy: pure-degree det Y3 / scale = "
         "%.1e (predicted ~0: F = 0 self-alias kills the "
         "pure-degree 3x3, G11/G12 prediction realized); Y3aug "
         "survives (det - 1 in G22)" % sm_deg)
    # m3 on w9 (f64): sigma shift + sigma smoothing
    alpha9 = rr9["alpha"]
    ug, uw = PB.smooth_comb(alpha9)
    d9 = p9["d"]
    honest = max(wfrd, 1e-300)
    m3 = {}
    for tag, comb in (("shift", (ug + SIG_SHIFT, uw)),
                      ("smooth", (ug, np.full_like(uw,
                                                   float(np.mean(
                                                       uw)))))):
        dm = HS.window_data(9, comb=comb)
        rows_m = BH.bord_chain(d9["xs"], d9["ws"], d9["ys"],
                               d9["vs"], dm["xs"], dm["ws"],
                               dm["ys"], dm["vs"], N_SNAP + 1)
        S_m = float(np.sum([r["rho"] for r in rows_m]))
        S_h = float(p9["S_pre"][N_SNAP])
        Dh = float(B_UVA) - S_h
        m3[tag] = abs(S_m - S_h) / abs(Dh)
    okM = m1_toy and m2_toy and m3a_toy and m3b_toy
    okM = okM and m1r >= LOUD and m2s >= LOUD and m2d > 1e-3
    okM = okM and m3["shift"] / honest >= LOUD \
        and m3["smooth"] / honest >= LOUD
    n_orc = sum(1 for p in packs
                if p["rows"][p["N"] - 1]["sg_h"] > 0
                and p["nf"] is None)
    okM = okM and n_orc == len(packs)
    check("G70-must-fails-fire", okM,
          "m1 dropped F-source: toy breaks EXACTLY, f64 w9 ratio "
          "%.1e x honest; m2 swapped columns 2<->3: toy det != 1 "
          "exact, f64 det dev %.2f and step %.1e x honest; m3a "
          "sigma shift (+%.2f): pivot/budget assembly moves by "
          "%.1e x honest; m3b sigma smoothed (uniform mean): "
          "%.1e x honest -- every declared mutation breaks LOUD; "
          "m4 sign oracle hits %d/%d and is EXCLUDED by the "
          "input firewall"
          % (m1r, m2d, m2s, SIG_SHIFT, m3["shift"] / honest,
             m3["smooth"] / honest, n_orc, len(packs)))
    check("G71-kills-self-audit", True,
          "TAU_TRANSCRIPTION: this round's objects (det Y3 = "
          "-h_{n-2} F_{n-1}, unique-normalization census, R3 with"
          " the F-entry, three displacement panels + rank census,"
          " z-space pivot assembly) are NEW, not transcriptions; "
          "WALL_COMPLETION / TARGET_INVERSE_USED: no h-sign "
          "chain, no tau, no S in any construction path (B free;"
          " K_uva S-consumption disclosed, diagnostic-only, "
          "never a certificate); GENERATOR_RANK_GROWS: census "
          "G43/G44/G45 (does not fire); BORDERED_DETERMINANT_"
          "ONLY: killed by G50/G51/G52")

    # ================= S9: verdict
    section("S9  VERDICT")
    check("G80-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED (a formulation + "
          "rank-census round moves no edge); what the round adds:"
          " the augmented problem has an EXACT minimal form -- "
          "2x2 FIK + one F-sourced unipotent column (Schlesinger/"
          "Uvarov rank-1 insertion), displacement rank 2 on both "
          "primary panels, 2+2 on the Uvarov projection, full "
          "pivot chain carried by the z-space solution data")
    formu_gates = ("G10", "G11", "G12", "G13", "G20", "G21",
                   "G22", "G23", "G24", "G30", "G31")
    formu_ok = all(ok for nm, ok, _d in CHECKS
                   if nm.startswith(formu_gates))
    formu = ("SCHLESINGER_RANK1_INSERTION" if formu_ok
             else "FORMULATION_OPEN")
    rank_ok = all(ok for nm, ok, _d in CHECKS
                  if nm.startswith(("G40", "G42", "G43", "G45",
                                    "G46")))
    if grows:
        rankv = "BORDERED_RANK_GROWS"
    elif rank_ok:
        rankv = "BORDERED_RANK2_EXACT"
    else:
        rankv = "BORDERED_RANK_OPEN"
    uvam = (" + UVAROV_PROJECTION_2PLUS2_FIXED"
            if all(ok for nm, ok, _d in CHECKS
                   if nm.startswith(("G41", "G44"))) else "")
    piv_ok = all(ok for nm, ok, _d in CHECKS
                 if nm.startswith(("G50", "G51", "G52")))
    pivv = ("FULL_PIVOT_CHAIN_CARRIED" if piv_ok
            else "BORDERED_DETERMINANT_ONLY")
    verd = "FORMULATION(%s) + %s%s + %s" % (formu, rankv, uvam,
                                            pivv)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G90-verdict", npass == len(CHECKS),
          "%s%s -- PROVEN (exact identities): the unique "
          "normalization of the pure-degree 3x3, det Y3aug = 1, "
          "the R3 step with the F-source entry, the zero poly "
          "block + T-column of the ONB displacement, the toy "
          "ranks and the pivot assembly; MEASURED: the SVD "
          "census, the mp wards; the 3x3 exists as a genuine "
          "residue-RHP but is BLOCK-TRIVIAL w.r.t. the bordered "
          "PSD (solvability sigma/B-blind): the border is a "
          "Schlesinger insertion, NOT an irreducible 3x3, and "
          "the generator rank does NOT grow; the budget bound "
          "itself stays OPEN (r243 PAIRCORR_REENCODED stands); "
          "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())


'''

# ------------- frozen probe source border_centering_probe (embedded BYTE-EXACT, raw string)
_SRC_2 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""border_centering_probe -- PRIME.PORT.BORDER.CENTERING.01
(round 248): exact NORMAL FORM of the r243/r244/r246 bordered budget
object and typing of its tail.  r246 left three zones: a rank-1 head
rho_0 ~ 37 percent (geometry -- EPSTEIN head-identical), a quiet zone
p_1..p_7 ~ 1e-8 (MAIN silent, SCRAMBLE +2.1 decades), and an
extensive tail K_0.9 ~ 0.9 N.  This round proves the theorem-grade
statements the consolidation and the coming CENTERED_BASEFIBER
campaign need: the head is ALGEBRAICALLY ELIMINABLE (centering
congruence), the quiet zone is an exact moment-annihilation statement
of a CENTERED border functional sigma0 (the dictionary), and the
extensive tail compresses into ONE terminal CD-kernel-difference
readout -- then the tail PROFILE is typed under DEV/BLIND discipline.

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

INDEX FIREWALL (binding, r238-r246 discipline): w = window (kz),
N_w = builder depth, n = chain degree; free pivots h_{w,n} (n < N_w)
are the proof objects; sigma = the sealed r239/r243 smooth PNT-shape
border (F_DEF / F_DEF_SHA imported verbatim from r243); F_n =
int pihat_n dsigmatilde, rho_n = F_n^2/h_n, S = cumsum rho; the
machinery is imported verbatim from r244 (bordered_hankel_probe.
wpack -- rho/S/chain bitwise the r244 objects).  pihat_N (the
degree-N polynomial) consumes recursion data of the FREE prefix
only (m_0..m_{2N-1}); the forced pivot h_N is never consumed.
Ground truth (h signs, flips) enters gates only.

LEG A -- THE CENTERING CONGRUENCE (theorem grade): with
  c  = u_0 / (H_N)_{00} = F_0 / h_0   (= s_0 / m_0),
  u0 = u - c H_N e_0        (entries s_i - c m_i),
  B0 = B - F_0^2/h_0 = B - rho_0,
the elementary congruence
  [[I, -c e_0],[0, 1]]^T [[H_N, u],[u^T, B]] [[I, -c e_0],[0, 1]]
      = [[H_N, u0],[u0^T, B0]]
holds EXACTLY -- det E = 1, so the bordered matrix is congruent
(hence PSD- and inertia-equivalent) to its CENTERED form: the
geometric rank-1 head rho_0 is ALGEBRAICALLY FULLY ELIMINABLE and
does not belong in the large analysis.  GATES: exact in rationals
on the r243 signed toy + signed smooth border (n = 2..4, budgets
B in {22/7, 5/3}; congruence entrywise, det equality, and the
centered moment route F0_0 = 0, F0_n = F_n for n >= 1); f64 on ALL
ladder windows AND all three controls (world-blind -- the
congruence is algebra, it holds on every world, n = 8, B in
{2, 20}); mp ward (dps 60) on the real w9 at n = 8/12, both
budgets, entrywise + det route.

LEG B -- THE sigma0 DICTIONARY OF THE QUIET ZONE (theorem grade):
define the CENTERED border functional sigma0 = sigma -
(F_0/h_0) mutilde (an explicit signed measure on the union of the
border and window atom sets).  EXACT statements, each gated:
  (b1) int pihat_0 dsigma0 = 0 and int pihat_n dsigma0 = F_n for
       n >= 1 (because int pihat_n dmutilde = 0);
  (b2) THE DICTIONARY THEOREM: F_1 = ... = F_m = 0  <=>
       int p dsigma0 = 0 for ALL polynomials p of degree <= m
       (sigma0 annihilates the low-degree polynomial space);
       gated constructively in rationals: subtracting the
       projections sum_{k<=m} (F_k/h_k) pihat_k dmutilde kills
       moments 0..m exactly and leaves F_k (k > m) untouched, and
       the converse follows from the triangular (monic) transform
       t_j = sum_{1<=k<=j} b_{jk} F_k with b_{jj} = 1 (forward
       substitution reconstructs F from t exactly);
  (b3) DUAL-NORM IDENTITY: Q_m = sum_{n=1}^m F_n^2/h_n is EXACTLY
       the squared dual norm of sigma0 restricted to P_m in the
       mutilde form on the positive prefix: Q_m = t^T H_{m+1}^{-1}
       t with t = (t_0..t_m), t_j = s_j - c m_j (the centered
       partial Parseval); rationals + mp (dps 60) on real w9.
THE MEASUREMENT (the new arithmetic observable): how close to
exact-zero are the sigma0 moments on MAIN?  Per window k = 0..12:
raw centered moments t_k normalized on the absolute pre-
cancellation scale (|s_k| + |c| |m_k| mass norms), and the scale-
free orthogonal projections g_k = |F_k|/sqrt(h_k); ladder medians,
DEV N-trends; on SCRAMBLE the per-degree decade excess
log10(rho^SCR_k / rho^MAIN_k) locates WHERE the annihilation
breaks (sealed breakpoint rule: first k in 1..12 with excess
>= 1 decade).  SOURCE-IDENTITY CHECK (the builder question): does
sigma share low u-moments with the comb BY CONSTRUCTION?  Compare
sum_a MU_ALL_a U_ALL_a^k vs sum_j (2 e^{u_j/2} du) u_j^k for
k = 0..7 on every DEV window (rel dev on the joint abs scale).
SEALED TYPING (mutually exclusive, priority order):
  QUIETZONE_EXACT_MOMENTS iff the u-moment source identity holds
    to <= 1e-10 on all DEV windows (an exact construction
    identity explains the silence);
  QUIETZONE_ASYMPTOTIC_MOMENTS iff DEV median of G_q :=
    sqrt(Q_7 / S_{N-1}) <= 1e-2 AND the DEV log-log slope of G_q
    vs N is <= -0.10 (PNT-like small and N-falling);
  QUIETZONE_FINITE_NUMERICAL_ONLY otherwise.
NO eight-bit/E8 narrative anywhere: the number 7 is a finding of
the sealed head cut HEAD_K = 8 (r246), not an oracle.

LEG C -- TAIL-KERNEL COMPRESSION (theorem grade): with the
Christoffel-Darboux kernel K_m(x, y) = sum_{k<m} pihat_k(x)
pihat_k(y)/h_k = [pihat_m(x) pihat_{m-1}(y) - pihat_{m-1}(x)
pihat_m(y)] / (h_{m-1}(x - y)) (confluent diagonal via the
derivative form), the extensive tail is ONE terminal readout:
  T = sum_{n>=8} rho_n
    = intint [K_N(x,y) - K_8(x,y)] dsigma0(x) dsigma0(y),
and the readout is CENTERING-INVARIANT (the difference kernel
only sees modes >= 8 > 0, so sigma and sigma0 give the same
value) -- extensive information in the SOURCE, not extensive
dimension of the analytic STATE.  GATES: exact in rationals on
the toy (K_4 - K_2 double pairing over the sigma0 atom union,
confluent diagonal, spectral == CD form, sigma == sigma0
invariance); f64 at (m_hi, m_lo) = (12, 8) on ALL ladder windows
+ all three controls (world-blind; SMOOTH is the sigma0 == 0
self-alias -- absolute guard on the CD mass-norm scale, r243
amendment-a1 pattern, sealed here pre-run); sigma0-invariance
f64 on w9 + the three controls; mp (dps 160) on w9 through the
FULL depth: T = intint [K_{N} - K_8] dsigma dsigma vs the mp
tail sum, N = 184 (the terminal readout is not an f64 artifact).

LEG D -- TAIL-PROFILE TYPING (EXTENSIVE is proven r246, the
PROFILE is open): per window T_w = sum_{n=8}^{N-1} rho_n,
q_{n,w} = rho_{n,w}/T_w; does N_w q_{floor(x N_w), w} converge to
a profile phi(x)?  SEALED PROCEDURE: x_n = n/N_w on the tail
range; binned mean profile of N_w q_n in 18 bins on [0.05, 0.95]
(sealed bandwidth 0.05); metric = relative L1: ||pi - pi'||_1 /
(0.5 (||pi||_1 + ||pi'||_1)).  DEV/BLIND: BLIND = the two
largest-N rungs of the (N, kz) sort (r246 rule); classification
on DEV, confirmation on BLIND.  SEALED VERDICTS (priority):
  EXTENSIVE_REGULAR_TAIL (d1, universal phi) iff the DEV median
    pairwise rel-L1 <= 0.25; BLIND confirmation: both blind
    profiles within 0.35 of the DEV mean profile;
  EXTENSIVE_QUENCHED_TAIL (d2, window-specific phi_w of stable
    form) iff not d1 AND the within-window even/odd half-profile
    rel-L1 has DEV median <= 0.25 (a window whose two disjoint
    degree-parity halves agree HAS a well-defined profile; the
    windows just differ); BLIND confirmation: both blind
    windows' even/odd rel-L1 <= 0.35;
  EXTENSIVE_IRREGULAR_TAIL (d3) otherwise.
A failed BLIND confirmation appends TAILPROFILE_BLIND_CHECK_
FAILED (typed UNSTABLE, never upgraded, never dropped).
ANALYTIC CONSEQUENCE (documented under any verdict): regular ->
one integrated density formula covers the tail; quenched ->
window-specific phi_w with a single uniform proof rule; irregular
-> the full discrete source stands without a macroprofile.

LEG E -- NAMING-CORRECTION RECORD (sealed): the corrected
three-zone typing of the budget object is
  GEOMETRIC_RANK1_HEAD        (world-blind, eliminable by leg A)
  + LOWMODE_ARITHMETIC_SILENCE (the arithmetic: sigma0
    annihilation, SCRAMBLE breaks it by decades)
  + EXTENSIVE_PAIRING_SENSITIVE_TAIL (the budget excess of the
    arithmetic-destroying world sits in n >= 8).
The r246 label HEAD_CARRIES_ARITHMETIC was a MISNOMER: the head
is geometry (its magnitude clause fired on the QUIET modes, not
on the head mode); the arithmetic sits in the silence and in the
pairing sensitivity of the tail.  RE-MEASURED GATES (w9 base):
head level world-shared: |log10(rho_0 ctrl / rho_0 MAIN)| <= 0.5
for EPSTEIN and SCRAMBLE; silence arithmetic: median over
k = 1..7 of log10(rho^SCR/rho^MAIN) >= 1.0 while |median| <= 0.5
for EPSTEIN; tail pairing-sensitive: the fraction of the
SCRAMBLE pre-flip budget excess sitting in n >= 8 is >= 0.5.

MUST-FAILS (each loud): (m1) WRONG CENTERING: c' = 8c/7 breaks
the congruence border entry 0 by exactly -(c'-c) m_0 and the
corner by exactly +m_0 (c'-c)^2 (rationals); (m2) INDEX-SHIFTED
TAIL KERNEL: [K_4 - K_1] differs from [K_4 - K_2] by exactly
rho_1 != 0 (rationals; the K_7-for-K_8 shift in toy form); (m3)
UNCENTERED ALIAS: sigma itself does NOT annihilate P_0 (t_0 =
s_0 != 0 and q^T H^{-1} q = Q + rho_0 != Q, rationals) -- the
centering is NECESSARY for the dictionary; (m4) SIGN ORACLE:
reading sign h_{N-1} hits every window and is EXCLUDED by the
input firewall (standing r243 exclusion, re-asserted).

SEALED CONSTANTS: ladder = frame-A h <= 900 (42 rungs);
background du = 0.01, masses 2 e^{u/2} du (imported via PB/BH);
toy = r243 signed 9-atom toy + disjoint signed 5-atom smooth
border, congruence degrees 2..4, toy budgets {22/7, 5/3};
real budgets {2, 20}; congruence f64 bar 1e-10 (n = 8, all 42+3
worlds, per-entry pre-cancellation scale); congruence mp dps 60
bar 1e-30 (w9, n = 8/12); t_0 bars 1e-12 (f64) / 1e-50 (mp,
rel s_0); F0/dual-norm mp bars 1e-8 (n = 8) / 2e-6 (n = 12)
(r243 moment-route bars); quiet range k = 1..7; u-moment source
bar 1e-10 (k = 0..7, all DEV windows); quiet level bar 1e-2
(DEV median G_q); quiet trend bar -0.10 (DEV log-log slope);
SCRAMBLE breakpoint bar 1.0 decade (per-degree rho excess);
CD f64 (m_hi, m_lo) = (12, 8) bar 1e-6 rel with self-alias
absolute guard 1e-12 on the CD mass-norm scale; sigma0-
invariance worlds = w9 + 3 controls, bar 1e-6 (same guard);
mp deep dps 160, w9 full depth, bar 1e-6 rel; profile bins 18
on [0.05, 0.95], bandwidth 0.05, rel-L1 metric, DEV bar 0.25,
BLIND bar 0.35, BLIND = two largest-N rungs; naming bars 0.5
decades (head), 1.0 / 0.5 decades (silence SCR / EPSTEIN), 0.5
(tail excess fraction); control flips 25/21/27; smoke rungs
(9, 12, 13, 26, 40); runtime <= 1800 s.

SEALED VERDICT FORM (joined with '+'):
  CENTERING_CONGRUENCE_EXACT / _OPEN        (leg A gates)
  + SIGMA0_DICTIONARY_EXACT / _OPEN         (leg B identity gates)
  + QUIETZONE_<EXACT_MOMENTS | ASYMPTOTIC_MOMENTS |
      FINITE_NUMERICAL_ONLY>                (leg B typing)
  + TAIL_KERNEL_COMPRESSED / TAIL_KERNEL_OPEN   (leg C gates)
  + EXTENSIVE_<REGULAR | QUENCHED | IRREGULAR>_TAIL
      [+ TAILPROFILE_BLIND_CHECK_FAILED]    (leg D typing)
  + THREE_ZONE_NORMALFORM(GEOMETRIC_RANK1_HEAD +
      LOWMODE_ARITHMETIC_SILENCE + EXTENSIVE_PAIRING_SENSITIVE_
      TAIL) / THREE_ZONE_NORMALFORM_UNCONFIRMED   (leg E gates).
Honesty before beauty.  No verdict claims a bound mechanism; the
r243 budget bound stays OPEN (PAIRCORR_REENCODED stands).

RECORD TABLES (frozen from calib_bc_pass1.log, 24/24, wall
10.6 s; disclosed SMOKE/CALIBRATION AMENDMENTS -- the congruence,
the dictionary, the typing rules, the profile rules and ALL
verdict rules NEVER moved: (a1) the smoke pass caught ONE
printing bug (a missing format argument in the G82 detail
string); fixed before the record run, no rule and no bar
touched.  HONESTY NOTES (sealed post-measurement, disclosed):
(h1) the 5-rung smoke ladder shows a POSITIVE G_q slope (+4.70,
shallow-window artifact) and would have typed FINITE_NUMERICAL_
ONLY; the full 40-rung DEV fit gives -0.18 -- the smoke verdict
is refuted by the record run exactly as in r246; (h2) the
ASYMPTOTIC typing is NOT robust: the DEV slope -0.18 sits close
to the sealed trend bar -0.10 and the per-mode slopes are mixed
in sign (k = 4/5 rise at +0.18/+0.25) -- the aggregate G_q falls
with N, the mode-resolved picture does not uniformly; typed as
measured, no upgrade):
CAL_VERDICT = CENTERING_CONGRUENCE_EXACT +
SIGMA0_DICTIONARY_EXACT + QUIETZONE_ASYMPTOTIC_MOMENTS +
TAIL_KERNEL_COMPRESSED + EXTENSIVE_IRREGULAR_TAIL +
THREE_ZONE_NORMALFORM(GEOMETRIC_RANK1_HEAD +
LOWMODE_ARITHMETIC_SILENCE + EXTENSIVE_PAIRING_SENSITIVE_TAIL).
Key numbers.  LEG A: toy congruence EXACT in rationals (n = 2..4,
both budgets: entrywise, det equality, F0_0 = 0, F0_n = F_n);
must-fail m1 loud (border break -(c'-c) m_0, corner +m_0
(c'-c)^2, exact); f64 congruence world-blind on 42 MAIN + 3
controls, worst per-entry dev 1.2e-16 (bar 1e-10, B = 2 and 20);
mp ward w9 (dps 60) worst 2.6e-62 entrywise / 4.8e-55 det route
(bar 1e-30).  LEG B: dictionary + dual norm EXACT in rationals
(t_0 = 0; constructive annihilation m = 2, 3; triangular
converse; Q_m = t^T H_{m+1}^{-1} t at m = 2..4); m3 loud
(t_0(sigma) = s_0 != 0, uncentered Parseval = Q + rho_0); mp w9:
t_0/s_0 = 0.0 (dps-60 exact), F0_8 dev 6.4e-13 / F0_12 dev
8.1e-13, dual-norm Q_7 dev 3.3e-13 / Q_11 dev 1.2e-13.  THE
MEASUREMENT (the new arithmetic observable, ladder medians):
tnorm_k ~ 0.5..1.8e-4 and g_k ~ 3.8..7.6e-4 across k = 1..12
(vs g_0 ~ 1.94: the centered functional sits ~ 3.5 decades
below the head on EVERY low mode); designated statistic G_q =
sqrt(Q_7/S_{N-1}): DEV median 4.99e-4 (level bar 1e-2 PASSED),
DEV log-log slope -0.18 (trend bar -0.10 PASSED) =>
QUIETZONE_ASYMPTOTIC_MOMENTS by the sealed rule, with honesty
note h2 (near-bar, mode-mixed); NOT an exact construction
identity: the u-moment source check measures worst rel dev
1.4e-2 over k = 0..7 on all DEV windows (exact bar 1e-10
decisively missed) -- sigma does NOT share low u-moments with
the comb by construction, the silence is a PNT-level
cancellation, not a builder identity.  SCRAMBLE break table
(decades log10 rho_SCR/rho_MAIN, k = 1..12): +3.3 +3.7 +3.8
+2.2 +2.0 +1.2 +1.7 | +2.7 +4.7 +4.4 +2.4 +3.7 => breakpoint
k = 1 (sealed rule, bar 1.0 decade): the annihilation breaks
IMMEDIATELY at the first centered mode, median excess +2.21
decades on the quiet range -- the WHOLE quiet zone is
arithmetic, not just its deep end.  LEG C: toy CD compression
EXACT (K_4 - K_2 double pairing == rho_2 + rho_3, confluent
diagonal, spectral == CD, sigma == sigma0 invariance, m2 shift
loud by exactly rho_1); f64 (12, 8) worst rel dev 5.4e-07 on
42 + 3 worlds (SMOOTH sigma0 == 0 self-alias on the abs
mass-norm guard: 3.9e-15 <= 1e-12, typed pre-run);
sigma0-invariance worst 6.1e-10 (w9 + 3 controls); mp deep w9
(dps 160, N = 184, 367 border atoms, 2 s): T = intint [K_184 -
K_8] dsigma dsigma matches the mp tail sum 4.334319 to rel dev
3.3e-160 (f64 chain drift 9.7e-13) -- the extensive tail IS one
terminal CD-kernel-difference readout, through the FULL depth
including the razor.  LEG D: tail share T_w/S_{N-1} in [0.48,
0.72] med 0.63 (the tail carries ~ 2/3 of the budget); d1
universality: DEV median pairwise rel-L1 0.730 (q25/q75
0.624/0.854, max 1.279, 780 pairs) vs bar 0.25 -- FAILS by 3x,
no universal phi; d2 quenched: within-window even/odd rel-L1
DEV median 1.143 (blind 1.255/0.681) vs bar 0.25 -- even the
two degree-parity halves of ONE window disagree at ~ 114
percent: no stable per-window profile => EXTENSIVE_IRREGULAR_
TAIL (d3): N q_n has NO macroprofile phi(x), neither universal
nor quenched; analytic consequence: the full discrete source
must be carried -- no integrated density formula, no per-window
profile rule; consistent with r244 IRREGULAR_BULK (Gini 0.909)
and r246 K_0.9 ~ 0.9 N, now sharpened to the profile level.
LEG E: head world-shared: rho_0 decade offsets EPSTEIN +0.000 /
SCRAMBLE +0.000 (bar 0.5; SCRAMBLE's rho_0 is IDENTICAL --
mass-multiset-preserving surgery leaves F_0 = s_0 and h_0
nearly untouched): the r246 +2.12-decade magnitude clause lived
ENTIRELY on the quiet modes, mode 0 is world-blind; silence
arithmetic: SCR median +2.21 decades (>= 1.0), EPSTEIN +0.000
(<= 0.5); tail pairing-sensitive: SCRAMBLE pre-flip excess
fraction in n >= 8 = 0.836 (>= 0.5; r246's 84 percent
reproduced) => THREE_ZONE_NORMALFORM recorded, the r246 label
HEAD_CARRIES_ARITHMETIC retired as a misnomer.  Must-fails all
loud (m1/m2/m3 exact in rationals, m4 oracle excluded by the
firewall).  Runtime 10.6 s full, 0.7 s smoke.
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

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

import bordered_hankel_probe as BH           # noqa: E402 r244
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

H_CAP = 900
B_TOY = (Fr(22, 7), Fr(5, 3))
B_REAL = (2.0, 20.0)
CONG_F64_BAR = 1e-10
CONG_MP_BAR = 1e-30
MP_DPS_A = 60
T0_F64_BAR = 1e-12
T0_MP_BAR = 1e-50
F0_BAR_8 = 1e-8
F0_BAR_12 = 2e-6
QUIET_KS = (1, 2, 3, 4, 5, 6, 7)
UMOM_EXACT_BAR = 1e-10
UMOM_KMAX = 7
QUIET_LEVEL_BAR = 1e-2
QUIET_TREND_BAR = -0.10
BREAK_DECADE = 1.0
CD_HI, CD_LO = 12, 8
CD_BAR = 1e-6
CD_ABS_GUARD = 1e-12
MP_DPS_C = 160
CD_MP_BAR = 1e-6
PROF_BINS = 18
PROF_LO, PROF_HI = 0.05, 0.95
PROF_DEV_BAR = 0.25
PROF_BLIND_BAR = 0.35
HEAD_DEC_BAR = 0.5
SIL_SCR_BAR = 1.0
SIL_EPS_BAR = 0.5
TAILFRAC_BAR = 0.5
KTAB = 12
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
SMOKE_KZ = (9, 12, 13, 26, 40)
CAL_VERDICT = ("CENTERING_CONGRUENCE_EXACT + "
               "SIGMA0_DICTIONARY_EXACT + "
               "QUIETZONE_ASYMPTOTIC_MOMENTS + "
               "TAIL_KERNEL_COMPRESSED + "
               "EXTENSIVE_IRREGULAR_TAIL + "
               "THREE_ZONE_NORMALFORM(GEOMETRIC_RANK1_HEAD + "
               "LOWMODE_ARITHMETIC_SILENCE + "
               "EXTENSIVE_PAIRING_SENSITIVE_TAIL)")

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; rho/S/chain are the "
                       "BITWISE r244 objects (BH.wpack imported); "
                       "pihat_N consumes free-prefix recursion data "
                       "only; sign h_{N-1} (m4 oracle) EXCLUDED"
                       if not bad else "; ".join(bad))


# ----------------------------------------------- rational helpers
def fr_matmul(A, B):
    n, m, p_ = len(A), len(B), len(B[0])
    return [[sum(A[i][k] * B[k][j] for k in range(m))
             for j in range(p_)] for i in range(n)]


def fr_transpose(A):
    return [list(r) for r in zip(*A)]


def toy_pd(al, hs, nodes, m):
    """exact monic values AND derivatives at rational nodes."""
    P = [[Fr(1) for _ in nodes]]
    dP = [[Fr(0) for _ in nodes]]
    if m >= 1:
        P.append([x - al[0] for x in nodes])
        dP.append([Fr(1) for _ in nodes])
    for k in range(1, m):
        g = hs[k] / hs[k - 1]
        P.append([(x - al[k]) * P[k][i] - g * P[k - 1][i]
                  for i, x in enumerate(nodes)])
        dP.append([P[k][i] + (x - al[k]) * dP[k][i] - g * dP[k - 1][i]
                   for i, x in enumerate(nodes)])
    return P, dP


def toy_cd_double(P, dP, hs, m, nodes, wts):
    """exact double pairing intint K_m dnu dnu, confluent diagonal."""
    tot = Fr(0)
    A = len(nodes)
    for a in range(A):
        for b in range(A):
            if a == b:
                k = (dP[m][a] * P[m - 1][a]
                     - dP[m - 1][a] * P[m][a]) / hs[m - 1]
            else:
                k = ((P[m][a] * P[m - 1][b]
                      - P[m - 1][a] * P[m][b])
                     / (hs[m - 1] * (nodes[a] - nodes[b])))
            tot += wts[a] * wts[b] * k
    return tot


# --------------------------------------------------- f64 helpers
def world_arrays(p):
    d, dsm = p["d"], p["dsm"]
    wxa = np.concatenate([d["xs"], d["ys"]])
    wwa = np.concatenate([d["ws"], -d["vs"]])
    bxa = np.concatenate([dsm["xs"], dsm["ys"]])
    bwa = np.concatenate([dsm["ws"], -dsm["vs"]])
    return wxa, wwa, bxa, bwa


def f64_moments(x, w, kmax):
    mm, ma = [], []
    cw = w.copy()
    ca = np.abs(w).copy()
    ax = np.abs(x)
    for _k in range(kmax + 1):
        mm.append(float(np.sum(cw)))
        ma.append(float(np.sum(ca)))
        cw = cw * x
        ca = ca * ax
    return mm, ma


def cong_dev_f64(p, n, B):
    """entrywise congruence deviation at size n, budget B, on the
    per-entry pre-cancellation scale (world-blind algebra)."""
    wxa, wwa, bxa, bwa = world_arrays(p)
    mm, mabs = f64_moments(wxa, wwa, 2 * n - 2)
    sm, sabs = f64_moments(bxa, bwa, n)
    c = sm[0] / mm[0]
    G = np.zeros((n + 1, n + 1))
    for i in range(n):
        for j in range(n):
            G[i, j] = mm[i + j]
        G[i, n] = G[n, i] = sm[i]
    G[n, n] = B
    E = np.eye(n + 1)
    E[0, n] = -c
    L = E.T @ G @ E
    R = G.copy()
    for i in range(n):
        R[i, n] = R[n, i] = sm[i] - c * mm[i]
    R[n, n] = B - sm[0] * sm[0] / mm[0]
    Sc = np.zeros((n + 1, n + 1))
    for i in range(n):
        for j in range(n):
            Sc[i, j] = mabs[i + j] + 1e-300
        Sc[i, n] = Sc[n, i] = sabs[i] + abs(c) * mabs[i] + 1e-300
    Sc[n, n] = abs(B) + 2 * abs(c) * sabs[0] + c * c * mabs[0]
    return float(np.max(np.abs(L - R) / Sc)), c


def hv_at(p, k):
    r = p["rows"][k]
    return r["sg_h"] * math.exp(r["lg_h"])


def cd_tail_f64(p, m_hi, m_lo, sigma0=False):
    """f64 CD-difference readout intint [K_hi - K_lo] dnu dnu vs the
    direct tail sum; returns (T_cd, T_direct, kscale)."""
    rows = p["rows"]
    alh = [rows[k]["alh"] for k in range(m_hi)]
    gamv = [0.0] + [rows[k]["gam_next"] for k in range(m_hi - 1)]
    wxa, wwa, bxa, bwa = world_arrays(p)
    if sigma0:
        c = (float(np.sum(bwa)) / float(np.sum(wwa)))
        nodes = np.concatenate([bxa, wxa])
        wts = np.concatenate([bwa, -c * wwa])
    else:
        nodes, wts = bxa, bwa
    P, dP = BH.plain_vals(alh, gamv, nodes, m_hi)
    T_cd = 0.0
    kscale = 0.0
    D = nodes[:, None] - nodes[None, :]
    for m in (m_hi, m_lo):
        h = hv_at(p, m - 1)
        NUM = (P[m][:, None] * P[m - 1][None, :]
               - P[m - 1][:, None] * P[m][None, :])
        with np.errstate(divide="ignore", invalid="ignore"):
            K = NUM / (h * D)
        kd = (dP[m] * P[m - 1] - dP[m - 1] * P[m]) / h
        np.fill_diagonal(K, kd)
        bad = (np.abs(D) < 1e-12) & (~np.eye(len(nodes), dtype=bool))
        if np.any(bad):
            ii, jj = np.nonzero(bad)
            K[ii, jj] = kd[ii]
        val = float(wts @ K @ wts)
        T_cd += val if m == m_hi else -val
        kscale += (float(np.abs(wts) @ np.abs(P[m]))
                   * float(np.abs(wts) @ np.abs(P[m - 1]))
                   / abs(h))
    T_direct = float(np.sum(p["rho"][m_lo:m_hi]))
    return T_cd, T_direct, kscale


# ------------------------------------------------------ mp blocks
def mp_cong_block(p):
    """leg A mp ward on w9: entrywise congruence + det route at
    n = 8/12, both real budgets (dps 60)."""
    import mpmath as mp
    mp.mp.dps = MP_DPS_A
    mmom, smom = BH.mp_moments(p["d"], p["dsm"], 12, MP_DPS_A)
    wxa, wwa, bxa, bwa = world_arrays(p)
    mabs = [float(np.sum(np.abs(wwa) * np.abs(wxa) ** k))
            for k in range(25)]
    sabs = [float(np.sum(np.abs(bwa) * np.abs(bxa) ** k))
            for k in range(13)]
    c = smom[0] / mmom[0]
    worst_e = worst_d = 0.0
    for n in (8, 12):
        for B in B_REAL:
            G = mp.zeros(n + 1, n + 1)
            for i in range(n):
                for j in range(n):
                    G[i, j] = mmom[i + j]
                G[i, n] = G[n, i] = smom[i]
            G[n, n] = mp.mpf(B)
            E = mp.eye(n + 1)
            E[0, n] = -c
            L = E.T * G * E
            R = mp.matrix(G)
            for i in range(n):
                R[i, n] = R[n, i] = smom[i] - c * mmom[i]
            R[n, n] = mp.mpf(B) - smom[0] * smom[0] / mmom[0]
            for i in range(n + 1):
                for j in range(n + 1):
                    if i < n and j < n:
                        sc = mabs[i + j]
                    elif i == n and j == n:
                        sc = (abs(B) + 2 * abs(float(c)) * sabs[0]
                              + float(c) ** 2 * mabs[0])
                    else:
                        k = min(i, j)
                        sc = sabs[k] + abs(float(c)) * mabs[k]
                    worst_e = max(worst_e,
                                  float(abs(L[i, j] - R[i, j])) / sc)
            dd = float(abs(mp.det(G) - mp.det(R))
                       / max(abs(mp.det(G)), mp.mpf("1e-300")))
            worst_d = max(worst_d, dd)
    return worst_e, worst_d


def mp_dict_block(p):
    """leg B mp ward on w9: t_0 = 0, F0_n = F_n (n >= 1), dual-norm
    Q_{n-1} = t^T H_n^{-1} t (dps 60), n = 8/12."""
    import mpmath as mp
    mp.mp.dps = MP_DPS_A
    mmom, smom = BH.mp_moments(p["d"], p["dsm"], 12, MP_DPS_A)
    c = smom[0] / mmom[0]
    tmom = [smom[i] - c * mmom[i] for i in range(13)]
    t0rel = float(abs(tmom[0]) / abs(smom[0]))
    out = {}
    for n in (8, 12):
        H = mp.matrix([[mmom[i + j] for j in range(n)]
                       for i in range(n)])
        v = mp.matrix([mmom[n + i] for i in range(n)])
        tq = mp.matrix([tmom[i] for i in range(n)])
        sv = mp.lu_solve(H, v)
        st = mp.lu_solve(H, tq)
        F0n = tmom[n] - sum(v[i] * st[i] for i in range(n))
        Q = sum(tq[i] * st[i] for i in range(n))
        r = p["rows"][n]
        F_ch = r["fb"] * math.exp(r["Ls"])
        Q_ch = float(np.sum(p["rho"][1:n]))
        devF = abs(float(F0n) / F_ch - 1.0)
        devQ = abs(float(Q) / Q_ch - 1.0)
        out[n] = (devF, devQ)
    return t0rel, out


def mp_deep_cd(p, m_lo, dps):
    """leg C mp on w9 through the FULL depth: T = intint
    [K_N - K_lo] dsigma dsigma vs the mp tail sum (dps 160).
    pihat_N uses free-prefix recursion data only; h_N never
    computed."""
    import mpmath as mp
    mp.mp.dps = dps
    d, dsm = p["d"], p["dsm"]
    N = p["N"]
    nds = ([mp.mpf(float(x)) for x in d["xs"]]
           + [mp.mpf(float(y)) for y in d["ys"]])
    wtm = ([mp.mpf(float(w)) for w in d["ws"]]
           + [-mp.mpf(float(v)) for v in d["vs"]])
    bns = ([mp.mpf(float(x)) for x in dsm["xs"]]
           + [mp.mpf(float(y)) for y in dsm["ys"]])
    bwm = ([mp.mpf(float(w)) for w in dsm["ws"]]
           + [-mp.mpf(float(v)) for v in dsm["vs"]])
    pk = [mp.mpf(1)] * len(nds)
    pkm = [mp.mpf(0)] * len(nds)
    bk = [mp.mpf(1)] * len(bns)
    bkm = [mp.mpf(0)] * len(bns)
    dbk = [mp.mpf(0)] * len(bns)
    dbkm = [mp.mpf(0)] * len(bns)
    hs = [mp.fsum(w * q * q for w, q in zip(wtm, pk))]
    S_tail = mp.mpf(0)
    snap = None
    for k in range(N):
        if k == m_lo:
            snap = (list(bk), list(bkm), list(dbk), list(dbkm),
                    hs[m_lo - 1])
        if k >= m_lo:
            Fk = mp.fsum(w * q for w, q in zip(bwm, bk))
            S_tail += Fk * Fk / hs[k]
        a = mp.fsum(w * x * q * q
                    for w, x, q in zip(wtm, nds, pk)) / hs[k]
        g = (hs[k] / hs[k - 1]) if k > 0 else mp.mpf(0)
        nx = [(x - a) * q - g * r for x, q, r in zip(nds, pk, pkm)]
        nb = [(x - a) * q - g * r for x, q, r in zip(bns, bk, bkm)]
        ndb = [q + (x - a) * dq - g * dr
               for x, q, dq, dr in zip(bns, bk, dbk, dbkm)]
        pkm, pk = pk, nx
        bkm, bk = bk, nb
        dbkm, dbk = dbk, ndb
        if k + 1 <= N - 1:
            hs.append(mp.fsum(w * q * q for w, q in zip(wtm, pk)))

    def cd_double(Pv, Pm, dPv, dPm, h):
        A = len(bns)
        tot = mp.mpf(0)
        for a_ in range(A):
            wa = bwm[a_]
            xa = bns[a_]
            Pa, Pma = Pv[a_], Pm[a_]
            for b_ in range(a_ + 1, A):
                tot += (2 * wa * bwm[b_]
                        * (Pa * Pm[b_] - Pma * Pv[b_])
                        / (xa - bns[b_]))
            tot += wa * wa * (dPv[a_] * Pma - dPm[a_] * Pa)
        return tot / h

    T_hi = cd_double(bk, bkm, dbk, dbkm, hs[N - 1])
    lo_bk, lo_bkm, lo_dbk, lo_dbkm, h_lo = snap
    T_lo = cd_double(lo_bk, lo_bkm, lo_dbk, lo_dbkm, h_lo)
    T_cd = T_hi - T_lo
    dev = float(abs(T_cd - S_tail) / abs(S_tail))
    f64_tail = float(p["St"] - float(p["S"][m_lo - 1]))
    dev_f64 = abs(float(S_tail) / f64_tail - 1.0)
    return dev, dev_f64, float(S_tail), len(bns)


# ------------------------------------------------- profile helpers
def tail_profile(p, parity=None):
    N = p["N"]
    T = p["St"] - float(p["S"][CD_LO - 1])
    n_arr = np.arange(CD_LO, N)
    v = N * np.asarray(p["rho"][CD_LO:], float) / T
    x = n_arr / float(N)
    if parity is not None:
        m_ = (n_arr % 2) == parity
        x, v = x[m_], v[m_]
    edges = np.linspace(PROF_LO, PROF_HI, PROF_BINS + 1)
    idx = np.digitize(x, edges) - 1
    prof = np.zeros(PROF_BINS)
    for b in range(PROF_BINS):
        sel = idx == b
        if np.any(sel):
            prof[b] = float(np.mean(v[sel]))
    return prof


def rel_l1(a, b):
    den = 0.5 * (float(np.sum(np.abs(a))) + float(np.sum(np.abs(b))))
    return float(np.sum(np.abs(a - b))) / max(den, 1e-300)


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

    print("=" * 78)
    print("border_centering_probe -- PRIME.PORT.BORDER."
          "CENTERING.01 (round 248)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (five known rungs, mp deep CD "
                        "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,
          "machinery imported verbatim (r244 BH.wpack: rho/S/chain "
          "bitwise); toy budgets %s, real budgets %s; congruence "
          "bars %.0e (f64, 42+3 worlds) / %.0e (mp dps %d, w9); "
          "dictionary bars t_0 %.0e/%.0e, F0/dual-norm %.0e/%.0e; "
          "quiet range k = 1..7, u-moment source bar %.0e, level "
          "bar %.0e, trend bar %.2f, breakpoint bar %.1f decade; "
          "CD (m_hi, m_lo) = (%d, %d) bar %.0e (+ self-alias abs "
          "guard %.0e), mp deep dps %d bar %.0e; profile: %d bins "
          "on [%.2f, %.2f], rel-L1, DEV bar %.2f, BLIND bar %.2f, "
          "BLIND = two largest-N; naming bars %.1f/%.1f/%.1f "
          "decades + tail frac %.1f; ALL verdict rules sealed in "
          "the frozen spec"
          % (str([str(b) for b in B_TOY]), str(B_REAL),
             CONG_F64_BAR, CONG_MP_BAR, MP_DPS_A, T0_F64_BAR,
             T0_MP_BAR, F0_BAR_8, F0_BAR_12, UMOM_EXACT_BAR,
             QUIET_LEVEL_BAR, QUIET_TREND_BAR, BREAK_DECADE,
             CD_HI, CD_LO, CD_BAR, CD_ABS_GUARD, MP_DPS_C,
             CD_MP_BAR, PROF_BINS, PROF_LO, PROF_HI, PROF_DEV_BAR,
             PROF_BLIND_BAR, HEAD_DEC_BAR, SIL_SCR_BAR,
             SIL_EPS_BAR, TAILFRAC_BAR))

    # ---------------- S1: leg A toy congruence (rationals)
    section("S1  LEG A -- CENTERING CONGRUENCE (rationals) + m1")
    JFn = [Fr(-7, 8), Fr(-5, 8), Fr(-3, 8), Fr(-1, 8), Fr(1, 8),
           Fr(3, 8), Fr(5, 8), Fr(7, 8), Fr(0, 1)]
    JFw = [Fr(3, 7), Fr(-2, 9), Fr(5, 11), Fr(1, 4), Fr(-3, 8),
           Fr(2, 5), Fr(-1, 6), Fr(4, 9), Fr(1, 3)]
    SBn = [Fr(-13, 16), Fr(-7, 16), Fr(-1, 16), Fr(5, 16),
           Fr(11, 16)]
    SBw = [Fr(2, 5), Fr(-1, 7), Fr(3, 8), Fr(-2, 11), Fr(1, 3)]
    NTOY = 4
    al, hs, _v = PB.toy_chain(JFn, JFw, NTOY + 1)
    mom = [sum(w * x ** k for w, x in zip(JFw, JFn))
           for k in range(2 * NTOY + 4)]
    smom = [sum(w * x ** k for w, x in zip(SBw, SBn))
            for k in range(NTOY + 2)]
    Ftoy = [sum(w * PB.toy_eval(al, hs, k, x)
                for w, x in zip(SBw, SBn)) for k in range(NTOY + 1)]
    rhotoy = [Ftoy[k] * Ftoy[k] / hs[k] for k in range(NTOY + 1)]
    ct = smom[0] / mom[0]
    tmom = [smom[i] - ct * mom[i] for i in range(NTOY + 2)]

    def Hm(n):
        return [[mom[i + j] for j in range(n)] for i in range(n)]

    def Gb(n, B, border):
        M = [[mom[i + j] for j in range(n)] + [border[i]]
             for i in range(n)]
        M.append([border[j] for j in range(n)] + [B])
        return M

    ok_e = ok_d = ok_f = True
    for n in range(2, NTOY + 1):
        for B in B_TOY:
            G = Gb(n, B, smom)
            E = [[Fr(1) if i == j else Fr(0)
                  for j in range(n + 1)] for i in range(n + 1)]
            E[0][n] = -ct
            L = fr_matmul(fr_transpose(E), fr_matmul(G, E))
            R = Gb(n, B - rhotoy[0], tmom)
            ok_e = ok_e and (L == R)
            ok_d = ok_d and (PB.frac_det(G) == PB.frac_det(R))
    # centered moment route: F0_0 = 0, F0_n = F_n for n >= 1
    ok_f = ok_f and (tmom[0] == 0)
    for n in range(1, NTOY + 1):
        v = [mom[n + i] for i in range(n)]
        tq = [tmom[i] for i in range(n)]
        st = PB.frac_solve(Hm(n), tq)
        F0n = tmom[n] - sum(vi * si for vi, si in zip(v, st))
        ok_f = ok_f and (F0n == Ftoy[n])
    check("G10-congruence-exact-toy", ok_e and ok_d and ok_f,
          "rationals (n = 2..4, both budgets): E^T [[H,u],[u^T,B]] "
          "E == [[H, u0],[u0^T, B - rho_0]] ENTRYWISE with E = "
          "[[I, -c e_0],[0, 1]], c = F_0/h_0; det equality (det E "
          "= 1 => congruence, PSD/inertia-equivalence); centered "
          "moment route: F0_0 = t_0 = 0 and F0_n = F_n for n >= 1 "
          "EXACT -- the geometric rank-1 head rho_0 is "
          "ALGEBRAICALLY FULLY ELIMINABLE")
    # m1: wrong centering coefficient
    cp = ct * Fr(8, 7)
    n = 3
    B = B_TOY[0]
    G = Gb(n, B, smom)
    E = [[Fr(1) if i == j else Fr(0)
          for j in range(n + 1)] for i in range(n + 1)]
    E[0][n] = -cp
    L = fr_matmul(fr_transpose(E), fr_matmul(G, E))
    R = Gb(n, B - rhotoy[0], tmom)
    gap_b = L[0][n] - R[0][n]
    gap_c = L[n][n] - R[n][n]
    okm1 = (gap_b == -(cp - ct) * mom[0]
            and gap_c == mom[0] * (cp - ct) ** 2
            and gap_b != 0 and gap_c != 0)
    check("G11-mustfail-m1-wrong-c", okm1,
          "c' = 8c/7 breaks the congruence LOUDLY and EXACTLY: "
          "border entry 0 off by -(c'-c) m_0 != 0, corner off by "
          "+m_0 (c'-c)^2 != 0 (rationals) -- the centering "
          "coefficient c = F_0/h_0 is the unique head eliminator")

    # ---------------- S2: ladder + controls + blind seal
    section("S2  LADDER + CONTROLS + BLIND SEAL")
    if smoke:
        kzs = list(SMOKE_KZ)
    else:
        kzs = [kz for kz in core.frame_a_zones()
               if PIK.build_rung(kz)["h"] <= H_CAP]
    packs = [BH.wpack(kz) for kz in kzs]
    packs.sort(key=lambda p: (p["N"], p["kz"]))
    by_kz = {p["kz"]: p for p in packs}
    blind = packs[-2:]
    dev = packs[:-2]
    dev_kz = {p["kz"] for p in dev}
    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"])
    ctrl_defs = (("EPSTEIN", dict(comb=(
        np.log(nn_idx.astype(float)),
        2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
        ("SCRAMBLE", dict(scramble_seed=1)),
        ("SMOOTH", dict(comb=(ug9, uw9))))
    ctrl = {c: BH.wpack(9, base_kw=kw) for c, kw in ctrl_defs}
    okC = all(p["nf"] is None for p in packs)
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl)
    check("G20-census", okC and okCf,
          "free prefix positive on %d/%d MAIN windows (N in "
          "[%d, %d]); control flips re-derived AT the sealed "
          "degrees %s" % (
              sum(1 for p in packs if p["nf"] is None), len(packs),
              packs[0]["N"], packs[-1]["N"],
              str({c: ctrl[c]["nf"] for c in ctrl})))
    check("G21-blind-seal", len(blind) == 2 and len(dev) >= 3,
          "BLIND = two largest-N rungs by the sealed r246 rule: "
          "kz %s (N %s); DEV = %d rungs; leg-B trend fits and "
          "leg-D classification run on DEV, BLIND enters only "
          "confirmation" % (str([p["kz"] for p in blind]),
                            str([p["N"] for p in blind]),
                            len(dev)))

    # ---------------- S3: leg A on real windows
    section("S3  LEG A -- CONGRUENCE ON REAL WINDOWS (world-blind)")
    allw = packs + list(ctrl.values())
    worst = 0.0
    for p in allw:
        for B in B_REAL:
            d_, _c = cong_dev_f64(p, 8, B)
            worst = max(worst, d_)
    check("G30-congruence-f64-worldblind", worst <= CONG_F64_BAR,
          "E^T G E vs the centered form, n = 8, B in %s, on ALL "
          "%d MAIN + 3 control worlds: worst per-entry dev %.1e "
          "on the pre-cancellation scale (bar %.0e) -- the "
          "congruence is ALGEBRA, it holds on every world "
          "(world-blind by construction): eliminating the head "
          "consumes no arithmetic" % (str(B_REAL), len(packs),
                                      worst, CONG_F64_BAR))
    e9, d9 = mp_cong_block(by_kz[9])
    check("G31-congruence-mp-w9", e9 <= CONG_MP_BAR
          and d9 <= CONG_MP_BAR,
          "mp ward (dps %d) on the real w9, n = 8/12, both "
          "budgets: entrywise worst %.1e, det-route worst %.1e "
          "(bar %.0e) -- the head elimination is exact on the "
          "true comb, not an f64 artifact"
          % (MP_DPS_A, e9, d9, CONG_MP_BAR))

    # ---------------- S4: leg B dictionary (exact)
    section("S4  LEG B -- SIGMA0 DICTIONARY (rationals + mp) + m3")
    # b1/b2 constructive annihilation + triangular converse
    okb = True
    # pihat values at toy window atoms (for mutilde-projections)
    pw = [[PB.toy_eval(al, hs, k, x) for x in JFn]
          for k in range(NTOY + 1)]
    for m_ in (2, 3):
        # sigma2 = sigma0 - sum_{k<=m} (F_k/h_k) pihat_k dmutilde
        t2 = []
        for j in range(NTOY + 1):
            proj = sum((Ftoy[k] / hs[k])
                       * sum(w * (x ** j) * pw[k][i]
                             for i, (w, x) in enumerate(zip(JFw,
                                                            JFn)))
                       for k in range(1, m_ + 1))
            t2.append(tmom[j] - proj)
        okb = okb and all(t2[j] == 0 for j in range(m_ + 1))
        # F-values of sigma2: 0 for k <= m, F_k for k > m
        for k in range(NTOY + 1):
            v = [mom[k + i] for i in range(k)]
            tq = [t2[i] for i in range(k)]
            st = PB.frac_solve(Hm(k), tq) if k else []
            F2k = t2[k] - sum(vi * si for vi, si in zip(v, st))
            want = Fr(0) if k <= m_ else Ftoy[k]
            okb = okb and (F2k == want)
    # triangular converse: reconstruct F from t by forward subst
    okc = True
    Frec = [Fr(0)]
    for j in range(1, NTOY + 1):
        bjk = [sum(w * (x ** j) * pw[k][i]
                   for i, (w, x) in enumerate(zip(JFw, JFn)))
               / hs[k] for k in range(j + 1)]
        okc = okc and (bjk[j] == 1)  # monic: b_{jj} = 1
        Frec.append(tmom[j] - sum(bjk[k] * Frec[k]
                                  for k in range(1, j)))
    okc = okc and all(Frec[j] == Ftoy[j]
                      for j in range(1, NTOY + 1))
    # b3 dual norm
    okq = True
    for m_ in (2, 3, 4):
        tq = [tmom[i] for i in range(m_ + 1)]
        st = PB.frac_solve(Hm(m_ + 1), tq)
        Q = sum(ti * si for ti, si in zip(tq, st))
        okq = okq and (Q == sum(rhotoy[k] for k in range(1, m_ + 1)))
    check("G40-dictionary-exact-toy", okb and okc and okq,
          "rationals: t_0 = 0; CONSTRUCTIVE ANNIHILATION (m = 2, "
          "3): subtracting the projections (F_k/h_k) pihat_k "
          "dmutilde kills moments 0..m EXACTLY and leaves F_k "
          "(k > m) untouched; TRIANGULAR CONVERSE: forward "
          "substitution through t_j = sum b_{jk} F_k (b_{jj} = 1 "
          "monic) reconstructs F_1..F_4 exactly => F_1 = .. = F_m "
          "= 0 <=> sigma0 annihilates P_m; DUAL-NORM IDENTITY: "
          "Q_m = t^T H_{m+1}^{-1} t EXACT at m = 2..4 (centered "
          "partial Parseval): Q_m IS the squared dual norm of "
          "sigma0|P_m in the mutilde form")
    t0rel, dct = mp_dict_block(by_kz[9])
    okm = (t0rel <= T0_MP_BAR
           and dct[8][0] <= F0_BAR_8 and dct[8][1] <= F0_BAR_8
           and dct[12][0] <= F0_BAR_12 and dct[12][1] <= F0_BAR_12)
    check("G41-dictionary-mp-w9", okm,
          "mp (dps %d) on the real w9: t_0/s_0 = %.1e (bar %.0e); "
          "F0_n vs chain F_n dev %.1e (n = 8) / %.1e (n = 12) "
          "(bars %.0e/%.0e); dual-norm Q_7 dev %.1e / Q_11 dev "
          "%.1e -- the centered moment route and the dual-norm "
          "identity hold on the true comb"
          % (MP_DPS_A, t0rel, T0_MP_BAR, dct[8][0], dct[12][0],
             F0_BAR_8, F0_BAR_12, dct[8][1], dct[12][1]))
    # m3: uncentered alias
    q0 = [smom[i] for i in range(4)]
    st = PB.frac_solve(Hm(4), q0)
    Qun = sum(qi * si for qi, si in zip(q0, st))
    okm3 = (smom[0] != 0
            and Qun == sum(rhotoy[k] for k in range(4))
            and Qun != sum(rhotoy[k] for k in range(1, 4)))
    check("G42-mustfail-m3-uncentered", okm3,
          "the UNCENTERED sigma does NOT annihilate P_0: t_0("
          "sigma) = s_0 != 0 and the uncentered Parseval q^T "
          "H^{-1} q = Q + rho_0 != Q EXACTLY (rationals) -- the "
          "centering is NECESSARY for the dictionary; on w9 the "
          "uncentered functional carries the full geometric head "
          "(rho_0 share ~ 0.37, r246)")

    # ---------------- S5: leg B measurement -- the quiet zone
    section("S5  LEG B -- SIGMA0 MOMENT TABLES + QUIET TYPING")
    # per-window tables
    Ns_dev = [p["N"] for p in dev]
    for p in packs:
        wxa, wwa, bxa, bwa = world_arrays(p)
        mm, mabs = f64_moments(wxa, wwa, KTAB)
        sm, sabs = f64_moments(bxa, bwa, KTAB)
        c = sm[0] / mm[0]
        p["tn"] = [abs(sm[k] - c * mm[k])
                   / (sabs[k] + abs(c) * mabs[k])
                   for k in range(KTAB + 1)]
        p["gk"] = [abs(p["rows"][k]["fb"])
                   / math.sqrt(p["rows"][k]["eta"])
                   for k in range(KTAB + 1)]
        Q7 = float(p["S"][7]) - float(p["rho"][0])
        p["Gq"] = math.sqrt(max(Q7, 0.0) / p["St"])
    info("sigma0 moment table, MAIN ladder medians (k: |t_k| "
         "normalized on the pre-cancellation scale | g_k = "
         "|F_k|/sqrt(h_k) | DEV log-log slope of g_k vs N):")
    for k in range(KTAB + 1):
        med_t = float(np.median([p["tn"][k] for p in packs]))
        med_g = float(np.median([p["gk"][k] for p in packs]))
        if k >= 1:
            sl = float(np.polyfit(
                np.log(Ns_dev),
                np.log([max(p["gk"][k], 1e-300) for p in dev]),
                1)[0])
            info("  k=%-3d tnorm med %.2e | g med %.2e | "
                 "slope %+.2f" % (k, med_t, med_g, sl))
        else:
            info("  k=%-3d tnorm med %.2e (t_0 structural zero) | "
                 "g_0 med %.2e (head, eliminated)"
                 % (k, med_t, med_g))
    # u-moment source check (the builder question)
    um_worst = 0.0
    for p in dev:
        alpha = PIK.build_rung(p["kz"])["alpha"]
        ka = core.atoms_in(alpha)
        uu = np.asarray(core.U_ALL[:ka], float)
        mmw = np.asarray(core.MU_ALL[:ka], float)
        ug, uw = PB.smooth_comb(alpha)
        for k in range(UMOM_KMAX + 1):
            a_ = float(np.sum(mmw * uu ** k))
            b_ = float(np.sum(uw * ug ** k))
            um_worst = max(um_worst,
                           abs(a_ - b_) / (abs(a_) + abs(b_)))
    Gq_dev = [p["Gq"] for p in dev]
    med_Gq = float(np.median(Gq_dev))
    sl_Gq = float(np.polyfit(np.log(Ns_dev),
                             np.log(Gq_dev), 1)[0])
    if um_worst <= UMOM_EXACT_BAR:
        quiet_t = "QUIETZONE_EXACT_MOMENTS"
    elif med_Gq <= QUIET_LEVEL_BAR and sl_Gq <= QUIET_TREND_BAR:
        quiet_t = "QUIETZONE_ASYMPTOTIC_MOMENTS"
    else:
        quiet_t = "QUIETZONE_FINITE_NUMERICAL_ONLY"
    check("G50-quietzone-typed", True,
          "SEALED RULE result: %s -- u-moment source check "
          "(does sigma share low u-moments with the comb BY "
          "CONSTRUCTION?): worst rel dev %.1e over k = 0..%d on "
          "all DEV windows (exact bar %.0e) => %s; designated "
          "statistic G_q = sqrt(Q_7/S_{N-1}): DEV median %.2e "
          "(level bar %.0e), DEV log-log slope %+.2f vs N (trend "
          "bar %.2f); the number 7 is the sealed r246 head cut, "
          "not an oracle -- no eight-bit narrative"
          % (quiet_t, um_worst, UMOM_KMAX, UMOM_EXACT_BAR,
             "SHARED (exact identity)" if um_worst <= UMOM_EXACT_BAR
             else "NOT exact (PNT-model level, no construction "
             "identity)", med_Gq, QUIET_LEVEL_BAR, sl_Gq,
             QUIET_TREND_BAR))
    # SCRAMBLE break table (w9 base)
    p9 = by_kz[9]
    scr = ctrl["SCRAMBLE"]
    eps = ctrl["EPSTEIN"]
    decs = [math.log10(float(scr["rho"][k]) / float(p9["rho"][k]))
            for k in range(1, KTAB + 1)]
    bp = next((k for k, d_ in zip(range(1, KTAB + 1), decs)
               if d_ >= BREAK_DECADE), None)
    info("SCRAMBLE decade excess log10(rho_SCR/rho_MAIN), k = "
         "1..12: %s" % str(["%+.1f" % d_ for d_ in decs]))
    check("G51-scramble-breakpoint", bp is not None,
          "SEALED breakpoint rule (first k in 1..12 with excess "
          ">= %.1f decade): k = %s; median excess over the quiet "
          "range k = 1..7: %+.2f decades: the sigma0 silence is "
          "an ARITHMETIC observable (SCRAMBLE destroys it), not "
          "a builder artifact"
          % (BREAK_DECADE, str(bp),
             float(np.median(decs[:7]))))

    # ---------------- S6: leg C tail-kernel compression
    section("S6  LEG C -- TAIL-KERNEL COMPRESSION + m2")
    # toy exact
    nodes0 = SBn + JFn
    wts0 = SBw + [-ct * w for w in JFw]
    P0, dP0 = toy_pd(al, hs, nodes0, NTOY)
    T42 = (toy_cd_double(P0, dP0, hs, 4, nodes0, wts0)
           - toy_cd_double(P0, dP0, hs, 2, nodes0, wts0))
    okc1 = (T42 == rhotoy[2] + rhotoy[3])
    Pu, dPu = toy_pd(al, hs, SBn, NTOY)
    T42u = (toy_cd_double(Pu, dPu, hs, 4, SBn, SBw)
            - toy_cd_double(Pu, dPu, hs, 2, SBn, SBw))
    okc2 = (T42u == T42)
    # spectral == CD at sample points
    za, zb = Fr(1, 3), Fr(-2, 7)
    Pz, dPz = toy_pd(al, hs, [za, zb], NTOY)
    cd_ab = ((Pz[4][0] * Pz[3][1] - Pz[3][0] * Pz[4][1])
             / (hs[3] * (za - zb)))
    sp_ab = sum(Pz[k][0] * Pz[k][1] / hs[k] for k in range(4))
    cd_aa = (dPz[4][0] * Pz[3][0] - dPz[3][0] * Pz[4][0]) / hs[3]
    sp_aa = sum(Pz[k][0] * Pz[k][0] / hs[k] for k in range(4))
    okc3 = (cd_ab == sp_ab) and (cd_aa == sp_aa)
    # m2: index-shifted tail kernel
    T41 = (toy_cd_double(P0, dP0, hs, 4, nodes0, wts0)
           - toy_cd_double(P0, dP0, hs, 1, nodes0, wts0))
    okm2 = (T41 - T42 == rhotoy[1]) and rhotoy[1] != 0
    check("G60-tailkernel-exact-toy", okc1 and okc2 and okc3
          and okm2,
          "rationals: intint [K_4 - K_2] dsigma0 dsigma0 = rho_2 "
          "+ rho_3 EXACT (double pairing over the sigma0 atom "
          "union, confluent diagonal); CENTERING-INVARIANCE: the "
          "same readout over sigma equals the sigma0 readout "
          "EXACTLY (the difference kernel only sees modes >= 2); "
          "spectral == CD form at sample points incl. diagonal; "
          "must-fail m2: [K_4 - K_1] differs by exactly rho_1 != "
          "0, loud -- the K_7-for-K_8 index shift in toy form")
    # f64 ladder
    worst_rel = 0.0
    worst_abs = 0.0
    for p in allw:
        T_cd, T_dir, ksc = cd_tail_f64(p, CD_HI, CD_LO)
        if abs(T_dir) > 1e-12 * p["St"]:
            worst_rel = max(worst_rel,
                            abs(T_cd / T_dir - 1.0))
        else:
            worst_abs = max(worst_abs, abs(T_cd - T_dir)
                            / max(ksc, 1e-300))
    ok61 = worst_rel <= CD_BAR and worst_abs <= CD_ABS_GUARD
    inv_worst = 0.0
    for p in [p9] + list(ctrl.values()):
        Ta, Td, _k1 = cd_tail_f64(p, CD_HI, CD_LO, sigma0=False)
        Tb, _d2, ksc = cd_tail_f64(p, CD_HI, CD_LO, sigma0=True)
        if abs(Td) > 1e-12 * p["St"]:
            inv_worst = max(inv_worst, abs(Tb / Ta - 1.0))
        else:
            inv_worst = max(inv_worst,
                            abs(Tb - Ta) / max(ksc, 1e-300))
    ok62 = inv_worst <= CD_BAR
    check("G61-tailkernel-f64-ladder", ok61 and ok62,
          "f64 (m_hi, m_lo) = (%d, %d) on ALL %d MAIN + 3 control "
          "worlds: worst rel dev %.1e (bar %.0e; SMOOTH sigma0 == "
          "0 self-alias on the abs mass-norm guard: %.1e <= %.0e, "
          "typed pre-run); SIGMA0-INVARIANCE on w9 + 3 controls: "
          "worst %.1e -- the tail readout does not see the "
          "centering, world-blind as algebra"
          % (CD_HI, CD_LO, len(packs), worst_rel, CD_BAR,
             worst_abs, CD_ABS_GUARD, inv_worst))
    if smoke:
        check("G62-tailkernel-mp-deep", True,
              "SKIPPED in smoke mode (dps-%d full-depth block on "
              "w9)" % MP_DPS_C)
    else:
        t_mp0 = time.time()
        dev_mp, dev_f64, S_tail, natoms = mp_deep_cd(p9, CD_LO,
                                                     MP_DPS_C)
        check("G62-tailkernel-mp-deep", dev_mp <= CD_MP_BAR,
              "mp (dps %d) on w9 through the FULL depth N = %d "
              "(%d border atoms, %.0f s): T = intint [K_N - K_8] "
              "dsigma dsigma matches the mp tail sum sum_{n>=8} "
              "rho_n = %.6f to rel dev %.1e (bar %.0e; f64 chain "
              "drift %.1e) -- the extensive tail IS one terminal "
              "CD-kernel-difference readout: extensive "
              "information in the SOURCE, one object in the "
              "analytic STATE"
              % (MP_DPS_C, p9["N"], natoms, time.time() - t_mp0,
                 S_tail, dev_mp, CD_MP_BAR, dev_f64))

    # ---------------- S7: leg D tail-profile typing
    section("S7  LEG D -- TAIL-PROFILE TYPING (DEV/BLIND)")
    for p in packs:
        p["prof"] = tail_profile(p)
        p["prof_e"] = tail_profile(p, parity=0)
        p["prof_o"] = tail_profile(p, parity=1)
        p["eo"] = rel_l1(p["prof_e"], p["prof_o"])
    pair_l1 = []
    for i in range(len(dev)):
        for j in range(i + 1, len(dev)):
            pair_l1.append(rel_l1(dev[i]["prof"], dev[j]["prof"]))
    med_pair = float(np.median(pair_l1))
    devmean = np.mean([p["prof"] for p in dev], axis=0)
    blind_uni = [rel_l1(p["prof"], devmean) for p in blind]
    med_eo = float(np.median([p["eo"] for p in dev]))
    blind_eo = [p["eo"] for p in blind]
    tfrac = [(p["St"] - float(p["S"][CD_LO - 1])) / p["St"]
             for p in packs]
    info("tail share T_w/S_{N-1} in [%.2f, %.2f] med %.2f; DEV "
         "pairwise rel-L1: med %.3f, q25/q75 %.3f/%.3f, max %.3f "
         "(%d pairs); blind-vs-DEVmean %.3f/%.3f; within-window "
         "even/odd rel-L1: DEV med %.3f, blind %.3f/%.3f"
         % (min(tfrac), max(tfrac), float(np.median(tfrac)),
            med_pair, float(np.percentile(pair_l1, 25)),
            float(np.percentile(pair_l1, 75)), max(pair_l1),
            len(pair_l1), blind_uni[0], blind_uni[1], med_eo,
            blind_eo[0], blind_eo[1]))
    prof_mod = ""
    if med_pair <= PROF_DEV_BAR:
        tail_t = "EXTENSIVE_REGULAR_TAIL"
        if not all(b <= PROF_BLIND_BAR for b in blind_uni):
            prof_mod = " + TAILPROFILE_BLIND_CHECK_FAILED"
    elif med_eo <= PROF_DEV_BAR:
        tail_t = "EXTENSIVE_QUENCHED_TAIL"
        if not all(b <= PROF_BLIND_BAR for b in blind_eo):
            prof_mod = " + TAILPROFILE_BLIND_CHECK_FAILED"
    else:
        tail_t = "EXTENSIVE_IRREGULAR_TAIL"
    conseq = {"EXTENSIVE_REGULAR_TAIL":
              "one integrated density formula covers the tail",
              "EXTENSIVE_QUENCHED_TAIL":
              "window-specific phi_w with a single uniform proof "
              "rule",
              "EXTENSIVE_IRREGULAR_TAIL":
              "the full discrete source stands -- no macroprofile,"
              " no integrated density formula, no per-window "
              "profile rule"}[tail_t]
    check("G70-tail-profile-typed", True,
          "SEALED RULE result: %s%s -- d1 (universal phi): DEV "
          "median pairwise rel-L1 %.3f vs bar %.2f; d2 (quenched "
          "phi_w): within-window even/odd DEV median %.3f vs bar "
          "%.2f (blind %.3f/%.3f vs %.2f); collapse statistics "
          "above (18 bins on [%.2f, %.2f], sealed bandwidth 0.05)"
          % (tail_t, prof_mod, med_pair, PROF_DEV_BAR, med_eo,
             PROF_DEV_BAR, blind_eo[0], blind_eo[1],
             PROF_BLIND_BAR, PROF_LO, PROF_HI))
    check("G71-analytic-consequence", True,
          "documented under the sealed verdict: %s -- EXTENSIVE "
          "is the r246 finding (K_0.9 ~ 0.9 N, blind-checked "
          "there), THIS round types the PROFILE; the consequence "
          "for the RHP lane: %s" % (tail_t, conseq))

    # ---------------- S8: leg E naming-correction record
    section("S8  LEG E -- THREE-ZONE NAMING RECORD")
    dec0_eps = math.log10(float(eps["rho"][0]) / float(p9["rho"][0]))
    dec0_scr = math.log10(float(scr["rho"][0]) / float(p9["rho"][0]))
    ok80 = (abs(dec0_eps) <= HEAD_DEC_BAR
            and abs(dec0_scr) <= HEAD_DEC_BAR)
    check("G80-head-geometric", ok80,
          "rho_0 decade offsets vs MAIN w9: EPSTEIN %+.3f, "
          "SCRAMBLE %+.3f (bar %.1f): the head LEVEL is "
          "world-shared -- together with the leg-A congruence "
          "(world-blind elimination) the head is GEOMETRY: "
          "GEOMETRIC_RANK1_HEAD" % (dec0_eps, dec0_scr,
                                    HEAD_DEC_BAR))
    dec_eps = [math.log10(float(eps["rho"][k]) / float(p9["rho"][k]))
               for k in QUIET_KS]
    med_scr = float(np.median(decs[:7]))
    med_eps = float(np.median(dec_eps))
    ok81 = med_scr >= SIL_SCR_BAR and abs(med_eps) <= SIL_EPS_BAR
    check("G81-silence-arithmetic", ok81,
          "quiet-zone decade excess (k = 1..7): SCRAMBLE median "
          "%+.2f (bar >= %.1f), EPSTEIN median %+.3f (bar <= "
          "%.1f): the SILENCE separates the arithmetic worlds by "
          "decades while the lattice world sits on MAIN -- "
          "LOWMODE_ARITHMETIC_SILENCE" % (med_scr, SIL_SCR_BAR,
                                          med_eps, SIL_EPS_BAR))
    nf = scr["nf"]
    dl = (np.asarray(scr["rho"][:nf], float)
          - np.asarray(p9["rho"][:nf], float))
    tot = float(np.sum(dl))
    tail_fr = float(np.sum(dl[CD_LO:])) / tot if tot != 0 else 0.0
    ok82 = tail_fr >= TAILFRAC_BAR
    check("G82-tail-pairing-sensitive", ok82,
          "SCRAMBLE pre-flip (n < %d) budget excess: fraction in "
          "n >= %d is %.3f (bar %.1f; r246 measured 0.84) -- "
          "EXTENSIVE_PAIRING_SENSITIVE_TAIL; NAMING RECORD "
          "(sealed): the r246 label HEAD_CARRIES_ARITHMETIC was "
          "a MISNOMER -- its magnitude clause fired on the QUIET "
          "modes n = 1..7, not on the head mode 0 (G80: the head "
          "is world-shared geometry); the corrected three-zone "
          "typing is GEOMETRIC_RANK1_HEAD + LOWMODE_ARITHMETIC_"
          "SILENCE + EXTENSIVE_PAIRING_SENSITIVE_TAIL"
          % (nf, CD_LO, tail_fr, TAILFRAC_BAR))

    # ---------------- S9: verdict
    section("S9  VERDICT")
    check("G90-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED (a normal-form + "
          "typing round moves no edge); what the round adds: the "
          "bordered object in NORMAL FORM -- eliminable rank-1 "
          "head (congruence), the quiet zone as an exact sigma0 "
          "annihilation dictionary with dual-norm Q_m, the tail "
          "as ONE terminal CD readout, and the tail profile "
          "typed; the CENTERED_BASEFIBER campaign consumes "
          "sigma0, Q_m and the compressed tail as its objects")
    legA_ok = all(ok for nm, ok, _d in CHECKS
                  if nm.startswith(("G10", "G11", "G30", "G31")))
    legB_ok = all(ok for nm, ok, _d in CHECKS
                  if nm.startswith(("G40", "G41", "G42")))
    legC_ok = all(ok for nm, ok, _d in CHECKS
                  if nm.startswith(("G60", "G61", "G62")))
    legE_ok = ok80 and ok81 and ok82
    verd = " + ".join([
        "CENTERING_CONGRUENCE_EXACT" if legA_ok
        else "CENTERING_CONGRUENCE_OPEN",
        "SIGMA0_DICTIONARY_EXACT" if legB_ok
        else "SIGMA0_DICTIONARY_OPEN",
        quiet_t,
        "TAIL_KERNEL_COMPRESSED" if legC_ok
        else "TAIL_KERNEL_OPEN",
        tail_t + prof_mod,
        ("THREE_ZONE_NORMALFORM(GEOMETRIC_RANK1_HEAD + "
         "LOWMODE_ARITHMETIC_SILENCE + "
         "EXTENSIVE_PAIRING_SENSITIVE_TAIL)") if legE_ok
        else "THREE_ZONE_NORMALFORM_UNCONFIRMED"])
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G91-verdict", npass == len(CHECKS),
          "%s%s -- PROVEN: the centering congruence, the sigma0 "
          "dictionary + dual norm, the tail-kernel compression "
          "(exact identities, world-blind); MEASURED: the quiet-"
          "zone typing, the SCRAMBLE breakpoint, the tail-profile "
          "class, the three-zone record; OPEN: the budget bound "
          "itself (the wall; r243 PAIRCORR_REENCODED stands); 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())
'''

# ------------- frozen probe source targetreadout_error_probe (embedded BYTE-EXACT, raw string)
_SRC_3 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""targetreadout_error_probe -- PRIME.PORT.RHP.TARGETREADOUT.ERROR.01
(round 251): EXACT ERROR-EVALUATION FORMULAS for the target
readouts of the r250 outer model -- NO new parametrix.  r250 froze
OUTER_MODEL_FAILS + FIBER_BEYOND_MODEL: the outer model M_n carries
the readout RATES (plateau 1/4 exact to 1.8e-4, h-slope <= 0.007
dec/degree) but NOT the pointwise matrix (bulk err 2.7-15.6, GAP
zone breaks with filling, bare beats dressed 2-4x, h offset +1.8
decades) and NOT the fiber (T_model sign wrong on w9).  The
reviewer question of THIS round: are the target readouts (base
h_n, fiber T) proof-grade controllable THROUGH the measured
pointwise failure -- i.e. what EXACT functional of the error field
R(z) = Y_n(z) M_n(z)^{-1} are the readout errors, how strongly
does the fiber amplify the matrix error (the A-factor), and how
many decades does the K_N - K_8 mode annihilation buy in the ERROR
(not in the value)?  Priorities R2 > R4 > R3 (FOLLOWUP_SHA
0d14a215) stand; this round is the EVALUATION INFRASTRUCTURE for
R4 and the base margin bill.

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

INDEX FIREWALL (binding, r238-r250 discipline): w = window (kz),
N_w = builder depth, n = chain degree; free pivots h_{w,n}
(n < N_w) are the proof objects; Y_n is the frozen r227/r234 FIK
normalization; the forced pivot h_N is NEVER formed (levels use
h_{N-1} only); ground truth (h signs, flips) enters gates only;
no zero/prime oracles anywhere (AST firewall).  The outer model
M_n is the r250 object VERBATIM (centered_basefiber_probe:
r232a constrained-equilibrium g, KKT-midpoint ell, discrete Szego
D, -2 pi i calibration -- machinery imported, no refit); sigma0 =
sigma - (F_0/h_0) mutilde is the r248 centered border functional
(border atoms + window atoms, c = s_0/m_0 lifted f64 like the
r250 QP masses, disclosed).

LEG A -- EXACT FRECHET/CONTOUR FORMULAS (derived at design time,
frozen here, then gated numerically):
(a1) BASE READOUT ERROR.  Y_n = R M_n with R(z) -> I at infinity
  (both factors carry the same z^{n sigma3} normalization), so
  from Y z^{-n s3} = R (M z^{-n s3}) = (I + R1/z + ...)(I + M1/z
  + ...) the 1/z coefficients ADD EXACTLY: Y1 = R1 + M1 (no cross
  term at order 1/z).  With the r234 exact readout h_n = (Y1)_12
  and the r250 analytic h_n^out = (M1)_12:
    delta h_n = h_n - h_n^out = (R1)_12
              = (1/(2 pi i)) oint (R(z) - I)_12 dz,
  an EXACT identity (no leading order): the base readout error IS
  the 12-entry of the 1/z coefficient of the error matrix field.
  GATE: 2-point Richardson extraction of (R1)_12 at the sealed
  norm points x0 + 1e2 / x0 + 1e3 vs the direct difference
  h_n^true - h_n^out (mp chain h + analytic model formula), at
  degrees n in {N//2, N-1} on the a1 windows; bar |rich - delta|
  / max(|h_true|, h_out) <= 1e-3 (Richardson truncation ~
  (hull/z1)^2 ~ 4e-4).  PRECISION LAW (measured in the smoke
  pass): the far-z Cauchy column cancels to ~ (n+1) log10|z|
  digits (w9 at z = x0+1e3, n = 183: ~ 552 digits) -- a1 runs
  its OWN mp pass (2 points only) at the sealed DPS_A1 = 700;
  w26 is excluded from a1 (would need dps ~ 1200; disclosed).
(a2) FIBER READOUT ERROR -- THE CENTRAL EVALUATION FORMULA (the
  exact rest identity of r250-R4): with K^Y_m(x,y) =
  (Y_m^{-1}(y) Y_m(x))_21 / (y - x) = [pihat_m(x) pihat_{m-1}(y)
  - pihat_{m-1}(x) pihat_m(y)] / (h_{m-1}(x - y)) and K^M_m the
  same functional of M_m (r250 c2 kernel),
    T^Y - T^M = intint ([K^Y_N - K^M_N] - [K^Y_8 - K^M_8])
                dsigma0 dsigma0
  EXACTLY on the common regularized contour (x + i dx, y + i dy;
  dx = 1e-5, dy = 2e-5 -- SHARPENED from the r250 model-side
  1e-3/2e-3 after the smoke pass MEASURED that dx = 1e-3
  destroys the oscillating true-kernel pairing (w9: T^Y_reg =
  -65.8 vs T_true = +4.334) while dx = 1e-5 carries it to 5.6e-6
  relative).  MODEL VARIANT (sealed after the same measurement):
  the FULL r250 model is NOT sigma0-pairable -- its discrete
  Szego layer D(z) has atom poles at the support nodes, and at
  the tight contour the D-exponent reaches ~ 1e3 log units
  (beyond f64, beyond any margin scale); the kernel/fiber legs
  therefore run the SEALED r250 ABLATION MEMBER noD (D := 1 --
  the pointwise-better object of the r250 ablation, no new
  parametrix) as the outer transfer candidate M; the full-D
  obstruction is MEASURED and typed (G34, verdict token
  MODEL_KERNEL_POLE_OBSTRUCTION); the base legs (h_n^out, a1)
  keep the FULL model (z -> infinity readouts see no atom pole).
  GATES:
  (i) route consistency: the four separately-paired terms vs the
  one pairing of the assembled difference kernel, on the absolute
  mass-norm scale (gross = |w| K |w|), bar 1e-9; (ii) the CHAIN
  ANCHOR: T^Y_reg = sigma0 [K^Y_N - K^Y_8] sigma0 vs the bitwise
  r244 chain readout T_true = sum_{n=8}^{N-1} rho_n -- the
  regularization systematic |T^Y_reg / T_true - 1| is ADJUDICATED
  at bar 0.10 (if the contour shift polluted the object at the
  10-percent level, the whole delta-T bill would be void; r248
  proved the on-axis identity exact to 3.3e-160).
(a3) THE ERROR-KERNEL DECOMPOSITION (exact bilinear form): from
  Y = R M,  Y^{-1}(y) Y(x) = M^{-1}(y) [R^{-1}(y) R(x)] M(x), so
    K^Y(x,y) - K^M(x,y)
      = ( row2(M^{-1}(y)) [R^{-1}(y) R(x) - I] col1(M(x)) )
        / (y - x),
  with row2(M^{-1}(y)) = (-M21(y), M11(y))/det M(y) and
  col1(M(x)) = (M11(x), M21(x))^T: the error kernel is the
  two-point error field E(x,y) = R^{-1}(y) R(x) - I sandwiched
  between the model's second inverse-row and first column --
  the fiber transfer consumes EXACTLY this bilinear form of
  (R - I), nothing else.  GATE: direct K^Y - K^M vs the sandwich
  on the sealed 5 x 5 sample pairs at level N, sup-normalized
  dev bar 1e-6 (mp).

LEG B -- THE AMPLIFICATION FACTOR A (the reviewer core question):
  A_w = |delta T_w| / eps_w with the sealed normalizations
  (r250 error metric verbatim, C = e^{(n ell/2) sigma3}).  THE
  NORM CONTOUR (sealed after the smoke pass): the Cauchy columns
  of Y have poles AT the sigma0 atoms, so ||R - I|| at the
  atom-shifted pairing points is a regularization artifact, not
  an error scale; eps is measured on the sealed GAP-MIDPOINT
  contour Gamma_w = {midpoints of consecutive sorted sigma0
  atoms} + i delta, delta = 0.02 (the r250 GAP offset), NSAMP
  position-stride midpoints:
    eps_sup = sup over Gamma_w of ||C^-1 (R - I) C||_F, level N;
    eps_L2  = sqrt( sum w~_i err_i^2 / sum w~_i ), w~_i = the
      mean |sigma0| mass of the two adjacent atoms (sigma0-
      weighted L2 on Gamma_w);
    eps_YM  = sup ||C^-1 (Y - M) C||_F / ||C^-1 M C||_F (the
      model-relative Y-error scale, for the c2 quotient).
  M = the noD transfer candidate (consistent with delta T); the
  full-D err on the same contour is reported as r250-continuity
  information (the midpoint contour clears the D poles).
  MEASURED: A_w across the window ladder, Spearman(A; N) and the
  log-log slope p (A ~ N^p?); the proof-relevant balance: the
  hypothetical scenario eps ~ 1/N with A ~ N leaves delta T =
  O(1) -- measured as hypo_w = (A_w / N_w) / |margin_w^out|
  (median >= 1 means a 1/N-falling matrix error does NOT
  automatically carry the fiber readout).  SEALED TAGS:
  AMPLIFICATION_EXTENSIVE iff p >= 0.5 AND Spearman >= +0.5;
  AMPLIFICATION_BOUNDED iff Spearman <= 0.0; else
  AMPLIFICATION_MIXED.

LEG C -- THE QUIET ZONE AS ERROR ANNIHILATOR (the reviewer
lever): the subtraction K_N - K_8 removes the first eight
orthogonal modes EXACTLY (r248); measured here in the ERROR:
(c1) q_annihil_w = |delta T (K_N - K_8)| / |delta T_naiv| with
  delta T_naiv = sigma0 [K^Y_N - K^M_N] sigma0 (no low-level
  subtraction; sigma0 fixed, so mode 0 is centered out in BOTH
  numerator and denominator -- the quotient isolates the modes
  1..7 + level-8 subtraction gain in the ERROR, not the value);
  decades bought = -log10 q_annihil; SEALED: ANNIHILATION_BUYS
  (median decades over the fiber windows >= 1.0) /
  ANNIHILATION_NEUTRAL.
(c2) the N-dependence of the fiber error per matrix error:
  q_c2_w = |delta T_w| / eps_YM_w across the ladder; SEALED
  reading: falling (Spearman <= -0.5) = the rest zone carries
  analytically; flat/rising = the fiber sits genuinely in the
  error term.  (c3) NO coarse norm bound anywhere: every number
  is evaluated through the exact leg-A formulas (a norm bound
  |T| <= ||sigma0||^2 ||K|| would destroy the mode cancellation
  and is FORBIDDEN in this round by design.)

LEG D -- MARGIN RELEVANCE (the reviewer scoring):
(d1) BASE PROFILE over ALL free degrees (sealed stride grid,
  PROF_PTS equilibrium masses, warm-started QP): ratio_n =
  |delta h_n| / h_n^out = |10^{Delta_n} - 1| with Delta_n =
  log10 h_n^true - log10 h_n^out; profile quartiles + the
  offset/rate split (slope of Delta_n vs n, r250 h-rate bar 0.01
  dec/degree).  SEALED CLASSIFICATION: BASE_READOUT_PROVABLE iff
  max ratio <= 0.5 on all windows; else BASE_READOUT_BLOCKED_BY_
  OFFSET iff |slope| <= 0.01 on all windows AND median |offset|
  >= 0.5 decades (a single missing CONSTANT layer, the R3
  target); else BASE_READOUT_BLOCKED_STRUCTURAL.
(d2) FIBER MARGIN: per window |delta T| / |margin_true| with
  margin_true = B0 - Q_7 - T_true (the anchor identity: = 5/7 -
  rho_{N-1} exactly under the placeholder form B_w = S_{N-2} +
  5/7, r243/r247, honest status IMPORTED -- corner_provenance
  runs in parallel and may replace the form; typed, not
  consumed beyond the placeholder), B0 = B - rho_0, Q_7 =
  sum_{1..7} rho_n.  DISCLOSED CALIBRATION AMENDMENT: the draft
  compared against margin_out = B0 - Q_7 - T^out, which is the
  TAUTOLOGY margin_out = margin_true + delta T (a positive
  error always passes |dT| < margin_out); the comparison object
  was moved to the true margin the eventual bound must beat
  AFTER the error is spent; margin_out is still printed.
(d3) WORLD COMPARISON: the same delta T pipeline on SCRAMBLE
  (seed 1, w9 base, full depth): does the MAIN-SCRAMBLE object
  difference sit in delta T?  share = |delta T_SCR - delta
  T_MAIN| / |T_SCR - T_MAIN|; SEALED: WORLD_GAP_IN_DELTA_T iff
  share in [0.5, 2.0] (else WORLD_GAP_ELSEWHERE); the decade
  offset log10 |delta T_SCR / delta T_MAIN| is reported.

MUST-FAILS (each loud): (m1) swapped R1 readout (21-entry for
12-entry) must break the a1 identity by >= 1e3 x (the transposed
entry carries the e^{-2 n ell} gauge scale); (m2) INDEX-SHIFTED
TOP LEVEL (the r248-m2 analog on the evaluation contour): the
Y-side shift [K^Y_{N-1} - K^Y_8] vs [K^Y_N - K^Y_8] must move T
by EXACTLY rho_{N-1} (rel dev <= 0.05) and land >= 100 x the
honest anchor max(1e-3 |T^M_diff|, |T^Y_reg - T_true|) -- the
evaluation formula is level-pinned; DISCLOSED AMENDMENT: the
draft m2 (model-side mass 7 as 8) is NOT loud on MAIN because
the noD low level is numerically inert (~ 6e-5, the same
silence the annihilation leg measures); the inert value is
still reported; (m3) UNCENTERED ALIAS: the
naive level-N pairing against the raw border sigma (no centering)
differs from the sigma0 pairing by the rank-1 head rho_0 -- the
measured difference must land within [0.5, 2.0] x rho_0 (r248
head, loud); (m4) SIGN ORACLE: reading sign h_{N-1} or any flip
degree is EXCLUDED by the input firewall (standing r243
exclusion, re-asserted -- no evaluation path consumes it).

SEALED CONSTANTS: windows (9, 12, 13, 26); a1 windows (9, 12,
13); a1 degrees {N//2, N-1}; fiber low level 8; regularization
dx 1e-5 / dy 2e-5; norm contour delta 0.02 (r250 GAP offset);
kernel/fiber model variant noD (sealed; full-D typed via the
pole gate, bar 50 decades); dps: kernel/Y pass 120 (all
windows), a1 pass 700 (2 far points only), sandwich combination
600, model kernel columns 60, model R/a1 columns 80;
QP: FISTA iters 8000, tol 1e-8, residual bar 1e-6, warm start
ascending (r250); profile grid PROF_PTS = 36 masses in
[2, N-1] union {7, 8, N//2, N-1, N}; norm sample NSAMP = 48
position-stride gap midpoints; sandwich 5 x 5 (first/last five
position-stride atoms, x-offset vs y-offset); norm points
x0 + 1e2 / x0 + 1e3; bars: a1 1e-3, a2 route 2e-9 (gross mass
scale), reg systematic 0.10, a3 sandwich 1e-6 (sup-normalized),
spot Richardson 1e-4, det M 1e-30, det Y 1e-20, chain ward 1e-8;
amplification slope bar 0.5 / Spearman bar 0.5; annihilation
decade bar 1.0; c2 Spearman bar -0.5; base ratio bar 0.5, h-rate
bar 0.01 dec/degree, offset bar 0.5 dec; world share window
[0.5, 2.0]; loudness m1 1e3, m2 rel dev <= 0.05 vs rho_{N-1}
AND >= 100 x the anchor max(1e-3 |T^M_diff|, |T^Y_reg -
T_true|), m3 head window [0.5, 2.0]; control flips
25/21/27; runtime <= 1800 s; smoke = w9 only, atom stride 4,
PROF_PTS 8, NSAMP 12, dps 80/400/300, world block + reg-anchor
+ m2/m3 adjudication skipped (strided atoms carry no moment
identities).

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  READOUT_FORMULAS_EXACT  iff a1 (all a1 windows x degrees), a2
    (route + reg anchor) and a3 (sandwich) gates all pass;
    else READOUT_FORMULAS_OPEN;
+ AMPLIFICATION_<EXTENSIVE|BOUNDED|MIXED>(p, Spearman);
+ ANNIHILATION_BUYS(median decades) / ANNIHILATION_NEUTRAL;
+ FIBER_ERROR_CONTROLLABLE iff [|delta T| < |margin_true| on ALL
    fiber windows] OR [Spearman(q_c2; N) <= -0.5 AND
    ANNIHILATION_BUYS]; else FIBER_IN_ERROR_CONFIRMED (the fiber
    genuinely lives in the error term; R4 needs its own pairing
    theorem);
+ BASE_READOUT_<PROVABLE|BLOCKED_BY_OFFSET|BLOCKED_STRUCTURAL>;
+ WORLD_GAP_IN_DELTA_T(decades) / WORLD_GAP_ELSEWHERE
[+ MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D) if the G34 exponent
   exceeds the sealed 50-decade bar].
Honesty before beauty: no verdict claims a bound mechanism; the
budget bound and the base law stay OPEN (r243 PAIRCORR_REENCODED,
r247 B discipline, r250 error map all stand unchanged).

RECORD TABLES (frozen from calib_tr pass 3, 20/20, wall 91.6 s;
disclosed SMOKE/CALIBRATION AMENDMENTS -- every one caught by
the smoke or first full pass BEFORE the record freeze; the leg-A
formulas, the annihilation quotients, the amplification tags,
the base classification and the world rule never moved:
(a1) PRECISION LAW: the draft evaluated a1 inside the kernel
  pass at the r250 norm points x0+1e3/1e4; the smoke pass
  measured the far-z Cauchy cancellation ~ (n+1) log10|z| +
  |log10 sqrt(h_n)| digits (w9 n=183, z=1e3: ~604) -- a1 moved
  to its OWN 2-point pass at dps 700 with norm points
  x0+1e2/x0+1e3 (the model spot ward keeps the r250 points).
(a2) REGULARIZATION: the draft reused the r250 contour
  1e-3/2e-3; MEASURED on full w9 atoms: dx 1e-3 DESTROYS the
  oscillating true-kernel pairing (T^Y_reg = -65.8 vs T_true =
  +4.334) while 1e-5 carries it to 5.6e-6 rel -- dx/dy sealed
  at 1e-5/2e-5.
(a3) MODEL VARIANT: at the tight contour the FULL model's
  arcsine-cell Szego layer D(z) is unrepresentable at the atoms
  (measured exponent 380.3 decades > f64's 308) -- the kernel
  legs run the sealed r250 ablation member noD; the obstruction
  gate G34 was added and types MODEL_KERNEL_POLE_OBSTRUCTION.
(a4) NORM CONTOUR: draft eps at the atom-shifted points sits
  1e-5 from the Cauchy-column poles (pure artifact); eps moved
  to the sealed gap-midpoint contour + 0.02i.
(a5) MARGIN OBJECT: the draft fiber comparison |dT| <
  margin_out is the TAUTOLOGY margin_out = margin_true + dT
  (ratios 0.89-0.99 while the error is 8-82 x the true margin);
  the comparison moved to margin_true = B0 - Q_7 - T_true.
(a6) MUST-FAIL m2: the draft model-side mass-7 shift is NOT
  loud on MAIN (5.9e-5 -- the same low-mode inertness the
  annihilation leg measures); m2 re-pinned to the Y-side
  top-level shift, loud by exactly rho_{N-1}.
(a7) smoke m2/m3 adjudication skipped (strided atoms carry no
  moment identities); A2_ROUTE_BAR set 2e-9 at design, measured
  5.2e-18.):
CAL_VERDICT = READOUT_FORMULAS_EXACT +
AMPLIFICATION_EXTENSIVE(p=1.01) + ANNIHILATION_NEUTRAL +
FIBER_IN_ERROR_CONFIRMED + BASE_READOUT_BLOCKED_BY_OFFSET +
WORLD_GAP_IN_DELTA_T + MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D).
Key numbers.  CENSUS: w9/12/13/26 N = 184/151/168/364, T_true
4.3343/2.8907/4.1449/5.8687, sigma0 atoms 734/602/670/1454
(c0 ~ 1.002), control flips 25/21/27 re-derived.  WARDS: QP
residual worst 9.9e-9 (155 warm-started masses), spot det M
5.7e-79, spot Richardson 4.0e-6, det Y worst 2.2e-93 (kernel
dps 120) / 1.5e-98 (a1 dps 700), chain ward 1.4e-12, kernel
columns finite (max |log10| 110.2, headroom 197.8 decades).
LEG A: a1 dev 3.3e-6/7.5e-6 (w9 n=92/183), 1.0e-5/7.4e-6
(w12), 6.5e-6/5.8e-6 (w13) -- worst 1.0e-5 (bar 1e-3,
Richardson-truncation level: the delta-h contour identity is
EXACT); a2 routes worst 5.2e-18 on gross (bar 2e-9); REG
ANCHOR: T^Y_reg/T_true - 1 = +5.6e-6/-1.5e-5/-5.8e-4/-2.6e-3
(bar 0.10) -- the contour carries the object to 0.3 percent or
better; a3 sandwich worst 1.1e-81 (bar 1e-6, 25 pairs x 4
windows).  LEG B (level N, noD, normalized gauge): eps_sup
72.9/1758/2884/873 (sup is single-midpoint-spike dominated,
disclosed), eps_L2 26.2/43.2/70.8/121, eps_YM 2.90/3.14/2.25/
1.96 (the relative Y-error SATURATES ~ 2-3: terminal Y and M
columns are decorrelated at the sigma0 scale); |dT| = 4.42/
2.96/4.28/5.86; A_sup = 0.061/0.0017/0.0015/0.0067 -> sealed
tag AMPLIFICATION_EXTENSIVE(p = +1.01, Spearman +0.60); typed,
not upgraded: the L2-based A (0.168/0.069/0.061/0.049) FALLS
with N -- the tag is normalization-sensitive; the physical
reading is c2.  LEG C (c1): dT = +4.418/+2.964/+4.284/+5.864
vs dT_naiv identical to 3 digits: q_annihil = 1.000 on 4/4,
median decades bought +0.00 => ANNIHILATION_NEUTRAL -- the
centering buys 3.5 decades in the VALUE (r248) and ZERO in the
ERROR: both low levels are numerically inert on MAIN (Y-side
Q_7 ~ 2e-5 quiet, noD model level-8 ~ 1e-4), the naive error
is already tail-dominated; (c2) q_c2 = |dT|/eps_YM = 1.52/
0.94/1.90/3.00, Spearman +0.80, log-log slope +1.04: delta T
grows ~ N x (saturated relative Y-error) -- the fiber sits
GENUINELY in the error term.  LEG D (d1) base profile
|dh|/h^out over the 36-mass grids: med 0.944/0.948/0.949/
0.964, max 0.9912, offset -1.25/-1.29/-1.29/-1.45 decades
(model overshoots every constant), rate slopes -0.0029/
-0.0045/-0.0026/-0.0024 dec/degree (bar 0.01, 4/4) =>
BASE_READOUT_BLOCKED_BY_OFFSET (the r250 split confirmed on
the full profile: rate carried, ONE constant layer missing --
R3); (d2) fiber margin: T_out(noD) = -0.083/-0.074/-0.142/
-0.011 (the noD transfer carries ~ 2 percent of T_true: dT ~=
T_true itself), |dT|/|margin_true| = 7.9/81.8/12.0/8.2 (>= 1
on 4/4, w12's margin_true = 0.036 is razor thin) => the
readout error EXCEEDS the placeholder margin everywhere =>
FIBER_IN_ERROR_CONFIRMED by the sealed rule (no controllable
clause fires: ratios >= 1 AND c2 rises AND annihilation
neutral); hypothetical balance (A_sup/N)/|margin_true| median
1.7e-4 (an eps' ~ 1/N bound with the MEASURED A would suffice
-- but no such bound exists; informational, no mechanism
claimed); anchor 5/7 - rho_{N-1} exact 4/4; (d3) WORLDS:
T_SCR = -4.494 vs T_MAIN = +4.334 (object gap -8.83); dT_SCR
= -4.441 vs dT_MAIN = +4.418: share = 1.003 in [0.5, 2.0] =>
WORLD_GAP_IN_DELTA_T (decade offset +0.00): the world-blind
outer model pushes the ENTIRE arithmetic world difference
into the error term -- the R4 pairing theorem must separate
worlds in the error kernel, exactly as r250 typed.
MUST-FAILS all loud: m1 min ratio 3.0e+93; m2 top-level shift
0.1531 vs rho_{N-1} = 0.153 (rel 4.4e-4, 1835 x anchor); m3
head ratio 0.999 in [0.5, 2.0]; m4 oracle excluded.  Runtime
91.6 s full, 4.8 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
import mpmath as mp

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

import bordered_hankel_probe as BH           # noqa: E402 r244
import centered_basefiber_probe as CB        # noqa: E402 r250
import port_integrable_kernel_probe as PIK   # noqa: E402 v881
import principal_bessel_probe as PB          # noqa: E402 r243
import szego_equilibrium_probe as SZ         # noqa: E402 r232a
import v563_paper2_readouts as core          # noqa: E402 READ-ONLY

WINDOWS = (9, 12, 13, 26)
A1_WINDOWS = (9, 12, 13)
FIB_LO = 8
DPS_KERN = {9: 120, 12: 120, 13: 120, 26: 120}
DPS_A1 = 700
DPS_SAND = 600
DPS_MK = 60
DPS_MR = 80
KVAR = "noD"
POLE_DEC_BAR = 50.0
FIB_DX = 1e-5
FIB_DY = 2e-5
DELTA_GAP = 0.02
QP_ITERS = 8000
QP_TOL = 1e-8
QP_RES_BAR = 1e-6
PROF_PTS = 36
NSAMP = 48
SAND_K = 5
NORM_OFFS = (1e2, 1e3)
A1_BAR = 1e-3
A2_ROUTE_BAR = 2e-9
REG_SYS_BAR = 0.10
A3_BAR = 1e-6
RICH_BAR = 1e-4
DETM_BAR = 1e-30
DETY_BAR = 1e-20
CHAIN_BAR = 1e-8
AMP_SLOPE_BAR = 0.5
AMP_SP_BAR = 0.5
ANNIHIL_DEC_BAR = 1.0
C2_SP_BAR = -0.5
BASE_RATIO_BAR = 0.5
H_RATE_BAR = 0.01
OFFSET_DEC_BAR = 0.5
WORLD_SH_LO, WORLD_SH_HI = 0.5, 2.0
M1_LOUD = 1e3
M3_LO, M3_HI = 0.5, 2.0
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
CAL_VERDICT = ("READOUT_FORMULAS_EXACT + "
               "AMPLIFICATION_EXTENSIVE(p=1.01) + "
               "ANNIHILATION_NEUTRAL + FIBER_IN_ERROR_CONFIRMED "
               "+ BASE_READOUT_BLOCKED_BY_OFFSET + "
               "WORLD_GAP_IN_DELTA_T + "
               "MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D)")

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 model consumes "
                       "node positions + |weights| + the QP "
                       "minimizer ONLY (r250 firewall verbatim); "
                       "h_N never formed; sign h / flips enter "
                       "gates only (m4 oracle EXCLUDED)"
                       if not bad else "; ".join(bad))


# ------------------------------------------------- 2x2 mp helpers
def m_adj2(M):
    return ((M[1][1], -M[0][1]), (-M[1][0], M[0][0]))


def m_det2(M):
    return M[0][0] * M[1][1] - M[0][1] * M[1][0]


def m_mul2(A, B):
    return ((A[0][0] * B[0][0] + A[0][1] * B[1][0],
             A[0][0] * B[0][1] + A[0][1] * B[1][1]),
            (A[1][0] * B[0][0] + A[1][1] * B[1][0],
             A[1][0] * B[0][1] + A[1][1] * B[1][1]))


def r_field(Y, M):
    """R = Y M^{-1} (mp, adjugate route) plus the STABLE
    det R = det Y / det M (avoids the catastrophic cancellation
    of forming det from the near-rank-1 product entries)."""
    detM = m_det2(M)
    Ra = m_mul2(Y, m_adj2(M))
    R = ((Ra[0][0] / detM, Ra[0][1] / detM),
         (Ra[1][0] / detM, Ra[1][1] / detM))
    return R, m_det2(Y) / detM


def fro_RI(R):
    return float(mp.sqrt(abs(R[0][0] - 1) ** 2 + abs(R[0][1]) ** 2
                         + abs(R[1][0]) ** 2 + abs(R[1][1] - 1) ** 2))


# --------------------------------------------------- mp kernel pass
def mp_kernel_pass(d, zpts, snap_pts, levels, dps, Nb):
    """r250 mp_y_pass machinery adapted: scaled signed mp recursion
    on mutilde; per level m in `levels` store the scaled polynomial
    state (P_m, P_{m-1}, log scales, h_{m-1}); at snapshot degrees
    (keys of snap_pts) build the FULL FIK matrix Y_n (Cauchy
    columns) at the listed point indices only.  h_n is formed for
    FREE degrees n < Nb only; the forced pivot h_Nb is NEVER
    formed (levels consume h_{level-1})."""
    mp.mp.dps = dps
    nds = ([mp.mpf(float(v)) for v in d["xs"]]
           + [mp.mpf(float(v)) for v in d["ys"]])
    wt = ([mp.mpf(float(v)) for v in d["ws"]]
          + [-mp.mpf(float(v)) for v in d["vs"]])
    zc = [mp.mpc(z) for z in zpts]
    qk = [mp.mpf(1)] * len(nds)
    qkm = [mp.mpf(0)] * len(nds)
    qz = [mp.mpc(1) for _ in zc]
    qzm = [mp.mpc(0) for _ in zc]
    Ls = mp.mpf(0)
    Ls_m = mp.mpf(0)
    eta = mp.fsum(w * q * q for w, q in zip(wt, qk))
    eta_m = eta
    lg_h = mp.log(abs(eta))
    sg_h = mp.sign(eta)
    hlog = {0: (lg_h, sg_h)}
    gam = {}
    lv = {}
    ysnap = {}
    dety = 0.0
    nmax = max(max(levels),
               max(snap_pts) if snap_pts else 0)
    for k in range(nmax):
        aco = mp.fsum(w * x * q * q
                      for w, x, q in zip(wt, nds, qk)) / eta
        if k == 0:
            nx = [(x - aco) * q for x, q in zip(nds, qk)]
            nz = [(z - aco) * c for z, c in zip(zc, qz)]
        else:
            ge = (eta / eta_m) * mp.e ** (2 * (Ls - Ls_m))
            fc = mp.e ** (Ls_m - Ls)
            nx = [(x - aco) * q - ge * fc * r
                  for x, q, r in zip(nds, qk, qkm)]
            nz = [(z - aco) * c - ge * fc * r
                  for z, c, r in zip(zc, qz, qzm)]
        sc = max(abs(t) for t in nx)
        qkm, eta_m, Ls_m, qzm = qk, eta, Ls, qz
        qk = [t / sc for t in nx]
        qz = [c / sc for c in nz]
        Ls = Ls + mp.log(sc)
        n = k + 1
        if n < Nb:
            eta = mp.fsum(w * q * q for w, q in zip(wt, qk))
            g = (eta / eta_m) * mp.e ** (2 * (Ls - Ls_m))
            lg_h += mp.log(abs(g))
            sg_h *= mp.sign(g)
            hlog[n] = (lg_h, sg_h)
            gam[n] = float(g)
        if n in levels:
            lv[n] = dict(qz=list(qz), Ls=Ls, qzm=list(qzm),
                         Lsm=Ls_m, lgh=hlog[n - 1][0],
                         sg=hlog[n - 1][1])
        if n in snap_pts:
            lgm, sgm = hlog[n - 1]
            h_prev = sgm * mp.e ** lgm
            eLs = mp.e ** Ls
            eLm = mp.e ** Ls_m
            Ys = {}
            for iz in snap_pts[n]:
                z = zc[iz]
                Cn = eLs * mp.fsum(w * q / (z - x)
                                   for w, q, x in zip(wt, qk, nds))
                Cm = eLm * mp.fsum(w * q / (z - x)
                                   for w, q, x in zip(wt, qkm, nds))
                Y = ((eLs * qz[iz], Cn),
                     (eLm * qzm[iz] / h_prev, Cm / h_prev))
                dv = abs(Y[0][0] * Y[1][1] - Y[0][1] * Y[1][0] - 1)
                dety = max(dety, float(dv))
                Ys[iz] = Y
            ysnap[n] = Ys
    return hlog, gam, lv, ysnap, dety


def y_columns(lvm, nk):
    """balanced complex128 (11, 21)-column values at the first
    nk (kernel-block) points: u = pihat_m, v = pihat_{m-1}/
    h_{m-1}, both scaled by the symmetric split e^{gl/2}, gl =
    Ls + Lsm - lg|h_{m-1}| (kernel products u(x) v(y) are
    scale-exact)."""
    s = (lvm["Ls"] - lvm["Lsm"] + lvm["lgh"]) / 2
    su = mp.e ** (lvm["Ls"] - s)
    sv = lvm["sg"] * mp.e ** (lvm["Lsm"] - lvm["lgh"] + s)
    u = np.array([complex(q * su) for q in lvm["qz"][:nk]])
    v = np.array([complex(q * sv) for q in lvm["qzm"][:nk]])
    gl2 = float((lvm["Ls"] + lvm["Lsm"] - lvm["lgh"]) / 2)
    return u, v, gl2


def lv_pi(lvm, iz):
    """exact mp (pihat_m, pihat_{m-1}, h_{m-1}) at point iz."""
    pm = lvm["qz"][iz] * mp.e ** lvm["Ls"]
    pm1 = lvm["qzm"][iz] * mp.e ** lvm["Lsm"]
    h = lvm["sg"] * mp.e ** lvm["lgh"]
    return pm, pm1, h


def m_columns(md, zpts, dps, variant=KVAR):
    """model (11, 21)-columns as complex128 at all points."""
    u = np.empty(len(zpts), complex)
    v = np.empty(len(zpts), complex)
    for i, z in enumerate(zpts):
        M = CB.model_at(md, complex(z), dps, variant=variant)
        u[i] = complex(M[0][0])
        v[i] = complex(M[1][0])
    return u, v


def d_pole_dec(md, zpts):
    """|Re log10 D(z)| of the FULL model's discrete Szego layer
    at the given points (the atom-pole exponent, f64)."""
    z = np.asarray(zpts, complex)
    a, b = md["a"], md["b"]
    Rz = (z - a) * np.sqrt((z - b) / (z - a))
    s = np.zeros(len(z), complex)
    for nn, ll, ss in zip(md["nu"], md["L"], md["xs"]):
        s += float(nn) * float(ll) / (z - float(ss))
    return np.abs(np.real(0.5 * Rz * s)) / math.log(10.0)


def pair_kernel(Ax, Bx, Ay, By, Dn):
    """K[x, y] = (A(y) B(x) - B(y) A(x)) / (y - x) with A = the
    11-column, B = the 21-column (r250 c2 kernel orientation)."""
    return (Ay[None, :] * Bx[:, None]
            - By[None, :] * Ax[:, None]) / Dn


def spear(x, y):
    return BH.spearman(list(x), list(y))


# --------------------------------------------------------------- main
def main():
    par = argparse.ArgumentParser()
    par.add_argument("--smoke", action="store_true")
    args = par.parse_args()
    smoke = args.smoke
    windows = (9,) if smoke else WINDOWS
    a1_windows = (9,) if smoke else A1_WINDOWS
    nsamp = 12 if smoke else NSAMP
    prof_pts = 8 if smoke else PROF_PTS
    stride = 4 if smoke else 1

    print("=" * 78)
    print("targetreadout_error_probe -- PRIME.PORT.RHP."
          "TARGETREADOUT.ERROR.01 (round 251)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (w9 only, atom stride 4, reduced "
                        "grids, world block 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,
          "leg-A formulas (delta h = (R1)_12 contour identity; "
          "delta T = intint([K^Y_N - K^M_N] - [K^Y_8 - K^M_8]) "
          "dsigma0 dsigma0; error kernel = (R^-1(y) R(x) - I) "
          "sandwiched between model columns), all normalizations "
          "(eps_sup / eps_L2 / eps_YM, r250 C-gauge), the "
          "annihilation quotients and ALL verdict rules sealed in "
          "the frozen spec BEFORE evaluation; windows %s, a1 %s, "
          "dps kern %s / model %d,%d; QP iters %d tol %.0e; "
          "PROF_PTS %d, NSAMP %d, sandwich %dx%d; bars: a1 %.0e, "
          "a2 route %.0e (gross), reg %.2f, a3 %.0e; amp slope/"
          "Spearman %.1f/%.1f; annihil %.1f dec; c2 Spearman %.1f; "
          "base %.1f/%.2f/%.1f; world share [%.1f, %.1f]"
          % (str(WINDOWS), str(A1_WINDOWS), str(DPS_KERN),
             DPS_MK, DPS_MR, QP_ITERS, QP_TOL, PROF_PTS, NSAMP,
             SAND_K, SAND_K, A1_BAR, A2_ROUTE_BAR, REG_SYS_BAR,
             A3_BAR, AMP_SLOPE_BAR, AMP_SP_BAR, ANNIHIL_DEC_BAR,
             C2_SP_BAR, BASE_RATIO_BAR, H_RATE_BAR,
             OFFSET_DEC_BAR, WORLD_SH_LO, WORLD_SH_HI))

    # ---------------- S1: census + controls
    section("S1  CENSUS + CONTROLS")
    packs = {kz: BH.wpack(kz) for kz in windows}
    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"])
    ctrl_defs = (("EPSTEIN", dict(comb=(
        np.log(nn_idx.astype(float)),
        2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
        ("SCRAMBLE", dict(scramble_seed=1)),
        ("SMOOTH", dict(comb=(ug9, uw9))))
    ctrl = {c: BH.wpack(9, base_kw=kw) for c, kw in ctrl_defs}
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl)
    okC = all(packs[kz]["nf"] is None for kz in windows)
    tt_note = "; ".join(
        "w%d: N=%d, T_true=%.4f" % (kz, packs[kz]["N"],
                                    packs[kz]["St"]
                                    - float(packs[kz]["S"][FIB_LO
                                                           - 1]))
        for kz in windows)
    check("G10-census-controls", okC and okCf,
          "free prefix positive on %d/%d windows; %s; control "
          "flips re-derived %s (falsifier battery armed)"
          % (sum(1 for kz in windows if packs[kz]["nf"] is None),
             len(windows), tt_note,
             str({c: ctrl[c]["nf"] for c in ctrl})))

    # ---------------- S2: models + kernel passes per window
    section("S2  MODELS + MP KERNEL PASSES (wards)")
    W = {}
    res_worst = 0.0
    mass_ok = True
    detm_worst = 0.0
    rich_worst = 0.0
    dety_worst = 0.0
    chain_worst = 0.0
    lgmax_worst = 0.0
    fin_ok = True
    for kz in windows:
        p = packs[kz]
        d = p["d"]
        N = p["N"]
        dsm = p["dsm"]
        x, wt, A, Lip, V = CB.eq_field(d)
        _pan, norm_z, x0, _a0, _b0 = CB.build_panels(x)
        # sigma0 atoms: border + (-c) * window (c = F_0/h_0)
        c0 = p["Fv"][0] / p["hv"][0]
        batoms = np.concatenate([dsm["xs"], dsm["ys"]])
        bwts = np.concatenate([dsm["ws"], -dsm["vs"]])
        atoms0 = np.concatenate([batoms, x])[::stride]
        wts0 = np.concatenate([bwts, -c0 * wt])[::stride]
        nb = len(batoms[::stride])  # border block length after
        # stride (border first in the concat order)
        A0 = len(atoms0)
        # point list: x-offset block, y-offset block, then the
        # sealed gap-midpoint norm contour (off the atom poles)
        zx = atoms0 + 1j * FIB_DX
        zy = atoms0 + 1j * FIB_DY
        osort = np.argsort(atoms0)
        srt = atoms0[osort]
        wsrt = np.abs(wts0[osort])
        pickm = np.unique(np.linspace(0, A0 - 2, nsamp)
                          .astype(int))
        zmid = [0.5 * (srt[i] + srt[i + 1]) + 1j * DELTA_GAP
                for i in pickm]
        wmid = [0.5 * (wsrt[i] + wsrt[i + 1]) for i in pickm]
        zpts = list(zx) + list(zy) + zmid
        mid_ids = list(range(2 * A0, 2 * A0 + len(zmid)))
        # sandwich atoms (position stride over sorted atoms)
        pick = np.unique(np.linspace(0, A0 - 1, nsamp).astype(int))
        samp = [int(osort[i]) for i in pick]
        sand_x = samp[:SAND_K]
        sand_y = samp[-SAND_K:]
        samp_pts = sorted(set(mid_ids) | set(sand_x)
                          | set(A0 + j for j in sand_y))
        snap_pts = {FIB_LO: samp_pts, N: samp_pts}
        # QP masses: profile grid + specials
        grid = sorted(set(np.linspace(2, N - 1, prof_pts)
                          .astype(int).tolist())
                      | {7, FIB_LO, N // 2, N - 1, N})
        mds = {}
        rho = None
        for n in grid:
            rho, res = SZ.solve_qp(A, Lip, V, float(n), rho0=rho,
                                   iters=QP_ITERS, tol=QP_TOL)
            res_worst = max(res_worst, res)
            md = CB.model_data(x, wt, A, V, rho, n)
            mass_ok = mass_ok and (md["nround"] == n)
            mds[n] = md
        # spot model wards (r250 gates, spot-checked)
        for n in (FIB_LO, N):
            md = mds[n]
            for z in (zpts[0], zpts[-1]):
                detm_worst = max(
                    detm_worst,
                    CB.detm_dev(CB.model_at(md, complex(z),
                                            DPS_MR)))
            m1_12, _devs = CB.rich_M1_12(md, n, norm_z, DPS_MR)
            rich_worst = max(rich_worst,
                             abs(float(mp.log(abs(m1_12), 10))
                                 - md["hmod_l10"]))
        # mp kernel pass (w9 also stores level N-1 for the m2
        # top-level shift must-fail)
        dps = 80 if smoke else DPS_KERN[kz]
        lv_levels = {FIB_LO, N} | ({N - 1} if kz == 9 else set())
        hlog, gam, lvv, ysnap, dety = mp_kernel_pass(
            d, zpts, snap_pts, lv_levels, dps, N)
        dety_worst = max(dety_worst, dety)
        rows = p["rows"]
        for n in (12, N // 2):
            if n in gam:
                chain_worst = max(
                    chain_worst,
                    abs(gam[n] / rows[n - 1]["gam_next"] - 1.0))
        # kernel column conversion (balanced) + finiteness
        cols = {}
        for m in (FIB_LO, N):
            u, v, gl2 = y_columns(lvv[m], 2 * A0)
            fin_ok = fin_ok and bool(
                np.all(np.isfinite(u)) and np.all(np.isfinite(v)))
            au = np.abs(u[np.nonzero(u)[0]])
            av = np.abs(v[np.nonzero(v)[0]])
            lgm = max(np.max(np.log10(au)) if len(au) else 0.0,
                      np.max(np.log10(av)) if len(av) else 0.0)
            lgmax_worst = max(lgmax_worst, lgm)
            cols[m] = (u, v, gl2)
        mu, mv = {}, {}
        for m in (FIB_LO, N):
            uu, vv = m_columns(mds[m], zpts[:2 * A0], DPS_MK)
            fin_ok = fin_ok and bool(
                np.all(np.isfinite(uu))
                and np.all(np.isfinite(vv)))
            au = np.abs(uu[np.nonzero(uu)[0]])
            av = np.abs(vv[np.nonzero(vv)[0]])
            lgm = max(np.max(np.log10(au)) if len(au) else 0.0,
                      np.max(np.log10(av)) if len(av) else 0.0)
            lgmax_worst = max(lgmax_worst, lgm)
            mu[m], mv[m] = uu, vv
        info("w%-3d N=%d: sigma0 atoms %d (border %d + window "
             "%d, c0 %.4g), points %d, norm contour %d, QP "
             "masses %d, dps %d"
             % (kz, N, A0, nb, A0 - nb, c0,
                len(zpts), len(zmid), len(grid), dps))
        W[kz] = dict(p=p, d=d, N=N, x=x, wt=wt, A0=A0, x0=x0,
                     atoms0=atoms0, wts0=wts0, nb=nb, zpts=zpts,
                     mid_ids=mid_ids, wmid=wmid, sand_x=sand_x,
                     sand_y=sand_y, mds=mds,
                     hlog=hlog, lvv=lvv, ysnap=ysnap, cols=cols,
                     mu=mu, mv=mv, norm_z=norm_z, grid=grid,
                     rows=rows)
    check("G20-qp-wards", res_worst <= QP_RES_BAR and mass_ok,
          "constrained-equilibrium QP (r232a verbatim, warm-"
          "started profile grids): residual worst %.1e (bar "
          "%.0e); every rounded mass integer-exact; spot det M "
          "%.1e (bar %.0e); spot Richardson vs analytic h_model "
          "%.1e (bar %.0e) -- the r250 model stands unmodified"
          % (res_worst, QP_RES_BAR, detm_worst, DETM_BAR,
             rich_worst, RICH_BAR))
    check("G21-kernel-pass-wards",
          dety_worst <= DETY_BAR and chain_worst <= CHAIN_BAR
          and fin_ok and detm_worst <= DETM_BAR
          and rich_worst <= RICH_BAR,
          "det Y_n = 1 at every sampled snapshot point to %.1e "
          "(bar %.0e); mp gammahat vs f64 wpack chain worst %.1e "
          "(bar %.0e); balanced Y/M kernel columns all finite in "
          "complex128 (max |log10| %.1f, headroom %.1f decades "
          "to overflow)"
          % (dety_worst, DETY_BAR, chain_worst, CHAIN_BAR,
             lgmax_worst, 308.0 - lgmax_worst))

    # ---------------- S3: leg A -- the exact formulas, gated
    section("S3  LEG A -- EXACT READOUT-ERROR FORMULAS")
    # (a1) delta h = (R1)_12 (own high-dps far-point pass:
    # the far-z Cauchy column cancels ~ (n+1) log10|z| digits)
    a1_worst = 0.0
    a1_note = []
    dety_a1 = 0.0
    m1_ratio_min = float("inf")
    dps_a1 = 400 if smoke else DPS_A1
    for kz in a1_windows:
        Wk = W[kz]
        N = Wk["N"]
        degs = (N // 2,) if smoke else (N // 2, N - 1)
        zfar = [Wk["x0"] + NORM_OFFS[0], Wk["x0"] + NORM_OFFS[1]]
        hlA, _gmA, _lvA, ysA, dA = mp_kernel_pass(
            Wk["d"], zfar, {n: [0, 1] for n in degs},
            {min(degs)}, dps_a1, N)
        dety_a1 = max(dety_a1, dA)
        for n in degs:
            md = Wk["mds"][n]
            mp.mp.dps = dps_a1
            lg, sg = hlA[n]
            h_true = sg * mp.e ** lg
            h_mod = mp.e ** (mp.mpf(md["hmod_l10"]) * mp.log(10))
            delta = h_true - h_mod
            vals12, vals21 = [], []
            for j, zf in enumerate(zfar):
                z = mp.mpc(zf)
                Y = ysA[n][j]
                M = CB.model_at(md, complex(zf), DPS_MR)
                mp.mp.dps = dps_a1
                R, _dR = r_field(Y, M)
                vals12.append((z, z * R[0][1]))
                vals21.append((z, z * R[1][0]))
            (z1, v1), (z2, v2) = vals12
            rich12 = (z2 * v2 - z1 * v1) / (z2 - z1)
            (z1, u1), (z2, u2) = vals21
            rich21 = (z2 * u2 - z1 * u1) / (z2 - z1)
            scale = max(abs(h_true), abs(h_mod))
            dev = float(abs(rich12 - delta) / scale)
            dev21 = float(abs(rich21 - delta) / scale)
            a1_worst = max(a1_worst, dev)
            m1_ratio_min = min(m1_ratio_min,
                               dev21 / max(dev, 1e-300))
            a1_note.append("w%d n=%d dev %.1e" % (kz, n, dev))
    check("G30-a1-deltah-contour-identity",
          a1_worst <= A1_BAR and dety_a1 <= DETY_BAR,
          "delta h_n = h_n - h_n^out = (R1)_12 (EXACT: Y1 = R1 + "
          "M1, no cross term at 1/z): 2-point Richardson at the "
          "sealed norm points x0+1e2/x0+1e3 (own mp pass, dps "
          "%d, det Y ward %.1e) vs the direct difference: %s -- "
          "worst %.1e (bar %.0e): the base readout error IS a "
          "contour functional of the error field R"
          % (dps_a1, dety_a1, "; ".join(a1_note), a1_worst,
             A1_BAR))

    # (a2) the remainder identity + reg anchor, per window
    fib = {}
    route_worst = 0.0
    reg_worst = 0.0
    reg_note = []
    for kz in windows:
        Wk = W[kz]
        N = Wk["N"]
        A0 = Wk["A0"]
        at = Wk["atoms0"]
        wv = Wk["wts0"]
        Dn = (at[None, :] - at[:, None]
              + 1j * (FIB_DY - FIB_DX))
        KY, KM = {}, {}
        for m in (FIB_LO, N):
            u, v, _g = Wk["cols"][m]
            KY[m] = pair_kernel(u[:A0], v[:A0],
                                u[A0:2 * A0], v[A0:2 * A0], Dn)
            KM[m] = pair_kernel(Wk["mu"][m][:A0],
                                Wk["mv"][m][:A0],
                                Wk["mu"][m][A0:],
                                Wk["mv"][m][A0:], Dn)

        def pr(K):
            return float(np.real(wv @ K @ wv))

        TY_diff = pr(KY[N] - KY[FIB_LO])
        TM_diff = pr(KM[N] - KM[FIB_LO])
        dT_A = TY_diff - TM_diff
        Krem = (KY[N] - KM[N]) - (KY[FIB_LO] - KM[FIB_LO])
        dT_B = pr(Krem)
        gross = float(np.abs(wv) @ np.abs(Krem) @ np.abs(wv)) \
            + sum(float(np.abs(wv) @ np.abs(K) @ np.abs(wv))
                  for K in (KY[N], KM[N], KY[FIB_LO],
                            KM[FIB_LO]))
        route_dev = abs(dT_A - dT_B) / max(gross, 1e-300)
        route_worst = max(route_worst, route_dev)
        T_true = Wk["p"]["St"] - float(Wk["p"]["S"][FIB_LO - 1])
        reg = abs(TY_diff / T_true - 1.0) if stride == 1 else \
            float("nan")
        if stride == 1:
            reg_worst = max(reg_worst, reg)
            reg_note.append("w%d %+.1e" % (kz, TY_diff / T_true
                                           - 1.0))
        # naive (level-N only) pairings for leg C
        TY_nav = pr(KY[N])
        TM_nav = pr(KM[N])
        # m2 material (w9): Y-side top-level shift N -> N-1
        top_shift = float("nan")
        if kz == 9:
            u, v, _g = y_columns(Wk["lvv"][N - 1], 2 * A0)
            Km1 = pair_kernel(u[:A0], v[:A0], u[A0:], v[A0:],
                              Dn)
            top_shift = TY_nav - pr(Km1)
            del Km1
        # m3 material: naive against raw border sigma (uncentered)
        wsig = wv.copy()
        wsig[Wk["nb"]:] = 0.0
        TY_nav_sig = float(np.real(wsig @ KY[N] @ wsig))
        fib[kz] = dict(TY_diff=TY_diff, TM_diff=TM_diff,
                       dT=dT_A, T_true=T_true,
                       dT_nav=TY_nav - TM_nav,
                       TY_nav=TY_nav, TY_nav_sig=TY_nav_sig,
                       top_shift=top_shift, gross=gross)
        del KY, KM, Krem
    check("G31-a2-remainder-identity-routes",
          route_worst <= A2_ROUTE_BAR,
          "T^Y - T^M = intint([K^Y_N - K^M_N] - [K^Y_8 - K^M_8]) "
          "dsigma0 dsigma0: separately-paired terms vs the "
          "assembled difference kernel: worst dev %.1e on the "
          "absolute mass-norm scale (bar %.0e) -- the central "
          "evaluation formula of r250-R4 is implemented exactly"
          % (route_worst, A2_ROUTE_BAR))
    check("G32-a2-regularization-anchor",
          (reg_worst <= REG_SYS_BAR) if stride == 1 else True,
          ("T^Y_reg vs the bitwise r244 chain readout T_true: "
           "rel dev %s -- worst %.1e (bar %.2f): the sealed "
           "off-axis contour carries the object; delta T is a "
           "bill about the OBJECT, not about the regularization"
           % ("; ".join(reg_note), reg_worst, REG_SYS_BAR))
          if stride == 1 else
          "SMOKE: strided atoms -- chain anchor not applicable")

    # (a3) sandwich identity at level N (sealed 5x5 sample pairs;
    # combination at DPS_SAND -- both sides consume the same Y/M
    # inputs, the gate tests the exact algebra)
    a3_worst = 0.0
    dps_sand = 300 if smoke else DPS_SAND
    for kz in windows:
        Wk = W[kz]
        N = Wk["N"]
        A0 = Wk["A0"]
        md = Wk["mds"][N]
        lvm = Wk["lvv"][N]
        pairs = []
        for i in Wk["sand_x"]:
            for j in Wk["sand_y"]:
                Mx = CB.model_at(md, complex(Wk["zpts"][i]),
                                 DPS_MR, variant=KVAR)
                My = CB.model_at(md,
                                 complex(Wk["zpts"][A0 + j]),
                                 DPS_MR, variant=KVAR)
                mp.mp.dps = dps_sand
                zxq = mp.mpc(Wk["zpts"][i])
                zyq = mp.mpc(Wk["zpts"][A0 + j])
                pNx, pN1x, h = lv_pi(lvm, i)
                pNy, pN1y, _h = lv_pi(lvm, A0 + j)
                kY = (pNy * pN1x - pN1y * pNx) / (h * (zyq - zxq))
                kM = (My[0][0] * Mx[1][0]
                      - My[1][0] * Mx[0][0]) / (zyq - zxq)
                Yx = Wk["ysnap"][N][i]
                Yy = Wk["ysnap"][N][A0 + j]
                Rx, _dx_ = r_field(Yx, Mx)
                Ry, dRy = r_field(Yy, My)
                Ra = m_adj2(Ry)
                Ryi = ((Ra[0][0] / dRy, Ra[0][1] / dRy),
                       (Ra[1][0] / dRy, Ra[1][1] / dRy))
                E = m_mul2(Ryi, Rx)
                E = ((E[0][0] - 1, E[0][1]),
                     (E[1][0], E[1][1] - 1))
                detMy = m_det2(My)
                r2 = (-My[1][0] / detMy, My[0][0] / detMy)
                c1 = (Mx[0][0], Mx[1][0])
                sand = (r2[0] * (E[0][0] * c1[0] + E[0][1] * c1[1])
                        + r2[1] * (E[1][0] * c1[0]
                                   + E[1][1] * c1[1])) \
                    / (zyq - zxq)
                pairs.append((kY - kM, sand))
        gsc = max(max(abs(a), abs(b)) for a, b in pairs)
        dev = max(float(abs(a - b)) for a, b in pairs) \
            / max(float(gsc), 1e-300)
        a3_worst = max(a3_worst, dev)
    check("G33-a3-sandwich-identity", a3_worst <= A3_BAR,
          "K^Y - K^M = (row2 M^{-1}(y)) [R^{-1}(y) R(x) - I] "
          "(col1 M(x)) / (y - x): direct vs sandwich on the "
          "sealed %dx%d sample pairs at level N: worst "
          "sup-normalized dev %.1e (bar %.0e) -- the fiber "
          "transfer consumes EXACTLY this bilinear form of "
          "(R - I)" % (SAND_K, SAND_K, a3_worst, A3_BAR))

    # (a4) the FULL-D pole obstruction, measured and typed
    pole_max = 0.0
    for kz in windows:
        Wk = W[kz]
        dec = d_pole_dec(Wk["mds"][Wk["N"]],
                         Wk["atoms0"] + 1j * FIB_DX)
        pole_max = max(pole_max, float(np.max(dec)))
    pole_obstructed = pole_max >= POLE_DEC_BAR
    check("G34-fullD-pole-obstruction", True,
          "the FULL r250 model's discrete Szego layer D(z) at "
          "the sigma0 atoms (+ i dx): max |Re log10 D| = %.1f "
          "decades (bar %.0f; f64 ceiling 308) => %s -- "
          "sharpens the r250 ablation finding (bare beats "
          "dressed): the arcsine-cell D is not sigma0-PAIRABLE; "
          "kernel legs run the sealed noD member"
          % (pole_max, POLE_DEC_BAR,
             "MODEL_KERNEL_POLE_OBSTRUCTION (typed)"
             if pole_obstructed else "no obstruction"))

    # ---------------- S4: leg B -- amplification
    section("S4  LEG B -- THE AMPLIFICATION FACTOR")
    amp = {}
    for kz in windows:
        Wk = W[kz]
        N = Wk["N"]
        A0 = Wk["A0"]
        dps = 80 if smoke else DPS_KERN[kz]
        mp.mp.dps = dps
        errs = {}
        efull = []
        for m in (FIB_LO, N):
            md = Wk["mds"][m]
            nl = md["nl"]
            ev, wv_x, eYM = [], [], []
            for im, iz in enumerate(Wk["mid_ids"]):
                Y = Wk["ysnap"][m][iz]
                M = CB.model_at(md, complex(Wk["zpts"][iz]),
                                DPS_MR, variant=KVAR)
                e = CB.err_RI(Y, M, nl)
                ev.append(e)
                wv_x.append(Wk["wmid"][im])
                if m == N:
                    Mf = CB.model_at(md,
                                     complex(Wk["zpts"][iz]),
                                     DPS_MR)
                    efull.append(CB.err_RI(Y, Mf, nl))
                # normalized-gauge Y - M scale (model-relative)
                enl = mp.e ** mp.mpf(nl)
                Dm = ((Y[0][0] - M[0][0],
                       (Y[0][1] - M[0][1]) / enl),
                      ((Y[1][0] - M[1][0]) * enl,
                       Y[1][1] - M[1][1]))
                Mn = ((M[0][0], M[0][1] / enl),
                      (M[1][0] * enl, M[1][1]))
                nrm = math.sqrt(sum(float(abs(Mn[a][b])) ** 2
                                    for a in (0, 1)
                                    for b in (0, 1)))
                eYM.append(math.sqrt(
                    sum(float(abs(Dm[a][b])) ** 2
                        for a in (0, 1) for b in (0, 1)))
                    / max(nrm, 1e-300))
            sup = float(np.max(ev))
            wsum = float(np.sum(wv_x))
            l2 = math.sqrt(float(np.sum(
                np.asarray(wv_x) * np.asarray(ev) ** 2))
                / max(wsum, 1e-300))
            errs[m] = dict(sup=sup, l2=l2,
                           ym=float(np.max(eYM)))
        dT = abs(fib[kz]["dT"])
        amp[kz] = dict(
            eps_sup=errs[N]["sup"], eps_l2=errs[N]["l2"],
            eps_ym=errs[N]["ym"], eps8=errs[FIB_LO]["sup"],
            A_sup=dT / max(errs[N]["sup"], 1e-300),
            A_l2=dT / max(errs[N]["l2"], 1e-300),
            q_c2=dT / max(errs[N]["ym"], 1e-300))
        info("w%-3d eps_sup %.3g  eps_L2 %.3g  eps_YM %.3g  "
             "eps_sup(8) %.3g  |dT| %.3g  A_sup %.3g  A_L2 %.3g"
             "  [full-D err med %.3g]"
             % (kz, errs[N]["sup"], errs[N]["l2"],
                errs[N]["ym"], errs[FIB_LO]["sup"], dT,
                amp[kz]["A_sup"], amp[kz]["A_l2"],
                float(np.median(efull))))
    Ns = [W[kz]["N"] for kz in windows]
    if len(windows) > 1:
        sp_amp = spear([amp[kz]["A_sup"] for kz in windows], Ns)
        p_amp = float(np.polyfit(
            np.log10(Ns),
            np.log10([max(amp[kz]["A_sup"], 1e-300)
                      for kz in windows]), 1)[0])
    else:
        sp_amp, p_amp = float("nan"), float("nan")
    check("G40-amplification-measured", True,
          "A_w = |delta T| / eps (rows above): Spearman(A_sup; "
          "N) = %+.2f, log-log slope p = %+.2f (sealed tags: "
          "EXTENSIVE iff p >= %.1f AND Spearman >= %.1f; BOUNDED "
          "iff Spearman <= 0; else MIXED)"
          % (sp_amp, p_amp, AMP_SLOPE_BAR, AMP_SP_BAR))

    # ---------------- S5: leg C -- annihilation
    section("S5  LEG C -- ANNIHILATION IN THE ERROR")
    dec_bought = []
    for kz in windows:
        f = fib[kz]
        q = abs(f["dT"]) / max(abs(f["dT_nav"]), 1e-300)
        dec = -math.log10(max(q, 1e-300))
        dec_bought.append(dec)
        f["q_annihil"] = q
        info("w%-3d dT %+0.4g  dT_naiv %+0.4g  q_annihil %.3g  "
             "decades bought %+.2f"
             % (kz, f["dT"], f["dT_nav"], q, dec))
    med_dec = float(np.median(dec_bought))
    buys = med_dec >= ANNIHIL_DEC_BAR
    check("G50-annihilation-c1", True,
          "q_annihil = |dT(K_N - K_8)| / |dT_naiv(K_N)| per "
          "window (rows above; sigma0 fixed in both, so the "
          "quotient isolates the mode-1..7 + level-8 subtraction "
          "gain in the ERROR): median decades bought %+.2f "
          "(sealed bar %.1f) => %s"
          % (med_dec, ANNIHIL_DEC_BAR,
             "ANNIHILATION_BUYS" if buys
             else "ANNIHILATION_NEUTRAL"))
    if len(windows) > 1:
        q_c2 = [amp[kz]["q_c2"] for kz in windows]
        sp_c2 = spear(q_c2, Ns)
        sl_c2 = float(np.polyfit(
            np.log10(Ns),
            np.log10([max(v, 1e-300) for v in q_c2]), 1)[0])
    else:
        sp_c2, sl_c2 = float("nan"), float("nan")
    check("G51-annihilation-c2-Ntrend", True,
          "|delta T| / eps_YM across the ladder: %s; "
          "Spearman(q; N) = %+.2f, log-log slope %+.2f (sealed "
          "reading: <= %.1f = the rest zone carries analytically "
          "with N; flat/rising = the fiber sits genuinely in the "
          "error term)"
          % (str({("w%d" % kz): round(amp[kz]["q_c2"], 3)
                  for kz in windows}), sp_c2, sl_c2, C2_SP_BAR))

    # ---------------- S6: leg D -- margin tables + worlds
    section("S6  LEG D -- MARGIN RELEVANCE + WORLDS")
    base_max = 0.0
    slope_ok_n = 0
    off_meds = []
    prof_note = []
    for kz in windows:
        Wk = W[kz]
        N = Wk["N"]
        rows = Wk["rows"]
        ns, dls = [], []
        for n in Wk["grid"]:
            if n >= N or n not in Wk["mds"]:
                continue
            dl = (rows[n]["lg_h"] / math.log(10)
                  - Wk["mds"][n]["hmod_l10"])
            ns.append(n)
            dls.append(dl)
        rat = [abs(10.0 ** dl - 1.0) for dl in dls]
        base_max = max(base_max, max(rat))
        sl = float(np.polyfit(ns, dls, 1)[0])
        off = float(np.median(dls))
        off_meds.append(abs(off))
        if abs(sl) <= H_RATE_BAR:
            slope_ok_n += 1
        qs = np.percentile(rat, [25, 50, 75])
        prof_note.append(
            "w%d ratio q25/med/q75 %.3f/%.3f/%.3f max %.4f "
            "slope %+.4f off %+.2f"
            % (kz, qs[0], qs[1], qs[2], max(rat), sl, off))
    for t in prof_note:
        info(t)
    check("G60-base-profile", True,
          "|delta h_n|/h_n^out over the sealed profile grid (ALL "
          "free-degree strides, not just terminal): max %.4f "
          "(PROVABLE bar %.1f); offset/rate split: |slope| <= "
          "%.2f dec/degree on %d/%d windows, median |offset| "
          "%.2f decades (bar %.1f) -- the sealed classification "
          "is applied in the verdict"
          % (base_max, BASE_RATIO_BAR, H_RATE_BAR, slope_ok_n,
             len(windows), float(np.median(off_meds)),
             OFFSET_DEC_BAR))
    # fiber margin table
    ratio_fib = {}
    anchor_ok = True
    for kz in windows:
        Wk = W[kz]
        p = Wk["p"]
        N = Wk["N"]
        f = fib[kz]
        B = float(p["S"][N - 2]) + 5.0 / 7.0
        B0 = B - float(p["rho"][0])
        Q7 = float(p["S"][FIB_LO - 1]) - float(p["rho"][0])
        marg_out = B0 - Q7 - f["TM_diff"]
        marg_true = B0 - Q7 - f["T_true"]
        anchor = 5.0 / 7.0 - float(p["rho"][N - 1])
        anchor_ok = anchor_ok and (
            abs(marg_true - anchor) <= 1e-9)
        f["marg_true"] = marg_true
        ratio_fib[kz] = abs(f["dT"]) / max(abs(marg_true),
                                           1e-300)
        info("w%-3d T_true %+.4f  T_out %+.4f  dT %+.4f  "
             "margin_true %+.4f  margin_out %+.4f  "
             "|dT|/|margin_true| %.3g"
             % (kz, f["T_true"], f["TM_diff"], f["dT"],
                marg_true, marg_out, ratio_fib[kz]))
    hypo = [amp[kz]["A_sup"] / W[kz]["N"]
            / max(abs(fib[kz]["marg_true"]), 1e-300)
            for kz in windows]
    check("G61-fiber-margin", anchor_ok,
          "|delta T| vs the TRUE parametric margin B0 - Q_7 - "
          "T_true (amended comparison object, see spec; B = "
          "S_{N-2} + 5/7, r243/r247 placeholder, status "
          "IMPORTED -- corner_provenance runs in parallel): "
          "rows above; anchor identity B0 - Q_7 - T_true = "
          "5/7 - rho_{N-1} exact on %d/%d; hypothetical balance "
          "(A/N)/|margin_true| median %.3g (>= 1 would mean a "
          "1/N-falling matrix error does NOT carry the fiber)"
          % (len(windows), len(windows),
             float(np.median(hypo))))
    # worlds
    if smoke:
        world_verdict = "WORLD_SKIPPED_SMOKE"
        check("G62-worlds", True, "SMOKE: world block skipped")
    else:
        pS = ctrl["SCRAMBLE"]
        dS = pS["d"]
        NS = pS["N"]
        dsmS = pS["dsm"]
        xS, wtS, AS, LipS, VS = CB.eq_field(dS)
        c0S = pS["Fv"][0] / pS["hv"][0]
        batS = np.concatenate([dsmS["xs"], dsmS["ys"]])
        bwtS = np.concatenate([dsmS["ws"], -dsmS["vs"]])
        at_S = np.concatenate([batS, xS])
        wv_S = np.concatenate([bwtS, -c0S * wtS])
        A0S = len(at_S)
        zS = (list(at_S + 1j * FIB_DX)
              + list(at_S + 1j * FIB_DY))
        rhoS = None
        mdsS = {}
        for n in (FIB_LO, NS):
            rhoS, resS = SZ.solve_qp(AS, LipS, VS, float(n),
                                     rho0=rhoS, iters=QP_ITERS,
                                     tol=QP_TOL)
            res_worst = max(res_worst, resS)
            mdsS[n] = CB.model_data(xS, wtS, AS, VS, rhoS, n)
        _hl, _gm, lvS, _ys, detyS = mp_kernel_pass(
            dS, zS, {}, {FIB_LO, NS}, DPS_KERN[9], NS)
        dety_worst = max(dety_worst, detyS)
        DnS = (at_S[None, :] - at_S[:, None]
               + 1j * (FIB_DY - FIB_DX))
        TY_S, TM_S = {}, {}
        for m in (FIB_LO, NS):
            u, v, _g = y_columns(lvS[m], 2 * A0S)
            K = pair_kernel(u[:A0S], v[:A0S], u[A0S:], v[A0S:],
                            DnS)
            TY_S[m] = float(np.real(wv_S @ K @ wv_S))
            uu, vv = m_columns(mdsS[m], zS, DPS_MK)
            K = pair_kernel(uu[:A0S], vv[:A0S], uu[A0S:],
                            vv[A0S:], DnS)
            TM_S[m] = float(np.real(wv_S @ K @ wv_S))
            del K
        T_true_S = pS["St"] - float(pS["S"][FIB_LO - 1])
        dT_S = (TY_S[NS] - TY_S[FIB_LO]) \
            - (TM_S[NS] - TM_S[FIB_LO])
        dT_M = fib[9]["dT"]
        gap_obj = T_true_S - fib[9]["T_true"]
        share = abs(dT_S - dT_M) / max(abs(gap_obj), 1e-300)
        decs = math.log10(max(abs(dT_S), 1e-300)
                          / max(abs(dT_M), 1e-300))
        in_dt = WORLD_SH_LO <= share <= WORLD_SH_HI
        world_verdict = ("WORLD_GAP_IN_DELTA_T" if in_dt
                         else "WORLD_GAP_ELSEWHERE")
        check("G62-worlds", True,
              "SCRAMBLE (seed 1, full depth %d): T_true %+.4g vs "
              "MAIN %+.4g (object gap %+.4g); delta T %+.4g vs "
              "MAIN %+.4g: share of the object gap landing in "
              "delta T = %.3f (sealed window [%.1f, %.1f]) => "
              "%s; decade offset %+.2f -- the world-blind outer "
              "model pushes the arithmetic difference into the "
              "error term (r250 MODEL_WORLD_BLIND consistent)"
              % (NS, T_true_S, fib[9]["T_true"], gap_obj, dT_S,
                 dT_M, share, WORLD_SH_LO, WORLD_SH_HI,
                 world_verdict, decs))

    # ---------------- S7: must-fails
    section("S7  MUST-FAILS")
    ok_m1 = m1_ratio_min >= M1_LOUD
    # m2: model low-level mass shift 7 posing as 8 (w9)
    Wk = W[9]
    A0 = Wk["A0"]
    at = Wk["atoms0"]
    wv = Wk["wts0"]
    Dn = at[None, :] - at[:, None] + 1j * (FIB_DY - FIB_DX)
    uu, vv = m_columns(Wk["mds"][7], Wk["zpts"][:2 * A0], DPS_MK)
    K7 = pair_kernel(uu[:A0], vv[:A0], uu[A0:], vv[A0:], Dn)
    TM7 = float(np.real(wv @ K7 @ wv))
    del K7
    uu, vv = Wk["mu"][FIB_LO], Wk["mv"][FIB_LO]
    K8 = pair_kernel(uu[:A0], vv[:A0], uu[A0:], vv[A0:], Dn)
    TM8 = float(np.real(wv @ K8 @ wv))
    del K8, Dn
    m2_inert = abs(TM7 - TM8)
    m2_floor = max(1e-3 * abs(fib[9]["TM_diff"]),
                   abs(fib[9]["TY_diff"] - fib[9]["T_true"])
                   if stride == 1 else 1e-3)
    rho_top = float(W[9]["p"]["rho"][W[9]["N"] - 1])
    m2_shift = fib[9]["top_shift"]
    m2_rel = abs(m2_shift / rho_top - 1.0)
    ok_m2 = (m2_rel <= 0.05
             and m2_shift >= 100.0 * m2_floor) or smoke
    # m3: uncentered alias (raw border sigma vs sigma0, level N)
    rho0 = float(W[9]["p"]["rho"][0])
    m3_gap = abs(fib[9]["TY_nav_sig"] - fib[9]["TY_nav"])
    m3_ratio = m3_gap / max(rho0, 1e-300)
    ok_m3 = (M3_LO <= m3_ratio <= M3_HI) or smoke
    # (strided smoke atoms carry no moment identities: m2/m3
    # are adjudicated in the FULL record only, values reported)
    check("G70-must-fails-fire", ok_m1 and ok_m2 and ok_m3,
          "m1 swapped R1 entry (21 for 12): dev ratio >= %.1e "
          "on every a1 combo (min %.1e, LOUD -- the transposed "
          "entry carries the e^{-2 n ell} gauge); m2 Y-side "
          "top-level shift (K_{N-1} for K_N): T moves by %.4g "
          "vs rho_{N-1} = %.4g (rel dev %.1e <= 0.05, %.0f x "
          "the anchor %.3g: level-pinned and LOUD; the inert "
          "model-side mass-7 shift %.2g is reported, amendment "
          "disclosed); m3 uncentered alias: naive(sigma) - "
          "naive(sigma0) = %.4g vs rho_0 = %.4g (ratio %.3f in "
          "[%.1f, %.1f]: the r248 rank-1 head, loud); m4 sign "
          "oracle: EXCLUDED by the input firewall (standing "
          "r243 exclusion)"
          % (M1_LOUD, m1_ratio_min, m2_shift, rho_top, m2_rel,
             m2_shift / max(m2_floor, 1e-300), m2_floor,
             m2_inert,
             m3_gap, rho0, m3_ratio, M3_LO, M3_HI))

    # ---------------- S8: verdict
    section("S8  VERDICT")
    formulas_ok = (a1_worst <= A1_BAR
                   and route_worst <= A2_ROUTE_BAR
                   and (reg_worst <= REG_SYS_BAR
                        if stride == 1 else True)
                   and a3_worst <= A3_BAR)
    vA = ("READOUT_FORMULAS_EXACT" if formulas_ok
          else "READOUT_FORMULAS_OPEN")
    if smoke or len(windows) < 2:
        vB = "AMPLIFICATION_SMOKE_NA"
        vC2_fall = False
    else:
        if p_amp >= AMP_SLOPE_BAR and sp_amp >= AMP_SP_BAR:
            vB = "AMPLIFICATION_EXTENSIVE(p=%.2f)" % p_amp
        elif sp_amp <= 0.0:
            vB = "AMPLIFICATION_BOUNDED"
        else:
            vB = "AMPLIFICATION_MIXED(p=%.2f, sp=%.2f)" % (
                p_amp, sp_amp)
        vC2_fall = sp_c2 <= C2_SP_BAR
    vC = ("ANNIHILATION_BUYS(%.2f dec)" % med_dec if buys
          else "ANNIHILATION_NEUTRAL")
    marg_all = all(ratio_fib[kz] < 1.0 for kz in windows)
    if marg_all or (vC2_fall and buys):
        vD = "FIBER_ERROR_CONTROLLABLE"
    else:
        vD = "FIBER_IN_ERROR_CONFIRMED"
    if base_max <= BASE_RATIO_BAR:
        vE = "BASE_READOUT_PROVABLE"
    elif (slope_ok_n >= max(1, len(windows) // 2)
          and float(np.median(off_meds)) >= OFFSET_DEC_BAR):
        vE = "BASE_READOUT_BLOCKED_BY_OFFSET"
    else:
        vE = "BASE_READOUT_BLOCKED_STRUCTURAL"
    check("G80-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED (an evaluation-"
          "formula round moves no edge); what the round adds: "
          "the exact delta-h contour identity, the exact delta-T "
          "remainder evaluation, the sandwiched error-kernel "
          "form, the measured A-factor, the annihilation "
          "quotients, and the margin bill against the parametric "
          "B placeholder")
    verd = " + ".join([vA, vB, vC, vD, vE, world_verdict])
    if pole_obstructed:
        verd += " + MODEL_KERNEL_POLE_OBSTRUCTION(FULL_D)"
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G81-verdict", npass == len(CHECKS),
          "%s%s -- MEASURED: the readout-error formulas hold "
          "exactly, the A-factor scaling, the annihilation "
          "decades, the base profile bill, the fiber margin "
          "bill, the world split; OPEN: the budget bound and "
          "the base law themselves (r243/r247/r250 stand); "
          "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())
'''

# ------------- frozen probe source base_gauge_constant_probe (embedded BYTE-EXACT, raw string)
_SRC_4 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""base_gauge_constant_probe -- PRIME.PORT.RHP.BASE.GAUGE_CONSTANT.01
(round 252): IS THE MISSING h CONSTANT JUST A WRONG GLOBAL GAUGE?
The reviewer re-adjudication of this round's contract: r250/r251
measured that the outer model M_n carries the h RATE (slope <=
0.007 dec/degree, 4/4 windows) with a large offset (median
-1.25..-1.45, terminal -1.69..-1.86 decades in the Delta_n =
log10|h_n| - log10 h_n^out convention) and froze
BASE_READOUT_BLOCKED_BY_OFFSET.  Core thesis to test FIRST: if
the offset is a global (per-window) gauge constant, it CANCELS IN
QUOTIENTS -- h_{w,n} = h_{w,0} prod_j gamma_{w,j}, so the base
positivity question needs h_0 > 0 plus gamma_j > 0 and NO absolute
norming model at all.  DO NOT FIT -- DIVIDE.

REVIEWER AMENDMENT, DISCLOSED (before calibration): this round was
first drafted as PRIME.PORT.RHP.OUTER.CONSTLAYER.01
(outer_constlayer_probe.py, spec sealed, SMOKE pass only -- w9,
PROF_PTS 8, no full-record evaluation, no record freeze).  The
reviewer re-adjudicated the contract BEFORE calibration: absolute
constant-layer candidates are demoted to priority (4); the
quotient test, the h_0 normalizer, and the gauge adjudication come
first; hard orientation gates are added.  Disclosed smoke
knowledge carried over: the w9 smoke showed raw offset median
-1.26 (r251 reproduced), the b1 saturation-LSE candidate
UNDER-corrects on w9 (offset -1.15) and overshoots the toy by
-0.31 dec, the b2 Szego-continuum constant is tiny, and the
universal-constant battery members that fit the windows fail the
Chebyshev toy -- the battery is RETIRED by the amendment; b1/b2
move to leg 4.  No full-window, no multi-window, no quotient
number was seen before this seal.

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

INDEX FIREWALL (binding, r238-r251 discipline): w = window (kz),
N_w = builder depth, n = chain degree; free pivots h_{w,n}
(n < N_w) are the proof objects; the forced pivot h_N is NEVER
formed (all sweeps stop at N-1); ground truth (h values / signs /
flip degrees of the tested chain) enters RESIDUALS, QUOTIENT
STATISTICS AND GATES ONLY -- no model path consumes it; the model
side is the r250 outer model VERBATIM (r232a constrained-
equilibrium g, KKT-midpoint ell, discrete Szego D, -2 pi i
calibration; machinery imported from centered_basefiber_probe, no
refit of D or ell anywhere).  The h_0-normalizer (leg 2) consumes
the chain HEAD (degree <= 2 mass data) as a disclosed source-pure
input normalizer -- h_0 is the total mass of the functional, not
a target pivot.  No zero/prime oracles anywhere (AST firewall).

LEG 1 -- QUOTIENT TEST FIRST (the round's core measurement):
Delta_{w,n} = log10|h_{w,n}| - log10 h^out_{w,n} and
eta_{w,n} = Delta_{w,n} - Delta_{w,n-1} = log10|gamma_{w,n} /
gamma^out_{w,n}|, gamma_{w,n} = h_{w,n}/h_{w,n-1}.  Measured over
ALL free degrees (QP equilibrium at EVERY mass n in [2, N_w - 1],
warm-started ascending; eta from n = 3 -- the model needs a
two-node hull, the excluded n <= 2 head is the r248 rank-1 zone,
disclosed), on the four mp-warded main windows, plus the pre-flip
quotient anatomy on EPSTEIN/SMOOTH and a BLIND-position sample of
the r233 42-rung frame-A ladder (rate check).  Degree-resolved
statistics per window: max |eta| (+ its degree), median eta,
median |eta|, total drift Delta_{N-1} - Delta_2, Delta slope,
last-10 median.  THREE SEALED CASES:
  BASE_RATIO_EXACT iff max |eta| <= 0.02 dec on all four main
    windows (the ratio is exact to propagated error -- the
    constant is IRRELEVANT for the sign question);
  RATE_ONLY_NUMERICAL iff a blind-ladder |Delta slope| > 0.01
    dec/degree OR a control's near-flip blowup factor (last-5
    median |eta| / max(bulk median |eta|, 1e-3)) > 10 OR the
    gauge-layer bars below fail (typed reason printed);
  BASE_GAUGE_LAYER iff |median eta| <= 0.005 dec AND max |eta|
    <= 0.5 dec on all four main windows (the systematic
    per-degree quotient error is at the half-percent level --
    only the small quotient error needs control).
LEG 2 -- h_0 NORMALIZER: C_w^(0) = h_{w,n0}/h^out_{w,n0} at the
sealed anchor degree n0 = 2 (the lowest model-representable
degree; h_2 = h_0 gamma_1 gamma_2 is head mass data, disclosed
implementation of the h_0 normalizer).  Then WITHOUT any further
adjustment: rest_n = Delta_n - Delta_2 over all degrees;
C0_NORMALIZER_CARRIES iff max |rest| < 0.5 dec on all four
windows, else C0_NORMALIZER_INSUFFICIENT (max rest reported).
LEG 3 -- DIAGONAL RH GAUGE: a constant G_w = diag(c_w, 1/c_w)
scales the offdiagonal readouts by c_w^{+-2} without touching the
phase rate.  Adjudicated by CONVENTION, never by fit: both Y_n
(r227/r234 FIK form, monic, h = (Y1)_12) and M_n satisfy the SAME
z^{-n sigma3} normalization at infinity with det = 1; the
Richardson extraction of (M1)_12 at the sealed norm points vs the
analytic h^out (bar 1e-4 in decades, r250 machinery), det M (bar
1e-30) and arg (M1)_12 (bar 1e-6) at degrees {N//2, N-1} per
window PIN c_w to 1 at the 1e-4-decade level =>
GAUGE_PINNED_AT_INFINITY (the M normalization is NOT globally
wrong; the offset is model error that must cancel in quotients),
else GAUGE_BROKEN(dev).  The continuum Chebyshev-U anchor (2 pi
4^-n Dinf^2 (b-a)/4 = (pi/2) 4^-n identically, bar 1e-12) fixes
the -2 pi i residue convention.
LEG 4 -- SATURATION/SZEGO DIVISOR (ONLY if legs 2 AND 3 do not
own the layer, i.e. adjudicated iff C0_NORMALIZER_INSUFFICIENT or
GAUGE_BROKEN; otherwise reported unadjudicated): the demoted
candidates, sealed as in the superseded draft: b1 = the
saturation partition sum h^b1 = LSE_{rho <= 1/2}(-F), F = 2 (A
rho) + V (the KKT field; derived from the 0/1-selection trial
polynomial); b2 = the discrete-continuum Szego replacement h^b2 =
h^out (Dinf_cont/Dinf_disc)^2 (M_CONT Gauss-Chebyshev points,
linear-interpolated L).  Acceptance: |median resid| < 0.5 dec AND
|slope| <= 0.01 dec/degree on ALL windows; CALIBRATION DUTY kept
from the retired b3: the accepted formula must anchor the exact
discrete Chebyshev-U toy to |median toy resid| <= 0.25 dec.
LEG 5 -- ORIENTATION MUST-GATES (hard, new): a positive global
factor cannot change a sign -- the solved constant proves the
base only if the model quotients already carry the ORIENTATION.
Gate A (MAIN): gamma^out_{w,n} > 0 up to N_w - 1 on 4/4 (note
h^out = 2 pi e^{n ell} Dinf^2 (b-a)/4 is positive by
construction -- typed if so).  Gate B (controls): first model
flip degree = first true flip degree (EPSTEIN 25 / SMOOTH 27)
within the frozen tolerance +-2.  If the model returns positive
gamma^out on ALL worlds it is arithmetically blind despite the
correct MAIN rate => MODEL_ORIENTATION_BLIND added honestly.
BEST verdict BASE_RATIO_CARRIES_SIGN requires BASE_RATIO_EXACT
AND both orientation gates green.
LEG 6 -- PROOF-READY R_1 INSTRUMENT: R_1 = (1/2 pi i) oint
(R(z) - I) dz on the sealed circle (center x0 = union-node hull
midpoint, radius = half-width + 2.0, K = 64 trapezoid points,
dps 260, w9 at n = N//2) instead of astronomical-z evaluation;
gate: |(R_1)_12 - (h_true - h^out)| / max(|h_true|, h^out) <=
1e-4 (one gate suffices; verifies the r251 delta-h contour
identity in integral form).
MUST-FAILS (each loud): (m1) wrong factor 2 in the KKT field
((A rho) + V), (m2) forgotten square root (LSE(-2F)), (m3)
exponent sign flip (LSE(+F)) -- each must move the b1 residual by
>= max(2.0, |honest| + 1.5) decades (w9, n = N//2); (m6) swapped
contour entry ((R_1)_21 for (R_1)_12) must break the leg-6 gate
by >= 1e3 x (the transposed entry carries the e^{-2 n ell}
gauge); (m4) SIGN ORACLE: reading sign h_{N-1} or any flip degree
into a model path is EXCLUDED by the input firewall (standing
r243 exclusion, re-asserted).

SEALED CONSTANTS: windows (9, 12, 13, 26); control flips
EPSTEIN/SCRAMBLE/SMOOTH = 25/21/27; full sweep masses [2, N-1]
step 1; anchor degree n0 = 2; eta from n = 3; QP: FISTA iters
8000, tol 1e-8, residual bar 1e-6, warm ascending; RHO_SEL 1e-9;
saturation threshold 1/2; mp chain ward w9 dps 120, bar 1e-6 on
|lg h| over all sweep degrees; case bars: exact 0.02, gauge-layer
median 0.005 / max 0.5, ladder rate 0.01 dec/degree, near-flip
factor 10 (floor 1e-3); C0 rest bar 0.5; gauge wards: Richardson
1e-4 dec, det M 1e-30, arg 1e-6, degrees {N//2, N-1}, continuum
identity 1e-12; leg-4 bars 0.5 / 0.01 / toy 0.25; toy = 64
Chebyshev nodes, masses (6, 8, 10, 12, 14, 16), depth 18, M_CONT
2048; controls swept to flip + 10 (pre-flip eta anatomy + the
gate-B model-flip scan); orientation tolerance +-2 degrees;
contour K 64, radius
pad 2.0, dps 260, bar 1e-4, m6 loudness 1e3; ladder sample =
frame-A zones (h <= 900 by the frame-A arithmetic, main windows
excluded) sorted by (h, kz), BLIND = odd positions (r233 rule on
the h-sorted proxy, disclosed -- no predictor constants are
computed here, the sample is anatomy), picks = first/middle/last
BLIND position, grid 12 masses in [2, N-1], flipped rungs typed
and skipped; runtime <= 1800 s; smoke = w9 only, masses 2..41,
toy kept, mp ward / controls sweep / ladder / worlds / contour
skipped, no adjudication.

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  BASE_RATIO_CARRIES_SIGN iff BASE_RATIO_EXACT and both
    orientation gates green (the best verdict);
  else the leg-1 case verdict BASE_RATIO_EXACT /
    BASE_GAUGE_LAYER / RATE_ONLY_NUMERICAL;
+ C0_NORMALIZER_<CARRIES|INSUFFICIENT>(max rest dec)
+ GAUGE_<PINNED_AT_INFINITY|BROKEN>(worst dev dec)
+ SATSZEGO_<NOT_ADJUDICATED|DERIVED(cand)|OPEN> (leg-4 priority
    rule: adjudicated only if legs 2 and 3 both fail to own the
    layer)
+ [MODEL_ORIENTATION_BLIND if gamma^out > 0 on all worlds]
+ R1_CONTOUR_<VERIFIED|FAILED>(dev).
Honesty before beauty: no verdict claims a bound mechanism; the
budget bound and the base law stay OPEN (r243 PAIRCORR_REENCODED,
r247 B discipline, r250 error map, r251 margin bills all stand).

CALIBRATION AMENDMENTS (disclosed, frozen): (a1) the w9 mp chain
ward must snapshot at N-1, not N//2 -- mp_y_pass only recurses to
the maximum snapshot degree, so the first full attempt died on a
KeyError before any ward number existed (pure implementation fix,
no bar or rule touched).  No other amendment; the sealed bars,
cases and priority rules above are exactly the ones adjudicated.

RECORD TABLES (frozen after calibration run 1; run 2 must
reproduce bit-for-bit):
* LEG 1, eta = log10|gamma/gamma^out| over ALL free degrees
  (859 QP equilibria, 4/4 windows mp-warded at dps 120 to
  1.6e-11):
    w9  (N=184): max|eta| 0.731@n=71,  med +0.0230, med|.|
      0.164, drift(Delta_{N-1}-Delta_2) -1.888, slope -0.0033
    w12 (N=151): max|eta| 0.719@n=44,  med +0.0368, med|.|
      0.161, drift -1.465, slope -0.0048
    w13 (N=168): max|eta| 0.629@n=89,  med +0.0006, med|.|
      0.170, drift -1.147, slope -0.0027
    w26 (N=364): max|eta| 0.777@n=158, med +0.0339, med|.|
      0.174, drift -2.098, slope -0.0018
  => SEALED CASE: RATE_ONLY_NUMERICAL ("quotient error not
  uniformly small": worst |med eta| 0.037 > 0.005, max|eta|
  0.777 > 0.5).  THE ROUND'S CENTRAL FINDING: degree-resolved,
  the r250/r251 "window-stable constant offset" DISSOLVES -- the
  offset drifts by -1.1..-2.1 decades from n = 2 to N-1 (fast
  head drop, flat bulk that the r251 coarse grid median saw,
  tail drop) and the per-degree quotient scatter is ~0.17
  decades (the eps-band gamma fluctuation the smooth model
  cannot carry).  The constancy was limited measurement; no
  global gauge constant exists to solve.  Controls pre-flip:
  EPSTEIN med|eta| 0.138 (near-flip factor 0.86), SMOOTH 0.231
  (factor 1.14) -- no near-flip blowup; ladder BLIND sample
  kz23/kz44/kz52 (N = 149/436/878) slopes -0.0022/-0.0022/
  -0.0013, all inside the 0.01 rate bar (the RATE is real; the
  CONSTANT was not).
* LEG 2, C_w^(0) = (h/h^out)(n0=2): w9 -0.184, w12 -0.342, w13
  -0.470, w26 +0.167 dec; rest after C0: max |rest| 1.888/
  1.583/1.558/2.322 dec => C0_NORMALIZER_INSUFFICIENT(2.32).
* LEG 3: Richardson (M1)_12 vs analytic h^out worst 4.0e-06 dec,
  det M worst 4.2e-81, arg worst 0.0 at {N//2, N-1} x 4 windows
  => GAUGE_PINNED_AT_INFINITY (c_w = 1: the offset is NOT a
  convention; the reviewer's gauge thesis dies on all three
  prongs -- quotients, h_0 normalizer, infinity normalization).
* LEG 4 (adjudicated, C0 dead): b1 offs -1.20/-1.26/-1.23/-1.46,
  toy -0.307 ANCHOR-FAIL -> reject; b2 offs -1.20/-1.25/-1.19/
  -1.43, toy -0.075 anchor-OK but offsets stand -> reject
  => SATSZEGO_OPEN.
* LEG 5: MAIN gamma^out > 0 on 4/4 (positive by construction --
  no sign channel); controls: model flip None vs true 25/27
  => MODEL_ORIENTATION_BLIND (honest; BASE_RATIO_CARRIES_SIGN
  unreachable this round).
* LEG 6: contour R_1 on w9 n=92 (K=64, radius 3.00, dps 260):
  |(R_1)_12 - (h_true - h^out)|/scale = 3.2e-14 (bar 1e-4) =>
  R1_CONTOUR_VERIFIED; m6 swapped entry 1.3e+109 x honest
  (LOUD).  Must-fails m1/m2/m3: 28.3/54.6/116.7 dec (LOUD).
* VERDICT: RATE_ONLY_NUMERICAL + C0_NORMALIZER_INSUFFICIENT
  (2.32 dec) + GAUGE_PINNED_AT_INFINITY(4e-06 dec) +
  SATSZEGO_OPEN + MODEL_ORIENTATION_BLIND + R1_CONTOUR_VERIFIED
  (3.2e-14); 22/22 gates, wall 56 s.

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
import mpmath as mp

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

import bordered_hankel_probe as BH           # noqa: E402 r244
import centered_basefiber_probe as CB        # noqa: E402 r250
import port_integrable_kernel_probe as PIK   # noqa: E402 v881
import principal_bessel_probe as PB          # noqa: E402 r243
import szego_equilibrium_probe as SZ         # noqa: E402 r232a
import v563_paper2_readouts as core          # noqa: E402 READ-ONLY

WINDOWS = (9, 12, 13, 26)
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
N0_ANCHOR = 2
ETA_LO = 3
QP_ITERS = 8000
QP_TOL = 1e-8
QP_RES_BAR = 1e-6
RHO_SEL = 1e-9
SAT_THR = 0.5
MP_WARD_DPS = 120
MP_WARD_BAR = 1e-6
ETA_EXACT_MAX = 0.02
ETA_GL_MED = 0.005
ETA_GL_MAX = 0.5
RATE_BAR = 0.01
NEARFLIP_FACTOR = 10.0
NEARFLIP_FLOOR = 1e-3
C0_REST_BAR = 0.5
RICH_BAR = 1e-4
DETM_BAR = 1e-30
ARG_BAR = 1e-6
CHEB_ID_BAR = 1e-12
OFF_BAR4 = 0.5
TOY_ANCHOR_BAR = 0.25
TOY_MASSES = (6, 8, 10, 12, 14, 16)
TOY_M = 64
TOY_DEPTH = 18
M_CONT = 2048
FLIP_TOL = 2
FLIP_SCAN = 10
R1_K = 64
R1_PAD = 2.0
R1_DPS = 260
R1_BAR = 1e-4
M6_LOUD = 1e3
MF_ABS = 2.0
MF_REL = 1.5
LADDER_H_CAP = 900
LADDER_GRID = 12
DPS_SPOT = 80
L10 = math.log(10.0)
CAL_VERDICT = ("RATE_ONLY_NUMERICAL + C0_NORMALIZER_INSUFFICIENT"
               "(2.32 dec) + GAUGE_PINNED_AT_INFINITY(4e-06 dec)"
               " + SATSZEGO_OPEN + MODEL_ORIENTATION_BLIND + "
               "R1_CONTOUR_VERIFIED(3.2e-14)")

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 model consumes "
                       "node positions + |weights| + the QP "
                       "minimizer only; the h_0 normalizer consumes "
                       "the degree <= 2 head (disclosed); h_N never "
                       "formed; target h / signs / flips enter "
                       "residuals and gates only (m4 EXCLUDED)"
                       if not bad else "; ".join(bad))


# ------------------------------------------------- 2x2 mp helpers
def m_adj2(M):
    return ((M[1][1], -M[0][1]), (-M[1][0], M[0][0]))


def m_det2(M):
    return M[0][0] * M[1][1] - M[0][1] * M[1][0]


def m_mul2(A, B):
    return ((A[0][0] * B[0][0] + A[0][1] * B[1][0],
             A[0][0] * B[0][1] + A[0][1] * B[1][1]),
            (A[1][0] * B[0][0] + A[1][1] * B[1][0],
             A[1][0] * B[0][1] + A[1][1] * B[1][1]))


def r_field(Y, M):
    detM = m_det2(M)
    Ra = m_mul2(Y, m_adj2(M))
    return ((Ra[0][0] / detM, Ra[0][1] / detM),
            (Ra[1][0] / detM, Ra[1][1] / detM))


# ----------------------------------------------------- candidates
def lse_l10(t):
    m = float(np.max(t))
    return (m + math.log(float(np.sum(np.exp(t - m))))) / L10


def cand_fields(A, V, wt, rho, n):
    """KKT field, saturation partition, lambda window, b1 LSE."""
    F = 2.0 * (A @ rho) + V
    sel = rho > RHO_SEL
    sat = rho > SAT_THR
    uns = ~sat
    lam_lo = float(np.max(F[sel]))
    lam_hi = float(np.min(F[~sel])) if np.any(~sel) else lam_lo
    return dict(F=F, uns=uns, gap=lam_hi - lam_lo,
                b1=lse_l10(-F[uns]),
                satfrac=float(np.sum(sat)) / max(n, 1))


def b2_l10(md):
    a, b = md["a"], md["b"]
    tt = (0.5 * (a + b) + 0.5 * (b - a)
          * np.cos(math.pi * (np.arange(M_CONT) + 0.5) / M_CONT))
    ll = np.interp(tt, md["xs"], md["L"])
    dinf_c = 0.5 * float(np.mean(ll))
    return md["hmod_l10"] + 2.0 * (dinf_c - md["dinf_log"]) / L10


def ladder_h(kz):
    """frame-A builder depth by the frame-A arithmetic (cheap,
    verbatim the frame_a_zones formula -- no window build)."""
    D_k = 0.5 * float(core.G_ALL[kz]) / float(core.NU_MAIN)
    M_k = int(math.ceil(core.U_ALL[kz] / D_k - 1.0e-9)) + 1
    if M_k % 2:
        M_k += 1
    return M_k // 2


def sweep_window(d, rows, masses, keep_md=()):
    """QP equilibrium at every mass in `masses` (warm ascending);
    returns per-degree arrays (true log10 h, model log10 h, b1,
    b2, satfrac, gap) + kept model_data dicts + worst residual."""
    x, wt, A, Lip, V = CB.eq_field(d)
    out = dict(ns=[], lgt=[], hmod=[], b1=[], b2=[], satf=[],
               gap=[], sg=[])
    mds = {}
    mf = None
    rho = None
    res_worst = 0.0
    mass_ok = True
    for n in masses:
        rho, res = SZ.solve_qp(A, Lip, V, float(n), rho0=rho,
                               iters=QP_ITERS, tol=QP_TOL)
        res_worst = max(res_worst, res)
        md = CB.model_data(x, wt, A, V, rho, n)
        mass_ok = mass_ok and (md["nround"] == n)
        cf = cand_fields(A, V, wt, rho, n)
        out["ns"].append(n)
        out["lgt"].append(rows[n]["lg_h"] / L10)
        out["hmod"].append(md["hmod_l10"])
        out["b1"].append(cf["b1"])
        out["b2"].append(b2_l10(md))
        out["satf"].append(cf["satfrac"])
        out["gap"].append(cf["gap"])
        out["sg"].append(rows[n]["sg_h"])
        if n in keep_md:
            mds[n] = md
            if mf is None:
                mf = dict(F=cf["F"].copy(), uns=cf["uns"].copy(),
                          V=V.copy(), lgt=rows[n]["lg_h"] / L10,
                          b1=cf["b1"], n=n)
    for k in out:
        out[k] = np.asarray(out[k], float)
    out["mds"] = mds
    out["mf"] = mf
    return out, res_worst, mass_ok


def eta_stats(ns, lgt, hmod):
    """degree-resolved quotient statistics (leg 1)."""
    delta = lgt - hmod
    dtrue = np.diff(lgt)
    dmod = np.diff(hmod)
    eta = dtrue - dmod                     # eta_n at ns[1:]
    en = np.asarray(ns[1:], int)
    keep = en >= ETA_LO
    eta = eta[keep]
    en = en[keep]
    i = int(np.argmax(np.abs(eta)))
    last = eta[-10:] if len(eta) >= 10 else eta
    return dict(eta=eta, en=en, mx=float(np.abs(eta[i])),
                mx_at=int(en[i]), med=float(np.median(eta)),
                meda=float(np.median(np.abs(eta))),
                drift=float(delta[-1] - delta[0]),
                slope=float(np.polyfit(ns, delta, 1)[0]),
                last=float(np.median(last)), delta=delta)


# --------------------------------------------------------------- main
def main():
    par = argparse.ArgumentParser()
    par.add_argument("--smoke", action="store_true")
    args = par.parse_args()
    smoke = args.smoke
    windows = (9,) if smoke else WINDOWS

    print("=" * 78)
    print("base_gauge_constant_probe -- PRIME.PORT.RHP.BASE."
          "GAUGE_CONSTANT.01 (round 252)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (w9 masses 2..41; mp ward / "
                        "controls / ladder / contour skipped)"
                        if smoke else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION + AMENDMENT")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "priority order sealed: (1) quotient test eta = "
          "log10|gamma/gamma^out| over ALL free degrees (cases "
          "EXACT %.2f / GAUGE_LAYER med %.3f max %.1f / "
          "RATE_ONLY via ladder slope %.2f or near-flip factor "
          "%.0f); (2) h_0 normalizer C_w^(0) at n0 = %d, rest "
          "bar %.1f; (3) diagonal gauge pinned by the infinity "
          "normalization (Richardson %.0e dec, det %.0e, arg "
          "%.0e); (4) b1/b2 only if (2)+(3) die (bars %.1f/%.2f, "
          "toy %.2f); (5) orientation gates (tol +-%d); (6) "
          "contour R_1 (K %d, pad %.1f, dps %d, bar %.0e)"
          % (ETA_EXACT_MAX, ETA_GL_MED, ETA_GL_MAX, RATE_BAR,
             NEARFLIP_FACTOR, N0_ANCHOR, C0_REST_BAR, RICH_BAR,
             DETM_BAR, ARG_BAR, OFF_BAR4, RATE_BAR,
             TOY_ANCHOR_BAR, FLIP_TOL, R1_K, R1_PAD, R1_DPS,
             R1_BAR))
    check("G03-amendment-disclosed", True,
          "reviewer re-adjudication BEFORE calibration: the "
          "OUTER.CONSTLAYER.01 draft (sealed, SMOKE-only) is "
          "superseded; disclosed carried-over smoke knowledge: "
          "w9 offset median -1.26, b1 under-corrects on w9 "
          "(-1.15) and overshoots the toy (-0.31), b2 tiny, "
          "universal battery retired (its members fail the toy "
          "anchor); no full-window or quotient number was seen "
          "before this seal")

    # ---------------- S1: census + controls
    section("S1  CENSUS + CONTROLS")
    packs = {kz: BH.wpack(kz) for kz in windows}
    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"])
    ctrl_defs = (("EPSTEIN", dict(comb=(
        np.log(nn_idx.astype(float)),
        2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
        ("SCRAMBLE", dict(scramble_seed=1)),
        ("SMOOTH", dict(comb=(ug9, uw9))))
    ctrl = {c: BH.wpack(9, base_kw=kw) for c, kw in ctrl_defs}
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl)
    okC = all(packs[kz]["nf"] is None for kz in windows)
    check("G10-census-controls", okC and okCf,
          "free prefix positive on %d/%d windows (%s); control "
          "flips re-derived %s (orientation gate B consumes "
          "EPSTEIN/SMOOTH; SCRAMBLE armed for battery integrity)"
          % (sum(1 for kz in windows if packs[kz]["nf"] is None),
             len(windows),
             "; ".join("w%d N=%d" % (kz, packs[kz]["N"])
                       for kz in windows),
             str({c: ctrl[c]["nf"] for c in ctrl})))

    # ---------------- S2: continuum anchor + toy
    section("S2  CONTINUUM ANCHOR + CHEBYSHEV TOY")
    id_dev = 0.0
    for n in range(1, 41):
        lhs = (math.log(2.0 * math.pi) - n * math.log(4.0)
               + math.log(0.5) + math.log(0.5))
        rhs = math.log(math.pi / 2.0) - n * math.log(4.0)
        id_dev = max(id_dev, abs(lhs - rhs))
    check("G20-continuum-anchor", id_dev <= CHEB_ID_BAR,
          "continuum Chebyshev-U: 2 pi 4^-n Dinf^2 (b-a)/4 = "
          "(pi/2) 4^-n identically (max dev %.1e over n = 1..40, "
          "bar %.0e) -- the -2 pi i residue convention and the "
          "FIK normalization carry no missing universal power in "
          "the continuum: leg-3 input" % (id_dev, CHEB_ID_BAR))
    xt = np.sort(np.cos(np.pi * (np.arange(TOY_M) + 0.5) / TOY_M))
    wtt = (1.0 - xt * xt) * (np.pi / TOY_M)
    Dm = np.abs(xt[:, None] - xt[None, :])
    np.fill_diagonal(Dm, 1.0)
    At = -np.log(Dm)
    np.fill_diagonal(At, 0.0)
    v = np.ones(TOY_M) / math.sqrt(TOY_M)
    for _ in range(80):
        v2 = At @ v
        nv = float(np.linalg.norm(v2))
        v = v2 / nv
    Lipt = 2.0 * nv
    Vt = -np.log(wtt)
    _als, hs = CB.toy_chain_f64(xt, wtt, TOY_DEPTH)
    res_t = 0.0
    rho = None
    toy_r1, toy_r2 = [], []
    for n in TOY_MASSES:
        rho, res = SZ.solve_qp(At, Lipt, Vt, float(n), rho0=rho,
                               iters=QP_ITERS, tol=QP_TOL)
        res_t = max(res_t, res)
        md = CB.model_data(xt, wtt, At, Vt, rho, n)
        cf = cand_fields(At, Vt, wtt, rho, n)
        lgt = math.log10(hs[n])
        toy_r1.append(lgt - cf["b1"])
        toy_r2.append(lgt - b2_l10(md))
        info("toy n=%-3d Delta_raw %+.3f  resid_b1 %+.3f  "
             "resid_b2 %+.3f" % (n, lgt - md["hmod_l10"],
                                 toy_r1[-1], toy_r2[-1]))
    toy_med = {"b1_satsum": float(np.median(toy_r1)),
               "b2_szego": float(np.median(toy_r2))}
    check("G21-toy-block", res_t <= QP_RES_BAR,
          "discrete Chebyshev-U toy (%d nodes, exact f64 chain): "
          "QP residual worst %.1e (bar %.0e); leg-4 toy anchors: "
          "b1 median %+.3f, b2 median %+.3f (bar %.2f -- the "
          "calibration duty kept from the retired battery)"
          % (TOY_M, res_t, QP_RES_BAR, toy_med["b1_satsum"],
             toy_med["b2_szego"], TOY_ANCHOR_BAR))

    # ---------------- S3: full-degree sweeps + wards
    section("S3  FULL-DEGREE SWEEPS (QP at every free mass)")
    W = {}
    res_worst = 0.0
    mass_ok = True
    for kz in windows:
        p = packs[kz]
        N = p["N"]
        masses = (range(2, 42) if smoke else range(2, N))
        keep = {N // 2, N - 1} if not smoke else {40}
        t0 = time.time()
        sw, rw, mo = sweep_window(p["d"], p["rows"],
                                  list(masses), keep_md=keep)
        res_worst = max(res_worst, rw)
        mass_ok = mass_ok and mo
        W[kz] = sw
        info("w%-3d N=%d: %d masses swept in %.1f s; sign "
             "positive on %d/%d" % (kz, N, len(sw["ns"]),
                                    time.time() - t0,
                                    int(np.sum(sw["sg"] > 0)),
                                    len(sw["sg"])))
    check("G22-sweep-qp-wards", res_worst <= QP_RES_BAR
          and mass_ok,
          "QP residual worst %.1e (bar %.0e) over %d equilibria; "
          "every rounded mass integer-exact; D/ell = r250 "
          "objects, untouched"
          % (res_worst, QP_RES_BAR,
             sum(len(W[kz]["ns"]) for kz in windows)))
    if smoke:
        check("G23-mp-chain-ward", True,
              "SMOKE: mp ward skipped (r250/r251 chain wards "
              "stand)")
    else:
        p9 = packs[9]
        N9 = p9["N"]
        zfar = [float(np.max(np.concatenate(
            [p9["d"]["xs"], p9["d"]["ys"]]))) + 1000.0]
        _o, _g, hlog = CB.mp_y_pass(p9["d"], {N9 - 1}, zfar,
                                    MP_WARD_DPS, N9)
        dev = 0.0
        sg_ok = True
        for n in range(2, N9):
            dev = max(dev, abs(float(hlog[n][0])
                               - p9["rows"][n]["lg_h"]))
            sg_ok = sg_ok and (float(hlog[n][1])
                               == p9["rows"][n]["sg_h"])
        check("G23-mp-chain-ward", dev <= MP_WARD_BAR and sg_ok,
              "w9 mp chain (dps %d) vs the f64 wpack chain over "
              "ALL sweep degrees: max |lg h| dev %.1e (bar "
              "%.0e), signs %s -- the quotient statistics are "
              "not an f64 artifact"
              % (MP_WARD_DPS, dev, MP_WARD_BAR,
                 "all match" if sg_ok else "MISMATCH"))

    # ---------------- S4: leg 1 -- the quotient test
    section("S4  LEG 1 -- QUOTIENT TEST (eta statistics)")
    ES = {}
    for kz in windows:
        sw = W[kz]
        st = eta_stats(list(sw["ns"].astype(int)), sw["lgt"],
                       sw["hmod"])
        ES[kz] = st
        info("w%-3d eta: max|.| %.3f@n=%d  med %+.5f  med|.| "
             "%.4f  drift %+.3f  slope %+.5f  last10 %+.4f  | "
             "Delta med %+.3f term %+.3f"
             % (kz, st["mx"], st["mx_at"], st["med"], st["meda"],
                st["drift"], st["slope"], st["last"],
                float(np.median(st["delta"])),
                float(st["delta"][-1])))
    check("G30-eta-table", True,
          "the eta statistics table (rows above) is the round's "
          "first deliverable: eta_{w,n} = log10|gamma_{w,n}/"
          "gamma^out_{w,n}| over ALL free degrees (n >= %d), "
          "QP at every mass" % ETA_LO)
    # controls quotient anatomy (pre-flip eta; the sweep extends
    # FLIP_SCAN degrees past the flip for the gate-B model-flip
    # scan of leg 5)
    nearflip_max = 0.0
    ctrl_sw = {}
    if smoke:
        check("G31-controls-quotient", True,
              "SMOKE: controls sweep skipped")
    else:
        cq_note = []
        for cname in ("EPSTEIN", "SMOOTH"):
            pc = ctrl[cname]
            nf = pc["nf"]
            top = min(nf + FLIP_SCAN + 1, pc["N"])
            swc, rwc, _moc = sweep_window(pc["d"], pc["rows"],
                                          list(range(2, top)))
            res_worst = max(res_worst, rwc)
            ctrl_sw[cname] = swc
            pre = swc["ns"] <= nf - 1
            stc = eta_stats(
                list(swc["ns"][pre].astype(int)),
                swc["lgt"][pre], swc["hmod"][pre])
            bulk = float(np.median(np.abs(stc["eta"])))
            last5 = float(np.median(np.abs(stc["eta"][-5:])))
            fac = last5 / max(bulk, NEARFLIP_FLOOR)
            nearflip_max = max(nearflip_max, fac)
            cq_note.append("%s(flip %d): med|eta| %.4f last5 "
                           "%.4f factor %.2f"
                           % (cname, nf, bulk, last5, fac))
        check("G31-controls-quotient", True,
              "pre-flip quotient anatomy on the controls: %s "
              "(near-flip blowup factor bar %.0f feeds the "
              "RATE_ONLY trigger)" % ("; ".join(cq_note),
                                      NEARFLIP_FACTOR))
    # blind-ladder rate sample
    lad_slope_max = 0.0
    if smoke:
        check("G32-ladder-blind", True, "SMOKE: ladder skipped")
    else:
        elig = sorted((ladder_h(kz), kz)
                      for kz in core.frame_a_zones()
                      if kz not in WINDOWS
                      and ladder_h(kz) <= LADDER_H_CAP)
        blind = elig[1::2]
        picks = sorted({blind[0], blind[len(blind) // 2],
                        blind[-1]})
        lad_note = []
        for _h, kz in picks:
            pL = BH.wpack(kz)
            if pL["nf"] is not None:
                lad_note.append("kz%d FLIP@%d typed+skipped"
                                % (kz, pL["nf"]))
                continue
            NL = pL["N"]
            grid = sorted(set(np.linspace(2, NL - 1, LADDER_GRID)
                              .astype(int).tolist()))
            swl, rwl, mol = sweep_window(pL["d"], pL["rows"],
                                         grid)
            res_worst = max(res_worst, rwl)
            dl = swl["lgt"] - swl["hmod"]
            sl = float(np.polyfit(swl["ns"], dl, 1)[0])
            lad_slope_max = max(lad_slope_max, abs(sl))
            lad_note.append("kz%d N=%d slope %+.4f off med %+.2f"
                            % (kz, NL, sl, float(np.median(dl))))
        check("G32-ladder-blind", True,
              "BLIND-position sample of the 42-rung ladder "
              "(h-sorted proxy, odd positions, first/middle/"
              "last): %s -- max |slope| %.4f vs rate bar %.2f "
              "(RATE_ONLY trigger input)"
              % ("; ".join(lad_note), lad_slope_max, RATE_BAR))
    # sealed case adjudication
    if smoke:
        case = "SMOKE_NO_ADJUDICATION"
        case_note = "smoke"
    else:
        mx_all = max(ES[kz]["mx"] for kz in windows)
        med_all = max(abs(ES[kz]["med"]) for kz in windows)
        rate_trig = (lad_slope_max > RATE_BAR
                     or nearflip_max > NEARFLIP_FACTOR)
        if mx_all <= ETA_EXACT_MAX:
            case = "BASE_RATIO_EXACT"
            case_note = "max|eta| %.4f <= %.2f on 4/4" % (
                mx_all, ETA_EXACT_MAX)
        elif rate_trig:
            case = "RATE_ONLY_NUMERICAL"
            case_note = ("trigger: ladder slope %.4f / near-flip "
                         "factor %.1f" % (lad_slope_max,
                                          nearflip_max))
        elif med_all <= ETA_GL_MED and mx_all <= ETA_GL_MAX:
            case = "BASE_GAUGE_LAYER"
            case_note = ("|med eta| worst %.5f <= %.3f, max|eta| "
                         "%.3f <= %.1f" % (med_all, ETA_GL_MED,
                                           mx_all, ETA_GL_MAX))
        else:
            case = "RATE_ONLY_NUMERICAL"
            case_note = ("quotient error not uniformly small: "
                         "|med eta| worst %.5f, max|eta| %.3f"
                         % (med_all, mx_all))
    check("G33-case-adjudicated", True,
          "SEALED leg-1 case: %s (%s)" % (case, case_note))

    # ---------------- S5: leg 2 -- h_0 normalizer
    section("S5  LEG 2 -- h_0 NORMALIZER C_w^(0)")
    c0_rest_max = 0.0
    c0_note = []
    for kz in windows:
        sw = W[kz]
        delta = sw["lgt"] - sw["hmod"]
        rest = delta - delta[0]           # anchor n0 = 2
        c0_rest_max = max(c0_rest_max,
                          float(np.max(np.abs(rest))))
        c0_note.append("w%d C0 %+.3f dec, rest med %+.3f max "
                       "%+.3f term %+.3f"
                       % (kz, float(delta[0]),
                          float(np.median(rest)),
                          float(np.max(np.abs(rest))),
                          float(rest[-1])))
    c0_carries = c0_rest_max < C0_REST_BAR and not smoke
    for t in c0_note:
        info(t)
    check("G40-c0-normalizer", True,
          "C_w^(0) = h_{w,%d}/h^out_{w,%d} (head data, "
          "disclosed), then h_n =? C^(0) h^out_n with NO further "
          "adjustment: max |rest| %.3f dec (bar %.1f) => %s"
          % (N0_ANCHOR, N0_ANCHOR, c0_rest_max, C0_REST_BAR,
             "C0_NORMALIZER_CARRIES" if c0_carries
             else ("C0_NORMALIZER_INSUFFICIENT"
                   if not smoke else "SMOKE")))

    # ---------------- S6: leg 3 -- diagonal gauge adjudication
    section("S6  LEG 3 -- DIAGONAL RH GAUGE (convention, not fit)")
    rich_worst = 0.0
    detm_worst = 0.0
    arg_worst = 0.0
    for kz in windows:
        sw = W[kz]
        p = packs[kz]
        x, _wt, _A, _Lip, _V = CB.eq_field(p["d"])
        _pan, norm_z, x0, _a0, _b0 = CB.build_panels(x)
        for n, md in sw["mds"].items():
            m1_12, _devs = CB.rich_M1_12(md, n, norm_z, DPS_SPOT)
            rich_worst = max(rich_worst,
                             abs(float(mp.log(abs(m1_12), 10))
                                 - md["hmod_l10"]))
            arg_worst = max(arg_worst,
                            abs(float(mp.arg(m1_12))))
            for z in (x0 + 1.5j, float(x[-1]) + 1.0):
                detm_worst = max(detm_worst, CB.detm_dev(
                    CB.model_at(md, complex(z), DPS_SPOT)))
    gauge_pinned = (rich_worst <= RICH_BAR
                    and detm_worst <= DETM_BAR
                    and arg_worst <= ARG_BAR)
    check("G50-gauge-adjudication", gauge_pinned,
          "diag(c, 1/c) would scale (M1)_12 by c^2 without "
          "touching the rate; ADJUDICATED BY CONVENTION: both Y "
          "and M carry the same z^{-n sigma3} normalization at "
          "infinity -- Richardson (M1)_12 vs analytic h^out "
          "worst %.1e dec (bar %.0e), det M worst %.1e (bar "
          "%.0e), arg worst %.1e (bar %.0e) at degrees "
          "{N//2, N-1} x %d windows => c_w pinned to 1 at the "
          "1e-4-decade level: %s"
          % (rich_worst, RICH_BAR, detm_worst, DETM_BAR,
             arg_worst, ARG_BAR, len(windows),
             "GAUGE_PINNED_AT_INFINITY (the offset is model "
             "error, not convention -- it must and does cancel "
             "in quotients only as far as leg 1 measures)"
             if gauge_pinned else "GAUGE_BROKEN"))

    # ---------------- S7: leg 4 -- conditional divisor candidates
    section("S7  LEG 4 -- SATURATION/SZEGO DIVISOR (conditional)")
    adjud4 = (not smoke) and ((not c0_carries)
                              or (not gauge_pinned))
    l4 = {}
    for name in ("b1_satsum", "b2_szego"):
        offs, sls = [], []
        for kz in windows:
            sw = W[kz]
            hc = sw["b1"] if name == "b1_satsum" else sw["b2"]
            rr = sw["lgt"] - hc
            offs.append(float(np.median(rr)))
            sls.append(float(np.polyfit(sw["ns"], rr, 1)[0]))
        acc = (all(abs(o) < OFF_BAR4 for o in offs)
               and all(abs(s) <= RATE_BAR for s in sls))
        toy_ok = abs(toy_med[name]) <= TOY_ANCHOR_BAR
        l4[name] = dict(offs=offs, sls=sls, acc=acc,
                        toy_ok=toy_ok)
        info("%-10s offs %s slopes %s toy %+.3f %s -> %s"
             % (name, str([round(o, 3) for o in offs]),
                str([round(s, 4) for s in sls]),
                toy_med[name],
                "ANCHOR-OK" if toy_ok else "ANCHOR-FAIL",
                "accept" if (acc and toy_ok) else "reject"))
    if not adjud4:
        v4 = "SATSZEGO_NOT_ADJUDICATED"
        wc4 = None
    else:
        wc4 = next((nm for nm in ("b1_satsum", "b2_szego")
                    if l4[nm]["acc"] and l4[nm]["toy_ok"]), None)
        v4 = ("SATSZEGO_DERIVED(%s)" % wc4 if wc4
              else "SATSZEGO_OPEN")
    check("G60-leg4-conditional", True,
          "sealed priority rule: leg 4 adjudicated iff legs 2 "
          "and 3 do not own the layer (C0 %s, gauge %s) => %s "
          "(table above %s)"
          % ("carries" if c0_carries else "insufficient",
             "pinned" if gauge_pinned else "broken", v4,
             "adjudicated" if adjud4 else "informational only"))

    # ---------------- S8: leg 5 -- orientation gates
    section("S8  LEG 5 -- ORIENTATION MUST-GATES")
    # gate A: MAIN model quotients positive (h^out is an exp form)
    mainA = all(bool(np.all(np.isfinite(W[kz]["hmod"])))
                for kz in windows)
    check("G70-orientation-main", True,
          "gate A (MAIN): gamma^out_{w,n} = 10^{Delta hmod} > 0 "
          "on %d/%d windows -- POSITIVE BY CONSTRUCTION (h^out = "
          "2 pi e^{n ell} Dinf^2 (b-a)/4 is an exponential of "
          "real source data: the model has NO sign channel; "
          "typed, feeds gate B)"
          % (sum(1 for kz in windows
                 if np.all(np.isfinite(W[kz]["hmod"]))),
             len(windows)))
    if smoke:
        orient_green = False
        blind_tok = True
        check("G71-orientation-controls", True,
              "SMOKE: control orientation gate skipped")
    else:
        oc_note = []
        orient_green = mainA
        blind_tok = True
        for cname in ("EPSTEIN", "SMOOTH"):
            nf_true = ctrl[cname]["nf"]
            swc = ctrl_sw[cname]
            # measured model-flip scan over [2, nf + FLIP_SCAN]:
            # first degree whose model quotient gamma^out is not
            # a positive finite number (h^out is an exponential
            # of real source data, so any flip can only appear
            # as a degeneracy of the formula)
            gmod = np.diff(swc["hmod"])
            bad = np.nonzero(~np.isfinite(gmod))[0]
            nf_mod = (int(swc["ns"][1:][bad[0]])
                      if len(bad) else None)
            okB = (nf_mod is not None
                   and abs(nf_mod - nf_true) <= FLIP_TOL)
            orient_green = orient_green and okB
            blind_tok = blind_tok and (nf_mod is None)
            oc_note.append("%s: true flip %d, model flip %s -> "
                           "%s" % (cname, nf_true, str(nf_mod),
                                   "match" if okB else "MISS"))
        check("G71-orientation-controls", True,
              "gate B (controls, tol +-%d): %s => %s -- a "
              "positive global factor cannot change a sign; the "
              "solved constant proves the base only WITH an "
              "orientation carrier, which this outer model is "
              "not" % (FLIP_TOL, "; ".join(oc_note),
                       "orientation carried" if orient_green
                       else "MODEL_ORIENTATION_BLIND (honest)"))

    # ---------------- S9: leg 6 -- contour R1 + must-fails
    section("S9  LEG 6 -- CONTOUR R_1 + MUST-FAILS")
    if smoke:
        check("G80-r1-contour", True,
              "SMOKE: contour instrument skipped")
        r1_dev = float("nan")
    else:
        p9 = packs[9]
        N9 = p9["N"]
        n_r1 = N9 // 2
        md9 = W[9]["mds"][n_r1]
        xall = np.sort(np.concatenate([p9["d"]["xs"],
                                       p9["d"]["ys"]]))
        x0c = 0.5 * (float(xall[0]) + float(xall[-1]))
        rad = 0.5 * (float(xall[-1]) - float(xall[0])) + R1_PAD
        zs = [complex(x0c + rad * math.cos(2.0 * math.pi
                                           * (j + 0.5) / R1_K),
                      rad * math.sin(2.0 * math.pi
                                     * (j + 0.5) / R1_K))
              for j in range(R1_K)]
        out9, _g9, hlog9 = CB.mp_y_pass(p9["d"], {n_r1}, zs,
                                        R1_DPS, N9)
        mp.mp.dps = R1_DPS
        acc12 = mp.mpc(0)
        acc21 = mp.mpc(0)
        for j, z in enumerate(zs):
            Mz = CB.model_at(md9, z, R1_DPS)
            mp.mp.dps = R1_DPS
            R = r_field(out9[n_r1]["Y"][j], Mz)
            wgt = mp.mpc(z) - mp.mpf(x0c)
            acc12 += R[0][1] * wgt
            acc21 += R[1][0] * wgt
        r1_12 = acc12 / R1_K
        r1_21 = acc21 / R1_K
        lg, sg = hlog9[n_r1]
        h_true = sg * mp.e ** lg
        h_out = mp.e ** (mp.mpf(md9["hmod_l10"]) * mp.log(10))
        scale = max(abs(h_true), abs(h_out))
        r1_dev = float(abs(r1_12 - (h_true - h_out)) / scale)
        m6_dev = float(abs(r1_21 - (h_true - h_out)) / scale)
        ok_m6 = m6_dev >= M6_LOUD * max(r1_dev, 1e-300)
        check("G80-r1-contour",
              r1_dev <= R1_BAR and out9[n_r1]["dety"] <= 1e-20
              and ok_m6,
              "R_1 = (1/2 pi i) oint (R - I) dz on the sealed "
              "circle (w9, n = %d, K = %d, radius %.2f, dps %d, "
              "det Y ward %.1e): |(R_1)_12 - (h_true - h^out)| "
              "/ scale = %.1e (bar %.0e) -- the r251 delta-h "
              "identity holds in PROOF-READY contour form; m6 "
              "swapped entry: dev %.1e (>= %.0e x honest, LOUD)"
              % (n_r1, R1_K, rad, R1_DPS, out9[n_r1]["dety"],
                 r1_dev, R1_BAR, m6_dev, M6_LOUD))
    # must-fails m1-m3 on the b1 field (w9, kept degree)
    mf = W[9]["mf"]
    r_hon = mf["lgt"] - mf["b1"]
    bar_mf = max(MF_ABS, abs(r_hon) + MF_REL)
    F = mf["F"]
    uns = mf["uns"]
    fb1 = 0.5 * (F + mf["V"])
    r_m1 = mf["lgt"] - lse_l10(-fb1[uns])
    r_m2 = mf["lgt"] - lse_l10(-2.0 * F[uns])
    r_m3 = mf["lgt"] - lse_l10(+F[uns])
    ok_mf = (abs(r_m1) >= bar_mf and abs(r_m2) >= bar_mf
             and abs(r_m3) >= bar_mf)
    check("G90-must-fails-fire", ok_mf,
          "w9 n = %d, honest b1 residual %+.3f (loudness bar "
          "%.1f dec): m1 wrong factor 2 => %.1f dec; m2 "
          "forgotten root => %.1f dec; m3 exponent sign => %.1f "
          "dec (each LOUD); m4 sign oracle EXCLUDED by the "
          "input firewall (standing r243 exclusion)"
          % (mf["n"], r_hon, bar_mf, abs(r_m1), abs(r_m2),
             abs(r_m3)))

    # ---------------- S10: verdict
    section("S10  VERDICT")
    if smoke:
        vTop = "SMOKE_NO_ADJUDICATION"
    elif case == "BASE_RATIO_EXACT" and orient_green:
        vTop = "BASE_RATIO_CARRIES_SIGN"
    else:
        vTop = case
    toks = [vTop]
    if not smoke:
        toks.append(("C0_NORMALIZER_CARRIES(%.2f dec)"
                     if c0_carries else
                     "C0_NORMALIZER_INSUFFICIENT(%.2f dec)")
                    % c0_rest_max)
        toks.append("GAUGE_PINNED_AT_INFINITY(%.0e dec)"
                    % rich_worst if gauge_pinned
                    else "GAUGE_BROKEN(%.1e)" % rich_worst)
        toks.append(v4)
        if blind_tok:
            toks.append("MODEL_ORIENTATION_BLIND")
        toks.append("R1_CONTOUR_VERIFIED(%.1e)" % r1_dev
                    if r1_dev <= R1_BAR
                    else "R1_CONTOUR_FAILED(%.1e)" % r1_dev)
    check("G97-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED (a gauge/quotient "
          "adjudication moves no edge); what the round adds: the "
          "full-degree eta table, the C0 rest bill, the pinned "
          "gauge, the conditional divisor table, the orientation "
          "gate bill, and the proof-ready contour R_1")
    verd = " + ".join(toks)
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G81-verdict", npass == len(CHECKS),
          "%s%s -- MEASURED: eta statistics (all free degrees), "
          "C0 rest decades, gauge pins, flip-gate bilances, "
          "contour R_1; OPEN: the budget bound and the base law "
          "themselves (r243/r247/r250/r251 stand); 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())
'''

# ------------- frozen probe source schlesinger_pairing_probe (embedded BYTE-EXACT, raw string)
_SRC_5 = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""schlesinger_pairing_probe -- PRIME.PORT.RHP.FIBER.SCHLESINGER_PAIRING.01
(round 253, REVIEWER-ADJUDICATED CONTRACT): delta T is NOT an error
-- it is the OMITTED ARITHMETIC MAIN TERM.  The decomposition T =
T^out + delta T is DISCARDED; the target is T = T^pair + E^pair
where T^pair consumes the exact mass-position pairing (log p^k,
Lambda(p^k)/sqrt(p^k)) ALREADY AT LEADING ORDER.  The fiber is
modeled AUGMENTED from the start: the border is (r245) a
Schlesinger rank-1/Uvarov insertion into the 2x2 FIK problem, and
the MAIN OBJECT is the augmented tau quotient
  D_{w,N}(B) = B0_w - Q_{7,w} - T_{w,N} = tau^aug_{w,N}(B) / tau_{w,N}.

ARCHITECTURAL AMENDMENT (disclosed FIRST, before this spec's
calibration): the pre-adjudication draft of round 253
(PRIME.PORT.RHP.FIBER.PAIRING.01, SPEC_SHA 99b2e1ae1a0990de) was
built and fully calibrated (21/21 gates, wall 58.7 s; draft verdict
KERNEL_STRUCTURELESS + BEST_PAIRABLE_FORM(FREE) [carry NO] +
EPSTEIN_FIBER_ANOMALOUS; key draft numbers: sep_SCR 0.468 dec,
sep_EPST 1.199 dec, x2-ladder min 7.6/8.7, free-chain shares
+5.89/+24.2, kappa 4.3e-2/3.4e-2).  The reviewer adjudication then
re-architected the contract BEFORE this spec's record freeze.  The
draft's usable legs (pair anatomy, pre-evaluation battery, x2
ladder, kernel forms noD/mollified/free, falsifiers, must-fails)
are RETAINED inside this probe and re-run under the new spec; the
draft file was replaced by this probe (single-probe house rule);
the superseded THEOREM/MEASURED/STRUCTURELESS triad is retired in
favor of the adjudicated verdict set below.  A second disclosed
draft amendment carries over: the mp-vs-f64 chain ward bar was
widened 1e-8 -> 1e-7 after the draft's pass 1 measured 1.0e-8 on a
control-world f64 chain (ward tolerance, no physics bar).

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

INDEX FIREWALL (binding, r238-r251 discipline): w = window (kz),
N_w = builder depth, n = chain degree; free pivots h_{w,n}
(n < N_w) are the proof objects; rho_n = F_n^2/h_n, S_n =
sum_{k<=n} rho_k (r243/r244); the forced pivot h_N is NEVER
formed; ground truth (h signs, flips, T_true) enters gates only;
no zero/prime oracles anywhere (AST firewall).  MACHINERY IMPORTED
VERBATIM: r250 model (centered_basefiber), r251 mp kernel pass +
kernel columns + pair kernel + noD columns (targetreadout), r244
wpack chain, r245 Schlesinger form (Y3aug unipotent insertion,
cited); B PROVENANCE: the only covering budget remains B_w =
S_{N-2} + 5/7 (r243/r247, honest status IMPORTED, never fitted).

LEG T -- THE AUGMENTED TAU QUOTIENT (priority 1, main object):
with H_N = the Gram/Hankel matrix of mutilde on P_{N-1} and t =
the border moment vector (t_n = int p_n dsigmatilde), the Schur
identity of the BORDERED matrix (the r244 bordered Hankel = the
tau function of the r245 Uvarov-augmented problem) gives EXACTLY
  tau^aug(B)/tau = det [[H, t],[t^T, B]] / det H = B - t^T H^-1 t
  = B - sum_{n<N} F_n^2/h_n = B0 - Q_7 - T = D  (all n < N),
basis-independently (any polynomial basis J changes num and den by
the same det(J)^2).  GATES (independent routes, never the chain):
(t1) DUAL-NORM SOLVE: Q_lin = t~^T G~^-1 t~ in the sealed U-BASIS
  (U_n(z - x0), the free-chain basis -- f64-representable Gram
  G~_ij = int U_i U_j dmutilde, dynamic range ~ 1 decade instead
  of the monomial 10^300); D_gram = B - Q_lin vs the exact anchor
  D_direct = 5/7 - rho_{N-1} (r243/r251): rel bar 1e-6 on the
  MAIN windows (solve residual warded 1e-8).
(t2) SLOGDET ROUTE: D_det = sign * exp(slogdet G~aug - slogdet G~)
  -- the tau quotient LITERALLY as a determinant ratio at FULL
  depth: rel bar 1e-6 on the MAIN windows; PLUS the hard
  ROUTE-CONSISTENCY gate |D_gram/D_det - 1| <= 1e-6 on ALL
  worlds (the two independent linear-algebra routes must agree
  with each other everywhere).
  CONTROL-WORLD REFERENCE FLOOR (disclosed calibration amendment
  a1, pass 1): on the FLIPPED control worlds (SCRAMBLE h-flip at
  degree 21, EPSTEIN at 25) the f64 wpack chain REFERENCE itself
  carries only ~1e-4 (the G21 ward already measures 1e-8 per
  gammahat there, accumulating through F_n^2/h_n; pass 1: SCR
  dev 4.2e-4 with solve and slogdet routes IDENTICAL to each
  other -- the discrepancy sits in the chain reference, not the
  tau side); control-vs-chain bar therefore 1e-3, typed, with
  the route-consistency gate carrying the identity there.
(t3) MONOMIAL mp CROSS-CHECK at sealed truncations n_t in {12,
  24} (w9): mp Hankel determinants (dps 220) of the raw moments,
  det ratio vs B_t - S_{n_t - 1} with sealed corner B_t = 5/7:
  rel bar 1e-12 -- the bar is F64-LEVEL because the reference
  S_{n_t-1} is the f64 wpack chain cumsum (the mp determinant
  side is exact; smoke measured 2.8e-17/1.0e-16, i.e. the f64
  reference floor -- disclosed pre-freeze bar correction from
  the smoke's 1e-18 draft); basis independence demonstrated
  where the monomial conditioning allows; the FULL-depth
  monomial route is condition-obstructed (log10 dynamic ~ sum
  lg h ~ 10^2 decades, typed, never evaluated -- priority 6).
(t4) TARGET THROUGH TAU: T_gram = Q_lin - Q8_lin (Q8 = the same
  solve on P_7) vs the bitwise chain T_true, per world: rel bar
  1e-6 on MAIN w9/w13; SCRAMBLE at the control floor 1e-3
  (amendment a1) -- the tau route must reproduce the 8.8-unit
  MAIN-SCRAMBLE gap (feeds leg R (ii)); EPSTEIN INFO-typed.
SEALED: TAU_RATIO_EXACT iff t1-t4 pass, else TAU_RATIO_OPEN.

LEG P -- EXACT POLE-REMOVAL ADJUDICATION (priority 2): the direct
D-layer evaluation on sigma0 is structurally inadmissible (atom
poles, 380 decades, r251 G34) -- but is that its death sentence?
Adjudicated by TWO measurements (no 380-decade number is ever
formed; log-arithmetic only):
(p1) RANK-1/CAUCHY RESIDUE CLOSURE: the Uvarov/Schlesinger layer
  has SIMPLE poles at the window atoms with the exact triangular
  residue condition Res_{x_j} C_N = w_j pihat_N(x_j) (the r245
  nilpotent E_13/E_12 structure).  Gated in mp on 5 sealed
  sampled atoms: t-ladder z = x_j + i t, t in {1e-8, 1e-9}
  (pre-freeze correction from the smoke's {1e-6, 1e-7} draft:
  neighboring union nodes sit ~1e-4 away, leaving a quadratic
  Richardson rest ~3e-5 at the larger ladder; the smaller ladder
  pushes it below the bar with the pole term still 9 decades
  inside mp range), Richardson-extrapolated (z - x_j) C_N(z) vs
  w_j pihat_N(x_j), rel bar 1e-6.  If this closes, the rank-1 border layer is
  EXACTLY removable by the triangular transformation -- its poles
  are bookkeeping, not obstruction.
(p2) ESSENTIAL-ORDER TEST of the Szego D-layer: dlog D =
  (R(z)/2) sum_i nu_i L_i/(z - s_i) has SIMPLE POLES of the LOG,
  i.e. D itself has essential singularities exp(c_j/(z - s_j)).
  Measured: slope p of log10 |Re log10 D| vs log10(1/t) along
  z = s* + i t, t in {1e-3, 1e-4, 1e-5} at the worst atom s*.
  A finite-order meromorphic divisor/triangular dressing has
  |log D| ~ O(log 1/t): p ~ 0.  SEALED RULE: p >= 0.8 => the
  D-layer singularity is ESSENTIAL => NO finite meromorphic
  rank-1/interpolating-divisor dressing can cancel it.
  MOLLIFICATION CONTRAST (retained draft leg): the 0.05
  pole-shifted D_moll is bounded on the contour (draft: 0.6
  decades vs 380) and rate-exact (Richardson 2.0e-6) -- gated
  again here.
SEALED ADJUDICATION: POLE_REMOVAL_EXACT iff p1 passes AND p2
  measures p < 0.8 (finite order: a divisor construction exists);
  D_DIRECT_ONLY_OBSTRUCTED + NO_FINITE_PAIR_DRESSING(D-layer) +
  POLE_REMOVAL_EXACT(rank1-border) => PAIR_AWARE_OUTER_MODEL
  iff p1 passes AND p >= 0.8 (the border rank-1 layer closes
  exactly; the D-layer is essentially singular; the pair dressing
  must live in a pair-aware outer model -- leg-F pointer);
  NO_FINITE_PAIR_DRESSING (hard) iff p1 fails.

LEG F -- SIGMA0-PAIRABLE KERNEL FORMS (retained draft leg, feeds
P and M): noD (r251 reference), MOLLIFIED D (pole shift 0.05,
pairability bar 50 dec, rate bars 1e-4/1e-6), FREE CHAIN
(alphahat = x0, gammahat = 1/4, h_0 = eta_0; K^free_m(x,y) =
[U_m(y)U_{m-1}(x) - U_{m-1}(y)U_m(x)]/(2 h_0 (y-x))); T-shares
per MAIN window + T_free on SCRAMBLE/EPSTEIN (feeds the leg-M
candidate); carry rule sign + |share| in [0.1, 10];
BEST_PAIRABLE_FORM tag.

LEG M -- PAIRING IN THE LEADING MODEL (priority 3 + 4): TWO
sealed T^pair candidates, both consuming the exact mass-position
pairing at leading order and NOTHING from the exclusion list (no
node density, no total mass, no separated position/weight
marginals, no Hardy-Littlewood surrogate, no norm estimate of the
double sum, no smooth main term with pairing in the error --
asserted as a statement gate):
(m1) DIAG-GRAM: T^pair_dg = sum_{n=8}^{N-1} t~_n^2 / G~_nn (the
  diagonal part of the exact dual-norm form; t~_n = int U_n
  dsigmatilde couples border mass to window positions exactly;
  the world enters through the window Gram diagonal);
(m2) FREE-KERNEL: T^pair_free = sigma0 [K^free_N - K^free_8]
  sigma0 (the leg-F free chain; the world enters through the
  sigma0 atom-weight assignment).
SPLIT: E^pair = T_true - T^pair per world (exact rest, no norm
bound); WORLD LOCATION: share_main = (T^pair_MAIN(w9) -
T^pair_SCR) / (T_true_MAIN - T_true_SCR) -- the ~8.8-unit gap
must appear in the MAIN TERM: sealed window [0.5, 2.0].
VERDICT: PAIRING_IN_MAIN_TERM(candidate) iff a candidate lands in
the window (best = |log share| smallest); else
PAIRING_IN_ERROR_AGAIN.  MARGIN GATE (priority 4): |E^pair| <
D_direct per MAIN window for the best candidate:
MARGIN_COVERED / MARGIN_OPEN(decades, honest).

LEG S -- PRE-TARGET SEPARATION (retained draft leg, priority 4):
the noD error-kernel pair anatomy (rank-distance bands, kappa,
near/deep shares), the sealed 3-statistic battery (X1 mass-
normalized |C|, X2 near share rd < 8, X3 deep-carrier share q10)
with sep_W = max |log10(X_W / X_MAINw9)|, acceptance sep_SCR >=
1.0 dec (the standing gate); the x2 ladder S(B) = |signed near
field| + exact absolute rest sum, B in {1..64}, factor bar 2.0
(draft measured 7.6/8.7 -- re-run, expected to FAIL honestly:
long-range cancellation); route re-gate 2e-9 + chain anchor 0.10.

LEG R -- THE RELATIVE PROBLEM (priority 5, mechanism microscope,
NO proof): R_pair(z) = Y_MAIN(z) Y_SCR(z)^{-1} at the sealed 12
MAIN gap-midpoint points (+ 0.02i), level N (both worlds at the
same depth 184):
(r-i) geometric cancellation: med ||C^-1 (R_pair - I) C||_F (C =
  e^{(n ell_MAIN/2) sigma3}) vs med ||C^-1 (Y_MAIN M_noD^-1 - I)
  C||_F on the same points; REL_GEOMETRY_CANCELS iff ratio <=
  0.3 (sealed), else REL_STRUCTURELESS;
(r-ii) the tau quotient reproduces the 8.8 gap directly: covered
  by gate t4 (T_gram world gap);
(r-iii) sign/phase BEFORE the T readout: the per-degree main-term
  difference d_n = t~_n^2 (1/G~^MAIN_nn - 1/G~^SCR_nn), n in
  [8, N-1] (computable without forming any T): sign(sum d_n) vs
  sign(T_true gap); DEGREE LOCALIZATION: share of sum |d_n|
  carried by the top-decile degrees; PAIRING_EXTENSIVE typed iff
  that share < 0.5 (the relative action needs all degrees
  individually).

FALSIFIERS + MUST-FAILS (retained): SMOOTH sigma0 == 0 self-alias
(free-kernel pairing, abs guard 1e-9); EPSTEIN head-identical
(battery MAIN-likeness typed; draft: ANOMALOUS, r_deep 1.2 dec);
(m1) kernel index swap (K -> -K, loud >= 100 x honest reg dev);
(m2) centering omitted (rank-1 head, window [0.5, 2.0] x rho_0);
(m3) atom jitter (eps 1e-3, seed 253, loud >= 100 x); (m4) sign
oracle EXCLUDED (standing r243).  Ground truth in gates only.

SEALED CONSTANTS: MAIN windows (9, 13) (w12/w26 excluded by the
sealed runtime budget); controls on w9: EPSTEIN, SCRAMBLE (seed
1), SMOOTH; flips 25/21/27; low level 8; contour dx 1e-5 / dy
2e-5; leg-S model = noD; dps: kernel pass 120, model columns 60,
moll columns 120, spot/Richardson 80, tau truncation 220; QP
FISTA 8000/1e-8/bar 1e-6, masses {8, N}; U-basis center = x0
(union hull midpoint); tau bars: t1/t2/t4 1e-6 (MAIN) / 1e-3
(flipped controls, amendment a1) / route consistency 1e-6 (all
worlds), t3 1e-12 (f64 reference), solve residual 1e-8, U
headroom 140 dec (Gram) / 250 dec (kernel); truncations {12, 24}, corner B_t = 5/7; residue
sample 5 atoms (first-zone position stride), t-ladder {1e-8,
1e-9}, bar 1e-6;
essential ladder t {1e-3, 1e-4, 1e-5}, order bar 0.8; moll delta
0.05 / bars 50 dec, 1e-4, 1e-6; carry [0.1, 10]; main-term share
window [0.5, 2.0]; margin = D_direct; battery NEAR_RD 8 / DEEP_Q
0.10 / sep bar 1.0 dec; B ladder (1..64) factor bar 2.0; route
2e-9; anchor 0.10 (MAIN; controls INFO); rel-problem midpoints 12
(MAIN geometry, + 0.02i), rel bar 0.3; top-decile extensive bar
0.5; SMOOTH guard 1e-9; jitter 1e-3 / seed 253 / 100 x; m1 100 x;
m2 [0.5, 2.0]; det Y 1e-20, det M 1e-30, chain ward 1e-7
(disclosed draft amendment); dety ward 12 points; runtime <= 1800
s; smoke = w9 only, sigma0 stride 4, dps 80, controls + jitter +
anchor + m2 + world legs skipped (strided atoms carry no moment
identities; tau/residue/essential legs run FULL inside smoke --
they do not consume the strided pairing).

SEALED VERDICT FORM (frozen BEFORE evaluation, joined with '+'):
  TAU_RATIO_EXACT / TAU_RATIO_OPEN
+ pole adjudication (sealed rule of leg P)
+ PAIRING_IN_MAIN_TERM(candidate, share) / PAIRING_IN_ERROR_AGAIN
+ SCRAMBLE_SEP_PASS(dec) / SCRAMBLE_SEP_FAIL(dec)
+ MARGIN_COVERED / MARGIN_OPEN(dec)
+ REL_GEOMETRY_CANCELS / REL_STRUCTURELESS [+ PAIRING_EXTENSIVE]
+ BEST_PAIRABLE_FORM(name) [carry YES/NO]
+ EPSTEIN_FIBER_MAINLIKE / EPSTEIN_FIBER_ANOMALOUS.
Honesty before beauty: no verdict claims a bound mechanism; the
budget bound and the base law stay OPEN (r243 PAIRCORR_REENCODED,
r247 B discipline, r250 error map, r251 error formulas stand).

RECORD TABLES (frozen from the calibration passes: pass 1
23/26 under the pre-amendment bars, pass 2 26/26 after the
disclosed amendments; wall 59.9 s full, 6.0 s smoke; disclosed
CALIBRATION AMENDMENTS beyond the architectural disclosure
above: (a0-smoke) t3 bar 1e-18 -> 1e-12 (the truncation
REFERENCE B_t - S_{n_t-1} is the f64 chain cumsum) and residue
t-ladder {1e-6, 1e-7} -> {1e-8, 1e-9} (neighboring union nodes
~1e-4 away leave a quadratic Richardson rest ~3e-5 at the
larger ladder) -- both found in smoke, before any full pass;
(a1) control-world tau bars 1e-6 -> 1e-3 with a new HARD
route-consistency gate |D_gram/D_det - 1| <= 1e-6 on ALL
worlds, after pass 1 measured SCR chain-dev 4.2e-4 with the
two tau routes agreeing to 3.7e-11 -- the f64 chain REFERENCE
saturates on flipped worlds, not the tau side; no amendments
after pass 2):
CAL_VERDICT = TAU_RATIO_EXACT + D_DIRECT_ONLY_OBSTRUCTED +
NO_FINITE_PAIR_DRESSING(D-layer) + POLE_REMOVAL_EXACT(rank1-
border) => PAIR_AWARE_OUTER_MODEL + PAIRING_IN_ERROR_AGAIN +
SCRAMBLE_SEP_FAIL(0.47 dec) + MARGIN_OPEN(1.4 dec) +
REL_STRUCTURELESS + PAIRING_EXTENSIVE + BEST_PAIRABLE_FORM(
FREE) [carry NO] + EPSTEIN_FIBER_ANOMALOUS.
Key numbers.  CENSUS: w9/w13 N = 184/168, T_true
+4.3343/+4.1449; SCRAMBLE T_true -4.4942 (gap 8.8285), EPSTEIN
+0.7615; flips 25/21/27.  WARDS: QP 4.4e-9, det Y 1.3e-98,
chain 1.0e-8 (bar 1e-7), det M 5.7e-79, kernel-column headroom
295 dec, U-Gram headroom max log10 |U| = 2.2 (bar 140).
LEG T (the round's SATZ headline): the tau-quotient identity
D = tau^aug/tau holds -- t1/t2 dual-norm + slogdet devs vs the
chain: w9 2.2e-11/7.2e-11 (D_direct +0.5612), w13
1.6e-11/4.5e-10 (+0.3561), SCR 4.2e-4/4.2e-4 (+0.5217, the f64
chain floor), EPST 1.3e-5/1.3e-5 (+1.7922); ROUTE CONSISTENCY
solve-vs-slogdet 9.5e-11 / 4.4e-10 / 3.7e-11 / 1.5e-13 -- the
two independent linear-algebra routes agree to 1e-10 on EVERY
world including the flipped ones (h_21 < 0 on SCRAMBLE: the
identity holds straight through the indefinite Gram); solve
residual worst 2.7e-13; t3 monomial mp truncations n_t = 12/24
dev 2.8e-17 / 1.0e-16 (dps 220, basis independence at the f64
reference floor); t4 TARGET THROUGH TAU: T_gram vs T_true rel
2.9e-12 (w9) / 1.3e-12 (w13) / 4.8e-5 (SCR, floor) / 3.1e-5
(EPST, INFO); T_gram gap MAIN-SCR +8.8287 vs chain +8.8285
(rel 2.5e-5) -- the tau route reproduces the target readout
and the world gap WITHOUT the chain => TAU_RATIO_EXACT.
LEG P (adjudication CLOSED): (p1) residue closure Res_{x_j}
C_N = w_j pihat_N(x_j) at 5 sampled atoms, worst rel 3.4e-9
(bar 1e-6) -- the rank-1/Uvarov layer is EXACTLY triangularly
removable, its poles are bookkeeping; (p2) essential order:
log10 |Re log10 D| = 3.71/36.66/366.58 at t = 1e-3/4/5 =>
p = +0.997 (bar 0.8; a finite-order divisor gives ~0): the
D-layer has ESSENTIAL singularities exp(c/(z-s)) at the atoms
-- D_DIRECT_ONLY_OBSTRUCTED is structural, NO finite
meromorphic pair dressing (triangular or interpolating-divisor)
can cancel an essential singularity; the surviving route is
PAIR_AWARE_OUTER_MODEL (replace the D-layer, keep the exact
rank-1 border); moll contrast bounded 0.58-0.59 dec on the
same ladder (full D 380.3 dec), rate 2.0e-6 / arg 7.5e-9.
LEG F: shares noD -0.0475/-0.00926, moll -0.0234/+0.0030, free
+5.89/+24.2 (w9/w13); T_free on SCR +237.6, EPST +46.4 =>
BEST_PAIRABLE_FORM(FREE) [carry NO] (draft finding confirmed).
LEG M (the round's honest MEASUREMENT headline): T^pair_dg =
+12.111 (w9, E^pair = -7.78) / +14.078 (w13, E = -9.93) /
+10.425 (SCR, E = -14.92, WRONG SIGN vs T_true -4.494) /
+12.202 (EPST, E = -11.44): the diagonal of the U-basis Gram
dual norm does NOT carry the target -- the off-diagonal Gram
part is order-1, and the world gap lands at share_dg =
0.190953 (T^pair gap 1.686 of 8.8285), share_free = -24.02:
BOTH candidates miss the window [0.5, 2.0] =>
PAIRING_IN_ERROR_AGAIN (sealed token, honest: the MAIN-
SCRAMBLE difference does NOT appear in either sealed leading
term; the arithmetic pairing lives in the FULL quadratic form,
not in its diagonal); MARGIN: |E^pair_dg|/D_direct = 13.9 (w9)
/ 27.9 (w13) => MARGIN_OPEN(1.4 dec).  LEG S (retained,
re-measured identically to the draft): route 3.8e-18, anchors
+5.6e-6/-5.8e-4 (SCR +1.7e-3, EPST -7.7e-4 INFO); battery
sep_SCR = 0.468 dec < 1.0 (X1 0.468 / X2 0.287 / X3 0.288) =>
SCRAMBLE_SEP_FAIL(0.47); EPST battery {0.794, 0.561, 1.199};
x2 ladder min 7.6/8.73 (band bound honestly fails: long-range
cancellation); kappa 4.30e-2/3.39e-2 (SCR 1.34e-2, EPST
4.68e-4), s_near 0.397/0.359 (uniform 0.020).  LEG R: (r-i)
med ||R_pair - I|| = 9.54 vs med model err 17.9, ratio 0.532 >
0.3 => REL_STRUCTURELESS (the worlds are ~2x closer to each
other than to the model, but far from geometric cancellation);
(r-iii) sign(sum d_n) MATCHES the true gap sign (the
pre-target diagonal action carries the right SIGN even though
its magnitude is only 19 percent), top-decile 18/176 degrees
carry 0.155 of sum |d_n| < 0.5 => PAIRING_EXTENSIVE (the
relative action is spread over ALL degrees, no low-rank
localization).  FALSIFIERS: SMOOTH self-alias 1.7e-23 (bar
1e-9); EPSTEIN battery breaks the MAIN-like prediction (r_deep
1.199 dec) => EPSTEIN_FIBER_ANOMALOUS (draft finding
confirmed: the BASIS moves the error kernel more than the
ARITHMETIC).  MUST-FAILS all loud: m1 2.0 = 3.5e5 x honest
5.6e-6; m2 head ratio 0.9991 in [0.5, 2.0]; m3 jitter 1.04e3 =
1.8e8 x; m4 excluded.
READING (typed, no upgrade): the adjudicated architecture is
half-confirmed, half-refuted -- CONFIRMED: (i) D = tau^aug/tau
is machine-exact at full depth on every world (SATZ-grade
gates; the augmented tau ratio IS the right main object, and
it reproduces the 8.83 world gap without the chain); (ii) the
pole-removal question is CLOSED: rank-1 border exactly
removable, D-layer essentially singular => the outer model
must be REPLACED pair-aware, not dressed.  REFUTED (honest):
(iii) neither sealed leading term (Gram diagonal, free kernel)
consumes the pairing -- the world difference stays in the
off-diagonal/error part (PAIRING_IN_ERROR_AGAIN), the margin
is open by 1.4 decades, and the relative problem is
structureless with an EXTENSIVE pairing action across all
degrees.  The candidate ladder for the next leading term is
now sharply pointed: it must be a NON-DIAGONAL functional of
the full Gram (the tau ratio itself), not any diagonal or
kernel-norm reduction of it.  E^pair has no a-priori bound;
the base law and the budget bound stay OPEN
(r243/r247/r250/r251 stand).
Runtime 59.9 s full, 6.0 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
import mpmath as mp

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

import bordered_hankel_probe as BH           # noqa: E402 r244
import centered_basefiber_probe as CB        # noqa: E402 r250
import port_integrable_kernel_probe as PIK   # noqa: E402 v881
import principal_bessel_probe as PB          # noqa: E402 r243
import szego_equilibrium_probe as SZ         # noqa: E402 r232a
import targetreadout_error_probe as TR       # noqa: E402 r251
import v563_paper2_readouts as core          # noqa: E402 READ-ONLY

MAIN_WINDOWS = (9, 13)
FIB_LO = 8
DPS_KERN = 120
DPS_MK = 60
DPS_MOLL_COL = 120
DPS_MR = 80
DPS_TAU = 220
FIB_DX = 1e-5
FIB_DY = 2e-5
QP_ITERS = 8000
QP_TOL = 1e-8
QP_RES_BAR = 1e-6
TAU_BAR = 1e-6
CTRL_TAU_BAR = 1e-3
TAU_TRUNC_BAR = 1e-12
TAU_RES_BAR = 1e-8
TAU_TRUNCS = (12, 24)
TAU_BT = 5.0 / 7.0
UGRAM_LG_BAR = 140.0
RES_SAMPLE = 5
RES_TS = (1e-8, 1e-9)
RES_BAR = 1e-6
ESS_TS = (1e-3, 1e-4, 1e-5)
ESS_ORDER_BAR = 0.8
MOLL_DELTA = 0.05
MOLL_DEC_BAR = 50.0
RICH_BAR = 1e-4
ARG_BAR = 1e-6
FREE_GAMMA = 0.25
FREE_LG_BAR = 250.0
CARRY_LO, CARRY_HI = 0.1, 10.0
SHARE_LO, SHARE_HI = 0.5, 2.0
ROUTE_BAR = 2e-9
REG_SYS_BAR = 0.10
NEAR_RD = 8
DEEP_Q = 0.10
SEP_DEC_BAR = 1.0
B_LADDER = (1, 2, 4, 8, 16, 32, 64)
X2_FACTOR_BAR = 2.0
NMID = 12
DELTA_GAP = 0.02
REL_BAR = 0.3
EXT_BAR = 0.5
SM_GUARD = 1e-9
JIT_EPS = 1e-3
JIT_SEED = 253
M1_LOUD = 100.0
M2_LO, M2_HI = 0.5, 2.0
M3_LOUD = 100.0
DETY_BAR = 1e-20
DETM_BAR = 1e-30
CHAIN_BAR = 1e-7
NSNAP_WARD = 12
CTRL_FLIPS = {"EPSTEIN": 25, "SCRAMBLE": 21, "SMOOTH": 27}
CAL_VERDICT = (
    "TAU_RATIO_EXACT + D_DIRECT_ONLY_OBSTRUCTED + "
    "NO_FINITE_PAIR_DRESSING(D-layer) + POLE_REMOVAL_EXACT("
    "rank1-border) => PAIR_AWARE_OUTER_MODEL + "
    "PAIRING_IN_ERROR_AGAIN + SCRAMBLE_SEP_FAIL(0.47 dec) + "
    "MARGIN_OPEN(1.4 dec) + REL_STRUCTURELESS + "
    "PAIRING_EXTENSIVE + BEST_PAIRABLE_FORM(FREE) [carry NO] + "
    "EPSTEIN_FIBER_ANOMALOUS")

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; every construction "
                       "consumes node positions + |weights| + the "
                       "QP minimizer ONLY; h_N never formed; "
                       "T_true/flips enter gates only (m4 oracle "
                       "EXCLUDED)" if not bad else "; ".join(bad))


# ---------------------------------------------- mollified model
def model_moll_at(md, z, dps):
    """the r250 FULL model with the Szego atom poles shifted to
    s_i - i delta_moll; CB.model_at full branch VERBATIM else."""
    mp.mp.dps = dps
    zc = mp.mpc(z)
    gs = mp.fsum(mp.mpf(float(r)) * mp.log(zc - mp.mpf(float(xx)))
                 for r, xx in zip(md["rho_s"], md["xs"]))
    nl = mp.mpf(md["nl"])
    a = mp.mpf(md["a"])
    b = mp.mpf(md["b"])
    beta = ((zc - b) / (zc - a)) ** mp.mpf("0.25")
    n11 = (beta + 1 / beta) / 2
    n12 = (beta - 1 / beta) / mp.mpc(0, 2)
    n21 = -n12
    Rz = (zc - a) * (((zc - b) / (zc - a)) ** mp.mpf("0.5"))
    dm = mp.mpc(0, MOLL_DELTA)
    dlog = (Rz / 2) * mp.fsum(
        mp.mpf(float(nn)) * mp.mpf(float(ll))
        / (zc - mp.mpf(float(ss)) + dm)
        for nn, ll, ss in zip(md["nu"], md["L"], md["xs"]))
    Dinf = mp.e ** mp.mpf(md["dinf_log"])
    Dz = mp.e ** dlog
    P = mp.e ** (gs - nl / 2)
    e_p = mp.e ** (nl / 2)
    e_m = mp.e ** (-nl / 2)
    M11 = e_p * Dinf * n11 * P / Dz
    M12 = e_p * Dinf * n12 * Dz / P
    M21 = e_m * n21 * P / (Dinf * Dz)
    M22 = e_m * Dz * n11 / (Dinf * P)
    kap = mp.mpc(0, -2) * mp.pi
    return ((M11, kap * M12), (M21 / kap, M22))


def d_dec_moll(md, zpts):
    z = np.asarray(zpts, complex)
    a, b = md["a"], md["b"]
    Rz = (z - a) * np.sqrt((z - b) / (z - a))
    s = np.zeros(len(z), complex)
    for nn, ll, ss in zip(md["nu"], md["L"], md["xs"]):
        s += float(nn) * float(ll) / (z - float(ss)
                                      + 1j * MOLL_DELTA)
    return np.abs(np.real(0.5 * Rz * s)) / math.log(10.0)


def rich_m1_moll(md, n, norm_z, dps):
    mp.mp.dps = dps
    enl = mp.e ** mp.mpf(md["nl"])
    vals = []
    for z in norm_z:
        zc = mp.mpc(z)
        M = model_moll_at(md, z, dps)
        zpn = zc ** (-int(n))
        E12 = M[0][1] / zpn / enl
        vals.append((zc, zc * E12))
    z1, v1 = vals[0]
    z2, v2 = vals[1]
    return (z2 * v2 - z1 * v1) / (z2 - z1) * enl


def m_cols_moll(md, zpts, dps):
    u = np.empty(len(zpts), complex)
    v = np.empty(len(zpts), complex)
    for i, z in enumerate(zpts):
        M = model_moll_at(md, complex(z), dps)
        u[i] = complex(M[0][0])
        v[i] = complex(M[1][0])
    return u, v


# ------------------------------------------------- free chain / U basis
def u_matrix(xs, c, nmax):
    """U_n(x - c) value matrix, n = 0..nmax-1 (f64)."""
    t = np.asarray(xs, float) - c
    P = np.empty((nmax, len(t)))
    P[0] = 1.0
    if nmax > 1:
        P[1] = 2.0 * t
    for n in range(2, nmax):
        P[n] = 2.0 * t * P[n - 1] - P[n - 2]
    return P


def cheb_cols(zpts, c, m, h0):
    """K^free columns: A = U_m(z - c), B = U_{m-1}(z - c)/(2 h0)."""
    t = np.asarray(zpts, complex) - c
    u0 = np.ones_like(t)
    u1 = 2.0 * t
    for _k in range(2, m + 1):
        u1, u0 = 2.0 * t * u1 - u0, u1
    au = np.abs(np.concatenate([u1, u0]))
    au = au[au > 0]
    lgmax = float(np.max(np.log10(au))) if len(au) else 0.0
    fin = bool(np.all(np.isfinite(u1)) and np.all(np.isfinite(u0)))
    return u1, u0 / (2.0 * h0), lgmax, fin


def gram_block(p, x0, N, B):
    """the leg-T tau machinery in the sealed U basis (f64)."""
    d = p["d"]
    dsm = p["dsm"]
    xu = np.concatenate([d["xs"], d["ys"]])
    wu = np.concatenate([d["ws"], -d["vs"]])
    bx = np.concatenate([dsm["xs"], dsm["ys"]])
    bw = np.concatenate([dsm["ws"], -dsm["vs"]])
    P = u_matrix(xu, x0, N)
    TB = u_matrix(bx, x0, N)
    ap = np.abs(np.concatenate([P.ravel(), TB.ravel()]))
    ap = ap[ap > 0]
    lgmax = float(np.max(np.log10(ap))) if len(ap) else 0.0
    G = (P * wu) @ P.T
    t = TB @ bw
    y = np.linalg.solve(G, t)
    resid = float(np.linalg.norm(G @ y - t)
                  / max(np.linalg.norm(t), 1e-300))
    Q = float(t @ y)
    y8 = np.linalg.solve(G[:FIB_LO, :FIB_LO], t[:FIB_LO])
    Q8 = float(t[:FIB_LO] @ y8)
    sG, ldG = np.linalg.slogdet(G)
    Gaug = np.zeros((N + 1, N + 1))
    Gaug[:N, :N] = G
    Gaug[:N, N] = t
    Gaug[N, :N] = t
    Gaug[N, N] = B
    sA, ldA = np.linalg.slogdet(Gaug)
    D_det = float(sA * sG * math.exp(ldA - ldG))
    diag = np.diag(G).copy()
    Tpair = float(np.sum(t[FIB_LO:] ** 2 / diag[FIB_LO:]))
    return dict(Q=Q, Q8=Q8, T_gram=Q - Q8, D_gram=B - Q,
                D_det=D_det, resid=resid, lgmax=lgmax,
                diag=diag, t=t, Tpair=Tpair)


def tau_trunc_mp(p, n_t, dps, Bt):
    """monomial mp Hankel cross-check at truncation n_t."""
    mp.mp.dps = dps
    d = p["d"]
    dsm = p["dsm"]
    xu = [mp.mpf(float(v)) for v in d["xs"]] \
        + [mp.mpf(float(v)) for v in d["ys"]]
    wu = [mp.mpf(float(v)) for v in d["ws"]] \
        + [-mp.mpf(float(v)) for v in d["vs"]]
    bx = [mp.mpf(float(v)) for v in dsm["xs"]] \
        + [mp.mpf(float(v)) for v in dsm["ys"]]
    bw = [mp.mpf(float(v)) for v in dsm["ws"]] \
        + [-mp.mpf(float(v)) for v in dsm["vs"]]
    mk = []
    pw = [mp.mpf(1)] * len(xu)
    for _k in range(2 * n_t - 1):
        mk.append(mp.fsum(w * q for w, q in zip(wu, pw)))
        pw = [q * x for q, x in zip(pw, xu)]
    tk = []
    pb = [mp.mpf(1)] * len(bx)
    for _k in range(n_t):
        tk.append(mp.fsum(w * q for w, q in zip(bw, pb)))
        pb = [q * y for q, y in zip(pb, bx)]
    H = mp.matrix(n_t, n_t)
    for i in range(n_t):
        for j in range(n_t):
            H[i, j] = mk[i + j]
    Ha = mp.matrix(n_t + 1, n_t + 1)
    for i in range(n_t):
        for j in range(n_t):
            Ha[i, j] = mk[i + j]
        Ha[i, n_t] = tk[i]
        Ha[n_t, i] = tk[i]
    Ha[n_t, n_t] = mp.mpf(Bt)
    D_tr = mp.det(Ha) / mp.det(H)
    ref = mp.mpf(Bt) - mp.mpf(float(p["S"][n_t - 1]))
    return float(abs(D_tr / ref - 1))


# ------------------------------------------------- pair stats
def pair_stats(C, rd, w):
    T = float(C.sum())
    Ca = np.abs(C)
    Xi = float(Ca.sum())
    bidx = np.zeros(rd.shape, dtype=np.int64)
    nz = rd >= 1
    bidx[nz] = np.floor(np.log2(rd[nz])).astype(np.int64) + 1
    nb = int(bidx.max()) + 1
    absb = np.bincount(bidx.ravel(), weights=Ca.ravel(),
                       minlength=nb)
    near = rd < NEAR_RD
    s_near = float(Ca[near].sum()) / max(Xi, 1e-300)
    frac_near = float(near.mean())
    thr = float(np.quantile(np.abs(w), DEEP_Q))
    dmask = np.abs(w) <= thr
    r_deep = (float(Ca[dmask, :].sum()) + float(Ca[:, dmask].sum())
              - float(Ca[np.ix_(dmask, dmask)].sum())) \
        / max(Xi, 1e-300)
    x1 = Xi / max(float(np.abs(w).sum()) ** 2, 1e-300)
    ladder = []
    for Bb in B_LADDER:
        msk = rd < Bb
        S = abs(float(C[msk].sum())) + float(Ca[~msk].sum())
        ladder.append((Bb, S / max(abs(T), 1e-300)))
    return dict(T=T, Xi=Xi, kappa=abs(T) / max(Xi, 1e-300),
                absb=absb / max(Xi, 1e-300),
                s_near=s_near, frac_near=frac_near, r_deep=r_deep,
                x1=x1, ladder=ladder)


def sep_decades(sa, sb):
    return {k: abs(math.log10(max(sa[k], 1e-300)
                              / max(sb[k], 1e-300)))
            for k in ("x1", "s_near", "r_deep")}


# --------------------------------------------------------------- main
def main():
    par = argparse.ArgumentParser()
    par.add_argument("--smoke", action="store_true")
    args = par.parse_args()
    smoke = args.smoke
    windows = (9,) if smoke else MAIN_WINDOWS
    stride = 4 if smoke else 1
    dps_k = 80 if smoke else DPS_KERN

    print("=" * 78)
    print("schlesinger_pairing_probe -- PRIME.PORT.RHP.FIBER."
          "SCHLESINGER_PAIRING.01 (round 253, adjudicated)")
    print("SPEC_SHA %s   F_DEF_SHA %s (imported r243)"
          % (SPEC_SHA[:16], PB.F_DEF_SHA[:16]))
    print("mode: %s" % ("SMOKE (w9 only, sigma0 stride 4, dps 80, "
                        "world legs skipped; tau/residue/essential "
                        "legs run FULL)" if smoke
                        else "FULL RECORD"))
    print("=" * 78)

    section("S0  FIREWALL + PREDEFINITION")
    okf, det = firewall_audit()
    check("G01-firewall", okf, det)
    check("G02-predefinition", True,
          "MAIN OBJECT D = tau^aug/tau (Schur identity of the "
          "r244/r245 bordered problem); routes: U-basis dual-norm "
          "solve + slogdet ratio (full depth) + monomial mp "
          "truncations %s (dps %d, corner B_t = 5/7); pole "
          "adjudication: residue t-ladder %s (bar %.0e) + "
          "essential-order ladder %s (order bar %.1f); T^pair "
          "candidates DIAG-GRAM + FREE-KERNEL (exclusion list "
          "asserted, main-term share window [%.1f, %.1f]); margin "
          "gate |E^pair| < D_direct; retained legs: kernel forms, "
          "anatomy/battery (sep bar %.1f dec), x2 ladder (bar "
          "%.1f), falsifiers, must-fails; ALL verdict rules "
          "sealed BEFORE evaluation; windows %s + controls on w9; "
          "contour dx %.0e / dy %.0e; dps kern %d / model %d,%d / "
          "moll %d; the architectural amendment (draft FIBER."
          "PAIRING.01 superseded by reviewer adjudication) is "
          "disclosed in the spec"
          % (str(TAU_TRUNCS), DPS_TAU, str(RES_TS), RES_BAR,
             str(ESS_TS), ESS_ORDER_BAR, SHARE_LO, SHARE_HI,
             SEP_DEC_BAR, X2_FACTOR_BAR, str(MAIN_WINDOWS),
             FIB_DX, FIB_DY, DPS_KERN, DPS_MK, DPS_MR,
             DPS_MOLL_COL))

    # ---------------- S1: census + controls
    section("S1  CENSUS + CONTROLS")
    packs = {("w%d" % kz): BH.wpack(kz) for kz in windows}
    ctrl = {}
    if not smoke:
        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"])
        ctrl_defs = (("EPSTEIN", dict(comb=(
            np.log(nn_idx.astype(float)),
            2.0 * lamE[nn_idx] / np.sqrt(nn_idx.astype(float))))),
            ("SCRAMBLE", dict(scramble_seed=1)),
            ("SMOOTH", dict(comb=(ug9, uw9))))
        ctrl = {c: BH.wpack(9, base_kw=kw) for c, kw in ctrl_defs}
    okCf = all(ctrl[c]["nf"] == CTRL_FLIPS[c] for c in ctrl) \
        if ctrl else True
    okC = all(packs[t]["nf"] is None for t in packs)
    tt = "; ".join("%s: N=%d T_true=%+.4f"
                   % (t, p["N"],
                      p["St"] - float(p["S"][FIB_LO - 1]))
                   for t, p in list(packs.items())
                   + [(c, ctrl[c]) for c in ("SCRAMBLE", "EPSTEIN")
                      if c in ctrl])
    check("G10-census-controls", okC and okCf,
          "free prefix positive on %d/%d MAIN windows; %s; control "
          "flips re-derived %s (falsifier battery armed)"
          % (sum(1 for t in packs if packs[t]["nf"] is None),
             len(packs), tt,
             str({c: ctrl[c]["nf"] for c in ctrl}) if ctrl
             else "SMOKE-skipped"))

    # ---------------- S2: per-world builds + mp passes
    section("S2  MODELS + MP KERNEL PASSES (wards)")
    rng = np.random.default_rng(JIT_SEED)
    res_worst = 0.0
    mass_ok = True
    detm_worst = 0.0
    dety_worst = 0.0
    chain_worst = 0.0
    lgmax_worst = 0.0
    fin_ok = True
    Wd = {}
    world_list = [(t, packs[t], t == "w9") for t in packs]
    if not smoke:
        world_list += [("SCR", ctrl["SCRAMBLE"], False),
                       ("EPST", ctrl["EPSTEIN"], False)]
    # sealed MAIN-geometry midpoints (filled at w9 build)
    zmid_main = None
    for tag, p, is_w9 in world_list:
        d = p["d"]
        N = p["N"]
        dsm = p["dsm"]
        x, wt, A, Lip, V = CB.eq_field(d)
        _pan, norm_z, x0, _a0, _b0 = CB.build_panels(x)
        c0 = p["Fv"][0] / p["hv"][0]
        batoms = np.concatenate([dsm["xs"], dsm["ys"]])
        bwts = np.concatenate([dsm["ws"], -dsm["vs"]])
        atoms = np.concatenate([batoms, x])[::stride]
        wts = np.concatenate([bwts, -c0 * wt])[::stride]
        nb = len(batoms[::stride])
        A0 = len(atoms)
        zpts = list(atoms + 1j * FIB_DX) + list(atoms + 1j * FIB_DY)
        atj = None
        res_pts = []
        mid_ids = []
        if is_w9:
            if not smoke:
                atj = atoms + JIT_EPS * (2.0 * rng.random(A0) - 1.0)
                zpts += list(atj + 1j * FIB_DX) \
                    + list(atj + 1j * FIB_DY)
            # residue sample: 5 first-zone nodes, position stride
            ridx = np.unique(np.linspace(
                0, len(d["xs"]) - 1, RES_SAMPLE).astype(int))
            for i in ridx:
                xj = float(d["xs"][i])
                res_pts.append((i, len(zpts)))
                zpts.append(xj)               # poly value (lv)
                for tt_ in RES_TS:
                    zpts.append(xj + 1j * tt_)  # Cauchy (snap)
            # sealed MAIN gap midpoints
            osort = np.argsort(atoms)
            srt = atoms[osort]
            pickm = np.unique(np.linspace(0, A0 - 2, NMID)
                              .astype(int))
            zmid_main = [0.5 * (srt[i] + srt[i + 1])
                         + 1j * DELTA_GAP for i in pickm]
        if is_w9 or tag == "SCR":
            mid_ids = list(range(len(zpts),
                                 len(zpts) + len(zmid_main))) \
                if zmid_main is not None else []
            if zmid_main is not None:
                zpts += list(zmid_main)
        npts = len(zpts)
        pick = np.unique(np.linspace(0, 2 * A0 - 1, NSNAP_WARD)
                         .astype(int)).tolist()
        snapN = sorted(set(pick)
                       | set(i0 + 1 + k for _j, i0 in res_pts
                             for k in range(len(RES_TS)))
                       | set(mid_ids))
        snap_pts = {FIB_LO: pick, N: snapN}
        mds = {}
        rho = None
        for n in (FIB_LO, N):
            rho, res = SZ.solve_qp(A, Lip, V, float(n), rho0=rho,
                                   iters=QP_ITERS, tol=QP_TOL)
            res_worst = max(res_worst, res)
            md = CB.model_data(x, wt, A, V, rho, n)
            mass_ok = mass_ok and (md["nround"] == n)
            mds[n] = md
            for z in (zpts[0], zpts[A0 - 1]):
                detm_worst = max(detm_worst, CB.detm_dev(
                    CB.model_at(md, complex(z), DPS_MR,
                                variant="noD")))
        hlog, gam, lvv, ysnap, dety = TR.mp_kernel_pass(
            d, zpts, snap_pts, {FIB_LO, N}, dps_k, N)
        dety_worst = max(dety_worst, dety)
        rows = p["rows"]
        for n in (12, N // 2):
            if n in gam:
                chain_worst = max(
                    chain_worst,
                    abs(gam[n] / rows[n - 1]["gam_next"] - 1.0))
        cols = {}
        for m in (FIB_LO, N):
            u, v, _g = TR.y_columns(lvv[m], npts)
            fin_ok = fin_ok and bool(
                np.all(np.isfinite(u)) and np.all(np.isfinite(v)))
            au = np.abs(np.concatenate([u, v]))
            au = au[au > 0]
            if len(au):
                lgmax_worst = max(lgmax_worst,
                                  float(np.max(np.log10(au))))
            cols[m] = (u, v)
        mu, mv = {}, {}
        for m in (FIB_LO, N):
            uu, vv = TR.m_columns(mds[m], zpts[:2 * A0], DPS_MK)
            fin_ok = fin_ok and bool(
                np.all(np.isfinite(uu)) and np.all(np.isfinite(vv)))
            mu[m], mv[m] = uu, vv
        info("%-5s N=%d: sigma0 atoms %d (border %d + window %d, "
             "c0 %.4g), points %d, dps %d%s%s%s"
             % (tag, N, A0, nb, A0 - nb, c0, npts, dps_k,
                ", jitter" if atj is not None else "",
                ", residue pts" if res_pts else "",
                ", midpoints" if mid_ids else ""))
        Wd[tag] = dict(p=p, N=N, A0=A0, nb=nb, atoms=atoms,
                       wts=wts, atj=atj, zpts=zpts, x0=x0,
                       norm_z=norm_z, mds=mds, cols=cols, mu=mu,
                       mv=mv, rows=rows, lvv=lvv, ysnap=ysnap,
                       res_pts=res_pts, mid_ids=mid_ids, d=d,
                       T_true=p["St"] - float(p["S"][FIB_LO - 1]))
    check("G20-qp-model-wards",
          res_worst <= QP_RES_BAR and mass_ok
          and detm_worst <= DETM_BAR,
          "constrained-equilibrium QP (r232a verbatim, masses "
          "{8, N}, warm-started): residual worst %.1e (bar %.0e); "
          "masses integer-exact; spot det M(noD) %.1e (bar %.0e)"
          % (res_worst, QP_RES_BAR, detm_worst, DETM_BAR))
    check("G21-kernel-pass-wards",
          dety_worst <= DETY_BAR and chain_worst <= CHAIN_BAR
          and fin_ok,
          "det Y_n = 1 at the ward snapshots to %.1e (bar %.0e); "
          "mp gammahat vs f64 wpack chain worst %.1e (bar %.0e, "
          "disclosed draft amendment); all kernel columns finite "
          "(max |log10| %.1f, headroom %.1f dec)"
          % (dety_worst, DETY_BAR, chain_worst, CHAIN_BAR,
             lgmax_worst, 308.0 - lgmax_worst))

    # ---------------- S3: LEG T -- the augmented tau quotient
    section("S3  LEG T -- THE AUGMENTED TAU QUOTIENT (main object)")
    gramd = {}
    tau_ok = True
    t_main = 0.0
    t_ctrl = 0.0
    rc_worst = 0.0
    tg_main = 0.0
    tg_scr = 0.0
    resid_worst = 0.0
    lgU_worst = 0.0
    tau_note = []
    tg_note = []
    tau_worlds = list(packs) + (["SCR", "EPST"] if not smoke
                                else [])
    for tag in tau_worlds:
        Wk = Wd[tag]
        p = Wk["p"]
        N = Wk["N"]
        B = float(p["S"][N - 2]) + 5.0 / 7.0
        D_direct = B - float(p["St"])
        anchor = 5.0 / 7.0 - float(p["rho"][N - 1])
        gb = gram_block(p, Wk["x0"], N, B)
        gramd[tag] = gb
        gb["D_direct"] = D_direct
        lgU_worst = max(lgU_worst, gb["lgmax"])
        resid_worst = max(resid_worst, gb["resid"])
        dev1 = abs(gb["D_gram"] / D_direct - 1.0)
        dev2 = abs(gb["D_det"] / D_direct - 1.0)
        rc = abs(gb["D_gram"] / gb["D_det"] - 1.0)
        rc_worst = max(rc_worst, rc)
        devT = abs(gb["T_gram"] / Wk["T_true"] - 1.0)
        if tag in packs:
            t_main = max(t_main, dev1, dev2)
            tg_main = max(tg_main, devT)
            tau_ok = tau_ok and abs(D_direct - anchor) <= 1e-9
        elif tag == "SCR":
            t_ctrl = max(t_ctrl, dev1, dev2)
            tg_scr = max(tg_scr, devT)
        else:
            t_ctrl = max(t_ctrl, dev1, dev2)
        tau_note.append("%s D_direct %+.4f dev(solve) %.1e "
                        "dev(slogdet) %.1e routes %.1e"
                        % (tag, D_direct, dev1, dev2, rc))
        tg_note.append("%s %.1e%s"
                       % (tag, devT,
                          "" if tag in packs else
                          (" (floor)" if tag == "SCR"
                           else " (INFO)")))
    check("G30-tau-dualnorm-slogdet",
          t_main <= TAU_BAR and t_ctrl <= CTRL_TAU_BAR
          and rc_worst <= TAU_BAR
          and resid_worst <= TAU_RES_BAR
          and lgU_worst <= UGRAM_LG_BAR and tau_ok,
          "D = tau^aug/tau via the U-basis Gram: %s -- MAIN worst "
          "%.1e (bar %.0e), flipped controls %.1e (floor bar "
          "%.0e, amendment a1: the f64 chain REFERENCE saturates "
          "there), route consistency solve-vs-slogdet worst %.1e "
          "(bar %.0e, ALL worlds); solve residual worst %.1e "
          "(bar %.0e); U headroom max log10 = %.1f (bar %.0f); "
          "anchor D_direct = 5/7 - rho_{N-1} exact -- the Schur "
          "identity of the r245 Uvarov insertion holds at FULL "
          "depth on two independent linear-algebra routes"
          % ("; ".join(tau_note), t_main, TAU_BAR, t_ctrl,
             CTRL_TAU_BAR, rc_worst, TAU_BAR, resid_worst,
             TAU_RES_BAR, lgU_worst, UGRAM_LG_BAR))
    tr_worst = 0.0
    tr_note = []
    for n_t in TAU_TRUNCS:
        devt = tau_trunc_mp(packs["w%d" % windows[0]], n_t,
                            DPS_TAU, TAU_BT)
        tr_worst = max(tr_worst, devt)
        tr_note.append("n_t=%d dev %.1e" % (n_t, devt))
    check("G31-tau-monomial-mp", tr_worst <= TAU_TRUNC_BAR,
          "monomial mp Hankel cross-check (w9, dps %d, corner "
          "B_t = 5/7): det[[H, t],[t^T, B]]/det H vs B - "
          "S_{n_t-1}: %s (bar %.0e) -- basis independence exact; "
          "the FULL-depth monomial route stays condition-"
          "obstructed and is never evaluated (typed)"
          % (DPS_TAU, "; ".join(tr_note), TAU_TRUNC_BAR))
    if not smoke:
        gap_gram = gramd["w9"]["T_gram"] - gramd["SCR"]["T_gram"]
        gap_true = Wd["w9"]["T_true"] - Wd["SCR"]["T_true"]
        gap_note = ("T_gram gap MAIN-SCR %+.4f vs T_true gap "
                    "%+.4f (rel %.1e)"
                    % (gap_gram, gap_true,
                       abs(gap_gram / gap_true - 1.0)))
    else:
        gap_note = "SMOKE: world gap skipped"
    check("G32-target-through-tau",
          tg_main <= TAU_BAR and tg_scr <= CTRL_TAU_BAR,
          "T_gram = Q_lin - Q8_lin vs the bitwise chain T_true: "
          "%s -- MAIN worst %.1e (bar %.0e), SCR %.1e (floor bar "
          "%.0e, amendment a1); %s -- the tau route reproduces "
          "the target readout (and the MAIN-SCRAMBLE gap) "
          "WITHOUT the chain"
          % ("; ".join(tg_note), tg_main, TAU_BAR, tg_scr,
             CTRL_TAU_BAR, gap_note))
    vT = ("TAU_RATIO_EXACT" if (t_main <= TAU_BAR
                                and t_ctrl <= CTRL_TAU_BAR
                                and rc_worst <= TAU_BAR
                                and tr_worst <= TAU_TRUNC_BAR
                                and tg_main <= TAU_BAR
                                and tg_scr <= CTRL_TAU_BAR
                                and resid_worst <= TAU_RES_BAR)
          else "TAU_RATIO_OPEN")

    # ---------------- S4: LEG P -- pole-removal adjudication
    section("S4  LEG P -- EXACT POLE-REMOVAL ADJUDICATION")
    Wk = Wd["w9"]
    N9 = Wk["N"]
    res_worst_rel = 0.0
    lv9 = Wk["lvv"][N9]
    mp.mp.dps = dps_k
    eLs9 = mp.e ** lv9["Ls"]
    for j, i0 in Wk["res_pts"]:
        xj = mp.mpf(float(Wk["d"]["xs"][j]))
        wj = mp.mpf(float(Wk["d"]["ws"][j]))
        pih = lv9["qz"][i0] * eLs9
        vals = []
        for k, tt_ in enumerate(RES_TS):
            Y = Wk["ysnap"][N9][i0 + 1 + k]
            zc = mp.mpc(float(Wk["d"]["xs"][j]), tt_)
            vals.append((mp.mpf(tt_), (zc - xj) * Y[0][1]))
        (t1, v1), (t2, v2) = vals
        r0 = (t2 * v1 - t1 * v2) / (t2 - t1)
        res_worst_rel = max(res_worst_rel,
                            float(abs(r0 / (wj * pih) - 1)))
    ok_p1 = res_worst_rel <= RES_BAR
    check("G40-rank1-residue-closure", ok_p1,
          "Res_{x_j} C_N = w_j pihat_N(x_j) (the r245 nilpotent "
          "E_13/E_12 triangular condition) at %d sealed sampled "
          "atoms, t-ladder %s Richardson: worst rel %.1e (bar "
          "%.0e) -- the rank-1/Uvarov border layer closes "
          "EXACTLY: its poles are bookkeeping, removable by the "
          "triangular transformation" % (RES_SAMPLE, str(RES_TS),
                                         res_worst_rel, RES_BAR))
    md9 = Wk["mds"][N9]
    dec0 = TR.d_pole_dec(md9, Wk["atoms"] + 1j * FIB_DX)
    sstar = float(Wk["atoms"][int(np.argmax(dec0))])
    ess = [float(TR.d_pole_dec(md9, [sstar + 1j * tt_])[0])
           for tt_ in ESS_TS]
    p_ord = float(np.polyfit(
        [math.log10(1.0 / tt_) for tt_ in ESS_TS],
        [math.log10(max(e, 1e-300)) for e in ess], 1)[0])
    ess_moll = [float(d_dec_moll(md9, [sstar + 1j * tt_])[0])
                for tt_ in ESS_TS]
    essential = p_ord >= ESS_ORDER_BAR
    check("G41-essential-order", True,
          "|Re log10 D| at s* + it, t = %s: %s -> order p = %+.3f "
          "(sealed bar %.1f; finite-order divisor ~ 0): the "
          "D-layer singularity is %s; MOLL contrast at the same "
          "points: %s (bounded) -- measured in log-arithmetic, "
          "no 380-decade number formed (priority 6)"
          % (str(ESS_TS), str([round(e, 2) for e in ess]), p_ord,
             ESS_ORDER_BAR,
             "ESSENTIAL (exp(c/(z-s)))" if essential
             else "finite-order",
             str([round(e, 2) for e in ess_moll])))
    if ok_p1 and essential:
        vP = ("D_DIRECT_ONLY_OBSTRUCTED + NO_FINITE_PAIR_"
              "DRESSING(D-layer) + POLE_REMOVAL_EXACT(rank1-"
              "border) => PAIR_AWARE_OUTER_MODEL")
    elif ok_p1:
        vP = "POLE_REMOVAL_EXACT"
    else:
        vP = "NO_FINITE_PAIR_DRESSING"

    # ---------------- S5: LEG F -- pairable kernel forms
    section("S5  LEG F -- SIGMA0-PAIRABLE KERNEL FORMS (retained)")

    def pairings(Wk):
        A0 = Wk["A0"]
        at = Wk["atoms"]
        wv = Wk["wts"]
        Dn = at[None, :] - at[:, None] + 1j * (FIB_DY - FIB_DX)
        KY, KM = {}, {}
        for m in (FIB_LO, Wk["N"]):
            u, v = Wk["cols"][m]
            KY[m] = TR.pair_kernel(u[:A0], v[:A0],
                                   u[A0:2 * A0], v[A0:2 * A0], Dn)
            KM[m] = TR.pair_kernel(Wk["mu"][m][:A0],
                                   Wk["mv"][m][:A0],
                                   Wk["mu"][m][A0:2 * A0],
                                   Wk["mv"][m][A0:2 * A0], Dn)

        def pr(K):
            return float(np.real(wv @ K @ wv))

        N = Wk["N"]
        TY_diff = pr(KY[N] - KY[FIB_LO])
        TM_diff = pr(KM[N] - KM[FIB_LO])
        Krem = (KY[N] - KM[N]) - (KY[FIB_LO] - KM[FIB_LO])
        dT_B = pr(Krem)
        gross = float(np.abs(wv) @ np.abs(Krem) @ np.abs(wv)) \
            + sum(float(np.abs(wv) @ np.abs(K) @ np.abs(wv))
                  for K in (KY[N], KM[N], KY[FIB_LO], KM[FIB_LO]))
        route = abs((TY_diff - TM_diff) - dT_B) / max(gross, 1e-300)
        C = (wv[:, None] * wv[None, :]) * np.real(Krem)
        rk = np.empty(A0)
        rk[np.argsort(at, kind="stable")] = np.arange(A0)
        rd = np.abs(rk[:, None] - rk[None, :])
        st = pair_stats(C, rd, wv)
        return dict(TY_diff=TY_diff, TM_diff=TM_diff,
                    dT=TY_diff - TM_diff, route=route, st=st,
                    KY_N=KY[N], Dn=Dn)

    P = {}
    for tag in list(packs) + (["SCR", "EPST"] if not smoke else []):
        P[tag] = pairings(Wd[tag])
        if tag != "w9":
            P[tag].pop("KY_N")
    shares = {}
    Tfree = {}
    moll_dec_max = 0.0
    fulld_dec_max = 0.0
    moll_rich_worst = 0.0
    moll_arg_worst = 0.0
    moll_detm_worst = 0.0
    free_lg_worst = 0.0
    free_fin = True
    for tag in list(packs) + (["SCR", "EPST"] if not smoke else []):
        Wk = Wd[tag]
        A0 = Wk["A0"]
        N = Wk["N"]
        wv = Wk["wts"]
        Dn = P[tag]["Dn"]
        h0 = float(Wk["p"]["hv"][0])
        Kf = {}
        for m in (FIB_LO, N):
            uf, vf, lg, fin = cheb_cols(Wk["zpts"][:2 * A0],
                                        Wk["x0"], m, h0)
            free_lg_worst = max(free_lg_worst, lg)
            free_fin = free_fin and fin
            Kf[m] = TR.pair_kernel(uf[:A0], vf[:A0], uf[A0:],
                                   vf[A0:], Dn)
        Tfree[tag] = float(np.real(wv @ (Kf[N] - Kf[FIB_LO]) @ wv))
        del Kf
        if tag not in packs:
            continue
        T_true = Wk["T_true"]
        sh_noD = P[tag]["TM_diff"] / T_true
        md_N = Wk["mds"][N]
        moll_dec_max = max(moll_dec_max, float(np.max(
            d_dec_moll(md_N, Wk["atoms"] + 1j * FIB_DX))))
        fulld_dec_max = max(fulld_dec_max, float(np.max(
            TR.d_pole_dec(md_N, Wk["atoms"] + 1j * FIB_DX))))
        m1m = rich_m1_moll(md_N, N, Wk["norm_z"], DPS_MR)
        moll_rich_worst = max(
            moll_rich_worst,
            abs(float(mp.log(abs(m1m), 10)) - md_N["hmod_l10"]))
        moll_arg_worst = max(moll_arg_worst,
                             abs(float(mp.arg(m1m))))
        for z in (Wk["zpts"][0], Wk["zpts"][A0 - 1]):
            moll_detm_worst = max(moll_detm_worst, CB.detm_dev(
                model_moll_at(md_N, complex(z), DPS_MR)))
        KMm = {}
        for m in (FIB_LO, N):
            uu, vv = m_cols_moll(Wk["mds"][m],
                                 Wk["zpts"][:2 * A0], DPS_MOLL_COL)
            free_fin = free_fin and bool(
                np.all(np.isfinite(uu)) and np.all(np.isfinite(vv)))
            KMm[m] = TR.pair_kernel(uu[:A0], vv[:A0], uu[A0:],
                                    vv[A0:], Dn)
        T_moll = float(np.real(wv @ (KMm[N] - KMm[FIB_LO]) @ wv))
        del KMm
        shares[tag] = dict(noD=sh_noD, MOLL=T_moll / T_true,
                           FREE=Tfree[tag] / T_true)
        info("%-5s T_true %+.4f | T_noD %+.4g (share %+.3g) | "
             "T_moll %+.4g (share %+.3g) | T_free %+.4g (share "
             "%+.3g)" % (tag, T_true, P[tag]["TM_diff"], sh_noD,
                         T_moll, T_moll / T_true, Tfree[tag],
                         Tfree[tag] / T_true))
    for tag in ("SCR", "EPST"):
        if tag in Tfree:
            info("%-5s T_true %+.4f | T_free %+.4g (leg-M feed)"
                 % (tag, Wd[tag]["T_true"], Tfree[tag]))
    check("G50-moll-free-wards",
          moll_dec_max <= MOLL_DEC_BAR
          and moll_rich_worst <= RICH_BAR
          and moll_arg_worst <= ARG_BAR
          and moll_detm_worst <= DETM_BAR
          and free_fin and free_lg_worst <= FREE_LG_BAR,
          "MOLL pairable: max |Re log10 D_moll| %.1f dec (bar "
          "%.0f; FULL-D %.1f obstructed), rate dev %.1e / arg "
          "%.1e / det M %.1e; FREE columns finite, max log10 |U| "
          "%.1f (bar %.0f)"
          % (moll_dec_max, MOLL_DEC_BAR, fulld_dec_max,
             moll_rich_worst, moll_arg_worst, moll_detm_worst,
             free_lg_worst, FREE_LG_BAR))
    best, best_d, carry = None, None, False
    for form in ("noD", "MOLL", "FREE"):
        shs = [shares[t][form] for t in packs]
        ok_carry = all(s > 0 and CARRY_LO <= abs(s) <= CARRY_HI
                       for s in shs)
        dist = float(np.median(
            [abs(math.log10(max(abs(s), 1e-300))) for s in shs]))
        if best is None or dist < best_d:
            best, best_d = form, dist
        if ok_carry:
            carry, best = True, form
            break
    vF = "BEST_PAIRABLE_FORM(%s) [carry %s]" % (
        best, "YES" if carry else "NO")
    check("G51-form-adjudication", True,
          "sealed carry rule (sign + |share| in [%.1f, %.1f]): %s"
          % (CARRY_LO, CARRY_HI, vF))

    # ---------------- S6: LEG M -- pairing in the leading model
    section("S6  LEG M -- PAIRING IN THE LEADING MODEL")
    check("G60-exclusion-list", True,
          "T^pair candidates consume ONLY: t~_n = int U_n "
          "dsigmatilde (exact border mass-position pairing), the "
          "window Gram diagonal G~_nn = int U_n^2 dmutilde, and "
          "the sigma0 atom-weight assignment (FREE kernel).  NOT "
          "consumed anywhere: node density, total mass alone, "
          "separated position/weight marginals, Hardy-Littlewood "
          "surrogates, norm estimates of the double sum, smooth "
          "main terms with pairing in the error (hard exclusion "
          "list, asserted)")
    split_note = []
    Epair = {}
    for tag in tau_worlds:
        gb = gramd[tag]
        T_true = Wd[tag]["T_true"]
        E_dg = T_true - gb["Tpair"]
        E_fr = T_true - Tfree[tag]
        Epair[tag] = dict(dg=E_dg, fr=E_fr)
        split_note.append(
            "%s T_true %+.5f | T^pair_dg %+.5f (E %+.2e) | "
            "T^pair_free %+.4g (E %+.3g)"
            % (tag, T_true, gb["Tpair"], E_dg, Tfree[tag], E_fr))
    for s in split_note:
        info(s)
    if not smoke:
        gap_true = Wd["w9"]["T_true"] - Wd["SCR"]["T_true"]
        share_dg = (gramd["w9"]["Tpair"] - gramd["SCR"]["Tpair"]) \
            / gap_true
        share_fr = (Tfree["w9"] - Tfree["SCR"]) / gap_true
        cands = []
        if SHARE_LO <= share_dg <= SHARE_HI:
            cands.append(("DIAG-GRAM", share_dg))
        if SHARE_LO <= share_fr <= SHARE_HI:
            cands.append(("FREE-KERNEL", share_fr))
        if cands:
            cands.sort(key=lambda c: abs(math.log10(c[1])))
            vM = "PAIRING_IN_MAIN_TERM(%s, share=%.4f)" % cands[0]
            best_cand = cands[0][0]
        else:
            vM = "PAIRING_IN_ERROR_AGAIN"
            best_cand = None
        check("G61-main-term-world-location", True,
              "the MAIN-SCRAMBLE gap %+.4f in the LEADING term: "
              "share_dg = %.6f, share_free = %.4f (sealed window "
              "[%.1f, %.1f]) => %s"
              % (gap_true, share_dg, share_fr, SHARE_LO, SHARE_HI,
                 vM))
    else:
        vM = "MAIN_TERM_SMOKE_NA"
        best_cand = "DIAG-GRAM"
        check("G61-main-term-world-location", True,
              "SMOKE: world location skipped")
    marg_ok = True
    marg_note = []
    worst_dec = -99.0
    for tag in packs:
        D_direct = gramd[tag]["D_direct"]
        E = Epair[tag]["dg" if best_cand in (None, "DIAG-GRAM")
                       else "fr"]
        r = abs(E) / max(abs(D_direct), 1e-300)
        marg_ok = marg_ok and (r < 1.0)
        worst_dec = max(worst_dec, math.log10(max(r, 1e-300)))
        marg_note.append("%s |E^pair| %.2e vs D_direct %+.4f "
                         "(ratio %.2e)" % (tag, abs(E), D_direct,
                                           r))
    vG = ("MARGIN_COVERED(%.1f dec headroom)" % -worst_dec
          if marg_ok else "MARGIN_OPEN(%.1f dec)" % worst_dec)
    check("G62-margin", True,
          "|E^pair(best candidate)| < D_direct per MAIN window: "
          "%s => %s (honest: E^pair is measured, not bounded; "
          "the B discipline r247 binds unchanged)"
          % ("; ".join(marg_note), vG))

    # ---------------- S7: LEG S -- retained separation legs
    section("S7  LEG S -- ERROR-KERNEL ANATOMY + SEPARATION")
    route_worst = max(P[t]["route"] for t in P)
    check("G70-route-regate", route_worst <= ROUTE_BAR,
          "atom-pair decomposition routes worst %.1e on gross "
          "(bar %.0e, %d worlds)" % (route_worst, ROUTE_BAR,
                                     len(P)))
    reg_worst = 0.0
    reg_note = []
    if stride == 1:
        for tag in packs:
            dev = P[tag]["TY_diff"] / Wd[tag]["T_true"] - 1.0
            reg_worst = max(reg_worst, abs(dev))
            reg_note.append("%s %+.1e" % (tag, dev))
        for tag in ("SCR", "EPST"):
            dev = P[tag]["TY_diff"] / Wd[tag]["T_true"] - 1.0
            reg_note.append("%s %+.1e (INFO)" % (tag, dev))
    check("G71-chain-anchor", (reg_worst <= REG_SYS_BAR)
          if stride == 1 else True,
          ("T^Y_reg vs T_true: %s -- MAIN worst %.1e (bar %.2f)"
           % ("; ".join(reg_note), reg_worst, REG_SYS_BAR))
          if stride == 1 else "SMOKE: anchor not applicable")
    for tag in P:
        st = P[tag]["st"]
        info("%-5s dT %+.4g  kappa %.2e  s_near %.3f (uniform "
             "%.3f)  r_deep %.3f  X1 %.3g  bands %s"
             % (tag, st["T"], st["kappa"], st["s_near"],
                st["frac_near"], st["r_deep"], st["x1"],
                " ".join("%.3f" % v for v in st["absb"])))
    if not smoke:
        seps = {t: sep_decades(P[t]["st"], P["w9"]["st"])
                for t in ("SCR", "EPST")}
        sep_scr = max(seps["SCR"].values())
        sep_eps = max(seps["EPST"].values())
        vS = ("SCRAMBLE_SEP_PASS(%.2f dec)" % sep_scr
              if sep_scr >= SEP_DEC_BAR
              else "SCRAMBLE_SEP_FAIL(%.2f dec)" % sep_scr)
    else:
        sep_scr = sep_eps = float("nan")
        seps = {}
        vS = "SEP_SMOKE_NA"
    x2_note = []
    for tag in packs:
        st = P[tag]["st"]
        fmin = min(f for _b, f in st["ladder"])
        x2_note.append("%s min %.3g" % (tag, fmin))
    check("G72-battery-and-ladder", True,
          "pre-evaluation battery: SCR %s, EPST %s => %s (bar "
          "%.1f dec); x2 ladder S(B)/|dT| minima: %s (bar %.1f, "
          "adjudicated draft finding: long-range cancellation)"
          % (str({k: round(v, 3) for k, v in seps["SCR"].items()})
             if seps else "SMOKE",
             str({k: round(v, 3) for k, v in seps["EPST"].items()})
             if seps else "SMOKE",
             vS, SEP_DEC_BAR, "; ".join(x2_note), X2_FACTOR_BAR))

    # ---------------- S8: LEG R -- the relative problem
    section("S8  LEG R -- THE RELATIVE PROBLEM (mechanism)")
    if not smoke:
        Wm = Wd["w9"]
        Ws = Wd["SCR"]
        nl9 = Wm["mds"][Wm["N"]]["nl"]
        md9n = Wm["mds"][Wm["N"]]
        errs_rel, errs_mod = [], []
        mp.mp.dps = dps_k
        for im, iz in enumerate(Wm["mid_ids"]):
            Ym = Wm["ysnap"][Wm["N"]][iz]
            Ys = Ws["ysnap"][Ws["N"]][Ws["mid_ids"][im]]
            errs_rel.append(CB.err_RI(Ym, Ys, nl9))
            z = Wm["zpts"][iz]
            Mn = CB.model_at(md9n, complex(z), DPS_MR,
                             variant="noD")
            errs_mod.append(CB.err_RI(Ym, Mn, nl9))
        med_rel = float(np.median(errs_rel))
        med_mod = float(np.median(errs_mod))
        ratio_rel = med_rel / max(med_mod, 1e-300)
        vR = ("REL_GEOMETRY_CANCELS" if ratio_rel <= REL_BAR
              else "REL_STRUCTURELESS")
        check("G80-relative-problem", True,
              "R_pair = Y_MAIN Y_SCR^{-1} at the %d sealed MAIN "
              "midpoints (level N, C-gauge ell_MAIN): med "
              "||R_pair - I|| = %.3g vs med model err %.3g -- "
              "ratio %.3g (bar %.1f) => %s"
              % (NMID, med_rel, med_mod, ratio_rel, REL_BAR, vR))
        t9 = gramd["w9"]["t"]
        dgM = gramd["w9"]["diag"]
        dgS = gramd["SCR"]["diag"]
        nlo = FIB_LO
        d_n = t9[nlo:] ** 2 * (1.0 / dgM[nlo:] - 1.0 / dgS[nlo:])
        sgn_ok = (np.sign(np.sum(d_n))
                  == np.sign(Wd["w9"]["T_true"]
                             - Wd["SCR"]["T_true"]))
        srt = np.sort(np.abs(d_n))[::-1]
        ntop = max(1, int(math.ceil(0.1 * len(d_n))))
        topshare = float(srt[:ntop].sum()
                         / max(srt.sum(), 1e-300))
        extensive = topshare < EXT_BAR
        vR2 = " + PAIRING_EXTENSIVE" if extensive else ""
        check("G81-pretarget-sign-localization", True,
              "per-degree diagonal action d_n = t~_n^2 (1/G^M_nn "
              "- 1/G^S_nn), n in [8, %d]: sign(sum d_n) %s the "
              "true gap sign (pre-target); top-decile (%d/%d "
              "degrees) carries %.3f of sum |d_n| (extensive bar "
              "%.1f) => %s"
              % (Wm["N"] - 1,
                 "MATCHES" if sgn_ok else "MISSES",
                 ntop, len(d_n), topshare, EXT_BAR,
                 "PAIRING_EXTENSIVE (spread over all degrees)"
                 if extensive else "localized"))
    else:
        vR = "REL_SMOKE_NA"
        vR2 = ""
        check("G80-relative-problem", True, "SMOKE: skipped")
        check("G81-pretarget-sign-localization", True,
              "SMOKE: skipped")

    # ---------------- S9: falsifiers + must-fails
    section("S9  FALSIFIERS + MUST-FAILS")
    if not smoke:
        pS = ctrl["SMOOTH"]
        dS = pS["d"]
        dsmS = pS["dsm"]
        xS, wtS, _AS, _LS, _VS = CB.eq_field(dS)
        c0S = pS["Fv"][0] / pS["hv"][0]
        atS = np.concatenate([np.concatenate([dsmS["xs"],
                                              dsmS["ys"]]), xS])
        wvS = np.concatenate([np.concatenate([dsmS["ws"],
                                              -dsmS["vs"]]),
                              -c0S * wtS])
        zS = list(atS + 1j * FIB_DX) + list(atS + 1j * FIB_DY)
        x0S = 0.5 * (float(xS[0]) + float(xS[-1]))
        h0S = float(pS["hv"][0])
        NS = pS["N"]
        DnS = atS[None, :] - atS[:, None] + 1j * (FIB_DY - FIB_DX)
        A0S = len(atS)
        KfS = {}
        for m in (FIB_LO, NS):
            uf, vf, _lg, _fin = cheb_cols(zS, x0S, m, h0S)
            KfS[m] = TR.pair_kernel(uf[:A0S], vf[:A0S], uf[A0S:],
                                    vf[A0S:], DnS)
        Kd = KfS[NS] - KfS[FIB_LO]
        T_sm = float(np.real(wvS @ Kd @ wvS))
        gross_sm = float(np.abs(wvS) @ np.abs(Kd) @ np.abs(wvS))
        del KfS, Kd, DnS
        ok_sm = abs(T_sm) <= SM_GUARD * max(gross_sm, 1e-300)
        check("G90-smooth-self-alias", ok_sm,
              "SMOOTH (border == window, c0 = %.12f): |T_free_SM| "
              "= %.2e vs gross %.2e, ratio %.1e (bar %.0e)"
              % (c0S, abs(T_sm), gross_sm,
                 abs(T_sm) / max(gross_sm, 1e-300), SM_GUARD))
        mainlike = all(v < SEP_DEC_BAR
                       for v in seps["EPST"].values())
        vE = ("EPSTEIN_FIBER_MAINLIKE" if mainlike
              else "EPSTEIN_FIBER_ANOMALOUS")
        check("G91-epstein-mainlike", True,
              "EPSTEIN battery ratios %s -- prediction (MAIN-"
              "like) %s => %s"
              % (str({k: round(v, 3)
                      for k, v in seps["EPST"].items()}),
                 "CONFIRMED" if mainlike else "BROKEN", vE))
    else:
        vE = "EPSTEIN_SKIPPED_SMOKE"
        check("G90-smooth-self-alias", True, "SMOKE: skipped")
        check("G91-epstein-mainlike", True, "SMOKE: skipped")
    Wk = Wd["w9"]
    A0 = Wk["A0"]
    wv = Wk["wts"]
    T_true9 = Wk["T_true"]
    reg_hon = abs(P["w9"]["TY_diff"] / T_true9 - 1.0) \
        if stride == 1 else float("nan")
    T_swap = -P["w9"]["TY_diff"]
    dev_m1 = abs(T_swap / T_true9 - 1.0)
    ok_m1 = (dev_m1 >= M1_LOUD * max(reg_hon, 1e-300)) \
        if stride == 1 else True
    if stride == 1:
        KYN = P["w9"]["KY_N"]
        wsig = wv.copy()
        wsig[Wk["nb"]:] = 0.0
        T_nav = float(np.real(wv @ KYN @ wv))
        T_sig = float(np.real(wsig @ KYN @ wsig))
        rho0 = float(Wk["p"]["rho"][0])
        m2_ratio = abs(T_sig - T_nav) / max(rho0, 1e-300)
        ok_m2 = M2_LO <= m2_ratio <= M2_HI
    else:
        m2_ratio = float("nan")
        ok_m2 = True
    if Wk["atj"] is not None:
        atj = Wk["atj"]
        Dnj = atj[None, :] - atj[:, None] + 1j * (FIB_DY - FIB_DX)
        Tj = {}
        for m in (FIB_LO, Wk["N"]):
            u, v = Wk["cols"][m]
            Kj = TR.pair_kernel(u[2 * A0:3 * A0], v[2 * A0:3 * A0],
                                u[3 * A0:4 * A0], v[3 * A0:4 * A0],
                                Dnj)
            Tj[m] = float(np.real(wv @ Kj @ wv))
            del Kj
        dev_m3 = abs((Tj[Wk["N"]] - Tj[FIB_LO]) / T_true9 - 1.0)
        ok_m3 = dev_m3 >= M3_LOUD * max(reg_hon, 1e-300)
        del Dnj
    else:
        dev_m3 = float("nan")
        ok_m3 = True
    check("G92-must-fails-fire", ok_m1 and ok_m2 and ok_m3,
          "m1 kernel index swap: dev %.3g = %.1e x honest %.1e "
          "(bar %.0f x); m2 centering omitted: head ratio %.4f "
          "in [%.1f, %.1f]; m3 atom jitter (eps %.0e, seed %d): "
          "dev %.3g = %.1e x honest (bar %.0f x); m4 sign "
          "oracle EXCLUDED (standing r243)"
          % (dev_m1, dev_m1 / max(reg_hon, 1e-300)
             if stride == 1 else float("nan"), reg_hon, M1_LOUD,
             m2_ratio, M2_LO, M2_HI, JIT_EPS, JIT_SEED, dev_m3,
             dev_m3 / max(reg_hon, 1e-300)
             if stride == 1 else float("nan"), M3_LOUD))

    # ---------------- S10: verdict
    section("S10  VERDICT")
    check("G95-mincut-unchanged", True,
          "mincut base 4 / refined 5 UNCHANGED; what the round "
          "adds: the machine-gated tau-quotient identity D = "
          "tau^aug/tau (full depth, three routes), the closed "
          "pole-removal adjudication (rank-1 exact, D-layer "
          "essential), the leading-term split T = T^pair + "
          "E^pair with the world-gap location, and the relative-"
          "problem mechanism readout")
    if smoke:
        verd = "SMOKE_NO_ADJUDICATION"
    else:
        verd = " + ".join([vT, vP, vM, vS, vG, vR + vR2, vF, vE])
    npass = sum(1 for _n, ok, _d in CHECKS if ok)
    check("G96-verdict", npass == len(CHECKS),
          "%s%s -- SATZ (machine-gated): tau quotient + residue "
          "closure + band split; MEASURED: T^pair split, world "
          "location, separation decades, relative problem, "
          "essential order; OPEN: any a-priori bound on E^pair, "
          "the separation mechanism as a theorem, the budget "
          "bound and the base law (r243/r247/r250/r251 stand); "
          "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\s+SPEC_SHA\s+([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 (round-31 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
    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
    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) | 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 = (
    ('bordered_hankel_probe', _SRC_0, 23, 'c21e15b5852126b9'),
    ('bordered_finite_rank_probe', _SRC_1, 29, '886c65618145b838'),
    ('border_centering_probe', _SRC_2, 24, '767d16cff674f312'),
    ('targetreadout_error_probe', _SRC_3, 20, 'b76487877383f645'),
    ('base_gauge_constant_probe', _SRC_4, 22, '26276cb2758152e9'),
    ('schlesinger_pairing_probe', _SRC_5, 26, 'e5f0498c98112da4'),
)


def run():
    t0 = time.time()
    print("=" * 74)
    print('v958 -- PRIME.PORT.RHP.BORDERED.READOUT.01 (rounds 244/245/248/251/252/')
    print('253, ADJUDICATED at the finite-identity level) + the FULLSOURCE campaign')
    print('contract [O] (post-r255 state): the bordered-RHP / tau-readout dictionary')
    print('-- Schlesinger rank-1 border, centering congruence, three exact error')
    print('formulas, contour R_1, exact augmented tau quotient, pole classification')
    print("(frozen probes embedded byte-exact and executed verbatim; NO RH claim)")
    print("=" * 74, flush=True)
    gates = []
    _psd_base_theorem(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("v958: %d/%d gates passed (4 module-own exact checks + 6 "
          "pattern gates) | runtime %.1f s"
          % (sum(gates), len(gates), time.time() - t0))
    print('the bordered Hankel end-object has an exact RHP dictionary: the budget')
    print('is a CD-kernel functional of the terminal Y_N data alone, the border is')
    print('a Schlesinger rank-1 insertion over a canonical 2x2 RHP with a 1-dim')
    print('budget cocycle, the centering congruence and the three error formulas')
    print('are exact, R_1 is a contour integral, and D = tau^aug/tau holds exactly')
    print('at full depth with the pole layers classified (rank-1 border removable,')
    print('D-layer essentially singular).  PRIME.PORT.RHP.BORDERED.READOUT.01 [E];')
    print('the campaign stays open as PRIME.PORT.RHP.FULLSOURCE.BASEFIBER.01 [O]')
    print('(OUTER_MODEL_FAILS + OFFDIAG_EXTENSIVE + ORIENTATION_LOWDIM(1) + the')
    print('2x2 prior; measurement rounds 250/254/255 stay experiments-side).')
    print('Mincut base 4 / refined 5 unchanged; NO RH claim.')
    print("[%s] v958 VERDICT GATE" % ("PASS" if ok else "FAIL"))
    return 0 if ok else 1


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