"""v527 -- SEAM.CLOCK.SILVER.01: the silver clock eigenvalue EXPLAINED and DEMYSTIFIED (double verdict, anti-numerology style). STRUCTURE = SUCCESS (closed-form origin of {1, sqrt2-1}); CONNECTION = KILL (frozen-registry readout census, 0 hits). NO marker moves. [E] 1. STRUCTURE SUCCESS: {1, sqrt2-1} closed -- diagonal Hankel pencil at N=8, tan(pi/8)=C(3)/C(1), doubling = exact second quantisation, carrier = silver-midpoint axes of the mu4 torsor, gap = arcsinh(1)=gd^{-1}(pi/4). [E] 2. LATTICE DATUM, NOT CONTINUUM: N-scaling (N=8..24) shows pure N=8/16 Majorana lattice datum; positive clock only for N==0 mod 8; golden family as N=10 control. [E] 3. CONNECTION KILL: preregistered 11466-candidate census over the 16 frozen numbers: 0 hits above null expectation; placebos (golden ratio, plastic number) comparable -- NO readout connection. Honest negative in the v100/v513 style. [E] 4. Cross-link to v526 replacement identity: sqrt2-1 as thermal kernel ratio C(3)/C(1)=1/(2 cosh 2 omega - 1). Status: [E] exact sympy Hankel/trig + 40-digit census. Python; Wolfram-mirrored (tan(pi/8) pencil / N-scaling membership / gap = arcsinh(1) -- the frozen-registry numerical census is Python-only), counted per GATE.WOLFRAM.02. Discovery provenance: experiments/tfpt-discovery/seam_clock_silver_spectrum_probe.py (22/22, 2026-07-23). === ORIGINAL PROBE HEADER (kept verbatim) === seam_clock_silver_spectrum_probe.py -- EXPLORATION ONLY (sandbox). Origin and readout-connection of the SILVER clock spectrum {1, sqrt(2)-1} found by woit_os_beta2_os_quotient_probe.py (the compressed quarter-turn transfer T^{N/4} on the OS quotient of the N = 8 seam circle). Nothing in verification/, ledger, papers, changelog, website or scorecard is touched; no files are written; standalone; deterministic; runtime target < 15 min. === PREREGISTRATION (frozen BEFORE the run; criteria not adjusted after) === Two INDEPENDENT verdicts: VERDICT-STRUCTURE (Part A): the closed-form origin of the silver spectrum. SUCCESS iff every A-check passes (the chain below is machine-certified exactly / at 40 digits); otherwise UNDECIDED/KILL with the gap named. VERDICT-CONNECTION (Part B): a preregistered, look-elsewhere-counted scan of the frozen [E]-numbers for silver relations. Logic frozen in [B-5] below. Pre-derived exact anchors (declared BEFORE the run, to be machine- confirmed; derived by hand from the beta2 Hankel structure): (a) the one-particle OS Gram at bond cut k = N-1 is the Hankel matrix G_ab = C(a+b-(N-1)), C(d) = (2/N)/sin(pi d/N) for odd d, else 0; the k-step transfer is the shifted Hankel T_ab = G_{a,b+k}. (b) at N = 8 the quarter-turn domain {4,5} makes both matrices DIAGONAL (C(2) = C(4) = 0), so the compressed clock spectrum is the pure kernel ratios {C(3)/C(1), C(5)/C(3)} = {sin(pi/8)/sin(3pi/8), sin(3pi/8)/sin(5pi/8)} = {tan(pi/8), 1} with tan(pi/8) = sqrt(2)-1 = 1/delta_S. (c) the full domain-algebra clock is the SECOND QUANTISATION of the one-particle pencil: spectrum = all subset products of the one-particle eigenvalues -- this is the origin of the observed doubling {1, sqrt(2)-1} in BOTH parity sectors at N = 8. (d) scaling: the positive clock exists only for N == 0 mod 8 (for N == 4 mod 8 the shifted Hankel lands on the COMPLEMENTARY checkerboard: parity conjugation flips T -> -T, the pencil spectrum is symmetric +/-, indefinite -> contract-kill shape); for N = 16, 24, ... the silver value is NOT in the spectrum (exact certificates) and lambda_max(N) grows monotonically (numeric 40-digit): {1, 1/delta_S} is an N = 8 lattice datum, not a continuum limit. (e) controls N = 6 / 10 (no mu4: 4 does not divide N, the quarter turn is not a lattice step): the nearest even-step clocks give 1/2 (N = 6, third turn) and the GOLDEN family {phi/2} u roots(lam^2 - phi lam + (phi-1)/2) (N = 10, fifth turn): the Dirichlet-kernel mechanism yields metallic trigonometry GENERICALLY; silver specifically = the mu4 quarter turn at N = 8. (f) gap: -ln(sqrt(2)-1) = ln(1+sqrt(2)) = ln delta_S = arcsinh(1) = gd^{-1}(pi/4) = ln tan(3pi/8); the beta2 KMS drift witness C(1)/C(3) = delta_S = e^{+DeltaK} exactly at N = 8 (and ONLY there: the N = 16 edge drift is a different number, exact inequality); arcsinh(1) != pi/4 = the naive continuum NS gap (theta r with theta = pi/2, r = 1/2). [B] PREREGISTERED RELATION CLASS (Part B; frozen): candidate values v = (p/q) * n * b * c3^f with p, q coprime, 1 <= p, q <= 12 (small rationals) n in {1, 4, 8, 16, 1/4, 1/8, 1/16} (|mu4| = 4 and N = 8, 16) b in {dS, dS^2, dS^-1, dS^-2, ln dS, 1/ln dS}, dS = 1+sqrt(2) f in {0, 1, 2} (c3 = 1/(8 pi)) TARGETS (primary): the 16 "predictions" entries of verification/predictions_frozen.json (read-only); the two "assigned" integers and the bands/variants are EXCLUDED (rational targets trivialise the class). TARGETS (secondary, recorded separately, same discipline): phi0, lambda_C, and the v124 clock rates {6 ln(3/2), 6 ln 3}. HIT TIERS (relative |v/t - 1|): T1 <= 1e-30 (exact candidate; must then be closed-form verified), T2 <= 1e-6, T3 <= 1e-3 (calibration only). NULL EXPECTATION: analytic local-density estimate per target (candidates within a factor-2 log window / (2 ln 2), times 2 eps), summed; plus two placebo bases through the SAME class: golden phi_G = (1+sqrt(5))/2 and plastic rho (rho^3 = rho + 1), each with the analogous 6-element base set. [B-5] VERDICT-CONNECTION logic (frozen): ERFOLG iff >= 1 T1 hit that survives closed-form verification; UNENTSCHIEDEN iff no T1 but T2_silver >= 3 AND T2_silver >= 3 * max(T2_golden, T2_plastic, E_T2); KILL otherwise (silver behaves like a placebo: no readout connection above the null expectation). Calibration sanity (must PASS): for every base with analytic E_T3 >= 3 the observed T3 count is within a factor 5 of E_T3. === FINDINGS (from the frozen-prereg run, 2026-07-23; 22/22) === VERDICT-STRUCTURE: SUCCESS -- the silver spectrum has a closed origin: * Hankel form G_ab = C(a+b-(N-1)), NS-Dirichlet carrier sum_{j k + N/2: 15 -> 7 at N = 16, 7 -> 3 at N = 8, exactly the beta2 theta_perp axes) up to the NS deck sign (S_{N/4} R_k S_{N/4}^{-1} = -R_{k+N/2} exactly, eps = -1 at both levels). * v512 tie: S_SILVER = 3 + 2 sqrt(2) = delta_S^2 = cot^2(pi/8) = e^{2 arcsinh(1)} exactly -- the SAME silver quantity (delta_S powers), but a different structural role (harmonic mark POSITION there, transfer EIGENVALUE here); no further identification. * Scaling: N == 4 mod 8 (12, 20): T lands on the complementary checkerboard, parity flips T -> -T, spectrum exactly symmetric +/- with a zero mode -- NO positive clock (mod-8 selection: the positive mu4 clock exists iff 8 | N). N = 16: silver is NOT an eigenvalue (|det(T - (sqrt(2)-1)G)| = 8.7e-3, 9.1e-4 > 1e-30 on the two blocks); nor is 1; the tan(k pi/16) family all fail. N = 24: silver not an eigenvalue (3x3 blocks, dets 1.1e-5, 2.0e-6 > 1e-30). Numeric scan N = 8..40: lambda_max = 1 -> 1.6414 -> 2.8055 -> 5.1033 -> 9.6447 (strictly increasing), lambda_min = 0.414 -> 0.0665 -> 0.00826 -> 9.5e-4 -> 1.0e-4 -> 0; nearest-to-silver distance does NOT converge to 0 (N = 40 false friend 0.4144378... vs 0.4142135...: differs at 2.24e-4 -- 40-digit discrimination). {1, 1/delta_S} is a 16-Majorana/N = 8 lattice datum, NOT a continuum datum. * Controls: N = 6 third turn = 1/2 exactly; N = 10 fifth turn = {phi/2} u roots(lam^2 - phi lam + (phi-1)/2) exactly (GOLDEN family, phi = (1+sqrt 5)/2): metallic trigonometry is generic, silver is the mu4-specific instance. * Gap: -ln(sqrt(2)-1) = ln delta_S = arcsinh(1) = gd^{-1}(pi/4) = ln tan(3pi/8) exactly; e^{-2 DeltaK} = 1/S_SILVER(v512); the beta2 KMS drift C(1)/C(3) = e^{+DeltaK} exactly at N = 8, while the N = 16 edge drift sin(7pi/16)/sin(pi/16) = 5.0273 matches neither 1/lambda_min = 15.04 nor any delta_S power (40-digit inequalities): the drift = gap coincidence is exclusive to N = 8; arcsinh(1) != pi/4 (naive continuum NS gap theta r at theta = pi/2, r = 1/2; separation 0.0960) at 40 digits. VERDICT-CONNECTION: KILL -- no readout connection above null: * class size 91 coprime rationals x 7 x 6 x 3 = 11,466 candidates (5,598 distinct values), 16 primary + 4 secondary targets; * silver: T1 = 0, T2 = 0, T3 = 35 (primary); analytic null E_T3 = 24.9, E_T2 = 0.0249 -- observed T3 within the declared factor-5 calibration band of the null; * placebos: golden T3 = 23, plastic T3 = 20 (comparable: the class is calibrated, not silver-tuned); golden/plastic T2 = 0 = silver; * closest approach anywhere: MC_OVER_MS at rel. distance 1.03e-5 (recorded; a factor 10 above the T2 threshold, and ~0.26 such approaches are expected by chance across the census -- no overshoot); * secondary targets (phi0, lambda_C, v124 rates 6 ln(3/2), 6 ln 3): T1 = T2 = 0 (T3 = 10); * per frozen [B-5] logic: KILL. The silver ratio does not reach the frozen readout numbers through the declared narrow class. TRANSPARENCY (tooling only; preregistration text unchanged): run 1 scored 20/22 -- the two misses were sympy simplification gaps, not substantive: (i) log(3 + 2 sqrt(2)) - 2 asinh(1) and (ii) sinh(ln(1 + sqrt(2))) - 1 do not close under plain simplify(); both are now certified via exact algebraic square/exp-rewrite identities (S = delta_S^2 exactly, asinh(1).rewrite(log) = log(delta_S) exactly, radsimp of the exp form) plus 40-digit zeros. No criterion, tolerance or expectation was changed. Construction base (READ-ONLY): experiments/tfpt-discovery/ woit_os_beta2_os_quotient_probe.py (kernel, Pfaffian-Wick, theta/tower machinery -- copied verbatim where possible), verification/ v519_woit_theta_rp_free.py (torsor/silver-midpoint data), verification/v512_seam_tau_flag.py (S_SILVER), verification/ v100_numerology_null_mc.py (null-census methodology), verification/ predictions_frozen.json + tfpt_constants.py (frozen inventories), verification/v124_resummed_clock.py (clock-chain rates). Exact throughout (sympy trig-algebraic entries, Pfaffian-Wick); definiteness/membership certificates are 40-digit (mp.mp.dps = 40, threshold 1e-30) on exact Hermitian matrices. Run: . experiments/tfpt-discovery/.venv/bin/activate python experiments/tfpt-discovery/seam_clock_silver_spectrum_probe.py """ import json import os import time from bisect import bisect_left, bisect_right from itertools import combinations from math import gcd import mpmath as mp import sympy as sp from tfpt_constants import check as _check, summary, reset mp.mp.dps = 40 I = sp.I ETA = I RESULTS = [] T0_WALL = time.perf_counter() SILVER = sp.sqrt(2) - 1 # tan(pi/8) = 1/delta_S DELTA_S = 1 + sp.sqrt(2) # the silver ratio S_SILVER_V512 = 3 + 2 * sp.sqrt(2) # v512 silver mark position PHI_G = (1 + sp.sqrt(5)) / 2 # golden (control) def check(name, ok): RESULTS.append(bool(ok)) _check("[%2d] %s" % (len(RESULTS), name), bool(ok)) def iszero(e): e2 = sp.expand(e) if e2 == 0: return True e3 = sp.expand(sp.expand_complex(e2)) if e3 == 0: return True return sp.simplify(e3) == 0 # --------------------------------------------------------------------------- # chiral NS kernel + Pfaffian-Wick + theta/shift machinery (beta2 verbatim) # --------------------------------------------------------------------------- def c_of(d, n): if d % 2 == 0: return sp.Integer(0) return sp.Rational(2, n) / sp.sin(sp.pi * sp.Rational(d, n)) def g2f(a, b, n): if a == b: return sp.Integer(1) return I * c_of(a - b, n) _WICK = {} def wick(idx, n): idx = tuple(idx) if len(idx) == 0: return sp.Integer(1) if len(idx) % 2 == 1: return sp.Integer(0) key = (idx, n) if key in _WICK: return _WICK[key] head, rest = idx[0], idx[1:] tot = sp.Integer(0) for j, b in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * g2f(head, b, n) * wick(sub, n) tot = sp.expand_complex(tot) _WICK[key] = tot return tot def refl_map(k, n): def r(a): return (k - a) % n def s(a): return -1 if (k - a) % (2 * n) >= n else 1 return r, s def theta_mono(mono, r, s, eta): imgs = [r(a) for a in reversed(mono)] coeff = eta ** len(mono) for a in mono: coeff *= s(a) lst = list(imgs) sign = 1 for i in range(len(lst)): for j in range(len(lst) - 1 - i): if lst[j] > lst[j + 1]: lst[j], lst[j + 1] = lst[j + 1], lst[j] sign = -sign assert len(set(lst)) == len(lst) return coeff * sign, tuple(lst) def mono_mul(m1, m2): out = list(m1) sign = 1 for g in m2: out.append(g) i = len(out) - 1 while i > 0 and out[i - 1] > out[i]: out[i - 1], out[i] = out[i], out[i - 1] sign = -sign i -= 1 if i > 0 and out[i - 1] == out[i]: del out[i - 1:i + 1] return sign, tuple(out) def shift_mono(m, k, n): """alpha_k on a sorted monomial with NS wrap sign -1 per crossing.""" c = 1 imgs = [] for a in m: q = a + k c *= (-1 if q >= n else 1) imgs.append(q % n) lst = list(imgs) sgn = 1 for i in range(len(lst)): for j in range(len(lst) - 1 - i): if lst[j] > lst[j + 1]: lst[j], lst[j + 1] = lst[j + 1], lst[j] sgn = -sgn assert len(set(lst)) == len(lst) return c * sgn, tuple(lst) def os_entry(ea, eb, k, r, s, n): """omega(theta(e_a) alpha_k(e_b)), exact (eta = +i pinned by v519).""" ca, ma = theta_mono(ea, r, s, ETA) cb, mb = shift_mono(eb, k, n) cs, mm = mono_mul(ma, mb) return sp.expand_complex(ca * cb * cs * wick(mm, n)) def os_matrix(basis, k, r, s, n): d = len(basis) return sp.Matrix(d, d, lambda i, j: os_entry(basis[i], basis[j], k, r, s, n)) def hermitian_exact(M): d = M - M.conjugate().T return all(iszero(x) for x in d) def to_mp(M): A = mp.matrix(M.rows, M.cols) for i in range(M.rows): for j in range(M.cols): re_, im_ = M[i, j].evalf(45).as_real_imag() A[i, j] = mp.mpc(mp.mpf(str(re_)), mp.mpf(str(im_))) return A def ctr(A): B = mp.matrix(A.cols, A.rows) for i in range(A.rows): for j in range(A.cols): B[j, i] = mp.conj(A[i, j]) return B def frame_spec(Gs, Ts): """spectrum of the G-compressed pencil (exact input, 40-digit out).""" G, T = to_mp(Gs), to_mp(Ts) n = G.rows EG, QG = mp.eighe(G) Gis = QG * mp.diag([1 / mp.sqrt(EG[i]) for i in range(n)]) * ctr(QG) B = Gis * T * Gis B = (B + ctr(B)) * mp.mpf('0.5') EB, _ = mp.eighe(B) return sorted([EB[i].real for i in range(n)]) def one_particle_pencil_mp(N): """pure-mpmath quarter-turn pencil on {N/2 .. 3N/4-1} (Hankel form).""" def Cmp(d): if d % 2 == 0: return mp.mpf(0) return (mp.mpf(2) / N) / mp.sin(mp.pi * d / N) dom = list(range(N // 2, 3 * N // 4)) m = len(dom) G = mp.matrix(m, m) T = mp.matrix(m, m) for i, a in enumerate(dom): for j, b in enumerate(dom): G[i, j] = Cmp(a + b - (N - 1)) T[i, j] = Cmp(a + b - (N - 1) + N // 4) return G, T def pencil_spec_mp(G, T): n = G.rows EG, QG = mp.eighe(G) Gis = QG * mp.diag([1 / mp.sqrt(EG[i]) for i in range(n)]) * QG.T B = Gis * T * Gis B = (B + B.T) * mp.mpf('0.5') EB, _ = mp.eighe(B) return sorted([EB[i] for i in range(n)]) def shift_matrix(n, k, wrap_sign): M = [[0] * n for _ in range(n)] for a in range(n): b = (a + k) % n M[b][a] = wrap_sign if a + k >= n else 1 return M def refl_matrix(n, k, wrap_sign): M = [[0] * n for _ in range(n)] for a in range(n): idx = (k - a) % (2 * n) M[idx % n][a] = wrap_sign if idx >= n else 1 return M def hankel_pencil_exact(N, dom, k): m = len(dom) G = sp.Matrix(m, m, lambda i, j: c_of(dom[i] + dom[j] - (N - 1), N)) T = sp.Matrix(m, m, lambda i, j: c_of(dom[i] + dom[j] - (N - 1) + k, N)) return G, T def det40(M): """40-digit |det| of an exact matrix (nonzero-certificate helper).""" v = sp.det(M).evalf(45) re_, im_ = v.as_real_imag() return mp.sqrt(mp.mpf(str(re_)) ** 2 + mp.mpf(str(im_)) ** 2) TOL30 = mp.mpf(10) ** (-30) # --------------------------------------------------------------------------- # Part A1 -- closed-form origin # --------------------------------------------------------------------------- def a1_1_hankel(): print(" -- A1.1: the one-particle OS Gram is the Hankel kernel") ok = True for N in (8, 16): r, s = refl_map(N - 1, N) half = list(range(N // 2, N)) for a in half: for b in half: lhs = os_entry((a,), (b,), 0, r, s, N) if not iszero(lhs - c_of(a + b - (N - 1), N)): ok = False # checkerboard: C(even) = 0 for d in range(0, N, 2): if c_of(d, N) != 0: ok = False # PD certificates (40-digit) pd = True for N in (8, 16): G, _ = one_particle_pencil_mp(N) # extend to the full half for the PD statement def Cmp(d): return (mp.mpf(2) / N) / mp.sin(mp.pi * d / N) if d % 2 else \ mp.mpf(0) half = list(range(N // 2, N)) m = len(half) Gh = mp.matrix(m, m) for i, a in enumerate(half): for j, b in enumerate(half): Gh[i, j] = Cmp(a + b - (N - 1)) E, _ = mp.eighe(Gh) if min(E[i] for i in range(m)) <= TOL30: pd = False check("A1.1 HANKEL FORM OF THE QUOTIENT [exact + 40-digit]: at the " "v519 bond cut k = N-1 the one-particle OS Gram is EXACTLY the " "Hankel matrix G_ab = C(a+b-(N-1)) with the chiral NS kernel " "C(d) = (2/N)/sin(pi d/N) (odd d; C(even) = 0 checkerboard), " "certified entrywise through the full theta/Wick machinery at " "N = 8 and N = 16 (%s), and the half-circle Gram is PD (%s) -- " "the k-step transfer is the SHIFTED Hankel T_ab = G_{a,b+k}: " "the whole clock question is a Hankel-pencil question about " "the kernel 1/sin" % (ok, pd), ok and pd) def a1_2_dirichlet(): print(" -- A1.2: NS-Dirichlet carrier of the kernel") z = sp.symbols('z') ok_laurent = True for N in (8, 16): M = N // 2 S = sum(z ** (2 * j + 1) - z ** (-(2 * j + 1)) for j in range(M)) # (z - 1/z) * S telescopes to z^N + z^-N - 2 identically if sp.expand((z - 1 / z) * S - (z ** N + z ** (-N) - 2)) != 0: ok_laurent = False # at z = e^{i pi d / N} with d odd: z^N = -1 -> (z-1/z) S = -4 # -> sum_j sin((2j+1) pi d/N) * sin(pi d/N) = 1 exactly ok_num = True for N in (8, 16): for d in range(1, 2 * N, 2): sd = mp.sin(mp.pi * d / N) tot = mp.fsum(mp.sin((2 * j + 1) * mp.pi * d / N) for j in range(N // 2)) if abs(tot * sd - 1) > TOL30: ok_num = False check("A1.2 NS-DIRICHLET CARRIER [exact Laurent identity]: " "(z - 1/z) sum_{j " "C(3)/C(1) = tan(pi/8) = sqrt(2)-1 = 1/delta_S and sin(5pi/8) " "= sin(3pi/8) => C(5)/C(3) = 1 closes EXACTLY (%s) -- the " "silver eigenvalue is the half-angle tangent forced by the " "complementary bond distances d = 1, 3 (1 + 3 = N/2) under " "the quarter-turn shift N/4 = 2" % (diag_ok, all(chain)), diag_ok and all(chain)) def a1_4_even_and_secondquant(): print(" -- A1.4: even sector + second quantisation (the doubling)") N = 8 r, s = refl_map(7, N) # even sector on the domain algebra {4,5}: basis {1, g4 g5} be = [(), (4, 5)] Ge = os_matrix(be, 0, r, s, N) Te = os_matrix(be, 2, r, s, N) herm = hermitian_exact(Ge) and hermitian_exact(Te) tr_ok = iszero(sp.simplify((Ge.inv() * Te).trace()) - (1 + SILVER)) det_ok = iszero(sp.simplify(sp.det(Te) / sp.det(Ge)) - SILVER) mem1 = iszero(sp.det(Te - Ge)) mem_s = iszero(sp.det(Te - SILVER * Ge)) prod_id = iszero(sp.simplify(c_of(5, N) / c_of(1, N)) - SILVER) # second quantisation at N = 16: full 2^4 domain algebra on {8..11} N2 = 16 r2, s2 = refl_map(15, N2) dom = [8, 9, 10, 11] basis = [m for d in range(5) for m in combinations(dom, d)] Gf = os_matrix(basis, 0, r2, s2, N2) Tf = os_matrix(basis, 4, r2, s2, N2) spec_full = frame_spec(Gf, Tf) b1 = [(a,) for a in dom] G1 = os_matrix(b1, 0, r2, s2, N2) T1 = os_matrix(b1, 4, r2, s2, N2) spec1 = frame_spec(G1, T1) prods = sorted(mp.mpf(1) if not S else mp.fprod([spec1[i] for i in S]) for dd in range(5) for S in combinations(range(4), dd)) dev = max(abs(a - b) for a, b in zip(prods, spec_full)) sq_ok = dev < TOL30 # vacuum fixed: tau(a, ()) = Gram(a, ()) for every a (lambda = 1) vac_ok = all(iszero(Tf[i, 0] - Gf[i, 0]) for i in range(len(basis))) check("A1.4 SECOND QUANTISATION = THE DOUBLING [exact + 40-digit]: " "the N = 8 EVEN sector {1, g4 g5} has generalized spectrum " "{1, C(5)/C(1)} with C(5)/C(1) = tan(pi/8) exactly (Vieta " "trace/det %s/%s, membership dets zero for lambda = 1 and " "sqrt(2)-1: %s/%s; telescoped product C(5)/C(1) = " "(C(3)/C(1))(C(5)/C(3)): %s) -- so BOTH parity sectors carry " "{1, 1/delta_S}: the doubling is the fermionic second " "quantisation of the one-particle pair {tan(pi/8), 1}; at " "N = 16 the FULL 16-dim domain-algebra clock spectrum equals " "all subset products of the 4 one-particle eigenvalues " "(max deviation %s < 1e-30: %s) and the vacuum column is " "fixed exactly (lambda = 1: %s)" % (tr_ok, det_ok, mem1, mem_s, prod_id, mp.nstr(dev, 3), sq_ok, vac_ok), herm and tr_ok and det_ok and mem1 and mem_s and prod_id and sq_ok and vac_ok) def a1_5_geometry(): print(" -- A1.5: the geometric carrier (torsor / bond angle)") # silver-midpoint cut points of the v519 mu = i axis: e^{2 i th} = i cut_ok = all(iszero(sp.exp(2 * I * t) - I) for t in (sp.pi / 4, 5 * sp.pi / 4)) # tan(pi/8) = tan(theta_cut / 2): stereographic half-angle coordinate stereo = iszero(sp.tan((sp.pi / 4) / 2) - SILVER) # pi/8 = 2 pi/16 = 16-Majorana bond angle = half the N = 8 spacing bond = iszero(sp.pi / 8 - 2 * sp.pi / 16) \ and iszero(sp.pi / 8 - (2 * sp.pi / 8) / 2) # quarter turn conjugates the cut axis into the perpendicular # torsor mirror: S_{N/4} R_k S_{N/4}^{-1} = +- R_{k+N/2} conj = {} for N, kcut in ((16, 15), (8, 7)): S = sp.Matrix(shift_matrix(N, N // 4, -1)) Rk = sp.Matrix(refl_matrix(N, kcut, -1)) Rp = sp.Matrix(refl_matrix(N, (kcut + N // 2) % N, -1)) M = S * Rk * S.inv() if M == Rp: conj[N] = '+1' elif M == -Rp: conj[N] = '-1' else: conj[N] = 'FAIL' conj_ok = all(v in ('+1', '-1') for v in conj.values()) check("A1.5 GEOMETRIC CARRIER [exact]: the clock eigenvalue is the " "HALF-ANGLE TANGENT OF THE SILVER MIDPOINT -- the mu = i " "torsor axis of v519 W-S2.4 cuts the seam at e^{i pi/4}, " "e^{i 5pi/4} (e^{2 i theta} = i: %s), and tan((pi/4)/2) = " "sqrt(2)-1 exactly (%s): the eigenvalue is the stereographic " "coordinate of the silver-midpoint direction; equivalently " "pi/8 = 2pi/16 = the 16-Majorana BOND ANGLE = half the N = 8 " "site spacing (%s); and the quarter turn maps the OS cut " "axis to the PERPENDICULAR torsor mirror, axis k -> k + N/2 " "(15 -> 7 at N = 16, 7 -> 3 at N = 8; signed-permutation " "identity S_{N/4} R_k S_{N/4}^{-1} = eps R_{k+N/2} with eps " "= %s) -- exactly the beta2 theta_perp axes: the clock's own " "quarter step interchanges the two clock-orbits of the mu4 " "torsor" % (cut_ok, stereo, bond, conj), cut_ok and stereo and bond and conj_ok) def a1_6_v512(): print(" -- A1.6: the v512 silver configuration -- same quantity?") # log(3 + 2 sqrt(2)) = 2 arcsinh(1): certified via the exact # algebraic square identity + asinh -> log rewrite + exp transport # (sympy's plain simplify does not close nested log/asinh forms) log_id = (iszero(S_SILVER_V512 - DELTA_S ** 2) and iszero(sp.asinh(1).rewrite(sp.log) - sp.log(DELTA_S)) and iszero(sp.radsimp(S_SILVER_V512 / DELTA_S ** 2) - 1)) num0 = abs(mp.log(3 + 2 * mp.sqrt(2)) - 2 * mp.asinh(1)) < TOL30 ids = [ iszero(S_SILVER_V512 - DELTA_S ** 2), iszero(S_SILVER_V512 - sp.cot(sp.pi / 8) ** 2), log_id and num0, iszero(DELTA_S - sp.cot(sp.pi / 8)), iszero(DELTA_S - sp.tan(3 * sp.pi / 8)), ] check("A1.6 v512 TIE [exact]: the v512 'silver' mark position " "S_SILVER = 3 + 2 sqrt(2) is EXACTLY delta_S^2 = cot^2(pi/8) " "= e^{2 arcsinh(1)} (%s) -- the SAME silver quantity (powers " "of delta_S = cot(pi/8) = tan(3pi/8)) as the clock eigenvalue " "1/delta_S = tan(pi/8), NOT a name coincidence; role typing " "stays separate: in v512 it is a harmonic mark POSITION on a " "topologically dead configuration (negative control there), " "here it is the transfer EIGENVALUE of the pinned mu4 clock " "-- common exact source: the pi/8 half-angle family of the " "16-Majorana circle" % ids, all(ids)) # --------------------------------------------------------------------------- # Part A2 -- scaling in N # --------------------------------------------------------------------------- def a2_mod8(N, num): dom = list(range(N // 2, 3 * N // 4)) G, T = hankel_pencil_exact(N, dom, N // 4) m = len(dom) # complementary checkerboard: G odd a+b support, T even a+b support comp = all(iszero(G[i, j] * T[i, j]) for i in range(m) for j in range(m)) # parity conjugation P = diag((-1)^a): P G P = G, P T P = -T P = sp.diag(*[sp.Integer(-1) ** a for a in dom]) par = (sp.expand(P * G * P - G) == sp.zeros(m, m) and sp.expand(P * T * P + T) == sp.zeros(m, m)) tr0 = iszero(sp.simplify((G.inv() * T).trace())) spec = frame_spec(G, T) paired = all(abs(spec[i] + spec[m - 1 - i]) < TOL30 for i in range(m // 2)) zero_mode = (m % 2 == 1) and abs(spec[m // 2]) < TOL30 indef = spec[0] < -mp.mpf('1e-3') check("A2.%d N = %d (N/4 = %d ODD) -> NO CLOCK [exact mechanism + " "40-digit]: the quarter-turn shift lands on the COMPLEMENTARY " "checkerboard (G_ij T_ij = 0 entrywise: %s); the site-parity " "conjugation P = diag((-1)^a) fixes G and FLIPS T (P G P = G, " "P T P = -T: %s), so the compressed clock anticommutes with a " "unitary involution: spectrum exactly symmetric +/- (paired " "at 40 digits: %s; trace(G^-1 T) = 0 exactly: %s) with a " "zero mode (%s) -- indefinite (%s), no positive transfer " "step, no spectral calculus: the POSITIVE mu4 clock exists " "only for N == 0 mod 8" % (num, N, N // 4, comp, par, paired, tr0, zero_mode, indef), comp and par and tr0 and paired and zero_mode and indef) def a2_3_n16_membership(): print(" -- A2.3: N = 16 -- silver is NOT in the spectrum (exact)") N = 16 # checkerboard blocks {8,10} and {9,11} dets_s, dets_1 = [], [] for blk in ([8, 10], [9, 11]): G, T = hankel_pencil_exact(N, blk, 4) dets_s.append(det40(T - SILVER * G)) dets_1.append(det40(T - G)) non_silver = all(d > TOL30 for d in dets_s) non_one = all(d > TOL30 for d in dets_1) # tan-family hypothesis: tan(k pi/16), k = 1..7 -- all fail fam_fail = True for k in range(1, 8): lam = sp.tan(k * sp.pi / 16) for blk in ([8, 10], [9, 11]): G, T = hankel_pencil_exact(N, blk, 4) if det40(T - lam * G) <= TOL30: fam_fail = False check("A2.3 N = 16: THE SILVER VALUE DOES NOT SURVIVE [exact " "entries, 40-digit nonzero certificates]: det(T - (sqrt(2)-1) " "G) = %s, %s on the two checkerboard blocks (both > 1e-30) -- " "sqrt(2)-1 is NOT an eigenvalue of the N = 16 one-particle " "clock; neither is 1 (dets %s, %s; the vacuum lambda = 1 " "lives at the ALGEBRA level as the empty product, A1.4); the " "naive family guess lambda in {tan(k pi/16)} fails for ALL " "k = 1..7 (%s): no tan(pi/N) family" % (mp.nstr(dets_s[0], 3), mp.nstr(dets_s[1], 3), mp.nstr(dets_1[0], 3), mp.nstr(dets_1[1], 3), fam_fail), non_silver and non_one and fam_fail) def a2_4_n24_membership(): print(" -- A2.4: N = 24 -- silver is NOT in the spectrum") N = 24 dets = [] pd_ok = True for blk in ([12, 14, 16], [13, 15, 17]): G, T = hankel_pencil_exact(N, blk, 6) dets.append(det40(T - SILVER * G)) E, _ = mp.eighe(to_mp(G)) if min(E[i].real for i in range(3)) <= TOL30: pd_ok = False check("A2.4 N = 24: SILVER ABSENT AGAIN [exact entries, 40-digit]: " "det(T - (sqrt(2)-1) G) = %s, %s on the two 3x3 checkerboard " "blocks (both > 1e-30), with PD Gram blocks (%s) -- the exact " "silver eigenvalue does not recur at the next mod-8 level " "either" % (mp.nstr(dets[0], 3), mp.nstr(dets[1], 3), pd_ok), all(d > TOL30 for d in dets) and pd_ok) def a2_5_scan(): print(" -- A2.5: numeric N-scan -- artefact vs continuum datum") silver = mp.sqrt(2) - 1 lam_max, lam_min, nearest = [], [], [] Ns = [8, 16, 24, 32, 40] for N in Ns: G, T = one_particle_pencil_mp(N) spec = pencil_spec_mp(G, T) lam_max.append(spec[-1]) lam_min.append(spec[0]) nearest.append(min(abs(s - silver) for s in spec)) mono_up = all(lam_max[i] < lam_max[i + 1] for i in range(len(Ns) - 1)) mono_dn = all(lam_min[i] > lam_min[i + 1] for i in range(len(Ns) - 1)) exact_at_8 = nearest[0] < TOL30 absent_after = all(d > mp.mpf('1e-4') for d in nearest[1:]) false_friend = abs(nearest[-1] - mp.mpf('2.242736e-4')) \ < mp.mpf('1e-9') check("A2.5 SCALING VERDICT: N = 8 DATUM, NOT A CONTINUUM LIMIT " "[40-digit scan N = 8..40]: lambda_max = %s strictly " "increasing (%s; no bounded limit -- the thermal/KMS " "non-contraction escalates), lambda_min = %s strictly " "decreasing to 0 (%s); distance of the spectrum to sqrt(2)-1: " "%s -- EXACTLY zero only at N = 8 (%s), bounded away (> 1e-4) " "for all larger N (%s) incl. the N = 40 FALSE FRIEND " "0.4144378... vs 0.4142135... (gap 2.24e-4: %s, a " "look-elsewhere lesson at 40 digits): the silver spectrum is " "a 16-Majorana/N = 8 lattice datum, not a continuum datum" % ([mp.nstr(x, 6) for x in lam_max], mono_up, [mp.nstr(x, 3) for x in lam_min], mono_dn, [mp.nstr(x, 3) for x in nearest], exact_at_8, absent_after, false_friend), mono_up and mono_dn and exact_at_8 and absent_after and false_friend) def a2_6_n6(): print(" -- A2.6: control N = 6 (no mu4)") N = 6 quarter_not_lattice = (N % 4 != 0) G, T = hankel_pencil_exact(N, [3], 2) lam = sp.simplify(T[0, 0] / G[0, 0]) ok = iszero(lam - sp.Rational(1, 2)) check("A2.6 CONTROL N = 6 [exact]: 4 does not divide 6 -- the " "quarter turn is NOT a lattice step (%s), there is no mu4 " "clock; the nearest even-step clock (third turn, k = 2, " "domain {3}) has the single eigenvalue C(3)/C(1) = " "sin(pi/6)/sin(pi/2) = 1/2 EXACTLY (%s) -- a plain rational, " "no silver" % (quarter_not_lattice, ok), quarter_not_lattice and ok) def a2_7_n10(): print(" -- A2.7: control N = 10 (no mu4) -- the GOLDEN family") N = 10 quarter_not_lattice = (N % 4 != 0) # fifth turn k = 2 on domain {5,6,7}; checkerboard {5,7} (+) {6} G2, T2 = hankel_pencil_exact(N, [5, 7], 2) tr = sp.simplify((G2.inv() * T2).trace()) dt = sp.simplify(sp.det(T2) / sp.det(G2)) ok_tr = iszero(tr - PHI_G) ok_dt = iszero(dt - (PHI_G - 1) / 2) lam6 = sp.simplify(c_of(5, N) / c_of(3, N)) ok_6 = iszero(lam6 - PHI_G / 2) and iszero(lam6 - sp.cos(sp.pi / 5)) check("A2.7 CONTROL N = 10 [exact]: 4 does not divide 10 (%s) -- no " "mu4 clock; the fifth-turn clock (k = 2, domain {5,6,7}) has " "the GOLDEN spectrum: block {6} eigenvalue C(5)/C(3) = " "sin(3pi/10) = cos(pi/5) = phi/2 exactly (%s); block {5,7} " "satisfies lambda^2 - phi lambda + (phi-1)/2 = 0 exactly " "(Vieta: trace = phi: %s, det ratio = (phi-1)/2: %s) -- the " "Dirichlet-kernel mechanism yields METALLIC trigonometry for " "every small N (1/2 at N = 6, golden at N = 10, SILVER at " "N = 8): what singles out silver is not the mechanism but the " "mu4 quarter turn itself, which exists exactly at the " "16-Majorana levels N == 0 mod 8" % (quarter_not_lattice, ok_6, ok_tr, ok_dt), quarter_not_lattice and ok_tr and ok_dt and ok_6) # --------------------------------------------------------------------------- # Part A4 -- the gap and the KMS structure # --------------------------------------------------------------------------- def a4_1_gap(): print(" -- A4.1: the spectral gap in closed form") # sinh(ln delta_S) = (delta_S - 1/delta_S)/2 = 1: exp-rewrite + # radsimp (plain simplify does not close it), plus 40-digit zero sinh_id = (iszero(sp.radsimp(sp.expand( sp.sinh(sp.log(DELTA_S)).rewrite(sp.exp))) - 1) and abs(mp.sinh(mp.log(1 + mp.sqrt(2))) - 1) < TOL30) ids = [ iszero(-sp.log(SILVER) - sp.log(DELTA_S)), iszero(sp.log(DELTA_S) - sp.asinh(1)), sinh_id, iszero(sp.exp(-2 * sp.asinh(1)) - 1 / S_SILVER_V512), ] check("A4.1 GAP CLOSED FORM [exact]: the modular generator K = " "-ln(compressed clock) has per-sector spectrum {0, DeltaK} " "with DeltaK = -ln(sqrt(2)-1) = ln(1+sqrt(2)) = ln delta_S = " "arcsinh(1) (%s; sinh(DeltaK) = 1 exactly: %s); the doubled " "algebra spectrum is the additive second quantisation " "{0, DeltaK} per sector (A1.4); and e^{-2 DeltaK} = " "1/S_SILVER(v512) exactly (%s) -- the v512 silver position is " "the two-quantum Boltzmann factor of the clock gap" % (ids[0] and ids[1], ids[2], ids[3]), all(ids)) def a4_2_kms(): print(" -- A4.2: the beta2 KMS drift vs the gap") N = 8 drift8 = sp.simplify(c_of(1, N) / c_of(3, N)) ok8 = iszero(drift8 - DELTA_S) \ and iszero(drift8 - sp.exp(sp.asinh(1))) # N = 16 edge drift ||T(4)[g_11]||^2/||[g_11]||^2 = C(15)/C(7) N2 = 16 drift16 = sp.simplify(c_of(15, N2) / c_of(7, N2)) d16 = mp.mpf(str(drift16.evalf(45))) G1, T1 = one_particle_pencil_mp(16) spec16 = pencil_spec_mp(G1, T1) neq_min = abs(d16 - 1 / spec16[0]) > mp.mpf('1e-3') neq_ds = min(abs(d16 - (mp.mpf(1) + mp.sqrt(2)) ** k) for k in (1, 2, 3)) > mp.mpf('1e-3') check("A4.2 DRIFT = e^{+DeltaK} EXACTLY AT N = 8, AND ONLY THERE " "[exact + 40-digit]: the pre-declared beta2 KMS witness " "C(1)/C(3) = 1 + sqrt(2) IS e^{+DeltaK} (%s) -- the edge-mode " "norm expansion and the clock gap are the same number " "(2-site exactness: the drift ratio is the inverse of the " "eigenvalue ratio); at N = 16 the analogous edge drift " "C(15)/C(7) = sin(7pi/16)/sin(pi/16) = %s matches neither " "1/lambda_min = %s (%s) nor any delta_S power (%s): the " "drift/gap coincidence is EXCLUSIVE to the N = 8 level" % (ok8, mp.nstr(d16, 8), mp.nstr(1 / spec16[0], 8), neq_min, neq_ds), ok8 and neq_min and neq_ds) def a4_3_gudermann(): print(" -- A4.3: Gudermannian form of the gap; continuum contrast") gd_ok = iszero(sp.asinh(1) - sp.log(sp.tan(3 * sp.pi / 8))) \ and iszero(sp.log(sp.tan(sp.pi / 8 + sp.pi / 4)) - sp.log(sp.tan(3 * sp.pi / 8))) # arcsinh(1) != pi/4 (naive continuum NS gap theta*r, theta = pi/2, # r = 1/2) -- 40-digit separation sep = abs(mp.asinh(1) - mp.pi / 4) sep_ok = sep > mp.mpf('0.09') check("A4.3 THE GAP IS THE INVERSE GUDERMANNIAN OF THE SILVER-" "MIDPOINT ANGLE [exact]: DeltaK = arcsinh(1) = ln tan(pi/8 + " "pi/4) = gd^{-1}(pi/4) (%s) -- the rapidity whose Gudermann " "angle is pi/4 = half the quarter-turn euclidean angle = the " "silver-midpoint axis angle (A1.5): the Wick bridge circle-" "angle <-> rapidity evaluated at the mu4 half-angle; it is " "NOT the naive continuum NS mode gap theta r = pi/4 (lowest " "NS momentum r = 1/2 under the quarter turn theta = pi/2): " "|arcsinh(1) - pi/4| = %s > 0.09 (%s) -- consistent with " "A2.5: the gap is lattice data, its closed form lives in the " "half-angle geometry, not in a continuum mode sum" % (gd_ok, mp.nstr(sep, 6), sep_ok), gd_ok and sep_ok) # --------------------------------------------------------------------------- # Part B -- preregistered readout census # --------------------------------------------------------------------------- def load_targets(): here = os.path.dirname(os.path.abspath(__file__)) path = os.path.join(here, 'predictions_frozen.json') with open(path) as fh: reg = json.load(fh) primary = [(e['id'], mp.mpf(e['frozen_value'])) for e in reg['predictions']] c3 = 1 / (8 * mp.pi) phi0 = 1 / (6 * mp.pi) + 48 * c3 ** 4 lamC = mp.sqrt(phi0 * (1 - phi0)) secondary = [('PHI0', phi0), ('LAMBDA_C_SEED', lamC), ('V124_RATE1', 6 * mp.log(mp.mpf(3) / 2)), ('V124_RATE2', 6 * mp.log(3))] return primary, secondary def class_values(base): """the frozen class: (p/q) * n * b * c3^f (base = 6-element b-set).""" c3 = 1 / (8 * mp.pi) rats = [mp.mpf(p) / q for p in range(1, 13) for q in range(1, 13) if gcd(p, q) == 1] ns = [mp.mpf(1), mp.mpf(4), mp.mpf(8), mp.mpf(16), mp.mpf(1) / 4, mp.mpf(1) / 8, mp.mpf(1) / 16] fs = [mp.mpf(1), c3, c3 ** 2] vals = [] for r in rats: for n in ns: for b in base: for f in fs: vals.append(r * n * b * f) return len(rats), vals def census(vals_sorted, targets, tiers): """hit counts per tier + nearest relative distance per target.""" counts = {t: 0 for t in tiers} nearest = [] for tid, t in targets: lo_all = bisect_left(vals_sorted, t * (1 - max(tiers))) hi_all = bisect_right(vals_sorted, t * (1 + max(tiers))) best = None for tier in tiers: lo = bisect_left(vals_sorted, t * (1 - tier)) hi = bisect_right(vals_sorted, t * (1 + tier)) counts[tier] += hi - lo i = bisect_left(vals_sorted, t) cands = [vals_sorted[j] for j in (i - 1, i, i + 1) if 0 <= j < len(vals_sorted)] if cands: best = min(abs(v / t - 1) for v in cands) nearest.append((tid, best)) _ = (lo_all, hi_all) return counts, nearest def null_expectation(vals_sorted, targets, tiers): """analytic local-density null: E = sum_t D_t * 2 eps.""" ln2 = mp.log(2) out = {t: mp.mpf(0) for t in tiers} for _, t in targets: lo = bisect_left(vals_sorted, t / 2) hi = bisect_right(vals_sorted, t * 2) dens = (hi - lo) / (2 * ln2) for tier in tiers: out[tier] += dens * 2 * tier return out def b_census(): print(" -- B: preregistered silver-relation census on the frozen " "registry") primary, secondary = load_targets() dS = mp.mpf(1) + mp.sqrt(2) gold = (1 + mp.sqrt(5)) / 2 disc = mp.sqrt(mp.mpf(23) / 108) plast = mp.cbrt(mp.mpf(1) / 2 + disc) + mp.cbrt(mp.mpf(1) / 2 - disc) def base6(x): return [x, x ** 2, 1 / x, 1 / x ** 2, mp.log(x), 1 / mp.log(x)] tiers = [mp.mpf('1e-30'), mp.mpf('1e-6'), mp.mpf('1e-3')] T1, T2, T3 = tiers n_rat, vals_s = class_values(base6(dS)) _, vals_g = class_values(base6(gold)) _, vals_p = class_values(base6(plast)) for v in (vals_s, vals_g, vals_p): v.sort() n_raw = len(vals_s) n_distinct = len({mp.nstr(v, 32) for v in vals_s}) # fairness: the declared generators reconstruct inside the class fair = all(any(abs(v - w) < mp.mpf('1e-35') for v in vals_s) for w in (dS, dS ** 2, 1 / dS, 1 / dS ** 2, mp.log(dS), 4 * dS, 16 / dS ** 2, mp.log(dS) / (8 * mp.pi) ** 2 * 64)) ok_inv = (len(primary) == 16 and abs(plast ** 3 - plast - 1) < mp.mpf('1e-35')) check("B.1 INVENTORY + CLASS [frozen]: 16 primary targets loaded " "from predictions_frozen.json (read-only), 4 secondary " "(phi0, lambda_C, v124 rates); class = %d coprime rationals " "x 7 (mu4/N powers) x 6 (delta_S branch) x 3 (c3 powers) = " "%d candidates (%d distinct values); plastic root certified " "(rho^3 - rho - 1 = 0 at 40 digits: %s); fairness: all " "declared generators reconstruct inside the class (%s)" % (n_rat, n_raw, n_distinct, ok_inv, fair), ok_inv and fair and n_raw == n_rat * 7 * 6 * 3) cs, near_s = census(vals_s, primary, tiers) cg, _ = census(vals_g, primary, tiers) cp, _ = census(vals_p, primary, tiers) E = null_expectation(vals_s, primary, tiers) print(" silver T1/T2/T3 = %d/%d/%d (null E: %s/%s/%s)" % (cs[T1], cs[T2], cs[T3], mp.nstr(E[T1], 3), mp.nstr(E[T2], 3), mp.nstr(E[T3], 3))) print(" golden T1/T2/T3 = %d/%d/%d ; plastic T1/T2/T3 = " "%d/%d/%d" % (cg[T1], cg[T2], cg[T3], cp[T1], cp[T2], cp[T3])) for tid, d in near_s: print(" nearest silver-class candidate to %-18s : " "rel dist %s" % (tid, "n/a" if d is None else mp.nstr(d, 4))) check("B.2 SILVER CENSUS RECORDED [frozen tiers]: exact tier T1 " "(1e-30) = %d, tight tier T2 (1e-6) = %d, calibration tier " "T3 (1e-3) = %d over 16 frozen targets x %d candidates -- " "every T1 hit would require closed-form verification; none " "to verify iff T1 = 0 (observed: %s)" % (cs[T1], cs[T2], cs[T3], n_raw, cs[T1] == 0), True) plc_ok = (cg[T3] + cp[T3]) >= cs[T3] // 2 check("B.3 PLACEBO CONTROLS [same class, same targets]: golden " "T3 = %d and plastic T3 = %d vs silver T3 = %d -- the " "placebos deliver comparable chance hits (%s): the class is " "calibrated, not silver-tuned; placebo T2 = %d/%d vs silver " "T2 = %d" % (cg[T3], cp[T3], cs[T3], plc_ok, cg[T2], cp[T2], cs[T2]), plc_ok) cal_ok = True for tag, c in (('silver', cs), ('golden', cg), ('plastic', cp)): if E[T3] >= 3 and not (E[T3] / 5 <= c[T3] <= E[T3] * 5): cal_ok = False check("B.4 NULL CALIBRATION [analytic density]: expected T3 hits " "under the log-local-density null = %s; observed %d " "(silver), %d (golden), %d (plastic) -- all within the " "declared factor 5 (%s); expected T2 = %s: any T2 hit is " "individually interesting, none is expected by chance" % (mp.nstr(E[T3], 4), cs[T3], cg[T3], cp[T3], cal_ok, mp.nstr(E[T2], 3)), cal_ok) cs2, near2 = census(vals_s, secondary, tiers) for tid, d in near2: print(" nearest silver-class candidate to %-18s : " "rel dist %s" % (tid, "n/a" if d is None else mp.nstr(d, 4))) check("B.5 SECONDARY TARGETS (phi0, lambda_C, v124 clock rates " "6 ln(3/2), 6 ln 3) [recorded separately]: T1 = %d, T2 = %d, " "T3 = %d -- the silver/arcsinh(1) family does not land on " "the resummed-clock chain either (closest approach printed " "above)" % (cs2[T1], cs2[T2], cs2[T3]), True) # frozen verdict logic [B-5] t1_verified = 0 # no T1 hits -> nothing to verify if cs[T1] > 0: t1_verified = -1 # would require closed-form work: flag only if cs[T1] > 0 and t1_verified > 0: verdict = "ERFOLG-ANSCHLUSS" elif cs[T1] == 0 and cs[T2] >= 3 and \ cs[T2] >= 3 * max(cg[T2], cp[T2], 1): verdict = "UNENTSCHIEDEN" else: verdict = "KILL" consistent = (verdict == "KILL") == (cs[T1] == 0 and not (cs[T2] >= 3 and cs[T2] >= 3 * max(cg[T2], cp[T2], 1))) check("B.6 VERDICT-CONNECTION PER FROZEN [B-5] LOGIC = %s " "[assembled]: T1 = %d (verified exact: %d), T2 silver/golden/" "plastic = %d/%d/%d, null E_T2 = %s -- the decision follows " "the preregistered branch exactly (consistency: %s)" % (verdict, cs[T1], max(t1_verified, 0), cs[T2], cg[T2], cp[T2], mp.nstr(E[T2], 3), consistent), consistent) return verdict # --------------------------------------------------------------------------- def run(): reset() print("v527 SEAM.CLOCK.SILVER.01 -- origin and readout-connection of the silver clock spectrum" "connection of the silver clock spectrum (EXPLORATION ONLY)") a1_1_hankel() a1_2_dirichlet() a1_3_n8_odd() a1_4_even_and_secondquant() a1_5_geometry() a1_6_v512() a2_mod8(12, 1) a2_mod8(20, 2) a2_3_n16_membership() a2_4_n24_membership() a2_5_scan() a2_6_n6() a2_7_n10() a4_1_gap() a4_2_kms() a4_3_gudermann() n_a = len(RESULTS) verdict_structure = "SUCCESS" if all(RESULTS) else "UNDECIDED" verdict_connection = b_census() npass = sum(RESULTS) print("\n%d/%d checks passed (runtime %.1f s)" % (npass, len(RESULTS), time.perf_counter() - T0_WALL)) if not all(RESULTS[:n_a]): verdict_structure = "UNDECIDED" print("VERDICT-STRUCTURE : %s (closed-form origin of {1, " "sqrt(2)-1})" % verdict_structure) print("VERDICT-CONNECTION: %s (frozen-registry readout census)" % verdict_connection) return summary("v527 SEAM.CLOCK.SILVER.01: STRUCTURE SUCCESS -- {1,sqrt2-1} closed via diagonal Hankel pencil at N=8, tan(pi/8)=C(3)/C(1), doubling = exact second quantisation, carrier = silver-midpoint axes of the mu4 torsor, gap = arcsinh(1)=gd^{-1}(pi/4); N-scaling shows pure N=8/16 Majorana lattice datum (not continuum); positive clock only for N==0 mod 8; CONNECTION KILL -- preregistered 11466-candidate census over 16 frozen numbers: 0 hits above null (placebos comparable); cross-link v526: sqrt2-1 = thermal kernel ratio; double verdict; no marker moves") if __name__ == "__main__": raise SystemExit(1 if run() else 0)