Follow the source behind the result.
Search the paper sections, open their original context and follow the checks they actually cite. The knowledge atlas explains the result; this library locates its source.
v808_petersen_sixthroot.py
verification/v808_petersen_sixthroot.py
This is a registered verification module. Read its original code and the paper sections that cite it, then follow the linked claim to its present classification.
Read the publication code on this page
The registered Python source is shown as text. Displaying it does not execute the code.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""v808 -- CARRIER.PETERSEN.RADIAL.01 (+ TRANSPORT.SIXTHROOT.01): the K5 edge machine, the Petersen carrier geometry with the radial dynamics whose sixth power IS the deployed transport spectrum, + the bit-exact decider on the PSD sixth root, ONE module from two probes (19/19 + 16/16 checks, ~1 s; discovery probes carrier_petersen_radial_probe.py PETERSEN-RADIAL-EXACT and transport_sixthroot_probe.py SIXTHROOT-SPECTRAL-ONLY, both 2026-08-06). PART 1, THE K5 EDGE MACHINE (all exact integer/Fraction): X = (-2,-2,-2,3,3) is the UNIQUE primitive traceless block-constant charge for the F|W = 3+2 split (sign pinned by the certified v774 table); E(K5) = 10 pairs carry the charge census {-4: 3, +1: 6, +6: 1} = the SU(5) decuple 3_{-4} + 6_{+1} + 1_{+6}, every pair cross-checked against the certified v774 hypercharge table (classes u_c/Q_up/Q_dn/e_c); under disjointness the pairs form the PETERSEN graph SRG(10,3,0,1) (charpoly (x-3)(x-1)^5(x+2)^4 exact, girth 5, |Aut| = 120 by full backtracking census = the faithful S5); the distance shells around the W vertex are (1, 3, 6) and CHARGE-PURE (+6/-4/+1 = e^c/u^c/Q), and the distance-2 shell induces a C6 -- THE FLAVOR HEXAGON AS GRAPH GEOMETRY [E neu] (explicit cycle verified edge by edge; 6 = |R+(A3)| = the transfer exponent, v124); the shell partition is EQUITABLE with quotient [[0,3,0],[1,0,2],[0,1,2]] whose eigenvector (6,-4,1) -> -2 IS the hypercharge vector, and P = Q_Pet/3 has spec(P^6) = {1, 64/729, 1/729} == the deployed TFPT transport spectrum EXACTLY (v54/v56/v171/v317; v124 lambda_n = (1-n/3)^6; GATE.METRIC.18). THE PREDICTION [H neu]: the full 10-dim Petersen walk has spec(P10^6) = {1, (1/3)^6 x5, (2/3)^6 x4} -- fast mode multiplicity 5 = g_car, slow hypercharge mode 4 = |mu4| (trace crosscheck 990 = 729 + 5 + 256); NO corpus 10-dim operator exists (T is 3-dim on the cusp space) -- a prediction, not a verification. PART 2, THE SIXTH ROOT (exact Fractions): B = (1/18)[[13,1,4],[1,13,4],[4,4,10]] -- every entry a compiler number (18 = p4(anchor), 13 = N_fam^2 + |Z2|^2, 4 = |mu4|, 10 = A_Lambda, 1 = N_Phi) -- is the UNIQUE symmetric doubly stochastic PSD sixth root with the frozen corpus-basis eigen-assignment ((1,1,1) -> 1, (1,-1,0) -> 2/3, (1,1,-2) -> 1/3; spectral reconstruction entry-exact; exactly 2 assignments in the corpus basis, a 1-parameter circle without the pin); B^6 carries the deployed spectrum exactly BUT the decider lands SPECTRAL-ONLY: B^6 is GL(3,Q)-conjugate to v486's lazy-walk M^6 (exact rational W and orthogonal O conjugations verified) and to the cusp-diagonal canonical form, yet bit-equal to NEITHER -- the corpus freezes the SPECTRUM, not the basis; the stochastic types differ (doubly vs sub-stochastic with absorbing channel). Controls fire in both parts (wrong edge 4+1 kills the (1,3,6) structure; Johnson complement kills the hexagon; both matrix perturbations break the spectrum). Typed carrier representation geometry -- ROOTCLASS-MIXED (v775) cited, no particle semantics. No marker move, NO RH claim. Python-only per GATE.WOLFRAM.02.
PROVENANCE: discovery probes carrier_petersen_radial_probe.py (2026-08-06, 19/19, ~0.2 s, PETERSEN-RADIAL-EXACT) + transport_sixthroot_probe.py (2026-08-06, 16/16, ~0.3 s, SIXTHROOT-SPECTRAL-ONLY); both re-run identically at promotion. Promoted verbatim, part 2 wrapped in a function scope (v789/v795 precedent); the v774/tfpt_constants imports resolve against the verification directory (path swap, v795 precedent); module-level _LAST1/_LAST2 verdict captures inserted (v791 precedent); numbers unchanged; run() encodes both patterns (v757 precedent).
Original carrier_petersen_radial_probe.py docstring (verbatim):
carrier_petersen_radial_probe -- CARRIER.PETERSEN.RADIAL.01 (Arf
compiler programme, follow-up module 1): the K5 edge machine, the
Petersen carrier geometry, and the radial dynamics whose sixth power
is the deployed TFPT transport spectrum.
THEOREM CANDIDATE (preregistered). The five carrier slots of
S+_{D5} = Lambda^even C^5 split canonically F = {f1,f2,f3} |
W = {w1,w2} (the distinguished edge). On E(K5) = the 10 pairs (the
SU(5) decuple, = the {q*=1} words of v774), the unique primitive
traceless block-constant charge X = (-2,-2,-2,3,3) induces the charge
decomposition 3_{-4} + 6_{+1} + 1_{+6} (Y = X/6: -2/3, 1/6, 1).
Under disjointness the 10 pairs form the PETERSEN graph KG(5,2); the
distance shells around the W vertex are (1, 3, 6) = exactly the
charge classes (e^c, u^c, Q), and the distance-2 shell is a 6-cycle
-- the flavor hexagon as graph geometry [E neu]. The equitable
radial quotient Q_Pet = [[0,3,0],[1,0,2],[0,1,2]] has eigenpairs
(1,1,1)->3, (6,-4,1)->-2 (the HYPERCHARGE VECTOR, ordered
(e^c, u^c, Q)), (3,1,-1)->1; the radial walk P = Q_Pet/3 has
spec {1, -2/3, 1/3} and spec(P^6) = {1, (2/3)^6, (1/3)^6} -- the
deployed TFPT boundary transport spectrum, exactly.
THE STEPS (all exact integer/Fraction; sympy gated to charpolys):
P1 K5 EDGE MACHINE: X = (-2,-2,-2,3,3) is the UNIQUE primitive
traceless block-constant charge for the 3+2 split (3x+2y=0 =>
(x,y) = t(-2,3), primitive iff t = +-1; sign frozen by the
certified v774 table X5); E(K5) = 10 pairs decompose 3+6+1
with pair charges (-4, +1, +6) = the SU(5) decuple
3_{-4} + 6_{+1} + 1_{+6}, Y = X/6 = (-2/3, 1/6, 1);
cross-check EVERY pair against the certified v774 hypercharge
table (read-only import: the weight-2 words of C_even(5) ARE
E(K5), classes u_c/Q_up/Q_dn/e_c); Stab_{S5}(W) = S3 x S2
(order census 12 over all 120 permutations).
P2 PETERSEN: pairs under disjointness = KG(5,2); verify
SRG(10,3,0,1), exact spectrum 3^1 1^5 (-2)^4 (charpoly),
girth 5, diameter 2, |Aut| = 120 (full backtracking census)
= the faithful S5 image, betti = 15 - 10 + 1 = 6; distance
shells around W: sizes (1, 3, 6), each CHARGE-PURE
(+6, -4, +1); THE HEXAGON: the 6 distance-2 vertices induce a
C6 (2-regular, connected, girth 6), explicit cycle
(f1w1, f2w2, f3w1, f1w2, f2w1, f3w2) verified edge by edge --
the flavor hexagon as the distance-2 shell [E neu]; crosslink:
6 = |R+(A3)| = p2 = the transfer exponent (v124).
P3 RADIAL DYNAMICS: the shell partition is EQUITABLE (every
vertex checked); quotient == [[0,3,0],[1,0,2],[0,1,2]];
eigenpairs exact: (1,1,1)->3, (6,-4,1)->-2 with the exact
identification eigvec == (X(WW), X(FF), X(FW)) = the
hypercharge vector ordered (e^c, u^c, Q), (3,1,-1)->1;
P = Q_Pet/3 row-stochastic, spec(P) = {1, -2/3, 1/3},
spec(P^6) = {1, 64/729, 1/729} exact.
P4 TRANSPORT COMPARISON: the deployed TFPT transport operator T
is identified in the corpus as (i) the FROZEN SPECTRUM
{1, (2/3)^6, (1/3)^6} on the 3-dim cusp space (v54/v56 --
v56's explicit matrix is a float demonstration conjugate, not
a frozen matrix; v171 OS moments; v317; v124: lambda_n =
(1-n/3)^6; v82: Koide multiplier), with GATE.METRIC.18 forcing
the mu4-equivariant generator DIAGONAL in the cusp basis, and
(ii) the explicit local sixth-root generator of v486 (lazy
Z2-pair walk [[1,0,0],[0,1/2,1/6],[0,1/6,1/2]], spectrum
{1, 2/3, 1/3}, sub-stochastic; v327's uniform rule is the
superseded degenerate case {1, 2/3, 0}). GATES:
spec(P^6) == the frozen spectrum EXACTLY; lambda_n = (1-n/3)^6
re-verified; the deployed T lives on the 3-DIM QUOTIENT (cusp
space) -- the corpus provides NO 10-dim transfer operator, so
the FULL Petersen prediction is stated as [H neu]: P10 =
A_Pet/3 has spec {1, (1/3)^5, (-2/3)^4} and spec(P10^6) =
{1^1, (1/3)^6 x5, (2/3)^6 x4} -- fast mode x5 = g_car, slow
hypercharge mode x4 = |mu4| (multiplicity identities verified
exactly on the Petersen side; trace crosscheck
tr A^6 = 990 = 729 + 5 + 4*64). HONEST SIGN NOTE: the radial
sixth root has subleading eigenvalue -2/3 (negative); the sign
is invisible in the deployed sixth-power spectrum (the PSD
sixth root is the sibling probe TRANSPORT.SIXTHROOT.01).
C MUST-FAIL CONTROLS: (C1) the wrong edge choice F|W = 4+1 has
NO intra-W pair (no distinguished Petersen vertex) and only 2
pair-charge classes (6+4) -- the (1,3,6) charge/shell
structure breaks; (C2) scrambled adjacency (the Johnson
complement "share one slot") makes the former hexagon
3-regular -- the C6 breaks.
KILLS (frozen, any one fires => PETERSEN-RADIAL-DEAD):
K1 X not unique/primitive/traceless, or pair-charge census !=
{-4:3, +1:6, +6:1}, or Y != (-2/3, 1/6, 1), or any pair
disagrees with the certified v774 table, or |Stab(W)| != 12.
K2 Petersen structure fails: not SRG(10,3,0,1), spectrum !=
3^1 1^5 (-2)^4, girth != 5, diameter != 2, |Aut| != 120,
betti != 6.
K3 shells != (1,3,6), or a shell is not charge-pure, or the
distance-2 shell is not a C6 (incl. the stated cycle order).
K4 the shell partition is not equitable, or the quotient !=
[[0,3,0],[1,0,2],[0,1,2]], or an eigenpair deviates (incl.
the hypercharge-vector identification (6,-4,1) <-> -2).
K5 spec(P^6) != {1, 64/729, 1/729}, or the corpus spectrum
identification fails, or a multiplicity identity (5 = g_car,
4 = |mu4|, trace 990) breaks.
VERDICTS (frozen): PETERSEN-RADIAL-EXACT (all checks pass, controls
fire) / PETERSEN-RADIAL-PARTIAL (no kill fired, but a non-kill check
failed) / PETERSEN-RADIAL-DEAD (a kill fired OR a must-fail control
does not fire).
TYPING (carried): [E neu] exact finite algebra/graph identities;
[H neu] the 10-dim multiplicity reading and the hexagon=shell
reading as transport semantics. ROOTCLASS-MIXED cited: the pair
charges are CARRIER REPRESENTATION GEOMETRY (SU(5) decuple labels on
E(K5)); NO particle semantics is claimed -- the matter-classifier
reading remains Priority 2's separate kill test.
FIREWALL: experiments/-Probe; EINE neue Datei; schreibt nichts; kein
verification/-, Paper-, Ledger-, Changelog- oder Website-Surface
beruehrt. Exakte Ganzzahl/Fraction-Arithmetik; sympy nur fuer
charakteristische Polynome; keine Floats, kein RNG, kein Fit.
Quellen (read-only): verification/v774_arf_spinor_compiler.py (X5,
iota, class_of, xval -- die zertifizierte Hyperladungs-Tafel),
verification/v54_seam_horizon_keystones.py + v56_unique_attractor.py
(frozen transfer spectrum), v124_resummed_clock.py (lambda_n =
(1-n/3)^6, p2 = 6), v486_transfer_full_rule.py (lazy Z2-pair walk),
v327_hypergraph_rewrite.py (uniform rule), v212_leptogenesis_decuple
(A_Lambda = 10 = |E(K5)|), tfpt_constants (g_car, N_fam).
Run:
experiments/tfpt-discovery/.venv/bin/python \
experiments/tfpt-discovery/carrier_petersen_radial_probe.py
Original transport_sixthroot_probe.py docstring (verbatim):
transport_sixthroot_probe -- TRANSPORT.SIXTHROOT.01 (Arf compiler
programme, follow-up module 2): the bit-exact test of the candidate
PSD sixth root B of the deployed TFPT transport spectrum, and the
DECIDER bit-exact vs spectral-only.
THE CANDIDATE (preregistered, frozen):
B = (1/18) [[13, 1, 4],
[ 1, 13, 4],
[ 4, 4, 10]]
with the compiler-number identifications
18 = p4(1,1,2) = 1 + 1 + 16 (4th power sum of the anchor triple;
crosslink: p1 = 4 = |mu4|,
p2 = 6 = |R+(A3)| = the hand,
p3 = 10 = A_Lambda -- v397/v394),
13 = 3^2 + 2^2 (the (b,s) = (3,2) split, v14),
4 = |mu4|,
10 = A_Lambda = |E(K5)| = |Z2| * g_car (v212/v397),
1 = N_Phi (EM budget 41 = sum L + N_Phi, v159),
and the frozen eigen-assignment in the corpus basis
(1,1,1) -> 1, (1,-1,0) -> 2/3, (1,1,-2) -> 1/3.
THE STEPS (all exact Fractions; sympy gated to charpolys/radicals):
S1 COMPILER NUMBERS: verify every entry identification against
tfpt_constants (g_car, N_fam) and the corpus atoms (Z2 = g_car -
N_fam = 2, mu4 = 4, A_Lambda = 10 = Z2*g_car, N_Phi = 1,
anchor power sums p1..p4(1,1,2) = (4, 6, 10, 18), 13 = 3^2+2^2);
row-sum consistency 13 + 1 + 4 = 18 = p4.
S2 MATRIX LAWS: B symmetric, doubly stochastic (rows AND columns
sum to 1), PSD (symmetric + eigenvalues > 0; leading principal
minors 13/18, 14/27, 2/9 > 0; det B = 1*(2/3)*(1/3) = 2/9);
eigenvalues EXACTLY {1, 2/3, 1/3} (exact charpoly
(x-1)(x-2/3)(x-1/3)) with the frozen eigenvectors verified by
exact matvec.
S3 UNIQUENESS / FREEDOM CENSUS: the eigenvectors are mutually
orthogonal, so the spectral sum
B = J/3 + (2/3) vv^T/2 + (1/3) ww^T/6,
v = (1,-1,0), w = (1,1,-2), reconstructs B ENTRY-EXACTLY =>
B is the UNIQUE symmetric matrix with this eigen-assignment
(double stochasticity is then automatic). FREEDOM: (a) swapping
the two non-Perron eigenvalues gives the OTHER solution
B_swap = (1/18)[[11,5,2],[5,11,2],[2,2,14]] != B (census in the
corpus basis: exactly 2 assignments); (b) without pinning the
eigenvectors there is a 1-parameter circle family B_theta =
J/3 + (2/3) P_theta + (1/3)(I - J/3 - P_theta), symmetric and
doubly stochastic for every theta (verified symbolically) --
the corpus basis pins the circle to the 2 points, the stated
assignment to B alone.
S4 SIXTH POWER, BIT-EXACT: B^6 computed by exact Fraction matrix
power AND by the spectral formula; both agree:
B^6 = (1/4374) [[1651, 1267, 1456],
[1267, 1651, 1456],
[1456, 1456, 1462]],
spec(B^6) = {1, 64/729, 1/729} = the deployed transport
spectrum (v54/v56/v171/v317).
S5 THE DECIDER: compare B^6 bit-exactly against the two deployed
corpus surfaces:
(i) the canonical cusp-diagonal form D = diag(1, 64/729,
1/729) (GATE.METRIC.18: mu4-equivariance forces the
generator diagonal in the cusp basis; v54/v56 freeze the
spectrum, not an off-diagonal matrix) -- exact difference
B^6 - D printed; B^6 = U D U^{-1} with the RATIONAL
eigenbasis U = [[1,1,1],[1,-1,1],[1,0,-2]] verified
exactly;
(ii) the v486 lazy Z2-pair walk M = [[1,0,0],[0,1/2,1/6],
[0,1/6,1/2]] (the corpus's own sixth-root generator,
SUB-stochastic, row sums {1, 2/3, 2/3}); M^6 computed
exactly; B^6 != M^6 bit-exact (different row sums);
exact conjugations verified: RATIONAL W = U V^{-1} with
W M^6 W^{-1} = B^6, and the ORTHOGONAL eigenvector map
O (entries in Q(sqrt2, sqrt3, sqrt6)) with O M^6 O^T =
B^6 (sympy exact radicals).
TYPE of the relation: spectral equivalence via rational GL(3,Q)
conjugation (also orthogonal-irrational); the stochastic TYPES
differ (B doubly stochastic vs M sub-stochastic with absorbing
channel) => bit-exact identity fails for every deployed corpus
matrix.
C MUST-FAIL CONTROLS: (C1) the doubly-stochastic perturbation
B' = (1/18)[[12,2,4],[2,12,4],[4,4,10]] shifts the (1,-1,0)
eigenvalue to 10/18 = 5/9 != 2/3; (C2) the raw single-entry
perturbation B''_00 = 14/18 breaks stochasticity and the
spectrum ({1, 2/3, 1/3} is no longer contained in spec).
KILLS (frozen, any one fires => SIXTHROOT-DEAD):
K1 a compiler-number identification fails against
tfpt_constants/corpus atoms.
K2 B not symmetric/doubly stochastic/PSD, or eigenvalues !=
{1, 2/3, 1/3}, or an eigenvector assignment fails.
K3 the spectral reconstruction does not reproduce B entry-exactly
(uniqueness given the assignment fails).
K4 B^6 (Fraction power) != spectral formula, or spec(B^6) !=
{1, 64/729, 1/729}.
K5 a claimed exact conjugation identity fails.
DECIDER (frozen, data decides): SIXTHROOT-BITEXACT if B^6 equals a
deployed corpus matrix bit-exactly; SIXTHROOT-SPECTRAL-ONLY if all
kills pass but no bit-exact match exists (the exact difference and
conjugation type are then the deliverable); SIXTHROOT-DEAD if a kill
fires OR a must-fail control does not fire.
TYPING (carried): [E neu] exact matrix identities and censuses;
[H neu] the sixth-root reading as transport semantics.
ROOTCLASS-MIXED cited: carrier representation geometry, no particle
semantics.
FIREWALL: experiments/-Probe; EINE neue Datei; schreibt nichts; kein
verification/-, Paper-, Ledger-, Changelog- oder Website-Surface
beruehrt. Exakte Fraction-Arithmetik; sympy nur fuer charpolys und
die orthogonale Radikal-Konjugation; keine Floats, kein RNG, kein Fit.
Quellen (read-only): tfpt_constants (g_car, N_fam),
verification/v54_seam_horizon_keystones.py + v56_unique_attractor.py
(frozen spectrum {1, (2/3)^6, (1/3)^6}; v56's Matrix ist eine Float-
Demonstration, keine eingefrorene Matrix), v486_transfer_full_rule.py
(lazy Z2-pair walk, die Korpus-Sechstwurzel), v327_hypergraph_rewrite
(uniforme Regel, degeneriert), v212/v397 (A_Lambda), v159 (N_Phi),
v14_carrier_uniqueness (13 = 3^2 + 2^2 Kontext), GATE.METRIC.18
(Cusp-diagonale kanonische Form; status_ledger.csv, read-only).
Run:
experiments/tfpt-discovery/.venv/bin/python \
experiments/tfpt-discovery/transport_sixthroot_probe.py
"""
_LAST1 = {}
_LAST2 = {}
import itertools
import os
import sys
import time
from collections import Counter
from fractions import Fraction as Fr
from math import gcd
_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)
T0 = time.time()
CHECKS = []
KILLS = []
def check(name, ok, detail="", kill=None):
CHECKS.append((name, bool(ok)))
if kill and not ok:
KILLS.append(kill)
print("[%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("=" * 78)
print(title)
print("=" * 78, flush=True)
# ---------------------------------------------------------------- setup
F_SLOTS = (0, 1, 2) # f1, f2, f3
W_SLOTS = (3, 4) # w1, w2 (the distinguished edge)
X5 = (-2, -2, -2, 3, 3)
PAIRS = [frozenset(p) for p in itertools.combinations(range(5), 2)]
PIDX = {p: i for i, p in enumerate(PAIRS)}
W_VERTEX = frozenset(W_SLOTS)
def pair_charge(p, X=X5):
return sum(X[i] for i in p)
def adjacency(pairs, rule):
n = len(pairs)
return [[1 if i != j and rule(pairs[i], pairs[j]) else 0
for j in range(n)] for i in range(n)]
ADJ = adjacency(PAIRS, lambda a, b: not (a & b)) # Petersen
def frac_charpoly_check(A, factors):
"""exact charpoly comparison via sympy (gated)."""
from sympy import Matrix, symbols, expand, prod
x = symbols("x")
cp = Matrix(A).charpoly(x).as_expr()
target = expand(prod((x - r) ** m for r, m in factors))
return expand(cp - target) == 0
# ==================================================================== P1
def p1_edge_machine():
section("P1: die K5-Kantenmaschine (F|W = 3+2, X, Dekuple, Stab)")
# uniqueness of X: block-constant (x,x,x,y,y), traceless, primitive
sols = [(x, y) for x in range(-12, 13) for y in range(-12, 13)
if 3 * x + 2 * y == 0 and (x, y) != (0, 0)
and gcd(abs(x), abs(y)) == 1]
# algebra: 3x+2y=0 => (x,y) = t(-2,3); primitive iff |t| = 1
check("P1.1 EINDEUTIGKEIT: block-konstant + spurfrei => (x,y) = "
"t(-2,3); primitiv nur t = +-1: Zensus [-12,12]^2 = %s; "
"Vorzeichen durch die zertifizierte v774-Tafel X5 fixiert => "
"X = (-2,-2,-2,3,3)" % sols,
sorted(sols) == [(-2, 3), (2, -3)], kill="K1")
import v774_arf_spinor_compiler as v774 # read-only certified table
check("P1.2 v774-Anker: X5 == (-2,-2,-2,3,3) (die zertifizierte "
"Tafel waehlt den Repraesentanten)", v774.X5 == X5, kill="K1")
cen = Counter(pair_charge(p) for p in PAIRS)
ys = {c: Fr(c, 6) for c in cen}
check("P1.3 DEKUPLE: E(K5) = 10 Paare, Ladungszensus {-4: 3, +1: 6,"
" +6: 1} = 3_{-4} + 6_{+1} + 1_{+6}; Y = X/6 = (-2/3, 1/6, 1)",
len(PAIRS) == 10 and dict(cen) == {-4: 3, 1: 6, 6: 1}
and ys[-4] == Fr(-2, 3) and ys[1] == Fr(1, 6)
and ys[6] == Fr(1), kill="K1")
# pair -> v774 word (the weight-2 words of C_even(5) ARE E(K5))
def word_of_pair(p):
s = sorted(p)
if set(s) <= set(F_SLOTS):
return tuple(1 if k in s else 0 for k in range(3)) + (0,)
if s == [3, 4]:
return (0, 0, 0, 1) # A
i = s[0]
if s[1] == 3: # a-slot => F_i + A
return tuple(1 if k == i else 0 for k in range(3)) + (1,)
return tuple(1 if k == i else 0 for k in range(3)) + (0,) # F_i
ok_tab = True
names = Counter()
for p in PAIRS:
w = word_of_pair(p)
support = tuple(k for k in range(5) if v774.iota(w)[k])
if sum(v774.iota(w)) != 2 or support != tuple(sorted(p)):
ok_tab = False
if v774.xval(w) != pair_charge(p):
ok_tab = False
names[v774.class_of(w)] += 1
check("P1.4 v774-KREUZCHECK: jedes Paar = Traeger eines Gewicht-2-"
"Worts (iota-Support == Paar), Ladung == v774.xval, Klassen "
"%s == {u_c: 3, Q_up: 3, Q_dn: 3, e_c: 1} (die 10 = {q*=1})"
% dict(names),
ok_tab and dict(names) == {"u_c": 3, "Q_up": 3, "Q_dn": 3,
"e_c": 1}, kill="K1")
stab = [pi for pi in itertools.permutations(range(5))
if {pi[3], pi[4]} == set(W_SLOTS)]
ok_struct = all({pi[0], pi[1], pi[2]} == set(F_SLOTS) for pi in stab)
check("P1.5 Stab_{S5}(W): Ordnungszensus %d == 12 = |S3 x S2| "
"(F-Block und W-Block separat permutiert)" % len(stab),
len(stab) == 12 and ok_struct, kill="K1")
return stab
# ==================================================================== P2
def petersen_aut_count(A):
"""full backtracking census of adjacency-preserving bijections."""
n = len(A)
count = [0]
def extend(mapping, used):
k = len(mapping)
if k == n:
count[0] += 1
return
for cand in range(n):
if used[cand]:
continue
ok = True
for j in range(k):
if A[k][j] != A[cand][mapping[j]]:
ok = False
break
if ok:
mapping.append(cand)
used[cand] = True
extend(mapping, used)
mapping.pop()
used[cand] = False
extend([], [False] * n)
return count[0]
def p2_petersen():
section("P2: Petersen KG(5,2) -- SRG, Spektrum, Aut, Schalen, "
"das Hexagon")
n = 10
deg = [sum(ADJ[i]) for i in range(n)]
ok_srg = all(d == 3 for d in deg)
for i in range(n):
for j in range(i + 1, n):
common = sum(ADJ[i][k] * ADJ[j][k] for k in range(n))
if ADJ[i][j] == 1 and common != 0:
ok_srg = False
if ADJ[i][j] == 0 and common != 1:
ok_srg = False
check("P2.1 SRG(10, 3, 0, 1): 3-regulaer, adjazent -> 0 gemeinsame "
"Nachbarn, nicht-adjazent -> 1", ok_srg, kill="K2")
check("P2.2 SPEKTRUM exakt: charpoly = (x-3)(x-1)^5(x+2)^4",
frac_charpoly_check(ADJ, [(3, 1), (1, 5), (-2, 4)]),
kill="K2")
tri = sum(ADJ[i][j] * ADJ[j][k] * ADJ[k][i]
for i in range(n) for j in range(n) for k in range(n))
quad = 0
for quadv in itertools.combinations(range(n), 4):
for perm in itertools.permutations(quadv[1:]):
cyc = (quadv[0],) + perm
if all(ADJ[cyc[a]][cyc[(a + 1) % 4]] for a in range(4)):
quad += 1
has5 = any(
all(ADJ[cyc[a]][cyc[(a + 1) % 5]] for a in range(5))
for sub in itertools.combinations(range(n), 5)
for tail in itertools.permutations(sub[1:])
for cyc in ((sub[0],) + tail,))
# diameter 2: I + A + A^2 > 0 entrywise
A2 = [[sum(ADJ[i][k] * ADJ[k][j] for k in range(n))
for j in range(n)] for i in range(n)]
diam2 = all(ADJ[i][j] + A2[i][j] + (1 if i == j else 0) > 0
for i in range(n) for j in range(n))
m_edges = sum(deg) // 2
check("P2.3 Taillenweite 5 (0 Dreiecke, 0 Viererzyklen, ein "
"5-Zyklus existiert), Durchmesser 2, betti = 15 - 10 + 1 = 6",
tri == 0 and quad == 0 and has5 and diam2
and m_edges == 15 and m_edges - n + 1 == 6, kill="K2")
naut = petersen_aut_count(ADJ)
s5_maps = set()
ok_s5 = True
for pi in itertools.permutations(range(5)):
vperm = tuple(PIDX[frozenset(pi[i] for i in PAIRS[k])]
for k in range(10))
s5_maps.add(vperm)
for a in range(10):
for b in range(10):
if ADJ[a][b] != ADJ[vperm[a]][vperm[b]]:
ok_s5 = False
check("P2.4 |Aut| = %d == 120 (voller Backtracking-Zensus) = die "
"treue S5-Wirkung (120 verschiedene induzierte "
"Automorphismen): Aut(Petersen) = S5" % naut,
naut == 120 and len(s5_maps) == 120 and ok_s5, kill="K2")
# distance shells around the W vertex
w = PIDX[W_VERTEX]
dist = {w: 0}
frontier = [w]
while frontier:
nxt = []
for u in frontier:
for v2 in range(n):
if ADJ[u][v2] and v2 not in dist:
dist[v2] = dist[u] + 1
nxt.append(v2)
frontier = nxt
shells = {d: [i for i in range(n) if dist[i] == d]
for d in set(dist.values())}
sizes = tuple(len(shells[d]) for d in sorted(shells))
charges = {d: {pair_charge(PAIRS[i]) for i in shells[d]}
for d in shells}
check("P2.5 SCHALEN um W: Groessen %s == (1, 3, 6), LADUNGSREIN: "
"d=0 -> {+6} (e^c), d=1 -> {-4} (u^c), d=2 -> {+1} (Q)"
% (sizes,),
sizes == (1, 3, 6) and charges[0] == {6}
and charges[1] == {-4} and charges[2] == {1}, kill="K3")
hexa = shells[2]
degs_in = {i: sum(ADJ[i][j] for j in hexa) for i in hexa}
# connectivity of the induced subgraph
seen = {hexa[0]}
stack = [hexa[0]]
while stack:
u = stack.pop()
for v2 in hexa:
if ADJ[u][v2] and v2 not in seen:
seen.add(v2)
stack.append(v2)
tri_in = sum(ADJ[a][b] * ADJ[b][c] * ADJ[c][a]
for a in hexa for b in hexa for c in hexa)
quad_in = 0
for qv in itertools.combinations(hexa, 4):
for perm in itertools.permutations(qv[1:]):
cyc = (qv[0],) + perm
if all(ADJ[cyc[x]][cyc[(x + 1) % 4]] for x in range(4)):
quad_in += 1
stated = [frozenset(s) for s in
({0, 3}, {1, 4}, {2, 3}, {0, 4}, {1, 3}, {2, 4})]
ok_cycle = all(ADJ[PIDX[stated[k]]][PIDX[stated[(k + 1) % 6]]]
for k in range(6))
check("P2.6 DAS HEXAGON [E neu]: die 6 Distanz-2-Knoten induzieren "
"einen C6 (2-regulaer, zusammenhaengend, keine 3-/4-Zyklen); "
"explizite Ordnung (f1w1, f2w2, f3w1, f1w2, f2w1, f3w2) "
"Kante fuer Kante verifiziert; Crosslink: 6 = |R+(A3)| = p2 "
"= der Transfer-Exponent (v124)",
all(d == 2 for d in degs_in.values()) and len(seen) == 6
and tri_in == 0 and quad_in == 0 and ok_cycle
and len(hexa) == 6, kill="K3")
return shells
# ==================================================================== P3
QPET = [[0, 3, 0], [1, 0, 2], [0, 1, 2]]
def p3_radial(shells):
section("P3: die radiale Dynamik (aequitable Partition, Quotient, "
"Hyperladungs-Eigenvektor)")
cells = [shells[0], shells[1], shells[2]]
ok_eq = True
for ci, cell in enumerate(cells):
for u in cell:
row = [sum(ADJ[u][v] for v in cells[cj]) for cj in range(3)]
if row != QPET[ci]:
ok_eq = False
check("P3.1 AEQUITABEL: jeder Knoten der Zelle i hat exakt "
"Q[i][j] Nachbarn in Zelle j; Quotient == "
"[[0,3,0],[1,0,2],[0,1,2]]", ok_eq, kill="K4")
def matvec(M, v):
return tuple(sum(M[i][j] * v[j] for j in range(3))
for i in range(3))
ones, hyp, third_v = (1, 1, 1), (6, -4, 1), (3, 1, -1)
ok_e1 = matvec(QPET, ones) == (3, 3, 3)
ok_e2 = matvec(QPET, hyp) == (-12, 8, -2)
ok_e3 = matvec(QPET, third_v) == (3, 1, -1)
xw = (pair_charge(W_VERTEX),
pair_charge(PAIRS[shells[1][0]]),
pair_charge(PAIRS[shells[2][0]]))
check("P3.2 EIGENPAARE exakt: (1,1,1)->3; (6,-4,1)->-2 == DER "
"HYPERLADUNGS-VEKTOR (X(WW), X(FF), X(FW)) = %s geordnet "
"(e^c, u^c, Q); (3,1,-1)->1; charpoly(Q_Pet) = "
"(x-3)(x+2)(x-1)" % (xw,),
ok_e1 and ok_e2 and ok_e3 and hyp == xw
and frac_charpoly_check(QPET, [(3, 1), (-2, 1), (1, 1)]),
kill="K4")
P = [[Fr(QPET[i][j], 3) for j in range(3)] for i in range(3)]
ok_stoch = all(sum(P[i]) == 1 for i in range(3))
specP = sorted((Fr(1), Fr(-2, 3), Fr(1, 3)))
specP6 = sorted(x ** 6 for x in specP)
check("P3.3 P = Q_Pet/3 zeilenstochastisch; spec(P) = "
"{1, -2/3, 1/3}; spec(P^6) = {1, 64/729, 1/729} = "
"{1, (2/3)^6, (1/3)^6}",
ok_stoch
and frac_charpoly_check(P, [(Fr(1), 1), (Fr(-2, 3), 1),
(Fr(1, 3), 1)])
and specP6 == sorted([Fr(1), Fr(64, 729), Fr(1, 729)]),
kill="K4")
# ==================================================================== P4
def p4_transport():
section("P4: der Transport-Vergleich (die deployete T-Spektrum-"
"Identifikation)")
from tfpt_constants import g_car, N_fam
FROZEN_SPEC = sorted([Fr(1), Fr(64, 729), Fr(1, 729)])
specP6 = sorted(x ** 6 for x in (Fr(1), Fr(-2, 3), Fr(1, 3)))
check("P4.1 GATE: spec(P_radial^6) == das eingefrorene Transport-"
"Spektrum {1, (2/3)^6, (1/3)^6} EXAKT (v54/v56/v171/v317; "
"v124: lambda_n = (1 - n/3)^6; GATE.METRIC.18: Generator "
"diagonal in der Cusp-Basis)",
specP6 == FROZEN_SPEC
and [Fr(3 - nn, 3) ** 6 for nn in range(3)]
== [Fr(1), Fr(64, 729), Fr(1, 729)], kill="K5")
# v486 sixth-root generator (read-only re-derivation, exact)
s0, h0 = Fr(1, 2), Fr(1, 6)
M = [[Fr(1), Fr(0), Fr(0)], [Fr(0), s0, h0], [Fr(0), h0, s0]]
specM = sorted([Fr(1), s0 + h0, s0 - h0])
check("P4.2 KORPUS-SECHSTE-WURZEL: v486's lazy Z2-pair walk "
"[[1,0,0],[0,1/2,1/6],[0,1/6,1/2]] hat spec {1, 2/3, 1/3} "
"(sub-stochastisch, Zeilensummen {1, 2/3, 2/3}); v327's "
"uniforme Regel {1, 2/3, 0} ist der degenerierte Fall -- "
"T ist im Korpus 3-DIM (Quotient/Cusp-Raum), KEIN 10-dim "
"Operator deployed",
specM == sorted([Fr(1), Fr(2, 3), Fr(1, 3)])
and [sum(r) for r in M] == [1, Fr(2, 3), Fr(2, 3)])
# full 10-dim Petersen prediction [H neu]
P10 = [[Fr(ADJ[i][j], 3) for j in range(10)] for i in range(10)]
ok_p10 = frac_charpoly_check(
P10, [(Fr(1), 1), (Fr(1, 3), 5), (Fr(-2, 3), 4)])
# sixth-power multiplicities via the exact eigenvalue map
mult6 = {Fr(1): 1, Fr(1, 729): 5, Fr(64, 729): 4}
trA6 = 3 ** 6 * 1 + 1 * 5 + 64 * 4
A6 = ADJ
for _ in range(5):
A6 = [[sum(A6[i][k] * ADJ[k][j] for k in range(10))
for j in range(10)] for i in range(10)]
check("P4.3 VOLLE PETERSEN-VORHERSAGE [H neu]: spec(P10) = "
"{1, (1/3)^5, (-2/3)^4}; spec(P10^6) = {1^1, (1/3)^6 x5, "
"(2/3)^6 x4} -- schneller Modus x5 = g_car = %d, langsamer "
"Hyperladungs-Modus x4 = |mu4| = 4; Spur-Kreuzcheck "
"tr A^6 = %d == 990 = 729 + 5 + 4*64; KEIN Korpus-"
"Gegenstueck (T ist 3-dim) -- Vorhersage, nicht Verifikation"
% (g_car, sum(A6[i][i] for i in range(10))),
ok_p10 and mult6[Fr(1, 729)] == g_car == 5
and mult6[Fr(64, 729)] == 4
and sum(A6[i][i] for i in range(10)) == trA6 == 990,
kill="K5")
print(" HONEST SIGN NOTE: der radiale Unterleit-Eigenwert ist "
"-2/3 (negativ); das Vorzeichen ist im deployeten Sechst-"
"Potenz-Spektrum unsichtbar. Die PSD-Sechstwurzel ist "
"TRANSPORT.SIXTHROOT.01 (Schwester-Probe).")
print(" N_fam-Kreuzcheck: %d Zellen = N_fam = %d Cusp-Stufen"
% (3, N_fam))
# ==================================================================== C
def c_controls():
section("C: Must-fail-Kontrollen")
# C1: wrong edge F|W = 4+1
Xbad_sols = [(x, y) for x in range(-12, 13) for y in range(-12, 13)
if 4 * x + y == 0 and (x, y) != (0, 0)
and gcd(abs(x), abs(y)) == 1]
xb, yb = -1, 4
Xbad = (xb, xb, xb, xb, yb)
cen_bad = Counter(sum(Xbad[i] for i in p) for p in PAIRS)
w_pairs = [p for p in PAIRS if p <= {4}]
check("C1 KONTROLLE FEUERT (falsche Kante F|W = 4+1): primitive "
"Loesung (-1,4); Paar-Ladungszensus %s hat nur 2 Klassen "
"(6+4), KEIN intra-W-Paar existiert (%d) -- die (1,3,6)-"
"Struktur bricht" % (dict(cen_bad), len(w_pairs)),
sorted(Xbad_sols) == [(-1, 4), (1, -4)]
and len(cen_bad) == 2
and sorted(cen_bad.values()) == [4, 6] and not w_pairs)
# C2: scrambled adjacency (Johnson complement: share exactly one)
ADJ_J = adjacency(PAIRS, lambda a, b: len(a & b) == 1)
hexa = [PIDX[frozenset(s)] for s in
({0, 3}, {1, 4}, {2, 3}, {0, 4}, {1, 3}, {2, 4})]
degs = {i: sum(ADJ_J[i][j] for j in hexa) for i in hexa}
check("C2 KONTROLLE FEUERT (verwuerfelte Adjazenz = Johnson-"
"Komplement): das Hexagon wird %s-regulaer statt 2-regulaer "
"-- der C6 bricht" % sorted(set(degs.values())),
set(degs.values()) == {3})
# ======================================================================
def main():
print("=" * 78)
print("CARRIER.PETERSEN.RADIAL.01 -- die K5-Kantenmaschine, "
"Petersen, radiale Dynamik")
print("=" * 78, flush=True)
p1_edge_machine()
shells = p2_petersen()
p3_radial(shells)
p4_transport()
c_controls()
section("ZUSAMMENFASSUNG / VERDIKT")
n_pass = sum(1 for _, ok in CHECKS if ok)
n_all = len(CHECKS)
controls_ok = all(ok for nm, ok in CHECKS if nm.startswith("C"))
print("%d/%d Checks bestanden" % (n_pass, n_all))
if KILLS or not controls_ok:
verdict = "PETERSEN-RADIAL-DEAD"
print("VERDIKT: PETERSEN-RADIAL-DEAD -- Kills: %s%s"
% (sorted(set(KILLS)),
"" if controls_ok else " (+ Kontrolle feuert nicht)"))
elif n_pass == n_all:
verdict = "PETERSEN-RADIAL-EXACT"
print("VERDIKT: PETERSEN-RADIAL-EXACT -- X eindeutig, Dekuple "
"3_{-4}+6_{+1}+1_{+6} == v774-Tafel, Petersen SRG(10,3,"
"0,1) mit Aut = S5, Schalen (1,3,6) ladungsrein, das "
"Hexagon = die Distanz-2-Schale, Quotient aequitabel "
"mit Hyperladungs-Eigenvektor (6,-4,1) -> -2, "
"spec(P^6) == das deployete Transport-Spektrum exakt; "
"10-dim Multiplizitaeten (x5 = g_car, x4 = |mu4|) als "
"[H neu]-Vorhersage.")
else:
verdict = "PETERSEN-RADIAL-PARTIAL"
print("VERDIKT: PETERSEN-RADIAL-PARTIAL -- kein Kill, aber "
"Nicht-Kill-Checks gescheitert; siehe FAIL-Zeilen.")
_LAST1["verdict"] = verdict
print("Verdikt-Enum: %s" % verdict)
print("Laufzeit: %.1f s" % (time.time() - T0))
print("ALLE CHECKS BESTANDEN" if n_pass == n_all
else "CHECKS FEHLGESCHLAGEN")
return 0 if n_pass == n_all else 1
_run_part1 = main
def _run_part2():
"""Part 2: transport_sixthroot_probe.py, promoted verbatim in a function scope (v789/v795 precedent)."""
import os
import sys
import time
from fractions import Fraction as Fr
_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)
T0 = time.time()
CHECKS = []
KILLS = []
BITEXACT_HITS = []
def check(name, ok, detail="", kill=None):
CHECKS.append((name, bool(ok)))
if kill and not ok:
KILLS.append(kill)
print("[%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("=" * 78)
print(title)
print("=" * 78, flush=True)
# ------------------------------------------------------------- helpers
def mat(rows):
return [[Fr(x) for x in r] for r in rows]
def mmul(A, B):
n, m, p = len(A), len(B[0]), len(B)
return [[sum(A[i][k] * B[k][j] for k in range(p)) for j in range(m)]
for i in range(n)]
def mpow(A, k):
R = [[Fr(1) if i == j else Fr(0) for j in range(len(A))]
for i in range(len(A))]
for _ in range(k):
R = mmul(R, A)
return R
def matvec(A, v):
return tuple(sum(A[i][j] * v[j] for j in range(len(v)))
for i in range(len(A)))
def outer(v, w):
return [[Fr(v[i] * w[j]) for j in range(len(w))]
for i in range(len(v))]
def madd(*Ms):
n = len(Ms[0])
return [[sum(M[i][j] for M in Ms) for j in range(n)]
for i in range(n)]
def mscale(c, M):
return [[c * M[i][j] for j in range(len(M[0]))]
for i in range(len(M))]
def fmt(M):
return "[" + "; ".join(",".join(str(x) for x in r) for r in M) + "]"
B = mat([[Fr(13, 18), Fr(1, 18), Fr(4, 18)],
[Fr(1, 18), Fr(13, 18), Fr(4, 18)],
[Fr(4, 18), Fr(4, 18), Fr(10, 18)]])
V1, V2, V3 = (1, 1, 1), (1, -1, 0), (1, 1, -2)
EIG = {V1: Fr(1), V2: Fr(2, 3), V3: Fr(1, 3)}
# ==================================================================== S1
def s1_compiler_numbers():
section("S1: Compiler-Zahlen-Identifikationen gegen tfpt_constants")
from tfpt_constants import g_car, N_fam
Z2 = g_car - N_fam
mu4 = 4
A_Lambda = Z2 * g_car
N_Phi = 1
anchor = (1, 1, 2)
p = [sum(a ** k for a in anchor) for k in range(1, 5)]
check("S1.1 Anker-Potenzsummen p1..p4(1,1,2) = %s == (4, 6, 10, 18)"
": p1 = |mu4|, p2 = 6 = |R+(A3)| (die Hand, v486), "
"p3 = A_Lambda (v397), p4 = 18 = der Nenner" % (p,),
p == [4, 6, 10, 18] and p[0] == mu4 and p[2] == A_Lambda,
kill="K1")
check("S1.2 13 = 3^2 + 2^2 = N_fam^2 + Z2^2 (der (b,s) = (3,2)-"
"Split, v14); 4 = |mu4|; 10 = A_Lambda = |E(K5)| = |Z2|*"
"g_car = %d (v212/v397); 1 = N_Phi (EM-Budget 41 = 40 + "
"N_Phi, v159)" % A_Lambda,
13 == N_fam ** 2 + Z2 ** 2 and mu4 == 4
and A_Lambda == 10 and N_Phi == 1, kill="K1")
check("S1.3 Zeilensummen-Konsistenz: 13 + 1 + 4 = 18 = p4 und "
"4 + 4 + 10 = 18; Eintraege = {13, 1, 4, 10} = "
"{3^2+2^2, N_Phi, |mu4|, A_Lambda} / 18",
13 + 1 + 4 == 18 and 4 + 4 + 10 == 18, kill="K1")
# ==================================================================== S2
def s2_matrix_laws():
section("S2: Matrixgesetze (symmetrisch, doppelt-stochastisch, "
"PSD, Eigensystem exakt)")
sym = all(B[i][j] == B[j][i] for i in range(3) for j in range(3))
rows = [sum(B[i]) for i in range(3)]
cols = [sum(B[i][j] for i in range(3)) for j in range(3)]
check("S2.1 B symmetrisch; doppelt-stochastisch (Zeilen %s, "
"Spalten %s); alle Eintraege > 0"
% (rows, cols),
sym and rows == [1, 1, 1] and cols == [1, 1, 1]
and all(B[i][j] > 0 for i in range(3) for j in range(3)),
kill="K2")
ok_vec = all(matvec(B, v) == tuple(lam * x for x in v)
for v, lam in EIG.items())
from sympy import Matrix, Rational, symbols, expand
x = symbols("x")
cp = Matrix(3, 3, lambda i, j: Rational(B[i][j].numerator,
B[i][j].denominator)
).charpoly(x).as_expr()
target = expand((x - 1) * (x - Rational(2, 3)) * (x - Rational(1, 3)))
check("S2.2 EIGENSYSTEM exakt: (1,1,1)->1, (1,-1,0)->2/3, "
"(1,1,-2)->1/3 (exakter Matvec); charpoly = "
"(x-1)(x-2/3)(x-1/3)",
ok_vec and expand(cp - target) == 0, kill="K2")
m1 = B[0][0]
m2 = B[0][0] * B[1][1] - B[0][1] * B[1][0]
det = (B[0][0] * (B[1][1] * B[2][2] - B[1][2] * B[2][1])
- B[0][1] * (B[1][0] * B[2][2] - B[1][2] * B[2][0])
+ B[0][2] * (B[1][0] * B[2][1] - B[1][1] * B[2][0]))
check("S2.3 PSD: fuehrende Hauptminoren (%s, %s, %s) > 0; "
"det B = 2/9 = 1*(2/3)*(1/3); Spur = 2 = 1 + 2/3 + 1/3"
% (m1, m2, det),
m1 > 0 and m2 > 0 and det == Fr(2, 9) == Fr(1) * Fr(2, 3)
* Fr(1, 3) and sum(B[i][i] for i in range(3)) == 2,
kill="K2")
# ==================================================================== S3
def s3_uniqueness():
section("S3: Eindeutigkeit gegeben die Zuordnung / Freiheits-Zensus")
ortho = (sum(a * b for a, b in zip(V2, V3)) == 0
and sum(a * b for a, b in zip(V1, V2)) == 0
and sum(a * b for a, b in zip(V1, V3)) == 0)
B_rec = madd(mscale(Fr(1, 3), outer(V1, V1)),
mscale(Fr(2, 3) / 2, outer(V2, V2)),
mscale(Fr(1, 3) / 6, outer(V3, V3)))
check("S3.1 EINDEUTIG: Basis orthogonal; Spektralsumme J/3 + "
"(2/3) vv^T/2 + (1/3) ww^T/6 == B EINTRAG-EXAKT => B ist "
"die einzige symmetrische Matrix mit dieser Zuordnung "
"(doppelte Stochastik folgt)",
ortho and B_rec == B, kill="K3")
B_swap = madd(mscale(Fr(1, 3), outer(V1, V1)),
mscale(Fr(1, 3) / 2, outer(V2, V2)),
mscale(Fr(2, 3) / 6, outer(V3, V3)))
swap_expect = mat([[Fr(11, 18), Fr(5, 18), Fr(2, 18)],
[Fr(5, 18), Fr(11, 18), Fr(2, 18)],
[Fr(2, 18), Fr(2, 18), Fr(14, 18)]])
rows_sw = [sum(B_swap[i]) for i in range(3)]
check("S3.2 ZENSUS in der Korpus-Basis: die getauschte Zuordnung "
"gibt B_swap = (1/18)[[11,5,2],[5,11,2],[2,2,14]] != B "
"(ebenfalls symmetrisch doppelt-stochastisch) -- genau 2 "
"Zuordnungen, die angegebene waehlt B",
B_swap == swap_expect and B_swap != B
and rows_sw == [1, 1, 1], kill="K3")
# (b) the theta-circle: without the eigenvector pin, a 1-parameter
# family of symmetric doubly stochastic solutions exists
from sympy import (Matrix, Rational, cos, sin, symbols, simplify,
eye, ones)
th = symbols("theta", real=True)
u2 = Matrix([1, -1, 0]) / Matrix([1, -1, 0]).norm()
u3 = Matrix([1, 1, -2]) / Matrix([1, 1, -2]).norm()
e = cos(th) * u2 + sin(th) * u3
P_th = e * e.T
J3 = ones(3, 3) / 3
B_th = J3 + Rational(2, 3) * P_th \
+ Rational(1, 3) * (eye(3) - J3 - P_th)
rowsums = [simplify(sum(B_th[i, j] for j in range(3)))
for i in range(3)]
symm = all(simplify(B_th[i, j] - B_th[j, i]) == 0
for i in range(3) for j in range(3))
at0 = all(simplify(B_th[i, j].subs(th, 0)
- Rational(B[i][j].numerator,
B[i][j].denominator)) == 0
for i in range(3) for j in range(3))
check("S3.3 FREIHEIT ohne Eigenvektor-Pin: B_theta = J/3 + (2/3) "
"P_theta + (1/3)(I - J/3 - P_theta) ist fuer JEDES theta "
"symmetrisch mit Zeilensummen 1 (symbolisch verifiziert; "
"1-Parameter-Kreis) und B_0 == B -- die Korpus-Basis pinnt "
"auf 2 Punkte, die Zuordnung auf B allein",
all(r == 1 for r in rowsums) and symm and at0)
# ==================================================================== S4
def s4_sixth_power():
section("S4: B^6 bit-exakt (Fraction-Potenz == Spektralformel)")
B6 = mpow(B, 6)
B6_spec = madd(mscale(Fr(1, 3), outer(V1, V1)),
mscale(Fr(64, 729) / 2, outer(V2, V2)),
mscale(Fr(1, 729) / 6, outer(V3, V3)))
expect = mat([[Fr(1651, 4374), Fr(1267, 4374), Fr(1456, 4374)],
[Fr(1267, 4374), Fr(1651, 4374), Fr(1456, 4374)],
[Fr(1456, 4374), Fr(1456, 4374), Fr(1462, 4374)]])
check("S4.1 B^6 = (1/4374)[[1651,1267,1456],[1267,1651,1456],"
"[1456,1456,1462]]: direkte Fraction-Potenz == "
"Spektralformel == erwartete Matrix",
B6 == B6_spec == expect, kill="K4")
ok_vec6 = all(matvec(B6, v) == tuple(lam ** 6 * x for x in v)
for v, lam in EIG.items())
check("S4.2 spec(B^6) = {1, 64/729, 1/729} = das deployete "
"Transport-Spektrum (v54/v56/v171/v317); B^6 doppelt-"
"stochastisch (Zeilensummen %s)"
% [sum(B6[i]) for i in range(3)],
ok_vec6 and [sum(B6[i]) for i in range(3)] == [1, 1, 1],
kill="K4")
return B6
# ==================================================================== S5
def s5_decider(B6):
section("S5: DER ENTSCHEIDER -- bit-exakt vs. nur spektral")
D = mat([[1, 0, 0], [0, Fr(64, 729), 0], [0, 0, Fr(1, 729)]])
hit_diag = (B6 == D)
if hit_diag:
BITEXACT_HITS.append("cusp-diagonal D")
diff = [[B6[i][j] - D[i][j] for j in range(3)] for i in range(3)]
print(" B^6 - D (exakt): %s" % fmt(diff))
U = mat([[1, 1, 1], [1, -1, 1], [1, 0, -2]])
# U columns = (1,1,1), (1,-1,0), (1,1,-2)
UD = mmul(U, D)
B6U = mmul(B6, U)
check("S5.1 (i) Cusp-diagonale kanonische Form (GATE.METRIC.18): "
"B^6 %s D = diag(1, 64/729, 1/729) bit-exakt; exakte "
"RATIONALE Konjugation B^6 U = U D mit U = [[1,1,1],"
"[1,-1,1],[1,0,-2]] (Spalten = die Eigenbasis)"
% ("==" if hit_diag else "!="),
B6U == UD, kill="K5")
# (ii) v486 lazy walk, re-derived exactly
M = mat([[1, 0, 0],
[0, Fr(1, 2), Fr(1, 6)],
[0, Fr(1, 6), Fr(1, 2)]])
M6 = mpow(M, 6)
a = (Fr(64, 729) + Fr(1, 729)) / 2
b = (Fr(64, 729) - Fr(1, 729)) / 2
M6_expect = mat([[1, 0, 0], [0, a, b], [0, b, a]])
rows_m6 = [sum(M6[i]) for i in range(3)]
hit_lazy = (B6 == M6)
if hit_lazy:
BITEXACT_HITS.append("v486 lazy walk M^6")
check("S5.2 (ii) v486 lazy Z2-pair walk: M^6 = [[1,0,0],[0,65/1458,"
"63/1458],[0,63/1458,65/1458]] exakt (a,b = %s, %s); "
"Zeilensummen %s (SUB-stochastisch) => B^6 %s M^6 bit-exakt"
% (a, b, rows_m6, "==" if hit_lazy else "!="),
M6 == M6_expect and not hit_lazy, kill="K5")
# exact rational conjugation W = U V^{-1}, W M^6 W^{-1} = B^6
V = mat([[1, 0, 0], [0, 1, 1], [0, 1, -1]])
# V columns = M eigenvectors (1,0,0), (0,1,1), (0,1,-1) for 1, 2/3, 1/3
ok_v = all(matvec(M, (V[0][k], V[1][k], V[2][k]))
== tuple(lam * x for x in (V[0][k], V[1][k], V[2][k]))
for k, lam in enumerate([Fr(1), Fr(2, 3), Fr(1, 3)]))
from sympy import Matrix, Rational, sqrt, simplify
def to_sym(A):
return Matrix(3, 3, lambda i, j: Rational(A[i][j].numerator,
A[i][j].denominator))
Us, Vs, Ms6, Bs6 = to_sym(U), to_sym(V), to_sym(M6), to_sym(B6)
W = Us * Vs.inv()
ok_rat = simplify(W * Ms6 * W.inv() - Bs6) == Matrix.zeros(3, 3)
# orthogonal conjugation from unit eigenvectors
bvecs = [Matrix(v) / Matrix(v).norm() for v in (V1, V2, V3)]
mvecs = [Matrix(v) / Matrix(v).norm()
for v in ((1, 0, 0), (0, 1, 1), (0, 1, -1))]
O = sum((bvecs[k] * mvecs[k].T for k in range(3)),
Matrix.zeros(3, 3))
ok_orth = (simplify(O * O.T - Matrix.eye(3)) == Matrix.zeros(3, 3)
and simplify(O * Ms6 * O.T - Bs6) == Matrix.zeros(3, 3))
check("S5.3 EXAKTE KONJUGATIONEN: rationales W = U V^{-1} in "
"GL(3,Q) mit W M^6 W^{-1} = B^6; orthogonales O (Eintraege "
"in Q(sqrt2, sqrt3, sqrt6)) mit O O^T = I und O M^6 O^T = "
"B^6 -- TYP: spektrale Aequivalenz, KEINE bit-exakte "
"Identitaet; stochastische Typen verschieden (doppelt- vs. "
"sub-stochastisch mit absorbierendem Kanal)",
ok_v and ok_rat and ok_orth, kill="K5")
print(" KORPUS-IDENTIFIKATION von T: eingefrorenes SPEKTRUM "
"{1, (2/3)^6, (1/3)^6} auf dem 3-dim Cusp-Raum "
"(v54_seam_horizon_keystones, v56_unique_attractor [Matrix "
"dort nur Float-Demonstration], v171_os_moment_cluster, "
"v317_galois_family, v124_resummed_clock); expliziter "
"Sechstwurzel-Generator: v486_transfer_full_rule (lazy "
"Z2-pair walk); degeneriert: v327_hypergraph_rewrite; "
"kanonische Form: cusp-diagonal (GATE.METRIC.18).")
# ==================================================================== C
def c_controls():
section("C: Must-fail-Kontrollen")
Bp = mat([[Fr(12, 18), Fr(2, 18), Fr(4, 18)],
[Fr(2, 18), Fr(12, 18), Fr(4, 18)],
[Fr(4, 18), Fr(4, 18), Fr(10, 18)]])
lam_v2 = matvec(Bp, V2)
fired1 = lam_v2 == tuple(Fr(5, 9) * x for x in V2)
check("C1 KONTROLLE FEUERT (doppelt-stochastische Stoerung "
"13->12, 1->2): der (1,-1,0)-Eigenwert wird 5/9 != 2/3 -- "
"das Spektrum bricht",
fired1 and Fr(5, 9) != Fr(2, 3))
Bpp = [row[:] for row in B]
Bpp[0][0] = Fr(14, 18)
rows_pp = [sum(Bpp[i]) for i in range(3)]
from sympy import Matrix, Rational, symbols
x = symbols("x")
cp = Matrix(3, 3, lambda i, j: Rational(Bpp[i][j].numerator,
Bpp[i][j].denominator)
).charpoly(x)
still = all(cp.eval(Rational(v.numerator, v.denominator)) == 0
for v in (Fr(1), Fr(2, 3), Fr(1, 3)))
check("C2 KONTROLLE FEUERT (rohe Eintrags-Stoerung B_00 -> 14/18):"
" Zeilensummen %s != (1,1,1) und {1, 2/3, 1/3} ist NICHT "
"mehr im Spektrum enthalten" % (rows_pp,),
rows_pp != [1, 1, 1] and not still)
# ======================================================================
def main():
print("=" * 78)
print("TRANSPORT.SIXTHROOT.01 -- der bit-exakte Test der PSD-"
"Sechstwurzel B")
print("=" * 78, flush=True)
s1_compiler_numbers()
s2_matrix_laws()
s3_uniqueness()
B6 = s4_sixth_power()
s5_decider(B6)
c_controls()
section("ZUSAMMENFASSUNG / VERDIKT")
n_pass = sum(1 for _, ok in CHECKS if ok)
n_all = len(CHECKS)
controls_ok = all(ok for nm, ok in CHECKS if nm.startswith("C"))
print("%d/%d Checks bestanden" % (n_pass, n_all))
if KILLS or not controls_ok:
verdict = "SIXTHROOT-DEAD"
print("VERDIKT: SIXTHROOT-DEAD -- Kills: %s%s"
% (sorted(set(KILLS)),
"" if controls_ok else " (+ Kontrolle feuert nicht)"))
elif BITEXACT_HITS:
verdict = "SIXTHROOT-BITEXACT"
print("VERDIKT: SIXTHROOT-BITEXACT -- Treffer: %s"
% BITEXACT_HITS)
else:
verdict = "SIXTHROOT-SPECTRAL-ONLY"
print("VERDIKT: SIXTHROOT-SPECTRAL-ONLY -- B ist die "
"eindeutige symmetrische doppelt-stochastische "
"PSD-Sechstwurzel in der Korpus-Basis mit der "
"angegebenen Zuordnung; B^6 traegt exakt das deployete "
"Spektrum, aber KEINE deployete Korpus-Matrix ist "
"bit-exakt B^6 (der Korpus friert das Spektrum ein, "
"nicht die Basis); Konjugationstyp: rational GL(3,Q) "
"(auch orthogonal-irrational) auf v486's M^6 bzw. die "
"cusp-diagonale Form.")
_LAST2["verdict"] = verdict
print("Verdikt-Enum: %s" % verdict)
print("Laufzeit: %.1f s" % (time.time() - T0))
print("ALLE CHECKS BESTANDEN" if n_pass == n_all
else "CHECKS FEHLGESCHLAGEN")
return 0 if n_pass == n_all else 1
rc = main()
return rc, list(CHECKS)
def run():
"""run_all entry point (combined adjudication): part 1 must be 19/19
(PETERSEN-RADIAL-EXACT), part 2 must be 16/16
(SIXTHROOT-SPECTRAL-ONLY)."""
rc1 = _run_part1()
fails1 = [n for (n, ok) in CHECKS if not ok]
v1 = _LAST1.get("verdict", "")
part1_ok = (rc1 == 0 and not fails1 and len(CHECKS) == 19
and v1 == "PETERSEN-RADIAL-EXACT")
print("\n[%s] PART-1 PATTERN GATE: expected 19/19 "
"(PETERSEN-RADIAL-EXACT) -- got %d checks, fails: %s, "
"verdict: %s"
% ("PASS" if part1_ok else "FAIL", len(CHECKS),
fails1 or "none", v1))
rc2, chks2 = _run_part2()
fails2 = [n for (n, ok) in chks2 if not ok]
v2 = _LAST2.get("verdict", "")
part2_ok = (rc2 == 0 and not fails2 and len(chks2) == 16
and v2 == "SIXTHROOT-SPECTRAL-ONLY")
print("\n[%s] PART-2 PATTERN GATE: expected 16/16 "
"(SIXTHROOT-SPECTRAL-ONLY) -- got %d checks, fails: %s, "
"verdict: %s"
% ("PASS" if part2_ok else "FAIL", len(chks2),
fails2 or "none", v2))
ok = part1_ok and part2_ok
print("\nCOMBINED ADJUDICATION: %s -- PETERSEN-RADIAL-EXACT + "
"SIXTHROOT-SPECTRAL-ONLY: the K5 edge machine is exact (the "
"charge X unique, the decuple 3_{-4}+6_{+1}+1_{+6} == the "
"certified v774 table, Petersen SRG(10,3,0,1) with Aut = S5, "
"shells (1,3,6) charge-pure, the flavor hexagon = the "
"distance-2 shell, equitable quotient with hypercharge "
"eigenvector (6,-4,1) -> -2, spec(P^6) == the deployed "
"transport spectrum exactly; the 10-dim multiplicity reading "
"x5 = g_car / x4 = |mu4| stays an [H neu] prediction); B is "
"the unique symmetric doubly stochastic PSD sixth root in the "
"corpus basis, B^6 carries the deployed spectrum exactly but "
"is bit-equal to NO deployed corpus matrix (GL(3,Q)-conjugate "
"to v486's M^6 and the cusp-diagonal form) -- the corpus "
"freezes the spectrum, not the basis. NO RH claim."
% ("PASS" if ok else "FAIL"))
return 0 if ok else 1
if __name__ == "__main__":
raise SystemExit(run())
Recorded source fingerprint
b92c657934e960f63561fc65804877ef4080194420ce5c3fb0214506ced80efc
Paper sections that cite this module
The module’s catalogue entry retains all 13 section references.
What this source index covers
The public registry includes 116 document views, 6,693 section records and 985 physical LaTeX sources. Active publication documents, research material and archives retain their recorded roles. This is source navigation, not a new semantic review or proof run.