#!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""v801 -- PRIME.CP.INTERTWINER.01: the carrier intertwiner EXISTS in Stinespring form -- demand (3) of PRIME.POSITIVE_DESCENT.01 finite-level SOLVED (29/29 checks, controls 3/3, ~2 s; discovery probe prime_cp_intertwiner_probe.py, 2026-08-06, verdict CP-INTERTWINER-EXISTS; FROZEN_SPEC SHA-hashed before the first run). THE OBJECT: Phi(a) = V* pi(a) V with V = the leg-indexed stack of the 105 Kraus operators K_e = 7^{-1/2} |y_e> y (B[x,y] = 1 for the polar incidence of the lex-first sigma-invariant symplectic form on V = L/(1+i)L = F2^4, v738 frame rebuilt live) with involution = ARROW REVERSAL (closed because B = B^T) and the KMS half-weight 7^{-1/2} per leg; the generated *-algebra is decided by exact span closure (matrix-unit composition). Odd places 3, 5, 7: the ledger-certified structure (odd tower arrows act as degree * id on V; the arrow content that survives is the C2 packet composition) enters as the commuting packet slots C[C2] with the packet matrices M_n = [[A,B],[B,A]] and the p^3-corrected Hecke composition, recomputed exactly. Tower factor: the degree-2 shift U and half-weight D of v756 with D' U = 2^{-1/2} U D. 2 THE STINESPRING ISOMETRY: V = the leg-indexed stack of the 105 Kraus operators K_e = 7^{-1/2} |y_e>= 0 on a frozen generating family (105 single arrows exact + 12 LCG +-1 leg combinations via the exact integer Gram factorization 7 Phi(a*a) = M^T M, plus exact-rational LDL pivots on 3 of them); covariances: sigma (label permutation, exact integer), deck (the ledger two-step weight identity 4/196 = (7^{-1/2})^4 and T = 4 B^2 exact), KMS half-weight (D U = 2^{-1/2} U D and Kraus naturality), beta = 1 detailed balance (superoperator symmetry exact + KMS density preserved exactly), Gate-0 compatibility. 4 THE GL1 IDENTIFICATION (the decider): the four AUTOMORPHIC character channels of the ONE map, applied to the packet event stream, must land on the four sector windows: GL1 channel == the deployed Weil window (machine precision, the parent's D0 landing); chi4 channel == the chi_{-4} sector window; f8 channel (the C2-population sign character of the HECKE-PRIMITIVE packet element y_{p^k} = M_{p^k} - p^3 M_{p^{k-2}}, normalized p^{3k/2}) == the f8-sector window with its Gamma_R continuum; twist channel == the f8 (x) chi_{-4} window with the conductor-16 rule continuum. The ramified events are killed in the twisted channels BY THE ALGEBRA (a(2^k) = 0: the ramified packet is C2-symmetric; the mu4 slot is glue-uniform), reproducing the conductor-8/16 emptiness structurally. All four ladders PSD. 5 THE KILL (frozen): if the Choi census fails STRUCTURALLY (a negative Choi eigenvalue that exact rational arithmetic confirms), the required GL1 intertwiner is not completely positively realizable and the route dies (verdict CP-INTERTWINER-IMPOSSIBLE, breaking element reported exactly). CONTROLS (must fire): C1 a non-isometric V (one leg dropped) breaks unitality exactly (Phi(1) deficit = 1/7 at the dropped source label); C2 scrambled legs (LCG re-targeting, row degree preserved) keep unitality but break the involution closure (B asymmetric), sigma covariance and detailed balance; the v756 one-edge mutation replayed as the minimal version; C3 the naive linear pushforward (parent finding F1) FAILS the Choi census exactly where it failed the state property: on the abelian packet algebra the Choi matrix of a functional is its sector diagonal, and the linear candidate's minimal sector value ~ -6.6e-2 at (+1, v7, j2) IS a negative Choi eigenvalue (the negative anchor, reproduced live; exact-leg Fraction < 0). VERDICT ENUM (frozen): CP-INTERTWINER-EXISTS (Stinespring form certified with all covariances, GL1 lands on Weil, twisted channels land on their sector-adapted objects) / CP-INTERTWINER-PARTIAL (name what breaks) / CP-INTERTWINER-IMPOSSIBLE (the kill). FENCES: NO RH/GRH claim. Stop-list of the closed diagonal-Gram route binding; windows/continua machinery reused READ-ONLY (v563/v755 + sibling probes' certified constructions). The mirror sector (+,0,0) stays typed non-automorphic; no positivity demand is made there. Everything frozen before running; writes nothing; ONE new file; no verification//ledger/.tex/website surface touched. Predecessors (read-only): verification/v756_kms_incidence_stinespring (105-Kraus reference), verification/v738_hecke_mod_ramified (label frame), verification/v563_paper2_readouts + v755_simpler_schur_ recursion (deployed window machinery), experiments/tfpt-discovery/ hecke_arrow_ledger_probe (T4 leg classes == Kraus index set, deck weights; cited), positive_descent_probe (packet state, D0 landing, F1 anchor), f8_sector_continuum_probe (sector kernels), conductor_functoriality_probe (the closed Gamma_R rule + conductor 16). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/prime_cp_intertwiner_probe.py """ import ast import hashlib import math import os import sys import time from fractions import Fraction as Fr import numpy as np import scipy.linalg as sla _VERIFY = os.path.dirname(os.path.abspath(__file__)) _DISCOVERY = os.path.abspath(os.path.join(_VERIFY, "..", "experiments", "tfpt-discovery")) sys.path.insert(0, _DISCOVERY) sys.path.insert(0, _VERIFY) _LAST = {} import v563_paper2_readouts as core # noqa: E402 (deployed atoms) import v755_simpler_schur_recursion as srp # noqa: E402 (tower channels) import v738_hecke_mod_ramified as ram # noqa: E402 (label frame) import f8_sector_continuum_probe as fsc # noqa: E402 (sector kernels) import conductor_functoriality_probe as cfp # noqa: E402 (Gamma_R rule) # ------------------------------------------------------------- frozen spec FROZEN_SPEC = """\ PRIME.CP.INTERTWINER.01 finite-level spec v1 (frozen 2026-08-06, before the first run). Arrow algebra: ramified layer = *-algebra generated by the 105 polar incidence arrows (v738 frame, lex-first sigma-invariant symplectic form, involution = arrow reversal), decided by exact matrix-unit span closure; odd places 3/5/7 = commuting packet slots C[C2] with M_n = [[A,B],[B,A]], A/B = (sigma3 +- a(f8))/2 (independent eta recurrence, N_THETA = 22050), p^3-corrected composition exact; tower = v756 5-level Toeplitz factor with D = diag(2^{-l/2}), shift U. Stinespring: V = leg-indexed stack of K_e = 7^{-1/2}|y_e>= 0 on 105 single arrows (exact) + 12 LCG +-1 combos (integer Gram factorization 7 Phi(a*a) = M^T M, float ward rel <= 1e-12) + exact LDL pivots >= 0 on 3 combos; sigma covariance exact integer (P B P^T = B and per-leg P L_e P^T = L_sigma(e)); deck anchor 4/196 == (7^{-1/2})^4 and T = 4 B^2 == 28 I + 12 (J - I) exact; half-weight D'U = 2^{-1/2} U D <= 1e-14 and Kraus naturality == 0; beta = 1 balance: superop == transpose exact, KMS density preserved exact (Fractions); Gate-0 dev <= 1e-14. Channels (the ONE map, four characters): GL1 = carrier-trivial (mult 1 on ALL deployed events, u <= 10); chi4 = mu4 character (-1)^{(n-1)/2} on odd events, ramified killed (glue-uniform slot); f8 = C2-population sign of the Hecke-primitive element, t_k = (a_{p^k} - p^3 a_{p^{k-2}})/p^{3k/2}, ramified killed (a(2^k) = 0); twist = product channel. Continua: GL1 deployed (v755); chi4/f8/twist from the certified Gamma_R rule (conductor_functoriality_probe.rule_arch_lags, q = 4/8/16, read-only). Identification bars: GL1 rel dev <= 1e-12 vs deployed build; chi4/f8/twist window rel dev <= 1e-12 vs sibling-constructed combs (independent float Chebyshev path, mass dev <= 1e-9); exact Satake anchors p = 3 (k <= 9), 5 (k <= 6), 7 (k <= 5) via Fractions; Eisenstein co-channel sigma3(p^k) - p^3 sigma3(p^{k-2}) == p^{3k}+1 exact; Deligne |t_k| <= 2 + 1e-12 on every odd event. Ladders: all four sector windows PSD on rungs M = 256..640 (lambda_min >= -1e-10 ||T||_2); GL1 margin anchors 5.29e-5 (X=4), 1.18e-5 (X=10) within 5 percent (parent replay). Controls: C1 dropped leg -> Phi(1) deficit == 1/7 exact; C2 LCG re-target scramble (row degree 7 kept) -> B asymmetric + sigma dev > 0 + superop asymmetric; one-edge mutation -> sigma or balance breaks (v756 replay); C3 naive linear pushforward min sector value < -5e-2 at (+1, v7, j2) (float, X = 10) and exact-leg Fraction < 0 (unit weights, n <= 300) == negative Choi eigenvalue on the abelian packet algebra. Verdict enum: CP-INTERTWINER-EXISTS / CP-INTERTWINER-PARTIAL / CP-INTERTWINER-IMPOSSIBLE. LCG seed 20260805. Runtime cap ~25 min. NO RH/GRH claim; mirror sector stays non-automorphic; writes nothing. """ N_THETA = 22050 M_TOP = 640 DGRID = 1.0 / 64.0 ALPHA_TOP = 0.5 * M_TOP * DGRID # = 5.0, reach n <= e^10 RUNGS = (256, 320, 384, 448, 512, 576, 640) LABEL_DIM = 15 ROW_DEGREE = 7 LEVELS = 5 # v756 tower (TOWER_LEVEL 4) PSD_BAR = 1.0e-10 WARD_BAR = 1.0e-12 EXACT_DEPTH = 300 GL1_ANCHOR = (5.29e-5, 1.18e-5) # parent D2 margins X=4 / X=10 F1_SECTOR = (+1, "v7", 2) ODD_PLACES = (3, 5, 7) BANNED_IDS = ("sympy", "isprime", "primerange", "nextprime", "prevprime", "primepi", "zetazero", "nzeros", "mpz_zeta") CHECKS = [] GATE_FLAGS = {} CONTROL_FIRED = {} T0 = time.time() _LCG = [20260805] def lcg(n): _LCG[0] = (1103515245 * _LCG[0] + 12345) % (1 << 31) return _LCG[0] % n def check(name, ok, detail=""): CHECKS.append((name, bool(ok))) print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""), flush=True) return bool(ok) def section(title): print("\n" + "=" * 74) print(title) print("=" * 74, flush=True) # ==================================================================== G0 def g0_firewall(): section("G0 -- SHA-frozen spec + AST firewall + environment") sha = hashlib.sha256(FROZEN_SPEC.encode("utf-8")).hexdigest() print(" FROZEN_SPEC SHA-256 = %s" % sha) src = open(os.path.abspath(__file__), encoding="utf-8").read() tree = ast.parse(src) bad = [] for node in ast.walk(tree): name = None if isinstance(node, ast.Name): name = node.id elif isinstance(node, ast.Attribute): name = node.attr elif isinstance(node, (ast.Import, ast.ImportFrom)): mods = [al.name for al in node.names] if isinstance(node, ast.ImportFrom) and node.module: mods.append(node.module) for m in mods: if any(b in m for b in BANNED_IDS): bad.append(m) continue if name and name.lower() in BANNED_IDS: bad.append(name) check("G0.1 no prime-table / zeta symbols in this file", not bad, "found %s" % bad if bad else "clean") print(" python %s, numpy %s, scipy %s" % (sys.version.split()[0], np.__version__, __import__("scipy").__version__)) # ===================================================== S1 the arrow algebra def build_label_frame(): """v738 frame rebuilt live: sigma-bar, 15 labels, lex-first sigma-invariant symplectic form Omega, incidence B, y_chi / H*.""" from itertools import combinations L = ram.Lmodule() E4 = [tuple((1 if j == k else 0, 0) for j in range(4)) for k in range(4)] S = [L.coords(ram.pack(ram.sig8(ram.unpack(L.to_ambient(E4[k]))))) for k in range(4)] S2 = [[ram.par(S[k][j]) for j in range(4)] for k in range(4)] def sigbar(v): return tuple((sum(v[k] * S2[k][j] for k in range(4))) & 1 for j in range(4)) labels16 = [tuple((z >> b) & 1 for b in range(4)) for z in range(16)] labels = labels16[1:] # the 15 nonzero classes pairs = list(combinations(range(4), 2)) Omega = None n_inv = 0 for mask in range(1, 1 << 6): M = [[0] * 4 for _ in range(4)] for bi, (i, j) in enumerate(pairs): if (mask >> bi) & 1: M[i][j] = M[j][i] = 1 cols = [tuple(M[i][j] for i in range(4)) for j in range(4)] rk, _k, _i = ram.f2_rank_ker_inv(cols) if rk != 4: continue inv_ok = all( (sum(sigbar(v)[k] * M[k][l] * sigbar(w)[l] for k in range(4) for l in range(4))) & 1 == (sum(v[k] * M[k][l] * w[l] for k in range(4) for l in range(4))) & 1 for v in labels16 for w in labels16) if inv_ok: n_inv += 1 if Omega is None: Omega = M B = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for r, x in enumerate(labels): for c, y in enumerate(labels): pairing = 0 for j in range(4): for k in range(4): pairing ^= x[j] & int(Omega[j][k]) & y[k] B[r, c] = int(pairing == 0) # sigma permutation on the 15 nonzero labels lookup = {v: i for i, v in enumerate(labels)} perm = [lookup[sigbar(v)] for v in labels] P = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for src, tgt in enumerate(perm): P[tgt, src] = 1 # y_chi and its polar hyperplane H* (F1-control geometry) cols_o = [tuple(Omega[i][j] for i in range(4)) for j in range(4)] _rk, _ker, inv_o = ram.f2_rank_ker_inv(cols_o) a_par = tuple(ram.unpack(L.to_ambient(E4[k]))[0] % 2 for k in range(4)) y_chi = ram.f2_matvec(inv_o, a_par) Hstar = [v for v in labels if (sum(v[k] * Omega[k][l] * y_chi[l] for k in range(4) for l in range(4))) & 1 == 0] return dict(labels=labels, B=B, P=P, perm=perm, n_inv=n_inv, Omega=Omega, y_chi=y_chi, Hstar=Hstar, sigbar=sigbar) def s1_arrow_algebra(th): section("S1 -- THE ARROW *-ALGEBRA (ramified 105 legs + odd places " "3/5/7 + tower)") t0 = time.time() frame = build_label_frame() B = frame["B"] legs = [(x, y) for x in range(LABEL_DIM) for y in range(LABEL_DIM) if B[x, y]] I15 = np.eye(LABEL_DIM, dtype=np.int64) J15 = np.ones((LABEL_DIM, LABEL_DIM), dtype=np.int64) dev_bbt = int(np.max(np.abs(B @ B.T - (4 * I15 + 3 * J15)))) ok_a11 = (np.array_equal(B, B.T) and bool(np.all(B.sum(axis=1) == ROW_DEGREE)) and dev_bbt == 0 and len(legs) == 105) check("A1.1 arrow set: 105 legs, row degree 7, B == B^T (arrow " "REVERSAL closes the generating set under *), " "B B^T == 4I + 3J exact (%d sigma-invariant symplectic " "choices, lex-first frozen)" % frame["n_inv"], ok_a11, "%.1f s" % (time.time() - t0)) # A1.2 generated *-algebra by exact span closure of matrix units units = set((y, x) for (x, y) in legs) # arrow x -> y is E_{y,x} units |= set((x, y) for (y, x) in units) # adjoints (reversal) changed = True rounds = 0 while changed: changed = False rounds += 1 new = set() for (a, b) in units: for (c, d) in units: if b == c and (a, d) not in units: new.add((a, d)) if new: units |= new changed = True ok_a12 = len(units) == LABEL_DIM * LABEL_DIM check("A1.2 generated *-algebra == M_15 (exact matrix-unit closure: " "%d of %d units reached in %d rounds; the incidence graph is " "connected, so the arrow algebra is the FULL matrix algebra, " "not its trace collapse)" % (len(units), LABEL_DIM ** 2, rounds), ok_a12) # A1.3 deck / two-step weight anchor (ledger T4, re-derived exact) Tm = 4 * (B @ B) ok_t = (np.array_equal(Tm, 28 * I15 + 12 * (J15 - I15)) and Fr(4, 196) == Fr(1, 49) and Fr(1, 49) == Fr(1, 7) ** 2) # (7^{-1/2})^4 exact check("A1.3 DECK ANCHOR: T = 4 B^2 == 28 I + 12 (J - I) exact " "(row sum 196 = (2*7)^2); per-leg two-step weight 4/196 == " "(7^{-1/2})^4 exact (deck multiplicity 2 per step; the leg " "classes are the v756 Kraus index set -- ledger T4, cited)", ok_t) # A1.4 odd places 3/5/7: the packet C2 slots and their composition sig3, a_f8 = th["sig3"], th["a"] ok_pack = True heads = [] for p in ODD_PLACES: A_p = (int(sig3[p]) + int(a_f8[p])) // 2 B_p = (int(sig3[p]) - int(a_f8[p])) // 2 heads.append("p=%d: (A,B)=(%d,%d), a_p=%d" % (p, A_p, B_p, int(a_f8[p]))) ok_pack &= (A_p >= 0 and B_p >= 0 and (int(sig3[p]) + int(a_f8[p])) % 2 == 0) # composition gate: M_p M_{p^k} - p^3 M_{p^{k-1}} == M_{p^{k+1}} # on both C2 characters simultaneously (sigma3 and a faces), exact viol = 0 ntrip = 0 for p in ODD_PLACES: pk = p while pk * p <= N_THETA: nxt, cur, prv = pk * p, pk, pk // p for tab in (sig3, a_f8): if (int(tab[p]) * int(tab[cur]) - p ** 3 * int(tab[prv]) != int(tab[nxt])): viol += 1 ntrip += 1 pk *= p ok_a14 = ok_pack and viol == 0 check("A1.4 odd-place packet slots: populations nonneg integers " "(%s); p^3-corrected composition EXACT on both C2 characters " "at %d prime-power steps (violations %d); anchors a_p = " "(-4, -2, 24)" % ("; ".join(heads), ntrip, viol), ok_a14 and (int(a_f8[3]), int(a_f8[5]), int(a_f8[7])) == (-4, -2, 24)) # A1.5 the KMS half-weight rule is UNIVERSAL n^{-1/2} dev_tw = max(abs(2.0 ** (-0.5 * l) - (2.0 ** l) ** -0.5) for l in range(LEVELS)) ka, masks, devm = srp.channel_masks(ALPHA_TOP) nvals = np.array([int(round(math.exp(float(core.U_ALL[i])))) for i in range(ka)], dtype=np.int64) lam = np.array([math.log(int(th["spf"][n])) for n in nvals]) mu_ward = float(np.max(np.abs(core.MU_ALL[:ka] - 2.0 * lam / np.sqrt(nvals)) / np.abs(core.MU_ALL[:ka]))) ok_a15 = dev_tw == 0.0 and devm <= 1.0e-12 and mu_ward <= 1.0e-12 check("A1.5 KMS half-weight universality: tower diag 2^{-l/2} == " "n^{-1/2} at n = 2^l exact; deployed masses MU == " "2 Lambda(n)/sqrt(n) on ALL %d events (rel %.1e); event " "half-weight w_n = MU/2" % (ka, mu_ward), ok_a15) GATE_FLAGS["algebra"] = (ok_a11 and ok_a12 and ok_t and ok_a14 and ok_a15) return dict(frame=frame, B=B, legs=legs, ka=ka, masks=masks, nvals=nvals) # ============================================= S2 the Stinespring isometry def s2_stinespring(alg): section("S2 -- THE STINESPRING ISOMETRY V + Phi(a) = V* pi(a) V " "+ exact Choi") B, legs = alg["B"], alg["legs"] scale = 1.0 / math.sqrt(ROW_DEGREE) L_ops = [] # integer matrix units for (x, y) in legs: Lm = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) Lm[y, x] = 1 L_ops.append(Lm) K_ops = [scale * Lm.astype(float) for Lm in L_ops] # unitality: EXACT integer identity Sigma_e E_{x_e x_e} = 7 I acc = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for Lm in L_ops: acc += Lm.T @ Lm ok_unital_exact = np.array_equal(acc, ROW_DEGREE * np.eye(LABEL_DIM, dtype=np.int64)) V = np.vstack(K_ops) # (105*15, 15) isometry dev_iso = float(np.max(np.abs(V.T @ V - np.eye(LABEL_DIM)))) check("B2.1 V*V = 1: EXACT integer identity Sigma_e E_{x_e x_e} == " "7 I (float stack dev %.1e) -- the v756 unitality anchor " "re-derived through THIS construction" % dev_iso, ok_unital_exact and dev_iso <= 2.0e-14) def phi(a): out = np.zeros_like(np.asarray(a, dtype=float)) for K in K_ops: out += K.T @ a @ K return out dev_one = float(np.max(np.abs(phi(np.eye(LABEL_DIM)) - np.eye(LABEL_DIM)))) ok_diag = True for y in range(LABEL_DIM): Eyy = np.zeros((LABEL_DIM, LABEL_DIM)) Eyy[y, y] = 1.0 img7 = 7.0 * phi(Eyy) ok_diag &= bool(np.max(np.abs(img7 - np.diag( B[:, y].astype(float)))) <= 1.0e-13) check("B2.2 Phi(1) = 1 (dev %.1e) and 7 Phi(E_yy) == diag(B[:,y]) " "for all 15 diagonal units (Phi restricts to K = B/7 on the " "diagonal, exact)" % dev_one, dev_one <= 2.0e-14 and ok_diag) # exact rational Choi: diagonal 1/7 at the 105 leg coordinates choi_diag = {} for (x, y) in legs: choi_diag[(y + LABEL_DIM * x)] = Fr(1, 7) ok_choi = (len(choi_diag) == 105 and all(v == Fr(1, 7) for v in choi_diag.values())) tot = sum(choi_diag.values()) check("B2.3 CHOI MATRIX exact rationals: diagonal in the matrix-unit " "basis, 105 nonzero eigenvalues each == 1/7 EXACTLY, rank " "105, trace = %s == 15 (all other coordinates exactly 0: " "PSD is STRUCTURAL, Choi = Sigma_e vec(K_e) vec(K_e)^T)" % tot, ok_choi and tot == 15) # tower extension: vec(K_e (x) I_5) pairwise orthogonal, norm^2 = 5/7 ok_ext = True for i in range(3): e = lcg(105) f = lcg(105) Ke = np.kron(K_ops[e], np.eye(LEVELS)) nrm2 = float(np.sum(Ke * Ke)) ok_ext &= abs(nrm2 - LEVELS / 7.0) <= 1.0e-14 if legs[e] != legs[f]: Kf = np.kron(K_ops[f], np.eye(LEVELS)) ok_ext &= abs(float(np.sum(Ke * Kf))) == 0.0 check("B2.4 extended Choi (Phi (x) id_tower): nonzero eigenvalue " "5/7 x 105 (vec(K_e (x) I_5) pairwise orthogonal, sampled " "exact) -- the v756 rank-105 structure re-derived", ok_ext) GATE_FLAGS["stinespring"] = (ok_unital_exact and dev_iso <= 2e-14 and dev_one <= 2e-14 and ok_diag and ok_choi and ok_ext) return dict(L_ops=L_ops, K_ops=K_ops, V=V, phi=phi) # ================================================== S3 covariance gates def s3_covariances(alg, st): section("S3 -- covariance gates: sigma / half-weight / beta=1 " "balance / Gate-0 (all exact)") B, P, legs = alg["B"], alg["frame"]["P"], alg["legs"] perm = alg["frame"]["perm"] L_ops, K_ops = st["L_ops"], st["K_ops"] # sigma: incidence invariance + per-leg isometry covariance dev_sig = int(np.max(np.abs(P @ B @ P.T - B))) leg_idx = {e: i for i, e in enumerate(legs)} ok_legperm = all((perm[x], perm[y]) in leg_idx for (x, y) in legs) dev_legcov = 0 for (x, y) in legs: lhs = P @ L_ops[leg_idx[(x, y)]] @ P.T rhs = L_ops[leg_idx[(perm[x], perm[y])]] dev_legcov = max(dev_legcov, int(np.max(np.abs(lhs - rhs)))) ok_sigma = dev_sig == 0 and ok_legperm and dev_legcov == 0 check("C3.1 SIGMA COVARIANCE exact: P B P^T == B (dev %d); the leg " "permutation e -> sigma(e) exists and P L_e P^T == " "L_sigma(e) for ALL 105 legs (dev %d) -- (Pi_sigma (x) P) V " "= V P exactly" % (dev_sig, dev_legcov), ok_sigma) # half-weight: D'U = 2^{-1/2} U D + Kraus naturality D5 = np.diag([2.0 ** (-0.5 * l) for l in range(LEVELS)]) D6 = np.diag([2.0 ** (-0.5 * l) for l in range(LEVELS + 1)]) U = np.zeros((LEVELS + 1, LEVELS)) for l in range(LEVELS): U[l + 1, l] = 1.0 dev_du = float(np.max(np.abs(D6 @ U - (2.0 ** -0.5) * U @ D5))) dev_nat = 0.0 for i in range(0, 105, 17): # 7 sampled legs Ke5 = np.kron(K_ops[i], np.eye(LEVELS)) Dfull = np.kron(np.eye(LABEL_DIM), D5) dev_nat = max(dev_nat, float(np.max(np.abs( Ke5 @ Dfull - Dfull @ Ke5)))) Ke6 = np.kron(K_ops[i], np.eye(LEVELS + 1)) Ufull = np.kron(np.eye(LABEL_DIM), U) dev_nat = max(dev_nat, float(np.max(np.abs( Ke6 @ Ufull - Ufull @ Ke5)))) ok_half = dev_du <= 1.0e-14 and dev_nat == 0.0 check("C3.2 HALF-WEIGHT COVARIANCE: D'U == 2^{-1/2} U D (dev %.1e); " "Kraus multipliers commute with the half-weight and are " "natural for the degree-2 shift (dev %.1e, structurally " "exact: the legs act on the label factor only)" % (dev_du, dev_nat), ok_half) # beta = 1 detailed balance: superop symmetric + KMS density fixed S = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for (x, y) in legs: S[x, y] += 1 # 7 S = B on diag units ok_sym = np.array_equal(S, S.T) acc = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for Lm in st["L_ops"]: acc += Lm @ Lm.T # Sigma L L^T = diag(coldeg) ok_dens = np.array_equal(acc, ROW_DEGREE * np.eye(LABEL_DIM, dtype=np.int64)) # exact Fractions: Phi_*(I/15) = (1/(7*15)) Sigma L (I) L^T = I/15 ok_kms = ok_dens and Fr(1, 7 * 15) * 7 == Fr(1, 15) check("C3.3 BETA = 1 DETAILED BALANCE exact: weighted superoperator " "symmetric (7 S == B == B^T); Sigma_e L_e L_e^T == 7 I " "(column degree) => the KMS density (I/15) (x) " "diag(2^{-l})/Z is PRESERVED exactly (Fractions)", ok_sym and ok_kms) # Gate-0: label-blind periodic subalgebra fixed dev_g0 = 0.0 for l in range(LEVELS): m = np.zeros((LEVELS, LEVELS)) m[l, l] = 1.0 target = np.kron(np.eye(LABEL_DIM), m) img = np.zeros_like(target) for K in K_ops: Ke = np.kron(K, np.eye(LEVELS)) img += Ke.T @ target @ Ke dev_g0 = max(dev_g0, float(np.max(np.abs(img - target)))) ok_g0 = dev_g0 <= 1.0e-14 check("C3.4 GATE-0 COMPATIBILITY: Phi (x) id fixes the label-blind " "periodic subalgebra (dev %.1e)" % dev_g0, ok_g0) GATE_FLAGS["covariance"] = ok_sigma and ok_half and ok_sym \ and ok_kms and ok_g0 # ================================================ S4 Choi census on family def rational_psd(mat): """exact PSD decision for a symmetric Fraction matrix via pivoted LDL^T (returns (is_psd, witness)).""" n = len(mat) M = [[Fr(mat[i][j]) for j in range(n)] for i in range(n)] idx = list(range(n)) for step in range(n): piv, pval = -1, Fr(0) for i in range(step, n): if M[i][i] > pval: piv, pval = i, M[i][i] if piv < 0: for i in range(step, n): if M[i][i] < 0: return False, ("negative diagonal", idx[i], M[i][i]) for i in range(step, n): for j in range(step, n): if M[i][j] != 0: return False, ("zero diag, nonzero off", idx[i], M[i][j]) return True, None M[step], M[piv] = M[piv], M[step] for r in range(n): M[r][step], M[r][piv] = M[r][piv], M[r][step] idx[step], idx[piv] = idx[piv], idx[step] d = M[step][step] for i in range(step + 1, n): f = M[i][step] / d for j in range(step, n): M[i][j] -= f * M[step][j] return True, None def s4_choi_census(alg, st): section("S4 -- Choi census Phi(a*a) >= 0 on the frozen generating " "family (exact)") L_ops, phi = st["L_ops"], st["phi"] B = alg["B"] # (i) all 105 single arrows: Phi(g*g) = Phi(E_xx) = diag(B[:,x])/7 ok_single = True for (x, _y) in alg["legs"]: col = B[:, x] ok_single &= bool(np.all(col >= 0)) # exact diag, trivially PSD check("D4.1 all 105 single-arrow generators: Phi(g*g) == " "diag(B[:, x_e])/7 -- nonnegative diagonal, PSD EXACT " "(rational)", ok_single) # (ii) 12 LCG +-1 leg combinations: exact integer Gram factorization ok_combo = True ok_ldl = True max_ward = 0.0 for t in range(12): sel = [] used = set() while len(sel) < 15: e = lcg(105) if e not in used: used.add(e) sel.append(e) a = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for e in sel: a += (1 if lcg(2) == 0 else -1) * L_ops[e] # exact: 7 Phi(a*a) = M^T M with M = vstack(a L_e) Mstack = np.vstack([a @ Lm for Lm in L_ops]) G = Mstack.T @ Mstack # integer, PSD by Gram form ward = float(np.max(np.abs(7.0 * phi((a.T @ a).astype(float)) - G.astype(float)))) max_ward = max(max_ward, ward) ok_combo &= (ward <= 1.0e-10 and np.array_equal(G, G.T)) if t < 3: psd, wit = rational_psd([[Fr(int(G[i, j]), 7) for j in range(LABEL_DIM)] for i in range(LABEL_DIM)]) ok_ldl &= psd if not psd: print(" LDL WITNESS (combo %d): %s" % (t, (wit,))) check("D4.2 12 LCG +-1 leg combinations: 7 Phi(a*a) == M^T M " "EXACT integer Gram factorization (max float ward %.1e); " "PSD is STRUCTURAL; exact-rational LDL pivots >= 0 on 3 " "combos" % max_ward, ok_combo and ok_ldl) GATE_FLAGS["choi_census"] = ok_single and ok_combo and ok_ldl GATE_FLAGS["kill"] = not (ok_single and ok_combo and ok_ldl) # =========================================== S5 theta / packet event layer def sparse_theta_terms(kind, cap): out = [] if kind in ("th3", "th4"): out.append((0, 1)) n = 1 while n * n <= cap: c = 2 if kind == "th3" else 2 * ((-1) ** n) out.append((n * n, c)) n += 1 else: o = 1 while o * o <= cap: out.append((o * o, 2)) o += 2 return out def sparse_mul(dense, terms): out = np.zeros_like(dense) for e, c in terms: if e == 0: out += c * dense else: out[e:] += c * dense[:-e] return out def s5_theta_layer(): section("S5 -- packet layer rebuilt exact: sigma3, class thetas, f8 " "(eta recurrence)") t0 = time.time() sig3 = np.zeros(N_THETA + 1, dtype=np.int64) for d in range(1, N_THETA + 1): sig3[d::d] += d ** 3 spf = np.zeros(N_THETA + 1, dtype=np.int64) for p in range(2, N_THETA + 1): if spf[p] == 0: spf[p::p] = np.where(spf[p::p] == 0, p, spf[p::p]) SCAP = 2 * N_THETA t3 = sparse_theta_terms("th3", SCAP) t4 = sparse_theta_terms("th4", SCAP) one = np.zeros(SCAP + 1, dtype=np.int64) one[0] = 1 p3 = [one] p4 = [one] for _ in range(8): p3.append(sparse_mul(p3[-1], t3)) p4.append(sparse_mul(p4[-1], t4)) m53 = p3[5].copy() for _ in range(3): m53 = sparse_mul(m53, t4) m35 = p4[5].copy() for _ in range(3): m35 = sparse_mul(m35, t3) num0 = p3[8] + m53 + m35 + p4[8] num2 = p3[8] - m53 - m35 + p4[8] ok_div = bool(np.all(num0 % 4 == 0) and np.all(num2 % 4 == 0)) Th0 = (num0 // 4)[::2][:N_THETA + 1].copy() Th2 = (num2 // 4)[::2][:N_THETA + 1].copy() TCAP = 8 * N_THETA t2 = sparse_theta_terms("th2", TCAP) acc = np.zeros(TCAP + 1, dtype=np.int64) acc[0] = 1 for _ in range(8): acc = sparse_mul(acc, t2) ok_div &= bool(np.all(acc[::8][:N_THETA + 1] % 4 == 0)) Th1 = (acc[::8][:N_THETA + 1] // 4).copy() Th3 = Th1 tot = Th0 + Th1 + Th2 + Th3 ok_glue = (bool(np.all(tot[1:] == 240 * sig3[1:])) and (Th0[1], Th1[1], Th2[1], Th3[1]) == (52, 64, 60, 64)) check("E5.1 theta layer exact: heads (52, 64, 60, 64); glue " "identity Sum Th_j == 240 sigma3 for ALL n <= %d" % N_THETA, ok_div and ok_glue, "%.1f s" % (time.time() - t0)) tk = np.zeros(N_THETA + 1, dtype=np.int64) for d in range(2, N_THETA + 1, 2): tk[d::d] += d * (4 + (4 if d % 4 == 0 else 0)) g = np.zeros(N_THETA, dtype=np.int64) g[0] = 1 for n in range(1, N_THETA): s = int(np.dot(tk[1:n + 1], g[n - 1::-1])) q, r = divmod(-s, n) assert r == 0 g[n] = q a_f8 = np.zeros(N_THETA + 1, dtype=np.int64) a_f8[1:] = g odd = np.arange(1, N_THETA + 1, 2) ok_f8 = ((int(a_f8[3]), int(a_f8[5]), int(a_f8[7])) == (-4, -2, 24) and bool(np.all(a_f8[2::2] == 0)) and bool(np.all(Th0[odd] - Th2[odd] == -8 * a_f8[odd]))) check("E5.2 f8 exact (eta recurrence): a_p anchors (-4, -2, 24); " "a(even) == 0 (conductor 8: ramified channel EMPTY -- the " "structural kill of ramified events in the f8 channel); " "C2 link Th0 - Th2 == -8 f8 on all odd n", ok_f8) return dict(sig3=sig3, a=a_f8, spf=spf, Th=(Th0, Th1, Th2, Th3)) # ============================================ S6 the four channels (decider) def s6_channels(th, alg): section("S6 -- THE FOUR CHARACTER CHANNELS OF THE ONE MAP " "(the GL1 identification decider)") sig3, a_f8, spf = th["sig3"], th["a"], th["spf"] ka, masks, nvals = alg["ka"], alg["masks"], alg["nvals"] U_ev = np.array([float(core.U_ALL[i]) for i in range(ka)]) MU_ev = np.array([float(core.MU_ALL[i]) for i in range(ka)]) # per-event channel multipliers from the packet characters mult_gl1 = np.ones(ka) mult_c4 = np.zeros(ka) mult_f8 = np.zeros(ka) mult_tw = np.zeros(ka) ok_del = True for i in range(ka): n = int(nvals[i]) if n % 2 == 0: continue # killed BY the algebra p = int(spf[n]) k = 0 m = n while m % p == 0: m //= p k += 1 chi = -1.0 if ((n - 1) // 2) % 2 else 1.0 Tk = int(a_f8[n]) - (p ** 3 * int(a_f8[n // (p * p)]) if k >= 2 else 0) tk = Tk / p ** (1.5 * k) ok_del &= abs(tk) <= 2.0 + 1.0e-12 mult_c4[i] = chi mult_f8[i] = tk mult_tw[i] = chi * tk check("F6.1 channel multipliers: chi4 = (-1)^{(n-1)/2} (odd), " "f8 = Hecke-primitive Satake t_k = (a_{p^k} - p^3 " "a_{p^{k-2}})/p^{3k/2}, twist = product; ramified events " "killed BY the packet algebra (C2-symmetric + glue-uniform " "slots -> character value 0); Deligne |t_k| <= 2 on every " "odd event", ok_del) # exact Satake anchors (Fractions): T_k == Chebyshev-scaled recursion ok_ex = True for p, kmax in ((3, 9), (5, 6), (7, 5)): Tm1, Tc = Fr(2), Fr(int(a_f8[p])) for k in range(1, kmax + 1): pk = p ** k ref = Fr(int(a_f8[pk]) - (p ** 3 * int(a_f8[pk // p ** 2]) if k >= 2 else 0)) ok_ex &= (Tc == ref) Tm1, Tc = Tc, Fr(int(a_f8[p])) * Tc - p ** 3 * Tm1 # Eisenstein co-channel of the SAME primitive element ok_eis = True for p, kmax in ((3, 9), (5, 6), (7, 5)): for k in range(1, kmax + 1): pk = p ** k prim = int(sig3[pk]) - (p ** 3 * int(sig3[pk // p ** 2]) if k >= 2 else 0) ok_eis &= (prim == p ** (3 * k) + 1) check("F6.2 EXACT anchors (Fractions): primitive T_k == the scaled " "Chebyshev recursion T_{k+1} = a_p T_k - p^3 T_{k-1} at " "p = 3 (k <= 9), 5 (k <= 6), 7 (k <= 5); the SAME primitive " "element's trivial character == p^{3k} + 1 (the weight-4 " "Eisenstein co-channel: one element, two characters -- the " "packet register IS the (E, f8) pair)", ok_ex and ok_eis) # the incidence channel fixes the automorphic (V-trivial) sectors B = alg["B"] I15 = np.eye(LABEL_DIM, dtype=np.int64) ok_fix = bool(np.all(B.sum(axis=1) == ROW_DEGREE)) poly = (B - 7 * I15) @ (B - 2 * I15) @ (B + 2 * I15) ok_spec = int(np.max(np.abs(poly))) == 0 trB = int(np.trace(B)) # multiplicities: 7 once; +2 (a) and -2 (b): a+b = 14, 7+2a-2b = trB a_m = (trB - 7 + 2 * 14) // 4 b_m = 14 - a_m check("F6.3 the incidence channel on the sectors: K 1 = 1 exact " "(row degree 7 -- the automorphic V-trivial sectors pass " "through Phi UNCHANGED); (B - 7)(B - 2)(B + 2) == 0 exact " "(nontrivial V-sectors contracted by +-2/7, multiplicities " "%d/%d)" % (a_m, b_m), ok_fix and ok_spec and a_m + b_m == 14) # window continua: deployed GL1 + the certified Gamma_R rule c_cont = srp.continuum_lags(M_TOP) c_full = c_cont.copy() for cnl in ("ro", "re", "sp", "in"): c_full = c_full + srp.atom_channel_lags(ALPHA_TOP, M_TOP, masks[cnl]) rule = {nm: cfp.rule_arch_lags(mus, q) for nm, (mus, q, _p) in cfp.SECTOR_DATA.items()} dev_r = float(np.max(np.abs( rule["chi4"] - fsc.arch_lags_general( M_TOP, DGRID, 1.5, 2.0, math.log(4.0 / math.pi) - fsc.EULER)))) check("F6.4 continua from the certified closed rule (read-only): " "chi4 rule instance == sibling kernel (dev %.1e); f8/twist " "= {mu = 3/2, 5/2; q = 8/16} (duplication + Fricke " "conductor certified in the parent probes, cited)" % dev_r, dev_r <= 1.0e-9) # assemble the four channel windows from THE SAME event stream def window(mult_vec, continuum): m = mult_vec != 0.0 atoms, _d = core.atom_lags_at(ALPHA_TOP, M_TOP, U_ev[m], (MU_ev * mult_vec)[m]) return continuum + atoms w_gl1 = window(mult_gl1, c_cont) w_c4 = window(mult_c4, rule["chi4"]) w_f8 = window(mult_f8, rule["f8"]) w_tw = window(mult_tw, rule["twist"]) # I1 GL1 == deployed Weil window (the D0 landing, machine precision) dev_gl1 = float(np.max(np.abs(w_gl1 - c_full)) / np.max(np.abs(c_full))) ok_i1 = check("F6.5 I1 GL1 IDENTIFICATION: the GL1 channel of Phi on " "the packet stream == the DEPLOYED Weil window " "(rel dev %.1e <= 1e-12) -- the parent's D0 landing " "through the Stinespring form" % dev_gl1, dev_gl1 <= WARD_BAR) # I2 twisted channels == sibling-constructed sector combs # independent float Chebyshev path (sibling s2 construction) primes = [p for p in range(3, N_THETA + 1, 2) if int(spf[p]) == p] sib = {} for nm, apf in (("f8", lambda p: float(a_f8[p])), ("tw", lambda p: (float(a_f8[p]) * (1.0 if p % 4 == 1 else -1.0)))): pos, mas = [], [] for p in primes: u1 = math.log(p) if u1 >= 2.0 * ALPHA_TOP: break t1 = apf(p) / p ** 1.5 tkm1, tkk = 2.0, t1 k = 1 u = u1 while u < 2.0 * ALPHA_TOP: pos.append(u) mas.append(2.0 * tkk * math.log(p) / p ** (0.5 * k)) tkm1, tkk = tkk, t1 * tkk - tkm1 k += 1 u = k * u1 sib[nm] = (np.array(pos), np.array(mas)) # mass cross-dev on matched positions dev_mass = 0.0 for nm, mv in (("f8", mult_f8), ("tw", mult_tw)): mask = mv != 0.0 mine = np.stack([U_ev[mask], (MU_ev * mv)[mask]], axis=1) theirs = np.stack(sib[nm], axis=1) mine = mine[np.lexsort((mine[:, 1], mine[:, 0]))] theirs = theirs[np.lexsort((theirs[:, 1], theirs[:, 0]))] if mine.shape != theirs.shape: dev_mass = np.inf else: dev_mass = max(dev_mass, float(np.max(np.abs(mine - theirs)))) at4, _ = core.atom_lags_at( ALPHA_TOP, M_TOP, U_ev[mult_c4 != 0.0], (MU_ev * mult_c4)[mult_c4 != 0.0]) sgn = np.where(nvals % 4 == 1, 1.0, -1.0) oddm = nvals % 2 == 1 at4_sib, _ = core.atom_lags_at(ALPHA_TOP, M_TOP, U_ev[oddm], (MU_ev * sgn)[oddm]) dev_c4 = float(np.max(np.abs(at4 - at4_sib))) atf_sib, _ = core.atom_lags_at(ALPHA_TOP, M_TOP, *sib["f8"]) att_sib, _ = core.atom_lags_at(ALPHA_TOP, M_TOP, *sib["tw"]) dev_f8 = float(np.max(np.abs(w_f8 - (rule["f8"] + atf_sib))) / np.max(np.abs(w_f8))) dev_tw = float(np.max(np.abs(w_tw - (rule["twist"] + att_sib))) / np.max(np.abs(w_tw))) ok_i2 = check("F6.6 I2 SECTOR IDENTIFICATION: channel outputs == " "sibling sector objects -- chi4 comb dev %.1e; " "f8/twist masses vs independent Chebyshev path " "dev %.1e; f8 window rel %.1e; twist window rel " "%.1e (all <= 1e-12 / 1e-9 mass bar)" % (dev_c4, dev_mass, dev_f8, dev_tw), dev_c4 <= 1.0e-12 and dev_mass <= 1.0e-9 and dev_f8 <= WARD_BAR and dev_tw <= WARD_BAR) # I3 the four ladders PSD (one CP map, four positive sector outputs) def ladder(lag): out = [] for M in RUNGS: T = sla.toeplitz(lag[:M]) lam = float(sla.eigvalsh(T, subset_by_index=[0, 0])[0]) out.append((M, lam, float(sla.norm(T, 2)))) return out lads = {"GL1": ladder(w_gl1), "chi4": ladder(w_c4), "f8": ladder(w_f8), "twist": ladder(w_tw)} print(" PSD ladders (lambda_min per rung, X = M/64):") psd = {} for nm, lad in lads.items(): psd[nm] = all(lam >= -PSD_BAR * nrm for _M, lam, nrm in lad) print(" %-5s | %s [%s]" % (nm, " | ".join("%+.2e" % lam for _M, lam, _n in lad), "PSD" if psd[nm] else "NEG")) g0, g1 = lads["GL1"][0][1], lads["GL1"][-1][1] ok_anchor = (abs(g0 - GL1_ANCHOR[0]) <= 0.05 * GL1_ANCHOR[0] and abs(g1 - GL1_ANCHOR[1]) <= 0.05 * GL1_ANCHOR[1]) ok_i3 = check("F6.7 I3 all four channels PSD on all %d rungs; GL1 " "margins %.3e (X=4) / %.3e (X=10) match the parent " "anchors within 5%% -- FOUR sector windows as the " "OUTPUT of ONE Stinespring map + four characters" % (len(RUNGS), g0, g1), all(psd.values()) and ok_anchor) print(" (typed: chi4/f8/twist PSD reflects unproven GRH-type " "expectations at finite window depth -- consistency " "measurement, NOT a theorem; NO RH/GRH claim)") GATE_FLAGS["identification"] = ok_i1 and ok_i2 and ok_i3 return dict(lads=lads) # ==================================================== S7 must-fail controls def s7_controls(th, alg, st): section("S7 -- must-fail controls") B, legs = alg["B"], alg["legs"] L_ops = st["L_ops"] # C1 non-isometric V: drop the first leg acc = np.zeros((LABEL_DIM, LABEL_DIM), dtype=np.int64) for Lm in L_ops[1:]: acc += Lm.T @ Lm deficit = ROW_DEGREE * np.eye(LABEL_DIM, dtype=np.int64) - acc x0 = legs[0][0] fired1 = (int(deficit[x0, x0]) == 1 and int(np.sum(np.abs(deficit))) == 1) CONTROL_FIRED["C1"] = fired1 check("G7.1 C1 NON-ISOMETRIC V FIRES: dropping leg (%d -> %d) " "breaks unitality exactly -- Phi(1) deficit == 1/7 at the " "source label (exact integer 1 of 7)" % (legs[0][0], legs[0][1]), fired1) # C2a LCG re-target scramble (row degree preserved) Bs = np.zeros_like(B) for x in range(LABEL_DIM): tgt = set() while len(tgt) < ROW_DEGREE: tgt.add(lcg(LABEL_DIM)) for y in tgt: Bs[x, y] = 1 P = alg["frame"]["P"] asym = int(np.sum(np.abs(Bs - Bs.T))) dev_sig = int(np.max(np.abs(P @ Bs @ P.T - Bs))) unital_kept = bool(np.all(Bs.sum(axis=1) == ROW_DEGREE)) fired2a = unital_kept and asym > 0 and dev_sig > 0 check("G7.2 C2a SCRAMBLED LEGS FIRE: LCG re-targeting keeps row " "degree 7 (unitality survives -- the honesty point) but " "breaks the involution closure (|B - B^T| = %d), sigma " "covariance (dev %d) and detailed balance (superop " "asymmetric)" % (asym, dev_sig), fired2a) # C2b v756 one-edge mutation (minimal covariance break) Bm = B.copy() row = 0 inc = [c for c in range(LABEL_DIM) if B[row, c] == 1] absent = [c for c in range(LABEL_DIM) if B[row, c] == 0] Bm[row, inc[0]] = 0 Bm[row, absent[0]] = 1 dev_sig_m = int(np.max(np.abs(P @ Bm @ P.T - Bm))) dev_bal_m = int(np.max(np.abs(Bm - Bm.T))) fired2b = (bool(np.all(Bm.sum(axis=1) == ROW_DEGREE)) and (dev_sig_m > 0 or dev_bal_m > 0)) CONTROL_FIRED["C2"] = fired2a and fired2b check("G7.3 C2b ONE-EDGE MUTATION FIRES (v756 replay): CP/unital " "kept, sigma dev %d, balance dev %d" % (dev_sig_m, dev_bal_m), fired2b) # C3 the naive linear pushforward == negative Choi eigenvalue (F1) sig3, a_f8 = th["sig3"], th["a"] Th0, Th1, Th2, Th3 = th["Th"] ka, masks, nvals = alg["ka"], alg["masks"], alg["nvals"] chan = np.empty(ka, dtype="U2") for c, idx in masks.items(): chan[idx] = c sectors = [(eps, vc, jc) for eps in (+1, -1) for vc in ("v1", "v7") for jc in (0, 1, 2)] W = np.array([float(core.MU_ALL[i]) / 2.0 for i in range(ka)]) tvals = np.zeros((ka, 12)) for i in range(ka): n = int(nvals[i]) E = 240.0 * float(sig3[n]) c2m = float(a_f8[n]) / float(sig3[n]) mh = (1.0, (float(Th0[n]) - float(Th2[n])) / E, (float(Th0[n]) - float(Th1[n]) + float(Th2[n]) - float(Th3[n])) / E) is_ro = chan[i] == "ro" for k, (eps, vc, jc) in enumerate(sectors): c2f = 1.0 if eps == +1 else c2m vf = -1.0 / 7.0 if (is_ro and vc == "v7") else 1.0 tvals[i, k] = c2f * vf * mh[jc] lin = (W @ tvals) / float(W.sum()) kmin = int(np.argmin(lin)) mn_lin = float(lin[kmin]) sec_min = sectors[kmin] # exact leg: unit weights, n <= 300, Fractions exact_min = None for k, (eps, vc, jc) in enumerate(sectors): totx = Fr(0) for i in range(ka): n = int(nvals[i]) if n > EXACT_DEPTH: continue E = 240 * int(sig3[n]) c2f = Fr(1) if eps == +1 else Fr(int(a_f8[n]), int(sig3[n])) vf = (Fr(-1, 7) if (chan[i] == "ro" and vc == "v7") else Fr(1)) mh = (Fr(1), Fr(int(Th0[n]) - int(Th2[n]), E), Fr(int(Th0[n]) - int(Th1[n]) + int(Th2[n]) - int(Th3[n]), E)) totx += c2f * vf * mh[jc] if exact_min is None or totx < exact_min: exact_min = totx fired3 = (mn_lin < -5.0e-2 and sec_min == F1_SECTOR and exact_min < 0) CONTROL_FIRED["C3"] = fired3 check("G7.4 C3 NAIVE LINEAR PUSHFORWARD FIRES: on the abelian " "packet algebra the Choi matrix of a functional IS its " "sector diagonal -- min sector value %+.4e at (eps=%+d, %s, " "j=%d) < 0 (== the parent's F1 -6.6e-2 anchor) and the " "exact leg (Fractions, n <= %d) = %.4f < 0 EXACTLY: the " "linear transport fails the Choi census exactly where it " "failed the state property" % (mn_lin, sec_min[0], sec_min[1], sec_min[2], EXACT_DEPTH, float(exact_min)), fired3) GATE_FLAGS["controls"] = fired1 and fired2a and fired2b and fired3 # ======================================================== S8 verdict def s8_verdict(): section("S8 -- VERDICT + recommended contract text") ok_alg = GATE_FLAGS.get("algebra", False) ok_st = GATE_FLAGS.get("stinespring", False) ok_cov = GATE_FLAGS.get("covariance", False) ok_census = GATE_FLAGS.get("choi_census", False) ok_id = GATE_FLAGS.get("identification", False) ok_ctl = GATE_FLAGS.get("controls", False) kill = GATE_FLAGS.get("kill", False) or not ok_st if kill: verdict = "CP-INTERTWINER-IMPOSSIBLE" elif ok_alg and ok_st and ok_cov and ok_census and ok_id and ok_ctl: verdict = "CP-INTERTWINER-EXISTS" else: verdict = "CP-INTERTWINER-PARTIAL" print("\nVERDICT: %s" % verdict) if verdict == "CP-INTERTWINER-EXISTS": print(""" FINDING (finite level): the carrier intertwiner EXISTS in Stinespring form. Phi(a) = V* pi(a) V with V the 105-leg isometry (Sigma V*V = 1 exact) and pi the arrow representation is CP by construction, unital exactly, and covariant for sigma, deck, the KMS half-weight and beta=1 detailed balance -- all exact gates. Its four automorphic character channels applied to the ONE packet event stream land on the four sector windows (deployed GL1 Weil at machine precision; chi4 / f8 / twist on their Gamma_R-rule objects), each PSD on the full rung ladder. Demand (3) of PRIME.POSITIVE_DESCENT.01 is finite-level solved: positivity transport = Stinespring transport, and the naive linear pushforward's F1 failure is now typed as a NEGATIVE CHOI EIGENVALUE (control C3). STILL MISSING (the infinite-level version): (i) a compatible family V_X along the window net (the X-indexed dilations must form an inductive system with isometric connecting maps -- the net properties measured by the CP-extension gate, CPGATE-UNDECIDED-FALLING margins); (ii) normality/continuity of the limit map on the inductive-limit operator system (the v780 Z1-COMPACTNESS frame supplies the compactness demand); (iii) identification of the limit GL1 channel with the critical-line Weil functional -- which contains RH and is NOT claimed.""") print(""" RECOMMENDED CONTRACT TEXT -- PRIME.CP.INTERTWINER.01 (report only): Object: the finite-level carrier intertwiner Phi(a) = V* pi(a) V on the arrow *-algebra M_15 (x) C[tower] (x) (packet slots at odd places), V = the 105-leg Kraus stack (unitality exact), involution = arrow reversal, KMS half-weights 7^{-1/2} per leg / n^{-1/2} universal. Certified at finite level: CP/unitality (exact Choi, rank 105, eigenvalue 1/7); sigma/deck/half-weight/beta=1 covariances exact; Choi census on the generating family exact (integer Gram factorization); the four automorphic channels of the one map land on the deployed GL1 Weil window (machine precision) and the chi4/f8/twist Gamma_R-rule windows (PSD on X = 4..10). Demands (open): D1 the X-compatible dilation family and its inductive limit (with the CPGATE margin trends as the honest obstruction data); D2 normal extension on the Z1-COMPACTNESS limit object (v780); D3 the limit identification with the critical-line Weil functional (contains RH -- fenced). Kill: a finite positive packet whose required GL1 intertwiner fails the exact Choi census structurally.""") return verdict def main(): print("PRIME.CP.INTERTWINER.01 -- the carrier intertwiner in " "Stinespring form") print("started %s" % time.strftime("%Y-%m-%d %H:%M:%S")) g0_firewall() th = s5_theta_layer() alg = s1_arrow_algebra(th) st = s2_stinespring(alg) s3_covariances(alg, st) s4_choi_census(alg, st) s6_channels(th, alg) s7_controls(th, alg, st) verdict = s8_verdict() _LAST["verdict"] = verdict nfail = sum(1 for _n, ok in CHECKS if not ok) print("\nRESULT: %d/%d CHECKS PASSED%s (%.1f s)" % (len(CHECKS) - nfail, len(CHECKS), "" if nfail == 0 else "; FAILURES: %s" % ", ".join(n for n, ok in CHECKS if not ok), time.time() - T0)) return 0 if (nfail == 0 and verdict == "CP-INTERTWINER-EXISTS") else 1 def run(): """run_all entry point (v757 precedent): expected pattern 29/29 with verdict CP-INTERTWINER-EXISTS.""" rc = main() n_pass = sum(1 for _n, ok in CHECKS if ok) fails = [n for n, ok in CHECKS if not ok] v = _LAST.get("verdict", "") ok = (rc == 0 and n_pass == len(CHECKS) == 29 and not fails and v == "CP-INTERTWINER-EXISTS") print("\n[%s] PATTERN GATE: expected 29/29 with verdict " "CP-INTERTWINER-EXISTS; got %d/%d, fails: %s, verdict: %s" % ("PASS" if ok else "FAIL", n_pass, len(CHECKS), fails or "none", v)) print("\nCOMBINED ADJUDICATION: %s -- CP-INTERTWINER-EXISTS: the " "carrier intertwiner exists in Stinespring form Phi = V* pi V " "from the 105 Kraus legs (unitality exact; arrow *-algebra = " "the full M_15; Choi exact-rational with 105 eigenvalues 1/7); " "all covariances exact; the four automorphic channels of the " "ONE map land on the deployed GL1 Weil window (rel 6.0e-16) " "and the chi4/f8/twist Gamma_R-rule windows, all PSD; the " "ramified emptiness is structural; the v791 F1 failure is " "retyped as a negative Choi eigenvalue. The infinite-level " "steps (dilation family, normality on the Z1-COMPACTNESS " "object, the limit identification -- which contains RH) stay " "typed demands D1-D3. NO RH claim." % ("PASS" if ok else "FAIL")) return 0 if ok else 1 if __name__ == "__main__": raise SystemExit(run())