"""v548 -- PRIME.GREEN.SZEGO.IDENT.01: the Green/Szego identities of phase 2. The IDENTITY- and CERTIFICATE-shaped core of T147 (the exact factorisation of the all-D question) and T148 (the lifting statement dissected) -- every statement RECOMPUTED here from scratch on small exactly checkable frame-A windows (no citation of sandbox output). Companion to PRIME.LEVEL.LEMMA.01 (v547), which certified the a-priori level constant c_0^ap: THIS module certifies the two scalars that constant is made of -- the factorisation Gam = sqrt(Q_star) x Sw, the spectral factor Sw by an LDL^T inertia layer cake, and the geometric factor's l1-ceiling machinery with the Liouville transform -- on the same class of windows. WHAT IS LOAD-BEARING HERE (and nothing else): identities, per-instance theorems with CHECKED hypotheses, and per-window CERTIFIED inequalities. NO fit, NO D-exponent, NO uniform-in-zone statement, and NO statement FOR ALL D -- the ONE open input of T148 (a bound nu_L <= F(form) with F m-free for the bottom block of the REWEIGHTED section; equivalently bounded total variation of log Lam, or any weaker smoothness of the multiplier) stays OPEN and is neither assumed nor approached. Each identity is checked as a NUMERICAL RESIDUAL against a preregistered tolerance AND against at least one MUTATION CONTROL that must fail loudly. [E] (1) THE FACTORISATION IDENTITY (T147). For a symmetric positive definite E with Green matrix R = E^{-1} and any scalar lam_up: Gam := sqrt(m) lam_up max_j ||R e_j|| == sqrt(Q_star) x Sw , Sw := lam_up ||R||_F (purely SPECTRAL) , Q_star := m max_j (R^2)_jj / tr(R^2) (purely GEOMETRIC) , -- one line, exact, form-independent: the all-D question splits into one spectral and one geometric scalar and into nothing else. Verified on every window and on random PD forms; the certified factorisation (residual-paid column norms, Frobenius bracket) dominates the true Gam. [E] (2) THE BOTTOM-BLOCK EQUIDISTRIBUTION CONSTANT (T147). With Pi_B the spectral projector onto B = {k : lam_k <= 10 lam_hat} (preregistered rule): sum_j (Pi_B)_jj == |B| EXACTLY (the trace identity), hence Q_B := m max_j (Pi_B)_jj >= |B| is a THEOREM (max >= mean) -- and the Szego/Widom mechanism's sharp prediction Q_B <= 2|B|(1+o(1)) is taken as the REFERENCE: the measured Q_B/|B| lies in the preregistered band [1, 2.2] on every window, while the localised alternative (a rank-|B| coordinate projector, Q_B = m) is wrong by orders. The band statement is a MEASUREMENT on a finite list, typed as such. [E] (3) THE SECOND-DIFFERENCE l1 CEILING (T148, the lever). For the exact Dirichlet eigenpair L_0 s_k = mu_k s_k (Kac-Murdock-Szego 1953) and ANY unit vector psi with a_k = : mu_k^p a_k = is an IDENTITY, hence the certified coefficientwise bound |a_k| <= min(1, ||s_k||_inf ||L_0^p psi||_1 / mu_k^p), p = 1, 2, the summed ceiling dominating the true ||a||_1, and -- with mu_k >= 4k^2/(m+1)^2 from sin t >= 2t/pi -- the m-FREE closed form ||a||_1 <= 2 sqrt(nu) + 1, nu := (m+1)^{3/2} ||L_0 psi||_1/(2 sqrt 2), every power of m cancelled: nu alone carries the m-dependence. The arithmetic chain m ||psi||_inf^2 <= 2 ||a||_1^2 <= 2 ceil^2 closes it. Calibration: for the Dirichlet bottom mode ||a||_1 = 1 EXACTLY and nu -> pi at every size. [E] (4) THE LAYER-CAKE Sw CERTIFICATE (T148). At thresholds tau_i = rho_i x lam_lo (preregistered ladder, lam_lo a certified positive floor), a completed LDL^T factorisation counts eigenvalues below tau_i (Sylvester 1852; Bunch-Kaufman 1977) -- the count VERIFIED against the direct spectrum on every rung -- and the layer cake sum_k lam_k^{-2} <= N_1/lam_lo^2 + sum_i (N_{i+1}-N_i)/tau_i^2 + (m-N_L)/tau_L^2 certifies Sw = lam_up ||R||_F <= Sw_cnt per window, no sorted eigenvalue list trusted anywhere. Dropping the bottom layer breaks the bound on every window: the bottom eigenvalue IS the weight. [E] (5) THE LIOUVILLE TRANSFORM AND THE WEIGHT-CLASS DISCRIMINATOR (T148). E psi = lam psi <=> A phi = lam Lam phi with phi = Lam^{-1/2} psi: phi -- not psi -- is the vector the PURE Toeplitz-minus-Hankel section acts on (the classical Liouville change of variables, not a perturbation). The chain, every step verified in its direction: m ||psi||_inf^2 <= kap_Lam m ||phi_hat||_inf^2 <= 2 kap_Lam ||a(phi_hat)||_1^2 <= 2 kap_Lam ceil(phi_hat)^2 , kap_Lam = max Lam / min Lam A PRIORI (a ratio of two diagonal entries of the form; no eigenvector read). THE DISCRIMINATOR, the reason TV(log Lam) is the named hypothesis: on a model Toeplitz-minus-Hankel section with a GENUINE order-2 zero (f(0) = 0, f''(0)/2 = 1, verified exactly), reweighted by a BOUNDED-VARIATION multiplier versus a ROUGH one (lattice-scale oscillation, TV ~ m) at MATCHED kap_Lam, the smoothness functional nu stays flat for the BV class and grows for the rough class -- the rough class MUST be worse, and it is the roughness, not the conditioning, that breaks the ceiling. NAMED LIMITS AS LOAD-BEARING CONTENT (the claim INCLUDES them): (i) These are PER-INSTANCE statements on SMALL windows. Nothing here is uniform in the zone index or in D; what is established is a FINITE LIST of certified window inequalities with an explicit maximum, and every T147/T148 exponent is a FIT that stays in the sandbox. The step to ALL D -- an m-free bound on the smoothness functional nu_L of the reweighted bottom block by a functional of the form (equivalently: bounded TV(log Lam) or weaker) -- is OPEN, explicitly typed open, and neither assumed nor approached. (ii) (2) is a trace IDENTITY plus a MEASURED band with the mechanism's sharp prediction as reference; the mechanism's hypothesis at the symbol level was REFUTED by T148 (f(0) < 0 on every surface window: positive definiteness is a finite-section effect of the minus-Hankel part and the lumping), so the order-2 bottom scaling enters nowhere as a theorem and the Sw certificate of (4) does not use it -- it is an inertia count. (iii) (1) and (3) are statements about ANY symmetric PD form / ANY unit vector; (5)'s kap_Lam is a functional of the form alone; none of them says anything about the SIZE of any constant on any surface. (iv) The energy-route constant sig_tot is RETIRED AS A ROUTE (T148): the Green route is the certified one and no compiler statement waits on sig_tot; nothing here re-opens it and no marker of any pre-existing contract moves. HONEST FENCES (load-bearing typing): * THE RH FENCE. The surrounding statement is the positivity of a Weil window form (Weil 1952, CITED, never used as a criterion) on a FINITE list of prime-power zones. Everything here is an identity or a certified inequality PER INSTANCE; NOTHING here claims, assumes or approaches RH, and no statement about zeta zeros is made. No zero data of any kind is read, generated or approximated -- an AST firewall enforces this. NO all-D claim: even with every check green, what stands is a finite list of certified window statements on prime-power zones, and the all-D lifting input (nu_L / TV(log Lam)) stays open here and everywhere. * Classics named CLASSICAL: Kac-Murdock-Szego 1953 (the exact Dirichlet eigenpair and the order-2 model), Widom 1958 / Basor-Ehrhardt 2009 / Bottcher-Silbermann (the Toeplitz+Hankel address, CITED as the mechanism's home and never used as an authority), Sylvester 1852 / Bunch-Kaufman 1977 (inertia), Euler 1735 (sum k^-4 = pi^4/90), Rayleigh 1877 / Ritz 1909 (the variational upper bound), Cauchy- Schwarz, Davis-Kahan 1970 (CITED as the route T148 computed to be vacuous by 2.7-5.7 orders -- NOT used here), Gershgorin 1931, Wilkinson 1968 / Higham 2002 (completed Cholesky and its floor). * ZERO-FIREWALL: AST-checked; no zetazero / nzeros loader; the prime side is a finite zero-free sum over prime powers. Status: [E] exact linear-algebra / counting identities at rel < 1e-11 .. 1e-15 as stated, per-instance theorems with checked hypotheses, certified inequalities by completed Cholesky / completed LDL^T with the direction in the name, each with a mutation control that fails by >= 1e-3 relative. Python; Wolfram-mirrored not required (dense Cholesky / LDL^T / eigenvalue identities stay Python-only), counted per GATE.WOLFRAM.02. Discovery provenance: experiments/tfpt-discovery/green_asymptotic_probe.py (T147) experiments/tfpt-discovery/szego_bottom_probe.py (T148) """ from __future__ import annotations import ast import math import time import numpy as np from numpy.linalg import LinAlgError from scipy.linalg import cho_factor, cho_solve, eigh, eigvalsh, ldl from tfpt_constants import check, summary, reset # ---------------------------------------------------------------- budgets NU_MAIN = 4 # T105 admissibility floor / T112 frame A ATOM_MAX = 320000 # atom table cap, as in v546/v547 H_CAP = 300 # HARD cap on any inverted / diagonalised matrix H_MIN = 24 GL_N = 48 CHUNK = 16384 EULER = 0.5772156649015328606065120900824 LOG_PI = math.log(math.pi) U_ROUND = 2.0 ** -53 K_SCAN = 110 # prime-power zones scanned N_INST = 12 # frame-A windows kept (spread over the D range) N_RAND = 7 # random PD forms for the form-independent items RAND_M = 40 # their size # --- THE BOTTOM BLOCK, preregistered exactly as in T147 ---------------------- THETA_BLK = 10.0 # --- the certified counting ladder of item (4), preregistered ---------------- RHO_LADDER = (1.5, 2.0, 4.0, 8.0, 16.0, 64.0, 256.0, 1024.0) # --- THE MODEL LADDER of item (5): a symbol with a GENUINE order-2 zero ------ # f(th) = (2 - 2 cos th) + MODEL_Q (2 - 2 cos th)^2 , f(0) = 0, f''(0)/2 = 1 MODEL_Q = 0.3 MODEL_C = (2.0 + 6.0 * MODEL_Q, -1.0 - 4.0 * MODEL_Q, MODEL_Q) MODEL_SIZES = (64, 96, 144, 216, 288) WEIGHT_AMP = 0.6 # amplitude of the model diagonal reweighting # --- preregistered tolerances / bars (declared BEFORE any number) ----------- TOL_ID = 1.0e-11 # every identity must hold to this relative level TOL_DIR = 1.0e-9 # one-sided slack of per-instance theorem steps BAR_CTRL = 1.0e-3 # a mutation control must fail at least this hard QB_BAND = (1.0, 2.2) # the preregistered equidistribution band Q_B/|B| QB_REF = 2.0 # the Szego/Widom sharp reference Q_B <= 2|B| BAR_SMOOTH_FLAT = 1.5 # nu max/min on the BV ladder counted as FLAT BAR_ROUGH_GROW = 4.0 # nu growth ratio on the rough ladder (must exceed) BAR_ROUGH_OVER = 3.0 # rough nu top over BV nu top (must exceed) BAR_KAP_MATCH = 0.10 # relative kap_Lam mismatch allowed between classes BAR_TV_SPLIT = 8.0 # TV(log Lam) rough/BV at the top rung (must exceed) ZETA4 = math.pi ** 4 / 90.0 # sum_{k>=1} k^{-4} (Euler 1735) -- EXACT constant def sym(A): return 0.5 * (A + A.T) def rel(Dm, Rf): return float(np.abs(Dm).max()) / max(float(np.abs(Rf).max()), 1.0e-300) def ast_zero_firewall(src_path: str) -> bool: with open(src_path, "r", encoding="utf-8") as fh: tree = ast.parse(fh.read()) hits = [] for node in ast.walk(tree): if isinstance(node, ast.Call): f = node.func if isinstance(f, ast.Attribute) and f.attr in ( "zetazero", "nzeros", "second_sheet_zero", ): hits.append(f.attr) if isinstance(f, ast.Name) and f.id in ("zetazero", "nzeros"): hits.append(f.id) if isinstance(node, ast.Attribute) and node.attr in ("zetazero",): hits.append(node.attr) return not hits # ---------------------------------------------------------------- atoms def von_mangoldt_table(n_max): sieve = np.ones(n_max + 1, dtype=bool) sieve[:2] = False for i in range(2, int(math.isqrt(n_max)) + 1): if sieve[i]: sieve[i * i::i] = False lam = np.zeros(n_max + 1) for p in np.nonzero(sieve)[0]: p = int(p) lp = math.log(p) q = p while q <= n_max: lam[q] = lp q *= p return lam def atom_table(n_max): lam = von_mangoldt_table(n_max) out = [] for n in np.nonzero(lam > 0)[0]: n = int(n) out.append((n, lam[n], math.log(n), 2.0 * lam[n] / math.sqrt(n))) return out ATOMS_ALL = atom_table(ATOM_MAX) UU_ALL = [t[2] for t in ATOMS_ALL] NN_ALL = [t[0] for t in ATOMS_ALL] ATOM_PAIRS = [(t[2], t[3]) for t in ATOMS_ALL] U_SORTED = np.array(UU_ALL, dtype=float) _GLX, _GLW = np.polynomial.legendre.leggauss(GL_N) def atoms_in(alpha): lim = 2.0 * alpha + 1.0e-14 k = int(np.searchsorted(U_SORTED, lim, side="right")) return ATOM_PAIRS[:k] # --------------------------------- the archimedean kernel (Weil 1952, cited) def _arch_A_far(s, D): s = np.asarray(s, dtype=float).reshape(-1, 1) out = np.zeros(s.shape[0]) for lo, hi in ((s - D, s), (s, s + D)): mid = 0.5 * (lo + hi) half = 0.5 * (hi - lo) w = mid + half * _GLX[None, :] val = ((1.0 - np.abs(s - w) / D) * np.exp(-0.5 * w) / (-np.expm1(-2.0 * w))) out -= half[:, 0] * (val @ _GLW) return out def _arch_integrand(w, s, D): tri_s = max(0.0, 1.0 - abs(s) / D) S = 0.5 * (np.maximum(0.0, 1.0 - np.abs(s - w) / D) + np.maximum(0.0, 1.0 - np.abs(s + w) / D)) return ((tri_s * np.exp(-2.0 * w) - S * np.exp(-0.5 * w)) / (-np.expm1(-2.0 * w))) def _arch_A_near(s, D): s = abs(float(s)) tri_s = max(0.0, 1.0 - s / D) W = s + D pts = sorted({0.0, s, D - s, W}) pts = [p for p in pts if 0.0 <= p <= W] tot = 0.0 for lo, hi in zip(pts[:-1], pts[1:]): if hi <= lo: continue mid = 0.5 * (lo + hi) half = 0.5 * (hi - lo) w = mid + half * _GLX tot += half * float(np.dot(_GLW, _arch_integrand(w, s, D))) return (-(EULER + LOG_PI) * tri_s + 2.0 * tot + tri_s * (-math.log1p(-math.exp(-2.0 * W)))) def arch_A(sv, D): sv = np.abs(np.asarray(sv, dtype=float)) out = np.empty(sv.shape[0]) far = sv >= D if far.any(): out[far] = _arch_A_far(sv[far], D) for i in np.nonzero(~far)[0]: out[i] = _arch_A_near(sv[i], D) return out def arch_lags(M, D): out = np.empty(M) for a in range(0, M, CHUNK): b = min(M, a + CHUNK) out[a:b] = arch_A(np.arange(a, b) * D, D) return out def lag_vector_fast(alpha, M, atoms): """The T115 O(#atoms) lag assembly (frame-A code path of T128..T148).""" D = 2.0 * alpha / M c = arch_lags(M, D) for u_j, mu_j in atoms: i0 = int(math.floor(u_j / D)) for i in range(max(0, i0 - 2), min(M, i0 + 3)): v = 1.0 - abs(i * D - u_j) / D if v > 0.0: c[i] -= mu_j * 0.5 * v if u_j < D: for i in range(0, min(M, int(math.floor((D - u_j) / D)) + 2)): v = 1.0 - (i * D + u_j) / D if v > 0.0: c[i] -= mu_j * 0.5 * v return c, D # ------------------------------------- the reflection-odd sector (T106..T148) def odd_toeplitz(c, M): h = M // 2 r = np.arange(h) return (c[np.abs(r[:, None] - r[None, :])] - c[(M - 1) - r[:, None] - r[None, :]]) def even_window(u, D): M = int(math.ceil(u / D - 1.0e-9)) + 1 if M % 2: M += 1 return M def safe_cho(Q): try: return cho_factor(Q, lower=True, check_finite=False) except LinAlgError: return None def chol_floor(A_norm, h): """THE DECLARED FLOATING-POINT FLOOR (Wilkinson 1968; Higham 2002).""" ch = (h + 1.0) / max(1.0 - (h + 1.0) * U_ROUND, 1.0e-300) return ch * U_ROUND * A_norm def gersh(X): return float(np.max(np.abs(X).sum(axis=1))) def cert_lam_min_pos(Y, tries=40): """A CERTIFIED STRICTLY POSITIVE floor for lam_min(Y), halved until the Cholesky of Y - t I completes (nan if Y is not positive definite).""" n = Y.shape[0] if n == 0: return float("nan") Y = sym(Y) try: lam = float(eigvalsh(Y, subset_by_index=[0, 0])[0]) except (LinAlgError, ValueError): return float("nan") fl = chol_floor(gersh(Y), n) t = 0.9 * lam - fl for _ in range(tries): if t <= 0.0: return float("nan") if safe_cho(Y - t * np.eye(n)) is not None: return t t *= 0.5 return float("nan") def inertia_neg(X): """THE CERTIFIED EIGENVALUE COUNT (Sylvester 1852; Bunch-Kaufman 1977): the number of negative eigenvalues of a symmetric X from the block diagonal of a completed pivoted LDL^T -- a certificate, never a sorted list. Returns -1 when the factorisation does not complete.""" n = X.shape[0] if n == 0: return 0 try: _lu, d, _perm = ldl(sym(X), lower=True) except (LinAlgError, ValueError): return -1 if not np.all(np.isfinite(d)): return -1 i, neg = 0, 0 while i < n: two = (i + 1 < n) and (abs(float(d[i, i + 1])) > 0.0 or abs(float(d[i + 1, i])) > 0.0) if two: a = float(d[i, i]) b = (float(d[i, i + 1]) if abs(float(d[i, i + 1])) > 0.0 else float(d[i + 1, i])) c = float(d[i + 1, i + 1]) det = a * c - b * b tr = a + c if det < 0.0: neg += 1 elif tr < 0.0: neg += 2 i += 2 else: if float(d[i, i]) < 0.0: neg += 1 i += 1 return neg # ------------------------------------ the lumped pair and the whitened form def lump_pair(A): """Delta = the POSITIVE off-diagonal part, L_Delta = diag(Delta 1) - Delta, A_B = A + L_Delta (T136). DIRECTION: L_Delta >= 0, so A_B >= A.""" dg = np.diag(A).copy() off = A - np.diag(dg) Dl = np.where(off > 0.0, off, 0.0) P_row = Dl.sum(axis=1) LD = np.diag(P_row) - Dl return sym(A + LD) def jacobi_whiten(A, A_B): """With Lam = diag(A_B): E = Lam^{-1/2} A Lam^{-1/2} (counting measure). Lam is THE diagonal multiplier of items (2)/(5): the Jacobi whitening is exactly the conjugation the Liouville transform undoes.""" Lam = np.diag(A_B).copy() if not (float(np.min(Lam)) > 0.0): return None sq = 1.0 / np.sqrt(Lam) return dict(E=sym(A * np.outer(sq, sq)), Lam=Lam, sqinv=sq) # ------------------------------------- the exact Dirichlet pair (KMS 1953) def dirichlet_mu(m): """THE EXACT DIRICHLET EIGENVALUES mu_k = 4 sin^2(pi k / (2(m+1))), k = 1..m, of L_0 = tridiag(-1, 2, -1) -- THEOREM (Kac-Murdock-Szego 1953): the model Toeplitz-minus-Hankel section, symbol 2 - 2 cos th.""" kk = np.arange(1, m + 1, dtype=float) return 4.0 * np.sin(0.5 * math.pi * kk / (m + 1.0)) ** 2 def sine_basis(m): """THE ORTHONORMAL DIRICHLET (sine) BASIS, ||s_k||_inf <= sqrt(2/(m+1)). Rows are the modes.""" jj = np.arange(m) kk = np.arange(1, m + 1) return math.sqrt(2.0 / (m + 1.0)) * np.sin( math.pi * np.outer(kk, jj + 1.0) / (m + 1.0)) def lap_apply(psi): """L_0 psi with L_0 = tridiag(-1, 2, -1); applied, never formed.""" out = 2.0 * psi out[:-1] -= psi[1:] out[1:] -= psi[:-1] return out def l1_ceiling(psi, m, mu, a=None): """THE CERTIFIED l1 CEILING, item (3): the coefficient identity mu_k^p a_k = , the coefficientwise bound for p = 1, 2, the summed exact-mu ceiling, and the m-free closed form 2 sqrt(nu) + 1 with nu = (m+1)^{3/2} ||L_0 psi||_1 / (2 sqrt 2). DIRECTION: every entry is an UPPER bound on |a_k|.""" psi = np.asarray(psi, dtype=float) nrm = float(np.linalg.norm(psi)) if not (nrm > 0.0): return None psi = psi / nrm L1v = lap_apply(psi.copy()) L2v = lap_apply(L1v.copy()) n1 = float(np.sum(np.abs(L1v))) n2 = float(np.sum(np.abs(L2v))) sup_s = math.sqrt(2.0 / (m + 1.0)) b1 = np.minimum(1.0, sup_s * n1 / mu) b2 = np.minimum(1.0, sup_s * n2 / (mu * mu)) bnd = np.minimum(b1, b2) nu = (m + 1.0) ** 1.5 * n1 / (2.0 * math.sqrt(2.0)) kk = np.arange(1, m + 1, dtype=float) ceil_nu = float(np.sum(np.minimum(1.0, nu / (kk * kk)))) out = dict(nu=nu, L0_l1=n1, ceil_mu=float(np.sum(bnd)), ceil_nu=ceil_nu, ceil_closed=2.0 * math.sqrt(max(nu, 0.0)) + 1.0, bnd=bnd, sup2=m * float(np.max(np.abs(psi))) ** 2) if a is not None: a = np.asarray(a, dtype=float) out["l1_true"] = float(np.sum(np.abs(a))) out["viol_coef"] = float(np.max(np.abs(a) - bnd)) return out def block_split(w, theta=THETA_BLK): """B = { k : lam_k <= theta lam_hat } -- the PREREGISTERED T147 rule.""" m = w.shape[0] lam_hat = float(w[0]) nb = int(np.count_nonzero(w <= theta * lam_hat)) return max(1, min(nb, m - 1)) # ------------------------------------- the model ladder of item (5) def model_section(h, c=MODEL_C): """The model Toeplitz-minus-Hankel section from the short symbol c, through the SAME odd_toeplitz code path as the arithmetic form.""" M = 2 * h cc = np.zeros(M) n = min(len(c), M) cc[:n] = np.asarray(c, dtype=float)[:n] return sym(odd_toeplitz(cc, M)) def model_weight(m, kind): """The two weight classes of the discriminator: 'smooth' has ONE oscillation (TV(log Lam) m-independent, the weighted-Szego setting); 'rough' oscillates at the LATTICE scale (TV ~ m) at matched kap_Lam.""" x = np.arange(m, dtype=float) / max(m - 1.0, 1.0) if kind == "smooth": return 1.0 + WEIGHT_AMP * np.cos(math.pi * x) if kind == "rough": phi = 0.5 * (math.sqrt(5.0) - 1.0) return 1.0 + WEIGHT_AMP * np.cos( 2.0 * math.pi * phi * np.arange(m, dtype=float)) raise ValueError(kind) def tv_log(Lam): return float(np.sum(np.abs(np.diff(np.log(np.asarray(Lam, dtype=float)))))) def model_run(h, kind): """One rung of the discriminator ladder: reweight the model section by the declared class, take the bottom mode, read nu and kap_Lam.""" A = model_section(h) Lam = model_weight(h, kind) sq = 1.0 / np.sqrt(Lam) E = sym(A * np.outer(sq, sq)) try: wv, Vv = eigh(E, subset_by_index=[0, 0]) except (LinAlgError, ValueError): return None if not (float(wv[0]) > 0.0): return None mu = dirichlet_mu(h) lc = l1_ceiling(Vv[:, 0], h, mu) return dict(m=h, nu=lc["nu"], kap=float(np.max(Lam)) / float(np.min(Lam)), tv=tv_log(Lam)) # ------------------------------------------------------------------ battery def build_windows(): cand = [] for k in range(2, min(K_SCAN, len(UU_ALL) - 2)): g = UU_ALL[k + 1] - UU_ALL[k] if g <= 0.0: continue D = 0.5 * g / NU_MAIN M = even_window(UU_ALL[k], D) h = M // 2 if h < H_MIN or h > H_CAP: continue cand.append((k, D, M, h)) if not cand: return [] if len(cand) > N_INST: pick = [cand[round(j * (len(cand) - 1) / (N_INST - 1))] for j in range(N_INST)] else: pick = cand seen, out = set(), [] for row in pick: if row[0] in seen: continue seen.add(row[0]) out.append(row) return out def build_instance(k, D, M, h): """One window, end to end: the odd section, the lumped pair, the whitened form E with its full spectrum, the Green matrix R, the factorisation scalars of item (1), the bottom-block projector of item (2), the l1 ceilings of items (3)/(5), and the inertia ladder of (4).""" al = 0.5 * M * D c, _ = lag_vector_fast(al, M, atoms_in(al)) A = sym(odd_toeplitz(c, M)) A_B = lump_pair(A) jw = jacobi_whiten(A, A_B) if jw is None: return None E = jw["E"] m = E.shape[0] try: w, V = eigh(E) except (LinAlgError, ValueError): return None lam_hat = float(w[0]) if not (lam_hat > 0.0): return None lam_lo = cert_lam_min_pos(E) if not (np.isfinite(lam_lo) and lam_lo > 0.0): return None fac = safe_cho(E) if fac is None: return None R = sym(cho_solve(fac, np.eye(m), check_finite=False)) EV = E @ R den = np.sum(R * R, axis=0) # ||R e_j||^2 num = np.sum(R * EV, axis=0) # (Re_j)^T E (Re_j) rres = np.linalg.norm(EV - np.eye(m), axis=0) if not bool(np.all(den > 0.0)): return None fl_q = chol_floor(gersh(E), m) lam_up = float(np.min(num / den)) + fl_q # Rayleigh-Ritz upper bd res_f = float(np.linalg.norm(rres)) # ---- item (1): the factorisation scalars, true and certified fro2 = float(np.sum(R * R)) fro = math.sqrt(max(fro2, 1.0e-300)) fro_lo = max(fro - res_f / lam_lo, 1.0e-300) fro_up = fro + res_f / lam_lo col_true = np.sqrt(den) col_cert = col_true + rres / lam_lo cmax = float(np.max(col_true)) cmax_up = float(np.max(col_cert)) Sw = lam_up * fro Sw_up = lam_up * fro_up Qs = m * cmax * cmax / fro2 Qs_up = m * cmax_up * cmax_up / (fro_lo * fro_lo) gam_true = math.sqrt(m) * lam_up * cmax gam_id = math.sqrt(Qs) * Sw gam_fac = math.sqrt(Qs_up) * Sw_up # ---- item (2): the bottom-block projector nb = block_split(w) VB = np.ascontiguousarray(V[:, :nb]) PB_diag = np.sum(VB * VB, axis=1) Q_B = m * float(np.max(PB_diag)) trace_err = abs(float(np.sum(PB_diag)) - nb) / max(nb, 1) # ---- items (3)/(5): the l1 ceiling on psi and on phi_hat mu = dirichlet_mu(m) S = sine_basis(m) psi = V[:, 0].copy() lc = l1_ceiling(psi, m, mu, a=S @ psi) # the Liouville transform, per bottom-block mode kap_L = float(np.max(jw["Lam"])) / max(float(np.min(jw["Lam"])), 1.0e-300) sup_psi = m * np.max(np.abs(VB), axis=0) ** 2 PH = jw["sqinv"][:, None] * VB ph_nrm = np.linalg.norm(PH, axis=0) PH = PH / np.where(ph_nrm > 0.0, ph_nrm, 1.0)[None, :] sup_phi = m * np.max(np.abs(PH), axis=0) ** 2 AH = S @ PH l1_phi = np.sum(np.abs(AH), axis=0) ceil_phi = np.empty(nb) viol_phi = -float("inf") nu_L = -float("inf") for i in range(nb): lci = l1_ceiling(PH[:, i], m, mu, a=AH[:, i]) ceil_phi[i] = lci["ceil_mu"] viol_phi = max(viol_phi, lci["viol_coef"]) nu_L = max(nu_L, lci["nu"]) # ---- item (4): the inertia ladder N_cnt, N_dir, taus = [], [], [] for rho in RHO_LADDER: tau = rho * lam_lo n_i = inertia_neg(E - tau * np.eye(m)) if n_i < 0: return None N_cnt.append(int(n_i)) N_dir.append(int(np.count_nonzero(w < tau))) taus.append(float(tau)) Nv = np.maximum.accumulate(np.array(N_cnt, dtype=float)) tv_arr = np.array(taus, dtype=float) s2 = Nv[0] / (lam_lo * lam_lo) s2_mut = 0.0 # bottom layer DROPPED for i in range(len(tv_arr) - 1): step = max(Nv[i + 1] - Nv[i], 0.0) / (tv_arr[i] * tv_arr[i]) s2 += step s2_mut += step tail = max(m - Nv[-1], 0.0) / (tv_arr[-1] * tv_arr[-1]) s2 += tail s2_mut += tail Sw_cnt = lam_up * math.sqrt(max(s2, 0.0)) Sw_mut = lam_up * math.sqrt(max(s2_mut, 0.0)) return dict( n=NN_ALL[k], m=m, D=D, lam_hat=lam_hat, lam_lo=lam_lo, lam_up=lam_up, R=R, w=w, VB=VB, kap_L=kap_L, Lam=jw["Lam"], Sw=Sw, Sw_up=Sw_up, Sw_cnt=Sw_cnt, Sw_mut=Sw_mut, Qs=Qs, Qs_up=Qs_up, gam_true=gam_true, gam_id=gam_id, gam_fac=gam_fac, nb=nb, Q_B=Q_B, trace_err=trace_err, N_cnt=N_cnt, N_dir=N_dir, nu=lc["nu"], ceil_mu=lc["ceil_mu"], ceil_nu=lc["ceil_nu"], ceil_closed=lc["ceil_closed"], l1_true=lc["l1_true"], viol_coef=lc["viol_coef"], sup2=lc["sup2"], sup_psi=sup_psi, sup_phi=sup_phi, l1_phi=l1_phi, ceil_phi=ceil_phi, viol_phi=viol_phi, nu_L=nu_L, tv=tv_log(jw["Lam"])) def run(): reset() t0 = time.time() rng = np.random.default_rng(5482026) print("=" * 72) print("v548 PRIME.GREEN.SZEGO.IDENT.01 -- Green/Szego identities " "(T147/T148)") print("=" * 72) print("\nS0 -- firewall, frame-A windows, preregistered bars") check("S0.AST: no Riemann-zero / zetazero loader in this module", ast_zero_firewall(__file__)) INST = [] for (k, D, M, h) in build_windows(): row = build_instance(k, D, M, h) if row is not None: INST.append(row) h_max = max(t["m"] for t in INST) if INST else 0 d_lo = min(t["D"] for t in INST) if INST else float("nan") d_hi = max(t["D"] for t in INST) if INST else float("nan") check(f"S0.INST: {len(INST)} frame-A windows built end to end (whitened " f"form positive definite, Green matrix, full spectrum and inertia " f"ladder all completed); every inverted / factorised / diagonalised " f"matrix <= {H_CAP} (max m = {h_max}); the surface spans " f"D = {d_lo:.3e} .. {d_hi:.3e}", len(INST) >= 6 and h_max <= H_CAP) for t in INST: print(f" n={t['n']:>7d} D={t['D']:.4e} m={t['m']:>4d} " f"Sw={t['Sw']:.4f} Qs={t['Qs']:.4f} |B|={t['nb']} " f"Q_B/|B|={t['Q_B'] / t['nb']:.4f} kapL={t['kap_L']:.3f}") # random PD forms for the form-independent item (1) RAND = [] for _ in range(N_RAND): B = rng.standard_normal((RAND_M, RAND_M)) Ex = sym(B @ B.T) + 0.3 * np.eye(RAND_M) fac = safe_cho(Ex) Rx = sym(cho_solve(fac, np.eye(RAND_M), check_finite=False)) RAND.append(Rx) # ---------------------------------------------------------------- (1) print("\nS1 -- (1) the factorisation identity Gam = sqrt(Q*) x Sw " "(T147)") id_win = max(rel(t["gam_id"] - t["gam_true"], t["gam_true"]) for t in INST) id_rand = 0.0 for Rx in RAND: mR = Rx.shape[0] dnx = np.sum(Rx * Rx, axis=0) frx = float(np.sum(Rx * Rx)) g_true = math.sqrt(mR) * math.sqrt(float(np.max(dnx))) g_fact = math.sqrt(mR * float(np.max(dnx)) / frx) * math.sqrt(frx) id_rand = max(id_rand, abs(g_fact - g_true) / max(g_true, 1.0e-300)) check(f"S1.ID: Gam = sqrt(m) lam_up max_j ||R e_j|| == sqrt(Q_star) x Sw " f"with Sw = lam_up ||R||_F (purely spectral) and Q_star = " f"m max_j (R^2)_jj / tr(R^2) (purely geometric) -- EXACT on all " f"{len(INST)} windows (max rel {id_win:.2e}) and {N_RAND} random PD " f"forms (max rel {id_rand:.2e}, bar {TOL_ID:.0e}): the all-D " f"question splits into two named scalars and into nothing else", id_win < TOL_ID and id_rand < TOL_ID) dom_ok = all(t["gam_fac"] >= t["gam_true"] * (1.0 - TOL_DIR) for t in INST) sw_lo = min(t["Sw"] for t in INST) sw_hi = max(t["Sw"] for t in INST) qs_lo = min(t["Qs"] for t in INST) qs_hi = max(t["Qs"] for t in INST) check(f"S1.DOM: the CERTIFIED factorisation sqrt(Q_star_up) x Sw_up -- " f"column norms and Frobenius norm bracketed with the linear-solve " f"residual paid for -- dominates the true Gam on every window; the " f"two factors measure Sw = {sw_lo:.4f}..{sw_hi:.4f} and Q_star = " f"{qs_lo:.4f}..{qs_hi:.4f} here (finite list, no size claim beyond " f"it)", dom_ok) ctrl_id = min(rel(math.sqrt(1.01 * t["Qs"]) * t["Sw"] - t["gam_true"], t["gam_true"]) for t in INST) ctrl_col = float("inf") for Rx in RAND[:3]: mR = Rx.shape[0] dn0 = np.sum(Rx * Rx, axis=0) Rm = Rx.copy() Rm[:, int(np.argmax(dn0))] *= 1.02 # THE max Green column perturbed dnm = np.sum(Rm * Rm, axis=0) g_true = math.sqrt(mR) * math.sqrt(float(np.max(dn0))) g_mut = (math.sqrt(mR * float(np.max(dnm)) / float(np.sum(Rm * Rm))) * math.sqrt(float(np.sum(Rx * Rx)))) ctrl_col = min(ctrl_col, abs(g_mut - g_true) / max(g_true, 1.0e-300)) check(f"S1.CTRL: a 1% perturbation of Q_star breaks the identity on " f"every window (min rel {ctrl_id:.2e} > {BAR_CTRL:.0e}), and " f"perturbing THE largest Green column while keeping the old " f"Frobenius weight breaks the factorisation on every random form " f"(min rel {ctrl_col:.2e}) -- both factors are load-bearing, " f"neither is decorative", ctrl_id > BAR_CTRL and ctrl_col > BAR_CTRL) # ---------------------------------------------------------------- (2) print("\nS2 -- (2) the bottom-block equidistribution constant (T147)") tr_err = max(t["trace_err"] for t in INST) floor_ok = all(t["Q_B"] >= t["nb"] * (1.0 - TOL_DIR) for t in INST) check(f"S2.TRACE: sum_j (Pi_B)_jj == |B| EXACTLY on every window (max rel " f"{tr_err:.2e}, bar {TOL_ID:.0e}; |B| = " f"{min(t['nb'] for t in INST)}..{max(t['nb'] for t in INST)} at the " f"preregistered theta = {THETA_BLK:.0f} rule) -- the trace identity " f"of the spectral projector, hence Q_B = m max_j (Pi_B)_jj >= |B| " f"is a THEOREM (max >= mean), and it holds", tr_err < TOL_ID and floor_ok) qb_lo = min(t["Q_B"] / t["nb"] for t in INST) qb_hi = max(t["Q_B"] / t["nb"] for t in INST) band_ok = all(QB_BAND[0] - TOL_DIR <= t["Q_B"] / t["nb"] <= QB_BAND[1] for t in INST) check(f"S2.EQUI: the MEASURED equidistribution Q_B/|B| = " f"{qb_lo:.4f}..{qb_hi:.4f} lies in the preregistered band " f"[{QB_BAND[0]:.0f}, {QB_BAND[1]:.1f}] on all {len(INST)} windows, " f"against the Szego/Widom sharp reference Q_B <= {QB_REF:.0f}|B| " f"(Kac-Murdock-Szego 1953; Widom 1958; Basor-Ehrhardt 2009, CITED " f"as the mechanism's address) -- a measurement on a finite list, " f"typed as such; T148's honest negative stands beside it: the " f"symbol-level order-2 hypothesis is REFUTED (f(0) < 0), so the " f"mechanism enters nowhere as a theorem", band_ok) ctrl_loc = min(float(t["m"]) / (QB_BAND[1] * t["nb"]) for t in INST) ctrl_tr = float("inf") for t in INST[:4]: VBm = 1.01 * t["VB"] tr_m = abs(float(np.sum(VBm * VBm)) - t["nb"]) / t["nb"] ctrl_tr = min(ctrl_tr, tr_m) check(f"S2.CTRL: the localised alternative -- a rank-|B| COORDINATE " f"projector -- gives Q_B = m and overshoots the band by a factor " f">= {ctrl_loc:.1f} on every window (the naive Q_B ~ m reading is " f"loudly wrong), and scaling the block basis by 1% breaks the " f"trace identity (min rel {ctrl_tr:.2e} > {BAR_CTRL:.0e}) -- the " f"orthonormality is load-bearing", ctrl_loc > 1.0 + BAR_CTRL and ctrl_tr > BAR_CTRL) # ---------------------------------------------------------------- (3) print("\nS3 -- (3) the second-difference l1 ceiling (T148)") m_lic = 241 mu_lic = dirichlet_mu(m_lic) S_lic = sine_basis(m_lic) L0 = sym(2.0 * np.eye(m_lic) - np.eye(m_lic, k=1) - np.eye(m_lic, k=-1)) eig_err = rel(L0 @ S_lic.T - S_lic.T * mu_lic[None, :], S_lic.T) kk_lic = np.arange(1, m_lic + 1, dtype=float) mu_lb = 4.0 * kk_lic * kk_lic / (m_lic + 1.0) ** 2 check(f"S3.EIG: the two licences of the ceiling, verified before use " f"(m = {m_lic}): L_0 s_k = mu_k s_k with mu_k = " f"4 sin^2(pi k/(2(m+1))) EXACTLY (residual {eig_err:.2e}; THEOREM, " f"Kac-Murdock-Szego 1953) and mu_k >= 4k^2/(m+1)^2 from " f"sin t >= 2t/pi (smallest margin " f"{float(np.min(mu_lic - mu_lb)):.2e} >= 0) -- the second is what " f"turns the exact-mu ceiling into the m-free closed form", eig_err < TOL_ID and bool(np.all(mu_lic >= mu_lb - 1.0e-14))) viol_w = max(t["viol_coef"] for t in INST) viol_r = -float("inf") for _ in range(4): v = rng.standard_normal(m_lic) v /= float(np.linalg.norm(v)) lcv = l1_ceiling(v, m_lic, mu_lic, a=S_lic @ v) viol_r = max(viol_r, lcv["viol_coef"], lcv["l1_true"] - lcv["ceil_mu"], lcv["ceil_nu"] - lcv["ceil_closed"], lcv["sup2"] - 2.0 * lcv["l1_true"] ** 2) chain_w = max(max(t["l1_true"] - t["ceil_mu"], t["ceil_nu"] - t["ceil_closed"], t["sup2"] - 2.0 * t["l1_true"] ** 2) for t in INST) nu_lo = min(t["nu"] for t in INST) nu_hi = max(t["nu"] for t in INST) check(f"S3.COEF: |a_k| <= min(1, ||s_k||_inf ||L_0^p psi||_1 / mu_k^p) " f"for p = 1, 2 against the TRUE coefficients on the bottom mode of " f"every window (worst excess {viol_w:.2e} <= 0) and on random unit " f"vectors (worst {viol_r:.2e}); the chain ||a||_1 <= ceil_mu, " f"ceil_nu <= 2 sqrt(nu) + 1 and m ||psi||_inf^2 <= 2 ||a||_1^2 " f"holds everywhere (worst slack {chain_w:.2e} <= 0; nu = " f"{nu_lo:.1f}..{nu_hi:.1f} on this surface, its SIZE not claimed)", viol_w <= TOL_DIR and viol_r <= TOL_DIR and chain_w <= TOL_DIR) s0 = sine_basis(m_lic)[0].copy() lc0 = l1_ceiling(s0, m_lic, mu_lic, a=S_lic @ s0) check(f"S3.CAL: the Dirichlet calibration -- for the exact bottom mode " f"the Fourier l1 norm is 1 EXACTLY ({lc0['l1_true']:.12f}) and the " f"smoothness functional is nu = {lc0['nu']:.6f} against the exact " f"limit pi = {math.pi:.6f} at every m, so the whole m-dependence " f"of the ceiling is carried by nu ALONE (2 sqrt(pi) + 1 = " f"{2.0 * math.sqrt(math.pi) + 1.0:.4f})", abs(lc0["l1_true"] - 1.0) < 1.0e-10 and abs(lc0["nu"] - math.pi) < 0.05) ctrl_ceil = all(t["l1_true"] > BAR_CTRL * t["ceil_mu"] for t in INST) mu_shift = np.roll(mu_lic, 1) ctrl_mu = float("inf") for _ in range(3): v = rng.standard_normal(m_lic) v /= float(np.linalg.norm(v)) av = S_lic @ v L1v = lap_apply(v.copy()) ctrl_mu = min(ctrl_mu, rel(mu_shift * av - S_lic @ L1v, av)) check(f"S3.CTRL: the ceiling x {BAR_CTRL:.0e} fails against the true " f"l1 norm on every window, and mis-pairing the eigenvalues (mu " f"shifted by one index) breaks the coefficient identity mu_k a_k " f"= on every draw (min rel {ctrl_mu:.2e} > " f"{BAR_CTRL:.0e}) -- the exact eigenpair is load-bearing", ctrl_ceil and ctrl_mu > BAR_CTRL) # ---------------------------------------------------------------- (4) print("\nS4 -- (4) the layer-cake Sw certificate by LDL^T inertia " "(T148)") cnt_ok = all(t["N_cnt"] == t["N_dir"] for t in INST) n_rungs = len(RHO_LADDER) * len(INST) check(f"S4.INERTIA: the completed LDL^T inertia count at every rung of " f"the preregistered ladder tau_i = rho_i x lam_lo (rho = " f"{RHO_LADDER[0]:.1f}..{RHO_LADDER[-1]:.0f}, lam_lo a certified " f"positive floor by completed Cholesky) equals the direct spectral " f"count #{{lam_k < tau_i}} EXACTLY on all {n_rungs} (window, rung) " f"pairs -- Sylvester 1852 / Bunch-Kaufman 1977, a certificate and " f"never a sorted list", cnt_ok) sw_ok = all(t["Sw"] <= t["Sw_cnt"] * (1.0 + TOL_DIR) for t in INST) swc_lo = min(t["Sw_cnt"] for t in INST) swc_hi = max(t["Sw_cnt"] for t in INST) slack_hi = max(t["Sw_cnt"] / t["Sw"] for t in INST) check(f"S4.SW: the layer-cake bound sum_k lam_k^-2 <= N_1/lam_lo^2 + " f"sum_i (N_i+1 - N_i)/tau_i^2 + (m - N_L)/tau_L^2 certifies " f"Sw = lam_up ||R||_F <= {swc_lo:.4f}..{swc_hi:.4f} on every " f"window (true Sw = {sw_lo:.4f}..{sw_hi:.4f}, slack factor <= " f"{slack_hi:.3f}) -- the spectral factor of item (1) carries a " f"certificate on this finite list; NOTHING here says m-free " f"(that reading lives in the sandbox as a labelled trend)", sw_ok) ctrl_drop = all(t["Sw"] > t["Sw_mut"] * (1.0 + BAR_CTRL) for t in INST) ctrl_sc = all(t["Sw"] > BAR_CTRL * t["Sw_cnt"] for t in INST) check(f"S4.CTRL: DROPPING THE BOTTOM LAYER (the N_1/lam_lo^2 term) " f"breaks the bound on every window -- the bottom eigenvalue IS " f"the weight, the cake is not vacuous bookkeeping -- and the " f"bound x {BAR_CTRL:.0e} fails everywhere too", ctrl_drop and ctrl_sc) # ---------------------------------------------------------------- (5) print("\nS5 -- (5) the Liouville transform and the weight-class " "discriminator (T148)") stepA = -float("inf") stepB = -float("inf") stepC = -float("inf") viol_ph = -float("inf") slackA_hi = -float("inf") for t in INST: bA = t["kap_L"] * t["sup_phi"] stepA = max(stepA, float(np.max(t["sup_psi"] - bA))) slackA_hi = max(slackA_hi, float(np.max(bA / t["sup_psi"]))) stepB = max(stepB, float(np.max(t["sup_phi"] - 2.0 * t["l1_phi"] ** 2))) stepC = max(stepC, float(np.max(t["l1_phi"] - t["ceil_phi"]))) viol_ph = max(viol_ph, t["viol_phi"]) kap_lo = min(t["kap_L"] for t in INST) kap_hi = max(t["kap_L"] for t in INST) nul_hi = max(t["nu_L"] for t in INST) check(f"S5.CHAIN: the Liouville chain m||psi||_inf^2 <= kap_Lam " f"m||phi_hat||_inf^2 <= 2 kap_Lam ||a(phi_hat)||_1^2 <= 2 kap_Lam " f"ceil(phi_hat)^2 with phi = Lam^{{-1/2}} psi (the EXACT pencil " f"equivalence E psi = lam psi <=> A phi = lam Lam phi -- a change " f"of variables, not a perturbation; Davis-Kahan 1970 cited as the " f"route T148 computed to be vacuous and NOT used) holds stepwise " f"on every bottom-block mode of every window: worst step slacks " f"{stepA:.2e} / {stepB:.2e} / {stepC:.2e} <= 0, coefficient excess " f"{viol_ph:.2e}", stepA <= TOL_DIR and stepB <= TOL_DIR and stepC <= TOL_DIR and viol_ph <= TOL_DIR) check(f"S5.KAP: the price of the transform is the single A PRIORI " f"constant kap_Lam = max_j Lam_j / min_j Lam_j = " f"{kap_lo:.4f}..{kap_hi:.4f} -- a ratio of two diagonal entries " f"of the form, no eigenvector read to get it; the smoothness " f"functional of the transformed modes measures nu_L <= " f"{nul_hi:.1f} here, and a bound nu_L <= F(form) with F m-free is " f"THE open lifting input, explicitly NOT claimed", all(np.isfinite(t["kap_L"]) and t["kap_L"] >= 1.0 for t in INST)) # the weight-class discriminator on the model ladder mod_sym = np.array(MODEL_C) f0 = float(mod_sym[0] + 2.0 * (mod_sym[1] + mod_sym[2])) gam2 = -float(1.0 * 1.0 * mod_sym[1] + 4.0 * mod_sym[2]) SM, RG = [], [] for h in MODEL_SIZES: rs = model_run(h, "smooth") rr = model_run(h, "rough") if rs is None or rr is None: continue SM.append(rs) RG.append(rr) sm_ratio = max(r["nu"] for r in SM) / max(min(r["nu"] for r in SM), 1.0e-300) rg_ratio = RG[-1]["nu"] / max(RG[0]["nu"], 1.0e-300) over = RG[-1]["nu"] / max(max(r["nu"] for r in SM), 1.0e-300) kap_mis = max(abs(a["kap"] - b["kap"]) / max(a["kap"], 1.0e-300) for a, b in zip(SM, RG)) tv_split = RG[-1]["tv"] / max(SM[-1]["tv"], 1.0e-300) check(f"S5.MODEL: the model symbol has a GENUINE order-2 zero, verified " f"exactly (f(0) = {f0:.2e}, f''(0)/2 = {gam2:.12f}) -- the exact " f"hypothesis of the classical statement, so the ladder tests the " f"discriminator where the pure theorem holds (Kac-Murdock-Szego " f"1953; Widom 1958)", abs(f0) < 1.0e-12 and abs(gam2 - 1.0) < 1.0e-12 and len(SM) >= 4) check(f"S5.WCLASS: THE DISCRIMINATOR -- on the ladder m = " f"{MODEL_SIZES[0]}..{MODEL_SIZES[-1]} at MATCHED conditioning " f"(kap_Lam mismatch {kap_mis:.4f} <= {BAR_KAP_MATCH:.2f}): the " f"BOUNDED-VARIATION multiplier keeps nu FLAT (max/min " f"{sm_ratio:.3f} <= {BAR_SMOOTH_FLAT:.1f}) while the ROUGH " f"multiplier (TV(log Lam) larger by {tv_split:.1f} >= " f"{BAR_TV_SPLIT:.0f} at the top rung) grows by {rg_ratio:.1f} >= " f"{BAR_ROUGH_GROW:.0f} and ends {over:.1f} >= {BAR_ROUGH_OVER:.0f} " f"times above the BV class -- the rough class MUST be worse, and " f"it is: the operative hypothesis is the ROUGHNESS of the " f"multiplier, not its condition number", sm_ratio <= BAR_SMOOTH_FLAT and rg_ratio >= BAR_ROUGH_GROW and over >= BAR_ROUGH_OVER and kap_mis <= BAR_KAP_MATCH and tv_split >= BAR_TV_SPLIT) ctrl_lv = float("inf") for t in INST: bA = BAR_CTRL * t["kap_L"] * t["sup_phi"] ctrl_lv = min(ctrl_lv, float(np.min(t["sup_psi"] / bA))) check(f"S5.CTRL: scaling the first Liouville step by {BAR_CTRL:.0e} " f"breaks it on every bottom-block mode of every window (min " f"violation factor {ctrl_lv:.1f} > 1) -- provably so, since the " f"slack of that step is bounded by kap_Lam^2 <= " f"{kap_hi * kap_hi:.1f} (measured worst {slackA_hi:.2f}) -- the " f"chain is not vacuous slack", ctrl_lv > 1.0 + BAR_CTRL) # ---------------------------------------------------------------- fences print("\nS6 -- the fences, restated as a check") check("S6.FENCE: PER-INSTANCE identities, theorems with checked " "hypotheses and certified inequalities on SMALL windows only -- a " "FINITE LIST with an explicit maximum, nothing uniform in the zone " "index or in D, and NO statement for ALL D: the ONE open lifting " "input (nu_L <= F(form) m-free; equivalently bounded TV(log Lam) " "or weaker smoothness of the multiplier) stays OPEN, unclaimed and " "unapproached, exactly as T148 typed it; the symbol-level order-2 " "hypothesis is REFUTED (T148: f(0) < 0 on every surface window) " "and enters nowhere as a theorem; sig_tot is RETIRED AS A ROUTE " "and not re-opened; every T147/T148 exponent is a FIT and stays " "in the sandbox; Kac-Murdock-Szego 1953 / Widom 1958 / " "Basor-Ehrhardt 2009 / Bottcher-Silbermann (the mechanism's " "address, never an authority) / Sylvester 1852 / Bunch-Kaufman " "1977 / Euler 1735 / Rayleigh 1877 / Ritz 1909 / Cauchy-Schwarz / " "Davis-Kahan 1970 (cited, computed vacuous, NOT used) / Gershgorin " "1931 / Wilkinson 1968 / Higham 2002 named CLASSICAL; Weil 1952 " "CITED, never used as a criterion; zero-firewall AST-checked; NO " "marker upgrade of any pre-existing contract", True) elapsed = time.time() - t0 print(f"\nv548 runtime: {elapsed:.1f}s") print(f" (1) factorisation identity: max rel {max(id_win, id_rand):.1e};" f" Sw = {sw_lo:.4f}..{sw_hi:.4f}, Q* = {qs_lo:.4f}..{qs_hi:.4f}") print(f" (2) bottom block: trace exact to {tr_err:.1e}; Q_B/|B| = " f"{qb_lo:.4f}..{qb_hi:.4f} in [{QB_BAND[0]:.0f}, {QB_BAND[1]:.1f}]") print(f" (3) l1 ceiling: worst coefficient excess " f"{max(viol_w, viol_r):.1e}; Dirichlet nu = {lc0['nu']:.4f} -> pi") print(f" (4) Sw certificate: {swc_lo:.4f}..{swc_hi:.4f} " f"(slack <= {slack_hi:.3f}); inertia == direct count on " f"{n_rungs} rungs") print(f" (5) Liouville: kap_Lam = {kap_lo:.3f}..{kap_hi:.3f}; " f"weight classes {sm_ratio:.2f} (BV, flat) vs {rg_ratio:.1f} " f"(rough, grows) at matched kap") return summary("PRIME.GREEN.SZEGO.IDENT.01 Green/Szego identities") if __name__ == "__main__": raise SystemExit(run())