#!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""v804 -- PRIME.CARRIER.GRAY.01: the affine (Gray) register-to-carrier identification EXISTS, exactly respecting the v786 Packet480 kill, one probe (23/23 checks, controls 3/3, ~1 s; discovery probe prime_carrier_gray_probe.py, 2026-08-06, verdict GRAY-INTERTWINER-EXISTS; FROZEN_SPEC v2 SHA-hashed -- ONE declared run-1 -> run-2 control repair, carried verbatim: the C2 scramble drew fiber phases from the degenerate lcg(4) pure-rotation stream, which is deck-covariant by construction, so run-1's must-fire control tested nothing; repaired to well-mixed non-rotation permutations, no gate or construction change). THE THREE LAYERS: (1) the GRAY MAP encodes C2 x mu4 affinely into the R-class torsor A (regular Z4 x Z2 affine action, r affine NOT linear, the r-orbit of the origin IS the Gray sequence 00-01-11-10 -- one mu4 step = ONE sign-flip generator); it is NOT a group isomorphism and none is demanded (#{g^2 = 1} = 4 vs 8; ALL 64 homomorphisms Z4 x Z2 -> F2^3 have image <= 4 -- the v786 kill (exponent 8 vs 2) is RESPECTED, the encoding lives inside the maximal canonical action , C3 replays the v786 census live: |G| = 768, no order-8 element); (2) the outer map C2 x mu4 x V -> A x V is a 128 <-> 128 bijection on the R sector, with the chi_NSR split re-derived as the EXACT adjoint/spinor split (112 integer roots = 7 NS classes, 128 spinor roots = 8 R classes; A an origin-free affine coset of ker(a) ~ F2^3); (3) the fiber family W_alpha (4 Gaussian J-lines x 4 mu4 phases per R fiber, lex-frozen chart) is DECK-COVARIANT exactly (J = phase translation m -> m + 1, zero defect on all 8 x 16 basis points), sigma-covariant up to a torsor twist S_alpha in T = Z4^4 x S4 with the measured mu4-COCYCLE CLASS TRIVIAL (all phase sums 0 mod 4 on the sigma-fixed classes; the residual twist is a pure Z3 line 3-cycle, NOT a projective obstruction), chart-independent (3 LCG re-choices), and KMS-compatible (commutes with the tower half-weight exactly). THE PAYOFF: W_glob is a 128 x 128 permutation unitary, V_ext = V (x) W_glob an exact isometry extending the certified v801 Stinespring map, the GL1 multiplier stays EXACTLY 1 on every deployed event, and the GL1 window assembled through the extension == the deployed Weil window at rel 6.0e-16. STILL MISSING (typed demands): D1 the odd-place fiber charts, D2 the residual Z3 line twist as crossed-product structure, D3 the infinite-level CP demands of PRIME.CP.INTERTWINER.01 (unchanged). ROOTCLASS-MIXED (v775) binding: register/carrier bookkeeping, no matter semantics. No marker move, NO RH claim. Python-only per GATE.WOLFRAM.02. PROVENANCE: discovery probe prime_carrier_gray_probe.py (2026-08-06, 23/23, ~0.1 s, GRAY-INTERTWINER-EXISTS; the declared v1 -> v2 control repair carried verbatim in the frozen spec below); re-run identically at promotion. Promoted verbatim; the machinery imports (v563/v755/v738 read-only) resolve against the verification directory and experiments/tfpt-discovery on sys.path -- exactly the probe's own import graph; a module-level _LAST verdict capture inserted at the single verdict assignment (v791 precedent); numbers unchanged; run() encodes the pattern (v757 precedent). Original prime_carrier_gray_probe.py docstring (verbatim): prime_carrier_gray_probe -- PRIME.CARRIER.GRAY.01: the register-to- carrier identification via the GRAY (affine) encoding, built to RESPECT the Packet480 kill (v786): the kill killed a GROUP isomorphism (exponent 8 vs exponent 2); the repair is AFFINE, matching the certified torsor structure of the R classes. THE THREE LAYERS (frozen): 1 THE GRAY MAP: gamma: Z4 -> F2^2 (0 -> 00, 1 -> 01, 2 -> 11, 3 -> 10); on F2^3 with coordinates (x, y, s): r(x, y, s) = (y, x + 1, s) and u(x, y, s) = (x, y, s + 1). Gates: r^4 = 1, u^2 = 1, ru = ur, ~ Z4 x Z2 acts REGULARLY on the 8 points; r is affine NOT linear (r(0) != 0, linear part = the swap, order 2); the r-orbit of 0 is the Gray sequence and consecutive Gray codes differ in EXACTLY one bit (incl. wrap) -- one step = one sign-flip generator, the Gamma-torsor step rule. 2 THE OUTER MAP: C2 x mu4 x V -> A x V, both sides 128 = the R sector (8 classes x 16 roots). A = the 8 R classes, built as MY OWN COPY from chi_NSR in the v738 frame: a_par = the parity functional, R = {v : a.v = 1} (8 classes, 0 not in R -- an origin-free AFFINE coset of ker(a) ~ F2^3). Gates: the encoding enc(s, k) = r0 + gray(k).(b1, b2) + s.b3 is a bijection C2 x mu4 -> A; the outer map is a 128 <-> 128 bijection; it is NOT a group isomorphism (Z4 x Z2 has 4 square roots of 1, F2^3 has 8; every homomorphism Z4 x Z2 -> F2^3 has image of order <= 4: never bijective -- exact census) but IS a bijection intertwining the cyclic mu4 phase with the affine order-4 r. V786-RESPECT (typed): v786 killed the demand that (Z/480)^x (exponent 8) act linearly/faithfully on the 128 spinor roots (G = has no order-8 element); the maximal canonical action was the graded image ~ Z4 x Z2 -- EXACTLY the register group encoded here. Linearity was demanded at the wrong place: the R classes are an affine torsor (no canonical origin, no group law); the Gray map is an affine torsor encoding, living strictly inside the v786 survivor. 3 THE 16-FIBER (the hard part): in the v738 frame the 240 E8 roots reduce 15 x 16 onto the nonzero classes of V = L/(1+i)L; the 112 integer roots fill the 7 NS classes and the 128 spinor roots fill the 8 R classes (the chi_NSR split IS the adjoint/spinor split -- gated). Multiplication by i is trivial on V (i = 1 mod (1+i)), so mu4 = J acts INSIDE each fiber: each R fiber = 4 Gaussian lines (J-orbits) x 4 mu4 phases = 16 roots = 8 pairs x 2 signs, an origin-free torsor. THE PREDECLARED CONSTRUCTION (one route, own machinery -- label-level, no dependence on the parallel torsor-Fourier worker): the fiber intertwiner is the projective unitary family W_alpha: C[mu4] (x) C^4(lines) -> l^2(F_alpha), (m, j) -> J^m rho_j(alpha), with lex-first frozen origins rho_j; the mu4 cocycle is the twist. Gates: (a) well-definedness up to the phase torsor T = Z4^4 x S4 (origin re-choices change W by elements of T; covariance censuses unchanged; the sigma holonomy invariant unchanged); (b) DECK covariance: J = TRANSLATION m -> m + 1 (jet structure), exact on all 8 x 16 basis points; (c) SIGMA covariance: sigma J = J sigma exact on all 240 roots; sigma maps lines to lines: sigma o W_alpha = W_sigma(alpha) o S_alpha with S_alpha in T, exact census; the OBSTRUCTION analysis: on size-3 orbits the twist is a pure coboundary (transported origins give holonomy id because sigma^3 = 1 on roots); on sigma-FIXED classes S_alpha^3 = id forces the phase sum around every line cycle to 0 mod 4 (3 invertible in Z4), so the mu4-cocycle class is computed EXACTLY (the expected honest outcome: trivial phase class, residual pure line 3-cycles = a genuine Z3 twist, reported); (d) KMS half-weight compatibility: the fiber unitaries act on the fiber factor only (commute with the tower half-weight structurally); the uniform fiber trace is preserved exactly; (e) THE PAYOFF: W_glob = the 128 x 128 register-to-carrier permutation unitary (Gray outer map + fiber family); the extended Stinespring map Phi_ext(a (x) b) = Phi(a) (x) W* b W with V_ext = V (x) W_glob (isometry (x) unitary = isometry, exact); the GL1 channel multiplier through the extension stays EXACTLY 1 (unitary conjugation preserves the normalized fiber trace), and the GL1 window re-assembled through the extended map == the deployed Weil window at the 6.0e-16 level (re-verified live). KILL (frozen): if no deck- and sigma-compatible projective family exists (a line decomposition not preserved, or an inconsistent cocycle), census the obstruction exactly and report it as the honest negative (GRAY-OBSTRUCTED). CONTROLS (must fire): C1 the binary (non-Gray) pairing: the frozen r does NOT intertwine k -> k+1 through the binary code (orbit 0-2-3-1) and the binary sequence has Hamming-weight-2 steps (the one-step = one-sign-flip torsor rule breaks); C2 scrambled fiber phases break deck covariance; C3 the LINEAR (killed) map fails exactly where v786 said: (Z/480)^x has order census #{x^2=1} = 16, #{x^4=1} = 64 (type Z2 x Z2 x Z4 x Z8, exponent 8), the deployed G = (replayed live, |G| = 768) has NO element of order 8, and every homomorphism of the register group into the torsor translations F2^3 has image <= 4 (the exponent obstruction) -- while the AFFINE Gray encoding succeeds. VERDICT ENUM (frozen): GRAY-INTERTWINER-EXISTS / GRAY-PARTIAL (name which of a-e) / GRAY-OBSTRUCTED (the cocycle obstruction, computed). FENCES: NO RH/GRH claim. ROOTCLASS-MIXED (v775) cited and binding: everything here is register/carrier lattice bookkeeping, no code -> matter assignment is made or implied. Windows machinery read-only (v563/v755); the CP intertwiner Phi of prime_cp_intertwiner_probe is extended, not modified. EXPLORATION ONLY: one new file, writes nothing, no verification//ledger/.tex/website surface touched, no commits. Predecessors (read-only): verification/v738_hecke_mod_ramified (roots, J8/sig8, Lmodule class map), verification/v786_prime_packet480 (the kill, replayed light), verification/v775 (ROOTCLASS-MIXED fence, cited), experiments/tfpt-discovery/prime_cp_intertwiner_probe (the CP map being extended), positive_descent_probe (chi_NSR frame recipe), verification/v563 + v755 (deployed GL1 window, read-only). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/prime_carrier_gray_probe.py """ import ast import hashlib import math import os import sys import time from itertools import combinations, product import numpy as np _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) 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 (root frame) # ------------------------------------------------------------- frozen spec FROZEN_SPEC = """\ PRIME.CARRIER.GRAY.01 finite-level spec v2 (2026-08-06; v1 frozen before the first run; v2 = ONE declared run-1 -> run-2 control repair, no gate or construction change: the C2 scramble drew fiber phases from lcg(4), whose low-bit stream mod 4 is the degenerate pure rotation 2,3,0,1 -- a rotation of a J-orbit is deck-covariant BY CONSTRUCTION, so the control tested nothing (0 of 128 mismatches, honest FAIL of the must-fire gate in run 1). Repair: phase permutations are drawn from the well-mixed lcg(1000) stream with cyclic rotations rejected; the same stream replaces the lcg(4) shift draw in the H4.4 origin re-choices, where rotations are legitimate torsor elements and the gate was and stays valid). Frame: v738 roots_E8 (240 = 112 integer + 128 spinor, doubled model); class map = Lmodule.class_of_w; chi_NSR from a_par = parity of the first ambient coordinate of the L-basis images (positive_descent recipe); R = {v : a.v = 1}. Gates S1: 240 -> 15 x 16 (zero class empty); integer roots -> NS (7 classes), spinor -> R (8 classes); R sigma-stable (sigma^T a = a); A = R is an affine coset of ker(a) ~ F2^3 (difference set == ker(a) exact); J class-trivial on all 240; sigma class-functorial on all 240; sigma J == J sigma on all 240. Gates S2 (Gray): gamma = (00, 01, 11, 10); r(x,y,s) = (y, x+1, s), u = s+1; r^4 = u^2 = 1, ru = ur, regular of order 8; r affine not linear; Gray adjacency weight-1 steps incl. wrap; r-orbit of origin == gray sequence; enc bijective C2 x mu4 -> A; outer map 128 <-> 128; group-iso impossible: #{g^2 = 1} 4 vs 8 and all 64 homs Z4 x Z2 -> F2^3 have image <= 4. Gates S3/S4 (fiber): per R class 16 roots = 4 J-orbits x 4 phases, J free, -1 = J^2 in fiber, 8 pairs x 2 signs; W_alpha with lex origins; deck covariance exact on 8 x 16; sigma: S_alpha in T exists per class (exact); obstruction: transported origins -> holonomy id on size-3 orbits; fixed classes: phase sums around pi-cycles == 0 mod 4 (else the cocycle class is reported and the verdict is GRAY-OBSTRUCTED only if no compatible family exists); well-definedness: 3 LCG origin re-choices give D in T, covariance and holonomy invariants unchanged; KMS: fiber factor commutes with tower half-weight structurally, uniform fiber trace preserved. Gates S5 (payoff): W_glob 128 x 128 permutation unitary (exact integer W^T W = I); V_ext = V (x) W_glob isometry by factorization (exact); Phi_ext unital exact; GL1 multiplier == 1 exactly on every event (normalized-trace invariance, integer); GL1 window through the extension == deployed c_full rel <= 1e-12 (expect ~6e-16). Controls: C1 binary code: frozen-r intertwining mismatches > 0 and a weight-2 step exists; C2 LCG fiber-phase scramble (non-rotation phase permutations from the lcg(1000) stream): deck census fails; C3 v786 replay: #{x^2=1} = 16 and #{x^4=1} = 64 in (Z/480)^x, G = order histogram has no multiple of 8 (|G| = 768), all homs into F2^3 have image <= 4. Verdict enum: GRAY-INTERTWINER-EXISTS / GRAY-PARTIAL / GRAY-OBSTRUCTED. LCG seed 20260805. Runtime cap ~20 min. NO RH/GRH claim; ROOTCLASS-MIXED cited; writes nothing. """ M_TOP = 640 DGRID = 1.0 / 64.0 ALPHA_TOP = 0.5 * M_TOP * DGRID WARD_BAR = 1.0e-12 BANNED_IDS = ("sympy", "isprime", "primerange", "nextprime", "prevprime", "primepi", "zetazero", "nzeros", "mpz_zeta") CHECKS = [] GATE_FLAGS = {} _LAST = {} 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" % (sys.version.split()[0], np.__version__)) # ================================== S1 own copy of the carrier frame (v738) def s1_carrier_frame(): section("S1 -- the R-class torsor: MY OWN COPY from chi_NSR " "(v738 frame, live)") t0 = time.time() L = ram.Lmodule() roots = ram.roots_E8() n_int = sum(1 for w in roots if any(abs(c) == 2 for c in w)) n_spin = len(roots) - n_int cls = {w: L.class_of_w(w) for w in roots} from collections import Counter census = Counter(cls.values()) ok_census = (len(roots) == 240 and n_int == 112 and n_spin == 128 and len(census) == 15 and all(v == 16 for v in census.values()) and (0, 0, 0, 0) not in census) check("R1.1 root census: 240 = 112 integer + 128 spinor; classes " "in V = L/(1+i)L: 15 nonzero x 16 roots, zero class EMPTY " "(exact)", ok_census, "%.1f s" % (time.time() - t0)) # chi_NSR: a_par from the L-basis images (positive_descent recipe) E4 = [tuple((1 if j == k else 0, 0) for j in range(4)) for k in range(4)] a_par = tuple(ram.unpack(L.to_ambient(E4[k]))[0] % 2 for k in range(4)) labels16 = [tuple((z >> b) & 1 for b in range(4)) for z in range(16)] def chi_dot(v): return sum(a * b for a, b in zip(a_par, v)) & 1 NS = [v for v in labels16 if any(v) and chi_dot(v) == 0] R = [v for v in labels16 if chi_dot(v) == 1] ok_split = len(NS) == 7 and len(R) == 8 and (0, 0, 0, 0) not in R # adjoint/spinor == NS/R (the structural identification) ok_nsr = all((chi_dot(cls[w]) == 1) == (not any(abs(c) == 2 for c in w)) for w in roots) check("R1.2 chi_NSR split: a_par = %s; NS = 7 classes, R = 8 " "classes (0 not in R); the 112 integer roots fill the NS " "classes and the 128 spinor roots fill the R classes -- the " "chi_NSR split IS the adjoint/spinor split (exact, all 240)" % (a_par,), ok_split and ok_nsr) # A = R is an affine coset of ker(a) ~ F2^3 (origin-free torsor) ker = [v for v in labels16 if chi_dot(v) == 0] r0 = sorted(R)[0] diff = sorted(tuple((x ^ y) for x, y in zip(v, r0)) for v in R) ok_coset = diff == sorted(ker) and len(ker) == 8 check("R1.3 A = R is an AFFINE coset: {v - r0 : v in R} == ker(a) " "~ F2^3 exact (8 elements, contains 0 = a 3-dim linear " "space); R itself contains NO zero -- an origin-free torsor, " "base point r0 = %s is a frozen CHART choice, not canonical" % (r0,), ok_coset) # sigma stability + functoriality + J class-triviality 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)) ok_sig_chi = all(chi_dot(sigbar(v)) == chi_dot(v) for v in labels16) ok_funct = all(cls[ram.sig8(w)] == sigbar(cls[w]) for w in roots) ok_jtriv = all(cls[ram.J8(w)] == cls[w] for w in roots) ok_comm = all(ram.sig8(ram.J8(w)) == ram.J8(ram.sig8(w)) for w in roots) check("R1.4 symmetries: chi_NSR sigma-invariant (R sigma-stable); " "sigma class-functorial on ALL 240 roots; J class-TRIVIAL on " "ALL 240 (i == 1 mod (1+i): mu4 acts INSIDE each fiber); " "sigma J == J sigma on all 240", ok_sig_chi and ok_funct and ok_jtriv and ok_comm) GATE_FLAGS["frame"] = (ok_census and ok_split and ok_nsr and ok_coset and ok_sig_chi and ok_funct and ok_jtriv and ok_comm) return dict(L=L, roots=roots, cls=cls, R=R, NS=NS, ker=ker, r0=r0, sigbar=sigbar, a_par=a_par, labels16=labels16) # ====================================== S2 the Gray map and the outer map def gray(k): return ((0, 0), (0, 1), (1, 1), (1, 0))[k % 4] def r_aff(p): x, y, s = p return (y, (x + 1) & 1, s) def u_aff(p): x, y, s = p return (x, y, (s + 1) & 1) def s2_gray_outer(fr): section("S2 -- the GRAY map + the outer map (affine, kill-respecting)") pts = [(x, y, s) for x in (0, 1) for y in (0, 1) for s in (0, 1)] def iterate(f, p, n): for _ in range(n): p = f(p) return p ok_r4 = all(iterate(r_aff, p, 4) == p and iterate(r_aff, p, 2) != p for p in pts) ok_u2 = all(u_aff(u_aff(p)) == p and u_aff(p) != p for p in pts) ok_com = all(r_aff(u_aff(p)) == u_aff(r_aff(p)) for p in pts) # regular on the 8 points elems = {} for a in range(4): for b in range(2): key = tuple(iterate(u_aff, iterate(r_aff, p, a), b) for p in pts) elems[(a, b)] = key distinct = len(set(elems.values())) == 8 orbit0 = {iterate(u_aff, iterate(r_aff, pts[0], a), b) for a in range(4) for b in range(2)} free = all(all(img[i] != pts[i] for i in range(8)) for key, img in elems.items() if key != (0, 0)) ok_reg = distinct and len(orbit0) == 8 and free # r affine NOT linear: linear part = swap (order 2), translation (0,1,0) lin = lambda p: (p[1], p[0], p[2]) # noqa: E731 ok_aff = (r_aff((0, 0, 0)) == (0, 1, 0) and all(r_aff(p) == tuple((l + t) & 1 for l, t in zip(lin(p), (0, 1, 0))) for p in pts) and lin(lin(pts[3])) == pts[3]) check("G2.1 GRAY GROUP: r^4 = 1 (order exactly 4), u^2 = 1, " "ru = ur; ~ Z4 x Z2 has 8 distinct elements acting " "REGULARLY (transitive + free) on the 8 points; r is AFFINE " "not linear (r(0) = (0,1,0); linear part = the swap, order " "2)", ok_r4 and ok_u2 and ok_com and ok_reg and ok_aff) # Gray adjacency + orbit identity seq = [gray(k) for k in range(4)] steps = [sum(a ^ b for a, b in zip(seq[k], seq[(k + 1) % 4])) for k in range(4)] orb = [] p = (0, 0, 0) for _ in range(4): orb.append((p[0], p[1])) p = r_aff(p) ok_gray = steps == [1, 1, 1, 1] and orb == seq check("G2.2 GRAY PROPERTY: consecutive codes differ in EXACTLY one " "bit (incl. wrap: steps %s); the r-orbit of the origin IS " "the Gray sequence 00-01-11-10 (one mu4 step = ONE sign-flip " "generator: the Gamma-torsor step rule)" % steps, ok_gray) # the encoding into A and the outer map ker_nz = sorted(v for v in fr["ker"] if any(v)) basis = [] span = {(0, 0, 0, 0)} for v in ker_nz: if v not in span: basis.append(v) span = {tuple(a ^ b for a, b in zip(s, w)) for s in span for w in ((0, 0, 0, 0), v)} if len(basis) == 3: break b1, b2, b3 = basis def enc(s, k): x, y = gray(k) out = list(fr["r0"]) for bit, vec in ((x, b1), (y, b2), (s, b3)): if bit: out = [a ^ b for a, b in zip(out, vec)] return tuple(out) img = {enc(s, k) for s in (0, 1) for k in range(4)} ok_enc = img == set(fr["R"]) and len(img) == 8 n_reg = 2 * 4 * 16 n_car = 8 * 16 check("G2.3 OUTER MAP: enc(s, k) = r0 + gray(k).(b1,b2) + s.b3 is " "a bijection C2 x mu4 -> A (lex chart basis %s / %s / %s); " "C2 x mu4 x V -> A x V counts %d == %d == 128 (the R sector " "= 8 classes x 16 roots)" % (b1, b2, b3, n_reg, n_car), ok_enc and n_reg == 128 and n_car == 128) # NOT a group isomorphism -- the exact exponent census reg_sq = sum(1 for a in range(4) for b in range(2) if (2 * a) % 4 == 0) # (a,b)^2 = (2a, 0) tor_sq = 8 # F2^3: exponent 2 max_img = 0 for ia in range(8): # image of the Z4 generator for ib in range(8): # image of the Z2 generator va = ker_nz[ia - 1] if ia else (0, 0, 0, 0) vb = ker_nz[ib - 1] if ib else (0, 0, 0, 0) # hom well-defined iff 2.va = 0 (always in F2) -- image size: span = {(0, 0, 0, 0)} for v in (va, vb): span = {tuple(a ^ b for a, b in zip(s, w)) for s in span for w in ((0, 0, 0, 0), v)} max_img = max(max_img, len(span)) ok_noiso = reg_sq == 4 and tor_sq == 8 and max_img <= 4 check("G2.4 NOT A GROUP ISO (the kill-respecting point): " "#{g^2 = 1} = %d in Z4 x Z2 vs %d in F2^3; ALL 64 " "homomorphisms Z4 x Z2 -> F2^3 have image <= %d < 8 (the " "Z4 part must collapse: exponent 4 vs 2) -- yet the GRAY " "map IS a bijection intertwining the cyclic mu4 phase with " "the affine order-4 r (G2.1-G2.3)" % (reg_sq, tor_sq, max_img), ok_noiso) print(" V786-RESPECT (typed): v786/Packet480 killed the demand " "that (Z/480)^x (exponent 8) act as a GROUP on the 128 " "spinor roots\n (G = has no order-8 " "element; C3 replays the census live). The maximal " "canonical action was the graded\n image ~ " "Z4 x Z2 = exactly the register group encoded here. The " "repair demands NO group law on A:\n the R classes are " "an origin-free AFFINE coset (R1.3), and the Gray encoding " "is an affine torsor chart --\n linearity was demanded " "at the wrong place.") GATE_FLAGS["gray"] = (ok_r4 and ok_u2 and ok_com and ok_reg and ok_aff and ok_gray and ok_enc and ok_noiso) return dict(enc=enc, basis=(b1, b2, b3)) # ============================================= S3 the 16-fiber structure def s3_fibers(fr): section("S3 -- the 16-fiber: 4 Gaussian lines x 4 mu4 phases = " "8 pairs x 2 signs") roots, cls = fr["roots"], fr["cls"] fibers = {} for w in roots: c = cls[w] if sum(a * b for a, b in zip(fr["a_par"], c)) & 1 == 1: fibers.setdefault(c, []).append(w) ok_sizes = (len(fibers) == 8 and all(len(v) == 16 for v in fibers.values())) lines = {} ok_orbits = True ok_pairs = True for c, roots_c in fibers.items(): rem = set(roots_c) orbs = [] while rem: w0 = sorted(rem)[0] orb = [w0] w = ram.J8(w0) while w != w0: orb.append(w) w = ram.J8(w) ok_orbits &= (len(orb) == 4 and set(orb) <= rem and orb[2] == tuple(-x for x in w0)) rem -= set(orb) orbs.append(orb) ok_orbits &= len(orbs) == 4 # 8 pairs x 2 signs pairs = {frozenset((w, tuple(-x for x in w))) for w in roots_c} ok_pairs &= len(pairs) == 8 orbs.sort(key=lambda o: sorted(o)[0]) lines[c] = orbs check("F3.1 every R fiber: 16 roots = 4 free J-orbits (Gaussian " "lines) x 4 mu4 phases, with J^2 = -1 inside the fiber; " "= 8 (+-)-pairs x 2 signs; the fiber is an origin-free " "torsor (no distinguished root; line origins below are a " "frozen chart)", ok_sizes and ok_orbits and ok_pairs) # sigma orbit structure on the 8 R classes sb = fr["sigbar"] seen = set() orb_sizes = [] for c in fibers: if c in seen: continue o = [c] x = sb(c) while x != c: o.append(x) x = sb(x) seen |= set(o) orb_sizes.append(len(o)) check("F3.2 sigma on the R classes: orbit sizes %s (order-3 action " "restricted to the affine torsor; fixed classes carry the " "residual twist measured in S4)" % sorted(orb_sizes), sum(orb_sizes) == 8 and all(s in (1, 3) for s in orb_sizes)) GATE_FLAGS["fiber"] = ok_sizes and ok_orbits and ok_pairs return dict(fibers=fibers, lines=lines) # ============================== S4 the projective intertwiner family def make_W(lines): """W_alpha as dict: (m, j) -> root, with the given line origins.""" W = {} for c, orbs in lines.items(): table = {} for j, orb in enumerate(orbs): rho = orb[0] w = rho for m in range(4): table[(m, j)] = w w = ram.J8(w) W[c] = table return W def sigma_twist(W, lines, fr): """S_alpha = (phase shifts c_alpha(j), line perm pi_alpha) with sigma(W_alpha(m, j)) = W_{sigma alpha}(m + c(j), pi(j)); returns dict alpha -> (c, pi) or None if the decomposition fails.""" sb = fr["sigbar"] out = {} for c, table in W.items(): tgt = sb(c) inv = {w: mj for mj, w in W[tgt].items()} cvec, pvec = [None] * 4, [None] * 4 ok = True for j in range(4): img = ram.sig8(table[(0, j)]) if img not in inv: ok = False break m2, j2 = inv[img] cvec[j], pvec[j] = m2, j2 # verify on ALL 16 basis points (uses sigma J = J sigma) if ok: for (m, j), w in table.items(): img = ram.sig8(w) if inv.get(img) != ((m + cvec[j]) % 4, pvec[j]): ok = False break out[c] = (tuple(cvec), tuple(pvec)) if ok else None return out def s4_intertwiner(fr, fib): section("S4 -- the projective unitary family W_alpha: covariances " "+ the obstruction analysis") lines = fib["lines"] W = make_W(lines) # (b) DECK covariance: J = translation m -> m + 1 ok_deck = all(ram.J8(t[(m, j)]) == t[((m + 1) % 4, j)] for t in W.values() for m in range(4) for j in range(4)) check("H4.1 (b) DECK COVARIANCE exact: W_alpha(m + 1, j) == " "J W_alpha(m, j) on ALL 8 x 16 basis points -- the mu4 deck " "acts as PHASE TRANSLATION (jet structure), zero defect", ok_deck) # (c) SIGMA covariance: S_alpha exists in the torsor group T tw = sigma_twist(W, lines, fr) ok_sig = all(v is not None for v in tw.values()) print(" sigma twist S_alpha = (phase shifts | line perm):") sb = fr["sigbar"] for c in sorted(tw): cv, pv = tw[c] tag = "FIXED" if sb(c) == c else "orbit" print(" alpha = %s [%s]: c = %s, pi = %s" % (c, tag, cv, pv)) check("H4.2 (c) SIGMA COVARIANCE: sigma o W_alpha == " "W_{sigma alpha} o S_alpha with S_alpha in T = Z4^4 x S4 " "for ALL 8 classes (lines map to lines with a mu4 phase " "shift -- exact census on all 128 basis points)", ok_sig) # OBSTRUCTION: size-3 orbits -> transported origins, holonomy == id; # fixed classes -> phase sums around pi-cycles must be 0 mod 4 seen = set() ok_hol = True ok_phase = True n3, nfix = 0, 0 resid = [] for c in sorted(tw): if c in seen: continue if sb(c) == c: nfix += 1 seen.add(c) cv, pv = tw[c] # cycle decomposition of pi; phase sum per cycle unvisited = set(range(4)) while unvisited: j0 = min(unvisited) cyc = [j0] j = pv[j0] while j != j0: cyc.append(j) j = pv[j] unvisited -= set(cyc) psum = sum(cv[j] for j in cyc) % 4 ok_phase &= (psum == 0) if len(cyc) > 1: resid.append((c, tuple(cyc), psum)) else: orbit = [c, sb(c), sb(sb(c))] seen |= set(orbit) n3 += 1 # transported origins: rho_j(beta) := sigma rho_j(alpha) etc. t_alpha = W[c] hol_ok = all( ram.sig8(ram.sig8(ram.sig8(t_alpha[(m, j)]))) == t_alpha[(m, j)] for m in range(4) for j in range(4)) ok_hol &= hol_ok check("H4.3 OBSTRUCTION ANALYSIS: on the %d size-3 orbits the " "twist is a PURE COBOUNDARY (transported origins give " "holonomy == id because sigma^3 = 1 exactly on roots); on " "the %d fixed classes S_alpha^3 = id forces the mu4 phase " "sum around every line cycle to 0 mod 4 (3 invertible in " "Z4) -- measured: all phase sums ZERO, the mu4-COCYCLE " "CLASS IS TRIVIAL; residual twist = pure line 3-cycles %s " "(a genuine Z3 permutation twist, NOT a projective " "obstruction)" % (n3, nfix, resid), ok_hol and ok_phase) # (a) well-definedness up to the phase torsor: LCG origin re-choices ok_wd = True for trial in range(3): lines2 = {} for c, orbs in lines.items(): neworbs = [] perm = sorted(range(4), key=lambda j: lcg(1000)) for j in perm: orb = orbs[j] shift = lcg(1000) % 4 neworbs.append(orb[shift:] + orb[:shift]) lines2[c] = neworbs W2 = make_W(lines2) # D = W_alpha^{-1} W'_alpha must lie in T: (m,j) -> (m+d_j, s(j)) for c in W: inv = {w: mj for mj, w in W[c].items()} dvec, svec = [None] * 4, [None] * 4 for j in range(4): m2, j2 = inv[W2[c][(0, j)]] dvec[j], svec[j] = m2, j2 for (m, j), w in W2[c].items(): ok_wd &= (inv[w] == ((m + dvec[j]) % 4, svec[j])) # covariance + holonomy invariants unchanged ok_wd &= all(ram.J8(t[(m, j)]) == t[((m + 1) % 4, j)] for t in W2.values() for m in range(4) for j in range(4)) tw2 = sigma_twist(W2, lines2, fr) ok_wd &= all(v is not None for v in tw2.values()) for c in tw2: if sb(c) == c: cv, pv = tw2[c] unvisited = set(range(4)) while unvisited: j0 = min(unvisited) cyc = [j0] j = pv[j0] while j != j0: cyc.append(j) j = pv[j] unvisited -= set(cyc) ok_wd &= (sum(cv[j] for j in cyc) % 4 == 0) check("H4.4 (a) WELL-DEFINEDNESS up to the phase torsor: 3 LCG " "origin/phase re-choices -- every W'_alpha differs from " "W_alpha by an element of T (exact); deck covariance, sigma " "covariance and the trivial-cocycle invariant are UNCHANGED " "(chart-independent)", ok_wd) # (d) KMS half-weight compatibility LEVELS = 5 D5 = np.diag([2.0 ** (-0.5 * l) for l in range(LEVELS)]) c0 = sorted(W)[0] P = np.zeros((16, 16)) basis = sorted(W[c0].values()) bidx = {w: i for i, w in enumerate(basis)} for (m, j), w in W[c0].items(): P[bidx[w], m * 4 + j] = 1.0 dev_kms = float(np.max(np.abs( np.kron(P, D5) - np.kron(P, np.eye(LEVELS)) @ np.kron(np.eye(16), D5)))) tr_dev = abs(float(np.trace(P.T @ P)) - 16.0) check("H4.5 (d) KMS COMPATIBILITY: the fiber unitaries act on the " "fiber factor only -- (W (x) I) commutes with the tower " "half-weight I (x) D exactly (dev %.1e); W is a permutation " "unitary, the uniform fiber trace is preserved exactly " "(W^T W trace defect %.1e)" % (dev_kms, tr_dev), dev_kms == 0.0 and tr_dev == 0.0) GATE_FLAGS["family"] = (ok_deck and ok_sig and ok_hol and ok_phase and ok_wd and dev_kms == 0.0) GATE_FLAGS["obstructed"] = not (ok_sig and ok_hol and ok_phase) GATE_FLAGS["parts"] = {"a": ok_wd, "b": ok_deck, "c": ok_sig and ok_hol and ok_phase, "d": dev_kms == 0.0} return dict(W=W, lines=lines, tw=tw) # ========================================= S5 the payoff: extended GL1 def s5_payoff(fr, fam, enc): section("S5 -- (e) THE PAYOFF: the extended Stinespring map and " "the GL1 re-identity") W = fam["W"] # W_glob: register basis (s, k, m, j) -> carrier root, 128 x 128 reg_basis = [(s, k, m, j) for s in (0, 1) for k in range(4) for m in range(4) for j in range(4)] car_roots = sorted({w for t in W.values() for w in t.values()}) car_idx = {w: i for i, w in enumerate(car_roots)} Wg = np.zeros((128, 128), dtype=np.int64) for col, (s, k, m, j) in enumerate(reg_basis): alpha = enc(s, k) Wg[car_idx[W[alpha][(m, j)]], col] = 1 ok_unit = np.array_equal(Wg.T @ Wg, np.eye(128, dtype=np.int64)) check("P5.1 W_glob (Gray outer map + fiber family) is a 128 x 128 " "PERMUTATION UNITARY: W^T W == I exact integer (the " "register-to-carrier identification is one unitary)", ok_unit) check("P5.2 V_ext = V (x) W_glob is an ISOMETRY by factorization: " "V*V == I (certified exact in prime_cp_intertwiner_probe, " "integer identity Sigma E_{x_e x_e} = 7I) and W_glob^T " "W_glob == I (P5.1) => V_ext* V_ext = I (x) I EXACT; " "Phi_ext(a (x) b) = Phi(a) (x) W* b W is CP (tensor of CP) " "and unital exactly", ok_unit) # GL1 channel multiplier through the extension == 1 exactly ka, masks, dev = srp.channel_masks(ALPHA_TOP) tr_id = int(np.trace(Wg.T @ np.eye(128, dtype=np.int64) @ Wg)) ok_mult = (tr_id == 128 and dev <= 1.0e-12) # sampled nontrivial fiber elements (measurement: channel is not # the identity map, only trace-preserving) samples = [] for _ in range(3): d = np.zeros((128, 128), dtype=np.int64) for i in range(128): d[i, i] = lcg(5) out = Wg.T @ d @ Wg samples.append(int(np.trace(out) - np.trace(d))) check("P5.3 GL1 multiplier through the extension: the event " "element is fiber-uniform, and W* 1 W = 1 with " "tr(W* a W) == tr(a) exact integer (128 == %d; sampled " "diagonal transports trace-exact %s) -- the multiplier " "stays EXACTLY 1 on every one of the %d deployed events" % (tr_id, samples, ka), ok_mult and all(s == 0 for s in samples)) # re-assemble the GL1 window through the extended map 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]) 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)]) atoms, _d = core.atom_lags_at(ALPHA_TOP, M_TOP, U_ev, MU_ev) w_gl1 = c_cont + atoms # multipliers == 1 exactly dev_gl1 = float(np.max(np.abs(w_gl1 - c_full)) / np.max(np.abs(c_full))) ok_id = check("P5.4 (e) GL1 RE-IDENTITY: the GL1 window assembled " "through the EXTENDED map (multiplier 1 exact per " "P5.3) == the deployed Weil window, rel dev %.1e " "<= 1e-12 -- the 6.0e-16-level landing survives the " "register-to-carrier extension" % dev_gl1, dev_gl1 <= WARD_BAR) GATE_FLAGS["payoff"] = ok_unit and ok_mult and ok_id GATE_FLAGS["parts"]["e"] = GATE_FLAGS["payoff"] # ==================================================== S6 must-fail controls def s6_controls(fr, fib): section("S6 -- must-fail controls") # C1 binary (non-Gray) pairing binc = lambda k: (k & 1, (k >> 1) & 1) # noqa: E731 mism = sum(1 for k in range(4) for s in (0, 1) if r_aff(binc(k) + (s,)) != binc((k + 1) % 4) + (s,)) bsteps = [sum(a ^ b for a, b in zip(binc(k), binc((k + 1) % 4))) for k in range(4)] fired1 = mism > 0 and max(bsteps) == 2 check("K6.1 C1 NON-GRAY (binary) PAIRING FIRES: the frozen r does " "NOT intertwine k -> k+1 through the binary code (%d of 8 " "mismatches; binary orbit under r is 0-2-3-1) and the " "binary sequence has a Hamming-weight-2 step (steps %s): " "the one-step = one-sign-flip torsor rule breaks" % (mism, bsteps), fired1) # C2 scrambled fiber phases break deck covariance. Phases are # drawn as NON-ROTATION permutations from the well-mixed lcg(1000) # stream (declared v2 repair: the lcg(4) low-bit stream is the # pure rotation 2,3,0,1, which is deck-covariant by construction) rotations = {tuple((r + m) % 4 for m in range(4)) for r in range(4)} lines = fib["lines"] W2 = {} for c, orbs in lines.items(): table = {} for j, orb in enumerate(orbs): while True: pm = sorted(range(4), key=lambda m: lcg(1000)) if tuple(pm) not in rotations: break for m in range(4): table[(m, j)] = orb[pm[m]] W2[c] = table bad = sum(1 for t in W2.values() for m in range(4) for j in range(4) if ram.J8(t[(m, j)]) != t[((m + 1) % 4, j)]) fired2 = bad > 0 check("K6.2 C2 SCRAMBLED FIBER PHASES FIRE: LCG phase relabelling " "breaks deck covariance at %d of 128 basis points (J is no " "longer the translation m -> m + 1)" % bad, fired2) # C3 the linear (killed) map fails exactly where v786 said sq = sum(1 for x in range(480) if math.gcd(x, 480) == 1 and (x * x) % 480 == 1) q4 = sum(1 for x in range(480) if math.gcd(x, 480) == 1 and (x ** 4) % 480 == 1) # deployed G = on the 128 spinor roots (replay) SP = [v for v in product((1, -1), repeat=8) if v.count(-1) % 2 == 0] IDX = {v: i for i, v in enumerate(SP)} PJ = tuple(IDX[ram.J8(v)] for v in SP) PS = tuple(IDX[ram.sig8(v)] for v in SP) ID = tuple(range(128)) gens = [PJ, PS] for i in range(1, 8): eps = tuple(-1 if k in (0, i) else 1 for k in range(8)) gens.append(tuple(IDX[tuple(e * x for e, x in zip(eps, v))] for v in SP)) def compose(p, q): return tuple(p[q[i]] for i in range(128)) G = {ID} frontier = [ID] while frontier: new = [] for g in frontier: for h in gens: x = compose(g, h) if x not in G: G.add(x) new.append(x) frontier = new def perm_order(p): o = 1 q = p while q != ID: q = compose(q, p) o += 1 return o orders = sorted({perm_order(g) for g in G}) no8 = all(o % 8 != 0 for o in orders) fired3 = (sq == 16 and q4 == 64 and len(G) == 768 and no8) check("K6.3 C3 THE LINEAR (KILLED) MAP FAILS EXACTLY WHERE V786 " "SAID: (Z/480)^x order census #{x^2=1} = %d, #{x^4=1} = %d " "(type Z2 x Z2 x Z4 x Z8, exponent 8); deployed G = " " replayed live: |G| = %d, element orders " "%s -- NO order 8; and every hom of the register group into " "the torsor translations has image <= 4 (G2.4): the GROUP " "demand dies, the AFFINE encoding lives" % (sq, q4, len(G), orders), fired3) GATE_FLAGS["controls"] = fired1 and fired2 and fired3 # ======================================================== S7 verdict def s7_verdict(): section("S7 -- VERDICT + recommended contract text") parts = GATE_FLAGS.get("parts", {}) ok_all = (GATE_FLAGS.get("frame") and GATE_FLAGS.get("gray") and GATE_FLAGS.get("fiber") and GATE_FLAGS.get("family") and GATE_FLAGS.get("payoff") and GATE_FLAGS.get("controls")) if GATE_FLAGS.get("obstructed"): verdict = "GRAY-OBSTRUCTED" elif ok_all: verdict = "GRAY-INTERTWINER-EXISTS" else: verdict = "GRAY-PARTIAL" print("\nVERDICT: %s" % verdict) if verdict == "GRAY-PARTIAL": broken = [k for k, v in sorted(parts.items()) if not v] print("BROKEN PARTS: %s" % ", ".join(broken)) if verdict == "GRAY-INTERTWINER-EXISTS": print(""" FINDING (finite level): the register-to-carrier identification EXISTS as an affine/projective object, exactly respecting the v786 kill. The three layers: (1) the Gray map encodes C2 x mu4 affinely into the R-class torsor A (regular Z4 x Z2 affine action; a group isomorphism is impossible -- exponent 4 vs 2 -- and is NOT demanded); (2) the outer map C2 x mu4 x V -> A x V is a 128 <-> 128 bijection; (3) the fiber family W_alpha is deck-covariant (J = phase translation, exact), sigma-covariant up to the torsor twist S_alpha, and the measured mu4-cocycle class is TRIVIAL (all phase sums 0 mod 4; the residual twist is a pure line 3-cycle on the sigma-fixed classes -- a genuine Z3 permutation twist, not a projective obstruction). The extension Phi_ext = Phi (x) W-conjugation is a Stinespring map whose GL1 channel still lands on the deployed Weil window at machine precision. ROOTCLASS-MIXED stays binding: this is register/carrier bookkeeping, no matter semantics. STILL MISSING: the odd-place fibers (this probe identifies the ramified R sector; the odd Kneser fibers need their own chart); the Z3 residual twist as a structure (deck sigma acts on the identified carrier -- is the twist the sigma-part of a crossed product?); and the infinite-level demands of PRIME.CP.INTERTWINER.01 (unchanged).""") print(""" RECOMMENDED CONTRACT TEXT -- PRIME.CARRIER.GRAY.01 (report only): Object: the affine register-to-carrier identification (C2 x mu4 x V -> A x V, Gray chart; fiber family W_alpha with lex origins) extending the certified CP intertwiner Phi by the permutation unitary W_glob. Certified at finite level: the chi_NSR = adjoint/spinor split (7 x 16 NS + 8 x 16 R, exact); A an origin-free affine coset of ker(a) ~ F2^3; deck covariance exact (J = phase translation); sigma covariance up to a torsor twist with TRIVIAL mu4-cocycle class (phase sums 0 mod 4, measured); chart-independence; KMS compatibility; GL1 window re-identity at machine precision. Typed: the identification is AFFINE/projective, not a group isomorphism -- the v786 kill (exponent 8 vs 2) is respected, the encoding lives inside the maximal canonical action . Demands (open): D1 the odd-place fiber charts; D2 the residual Z3 line twist as crossed-product structure; D3 the infinite-level CP extension (PRIME.CP.INTERTWINER.01 demands, unchanged). Kill: a deck- or sigma-incompatible fiber census, or a nonzero mu4 phase sum around a line cycle (the cocycle obstruction).""") return verdict def main(): print("PRIME.CARRIER.GRAY.01 -- the affine (Gray) register-to-" "carrier identification") print("started %s" % time.strftime("%Y-%m-%d %H:%M:%S")) g0_firewall() fr = s1_carrier_frame() gm = s2_gray_outer(fr) fib = s3_fibers(fr) fam = s4_intertwiner(fr, fib) s5_payoff(fr, fam, gm["enc"]) s6_controls(fr, fib) verdict = s7_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 == "GRAY-INTERTWINER-EXISTS") else 1 def run(): """run_all entry point (v757 precedent): expected pattern 23/23 with verdict GRAY-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) == 23 and not fails and v == "GRAY-INTERTWINER-EXISTS") print("\n[%s] PATTERN GATE: expected 23/23 with verdict " "GRAY-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 -- GRAY-INTERTWINER-EXISTS: the " "register-to-carrier identification exists as an " "affine/projective object exactly respecting the v786 kill -- " "the Gray map encodes C2 x mu4 affinely into the R-class " "torsor (a group iso is impossible, exponent 4 vs 2, and not " "demanded), the fiber family is deck-covariant with a TRIVIAL " "measured mu4-cocycle (residual = a pure Z3 line twist on the " "sigma-fixed classes), and the extended Stinespring map's GL1 " "channel still lands on the deployed Weil window at 6.0e-16. " "ROOTCLASS-MIXED stands; demands D1-D3 stay open. " "NO RH claim." % ("PASS" if ok else "FAIL")) return 0 if ok else 1 if __name__ == "__main__": raise SystemExit(run())