#!/usr/bin/env python3 """v742 -- PRIME.CHANNELINT.01: the cross-channel anatomy of the thin W3 margin -- ONE collective scalar balance, two exact Ward identities (INTERFERENCE-COLLECTIVE). PROVENANCE: discovery probe channel_interference_probe.py (2026-08-04, 14/14, verdict INTERFERENCE-COLLECTIVE). Promoted verbatim; numbers unchanged. channel_interference_probe.py -- PRIME.HECKE.MOD_RAMIFIED.02 (discovery probe): dissecting the cross-channel cancellation of the thin T-B margin. DIRECT FOLLOW-UP to hecke_mod_ramified_probe.py (HECKE-MOD-RAMIFIED- CHANNELS): the V = L/(1+i)L channel projection located the unique negative-pressure channel (ram-odd, the 2-adic layers of odd deck parity) but found the W3 / T-B margin to be a CROSS-channel cancellation (leave-one-out moves it 1e2..1e5 x). THIS probe asks HOW the channels cancel. THE INTERFERENCE OBJECT (an identity, not a model). On a deployed frame-A window (v563, verbatim) the thin T-B block is Ah = B - S with S = sum of the atom reads. Write Ah = sum_alpha T_alpha over the declared channel pieces (T_arch = B, T_c = -S_c). For 2x2 blocks the determinant polarises EXACTLY: det(Ah) = (1/2) sum_{alpha,beta} D(T_alpha, T_beta), D(X, Y) = X_11 Y_22 + X_22 Y_11 - 2 X_12 Y_12, so M[alpha,beta] := (1/2) D(T_alpha, T_beta) IS the channel-pair interference matrix; its total is the margin (in det units). In the eigenbasis (u = critical, v = transverse) of Ah, with per-channel components a = u'Tu, b = v'Tv, c = u'Tv: M = (1/2)(a b' + b a') - c c' (basis-invariance, checked), sum_alpha c_alpha = u' Ah v = 0 (EXACT Ward identity W0), sum_alpha a_alpha = lambda_1 (tiny), sum_alpha b_alpha = lambda_2, det Ah = lambda_1 lambda_2. So the cancellation anatomy is fully determined by TWO sum rules: the cross components cancel EXACTLY (spectral kinematics), and the margin smallness is the ONE scalar balance sum_alpha a_alpha on the critical direction. The probe measures whether that balance is few-term or collective, and whether it is ladder-stable. CHANNEL BASES. * TYPE basis (5, the irreducible coordinates): arch, ram-odd, ram-even, split, inert (2-adic layers graded by deck parity k mod 2 -- the chi_par grading established by the predecessor probe). * V basis (8 = 7 + trivial, the sigma-orbit channels): the atom side is lifted by the MEASURED projected-Hecke weights -- odd finite places and the archimedean place act V-scalar (rigidity theorem, re-verified here in W1), so their content spreads with the exact spectral weights dim_C/16; ram-even carries the trivial character, ram-odd the parity character chi_par. Then M_V = P M_type P', P = the weight matrix (column sums 1). WARD LAYER (exact, checked to round-off): on the 6 rigid channels (2 non-parity fixed + 4 moved) M_V[C,C'] = dim_C dim_C' m0 with ONE scalar m0 -- sigma-averaging + Hecke scalarity force all relations between the 3 fixed and 4 moved channels; every deviation of the 8x8 from the dims x dims profile lives EXACTLY in the trivial and parity rows/columns (the 2-adic content). MEASUREMENTS (declared_* sections only -- the v563 surface enters HERE and nowhere else): C1.a per window (ALL complete-comb frame-A windows): the 5x5 and 8x8 interference matrices, the balance vector a, the exact identities (polarisation total == det Ah; eigen route == direct route; W0; Ward relations on the 8x8), the collectivity indices k95(a) = #channels needed for 95% of sum |a| and kpair90 = #pairs needed for 90% of the |M| mass, the top-3 pairs, signs. C1.b ladder stability: sign pattern of (arch, split, inert), cosine stability of the normalised balance vectors, top-3-pair census. C2 must-fail control: position-scrambled windows (v563 scramble, same masses) must blow up the margin (>= 1e2 x) and the balance ratio |sum a| / sum |a| (>= 10 x) -- the fine balance is a property of the TRUE atom positions, not of the bookkeeping. PREREGISTERED BARS AND VERDICTS (frozen after calibration, see below): BAR_ID = 1e-10 (exact identities, relative to the INTERFERENCE MASS sum|M| -- the round-off of the near-cancelling total lives on that scale, not on the margin scale) BAR_WARD = 1e-12 (relative to max|M_V|, Ward relations) STABILITY (task (ii): "dieselben Paare tragen -> Struktur; wandernde Paare -> Konspiration"): big-3 sign pattern constant on the ladder AND modal top-3 pair set covers >= 90% of windows AND consecutive- window cosine of the normalised balance vectors >= 0.98 AND every balance component is MONOTONE along the ladder (smooth running, the opposite of wandering). CLASSIFICATION (task (i)): median k95(a) <= 3 -> few-term/pairwise; median k95(a) >= 4 (of 5 channels) -> collective balance. Verdicts: INTERFERENCE-BALANCE-STRUCTURED (stable + few-term + Ward + controls fire: reduced pair-balance question printed), INTERFERENCE-COLLECTIVE (stable + Ward + controls fire, but the balance is many-term: the honest negative for the pair reduction), INTERFERENCE-CONSPIRACY (cancellation anatomy wanders), INTERFERENCE-CONSTRUCTION-FAIL (an exact identity or a control fails). CALIBRATION NOTES (fixed before freezing, first full run kept otherwise): (1) the total-identity tolerance was mis-normalised to |det Ah| instead of sum|M| (worst measured residual 9e-14 relative to sum|M|, 1.3e-10 absolute at kz=105); (2) the naive global-cosine stability metric (min cosine vs the ladder median vector, measured 0.9446) was replaced by the consecutive-cosine + monotonicity pair, because the measured balance RUNS smoothly and strictly monotonically along the ladder -- a global-shape bar misreads deterministic running as instability. No bar was weakened to convert a structural FAIL into a PASS: the collectivity classification (k95 = 4) is reported as measured and drives the verdict to the honest negative. HONESTY: the 2x2 factorisation M = (1/2)(ab'+ba') - cc' is kinematics, not a finding; the findings are the sum rules, the stability data and the control. No RH claim, no marker move. FIREWALL: experiments/ probe; ONE new file; writes nothing; no verification/, paper, ledger, changelog or website surface touched. AST-enforced: no prime-table / zeta symbols; deployed tables and window builders only inside declared_* functions (checked on this file). The Hecke-side facts (scalarity, deck) are RE-VERIFIED here (W1) on the full layer enumerations, not imported. Predecessors (read-only): hecke_mod_ramified_probe.py (channels, rigidity, ram-odd pressure), v714 (tower), v722 (NS/R), v563 (window surface), hecke_sos_probe.py (the rescue-bookkeeping pattern). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/channel_interference_probe.py """ import ast import math import os import sys import time from itertools import product import numpy as np sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "verification")) import v563_paper2_readouts as core # noqa: E402 (declared_* only) # ---------------------------------------------------------------- constants NORM_MAX = 13 INDEX_L = 256 N_LADDER_CAP = 48 # even subsample cap of the complete-comb ladder N_SCRAM = 3 # scrambled control windows SEED_SCRAM = 563 # v563-style scramble seeds: SEED_SCRAM + kz BAR_ID = 1.0e-10 # exact identities, relative (see calibration) BAR_WARD = 1.0e-12 # Ward relations, relative to max|M_V| BAR_K95 = 3 # classification: few-term iff median k95 <= 3 BAR_COS_STEP = 0.98 # consecutive-window cosine (smooth running) BAR_TOP = 0.90 # modal top-3 pair set covers >= this fraction BAR_SCR_MARGIN = 1.0e2 # scramble: |margin| ratio >= this BAR_SCR_BAL = 10.0 # scramble: balance-ratio ratio >= this BANNED_IDS = ("sympy", "isprime", "primerange", "nextprime", "prevprime", "primepi", "zetazero", "zetas", "mpz_zeta") RESTRICTED = ("U_ALL", "MU_ALL", "LAM_TAB", "G_ALL", "NU_MAIN", "ATOM_MAX", "atoms_in", "atom_lags_at", "arch_lags", "frame_a_zones", "build_window", "odd_toeplitz", "_NN") TYPE_LABELS = ("arch", "ram-odd", "ram-even", "split", "inert") CHECKS = [] FATAL = [] def check(name, ok, detail="", fatal=False): CHECKS.append((name, bool(ok))) if fatal and not ok: FATAL.append(name) 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) _LCG = [20260804] def lcg(n): _LCG[0] = (1103515245 * _LCG[0] + 12345) % (1 << 31) return _LCG[0] % n # ---------------------------------------------------------- Gaussian basics def canon(z): a, b = z for _ in range(4): if a > 0 and b >= 0: return (a, b) a, b = -b, a raise ValueError(z) def gmul(x, y): return (x[0] * y[0] - x[1] * y[1], x[0] * y[1] + x[1] * y[0]) def gadd(x, y): return (x[0] + y[0], x[1] + y[1]) def gsub(x, y): return (x[0] - y[0], x[1] - y[1]) def gnorm(x): return x[0] * x[0] + x[1] * x[1] def gdivides(e, d): n = gnorm(e) xr = d[0] * e[0] + d[1] * e[1] xi = d[1] * e[0] - d[0] * e[1] return xr % n == 0 and xi % n == 0 def gquo_exact(x, d): n = gnorm(d) xr = x[0] * d[0] + x[1] * d[1] xi = x[1] * d[0] - x[0] * d[1] assert xr % n == 0 and xi % n == 0, (x, d) return (xr // n, xi // n) def gquo_round(x, d): n = gnorm(d) xr = x[0] * d[0] + x[1] * d[1] xi = x[1] * d[0] - x[0] * d[1] return ((2 * xr + n) // (2 * n), (2 * xi + n) // (2 * n)) def par(z): return (z[0] + z[1]) & 1 def class_census(nmax): am = int(math.isqrt(nmax)) + 1 cls = {} for a in range(-am, am + 1): for b in range(-am, am + 1): n = a * a + b * b if 1 <= n <= nmax: cls.setdefault(n, set()).add(canon((a, b))) return {n: sorted(v) for n, v in cls.items()} def irreducible(d, cls): n = gnorm(d) if n < 2: return False for m in sorted(cls): if m * m > n: break if m < 2: continue for e in cls[m]: if gdivides(e, d): return False return True # ------------------------------------------------- the lattice (v722 frame) def in_L(w): parities = {c % 2 for c in w} return len(parities) == 1 and sum(w) % 4 == 0 def roots_E8(): roots = [] for i in range(8): for j in range(i + 1, 8): for si in (2, -2): for sj in (2, -2): w = [0] * 8 w[i], w[j] = si, sj roots.append(tuple(w)) for signs in product((1, -1), repeat=8): if signs.count(-1) % 2 == 0: roots.append(signs) return roots def J8(w): out = [] for k in range(4): a, b = w[2 * k], w[2 * k + 1] out.extend([-b, a]) return tuple(out) def sig8(w): return (w[4], w[5], w[0], w[1], w[2], w[3], w[6], w[7]) def z_basis_L(): B = [] for i in range(6): w = [0] * 8 w[i], w[i + 1] = 2, -2 B.append(tuple(w)) w = [0] * 8 w[6], w[7] = 2, 2 B.append(tuple(w)) B.append(tuple([1] * 8)) return B def pack(w): return tuple((w[2 * k], w[2 * k + 1]) for k in range(4)) def unpack(z): out = [] for a, b in z: out.extend([a, b]) return tuple(out) def zi_hnf(rows): M = [list(r) for r in rows] out = [] for col in range(4): M = [r for r in M if any(r[c] != (0, 0) for c in range(col, 4))] while True: nz = [r for r in M if r[col] != (0, 0)] if len(nz) <= 1: break nz.sort(key=lambda r: gnorm(r[col])) piv = nz[0] for r in nz[1:]: q = gquo_round(r[col], piv[col]) for c in range(4): r[c] = gsub(r[c], gmul(q, piv[c])) nz = [r for r in M if r[col] != (0, 0)] assert len(nz) == 1, "rank defect in Z[i]-HNF" out.append(list(nz[0])) M = [r for r in M if r is not nz[0]] return out class Lmodule: def __init__(self): gens = [list(pack(b)) for b in z_basis_L()] self.M = zi_hnf(gens) idx = 1 for k in range(4): idx *= gnorm(self.M[k][k]) self.index = idx def to_ambient(self, y): out = [(0, 0)] * 4 for k in range(4): for c in range(4): out[c] = gadd(out[c], gmul(y[k], self.M[k][c])) return tuple(out) def coords(self, z): z = list(z) y = [(0, 0)] * 4 for k in range(4): y[k] = gquo_exact(z[k], self.M[k][k]) for c in range(4): z[c] = gsub(z[c], gmul(y[k], self.M[k][c])) assert all(c == (0, 0) for c in z) return tuple(y) def class_of_w(self, w): return tuple(par(c) for c in self.coords(pack(w))) def f2_matvec(cols, v): out = [0, 0, 0, 0] for j in range(4): if v[j]: for i in range(4): out[i] ^= cols[j][i] return tuple(out) def f2_rank_ker_inv(cols): A = [[cols[j][i] for j in range(4)] for i in range(4)] aug = [A[i] + [1 if i == j else 0 for j in range(4)] for i in range(4)] piv_cols = [] r = 0 for c in range(4): p = next((i for i in range(r, 4) if aug[i][c]), None) if p is None: continue aug[r], aug[p] = aug[p], aug[r] for i in range(4): if i != r and aug[i][c]: aug[i] = [(x ^ y) for x, y in zip(aug[i], aug[r])] piv_cols.append(c) r += 1 inv_cols = None if r == 4: inv_rows = [aug[i][4:] for i in range(4)] inv_cols = [tuple(inv_rows[i][j] for i in range(4)) for j in range(4)] return r, inv_cols def vidx(v): return v[0] + 2 * v[1] + 4 * v[2] + 8 * v[3] ALL_V = [tuple((n >> k) & 1 for k in range(4)) for n in range(16)] def field_for(pi): a, b = pi if b == 0: m = a elems = [(u, v) for u in range(m) for v in range(m)] F = dict(q=m * m, zero=(0, 0), one=(1, 0), elems=elems) F["add"] = lambda s, t: ((s[0] + t[0]) % m, (s[1] + t[1]) % m) F["neg"] = lambda s: ((-s[0]) % m, (-s[1]) % m) F["mul"] = lambda s, t: ((s[0] * t[0] - s[1] * t[1]) % m, (s[0] * t[1] + s[1] * t[0]) % m) F["red"] = lambda z: (z[0] % m, z[1] % m) F["lift"] = lambda e: (e[0], e[1]) else: q = a * a + b * b t = next(t for t in range(q) if (a + b * t) % q == 0) F = dict(q=q, zero=0, one=1, elems=list(range(q))) F["add"] = lambda s, u: (s + u) % q F["neg"] = lambda s: (-s) % q F["mul"] = lambda s, u: (s * u) % q F["red"] = lambda z: (z[0] + t * z[1]) % q F["lift"] = lambda e: (e, 0) F["inv"] = lambda s: next(e for e in F["elems"] if F["mul"](s, e) == F["one"]) return F def hyperplanes(F): out = [] for j0 in range(4): for tail in product(F["elems"], repeat=3 - j0): phi = [F["zero"]] * j0 + [F["one"]] + list(tail) out.append((j0, tuple(phi))) return out class Layer: def __init__(self, name, pi): self.name = name self.pi = pi self.q = gnorm(pi) self.F = field_for(pi) self.red1pi = self.F["red"]((1, 1)) self.is_ram = (self.red1pi == self.F["zero"]) self.subs = hyperplanes(self.F) def phi_of(self, phi, x): F = self.F s = F["zero"] for j in range(4): s = F["add"](s, F["mul"](phi[j], F["red"](x[j]))) return s def iota_cols(self, j0, phi): F = self.F cols = [] for j in range(4): c = [0, 0, 0, 0] if j == j0: c[j0] = par(self.pi) else: c[j] = 1 c[j0] ^= par(F["lift"](phi[j])) cols.append(tuple(c)) return cols def mprime_coords(self, j0, phi, x): F = self.F y = list(x) acc = x[j0] for j in range(4): if j != j0: acc = gadd(acc, gmul(F["lift"](phi[j]), x[j])) y[j0] = gquo_exact(acc, self.pi) return tuple(y) def representative(self, j0, phi, v): F = self.F x = [(vj, 0) for vj in v] s = self.phi_of(phi, x) if s != F["zero"]: if self.is_ram: return None c = F["mul"](F["neg"](s), F["inv"](self.red1pi)) x[j0] = gadd(x[j0], gmul((1, 1), F["lift"](c))) return tuple(x) # ------------------------------------------------------------- G0 firewall def g0_firewall(): section("G0 -- AST firewall + environment") 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 banned symbols absent (no prime table / no zeta charge)", not bad, "found %s" % bad if bad else "clean") allowed = set() for node in ast.walk(tree): if isinstance(node, ast.FunctionDef) and \ node.name.startswith("declared_"): for sub in ast.walk(node): allowed.add(id(sub)) leaks = [] for node in ast.walk(tree): if isinstance(node, ast.Attribute) and node.attr in RESTRICTED \ and id(node) not in allowed: leaks.append(node.attr) check("G0.2 deployed tables/window builders only inside declared_* " "sections", not leaks, "leaks: %s" % leaks if leaks else "clean") print(" python %s, numpy %s" % (sys.version.split()[0], np.__version__)) # ------------------------------------------ W1: Ward foundations (re-check) def w1_foundations(): """Re-verify the load-bearing Hecke-fiber facts on the full layer enumerations (predecessor probe: HECKE-MOD-RAMIFIED-CHANNELS).""" section("W1 -- Ward foundations: V, sigma channels, layer scalarity " "(re-verified)") L = Lmodule() roots = roots_E8() zero = (0, 0, 0, 0) census = {} for r in roots: cv = L.class_of_w(r) census[cv] = census.get(cv, 0) + 1 ok = (L.index == INDEX_L and len(census) == 15 and zero not in census and sorted(census.values()) == [16] * 15) check("W1.1 L as Z[i]^4 (index %d) and the 15 x 16 root census" % L.index, ok, fatal=True) # sigma-bar and the character channels S = [L.coords(pack(sig8(unpack(L.to_ambient( tuple((1 if j == k else 0, 0) for j in range(4))))))) for k in range(4)] S2 = [[par(S[k][j]) for j in range(4)] for k in range(4)] def sigchar(a): return tuple((sum(S2[k][j] * a[j] for j in range(4))) & 1 for k in range(4)) a_par = tuple(unpack(L.to_ambient(tuple((1 if j == k else 0, 0) for j in range(4))))[0] % 2 for k in range(4)) ok_chi = all((r[0] % 2) == (sum(a * b for a, b in zip(a_par, L.class_of_w(r))) & 1) for r in roots) seen, orbits = set(), [] for a in ALL_V: if a in seen: continue o = [a] x = sigchar(a) while x != a: o.append(x) x = sigchar(x) seen |= set(o) orbits.append(o) fixed_nt = [o for o in orbits if len(o) == 1 and o[0] != zero] moved = [o for o in orbits if len(o) == 3] ok_orb = (len(fixed_nt) == 3 and len(moved) == 4 and (a_par,) in [tuple(o) for o in fixed_nt]) check("W1.2 character channels: 1 trivial + 3 fixed + 4 moved " "(dims 1,1,1,1,3,3,3,3); chi_par = %s sigma-fixed, parity of " "all 240 roots" % (a_par,), ok_chi and ok_orb, fatal=True) # channel order: [triv, par, fixB, fixC, mov1..mov4] fix_rest = sorted([o[0] for o in fixed_nt if o[0] != a_par], key=vidx) mov_sorted = sorted(moved, key=lambda o: min(vidx(x) for x in o)) channels = ([[zero], [a_par]] + [[f] for f in fix_rest] + mov_sorted) dims = np.array([len(c) for c in channels], dtype=float) # layers: full enumeration, scalarity re-verified cls = class_census(NORM_MAX) prims = [(n, d) for n in sorted(cls) for d in cls[n] if irreducible(d, cls)] ok_prims = sorted(prims) == sorted( [(2, (1, 1)), (5, (1, 2)), (5, (2, 1)), (9, (3, 0)), (13, (2, 3)), (13, (3, 2))]) check("W1.3 ring-internal prime layers (norm <= %d): %s" % (NORM_MAX, [d for _n, d in prims]), ok_prims, fatal=True) ok_odd = True odd_detail = [] ram_hp = None for _n, d in prims: ly = Layer(str(d), d) if ly.is_ram: hps = set() okr = True for (j0, phi) in ly.subs: rk, inv = f2_rank_ker_inv(ly.iota_cols(j0, phi)) okr &= (rk == 3 and inv is None) hps.add(tuple(phi)) okr &= (len(hps) == 15) ram_hp = okr continue n_ok = 0 for (j0, phi) in ly.subs: rk, inv = f2_rank_ker_inv(ly.iota_cols(j0, phi)) if rk != 4: ok_odd = False continue # sampled constructive transport: induced endo == id good = True for _ in range(3): v = ALL_V[lcg(16)] x = ly.representative(j0, phi, v) y = ly.mprime_coords(j0, phi, x) t = tuple(par(c) for c in y) good &= (f2_matvec(ly.iota_cols(j0, phi), t) == v) ok_odd &= good n_ok += 1 odd_detail.append("%s:%d" % (str(d), n_ok)) check("W1.4 odd layers V-scalar (det iota-bar = 1 on ALL submodules " "+ sampled transports == id): %s" % ", ".join(odd_detail), ok_odd, fatal=True) check("W1.5 ramified layer: 15 submodules rank-3 <-> the 15 " "hyperplanes (deck Z/2; ram-odd carries chi_par, ram-even " "the trivial character)", bool(ram_hp), fatal=True) # weight matrix P (8 x 5): V-channel lift of the type basis P = np.zeros((8, 5)) for ci in range(8): P[ci, 0] = dims[ci] / 16.0 # arch (V-scalar) P[ci, 3] = dims[ci] / 16.0 # split (V-scalar) P[ci, 4] = dims[ci] / 16.0 # inert (V-scalar) P[1, 1] = 1.0 # ram-odd -> chi_par channel P[0, 2] = 1.0 # ram-even -> trivial channel ok_P = np.allclose(P.sum(axis=0), 1.0, atol=1e-15) check("W1.6 V-lift weight matrix P (8x5): column sums == 1 exactly " "(nothing lost, nothing invented)", ok_P, fatal=True) return dict(channels=channels, dims=dims, P=P, a_par=a_par) # ------------------------------------------------- C1/C2: declared surface def declared_c1_c2(ward): section("C1 -- [declared] the interference matrix on the deployed " "frame-A ladder") dims, P = ward["dims"], ward["P"] ch_labels = ["triv", "par", "fixB", "fixC", "mov1", "mov2", "mov3", "mov4"] def mixed_det(Pm, Qm): return (Pm[0, 0] * Qm[1, 1] + Pm[1, 1] * Qm[0, 0] - 2.0 * Pm[0, 1] * Qm[0, 1]) def channel_of(n): k, base = 1, n for j in range(int(math.log2(n)), 1, -1): p = int(round(n ** (1.0 / j))) hit = None for pc in (p - 1, p, p + 1): if pc >= 2 and pc ** j == n: hit = pc break if hit is not None: k, base = j, hit break if base == 2: return 1 if k % 2 else 2 # ram-odd / ram-even for a in range(1, int(math.isqrt(base)) + 1): b2 = base - a * a b = int(math.isqrt(b2)) if b > 0 and b * b == b2: return 3 # split return 4 # inert def window_bookkeeping(r, nn_true): """all interference objects for one built window.""" chan = np.array([channel_of(int(n)) for n in nn_true]) Tm = [r["B"].copy()] for ci in (1, 2, 3, 4): idx = np.nonzero(chan == ci)[0] lam = r["lam"][idx] Xn = r["Xn"][idx] Sc = np.array( [[float(lam @ Xn[:, 0]), float(lam @ Xn[:, 2])], [float(lam @ Xn[:, 2]), float(lam @ Xn[:, 1])]]) Tm.append(-Sc) Ah = r["Ah"] ok_sum = (np.max(np.abs(sum(Tm) - Ah)) <= BAR_ID * max(1.0, float(np.max(np.abs(Ah))))) det_ah = float(np.linalg.det(Ah)) evals, evecs = np.linalg.eigh(Ah) lam1, lam2 = float(evals[0]), float(evals[1]) u, v = evecs[:, 0], evecs[:, 1] a = np.array([float(u @ (T @ u)) for T in Tm]) b = np.array([float(v @ (T @ v)) for T in Tm]) c = np.array([float(u @ (T @ v)) for T in Tm]) M_dir = np.array([[0.5 * mixed_det(Tm[i], Tm[j]) for j in range(5)] for i in range(5)]) M_eig = 0.5 * (np.outer(a, b) + np.outer(b, a)) - np.outer(c, c) scale = max(1.0, float(np.max(np.abs(M_dir)))) ok_routes = float(np.max(np.abs(M_dir - M_eig))) <= 1e-8 * scale # round-off of the near-cancelling total scales with the # interference mass sum|M|, not with the margin (calibration) ok_total = abs(float(M_dir.sum()) - det_ah) <= BAR_ID * max( 1.0, float(np.abs(M_dir).sum())) w0 = abs(float(c.sum())) / max(1.0, float(np.max(np.abs(Ah)))) MV = P @ M_dir @ P.T # Ward relations on the 8x8: rigid block == dims x dims * m0 m0 = MV[2, 3] / (dims[2] * dims[3]) rigid = [2, 3, 4, 5, 6, 7] dev = max(abs(MV[i, j] / (dims[i] * dims[j]) - m0) for i in rigid for j in rigid if i != j) ok_ward = dev <= BAR_WARD * max(1.0, float(np.max(np.abs(MV)))) # collectivity indices aa = np.abs(a) order = np.argsort(-aa) csum = np.cumsum(aa[order]) k95 = int(np.searchsorted(csum, 0.95 * aa.sum()) + 1) pmass = [] for i in range(5): for j in range(i, 5): m = abs(M_dir[i, j]) * (1.0 if i == j else 2.0) pmass.append((m, (i, j))) pmass.sort(reverse=True) tot = sum(m for m, _ in pmass) acc, kp90 = 0.0, 0 for m, _ in pmass: acc += m kp90 += 1 if acc >= 0.90 * tot: break top3 = frozenset(p for _m, p in pmass[:3]) return dict(Ah=Ah, det=det_ah, onem=r["onem"], lam1=lam1, lam2=lam2, a=a, b=b, c=c, M=M_dir, MV=MV, m0=m0, ok_sum=ok_sum, ok_routes=ok_routes, ok_total=ok_total, w0=w0, ok_ward=ok_ward, k95=k95, kp90=kp90, top3=top3, rbal=abs(a.sum()) / aa.sum()) KZ = core.frame_a_zones() KZC = [kz for kz in KZ if int(core._NN[kz]) ** 2 <= core.ATOM_MAX] step = max(1, int(math.ceil(len(KZC) / float(N_LADDER_CAP)))) kz_ref = KZ[len(KZ) // 2] ladder = sorted(set(KZC[::step]) | {kz_ref, KZC[0], KZC[-1]}) print(" ladder: %d complete-comb windows (of %d; cap %d), " "reference kz=%d" % (len(ladder), len(KZC), N_LADDER_CAP, kz_ref)) rows = [] ok_id = ok_w0 = ok_ward_all = True print(" %-6s %-6s %-5s %-11s %-11s %-9s %-4s %-5s a-vector " "(arch, ram-odd, ram-even, split, inert)" % ("kz", "nzone", "h", "margin", "lambda1", "|Sa|/S|a|", "k95", "kp90")) for kz in ladder: r = core.build_window(kz) ka = r["n_atom"] nn_true = core._NN[:ka] w = window_bookkeeping(r, nn_true) w["kz"], w["nz"], w["h"] = kz, r["n_zone"], r["h"] rows.append(w) ok_id &= (w["ok_sum"] and w["ok_routes"] and w["ok_total"]) ok_w0 &= (w["w0"] <= BAR_ID) ok_ward_all &= w["ok_ward"] print(" %-6d %-6d %-5d %-11.4g %-11.4g %-9.2e %-4d %-5d " "[%+.4g %+.4g %+.4g %+.4g %+.4g]" % (kz, w["nz"], w["h"], w["onem"], w["lam1"], w["rbal"], w["k95"], w["kp90"], *w["a"])) check("C1.1 [declared] exact identities on every window: " "sum_ch T == Ah, eigen route == polarisation route, " "total == det Ah", ok_id, fatal=True) check("C1.2 [declared] WARD W0: sum_ch c_ch = u'Ah v = 0 EXACTLY " "(max rel %.1e) -- the cross components cancel by spectral " "kinematics on every window" % max(w["w0"] for w in rows), ok_w0, fatal=True) check("C1.3 [declared] WARD (sigma + scalarity): on the 6 rigid " "V-channels M_V[C,C'] = dim_C dim_C' m0 with ONE scalar " "(rel dev <= %.0e); all deviation lives in the triv/par " "rows/cols" % BAR_WARD, ok_ward_all, fatal=True) # ---- stability across the ladder (structure vs conspiracy) sgn = {tuple(int(s) for s in np.sign(w["a"][[0, 3, 4]])) for w in rows} A_norm = np.array([w["a"] / np.linalg.norm(w["a"]) for w in rows]) cos_step = np.array([float(A_norm[i] @ A_norm[i + 1]) for i in range(len(rows) - 1)]) cos_drift = float(A_norm[0] @ A_norm[-1]) A_raw = np.array([w["a"] for w in rows]) mono = [bool(np.all(np.diff(A_raw[:, j]) >= 0) or np.all(np.diff(A_raw[:, j]) <= 0)) for j in range(5)] top_census = {} for w in rows: top_census[w["top3"]] = top_census.get(w["top3"], 0) + 1 modal_top, modal_n = max(top_census.items(), key=lambda kv: kv[1]) frac_top = modal_n / float(len(rows)) k95_med = float(np.median([w["k95"] for w in rows])) kp90_med = float(np.median([w["kp90"] for w in rows])) k95_rng = (min(w["k95"] for w in rows), max(w["k95"] for w in rows)) kp90_rng = (min(w["kp90"] for w in rows), max(w["kp90"] for w in rows)) stab_ok = (len(sgn) == 1 and float(cos_step.min()) >= BAR_COS_STEP and all(mono) and frac_top >= BAR_TOP) few_term = (k95_med <= BAR_K95) check("C1.4 [declared] ladder stability = STRUCTURE, not " "conspiracy: big-3 sign pattern constant %s, consecutive " "cosine >= %.4f (bar %.2f), ALL 5 balance components " "monotone along the ladder (smooth running, total drift " "cos %.4f), modal top-3 pair set on %.0f%% of windows" % (sorted(sgn), float(cos_step.min()), BAR_COS_STEP, cos_drift, 100 * frac_top), stab_ok) lbl = lambda p: "%s x %s" % (TYPE_LABELS[p[0]], TYPE_LABELS[p[1]]) check("C1.5 [declared] collectivity indices measured and ladder-" "consistent: k95(a) in [%d,%d] (median %.0f -> %s balance), " "kpair90 in [%d,%d] (median %.0f); modal top-3 pairs: %s" % (k95_rng[0], k95_rng[1], k95_med, "FEW-TERM" if few_term else "COLLECTIVE", kp90_rng[0], kp90_rng[1], kp90_med, sorted(lbl(p) for p in modal_top)), k95_rng[1] - k95_rng[0] <= 2 and kp90_rng[1] - kp90_rng[0] <= 2) # ---- the reference-window matrices (the summary object) wref = next(w for w in rows if w["kz"] == kz_ref) print("\n SUMMARY -- reference window kz=%d (n_zone=%d, h=%d): " "margin 1-r12^2 = %.4g, det Ahat = %.4g" % (kz_ref, wref["nz"], wref["h"], wref["onem"], wref["det"])) print(" 5x5 type-basis interference matrix M (det units; total = " "det Ahat):") print(" %-9s" % "" + "".join("%12s" % l for l in TYPE_LABELS)) for i in range(5): print(" %-9s" % TYPE_LABELS[i] + "".join("%+12.4g" % wref["M"][i, j] for j in range(5))) print(" balance vector a (critical direction; sum = lambda1 = " "%.4g):" % wref["lam1"]) print(" " + " ".join("%s %+.5g" % (l, x) for l, x in zip(TYPE_LABELS, wref["a"]))) print(" 8x8 V-channel interference matrix M_V (dims %s; rigid " "block == dims x dims * m0, m0 = %+.6g):" % ([int(d) for d in dims], wref["m0"])) print(" %-6s" % "" + "".join("%12s" % l for l in ch_labels)) for i in range(8): print(" %-6s" % ch_labels[i] + "".join("%+12.4g" % wref["MV"][i, j] for j in range(8))) dev = wref["MV"] - np.outer(dims, dims) * wref["m0"] print(" deviation from the dims x dims profile (== the 2-adic " "content, exactly in triv/par rows/cols):") print(" triv row: " + " ".join("%+.3g" % x for x in dev[0])) print(" par row: " + " ".join("%+.3g" % x for x in dev[1])) # ---- C2 must-fail: scrambled positions section("C2 -- [declared] must-fail control: scrambled atom " "positions (same masses)") picks = [ladder[0], kz_ref, ladder[-1]][:N_SCRAM] ok_scr = True for kz in picks: r_s = core.build_window(kz, scramble_seed=SEED_SCRAM + kz) ka = r_s["n_atom"] nn_true = core._NN[:ka] w_s = window_bookkeeping(r_s, nn_true) w_t = next(w for w in rows if w["kz"] == kz) m_ratio = abs(w_s["onem"]) / max(abs(w_t["onem"]), 1e-300) b_ratio = w_s["rbal"] / max(w_t["rbal"], 1e-300) fired = (m_ratio >= BAR_SCR_MARGIN and b_ratio >= BAR_SCR_BAL) ok_scr &= fired print(" kz=%d: |margin| x%.3g (bar %.0e), balance ratio " "x%.3g (bar %.0e), top-3 %s -> %s" % (kz, m_ratio, BAR_SCR_MARGIN, b_ratio, BAR_SCR_BAL, sorted(lbl(p) for p in w_t["top3"]), sorted(lbl(p) for p in w_s["top3"]))) check("C2.1 [declared] scramble control FIRES on all %d windows: " "the fine balance lives in the true atom positions, not in " "the bookkeeping" % len(picks), ok_scr, fatal=True) return dict(stab_ok=stab_ok, few_term=few_term, ok_scr=ok_scr, rows=rows, wref=wref, k95_med=k95_med, kp90_med=kp90_med, cos_step_min=float(cos_step.min()), cos_drift=cos_drift, modal_top=modal_top, frac_top=frac_top) # ------------------------------------------------------------------ verdict def verdict(res): section("VERDICT") n_pass = sum(1 for _n, ok in CHECKS if ok) n_all = len(CHECKS) if FATAL: v = "INTERFERENCE-CONSTRUCTION-FAIL" note = "an exact identity or a control failed: %s" % FATAL[:3] elif res["stab_ok"] and res["few_term"]: v = "INTERFERENCE-BALANCE-STRUCTURED" note = ("the cancellation is a ONE-dimensional, ladder-stable, " "few-term balance: cross components cancel exactly (W0), " "and the margin is the scalar sum of %d..%d channel " "reads on a stable critical direction." % (int(res["k95_med"]), int(res["kp90_med"]))) elif res["stab_ok"]: v = "INTERFERENCE-COLLECTIVE" note = ("the cancellation is STABLE (signs, pairs, monotone " "running) and Ward-exact, but COLLECTIVE: k95 = %d of " "5 channels carry the critical-direction balance -- no " "dominant pair, no pair reduction." % int(res["k95_med"])) else: v = "INTERFERENCE-CONSPIRACY" note = "the cancellation anatomy wanders across the ladder." print("%d/%d checks passed" % (n_pass, n_all)) print("VERDICT: %s" % v) print("PRIME.HECKE.MOD_RAMIFIED.02: %s -- %s" % (v, note)) if v == "INTERFERENCE-BALANCE-STRUCTURED": print(""" THE REDUCED POSITIVITY QUESTION (typed, C2): On every deployed window, margin > 0 <=> lambda2 > 0 (transverse, O(1), never critical) AND the SCALAR BALANCE a_arch + a_ram-odd + a_ram-even + a_split + a_inert > 0 on the window's critical direction u -- five named channel functionals with LADDER-STABLE signs and smoothly running shape. This is the pair balance one level below the naive channel projection: not a decoupling into per-channel transfer matrices (odd-place rigidity forbids that -- predecessor probe), but a reduction of the growing-matrix positivity to ONE stable scalar sum rule whose terms are channel-resolved comb functionals.""") if v == "INTERFERENCE-COLLECTIVE": print(""" C2, THE HONEST NEGATIVE (typed): The hoped-for pair reduction does NOT exist: the margin is not a balance of a few dominant channel pairs but a COLLECTIVE scalar balance in which 4 of the 5 channels are load-bearing at the 95% level (arch and ram-odd on the negative side, split/inert/ram-even on the positive side; ram-even runs through zero at the deep end). The channel basis is therefore DIAGNOSTIC, not reductive: it localises the negative pressure (arch + ram-odd, i.e. the archimedean layer together with the odd-deck 2-adic channel, on the SAME side of the balance -- a measured structural datum), it delivers exact Ward identities (W0: the cross components cancel exactly on every window; sigma/scalarity: the 8x8 rigid block is dim_C dim_C' m0, all deviation in the triv/par rows), and the anatomy is ladder-stable with smooth monotone running -- structure, not conspiracy. But the positivity question does NOT reduce to a small pair form: odd-place rigidity spreads the bulk uniformly over the V-channels, and the critical-direction balance stays many-term. Transfer-matrix hopes via THIS route are closed.""") return n_pass == n_all def main(): t0 = time.time() print("=" * 74) print("PRIME.HECKE.MOD_RAMIFIED.02 -- how do the channels cancel? " "(interference matrix)") print("=" * 74) g0_firewall() ward = w1_foundations() res = declared_c1_c2(ward) ok = verdict(res) print("total runtime %.1f s" % (time.time() - t0)) return 0 if ok else 1 run = main if __name__ == "__main__": sys.exit(main())