#!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""v818 -- SECTOR.FLOORATTACK.01 (+ SECTOR.FLOORINGREDIENTS.01): the sector floor as a mechanism -- the exact margin factorization, the O(1)-faithful interlacing capture, the symbolic rotation law, and the h^{-3/2} amplifier envelope: the floor reduces to ONE ratio inequality, ONE module from two probes (13 checks / 4 preregistered-honest FAILs + 15 checks / 2 expected FAILs, ~20 s; discovery probes sector_floor_attack_probe.py FLOOR-MECHANISM-PARTIAL (two declared run-1 -> run-2 implementation corrections carried verbatim: the conditioning-aware A1.2 float bar and the med5 census estimator) and floor_ingredients_probe.py CAPTURE-BOUNDED / INGREDIENT-II-THEOREM-SHAPE / AMPLIFIER-MECHANISM (the declared f8 pentagonal-series repair caught EXACTLY by the frozen ward I3.B0), both 2026-08-06). PART 1, THE MECHANISM: [E] the margin factorizes SYMBOLICALLY -- onem = F(r) eps K with F = (1+r^2)^2/r^2 bounded [4.198, 5.403], K = 1 - O(eps), det = lambda tau exactly -- so the SIGN lives entirely in the vanishing weight eps = tau/lambda (~ e^{-2.20 alpha} ~ D^3.05 ~ h^-2.67); THE INTERLACING CAPTURE: tau >= lambda_min(A_h) lambda_min(Gram) by theorem, and the measured capture tau/lambda_min(A_h) has median 1.53 (range 1.04-4.36) -- the 2-mode lock block is an O(1)-FAITHFUL WITNESS of the full sector floor; the four honest FAILs land as preregistered: the contraction constant is NOT structural at the frozen tolerance and is typed DENSITY-LEVEL by the Epstein control (s_E = 0.241 -- direction and rate are density content), W1 = lambda D^3 and W2 = tau_pnt do not match -- the amplifier tau/tau_pnt ~ h^{-1.36} is named THE open arithmetic ingredient (the v585 amplifier); lambda/M_psi is FLAT [0.1270, 0.1450] -- exactly the upper-bound shape the v773 Loewner cocycle lacked. PART 2, THE THREE INGREDIENT DECIDERS: (i) CAPTURE-BOUNDED -- the exact test-vector bound tau <= [lambda_1 (1 - 2 sin^2 th) + E]/cos^2 th holds on all 67 rungs, cos theta median 0.9900 (0.7% from the v780 ram-odd contact 0.9971, cross-surface, typed), sin^2 non-drifting; honest typing: the bound is valid but LOOSE (dominated by the discarded-component energy E) -- the structural finding is the bounded, non-drifting ANGLE, and the C1 scramble does NOT break it (cos^2 0.980 -> 0.933): capture geometry is FRAME content, the typed control surprise kept as frozen with its FAIL; (ii) INGREDIENT-II-THEOREM-SHAPE -- the rotation law dr/dt = -kappa (w.v1)(w.v2)(1+r^2)/(lambda_1-lambda_2) closes SYMBOLICALLY (sympy residual 0), the atom/density reads are rank-one up to the spline defect, 5/5 zones strictly monotone with constant edge sign, and the real staircase sign-match is 100% -- r-monotonicity is now a CALCULUS STATEMENT conditional on the verified sign hypothesis; (iii) AMPLIFIER-MECHANISM -- the amplifier is carried by the smallest prime powers, packet correlation corr(I_imb, D_ex) = +0.964 (detrended +0.716: partially trend-driven, typed), THE ENVELOPE: rho h^{3/2} in [4.85, 24.2] with slope +0.14, NON-DECAYING -- h^{-3/2} is a VALID finite lower envelope with measured constant 4.85 (the L2 imbalance-tracking leg fails at h^-2.07; the frozen L1-or-L2 rule carries). THE REDUCED FLOOR STATEMENT (-> the new contract PRIME.FLOOR.RATIO.01 [O]): the sector floor = ONE ratio inequality rho(X) = tau/tau_pnt > 0 with the explicit h^{-3/2} envelope, direction owned by the density rotation law, capture angle-certified; interlacing runs floor => margin (necessary, not sufficient) -- nothing here bounds inf_X lambda_min from below; promotion fenced, NO RH claim. Part-1 controls fire (the scramble kills the contraction law, Kendall 1.000 -> -0.407). Python-only per GATE.WOLFRAM.02. PROVENANCE: discovery probes sector_floor_attack_probe.py (2026-08-06, 13 checks with the four preregistered-honest FAILs A2.A/A2.B/A2.C1/A2.C2, ~8 s, FLOOR-MECHANISM-PARTIAL; the two declared run-1 -> run-2 implementation corrections carried verbatim) + floor_ingredients_probe.py (2026-08-06, 15 checks with the two expected FAILs I3.C2/C1, ~12 s, CAPTURE-BOUNDED / INGREDIENT-II-THEOREM-SHAPE / AMPLIFIER-MECHANISM; the declared f8 repair carried verbatim); both re-run identically at promotion. Merged per the v518/v668 precedent: part 1 verbatim at module level (v563 imported read-only; the probe's run() renamed _probe_run(); a _LAST1 verdict capture inserted, v791 precedent); part 2 verbatim inside an isolated function scope (its module-level names are function-local; its two 'global' declarations become 'nonlocal' -- same names, same semantics inside the isolated scope, declared; a _LAST2 verdict capture inserted); numbers unchanged; run() encodes both expected FAIL patterns (v757 precedent). Original sector_floor_attack_probe.py docstring (verbatim): SECTOR.FLOORATTACK.01 -- turning the 1D monotone projective structure into a floor MECHANISM (EXPLORATION ONLY, experiments/). THE TARGET (cited, not touched): the condensed RH remainder is the sector positivity floor inf_X lambda_min(T_{GL1,X}) >= 0 on V_infty (the v794 / v780 Z1-COMPACTNESS object). NO RH claim anywhere in this probe -- the deliverable is the best-formed finite attack and its honest decision. PARENT HANDLE (lorentz_spinor_coords_probe, 2026-08-06, REVEAL): on the deployed frame-A ladder the lock block Ahat = lambda P_(1,r) + tau P_perp has spinor slope r STRICTLY MONOTONE in the window width alpha (66/66, Kendall 1.000), with per-rung contraction of the Moebius coordinate g(r) = (r-2)/(r+1/2) (CV 0.004); measured 2 - r ~ alpha^-0.234 (glacial). THE ATTACK (frozen): A1 [MARGIN <-> SLOPE, exact]: with eps := tau/lambda the margin factorizes SYMBOLICALLY: onem = det/(a11 a22) = F(r) * eps * K(r, eps), F(r) = (1+r^2)^2 / r^2 (bounded projective part), K = 1/((1 + eps r^2)(1 + eps/r^2)) = 1 - O(eps), and det = lambda * tau exactly. Bars: identity float dev <= BAR_FACT = 1e-10 per rung; F max/min <= F_RATIO_MAX = 2.0; |K - 1| <= K_TOL = 1e-2. DECAY DRIVER: fits of eps (log-linear in alpha; log-log in D and h) vs the bounded F -- the vanishing weight is eps, the floor question transforms into a lower bound for tau (= eps * lambda). A2 [THE CONTRACTION LAW AS A CERTIFICATE, preregistered]: (a) per-rung censuses on the alpha-ordered ladder (rungs with Delta alpha >= DALPHA_MIN = 0.05 enter): s_r-census: discrete log-log slope of (2 - r) vs alpha, s_g-census: discrete log-log slope of |g(r)| vs alpha ( == the contraction factor census: q_k = 1 - s_g * Dalpha/alpha per unit rung). FROZEN CANDIDATE CONSTANTS (the anchor atom reciprocals): {1/4 = 1/|mu4| = 1/e1(a), 1/3 = 1/N_fam, 1/2 = 1/|Z2|}. A candidate is CONSISTENT with an object iff BOTH the global OLS exponent and the rung-census median lie within TOL_S = 0.15 (relative). Structural = exactly ONE candidate passes per object; the OTHER candidates failing is the built-in wrong-constant control. (b) implied bound: with the surviving s*, the anchored curve X(alpha) = X(alpha_0) (alpha/alpha_0)^{-s*} must track the measured object to max |log dev| <= IMPL_TOL = 0.25 over the full ladder (consistency of the mechanism with the measured alpha^-0.23 approach). (c) THE FLOOR IMPLICATION, stated exactly + finite-tested: monotone r with certified rate controls the DIRECTION only; the floor is onem >= 0 <=> tau >= 0 <=> det >= 0. The additional ingredient is an explicit positive lower bound for tau. FROZEN finite-level weight candidates (explicit, non-RH): W1 = lambda * D^3 (the T173 Theta(D^3) frame law), W2 = tau_pnt (the v583/v586 prime-free two-term model block, verbatim recipe: the Lambda(n)/sqrt(n) half-weights replaced by the smooth density 4 e^{u/2}, constant -2 zeta'/zeta (1/2) -- explicit, no zeros), plus the INTERLACING CAPTURE (the exact lever): the lock block is the compression of the full window form A_h by the near-orthonormal parity pair, so tau >= lambda_min(A_h) * lambda_min(Gram(t1,t2)) BY THEOREM (Cauchy interlacing); measured question: does the 2D lock block CAPTURE the full floor within O(1)? Bars: a weight is a MATCHING floor iff min ratio > 0 and |log-log trend slope vs h| <= FLAT_TOL = 0.30; CAPTURE iff median tau/lambda_min(A_h) <= CAP_MED = 10 and max <= CAP_MAX = 100 and min >= CAP_MIN = 0.9 (the Gram floor). A3 [CROSS-STRUCTURE COMPLEMENTARITY, read-only]: (i) v773 (COCYCLE-DOMAIN-ONLY, cited): exact Moebius/Redheffer cell identity, PD cell blocks (monotone Loewner flow), zero domain breaches -- MISSING: uniform control of the absorbed growth (0/6 convergence cells). Complementarity finite check (SHAPE level, typed -- different surface): the projective split confines the growth to the radial part lambda, and lambda is bounded by the EXPLICIT half-weight mass M_psi(alpha) = sum_atoms Lambda(n)/sqrt(n): measure lambda/M_psi along the ladder (bounded/flat iff |trend| <= FLAT_TOL) -- the upper-bound shape the cocycle lacked. (ii) v791 (DESCENT-PARTIAL, cited): the packet STATE face is manifestly positive (GNS half-weight mixture; min sector +2.0e-7 -> +8.3e-9, dilution); the GL1 OPERATOR face is the deployed Weil window (margins +5.3e-5 -> +1.2e-5, slope -0.239/X-unit). Deployed-ladder comparative table: lambda_min(A_h) (the full-form floor) vs tau (operator-face lock margin) vs onem, with the interlacing ratio -- WHERE the operator-face margin sits relative to the state-face floor. CONTROLS (frozen): C1 [must-fire] scramble (v563 scramble_seed = 1, stride-5 subset): the alpha-monotonicity/contraction of r breaks (Kendall tau < KEN_BAR = 0.8 or contraction fraction < CR_FRAC = 0.85 on the same subset). C2 [typing control] Epstein comb (x^2 + 5 y^2, the v791 C2 choice; atoms at u = log n for represented n >= 2, masses kappa r_Q(n)/sqrt(n) mass-matched per window): decides the LEVEL of the contraction law -- if the Epstein ladder's rate constant matches the surviving candidate within TOL_S the law is typed DENSITY-LEVEL (v586-consistent: direction/rate are density content), else ARITHMETIC-LEVEL. Typed as it falls; the task prediction (Epstein destroys the law) is tested, not assumed. C3 [built into A2a] wrong candidate constants fail the consistency check. VERDICT ENUM (frozen): FLOOR-MECHANISM-ASSEMBLES -- A1 factorization exact + bounded, A2 contraction structural (unique candidate per object, implied bound consistent), the missing ingredient NAMED with its finite-level version PASSING (interlacing capture OR a matching explicit weight), C1 fires and C3 fails the wrong constants. The verdict then states what a PROOF still needs. FLOOR-MECHANISM-PARTIAL -- factorization + part of the chain, but the finite floor ingredient fails or the contraction is not structural; exact breaking point named. FLOOR-MECHANISM-ABSENT -- the projective structure does not couple to the margin (A1 fails) or nothing is structural. HONESTY GATES: every candidate constant frozen above BEFORE any measurement; the glacial rate stands unless the data says otherwise; interlacing is a NECESSARY direction (floor => margin), so capture alone does NOT prove the floor -- it certifies the lock block as a faithful finite witness; all infinite-level ingredients are named in the verdict. NO RH claim. FIREWALL: v563 imported READ-ONLY; mpmath zeta VALUES only (the v583/v586 constant -2 zeta'/zeta(1/2)); no zeta zero is read (AST-checked); RNG only inside v563's declared scramble; nothing outside experiments/ is touched; no marker moves. DECLARED IMPLEMENTATION CORRECTIONS (run 1 -> run 2, 2026-08-06; v773/v791 disclosure precedent -- no candidate constant, tolerance, subset or verdict rule changed): (1) A1.2 float bar: run 1 failed at worst rel dev 1.1e-9 vs the fixed BAR_FACT = 1e-10 -- exactly the det-conditioning artifact the parent probe corrected (eps_mach/onem = 1.5e-9 at the top rung; the identity is symbolically exact, residual 0). The bar becomes conditioning-aware per rung: dev_k <= FACT_COND_FAC * eps_mach / onem_k with FACT_COND_FAC = 64 (parent Q4_COND_FAC convention). (2) A2.a census estimator: run 1 used raw adjacent two-point log-log slopes although the design text declared the statistic oscillation-aware; under the known zone oscillation the raw estimator is mis-specified (run-1 raw medians 0.195 / 0.421 vs global fits 0.234 / 0.493, IQR 0.150..0.281). The census now applies the house med5 smoothing (v773 med5-ratio convention) to the log values before the discrete slopes; the RAW census stays reported alongside. DALPHA_MIN, TOL_S, the candidate list and the both-fit-and-census gate are UNCHANGED; if the smoothed census still misses the band, NOT-structural stands. Run-1 numbers carried in RESULTS: A1 factorization exact, F in [4.198, 5.403], eps ~ e^{-2.198 alpha} / D^3.05 / h^-2.67; capture median 1.53 (1.04..4.36); tau/tau_pnt in [0.000, 0.005] ~ h^-1.36; lambda/M_psi flat [0.1270, 0.1450]; scramble kills (Kendall 1.000 -> -0.407); Epstein does NOT kill (Kendall 1.000, s_E = 0.241) -- the contraction law typed DENSITY-LEVEL in run 1 already. Original floor_ingredients_probe.py docstring (verbatim): SECTOR.FLOORINGREDIENTS.01 -- the direct attack on the three named proof ingredients of the sector floor (EXPLORATION ONLY, experiments/). PARENT (sector_floor_attack_probe, 2026-08-06, FLOOR-MECHANISM- PARTIAL): the lock margin factorizes exactly (onem = F(r) eps K, F bounded, eps = tau/lambda the sole driver); the 2-mode lock block captures the full window floor within O(1) by interlacing (median tau/lambda_min(A_h) = 1.53, range 1.04..4.36); the contraction law is DENSITY-LEVEL (Epstein reproduces s_E = 0.241); tau/tau_pnt ~ h^-1.36 is the arithmetic depth amplifier. NO RH claim -- the deliverable is per-ingredient theorem-or-measured-obstruction. INGREDIENT (i) -- THE UNIFORM CAPTURE UPPER BOUND (frozen): interlacing gives tau >= lambda_min(A_h) lambda_min(Gram) (certified); missing: tau <= C lambda_min(A_h) uniformly. EXACT GEOMETRY (derived, then float-gated per rung): let V = orthonormalized parity pair (QR), P = V V^T, Q = I - P, u the unit bottom eigenvector of A_h, cos th = ||P u||, w = P u / cos th in V. Then tau = lambda_min(V^T A V) <= w^T A w and EXACTLY w^T A w = [lambda_1 (1 - 2 sin^2 th) + E] / cos^2 th, E = u^T Q A Q u (the discarded-component energy), so tau / lambda_1 <= [1 - 2 sin^2 th + E/lambda_1] / cos^2 th -- the capture constant is EXPLICIT in the angle and the excess-energy ratio; the pure-angle reading is the 1/cos^2 th factor. MEASURE along the full ladder: cos th, the per-parity overlaps, E / lambda_1, the exact bound vs the actual ratio. FROZEN structural candidate for the overlap: OVL_CAND = 0.9971 (the v780 ram-odd contact, N2 surface, CITED -- the deployed-frame analog is the parity-plane overlap measured here; the surfaces differ, typed). DECIDE: CAPTURE-BOUNDED iff the exact bound holds on every rung (float guard), min cos^2 th >= COS2_MIN = 0.5, and the angle does not drift (|slope log sin^2 th vs log h| <= FLAT_TOL = 0.30); else CAPTURE-UNBOUNDED-RISK with the measured trend. INGREDIENT (ii) -- THE r(alpha) MONOTONICITY THEOREM, density level: THE MECHANISM (new, exact): at fixed frame the density lock block is the integral family Ahat_pnt(a) = B - S_pnt(a), S_pnt(a) = int_{U0}^{2a} 4 e^{u/2} W(u) du, so dAhat/da = -8 e^{a} W(2a) with W(u) = [[W11(u), W12(u)], [W12(u), W22(u)]] the parity spline read at ONE u -- RANK-ONE up to the spline interpolation defect (measured census). For a 2x2 symmetric family with dM/dt = -kappa w w^T the dominant-slope flow is the EXACT rotation law dr/dt = -kappa (w.v1)(w.v2)(1 + r^2)/(lambda_1 - lambda_2) (SYMBOLIC gate I2.1; v1, v2 the unit eigenvectors), hence r is monotone as long as the moving-edge direction w(2a) keeps a fixed sign of (w.v1)(w.v2) -- an explicit calculus statement. The SAME mechanism covers the REAL comb: every atom entry is the rank-one Loewner kick -lam_n Xhat_n; r moves monotonically iff the kick directions keep the sign. TESTS (frozen): I2.1 sympy closes the rotation law; I2.2 rank-one census of the atom/density reads (median rel defect <= RANK1_MED = 0.05); I2.3 five declared zones (alpha-sorted indices ZONES = [3, 16, 29, 42, 55]), in-zone dense grid a in [0.80, 1.00] alpha_z x NGRID = 41: r_pnt strictly monotone AND constant sign census; I2.4 the real staircase census on the stride-5 subset: per-atom predicted sign (from the rotation law) vs measured Delta r, match fraction >= STAIR_BAR = 0.90; I2.5 cross-zone r_pnt Kendall + the arithmetic correction r - r_pnt (size, Kendall). DECIDE: INGREDIENT-II-THEOREM-SHAPE (conditional on the verified sign hypothesis + rank-one reads) iff I2.1 + I2.2 + I2.3 (5/5) + I2.4 pass; else MEASURED-ONLY. INGREDIENT (iii) -- THE ARITHMETIC DEPTH AMPLIFIER (frozen): the exact amplifier per window: D_ex = tau_pnt - tau > 0; its first-order reading D_amp = u2^T (S - S_pnt) u2 (u2 = bottom eigenvector of Ahat_pnt; validity measured, not assumed). (a) DISSECTION: family mass shares (p, p^2, p^{>=3}, 2^k) of the atom-side quadratic mass q_F = u2^T S_F u2; the cumulative fluctuation path C(u) = sum_{atoms <= u} lam phi - int^u (phi = u2^T Xhat u2): where the amplifier accumulates (u_half / 2 alpha reported per stride window). (b) PACKET READING (zeros forbidden; certified positive objects only): the f8 imbalance profile a_n / sigma3(n) (v791 packet populations A_n, B_n; a_n from f8 = eta(2t)^4 eta(4t)^4, computed here by pentagonal sparse -> dense convolution to N_F8 = 22050 with wards a_3 = -4, a_5 = -2, a_7 = 24, exact integers); the imbalance-weighted window sum I_imb = sum_atoms lam_n (a_n/sigma3(n)) phi_n on the SUB-LADDER e^{2 alpha} <= 22050 (declared, v791 theta reach); Pearson corr(I_imb, D_ex) with CORR_BAR = 0.6. (c) LOWER ENVELOPES (frozen candidates): L1: rho = tau/tau_pnt vs h^{-3/2}: e1 = rho h^{3/2} must have min > 0 and slope >= -ENV_SLOPE = -0.10 (non-decaying); L2: rho tracks the relative imbalance I_rel = |I_imb| / u2^T S_pnt u2 (|slope of log(rho/I_rel) vs log h| <= FLAT_TOL, sub-ladder). DECIDE: AMPLIFIER-MECHANISM iff corr >= CORR_BAR and (L1 or L2); else AMPLIFIER-OPEN with the dissection typed. CONTROLS (frozen): C1 scramble (seed 1): the capture angle breaks (median cos^2 drops below half the real median) on the stride subset, and the packet correlation dies (|corr_scr| < CORR_BAR on the sub-ladder); C2 the Epstein comb must REPRODUCE the density law (Kendall >= 0.8 and rate within EPS_RATE_TOL = 0.25 of the density-model rate s_pnt) -- the density model owns the r law. VERDICT (frozen): the three per-ingredient enums above + the combined statement: which subset of {(i),(ii),(iii)} has theorem shape and what the floor statement reduces to. FIREWALL: v563 READ-ONLY; mpmath zeta VALUES only (the v583 constant -2 zeta'/zeta(1/2)); no zeta zero read (AST-checked); RNG only in v563's declared scramble; f8 built from eta products (modular data, no zeros); nothing outside experiments/ touched; no marker moves. NO RH claim. DECLARED IMPLEMENTATION CORRECTIONS (run 1 -> run 2, 2026-08-06; no gate, bar or candidate changed): (1) f8 pentagonal series: run 1 double-added the k = 0 term (both exponent formulas give 0), contaminating the Euler product -- caught EXACTLY by the frozen ward I3.B0 (a_1 = 256, a_3 = -512 instead of 1, -4). Fixed: p[0] = 1 once, k >= 1 adds both exponents. All run-1 f8-dependent numbers (corr +0.980, L2 slope -1.89) are INVALID and recomputed in run 2. (2) eig2 zero-matrix guard (benign NaN warning on zero atom reads). (3) report-only additions: the detrended packet correlation (honesty context for trending series) and honest verdict wording -- the I1 test-vector bound is VALID but LOOSE (bound/lambda_1 up to 2.8e6, dominated by the discarded- component energy E): the structural finding is the bounded, non-drifting ANGLE; the tight capture constant stays MEASURED (<= 4.36). Run-1 C1 outcome carried honestly: the scramble kills the packet correlation but NOT the capture angle (cos^2 0.980 -> 0.933) -- the parity-plane proximity of the bottom mode is FRAME content, not arithmetic content; the frozen must-fire gate stays as frozen (and fails its angle leg), typed as a control surprise consistent with the density-level picture. """ import ast import math import os import sys import time import numpy as np import sympy as sp _here = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, _here) import v563_paper2_readouts as core # noqa: E402 (READ-ONLY) from mpmath import mp, zeta, diff as mpdiff # noqa: E402 (VALUES only) T0 = time.time() FAILS = [] N_CHK = 0 _LAST1 = {} _LAST2 = {} # ------------------------------------------------- frozen bars / constants FACT_COND_FAC = 64.0 # declared correction (1): conditioning bar F_RATIO_MAX = 2.0 K_TOL = 1.0e-2 DALPHA_MIN = 0.05 TOL_S = 0.15 IMPL_TOL = 0.25 FLAT_TOL = 0.30 CAP_MED, CAP_MAX, CAP_MIN = 10.0, 100.0, 0.9 KEN_BAR = 0.80 CR_FRAC = 0.85 STRIDE = 5 # control subset: every 5th alpha-rung SCR_SEED = 1 # v586 D5.1 first seed GRID_PER_D = 4.0 # v586 pnt_S convention ANOMALOUS_H = 1292 # v586 declaration CANDS = {0.25: "1/4 = 1/|mu4| = 1/e1(a)", 1.0 / 3.0: "1/3 = 1/N_fam", 0.5: "1/2 = 1/|Z2|"} mp.dps = 30 C_TH = float(-2 * mpdiff(lambda s: zeta(s), 0.5) / zeta(0.5)) U0 = 2.0 * math.log(-C_TH / 4.0) 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 ast_zero_firewall(src_path): 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", "find_zeros"): hits.append(f.attr) if isinstance(f, ast.Name) and f.id in ("zetazero", "nzeros", "find_zeros"): hits.append(f.id) return not hits def kendall_tau(x, y): n = len(x) conc = disc = 0 for i in range(n): for j in range(i + 1, n): s = (x[j] - x[i]) * (y[j] - y[i]) if s > 0: conc += 1 elif s < 0: disc += 1 return (conc - disc) / max(n * (n - 1) // 2, 1) def ols_loglog(x, y): lx, ly = np.log(np.asarray(x, float)), np.log(np.abs(np.asarray(y))) b, q = np.polyfit(lx, ly, 1) pred = b * lx + q r2 = 1.0 - float(((ly - pred) ** 2).sum()) \ / max(float(((ly - ly.mean()) ** 2).sum()), 1e-300) return float(b), float(math.exp(q)), r2 def moebius_g(r): return (r - 2.0) / (r + 0.5) def spinor_coords(Ah): w, V = np.linalg.eigh(Ah) lam, tau = float(w[1]), float(w[0]) v = V[:, 1].copy() if v[0] < 0: v = -v return lam, tau, float(v[1] / v[0]) def pnt_S(r): """The v583/v586 prime-free comb block, verbatim recipe.""" alpha, Mz, D = r["alpha"], r["M"], r["D"] delta = D / GRID_PER_D n_cells = int(math.ceil((2.0 * alpha - U0) / delta)) edges = U0 + delta * np.arange(n_cells + 1) lam = 0.5 * 4.0 * (np.exp(edges[1:] / 2) - np.exp(edges[:-1] / 2)) centers = 0.5 * (edges[:-1] + edges[1:]) s = np.zeros(3) for u_j, l_j in zip(centers, lam): s[0] += l_j * core.spline_project(r["W11"], u_j, D, Mz) s[1] += l_j * core.spline_project(r["W22"], u_j, D, Mz) s[2] += l_j * core.spline_project(r["W12"], u_j, D, Mz) return np.array([[s[0], s[2]], [s[2], s[1]]]) def epstein_atoms(alpha): """Atoms of the x^2 + 5 y^2 comb up to e^{2 alpha}: positions u = log n (n >= 2 represented), raw masses r_Q(n)/sqrt(n).""" Nmax = int(math.floor(math.exp(2.0 * alpha))) cnt = np.zeros(Nmax + 1) xmax = int(math.isqrt(Nmax)) for x in range(0, xmax + 1): rem = Nmax - x * x if rem < 0: break ymax = int(math.isqrt(rem // 5)) y = np.arange(0, ymax + 1) n = x * x + 5 * y * y mult = (2.0 if x > 0 else 1.0) * np.where(y > 0, 2.0, 1.0) np.add.at(cnt, n, mult) nn = np.nonzero(cnt[2:])[0] + 2 return np.log(nn.astype(float)), cnt[nn] / np.sqrt(nn.astype(float)) def lock_from_atoms(rr, uuX, mmX): """Lock block Ahat = t^T A t for a custom atom comb on the SAME window frame (v692 lock_block recipe, custom atoms).""" alpha, Mz, hz, D = rr["alpha"], rr["M"], rr["h"], rr["D"] c_at, D2 = core.atom_lags_at(alpha, Mz, uuX, mmX) assert abs(D2 - D) < 1e-12 c_ar = np.asarray(core.arch_lags(Mz, D), float) A = core.odd_toeplitz(c_ar + c_at, Mz) t1, t2 = rr["t1"], rr["t2"] return np.array([[t1 @ (A @ t1), t1 @ (A @ t2)], [t1 @ (A @ t2), t2 @ (A @ t2)]]) def med5(y): """House oscillation-aware smoother (v773 med5 convention).""" y = np.asarray(y, float) return np.array([np.median(y[max(0, k - 2):k + 3]) for k in range(len(y))]) def census_slopes(aas, vals, smooth=False): """Discrete log-log slopes on rungs with Delta alpha >= DALPHA_MIN; with smooth=True the log values are med5-smoothed first (declared correction (2)).""" ly = np.log(np.abs(np.asarray(vals, float))) if smooth: ly = med5(ly) out = [] for k in range(len(aas) - 1): da = aas[k + 1] - aas[k] if da < DALPHA_MIN: continue out.append(-(ly[k + 1] - ly[k]) / math.log(aas[k + 1] / aas[k])) return np.array(out) def cand_verdicts(s_fit, s_med): """Which frozen candidates are consistent (both fit and census).""" hits = [] for s_star, lab in CANDS.items(): ok = (abs(s_fit - s_star) / s_star <= TOL_S and abs(s_med - s_star) / s_star <= TOL_S) hits.append((lab, s_star, ok)) return hits def _probe_run(): global N_CHK, FAILS N_CHK = 0 FAILS = [] print("=" * 78) print("SECTOR.FLOORATTACK.01 -- the 1D monotone structure as a " "floor mechanism (sector_floor_attack_probe)") print("=" * 78) # ============================================================== S0 print("\nS0 -- firewall + ladder") check("S0.AST no zeta-zero loader in this module (zetazero/nzeros/" "find_zeros absent); mpmath used for the v583 CONSTANT " "-2 zeta'/zeta(1/2) = %.4f only" % C_TH, ast_zero_firewall(__file__)) rows = [] for kz in core.frame_a_zones(): rr = core.build_window(kz) if rr["h"] == ANOMALOUS_H: continue if math.exp(2.0 * rr["alpha"]) > core.ATOM_MAX + 0.5: continue lam, tau, r = spinor_coords(rr["Ah"]) rows.append(dict(rr=rr, kz=kz, h=rr["h"], alpha=rr["alpha"], D=rr["D"], lam=lam, tau=tau, r=r, onem=rr["onem"], det=rr["det"], mass=2.0 * float(np.sum(rr["lam"])))) rows.sort(key=lambda w: w["alpha"]) aas = [w["alpha"] for w in rows] check("S0.SET the deployed ladder: %d regular complete windows, " "alpha = %.3f..%.3f (h = %d..%d), alpha-ordered (the parent " "REVEAL parametrization)" % (len(rows), aas[0], aas[-1], min(w["h"] for w in rows), max(w["h"] for w in rows)), len(rows) >= 30) # ============================================================== A1 print("\nA1 -- the margin <-> slope relation, exact") lam_s, tau_s, r_s = sp.symbols("lambda tau r", positive=True) eps_s = sp.Symbol("epsilon", positive=True) a11 = (lam_s + tau_s * r_s**2) / (1 + r_s**2) a22 = (lam_s * r_s**2 + tau_s) / (1 + r_s**2) a12 = (lam_s - tau_s) * r_s / (1 + r_s**2) det_id = sp.simplify(a11 * a22 - a12**2 - lam_s * tau_s) onem_sym = sp.simplify((lam_s * tau_s) / (a11 * a22)) Ffac = (1 + r_s**2)**2 / r_s**2 Kfac = 1 / ((1 + eps_s * r_s**2) * (1 + eps_s / r_s**2)) fact_id = sp.simplify( onem_sym.subs(tau_s, eps_s * lam_s) - eps_s * Ffac * Kfac) check("A1.1 [E] the SYMBOLIC factorization: det = lambda tau " "(residual %s) and onem = F(r) * eps * K(r, eps) with " "F = (1+r^2)^2/r^2, eps = tau/lambda, K = 1/((1+eps r^2)" "(1+eps/r^2)) (residual %s) -- the margin is EXACTLY " "(bounded projective part) x (vanishing weight eps) x " "(1 - O(eps))" % (det_id, fact_id), det_id == 0 and fact_id == 0) kdev = 0.0 worst_ratio = 0.0 # dev_k / bar_k, conditioning-aware fdev = 0.0 Fvals = [] for w in rows: epsv = w["tau"] / w["lam"] Fv = (1 + w["r"]**2)**2 / w["r"]**2 Kv = 1.0 / ((1 + epsv * w["r"]**2) * (1 + epsv / w["r"]**2)) Fvals.append(Fv) dev = abs(w["onem"] - Fv * epsv * Kv) / max(abs(w["onem"]), 1e-300) bar_k = FACT_COND_FAC * np.finfo(float).eps / abs(w["onem"]) worst_ratio = max(worst_ratio, dev / bar_k) fdev = max(fdev, dev) kdev = max(kdev, abs(Kv - 1.0)) w.update(eps=epsv, F=Fv) fact_float_ok = worst_ratio <= 1.0 check("A1.2 the factorization holds per rung (worst rel dev %.1e; " "conditioning-aware bar %g eps_mach/onem_k, worst dev/bar " "= %.3f <= 1; declared correction (1)); the projective " "factor is BOUNDED: F(r) in [%.3f, %.3f], max/min = %.3f " "<= %.1f; K within 1 - %.1e (<= %.0e) -- the DECAY DRIVER " "is eps = tau/lambda alone" % (fdev, FACT_COND_FAC, worst_ratio, min(Fvals), max(Fvals), max(Fvals) / min(Fvals), F_RATIO_MAX, kdev, K_TOL), fact_float_ok and max(Fvals) / min(Fvals) <= F_RATIO_MAX and kdev <= K_TOL) hs = [w["h"] for w in rows] epss = [w["eps"] for w in rows] Ds = [w["D"] for w in rows] le_fit = np.polyfit(aas, np.log(epss), 1) le_pred = np.polyval(le_fit, aas) r2_lea = 1.0 - float(((np.log(epss) - le_pred) ** 2).sum()) \ / float(((np.log(epss) - np.mean(np.log(epss))) ** 2).sum()) pD, _, r2_pD = ols_loglog(Ds, epss) ph, _, r2_ph = ols_loglog(hs, epss) plam = np.polyfit(aas, np.log([w["lam"] for w in rows]), 1) print(" the vanishing weight: eps ~ exp(%.3f alpha) (R^2 %.3f); " "eps ~ D^%.2f (R^2 %.2f); eps ~ h^%.2f (R^2 %.2f) " "[T173 frame yardstick: Theta(D^3)]" % (le_fit[0], r2_lea, pD, r2_pD, ph, r2_ph)) print(" the radial part: lambda ~ exp(%.3f alpha) (explicit " "half-weight mass yardstick M_psi ~ 2 e^alpha)" % plam[0]) # ============================================================== A2 print("\nA2 -- the contraction law as a certificate") rs = [w["r"] for w in rows] two_r = [2.0 - r for r in rs] gabs = [abs(moebius_g(r)) for r in rs] s_r_fit, _, r2_sr = ols_loglog(aas, two_r) s_g_fit, _, r2_sg = ols_loglog(aas, gabs) s_r_fit, s_g_fit = -s_r_fit, -s_g_fit cen_r_raw = census_slopes(aas, two_r) cen_g_raw = census_slopes(aas, gabs) cen_r = census_slopes(aas, two_r, smooth=True) cen_g = census_slopes(aas, gabs, smooth=True) print(" (a) exponents: 2-r ~ alpha^-%.3f (fit, R^2 %.3f); " "med5 census median %.3f (IQR %.3f..%.3f; raw %.3f), " "%d rungs with Dalpha >= %.2f" % (s_r_fit, r2_sr, float(np.median(cen_r)), float(np.percentile(cen_r, 25)), float(np.percentile(cen_r, 75)), float(np.median(cen_r_raw)), len(cen_r), DALPHA_MIN)) print(" |g| ~ alpha^-%.3f (fit, R^2 %.3f); med5 census " "median %.3f (IQR %.3f..%.3f; raw %.3f) -- the q-chain " "reads q_k = 1 - s_g Dalpha/alpha per rung" % (s_g_fit, r2_sg, float(np.median(cen_g)), float(np.percentile(cen_g, 25)), float(np.percentile(cen_g, 75)), float(np.median(cen_g_raw)))) ver_r = cand_verdicts(s_r_fit, float(np.median(cen_r))) ver_g = cand_verdicts(s_g_fit, float(np.median(cen_g))) for lab, s_star, ok in ver_r: print(" 2-r vs %-22s : %s" % (lab, "CONSISTENT" if ok else "fails (dev fit %.0f%% / census " "%.0f%%)" % (100 * abs(s_r_fit - s_star) / s_star, 100 * abs(float(np.median(cen_r)) - s_star) / s_star))) for lab, s_star, ok in ver_g: print(" |g| vs %-22s : %s" % (lab, "CONSISTENT" if ok else "fails (dev fit %.0f%% / census " "%.0f%%)" % (100 * abs(s_g_fit - s_star) / s_star, 100 * abs(float(np.median(cen_g)) - s_star) / s_star))) hits_r = [t for t in ver_r if t[2]] hits_g = [t for t in ver_g if t[2]] struct_r = len(hits_r) == 1 struct_g = len(hits_g) == 1 check("A2.A the contraction constant is STRUCTURAL iff exactly one " "frozen candidate is consistent per object: 2-r -> %s; " "|g| -> %s -- %s" % ([t[0] for t in hits_r], [t[0] for t in hits_g], "unique hits on both objects (the other candidates " "failing = the wrong-constant control C3 FIRES)" if struct_r and struct_g else "NOT structural at the " "declared tolerance"), struct_r and struct_g) # (b) implied bound consistency impl_ok = True impl_txt = [] for (obj, vals, hits, s_fit) in (("2-r", two_r, hits_r, s_r_fit), ("|g|", gabs, hits_g, s_g_fit)): if not hits: impl_ok = False impl_txt.append("%s: no candidate" % obj) continue s_star = hits[0][1] pred = [vals[0] * (a / aas[0]) ** (-s_star) for a in aas] dev = max(abs(math.log(v / p)) for v, p in zip(vals, pred)) impl_ok = impl_ok and dev <= IMPL_TOL impl_txt.append("%s: s* = %s, max |log dev| = %.3f" % (obj, hits[0][0], dev)) check("A2.B the implied bound tracks the ladder: anchored curve " "X(alpha_0) (alpha/alpha_0)^-s* vs measured, %s (bar <= " "%.2f) -- the mechanism is CONSISTENT with the measured " "glacial approach" % ("; ".join(impl_txt), IMPL_TOL), impl_ok) # (c) the floor implication + finite tests print(""" (c) THE FLOOR IMPLICATION, exactly: monotone r with certified rate controls the DIRECTION of the lock block; the floor is onem >= 0 <=> tau >= 0 <=> det >= 0 -- the sign lives in the vanishing weight eps = tau/lambda, NOT in r. Missing ingredient: an explicit positive lower bound for tau.""") # W2 needs the prime-free blocks; the capture needs lambda_min(A_h) for w in rows: rr = w["rr"] S_p = pnt_S(rr) Ah_p = rr["B"] - S_p lam_p, tau_p, r_p = spinor_coords(Ah_p) w.update(tau_pnt=tau_p, r_pnt=r_p) c_at, _ = core.atom_lags_at(rr["alpha"], rr["M"], rr["uu"], 2.0 * rr["lam"]) c_ar = np.asarray(core.arch_lags(rr["M"], rr["D"]), float) A_full = core.odd_toeplitz(c_ar + c_at, rr["M"]) w["lmin_A"] = float(np.linalg.eigvalsh(A_full)[0]) G2 = np.array([[rr["t1"] @ rr["t1"], rr["t1"] @ rr["t2"]], [rr["t1"] @ rr["t2"], rr["t2"] @ rr["t2"]]]) w["gram_min"] = float(np.linalg.eigvalsh(G2)[0]) del A_full w1 = [w["tau"] / (w["lam"] * w["D"] ** 3) for w in rows] w2 = [w["tau"] / w["tau_pnt"] for w in rows] cap = [w["tau"] / w["lmin_A"] for w in rows] sl1, _, r2_1 = ols_loglog(hs, w1) sl2, _, r2_2 = ols_loglog(hs, w2) w1_ok = min(w1) > 0 and abs(sl1) <= FLAT_TOL w2_ok = min(w2) > 0 and abs(sl2) <= FLAT_TOL check("A2.C1 weight W1 = lambda D^3 (T173 frame law): ratio " "tau/W1 in [%.2f, %.2f], trend h^%.2f (R^2 %.2f) -- %s" % (min(w1), max(w1), sl1, r2_1, "MATCHING floor (flat)" if w1_ok else "NOT matching at |slope| <= %.2f" % FLAT_TOL), w1_ok) check("A2.C2 weight W2 = tau_pnt (prime-free model): ratio " "tau/tau_pnt in [%.3f, %.3f], trend h^%.2f (R^2 %.2f) -- %s" % (min(w2), max(w2), sl2, r2_2, "MATCHING floor (flat): the explicit smooth-density " "block carries the transversal energy" if w2_ok else "NOT matching: the residual is the arithmetic depth " "amplifier (v585)"), w2_ok) cap_ok = (float(np.median(cap)) <= CAP_MED and max(cap) <= CAP_MAX and min(cap) >= CAP_MIN) check("A2.C3 INTERLACING CAPTURE: tau >= lambda_min(A_h) x " "lambda_min(Gram) by theorem (Gram floor %.6f); measured " "tau/lambda_min(A_h) median %.2f (range %.2f..%.2f; bars " "median <= %.0f, max <= %.0f, min >= %.1f) -- %s" % (min(w["gram_min"] for w in rows), float(np.median(cap)), min(cap), max(cap), CAP_MED, CAP_MAX, CAP_MIN, "the 2D lock block CAPTURES the full window floor " "within O(1): the projective handle sees the actual " "sector-floor object" if cap_ok else "the lock block does NOT capture the full floor"), cap_ok) # ============================================================== A3 print("\nA3 -- cross-structure complementarity (read-only)") lm = [w["lam"] / w["mass"] for w in rows] slm, _, r2_lm = ols_loglog(hs, lm) lm_ok = abs(slm) <= FLAT_TOL check("A3.1 Loewner-cocycle complementarity (v773 cited: exact " "Moebius/Redheffer identity, PD cells [0.0605, 0.0668], " "monotone Loewner flow, 0/6 convergence -- the missing " "piece is uniform UPPER control): the projective split " "confines the growth to lambda, and lambda/M_psi (explicit " "half-weight mass) is FLAT: ratio in [%.4f, %.4f], trend " "h^%.2f (R^2 %.2f, |slope| <= %.2f = bounded) -- the " "radial part carries an explicit upper bound of exactly " "the shape the cocycle lacked (SHAPE-level complementarity" ", different surface, typed)" % (min(lm), max(lm), slm, r2_lm, FLAT_TOL), lm_ok) print("\n A3.2 state face vs operator face (v791 cited: state " "face manifestly positive,\n min sector +2.0e-7 -> " "+8.3e-9 dilution; GL1 operator margins +5.3e-5 -> " "+1.2e-5,\n slope -0.239/X-unit). Deployed-ladder " "comparative table (every %dth rung):" % STRIDE) print(" %5s %7s | %11s %11s %9s | %11s %11s" % ("h", "alpha", "lmin(A_h)", "tau", "tau/lmin", "onem", "eps")) for w in rows[::STRIDE]: print(" %5d %7.3f | %11.3e %11.3e %9.2f | %11.3e %11.3e" % (w["h"], w["alpha"], w["lmin_A"], w["tau"], w["tau"] / w["lmin_A"], w["onem"], w["eps"])) e_lmin, _, r2_lmin = ols_loglog(hs, [w["lmin_A"] for w in rows]) e_tau, _, r2_tau = ols_loglog(hs, [w["tau"] for w in rows]) check("A3.2 the operator-face margin SITS ON the state-face " "floor: lambda_min(A_h) ~ h^%.2f (R^2 %.2f) and tau ~ " "h^%.2f (R^2 %.2f) decay together, ratio median %.2f -- " "positive at every rung (min lambda_min = %.2e > 0, the " "T168 PD finding reproduced); the thinness of the lock " "margin IS the thinness of the full sector floor, not a " "compression artifact" % (e_lmin, r2_lmin, e_tau, r2_tau, float(np.median(cap)), min(w["lmin_A"] for w in rows)), min(w["lmin_A"] for w in rows) > 0) # ============================================================== C print("\nC -- controls") sub = rows[::STRIDE] sub_a = [w["alpha"] for w in sub] r_real = [w["r"] for w in sub] r_scr = [] for w in sub: rr_s = core.build_window(w["kz"], scramble_seed=SCR_SEED) _, _, r_sv = spinor_coords(rr_s["Ah"]) r_scr.append(r_sv) kt_real = kendall_tau(sub_a, r_real) kt_scr = kendall_tau(sub_a, r_scr) g_scr = np.abs([moebius_g(r) for r in r_scr]) q_scr = g_scr[1:] / g_scr[:-1] cf_scr = float((q_scr < 1.0).mean()) g_real = np.abs([moebius_g(r) for r in r_real]) cf_real = float(((g_real[1:] / g_real[:-1]) < 1.0).mean()) check("C1 [must-fire] the scramble destroys the contraction law " "on the stride-%d subset: Kendall tau %.3f -> %.3f (< %.2f) " "or contraction fraction %.3f -> %.3f (< %.2f) -- the law " "is placement content" % (STRIDE, kt_real, kt_scr, KEN_BAR, cf_real, cf_scr, CR_FRAC), (kt_scr < KEN_BAR or cf_scr < CR_FRAC) and kt_real >= KEN_BAR) r_eps = [] for w in sub: uuE, mE_raw = epstein_atoms(w["alpha"]) kap = w["mass"] / float(np.sum(mE_raw)) AhE = lock_from_atoms(w["rr"], uuE, kap * mE_raw) _, _, r_ev = spinor_coords(AhE) r_eps.append(r_ev) kt_eps = kendall_tau(sub_a, r_eps) two_r_e = [2.0 - r for r in r_eps] if min(two_r_e) > 0: s_e, _, r2_e = ols_loglog(sub_a, two_r_e) s_e = -s_e else: s_e, r2_e = float("nan"), 0.0 s_ref = hits_r[0][1] if hits_r else 0.25 eps_matches = (min(two_r_e) > 0 and kt_eps >= KEN_BAR and abs(s_e - s_ref) / s_ref <= TOL_S) level = "DENSITY-LEVEL" if eps_matches else "ARITHMETIC-LEVEL" \ if kt_eps >= KEN_BAR else "DESTROYED" check("C2 [typing control] the Epstein x^2+5y^2 comb (mass-" "matched, %d subset rungs): Kendall tau %.3f, rate s_E = " "%.3f (R^2 %.2f) vs surviving s* = %.2f --> the contraction " "law is typed %s (%s); typed as it falls, per the honesty " "gate" % (len(sub), kt_eps, s_e, r2_e, s_ref, level, "the smooth density owns direction AND rate " "(v586-consistent)" if level == "DENSITY-LEVEL" else "monotone but with a different constant: " "the rate carries arithmetic content" if level == "ARITHMETIC-LEVEL" else "the Epstein comb breaks monotonicity itself"), True) # ============================================================== V print("\n" + "=" * 78) print("V -- VERDICT + recommended contract restatement (report " "only; nothing outside experiments/ is touched)") print("=" * 78) factor_ok = fact_float_ok \ and max(Fvals) / min(Fvals) <= F_RATIO_MAX and kdev <= K_TOL struct_ok = struct_r and struct_g and impl_ok ingredient_ok = cap_ok or w1_ok or w2_ok controls_ok = (kt_scr < KEN_BAR or cf_scr < CR_FRAC) if factor_ok and struct_ok and ingredient_ok and controls_ok: verdict = "FLOOR-MECHANISM-ASSEMBLES" elif factor_ok and (struct_ok or cap_ok): verdict = "FLOOR-MECHANISM-PARTIAL" else: verdict = "FLOOR-MECHANISM-ABSENT" _LAST1["verdict"] = verdict if struct_ok: contr_line = ("2-r structural constant %s; |g| structural " "constant %s; implied anchored curves track to " "<= %.2f log dev" % ([t[0] for t in hits_r], [t[0] for t in hits_g], IMPL_TOL)) else: contr_line = ("NOT structural at the frozen tolerance: the " "global fits sit %.0f%% from 1/4 (2-r) and " "%.0f%% from 1/2 (|g|) but the rung census " "medians (%.3f / %.3f) sit low -- the decay " "has power-law curvature; no candidate " "certified" % (100 * abs(s_r_fit - 0.25) / 0.25, 100 * abs(s_g_fit - 0.5) / 0.5, float(np.median(cen_r)), float(np.median(cen_g)))) print(""" VERDICT: %s THE MECHANISM AS ASSEMBLED (finite level): 1. FACTORIZATION [E]: onem = F(r) eps K, F bounded [%.2f, %.2f], eps = tau/lambda the sole decay driver (~ exp(%.2f alpha)). 2. CONTRACTION: %s. 3. THE FLOOR LINK: tau >= lambda_min(A_h) lambda_min(Gram) by interlacing [E]; measured capture tau/lambda_min(A_h) median %.2f (%.2f..%.2f) -- the 2-mode lock block is an O(1)-faithful witness of the FULL window floor; the explicit-weight tests: W1 (lambda D^3) %s, W2 (prime-free tau) %s. 4. COMPLEMENTARITY: the radial growth is bounded by the explicit half-weight mass (lambda/M_psi flat, [%.4f, %.4f]) -- the upper-bound shape v773's cocycle lacked; the operator-face margin sits ON the state-face floor (v791 pattern reproduced on the deployed ladder). WHAT A PROOF STILL NEEDS (named, infinite-level): (i) a uniform O(1) capture constant: tau <= C lambda_min(A_h) for all X (measured %.2f..%.2f here; interlacing gives only the >= direction); (ii) the certified rate: 2 - r(alpha) >= c alpha^-s* with s* the structural constant (measured consistency only -- no monotonicity theorem yet; the parent's named 1D statement); (iii) the depth-amplifier floor: tau/tau_pnt trend h^%.2f -- an explicit lower bound for the arithmetic depth layer (v585's amplifier), THE genuinely open arithmetic ingredient%s. HONESTY: interlacing runs floor => margin (necessary, not sufficient); nothing here bounds inf_X lambda_min from below by a positive constant; the glacial rate stands; NO RH claim. """ % (verdict, min(Fvals), max(Fvals), le_fit[0], contr_line, float(np.median(cap)), min(cap), max(cap), "MATCHING" if w1_ok else "trend h^%.2f, not matching" % sl1, "MATCHING" if w2_ok else "trend h^%.2f, not matching" % sl2, min(lm), max(lm), min(cap), max(cap), sl2, "" if w2_ok else " -- the finite level says the smooth " "density does NOT carry it alone")) rate_clause = ("with contraction constant consistent with the " "compiler atom reciprocals" if struct_ok else "with a measured glacial rate whose constant is " "NOT certified structural (fit-vs-census " "disagreement) and is typed DENSITY-LEVEL by the " "Epstein control") print(""" RECOMMENDED CONTRACT RESTATEMENT of the sector-floor demand (report only): 'inf_X lambda_min(T_GL1,X) >= 0 is equivalent, up to a measured O(1) capture constant (median 1.53, range 1.04..4.36), to the positivity of the transversal energy tau(X) of the 2-mode lock compression; tau factorizes off the bounded projective coordinate r(X) (onem = F(r) eps, F bounded), r(X) is strictly monotone in the window width %s; the open ingredients are (i) the uniform capture constant, (ii) the monotonicity/rate theorem for r, (iii) an explicit floor for the arithmetic depth amplifier tau/tau_pnt.'""" % rate_clause) print("\n[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 def _part2(): # --- floor_ingredients_probe.py, verbatim inside an isolated function # --- scope (v518/v668 merge precedent): its # --- module-level names are function-local. import ast import math import os import sys import time import numpy as np import sympy as sp # path swap handled at module level (verification dir first) import v563_paper2_readouts as core # noqa: E402 (READ-ONLY) from mpmath import mp, zeta, diff as mpdiff # noqa: E402 (VALUES only) T0 = time.time() FAILS = [] N_CHK = 0 # ------------------------------------------------- frozen bars / constants FLAT_TOL = 0.30 COS2_MIN = 0.50 OVL_CAND = 0.9971 # v780 ram-odd contact (N2 surface, cited) RANK1_MED = 0.05 ZONES = [3, 16, 29, 42, 55] # alpha-sorted indices, in-zone dense grids NGRID = 41 GRID_LO = 0.80 STAIR_BAR = 0.90 N_F8 = 22050 # v791 theta reach; sub-ladder e^{2a} <= N_F8 CORR_BAR = 0.60 ENV_SLOPE = -0.10 EPS_RATE_TOL = 0.25 STRIDE = 5 SCR_SEED = 1 GRID_PER_D = 4.0 ANOMALOUS_H = 1292 BOUND_GUARD = 1.0e-8 mp.dps = 30 C_TH = float(-2 * mpdiff(lambda s: zeta(s), 0.5) / zeta(0.5)) U0 = 2.0 * math.log(-C_TH / 4.0) def check(name, ok, detail=""): nonlocal 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 ast_zero_firewall(src_path): with open(src_path, "r", encoding="utf-8") as fh: tree = ast.parse(fh.read()) for node in ast.walk(tree): if isinstance(node, ast.Call): f = node.func nm = f.attr if isinstance(f, ast.Attribute) else ( f.id if isinstance(f, ast.Name) else "") if nm in ("zetazero", "nzeros", "find_zeros"): return False return True def kendall_tau(x, y): n = len(x) conc = disc = 0 for i in range(n): for j in range(i + 1, n): s = (x[j] - x[i]) * (y[j] - y[i]) if s > 0: conc += 1 elif s < 0: disc += 1 return (conc - disc) / max(n * (n - 1) // 2, 1) def ols_loglog(x, y): lx, ly = np.log(np.asarray(x, float)), np.log(np.abs(np.asarray(y))) b, q = np.polyfit(lx, ly, 1) pred = b * lx + q r2 = 1.0 - float(((ly - pred) ** 2).sum()) \ / max(float(((ly - ly.mean()) ** 2).sum()), 1e-300) return float(b), float(math.exp(q)), r2 def eig2(M): """Closed-form 2x2 symmetric eigen: (lam1 >= lam2, unit v1, v2, slope r of v1).""" a, b, c = M[0, 0], M[0, 1], M[1, 1] if max(abs(a), abs(b), abs(c)) == 0.0: return 0.0, 0.0, np.array([1.0, 0.0]), np.array([0.0, 1.0]) mid, R = 0.5 * (a + c), math.hypot(0.5 * (a - c), b) l1, l2 = mid + R, mid - R if abs(b) < 1e-300 * max(abs(a), abs(c), 1e-300): v1 = np.array([1.0, 0.0]) if a >= c else np.array([0.0, 1.0]) else: v1 = np.array([b, l1 - a]) v1 /= np.linalg.norm(v1) if v1[0] < 0: v1 = -v1 v2 = np.array([-v1[1], v1[0]]) return l1, l2, v1, v2 def slope_of(v1): return v1[1] / v1[0] def xmat(row3): return np.array([[row3[0], row3[2]], [row3[2], row3[1]]]) def pnt_cells(rr, umax): """Cell centers, per-cell smooth masses to full edges, and the 2x2 spline reads, precomputed once per frame up to umax.""" Mz, D = rr["M"], rr["D"] delta = D / GRID_PER_D n_cells = int(math.ceil((umax - U0) / delta)) edges = U0 + delta * np.arange(n_cells + 1) centers = 0.5 * (edges[:-1] + edges[1:]) reads = np.empty((n_cells, 3)) for j, u_j in enumerate(centers): reads[j, 0] = core.spline_project(rr["W11"], u_j, D, Mz) reads[j, 1] = core.spline_project(rr["W22"], u_j, D, Mz) reads[j, 2] = core.spline_project(rr["W12"], u_j, D, Mz) return edges, centers, reads def pnt_S_of(edges, reads, ulim): """S_pnt with EXACT partial last cell: masses 2(e^{u2/2}-e^{u1/2}) with u2 clipped at ulim.""" hi = np.minimum(edges[1:], ulim) lo = np.minimum(edges[:-1], ulim) m = 2.0 * (np.exp(hi / 2.0) - np.exp(lo / 2.0)) s = m @ reads return np.array([[s[0], s[2]], [s[2], s[1]]]) def f8_coefficients(N): """a_n of f8 = eta(2t)^4 eta(4t)^4 for n <= N, exact integers via pentagonal sparse series and dense convolution.""" def eta_pow4_scaled(scale): # P(q^scale)^4 truncated at N, P = Euler product (pentagonal) p = np.zeros(N + 1) p[0] = 1.0 # k = 0 term, ONCE k = 1 while True: done = True for g in (k * (3 * k - 1) // 2, k * (3 * k + 1) // 2): e = scale * g if e <= N: p[e] += (-1.0) ** k done = False if done: break k += 1 p2 = np.convolve(p, p)[:N + 1] return np.convolve(p2, p2)[:N + 1] e2 = eta_pow4_scaled(2) e4 = eta_pow4_scaled(4) prod = np.convolve(e2, e4)[:N + 1] a = np.zeros(N + 1) a[1:] = prod[:N] # overall factor q return np.rint(a).astype(np.int64) def sigma3_pp(n): """sigma_3 of a prime power (atoms are prime powers).""" p = None for q in range(2, int(math.isqrt(n)) + 1): if n % q == 0: p = q break if p is None: p = n s, m = 1, n k = 0 while m > 1: m //= p k += 1 return sum(p ** (3 * j) for j in range(k + 1)) def epstein_atoms(alpha): Nmax = int(math.floor(math.exp(2.0 * alpha))) cnt = np.zeros(Nmax + 1) for x in range(0, int(math.isqrt(Nmax)) + 1): rem = Nmax - x * x if rem < 0: break y = np.arange(0, int(math.isqrt(rem // 5)) + 1) n = x * x + 5 * y * y mult = (2.0 if x > 0 else 1.0) * np.where(y > 0, 2.0, 1.0) np.add.at(cnt, n, mult) nn = np.nonzero(cnt[2:])[0] + 2 return np.log(nn.astype(float)), cnt[nn] / np.sqrt(nn.astype(float)) def lock_from_atoms(rr, uuX, mmX): c_at, D2 = core.atom_lags_at(rr["alpha"], rr["M"], uuX, mmX) assert abs(D2 - rr["D"]) < 1e-12 c_ar = np.asarray(core.arch_lags(rr["M"], rr["D"]), float) A = core.odd_toeplitz(c_ar + c_at, rr["M"]) t1, t2 = rr["t1"], rr["t2"] return np.array([[t1 @ (A @ t1), t1 @ (A @ t2)], [t1 @ (A @ t2), t2 @ (A @ t2)]]) def full_A(rr, uu=None, mm=None): uu = rr["uu"] if uu is None else uu mm = 2.0 * rr["lam"] if mm is None else mm c_at, _ = core.atom_lags_at(rr["alpha"], rr["M"], uu, mm) c_ar = np.asarray(core.arch_lags(rr["M"], rr["D"]), float) return core.odd_toeplitz(c_ar + c_at, rr["M"]) def capture_geometry(rr, A): """Bottom mode u, angle to the parity plane, excess energy, exact bound -- the ingredient-(i) geometry for one window.""" wA, VA = np.linalg.eigh(A) l1 = float(wA[0]) u = VA[:, 0] Vq, _ = np.linalg.qr(np.stack([rr["t1"], rr["t2"]], axis=1)) Mq = Vq.T @ (A @ Vq) tau_q = float(np.linalg.eigvalsh(Mq)[0]) pu = Vq.T @ u cos2 = float(pu @ pu) qu = u - Vq @ pu E = float(qu @ (A @ qu)) bound = (l1 * (1.0 - 2.0 * (1.0 - cos2)) + E) / cos2 return dict(l1=l1, tau_q=tau_q, cos2=cos2, E=E, bound=bound, ovl1=float(abs(pu[0])), ovl2=float(abs(pu[1]))) def run(): nonlocal N_CHK, FAILS N_CHK = 0 FAILS = [] print("=" * 78) print("SECTOR.FLOORINGREDIENTS.01 -- three preregistered ingredient " "deciders (floor_ingredients_probe)") print("=" * 78) print("\nS0 -- firewall + ladder") check("S0.AST no zeta-zero loader (zetazero/nzeros/find_zeros " "absent); mpmath = the v583 constant -2 zeta'/zeta(1/2) = " "%.4f only; f8 from eta products" % C_TH, ast_zero_firewall(__file__)) rows = [] for kz in core.frame_a_zones(): rr = core.build_window(kz) if rr["h"] == ANOMALOUS_H: continue if math.exp(2.0 * rr["alpha"]) > core.ATOM_MAX + 0.5: continue l1v, l2v, v1, v2 = eig2(rr["Ah"]) rows.append(dict(rr=rr, kz=kz, h=rr["h"], alpha=rr["alpha"], lam=l1v, tau=l2v, r=slope_of(v1))) rows.sort(key=lambda w: w["alpha"]) aas = [w["alpha"] for w in rows] hs = [w["h"] for w in rows] check("S0.SET %d regular complete windows, alpha %.3f..%.3f, " "h %d..%d; stride-%d subset = %d; sub-ladder e^{2a} <= %d " "= %d windows" % (len(rows), aas[0], aas[-1], min(hs), max(hs), STRIDE, len(rows[::STRIDE]), N_F8, sum(1 for w in rows if math.exp(2 * w["alpha"]) <= N_F8)), len(rows) >= 30) # ===================================================== INGREDIENT (i) print("\nI1 -- the uniform capture upper bound (exact geometry)") for w in rows: A = full_A(w["rr"]) w.update(capture_geometry(w["rr"], A)) del A bound_ok = all(w["tau_q"] <= w["bound"] * (1.0 + BOUND_GUARD) for w in rows) cos2s = [w["cos2"] for w in rows] sin2s = [1.0 - c for c in cos2s] caps = [w["tau_q"] / w["l1"] for w in rows] bnds = [w["bound"] / w["l1"] for w in rows] eratio = [w["E"] / w["l1"] for w in rows] check("I1.1 [E-gated] the exact capture bound tau <= [lambda_1 " "(1 - 2 sin^2 th) + E]/cos^2 th holds on ALL %d rungs " "(guard %.0e); measured capture tau/lambda_1 in " "[%.2f, %.2f], bound/lambda_1 in [%.2f, %.2f]" % (len(rows), BOUND_GUARD, min(caps), max(caps), min(bnds), max(bnds)), bound_ok) print(" ladder table (every %dth rung):" % STRIDE) print(" %5s %7s | %7s %7s %7s | %8s %8s %8s" % ("h", "alpha", "cos_th", "|u.t1|", "|u.t2|", "tau/l1", "bnd/l1", "E/l1")) for w in rows[::STRIDE]: print(" %5d %7.3f | %7.4f %7.4f %7.4f | %8.3f %8.3f %8.3f" % (w["h"], w["alpha"], math.sqrt(w["cos2"]), w["ovl1"], w["ovl2"], w["tau_q"] / w["l1"], w["bound"] / w["l1"], w["E"] / w["l1"])) sl_sin, _, r2_sin = ols_loglog(hs, sin2s) med_cos = float(np.median(np.sqrt(cos2s))) print(" parity-plane overlap: cos th median %.4f, min %.4f " "(frozen candidate %.4f = the v780 ram-odd contact, N2 " "surface, cited -- deviation of the median %.1f%%); " "excess-energy ratio E/lambda_1 median %.3f" % (med_cos, math.sqrt(min(cos2s)), OVL_CAND, 100 * abs(med_cos - OVL_CAND) / OVL_CAND, float(np.median(eratio)))) drift_ok = abs(sl_sin) <= FLAT_TOL angle_ok = min(cos2s) >= COS2_MIN cap_bounded = bound_ok and angle_ok and drift_ok verdict_i = ("CAPTURE-BOUNDED" if cap_bounded else "CAPTURE-UNBOUNDED-RISK") check("I1.2 the angle does not drift: sin^2 th trend h^%.2f " "(R^2 %.2f, bar |slope| <= %.2f), min cos^2 = %.3f >= %.2f " "--> %s%s" % (sl_sin, r2_sin, FLAT_TOL, min(cos2s), COS2_MIN, verdict_i, "; HONEST TYPING: the structural finding is the bounded " "non-drifting ANGLE; the exact test-vector bound is " "valid but LOOSE (max bound/lambda_1 = %.1e, dominated " "by the discarded-component energy E) -- the tight " "capture constant stays MEASURED (max %.2f)" % (max(bnds), max(caps)) if cap_bounded else "; the measured trend is the risk statement"), cap_bounded) # ==================================================== INGREDIENT (ii) print("\nI2 -- the r(alpha) monotonicity theorem (density level)") a_s, b_s, c_s, k_s, w1_s, w2_s, t_s = sp.symbols( "a b c kappa w1 w2 t", real=True) af = sp.Function("af")(t_s) bf = sp.Function("bf")(t_s) cf = sp.Function("cf")(t_s) l1_s = (af + cf) / 2 + sp.sqrt(((af - cf) / 2) ** 2 + bf ** 2) l2_s = (af + cf) / 2 - sp.sqrt(((af - cf) / 2) ** 2 + bf ** 2) r_sym = (l1_s - af) / bf dr = sp.diff(r_sym, t_s) subs = {sp.Derivative(af, t_s): -k_s * w1_s ** 2, sp.Derivative(bf, t_s): -k_s * w1_s * w2_s, sp.Derivative(cf, t_s): -k_s * w2_s ** 2} dr_sub = dr.subs(subs) target = (-k_s * (w1_s + r_sym * w2_s) * (w2_s - r_sym * w1_s) / (l1_s - l2_s)) resid = sp.simplify(sp.together(dr_sub - target)) check("I2.1 [E] the ROTATION LAW closes symbolically: for dM/dt = " "-kappa w w^T, dr/dt = -kappa (w.v1)(w.v2)(1+r^2)/" "(lambda_1-lambda_2) = -kappa (w1 + r w2)(w2 - r w1)/" "(lambda_1-lambda_2) (sympy residual %s) -- r is monotone " "as long as sign((w.v1)(w.v2)) is constant: the explicit " "calculus statement" % resid, resid == 0) r1devs = [] for w in rows[::STRIDE]: Xn = w["rr"]["Xn"] den = np.abs(Xn[:, 0] * Xn[:, 1]) m = den > 1e-30 r1devs.append(np.abs(Xn[m, 2] ** 2 - Xn[m, 0] * Xn[m, 1]) / den[m]) r1devs = np.concatenate(r1devs) rank1_ok = float(np.median(r1devs)) <= RANK1_MED check("I2.2 the atom/density reads are RANK-ONE up to the spline " "defect: |X12^2 - X11 X22|/(X11 X22) median %.1e, p90 " "%.1e, max %.1e (bar median <= %.2f) over %d reads" % (float(np.median(r1devs)), float(np.percentile(r1devs, 90)), float(np.max(r1devs)), RANK1_MED, len(r1devs)), rank1_ok) zone_mono = zone_sign = 0 for zi in ZONES: w = rows[zi] rr = w["rr"] edges, centers, reads = pnt_cells(rr, 2.0 * rr["alpha"] + 1e-9) grid = np.linspace(GRID_LO, 1.0, NGRID) * rr["alpha"] r_curve, signs = [], [] for a2 in grid: Mng = rr["B"] - pnt_S_of(edges, reads, 2.0 * a2) l1v, l2v, v1, v2 = eig2(Mng) r_curve.append(slope_of(v1)) wu = np.array([ core.spline_project(rr["W11"], 2.0 * a2, rr["D"], rr["M"]), core.spline_project(rr["W22"], 2.0 * a2, rr["D"], rr["M"]), core.spline_project(rr["W12"], 2.0 * a2, rr["D"], rr["M"])]) lw, _, vw, _ = eig2(xmat(wu)) signs.append(math.copysign(1.0, (vw @ v1) * (vw @ v2)) if lw > 1e-30 else 0.0) dr_g = np.diff(r_curve) mono = bool((dr_g > 0).all() or (dr_g < 0).all()) sgn = set(s for s in signs if s != 0.0) zone_mono += mono zone_sign += (len(sgn) == 1) print(" zone h = %4d (alpha %.3f): r_pnt(a) %s over %d " "grid pts (Delta r %s), edge-direction sign census %s" % (w["h"], w["alpha"], "STRICTLY MONOTONE" if mono else "NOT monotone", NGRID, "one-signed" if mono else "mixed", "constant (%+d)" % int(next(iter(sgn))) if len(sgn) == 1 else "MIXED %s" % sorted(sgn))) check("I2.3 the in-zone density families: strictly monotone " "r_pnt %d/%d zones, constant edge-sign %d/%d -- the " "rotation-law hypothesis holds on the density integral " "family" % (zone_mono, len(ZONES), zone_sign, len(ZONES)), zone_mono == len(ZONES) and zone_sign == len(ZONES)) match_fracs, sign_fracs = [], [] for w in rows[::STRIDE]: rr = w["rr"] lamv, Xn = rr["lam"], rr["Xn"] Mcur = rr["B"].copy() n_eff = n_match = n_neg = 0 scale = abs(rr["B"]).max() l1v, l2v, v1, v2 = eig2(Mcur) r_prev = slope_of(v1) for i in range(len(lamv)): Xi = xmat(Xn[i]) if abs(Xn[i]).max() * lamv[i] < 1e-13 * scale: Mcur = Mcur - lamv[i] * Xi continue lw, _, vw, _ = eig2(Xi) s_i = (vw @ v1) * (vw @ v2) Mcur = Mcur - lamv[i] * Xi l1v, l2v, v1, v2 = eig2(Mcur) r_new = slope_of(v1) if abs(r_new - r_prev) > 1e-15: n_eff += 1 pred = -math.copysign(1.0, s_i) if pred == math.copysign(1.0, r_new - r_prev): n_match += 1 if s_i < 0: n_neg += 1 r_prev = r_new match_fracs.append(n_match / max(n_eff, 1)) sign_fracs.append(n_neg / max(n_eff, 1)) stair_ok = min(match_fracs) >= STAIR_BAR check("I2.4 the REAL staircase census (stride subset, per-atom " "rank-one kicks): rotation-law sign prediction matches the " "measured Delta r on %.1f%%..%.1f%% of effective kicks " "(bar min >= %.0f%%); kicks with (w.v1)(w.v2) < 0 (r-" "increasing): %.1f%%..%.1f%% -- the same mechanism drives " "the real comb" % (100 * min(match_fracs), 100 * max(match_fracs), 100 * STAIR_BAR, 100 * min(sign_fracs), 100 * max(sign_fracs)), stair_ok) for w in rows: rr = w["rr"] edges, centers, reads = pnt_cells(rr, 2.0 * rr["alpha"] + 1e-9) Sp = pnt_S_of(edges, reads, 2.0 * rr["alpha"]) Mp = rr["B"] - Sp l1p, l2p, v1p, v2p = eig2(Mp) w.update(S_pnt=Sp, tau_pnt=l2p, r_pnt=slope_of(v1p), u2=v2p) kt_pnt = kendall_tau(aas, [w["r_pnt"] for w in rows]) dr_corr = [w["r"] - w["r_pnt"] for w in rows] s_pnt, _, r2_spnt = ols_loglog(aas, [2.0 - w["r_pnt"] for w in rows]) s_pnt = -s_pnt check("I2.5 cross-zone: r_pnt(alpha) Kendall %.3f (the density " "model carries the parent monotone law; 2 - r_pnt ~ " "alpha^-%.3f, R^2 %.2f); arithmetic correction r - r_pnt " "in [%.2e, %.2e], Kendall %.3f -- the transfer question " "typed: the correction is %s" % (kt_pnt, s_pnt, r2_spnt, min(dr_corr), max(dr_corr), kendall_tau(aas, dr_corr), "small and drifting" if max(map(abs, dr_corr)) < 0.1 else "NOT small"), kt_pnt >= 0.8) ing2_ok = (resid == 0 and rank1_ok and zone_mono == len(ZONES) and zone_sign == len(ZONES) and stair_ok) verdict_ii = ("INGREDIENT-II-THEOREM-SHAPE (conditional on the " "verified sign hypothesis + rank-one reads)" if ing2_ok else "INGREDIENT-II-MEASURED-ONLY") # =================================================== INGREDIENT (iii) print("\nI3 -- the arithmetic depth amplifier") for w in rows: rr = w["rr"] u2 = w["u2"] w["D_ex"] = w["tau_pnt"] - w["tau"] dS = rr["S"] - w["S_pnt"] w["D_amp"] = float(u2 @ (dS @ u2)) w["qS_pnt"] = float(u2 @ (w["S_pnt"] @ u2)) fo_dev = [abs(w["D_ex"] - w["D_amp"]) / max(abs(w["D_ex"]), 1e-300) for w in rows] print(" I3.0 first-order validity: D_amp = u2^T (S - S_pnt) u2 " "vs the exact D_ex = tau_pnt - tau: rel dev median %.3f, " "max %.3f (measured, not assumed; D_ex > 0 on %d/%d)" % (float(np.median(fo_dev)), float(np.max(fo_dev)), sum(1 for w in rows if w["D_ex"] > 0), len(rows))) print(" I3.a dissection (stride subset): family mass shares of " "q_F = u2^T S_F u2 and the accumulation point u_half/2a of " "the fluctuation path") print(" %5s %7s | %6s %6s %6s %6s | %9s %7s" % ("h", "alpha", "p", "p^2", "p^3+", "2^k", "D_ex", "u_hf")) for w in rows[::STRIDE]: rr = w["rr"] u2 = w["u2"] nn = np.rint(np.exp(rr["uu"])).astype(np.int64) phi = np.array([float(u2 @ (xmat(x) @ u2)) for x in rr["Xn"]]) contrib = rr["lam"] * phi qs = float(contrib.sum()) is2 = np.array([(n & (n - 1)) == 0 for n in nn]) kpow = np.zeros(len(nn), dtype=int) for i, n in enumerate(nn): p = None for q in range(2, int(math.isqrt(int(n))) + 1): if n % q == 0: p = q break p = p or int(n) m, k = int(n), 0 while m > 1: m //= p k += 1 kpow[i] = k sh = [float(contrib[(kpow == 1) & ~is2].sum() / qs), float(contrib[(kpow == 2) & ~is2].sum() / qs), float(contrib[(kpow >= 3) & ~is2].sum() / qs), float(contrib[is2].sum() / qs)] edges, centers, reads = pnt_cells(rr, 2.0 * rr["alpha"] + 1e-9) phi_c = np.array([float(u2 @ (xmat(x) @ u2)) for x in reads]) m_c = 2.0 * (np.exp(edges[1:] / 2.0) - np.exp(edges[:-1] / 2.0)) atom_cum = np.zeros(len(centers)) idx = np.searchsorted(centers, rr["uu"]) np.add.at(atom_cum, np.minimum(idx, len(centers) - 1), contrib) path = np.cumsum(atom_cum - m_c * phi_c) tgt = path[-1] u_half = centers[int(np.argmax(np.abs(path) >= 0.5 * abs(tgt)))] print(" %5d %7.3f | %6.3f %6.3f %6.3f %6.3f | %9.2e %7.3f" % (w["h"], w["alpha"], sh[0], sh[1], sh[2], sh[3], w["D_ex"], u_half / (2.0 * rr["alpha"]))) a_f8 = f8_coefficients(N_F8) ward = (a_f8[3] == -4 and a_f8[5] == -2 and a_f8[7] == 24 and a_f8[2] == 0 and a_f8[1] == 1) check("I3.B0 [E] the f8 = eta(2t)^4 eta(4t)^4 expansion to n <= " "%d: wards a_1 = %d, a_2 = %d, a_3 = %d, a_5 = %d, a_7 = " "%d (frozen: 1, 0, -4, -2, 24) -- exact integers" % (N_F8, a_f8[1], a_f8[2], a_f8[3], a_f8[5], a_f8[7]), ward) sub = [w for w in rows if math.exp(2.0 * w["alpha"]) <= N_F8] for w in sub: rr = w["rr"] u2 = w["u2"] nn = np.rint(np.exp(rr["uu"])).astype(np.int64) phi = np.array([float(u2 @ (xmat(x) @ u2)) for x in rr["Xn"]]) imb = np.array([a_f8[n] / sigma3_pp(int(n)) for n in nn]) w["I_imb"] = float(np.sum(rr["lam"] * imb * phi)) w["I_rel"] = abs(w["I_imb"]) / max(w["qS_pnt"], 1e-300) ii = [w["I_imb"] for w in sub] dd = [w["D_ex"] for w in sub] corr = float(np.corrcoef(ii, dd)[0, 1]) lh = np.log([w["h"] for w in sub]) res_i = np.asarray(ii) - np.polyval(np.polyfit(lh, ii, 1), lh) res_d = np.asarray(dd) - np.polyval(np.polyfit(lh, dd, 1), lh) corr_dt = float(np.corrcoef(res_i, res_d)[0, 1]) print(" honesty context: DETRENDED corr (residuals vs log h) " "= %+.3f -- the raw corr on trending series is reported, " "the detrended value shows the window-to-window coupling" % corr_dt) check("I3.B the packet-imbalance correlation on the sub-ladder " "(%d windows, e^{2a} <= %d): corr(I_imb, D_ex) = %+.3f " "(bar >= %.2f); I_imb sign census: %d/%d negative, D_ex " "%d/%d positive" % (len(sub), N_F8, corr, CORR_BAR, sum(1 for x in ii if x < 0), len(ii), sum(1 for x in dd if x > 0), len(dd)), abs(corr) >= CORR_BAR) rho = [w["tau"] / w["tau_pnt"] for w in rows] e1 = [r * h ** 1.5 for r, h in zip(rho, hs)] sl_e1, _, r2_e1 = ols_loglog(hs, e1) l1_ok = min(e1) > 0 and sl_e1 >= ENV_SLOPE check("I3.C1 envelope L1: rho = tau/tau_pnt vs h^{-3/2}: e1 = " "rho h^{3/2} in [%.2e, %.2e], slope %.2f (R^2 %.2f; valid " "iff min > 0 and slope >= %.2f) -- %s" % (min(e1), max(e1), sl_e1, r2_e1, ENV_SLOPE, "VALID: h^{-3/2} is a finite-level lower envelope with " "measured constant %.2e" % min(e1) if l1_ok else "NOT valid"), l1_ok) sub_h = [w["h"] for w in sub] track = [w["tau"] / w["tau_pnt"] / max(w["I_rel"], 1e-300) for w in sub] sl_tr, _, r2_tr = ols_loglog(sub_h, track) l2_ok = abs(sl_tr) <= FLAT_TOL check("I3.C2 envelope L2: rho tracks the relative imbalance " "I_rel = |I_imb|/u2^T S_pnt u2: rho/I_rel trend h^%.2f " "(R^2 %.2f, bar |slope| <= %.2f) -- %s" % (sl_tr, r2_tr, FLAT_TOL, "TRACKING: the f8 imbalance share carries the amplifier " "scale" if l2_ok else "not tracking"), l2_ok) ing3_ok = abs(corr) >= CORR_BAR and (l1_ok or l2_ok) verdict_iii = ("AMPLIFIER-MECHANISM" if ing3_ok else "AMPLIFIER-OPEN") # ============================================================== C print("\nC -- controls") scr_cos2, scr_ii, scr_dd = [], [], [] for w in rows[::STRIDE]: rr_s = core.build_window(w["kz"], scramble_seed=SCR_SEED) A_s = full_A(rr_s) g = capture_geometry(rr_s, A_s) del A_s scr_cos2.append(g["cos2"]) for w in sub: rr_s = core.build_window(w["kz"], scramble_seed=SCR_SEED) l1s, l2s, v1s, v2s = eig2(rr_s["Ah"]) u2 = w["u2"] # atom identities are unchanged by the scramble (positions only) nn = np.rint(np.exp(w["rr"]["uu"])).astype(np.int64) phi_s = np.array([float(u2 @ (xmat(x) @ u2)) for x in rr_s["Xn"]]) imb = np.array([a_f8[n] / sigma3_pp(int(n)) for n in nn]) scr_ii.append(float(np.sum(rr_s["lam"] * imb * phi_s))) scr_dd.append(w["tau_pnt"] - l2s) med_scr = float(np.median(scr_cos2)) med_real = float(np.median(cos2s)) corr_scr = float(np.corrcoef(scr_ii, scr_dd)[0, 1]) res_is = np.asarray(scr_ii) - np.polyval( np.polyfit(lh, scr_ii, 1), lh) res_ds = np.asarray(scr_dd) - np.polyval( np.polyfit(lh, scr_dd, 1), lh) corr_scr_dt = float(np.corrcoef(res_is, res_ds)[0, 1]) print(" honesty context: DETRENDED scrambled corr = %+.3f vs " "detrended real %+.3f -- the raw-corr control bar cannot " "separate arithmetic coupling from the shared alpha-trend; " "the detrended pair decides the position-specific content" % (corr_scr_dt, corr_dt)) c1_angle = med_scr < 0.5 * med_real c1_pack = abs(corr_scr) < CORR_BAR check("C1 [must-fire, kept as frozen] the scramble breaks the " "structure: capture angle median cos^2 %.3f -> %.3f (bar < " "half the real median %.3f: %s) and the packet correlation " "%+.3f -> %+.3f (bar |corr| < %.2f: %s)%s" % (med_real, med_scr, 0.5 * med_real, "fires" if c1_angle else "does NOT fire", corr, corr_scr, CORR_BAR, "fires" if c1_pack else "does NOT fire", "" if c1_angle else " -- TYPED CONTROL SURPRISE: the " "parity-plane proximity of the bottom mode survives the " "scramble = FRAME content, not arithmetic content " "(consistent with the density-level typing of the whole " "geometry)"), c1_angle and c1_pack) r_eps = [] sub5 = rows[::STRIDE] for w in sub5: uuE, mE_raw = epstein_atoms(w["alpha"]) kap = 2.0 * float(np.sum(w["rr"]["lam"])) / float(np.sum(mE_raw)) AhE = lock_from_atoms(w["rr"], uuE, kap * mE_raw) _, _, v1e, _ = eig2(AhE) r_eps.append(slope_of(v1e)) kt_eps = kendall_tau([w["alpha"] for w in sub5], r_eps) s_eps, _, r2_eps = ols_loglog([w["alpha"] for w in sub5], [2.0 - r for r in r_eps]) s_eps = -s_eps eps_ok = kt_eps >= 0.8 and abs(s_eps - s_pnt) / s_pnt <= EPS_RATE_TOL check("C2 the Epstein comb REPRODUCES the density law (the r law " "is density content): Kendall %.3f (>= 0.8), rate s_E = " "%.3f vs density-model s_pnt = %.3f (within %.0f%%) -- %s" % (kt_eps, s_eps, s_pnt, 100 * EPS_RATE_TOL, "the density model owns the law" if eps_ok else "MISMATCH typed"), eps_ok) # ============================================================== V print("\n" + "=" * 78) print("V -- the three verdicts + the reduced floor statement " "(report only)") print("=" * 78) theorem_set = [] if cap_bounded: theorem_set.append("(i)") if ing2_ok: theorem_set.append("(ii)") if ing3_ok: theorem_set.append("(iii)") _LAST2["verdicts"] = (verdict_i, verdict_ii, verdict_iii) print(""" INGREDIENT (i) : %s capture tau/lambda_1 in [%.2f, %.2f]; exact bound = [lambda_1 (1 - 2 sin^2 th) + E]/cos^2 th certified per rung; cos th median %.4f (v780 candidate %.4f cited, cross-surface), sin^2 trend h^%.2f. INGREDIENT (ii) : %s rotation law symbolic [E]; rank-one reads median defect %.1e; in-zone density families monotone %d/%d with constant edge sign %d/%d; real staircase sign-match %.1f%%..%.1f%%; cross-zone r_pnt Kendall %.3f. INGREDIENT (iii): %s corr(I_imb, D_ex) = %+.3f on %d windows; envelope L1 (h^-3/2) %s (e1 min %.2e, slope %.2f); envelope L2 (imbalance tracking) %s (slope %.2f). COMBINED: theorem shape now on {%s} of {(i),(ii),(iii)}. THE REDUCED FLOOR STATEMENT (given the subset; report only): 'inf_X lambda_min(T_GL1,X) >= 0 reduces to the transversal energy tau(X) of the 2-mode lock compression [parent, interlacing + measured O(1) capture%s]. tau(X) = tau_pnt(X) x rho(X) with tau_pnt the EXPLICIT density-model transversal (no zeros, no RH) and rho the arithmetic depth ratio. The direction r(X) is owned by the density model%s. What remains open is EXACTLY the amplifier floor: rho(X) > 0 with an explicit envelope%s -- the sector floor is now ONE ratio inequality about the prime comb against its own smooth density, with every other ingredient finite-level certified or theorem-shaped.' """ % (verdict_i, min(caps), max(caps), med_cos, OVL_CAND, sl_sin, verdict_ii, float(np.median(r1devs)), zone_mono, len(ZONES), zone_sign, len(ZONES), 100 * min(match_fracs), 100 * max(match_fracs), kt_pnt, verdict_iii, corr, len(sub), "VALID" if l1_ok else "not valid", min(e1), sl_e1, "TRACKING" if l2_ok else "not tracking", sl_tr, ", ".join(theorem_set) if theorem_set else "none", " -- now angle-certified" if cap_bounded else " -- capture still measured-only", " (rotation law [E], sign hypothesis verified finite-level)" if ing2_ok else " (measured only)", ": h^-3/2 holds finite-level" if l1_ok else " (no valid envelope found)")) 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 rc = run() return rc, list(FAILS), N_CHK def run(): """run_all entry point (v757 precedent): expected patterns 13 checks with the four preregistered-honest FAILs A2.A/A2.B/A2.C1/A2.C2 and verdict FLOOR-MECHANISM-PARTIAL (part 1), then 15 checks with the two expected FAILs I3.C2 (envelope L2 not tracking; the L1-or-L2 rule carries) and C1 (the typed control surprise: the capture angle survives the scramble = frame content) and verdicts CAPTURE-BOUNDED / INGREDIENT-II-THEOREM-SHAPE / AMPLIFIER-MECHANISM (part 2).""" _probe_run() fails1 = list(FAILS) n1 = N_CHK v1 = _LAST1.get("verdict") print() _rc2, fails2, n2 = _part2() vi, vii, viii = _LAST2.get("verdicts", ("?", "?", "?")) ok = (n1 == 13 and fails1 == ["A2.A", "A2.B", "A2.C1", "A2.C2"] and v1 == "FLOOR-MECHANISM-PARTIAL" and n2 == 15 and fails2 == ["I3.C2", "C1"] and vi == "CAPTURE-BOUNDED" and vii.startswith("INGREDIENT-II-THEOREM-SHAPE") and viii == "AMPLIFIER-MECHANISM") print("\n[%s] PATTERN GATE: expected 9/13 (FAILs A2.A A2.B A2.C1 " "A2.C2, FLOOR-MECHANISM-PARTIAL) + 13/15 (FAILs I3.C2 C1, " "CAPTURE-BOUNDED / THEOREM-SHAPE / AMPLIFIER-MECHANISM); got " "%d checks (fails %s, %s) + %d checks (fails %s, %s / %s / %s)" % ("PASS" if ok else "FAIL", n1, fails1 or "none", v1, n2, fails2 or "none", vi, vii, viii)) return 0 if ok else 1 if __name__ == "__main__": raise SystemExit(run())