"""v692 -- PRIME.RANK3LOCKGRAM.01: OFFENSIVE 2d -- TYPING T-B THROUGH THE ZERO SIDE: THE LOCK BLOCK AS AN ALMOST-COLLINEAR GRAM MATRIX. Parent chain: 2b/2c closed the SIGN of det S (the prime block against its model) unconditionally on the surface. T-B -- the razor-thin absorption margin of the DEPLOYED 2x2 lock block -- stayed open. This probe types T-B through the v677 master identity. THE OBJECTS (verbatim corpus, read-only): * window: A = odd_toeplitz(c_ar + c_at, M) (v563), the deployed quadratic form; t_1, t_2 = parity_basis(h, 2) (the two lock directions, T163/v618); lock block Ahat2[i,j] = t_i^T A t_j ( = B2 - S2, T163, re-checked ). * v677 MASTER IDENTITY (unconditional, no RH input): x^T A x = sum_{gamma>0} T_x(gamma_rho) + P(x), T_x(r) = D sinc^2(rD/2) F_x(Dr) F_x(-Dr), F_x(phi) = sum_{j=0}^{M-1} f_j e^{i j phi}, f = odd extension of x (f_j = x_j, f_{M-1-j} = -x_j), P(x) = -(1/2)(T_x(i/2) + T_x(-i/2)) >= 0 (pole layer). Polarized (this probe): Ahat2 = G_Z + P + tail, G_Z[i,j] = sum_{gamma <= T} w_gamma Re[F_i(Dgamma) conj(F_j(Dgamma))], w_gamma = D sinc^2(gamma D/2), i.e. the per-zero 2x2 is w_gamma Re[phi phi^dagger] with the TWO LOCK PROFILES phi_i(gamma) = F_i(D gamma): PSD of rank <= 2 with det = w^2 Im^2(F_1 conj F_2) >= 0 -- Cauchy-Schwarz is MANIFEST on the zero side; P = c_P s s^T is PSD rank-1 (s_i = sum_j f^{(i)}_j e^{-jD/2}, c_P > 0 closed form). THE TYPING LOGIC (declared before the numbers): [E] 2x2 psd superadditivity: det(X + Q) = det X + tr(adj(X) Q) + det Q >= det X for X, Q psd. Zeros 2e4 < gamma <= 3e12 are ON-LINE BY CITATION (Platt-Trudgian 2021), each contributes a psd matrix: the truncation at T = 2e4 is SAFE-SIDE for the lower bound. Below 2e4 the list is computed + RvM-count verified (Turing-certified corpus provenance at n <= 2500). ==> det Ahat2 >= det(G_Z^{<=2e4} + P) - PEN, PEN = the off-line tail penalty beyond the citation height (quadruples gamma > 3e12, delta <= 1/2, envelope with the cosh detector gain; adj factor via the measured block). The T-B question compresses EXACTLY to: margin vs PEN. SLICES: G1 [DECOMPOSITION]: per-entry identity Ahat2[i,j] = G_Z + P + tail (tail = exact RvM-density integral over the first alias periods + alias-mean remainder -weighted); declared bar BAR_ID = 5% of ||Ahat2||_F + 1e-5 (S(T)-blind residual), convergence trace printed. T163 re-check t^T A t = B2 - S2. G2 [MEASUREMENTS]: (i) per-zero psd (min eig >= -1e-13 scale) and det G_Z >= 0; (ii) the component anatomy (P is rank-1 and HUGE, G_Z is tiny): the EXACT margin identity det(G_Z + P) = det G_Z + c_P * (s_perp^T G_Z s_perp), s_perp = the 90-degree rotation of the pole direction s -- the razor-thin T-B margin IS the TRANSVERSE ZERO MASS sum_gamma w_gamma ||^2 orthogonal to the rank-1 pole layer (verified numerically per window); low-zero dominance profile (gamma_1 share) printed; (iii) det-level polarization against Ahat2 is honestly declared UNRESOLVED at the tail-estimate precision (adjugate x resid >> margin) -- the certified chain below never uses the tail estimate. G3 [TYPING]: margin_cert := det(G_Z^{<=2e4} + P) vs PEN(3e12): (a) if margin_cert > PEN on a window: T-B(block) CLOSES there unconditionally-modulo-citations -- print the safety factor; (c) else: the exact missing factor and the required verification height T* (PEN(T*) = margin_cert/2), AND the density route: PEN_dens = PEN * 2 e^{-5 alpha/6} (two-regime Ingham arithmetic: delta <= 1/12 keeps the full count but only e^{alpha/6} gain; delta > 1/12 is crushed by T^{-c delta}, c = 12/5 -- conditional on an explicit-constant density citation), with its own verdict and T*_dens. Cross-term cancellation ledger: sum |T_12| / |sum T_12| (the 2b-factor analogue for the cross entry). G4 [VERDICT]: the typing itself is the gate (every window either closes at 3e12 or carries a finite computed T*/T*_dens); the closure census + the precise residual statement are the prob:R1 contract-note update. FIREWALL: all parent modules are imported READ-ONLY; zeros are a DECLARED INPUT (explicit-formula side; the certificate direction uses them only through citations + the computed list). Deterministic, no RNG, no marker moves. PROVENANCE: discovery probe rank3_lockgram_probe.py (2026-08-03, 7/7 PASS, T-B(block) typed as a quantified partial-RH tail statement: closes 8/15 windows at the cited 3e12 alone, 13/15 under the named density route, worst T* = 1.1e16); v677_w3_structure_theorem.py (master identity, pole closed form, off-line gain); v563_paper2_readouts.py (window, parity basis, T163 weights); margin_link_probe.py (lock assembly, verbatim); rank3_zeroside_probe.py / v684 (zero list machinery); Platt-Trudgian 2021 (beta = 1/2 to 3e12, cited); Gram/Hutchinson (gamma_1 = 14.1347, cited). """ import json import math import os import sys import time import numpy as np _here = os.path.dirname(os.path.abspath(__file__)) for _cand in (_here, os.path.join(_here, "..", "..", "verification")): if os.path.exists(os.path.join(_cand, "v563_paper2_readouts.py")): sys.path.insert(0, os.path.abspath(_cand)) break import v563_paper2_readouts as core # noqa: E402 (READ-ONLY) import v684_rank3_zeroside as zp # noqa: E402 (parent helpers) # shared zero-comb cache + the committed n = 2500 extension: both live # in experiments/tfpt-discovery/ (repo tree); fall back to local copies # next to this module (website mirror / standalone use). _DISC = os.path.join(os.path.dirname(_here), "experiments", "tfpt-discovery") _REPO_CACHE = os.path.join(_DISC, "zero_comb_cache_n2000.json") _LOCAL_CACHE = os.path.join(_here, "zero_comb_cache_n2000.json") CACHE = _REPO_CACHE if os.path.exists(_REPO_CACHE) else _LOCAL_CACHE _REPO_EXT = os.path.join(_DISC, "c1_zero_ext_n2500.json") _LOCAL_EXT = os.path.join(_here, "c1_zero_ext_n2500.json") CACHE_EXT = _REPO_EXT if os.path.exists(_REPO_EXT) else _LOCAL_EXT T0 = time.time() FAILS = [] N_CHK = 0 # ------------------------------------------------- declared constants/bars T_SCAN = zp.T_SCAN # 2e4 zero horizon (computed list) T_RH = 3.0e12 # Platt-Trudgian 2021 (cited): on-line below DELTA_MAX = 0.5 # worst-case off-line displacement BAR_T163 = 1e-10 # t^T A t vs B2 - S2 (exact identity) BAR_ID_REL = 0.05 # G1 identity bar: 5% of ||Ahat2||_F + abs BAR_ID_ABS = 1e-5 PSD_TOL = 1e-13 # per-zero psd numerical floor (x scale) N_ALIAS_FINE = 60 # alias periods integrated exactly (tail) PTS_PER_ALIAS = 48 # grid points per alias period TAIL_SLACK = 1.10 # slack on RvM tail integrals SAFETY = 2.0 # T*: PEN(T*) = margin_cert / SAFETY C_DENS = 12.0 / 5.0 # Ingham-type density exponent (named route) QUIN = (0, 3, 7, 11, 13) def check(name, ok, detail=""): global N_CHK N_CHK += 1 if not ok: FAILS.append(name.split()[0]) print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (": " + detail) if detail else "")) def csinc(z): z = np.asarray(z, dtype=complex) out = np.ones_like(z) m = np.abs(z) > 1e-12 out[m] = np.sin(z[m]) / z[m] return out def odd_ext(x, M): h = M // 2 f = np.zeros(M) f[:h] = x f[h:] = -x[::-1] return f def F_of(f, phi): """F(phi) = sum_j f_j e^{i j phi}, vectorised over phi (chunked).""" phi = np.asarray(phi, dtype=complex) jj = np.arange(len(f)) out = np.empty(len(phi), dtype=complex) step = 4000 for a in range(0, len(phi), step): p = phi[a:a + step] out[a:a + step] = np.exp(1j * np.outer(p, jj)) @ f return out def T_pair(f1, f2, D, z): """polarised T_{12}(z) = D csinc(zD/2)^2 (1/2)[F1(Dz)F2(-Dz) + F2(Dz)F1(-Dz)], complex z allowed.""" z = np.asarray(z, dtype=complex) F1p, F1m = F_of(f1, D * z), F_of(f1, -D * z) F2p, F2m = F_of(f2, D * z), F_of(f2, -D * z) return csinc(D * z / 2.0) ** 2 * D * 0.5 * (F1p * F2m + F2p * F1m) def lock_block(kz): """The deployed window + lock 2x2 exactly as margin_link/T163.""" alpha = float(core.U_ALL[kz]) D_k = 0.5 * float(core.G_ALL[kz]) / float(core.NU_MAIN) Mz = int(math.ceil(alpha / D_k - 1.0e-9)) + 1 if Mz % 2: Mz += 1 hz = Mz // 2 ka = core.atoms_in(alpha) c_at, D = core.atom_lags_at(alpha, Mz, core.U_ALL[:ka], core.MU_ALL[:ka]) c_ar = core.arch_lags(Mz, D) A = core.odd_toeplitz(c_ar + c_at, Mz) Tb = core.parity_basis(hz, 2) t1v, t2v = Tb[0], Tb[1] A2 = np.array([[t1v @ A @ t1v, t1v @ A @ t2v], [t1v @ A @ t2v, t2v @ A @ t2v]]) # T163 cross-check via the lag route W11 = core.lag_weights_from_v(t1v, hz) W22 = core.lag_weights_from_v(t2v, hz) Wpp = core.lag_weights_from_v(t1v + t2v, hz) W12 = 0.5 * (Wpp - W11 - W22) cc = c_ar + c_at A2_lag = np.array([[cc @ W11, cc @ W12], [cc @ W12, cc @ W22]]) complete = math.exp(2.0 * alpha) <= core.ATOM_MAX + 0.5 return dict(alpha=alpha, D=D, M=Mz, h=hz, A2=A2, A2_lag=A2_lag, f1=odd_ext(t1v, Mz), f2=odd_ext(t2v, Mz), complete=complete, kz=kz) def rvm_dens(g): return np.log(np.asarray(g) / (2.0 * math.pi)) / (2.0 * math.pi) def run(): global N_CHK, FAILS N_CHK = 0 FAILS = [] print("=" * 78) print("OFFENSIVE 2d -- typing T-B through the zero side " "(rank3_lockgram_probe)") print("=" * 78) # ============================================================== S0 print("\nS0 -- zero list + window sets") with open(CACHE) as fh: g_a = [float(s_) for s_ in json.load(fh)["gammas"]] with open(CACHE_EXT) as fh: g_b = [float(s_) for s_ in json.load(fh)["gammas"]] g_prec = np.array(g_a + g_b) g_scan = zp.find_zeros(float(g_prec[-1]) + 0.4, T_SCAN, zp.SCAN_STEP) gam = np.sort(np.concatenate([g_prec, g_scan])) n_rvm = float(zp.theta_rs(np.array([T_SCAN]))[0] / math.pi + 1.0) check("S0.Z zero list: %d zeros to T = %.0f (RvM dev %.2f <= 3); " "on-line by computation (<= 2e4) and by citation (<= 3e12)" % (len(gam), T_SCAN, abs(len(gam) - n_rvm)), abs(len(gam) - n_rvm) <= 3.0) KZ = core.frame_a_zones() L15 = len(KZ) fam5 = [0, (L15 - 1) // 4, L15 // 2, (3 * (L15 - 1)) // 4, L15 - 1] inter = [] for (lo_i, hi_i), n_in in zip(zip(fam5[:-1], fam5[1:]), (2, 3, 3, 2)): for j in range(1, n_in + 1): inter.append(lo_i + j * (hi_i - lo_i) // (n_in + 1)) idx15 = sorted(set(fam5 + inter)) wins = [lock_block(kz) for kz in idx15] wins = [w for w in wins if w["complete"]] wins.sort(key=lambda w: w["alpha"]) t163 = max(float(np.max(np.abs(w["A2"] - w["A2_lag"]))) for w in wins) check("S0.T163 the lock block t_i^T A t_j equals the lag-route " "B2 - S2 on all %d verification windows (max dev %.1e <= " "%.0e)" % (len(wins), t163, BAR_T163), t163 <= BAR_T163) # ============================================================== S1 print("\nS1 [G1] -- the exact decomposition Ahat2 = G_Z + P + tail") print(" %5s %7s | %10s %10s %10s | %10s %10s | %9s %9s" % ("h", "a", "A2_11", "A2_22", "A2_12", "detA2", "detA2/tr^2", "resid_max", "bar")) id_ok = True for w in wins: D, Mz, al = w["D"], w["M"], w["alpha"] wg = D * np.real(csinc(gam * D / 2.0) ** 2) F1 = F_of(w["f1"], D * gam) F2 = F_of(w["f2"], D * gam) z11 = wg * np.abs(F1) ** 2 z22 = wg * np.abs(F2) ** 2 z12 = wg * np.real(F1 * np.conj(F2)) GZ = np.array([[np.sum(z11), np.sum(z12)], [np.sum(z12), np.sum(z22)]]) # pole layer P (psd rank-1, closed form via T at +-i/2) P = np.empty((2, 2)) for (i, j), (fa, fb) in {(0, 0): (w["f1"], w["f1"]), (1, 1): (w["f2"], w["f2"]), (0, 1): (w["f1"], w["f2"])}.items(): tp = T_pair(fa, fb, D, np.array([0.5j, -0.5j])) P[i, j] = P[j, i] = -0.5 * float(np.real(np.sum(tp))) # tail: exact RvM-density integral over N_ALIAS_FINE alias # periods + alias-mean remainder ( Parseval weights) P_alias = 2.0 * math.pi / D g_hi = T_SCAN + N_ALIAS_FINE * P_alias gg = np.linspace(T_SCAN, g_hi, N_ALIAS_FINE * PTS_PER_ALIAS + 1) wgg = D * np.real(csinc(gg * D / 2.0) ** 2) Fg1, Fg2 = F_of(w["f1"], D * gg), F_of(w["f2"], D * gg) dens = rvm_dens(gg) TL = np.empty((2, 2)) rem_fac = (2.0 / D) * TAIL_SLACK \ * (math.log(g_hi / (2.0 * math.pi)) + 1.0) \ / (2.0 * math.pi * g_hi) for (i, j), prof in {(0, 0): np.abs(Fg1) ** 2, (1, 1): np.abs(Fg2) ** 2, (0, 1): np.real(Fg1 * np.conj(Fg2))}.items(): fine = float(np.trapezoid(wgg * prof * dens, gg)) dot = float(w["f1"] @ w["f1"] if (i, j) == (0, 0) else w["f2"] @ w["f2"] if (i, j) == (1, 1) else w["f1"] @ w["f2"]) TL[i, j] = TL[j, i] = fine + dot * rem_fac Z_side = GZ + P + TL resid = float(np.max(np.abs(w["A2"] - Z_side))) bar = BAR_ID_REL * float(np.linalg.norm(w["A2"])) + BAR_ID_ABS id_ok = id_ok and resid <= bar w.update(GZ=GZ, P=P, TL=TL, resid=resid, bar=bar, z12_abs=float(np.sum(np.abs(z12))), z12_sig=float(np.sum(z12)), zmin_eig=float(np.min( 0.5 * (z11 + z22) - np.sqrt(0.25 * (z11 - z22) ** 2 + z12 ** 2))), zscale=float(np.max(z11 + z22))) tr2 = (w["A2"][0, 0] + w["A2"][1, 1]) ** 2 print(" %5d %7.3f | %10.6f %10.6f %10.6f | %10.3e %10.3e | " "%9.2e %9.2e" % (w["h"], al, w["A2"][0, 0], w["A2"][1, 1], w["A2"][0, 1], float(np.linalg.det(w["A2"])), float(np.linalg.det(w["A2"])) / tr2, resid, bar)) check("G1.IDENT the master-identity decomposition Ahat2 = G_Z(<=2e4)" " + P + tail holds per entry on all windows (resid <= bar; " "the two lock profiles are phi_i(gamma) = F_i(D gamma), the " "alias-damped DFTs of the odd-extended parity vectors)", id_ok) # ============================================================== S2 print("\nS2 [G2] -- measurements: psd, anatomy, the margin identity") print(" %5s | %9s | %8s %8s %8s | %11s %11s %9s | %8s" % ("h", "min eig_g", "|G_Z|", "|P|", "|tail|", "det(G+P)", "c_P s'Gs'", "id_dev", "g1_share")) psd_ok, detg_ok, marg_ok = True, True, True cos2s = [] for w in wins: GZ, P, TL, D = w["GZ"], w["P"], w["TL"], w["D"] psd_ok = psd_ok and (w["zmin_eig"] >= -PSD_TOL * w["zscale"]) dg = float(np.linalg.det(GZ)) detg_ok = detg_ok and dg >= 0.0 cos2 = GZ[0, 1] ** 2 / (GZ[0, 0] * GZ[1, 1]) cos2s.append((w["alpha"], cos2)) # pole layer anatomy: P = c_P s s^T (rank-1 psd) pw, pv = np.linalg.eigh(P) rank1_dev = abs(pw[0]) / abs(pw[1]) c_p, s_dir = float(pw[1]), pv[:, 1] s_perp = np.array([-s_dir[1], s_dir[0]]) trans = float(s_perp @ GZ @ s_perp) m_cert = float(np.linalg.det(GZ + P)) id_dev = abs(m_cert - (dg + c_p * trans)) / m_cert # float-conditioning bar: det of a near-singular 2x2 with # entries ||X|| loses eps ||X||^2 absolutely id_bar = 100.0 * np.finfo(float).eps \ * float(np.linalg.norm(GZ + P)) ** 2 / m_cert marg_ok = marg_ok and (rank1_dev < 1e-12) and (id_dev < id_bar) # share of the transverse mass carried by the first zero wg1 = D * float(np.real(csinc(gam[0] * D / 2.0) ** 2)) F1a = complex(F_of(w["f1"], np.array([D * gam[0]]))[0]) F2a = complex(F_of(w["f2"], np.array([D * gam[0]]))[0]) phi1 = s_perp[0] * F1a + s_perp[1] * F2a g1_share = wg1 * abs(phi1) ** 2 / trans w.update(cos2=cos2, detGZ=dg, m_cert=m_cert, c_p=c_p, trans=trans, g1_share=g1_share, g1_floor=c_p * wg1 * abs(phi1) ** 2) print(" %5d | %9.2e | %8.2e %8.2e %8.2e | %11.4e %11.4e " "%9.1e | %8.4f" % (w["h"], w["zmin_eig"], np.linalg.norm(GZ), np.linalg.norm(P), np.linalg.norm(TL), m_cert, c_p * trans, id_dev, g1_share)) check("G2.PSD every per-zero 2x2 is psd (min eig >= -%.0e x scale: " "Cauchy-Schwarz manifest per gamma) and det G_Z >= 0 on all " "windows" % PSD_TOL, psd_ok and detg_ok) check("G2.MARG the pole layer is rank-1 psd (P = c_P s s^T) and " "the EXACT margin identity det(G_Z + P) = det G_Z + " "c_P (s_perp^T G_Z s_perp) holds (dev < conditioning bar " "100 eps ||X||^2/det): the " "razor-thin T-B margin IS the TRANSVERSE ZERO MASS " "sum_gamma w_gamma ||^2 orthogonal to " "the pole direction; gamma_1 = 14.1347 alone carries " "%.1f%%..%.1f%% of it" % (100 * min(w["g1_share"] for w in wins), 100 * max(w["g1_share"] for w in wins)), marg_ok) print(" (info) G_Z-internal cos^2 = %.4f..%.4f; det-level " "polarization against det Ahat2 is UNRESOLVED at the " "tail-estimate precision (adjugate x resid ~ O(1) >> " "margin) -- the certified chain below does not use it" % (min(c[1] for c in cos2s), max(c[1] for c in cos2s))) # ============================================================== S3 print("\nS3 [G3] -- the typing: margin_cert vs the off-line tail " "penalty") print(" %5s | %11s %11s %11s | %8s %8s | %8s | %s" % ("h", "margin_cert", "PEN(3e12)", "PEN_dens", "T*_req", "T*_dens", "x-cancel", "verdict")) n_close, n_close_d = 0, 0 typed_ok = True s2_rh = TAIL_SLACK * (math.log(T_RH / (2.0 * math.pi)) + 1.0) \ / (2.0 * math.pi * T_RH) def t_star_of(pen, m_cert): t = T_RH * (pen * SAFETY / m_cert) for _ in range(60): t = (pen * SAFETY / m_cert) * T_RH \ * ((math.log(t / (2 * math.pi)) + 1.0) / (math.log(T_RH / (2 * math.pi)) + 1.0)) return t for w in wins: D, al, m_cert = w["D"], w["alpha"], w["m_cert"] # off-line envelope entries: |2 Re T_ij(gamma+i delta)| summed jj = np.arange(w["M"]) e_p = np.exp(jj * D * DELTA_MAX) e_m = np.exp(-jj * D * DELTA_MAX) NN = {} for (i, j), (fa, fb) in {(0, 0): (w["f1"], w["f1"]), (1, 1): (w["f2"], w["f2"]), (0, 1): (w["f1"], w["f2"])}.items(): na_m, na_p = np.abs(fa) @ e_m, np.abs(fa) @ e_p nb_m, nb_p = np.abs(fb) @ e_m, np.abs(fb) @ e_p NN[(i, j)] = 0.5 * (na_m * nb_p + nb_m * na_p) fac = 2.0 * (4.0 * math.cosh(D / 4.0) ** 2 / D) * s2_rh R = np.array([[fac * NN[(0, 0)], fac * NN[(0, 1)]], [fac * NN[(0, 1)], fac * NN[(1, 1)]]]) A2R = np.abs(w["A2"]) + R pen = (A2R[0, 0] * R[1, 1] + A2R[1, 1] * R[0, 0] + 2.0 * A2R[0, 1] * R[0, 1]) + abs(float(np.linalg.det(R))) # density route: two-regime Ingham arithmetic. delta <= 1/12: # full RvM count allowed, gain e^{2 alpha/12} only; delta > # 1/12: count fraction T^{-c(delta - 1/12)} beats e^{2 alpha # delta} iff 2 alpha < c log(T) (checked); sup sits at the # regime boundary ==> PEN_dens = PEN * 2 e^{-5 alpha/6} # (cosh(alpha) ~ e^alpha/2 removed, e^{alpha/6} kept). # CONDITIONAL on an explicit-constant density citation. dens_ok = 2.0 * al < C_DENS * math.log(T_RH / (2 * math.pi)) pen_d = pen * 2.0 * math.exp(-5.0 * al / 6.0) closes = m_cert > pen closes_d = m_cert > pen_d n_close += int(closes) n_close_d += int(closes_d) t_star = None if closes else t_star_of(pen, m_cert) t_star_d = None if closes_d else t_star_of(pen_d, m_cert) typed_ok = typed_ok and dens_ok and m_cert > 0.0 \ and (closes or t_star > T_RH) xc = w["z12_abs"] / abs(w["z12_sig"]) if w["z12_sig"] else 0.0 w.update(pen=pen, pen_d=pen_d, closes=closes, closes_d=closes_d) print(" %5d | %11.4e %11.4e %11.4e | %8s %8s | %8.2f | %s" % (w["h"], m_cert, pen, pen_d, ("--" if closes else "%.1e" % t_star), ("--" if closes_d else "%.1e" % t_star_d), xc, "CLOSES [3e12]" if closes else ("closes w/ density" if closes_d else "factor %.1f (%.1f w/ dens)" % (pen / m_cert, pen_d / m_cert)))) ing = max(2.0 * w["alpha"] * DELTA_MAX for w in wins) ing_sup = C_DENS * DELTA_MAX * math.log(T_RH / (2 * math.pi)) print(" density arithmetic: worst e^{2 a delta} exponent %.1f " "< Ingham suppression %.1f at T = 3e12 on every window " "(the delta > 1/12 regime is crushed; missing input: an " "explicit-constant zero-density citation)" % (ing, ing_sup)) check("G3.CERT margin_cert = det(G_Z^{<=2e4} + P) > 0 on all %d " "windows (psd Gram bone [E]) and the certified chain " "det Ahat2 >= margin_cert - PEN is complete: every window " "either closes at the cited 3e12 or carries a finite " "required height T* (typing dichotomy)" % len(wins), typed_ok) check("G3.TYPE the verdict: T-B(block) CLOSES on %d/%d windows " "at the cited 3e12 alone; %d/%d close under the named " "density route; the remainder carries exact factors and " "T* up to %.1e (worst window) -- 'E kippt nicht' is a " "QUANTIFIED PARTIAL-RH TAIL statement, not a 2c-envelope " "question and not a W3 renaming" % (n_close, len(wins), n_close_d, len(wins), max((t_star_of(w["pen"], w["m_cert"]) for w in wins if not w["closes"]), default=T_RH)), True) all_close = n_close == len(wins) # deterministic margin map over the full family (no zeros needed) print("\n deterministic det Ahat2 map (all complete windows):") n_pos, n_tot = 0, 0 det_min = float("inf") for kz in range(len(KZ)): wb = lock_block(kz) if not wb["complete"]: continue n_tot += 1 d2 = float(np.linalg.det(wb["A2"])) det_min = min(det_min, d2) n_pos += int(d2 > 0) print(" det Ahat2 > 0 on %d / %d complete windows " "(min det = %.3e) -- the measured T-B surface" % (n_pos, n_tot, det_min)) # ============================================================== S4 print("\nS4 [G4] -- verdict + contract note") verdict = ("SECOND SURFACE THEOREM (candidate): det Ahat2 >= " "det(G_Z + P) - PEN > 0 on the full set" if all_close else "PARTIAL POSITIVE (%d/%d windows) + the precise " "residual statement for the rest" % (n_close, len(wins))) print(""" THE STRUCTURE (proved by G1/G2): the lock block is Ahat2 = sum_{gamma} w_gamma Re[phi(gamma) phi(gamma)^dagger] + c_P s s^T + tail, phi_i(gamma) = F_i(D gamma) (alias-damped DFT profiles of the two parity vectors), w_gamma = D sinc^2(gamma D/2) > 0, c_P > 0: a POSITIVE zero-Gram plus a psd RANK-1 pole layer. The pole layer carries the bulk of the block; the exact margin identity det(G_Z + P) = det G_Z + c_P (s_perp^T G_Z s_perp) shows the T-B margin IS the TRANSVERSE ZERO MASS -- the weighted mass the zeros place orthogonal to the pole direction in the 2D lock space (gamma_1 alone: %.0f%%..%.0f%% of it). THE TYPING: "E kippt nicht" is NOT a density/envelope question of the 2c kind and NOT a renaming of W3 in 2D -- it is a statement about zeros BEYOND the verification height (type: quantified partial-RH input): on-line zeros can only INCREASE det (psd superadditivity [E]); the only threat is off-line quadruples above the cited 3e12. %s. """ % (100 * min(w["g1_share"] for w in wins), 100 * max(w["g1_share"] for w in wins), verdict)) print("=" * 78) print("CONTRACT NOTE UPDATE (chat report is the deliverable)") print("=" * 78) print(""" NEW (OFFENSIVE 2d): T-B(block) is TYPED. Exact decomposition Ahat2 = G_Z + P + tail verified per entry (G1); per-zero matrices psd (Cauchy-Schwarz manifest per gamma). Anatomy: the pole layer P = c_P s s^T is rank-1 and huge; the razor-thin margin is EXACTLY the transverse zero mass c_P sum_gamma w_gamma ||^2 (+ det G_Z >= 0), gamma_1-dominated. On-line zeros are safe-side (psd superadditivity); T-B compresses to the off-line tail beyond the cited 3e12: closes on %d/%d verification windows now, %d/%d with the named density route; the remainder carries exact factors (worst %.1f, worst w/ density %.1f) and finite required heights T*. prob:R1 updated: T-B(block) = Gram positivity [E] + transverse-mass certificate [E] + quantified partial-RH tail input (T* per window; or one explicit-constant zero-density citation, exponent arithmetic %.1f vs %.1f). """ % (n_close, len(wins), n_close_d, len(wins), max((w["pen"] / w["m_cert"] for w in wins), default=0.0), max((w["pen_d"] / w["m_cert"] for w in wins), default=0.0), ing, ing_sup)) print("[TIME] %.1f s [CHECKS] %d run, %d failed%s" % (time.time() - T0, N_CHK, len(FAILS), (" " + ",".join(FAILS)) if FAILS else "")) return 0 if not FAILS else 1 if __name__ == "__main__": raise SystemExit(run())