"""v506 -- SEAM.CLOCK.RIGIDITY.01: clock rigidity, Route B of the v503 classification -- how much of the order-4 seam clock is FORCED by established seam data? v503 (QGEO.EMERGE.LIGHT.01) localised the one remaining identification input: mark count 4 is derived (v216), the square modulus is derived GIVEN the clock (v493/v503), free dynamics picks hexagonal -- the order-4 clock itself was the carrier input [C], identical to the P2 typing rest R1 (v499). This module proves TWO theorems that reduce that input to ONE alignment bit, in two parts (Part A = Moebius/divisor side, Part B = fermionic/Fock side). Exact throughout (sympy; Fractions in Cl(16); no floats), deterministic. [E] PART A, THEOREM A (Moebius side; complete square-root classification): the collar deck z -> -z has in PGL2(C) EXACTLY TWO square roots (z -> +iz, z -> -iz), both AUTOMATICALLY of order 4 (complete case analysis: tr g != 0 forces diagonal with (a/d)^2 = -1; tr g = 0 forces det = 0, impossible) -- "order 4" is NOT an input once "square root of the deck" is given. A marks-preserving square root exists <=> the deck is the CENTRAL involution of the mark- stabiliser D4 (center = {id, deck}; exactly 2 order-4 elements = the clock pair, both squaring to the deck) ==> then the marks are one mu4 orbit, cross-ratio class {2, 1/2, -1}, j = 1728, tau = i, free 4-cycle, deck = clock^2, only the scale free (= the v492 S5 one-parameter family). COUNTEREXAMPLE (mandatory): {+-1, +-(3+2 sqrt2)} is deck-free AND harmonic (j = 1728) with full D4 stabiliser, but the deck sits in it NON-centrally (edge-type involution, the true central involution crosses the +- pairs) => ZERO roots -- harmonicity alone is NOT sufficient; the residual datum is deck-CENTRALITY (one bit), not the j-invariant. The RP filter selects nothing: both real structures pass both roots -- the Aut(Z4) = {clock, clock^-1} ambiguity is irreducible (consistent with v492 NC3). [E] PART A, B3/B4 (n-arithmetic + controls): a free Z_n on 4 marks forces n | 4; marks-transitivity forces n = 4; faithfulness (a Moebius map fixing >= 3 points is the identity) kills every n >= 5; n = 3 fixes a mark (hexagonal shadow); n = 6 dies INDEPENDENTLY at the cusp-class degree 3 (lam^5 - 1 has deg 5 != 3 = deg(lam^3 - 1), v117); the deck is modulus-blind (every {+-1, +-w} preserved -- v503 B5 exact). Controls: NO order-8 element preserves any 4-set (orbits of size 8); hexagonal marks have stabiliser A4 (order 12, ZERO order-4 elements, squares only orders {1, 3}); generic marks have Klein V4 (exponent 2 -- not even the deck has a root); stabiliser trichotomy V4/D4/A4 with order-4 counts (0, 2, 0): an order-4 element exists IFF the marks are harmonic, and then it is the clock pair. [E] PART B, THEOREM B (Fock side; the core result): the celestial sphere S^2 has b1 = 0, hence a UNIQUE spin structure whose restriction to any circle is the BOUNDING = NS/antiperiodic one (established P1 datum, v492/v490). One-particle level: the NS half-rotation D has D^2 = -1 (charpoly (lam^2+1)^8) -- the "Z2" deck is already order 4 before any Fock choice; the quarter-shift C has C^2 = D, C^8 = 1 (charpoly (lam^4+1)^4, zeta8 spectrum). Fock level: the Bogoliubov implementer Utilde = prod_j (1 - gamma_j gamma_{j+8}) satisfies Utilde^2 = 256 gamma_1...gamma_16, i.e. U^2 = (-1)^F EXACTLY, and (cU)^2 = c^2 (-1)^F is NEVER 1 (center of Cl(16) = scalars): the Z4 lift is FORCED -- 1 -> Z2^{(-1)^F} -> Z4 -> Z2^{deck} -> 1 is a NONSPLIT extension. Z8 tower: the quarter-shift lift V has V^2 prop Utilde, V^4 prop (-1)^F, projective order 8 = 2|mu4| -- the v492 Z8 spin bridge realised on the 16-Majorana Fock space, fermionically explained. R control: U_R^2 = +1 (split -- the forcing rests entirely on NS = the established geometry); 16-fold way: theta_v = 1 at nu = 16 (gaugeable point); robustness: the forcing already holds at 8 sites (16 is the carrier count 2^(g_car-1), not a tuning). [C] THE ONE RESIDUAL (verbatim): "the collar deck is the central involution of the mark-D4" (<=> square-root existence on the mark data) -- ONE alignment bit; the fermionic Z4 forces the ORDER, not the spatial alignment. No overclaim: given the bit, order 4, uniqueness up to Aut(Z4), the free 4-cycle, tau = i (scale free) and deck = clock^2 are all THEOREMS; without it, nothing pins the modulus. Status: [E] both theorems (exact sympy / exact Cl(16) Fractions); [C] the single alignment bit above. QGEO.REALIZE.01 stays [C]/[O] (text precised only), P2.TYPING.01 R1 mapped onto the same bit -- NO marker moves. Python; Wolfram-mirrored (square-root classification, D4 center + order-4 counts, counterexample arithmetic, Cl(16) identity Utilde^2 = 256 gamma_1...gamma_16, stabiliser trichotomy), counted per GATE.WOLFRAM.02. Discovery provenance: experiments/tfpt-discovery/ seam_clock_rigidity_moebius_probe.py (2026-07-21, 19/19) and seam_clock_rigidity_fock_probe.py (2026-07-21, 15/15).""" from fractions import Fraction as Fr from itertools import permutations import sympy as sp from sympy.combinatorics import Permutation from tfpt_constants import check, summary, reset, g_car, N_fam I = sp.I MU4 = N_fam + 1 # 4 = |mu4|, the seam clock order N_SITES = 16 # 16 Majorana modes = 2^(g_car-1), 4 per mark quadrant MARKS = [0, 4, 8, 12] # mu4 mark sites (0-based) on the 16-site seam circle def iszero(e): e2 = sp.expand(e) if e2 == 0: return True return sp.simplify(e2) == 0 # --------------------------------------------------------------------------- # PART A machinery: projective points (p, q), exact Moebius maps # --------------------------------------------------------------------------- def peq(P, Q): return iszero(P[0] * Q[1] - P[1] * Q[0]) def apply_m(M, P): return (sp.expand(M[0, 0] * P[0] + M[0, 1] * P[1]), sp.expand(M[1, 0] * P[0] + M[1, 1] * P[1])) def map3(A, B, C): """the unique Moebius matrix sending (inf, 0, 1) -> (A, B, C).""" alpha = C[0] * B[1] - B[0] * C[1] beta = A[0] * C[1] - C[0] * A[1] return sp.Matrix([[alpha * A[0], beta * B[0]], [alpha * A[1], beta * B[1]]]) def mexp(M): return M.applyfunc(sp.expand) def prop_mat(A, B): """projective equality of 2x2 matrices (A = c B).""" a = [A[0, 0], A[0, 1], A[1, 0], A[1, 1]] b = [B[0, 0], B[0, 1], B[1, 0], B[1, 1]] for i in range(4): for j in range(i + 1, 4): if not iszero(a[i] * b[j] - a[j] * b[i]): return False return True def is_scalar_mat(M): return iszero(M[0, 1]) and iszero(M[1, 0]) and iszero(M[0, 0] - M[1, 1]) def proj_order(M, cap=9): P = sp.eye(2) for n in range(1, cap + 1): P = mexp(P * M) if is_scalar_mat(P): return n return None def stabilizer(cfg): """ALL Moebius maps preserving the 4-point set cfg (complete: a Moebius map is fixed by the images of 3 points => enumerate all 24 ordered triples).""" S = map3(cfg[0], cfg[1], cfg[2]) Sinv = S.adjugate() found = [] for t in permutations(range(4), 3): T = map3(cfg[t[0]], cfg[t[1]], cfg[t[2]]) M = mexp(T * Sinv) ok = all(any(peq(apply_m(M, p), q) for q in cfg) for p in cfg) if ok and not any(prop_mat(M, X) for X in found): found.append(M) return found def mark_perm(M, cfg): perm = [] for p in cfg: img = apply_m(M, p) perm.append([j for j, q in enumerate(cfg) if peq(img, q)][0]) return perm def order_profile(stab): prof = {} for g in stab: o = proj_order(g) prof[o] = prof.get(o, 0) + 1 return prof def cross_ratio(P1, P2, P3, P4): d = lambda X, Y: X[0] * Y[1] - Y[0] * X[1] return sp.simplify(sp.expand(d(P1, P3) * d(P2, P4)) / sp.expand(d(P1, P4) * d(P2, P3))) def jlam(lam): return sp.simplify(256 * (lam ** 2 - lam + 1) ** 3 / (lam ** 2 * (lam - 1) ** 2)) DECK = sp.diag(1, -1) # z -> -z (the P1 collar involution) CLOCK = sp.diag(I, 1) # z -> iz CLOCKINV = sp.diag(-I, 1) # z -> -iz # --------------------------------------------------------------------------- # PART B machinery: abstract Clifford algebra Cl(n), exact Fractions # --------------------------------------------------------------------------- def mono_mul(m1, m2): """product of two monomials (sorted tuples); gamma_a^2 = 1.""" out = list(m1) sign = 1 for g in m2: out.append(g) i = len(out) - 1 while i > 0 and out[i - 1] > out[i]: out[i - 1], out[i] = out[i], out[i - 1] sign = -sign i -= 1 if i > 0 and out[i - 1] == out[i]: del out[i - 1:i + 1] return sign, tuple(out) def cmul(x, y): out = {} for m1, c1 in x.items(): for m2, c2 in y.items(): s, m = mono_mul(m1, m2) c = out.get(m, Fr(0)) + s * c1 * c2 if c: out[m] = c elif m in out: del out[m] return out def cadd(x, y): out = dict(x) for m, c in y.items(): cc = out.get(m, Fr(0)) + c if cc: out[m] = cc elif m in out: del out[m] return out def cscale(x, s): return {m: c * s for m, c in x.items()} if s else {} def gam(*idx): return {tuple(idx): Fr(1)} ONE = {(): Fr(1)} def is_scalar(x): return all(m == () for m in x) def prop(x, y): """x = c y for a scalar c (both nonzero); returns (True, c) or (False, None).""" if not x or not y or set(x) != set(y): return (False, None) m0 = next(iter(y)) c = x[m0] / y[m0] return (all(x[m] == c * y[m] for m in y), c) def apply_lin(mat, a, n): """one-particle image of gamma_a under integer matrix mat (n x n), as a Clifford element: sum_b mat[b][a] gamma_b.""" out = {} for bidx in range(n): if mat[bidx][a]: out = cadd(out, cscale(gam(bidx), Fr(mat[bidx][a]))) return out def implements(Uel, mat, n): """check U gamma_a = (sum_b mat[b][a] gamma_b) U for all a (no inverse needed).""" for a in range(n): lhs = cmul(Uel, gam(a)) rhs = cmul(apply_lin(mat, a, n), Uel) if cadd(lhs, cscale(rhs, Fr(-1))): return False return True def shift_matrix(n, k, wrap_sign): """gamma_j -> (wrap sign)^(#wraps) gamma_{j+k}; matrix M[b][a] with image(gamma_a) = sum_b M[b][a] gamma_b.""" M = [[0] * n for _ in range(n)] for a in range(n): b = (a + k) % n M[b][a] = wrap_sign if a + k >= n else 1 return M def matmul_i(A, B): n = len(A) return [[sum(A[i][k] * B[k][j] for k in range(n)) for j in range(n)] for i in range(n)] # --------------------------------------------------------------------------- # PART A: the Moebius / divisor side (Theorem A + B3/B4) # --------------------------------------------------------------------------- def part_a(): print("== PART A: Moebius side -- deck square roots, alignment bit, " "n-arithmetic ==") # -------------------------------------------- A-S1: square-root solve print(" -- A-S1: ALL square roots of the deck in PGL2(C) (complete)") a, b, c, d, lam_, r = sp.symbols('a b c d lam_ r') M = sp.Matrix([[a, b], [c, d]]) ch = sp.expand(M * M - (a + d) * M + M.det() * sp.eye(2)) z1, z2, z3 = sp.symbols('z1 z2 z3') V = sp.Matrix([[z1 ** 2, z1, -1], [z2 ** 2, z2, -1], [z3 ** 2, z3, -1]]) detV = sp.factor(V.det()) vand = sp.factor((z1 - z2) * (z1 - z3) * (z2 - z3)) vand_ok = iszero(detV - vand) or iszero(detV + vand) M0 = sp.Matrix([[2, 3], [5, -2]]) # generic traceless ev = list(M0.eigenvals().keys()) check("A-S1.1 NORMAL FORM + ID-RIGIDITY [exact]: Cayley-Hamilton M^2 = " "(tr M) M - (det M) I holds identically (%s); an involution (M^2 " "scalar, M nonscalar) forces tr M = 0, and a traceless M has " "eigenvalue ratio -1 (generic witness: eigenvalues %s), i.e. IS " "conjugate to the deck diag(1,-1); a Moebius map fixing >= 3 " "points has c = b = a-d = 0 (Vandermonde det = %s != 0) and is " "the identity" % (ch == sp.zeros(2, 2), ev, detV), ch == sp.zeros(2, 2) and vand_ok and iszero(ev[0] + ev[1])) b_sol = sp.solve(b * (a + d), b) # trace != 0 branch: b = 0 c_sol = sp.solve(c * (a + d), c) # trace != 0 branch: c = 0 ratio_sol = sp.solve(r ** 2 + 1, r) # (a/d)^2 = -1 Mt = sp.Matrix([[a, b], [c, -a]]) # trace = 0 branch E = sp.expand(Mt * Mt - lam_ * sp.diag(1, -1)) lam_forced = sp.solve(E[0, 0] - E[1, 1], lam_) # -> lam = 0 det_forced = sp.expand(Mt.det().subs(b * c, -a ** 2)) # bc = -a^2 => det = 0 sq_plus = mexp(CLOCK * CLOCK) sq_minus = mexp(CLOCKINV * CLOCKINV) check("A-S1.2 COMPLETE SQUARE-ROOT SOLVE [exact]: g^2 = deck in PGL2(C) " "has EXACTLY TWO solutions. tr g != 0 forces b = %s, c = %s " "(diagonal) and (a/d)^2 = -1 => a/d = %s: g = z -> +iz or " "z -> -iz; tr g = 0 forces lam = %s and det = %s = 0 " "(impossible). No parabolic, loxodromic or non-diagonal square " "roots exist" % (b_sol, c_sol, ratio_sol, lam_forced, det_forced), b_sol == [0] and c_sol == [0] and set(ratio_sol) == {I, -I} and lam_forced == [0] and det_forced == 0 and prop_mat(sq_plus, DECK) and prop_mat(sq_minus, DECK)) o_p, o_m = proj_order(CLOCK), proj_order(CLOCKINV) inv_pair = prop_mat(mexp(CLOCK * CLOCKINV), sp.eye(2)) fix0 = peq(apply_m(CLOCK, (0, 1)), (0, 1)) and peq(apply_m(CLOCK, (1, 0)), (1, 0)) h = sp.Matrix([[1, 2], [3, 5]]) transport = prop_mat(mexp((h * CLOCK * h.adjugate()) ** 2), mexp(h * DECK * h.adjugate())) check("A-S1.3 ORDER 4 IS AUTOMATIC [exact]: both roots have projective " "order (%s, %s) = 4 (elliptic, one PGL2 conjugacy class), are " "mutually inverse (%s) = the Aut(Z4) pair, share the deck's fixed " "points {0, inf} (%s), and the classification transports under " "conjugation (%s) -- 'order 4' is NOT an input once 'square root " "of the deck' is given" % (o_p, o_m, inv_pair, fix0, transport), o_p == 4 and o_m == 4 and inv_pair and fix0 and transport) # -------------------------------------------- A-S2: marks filter + alignment print(" -- A-S2: which deck-invariant 4-mark divisors admit a deck " "square root?") w, u = sp.symbols('w u') # plain complex symbols (no real assumption) w_sols = sorted(sp.solve(w - I, w) + sp.solve(w + I, w), key=str) i_not_pm1 = (not iszero(I - 1)) and (not iszero(I + 1)) mu4 = [(sp.Integer(1), 1), (I, 1), (sp.Integer(-1), 1), (-I, 1)] preserved = all(any(peq(apply_m(CLOCK, p), q) for q in mu4) for p in mu4) check("A-S2.4 MARKS FILTER [exact, complete]: for a deck-invariant " "deck-free set {1,-1,w,-w} the clock image of the mark 1 is i, " "which must be a mark; i != +-1 (%s) leaves w = +-i only (%s); " "both give the SAME set mu4 = {1,i,-1,-i}, and the clock " "preserves it (%s) -- a marks-preserving square root exists IFF " "the marks are one mu4 orbit aligned with the deck" % (i_not_pm1, w_sols, preserved), i_not_pm1 and set(w_sols) == {I, -I} and preserved) mu4u = [(u, 1), (I * u, 1), (-u, 1), (-I * u, 1)] crs = set() for pm in permutations(range(4)): crs.add(sp.nsimplify(cross_ratio(*[mu4u[k] for k in pm]))) j_val = jlam(sp.Integer(2)) orbit_ok = all(any(peq(apply_m(CLOCK, p), q) for q in mu4u) for p in mu4u) no_fixed = all(not peq(apply_m(CLOCK, p), p) for p in mu4u) deck_perm = mark_perm(DECK, mu4u) check("A-S2.5 ALIGNED = SQUARE [exact, symbolic scale u]: cross-ratio " "orderings of u*mu4 = %s (the harmonic class), j = %s = 1728, " "tau = i (v168/v214); the clock 4-cycles the marks freely (orbit " "%s, fixed marks none: %s); deck = clock^2 acts as the double " "transposition %s (v215 K1 pattern DERIVED); the scale u stays " "free = the v492 S5 one-parameter family" % (sorted(crs, key=str), j_val, orbit_ok, no_fixed, deck_perm), crs == {sp.Integer(2), sp.Rational(1, 2), sp.Integer(-1)} and j_val == 1728 and orbit_ok and no_fixed and deck_perm == [2, 3, 0, 1]) stab_mu4 = stabilizer(mu4) prof_mu4 = order_profile(stab_mu4) o4 = [g for g in stab_mu4 if proj_order(g) == 4] o4_are_clocks = all(prop_mat(g, CLOCK) or prop_mat(g, CLOCKINV) for g in o4) o4_sq_deck = all(prop_mat(mexp(g * g), DECK) for g in o4) center = [g for g in stab_mu4 if all(prop_mat(mexp(g * hh), mexp(hh * g)) for hh in stab_mu4)] center_ok = (len(center) == 2 and any(prop_mat(g, DECK) for g in center) and any(prop_mat(g, sp.eye(2)) for g in center)) roots_in_stab = [g for g in stab_mu4 if prop_mat(mexp(g * g), DECK)] check("A-S2.6 D4 STABILISER + CENTRALITY [exact]: |Stab(mu4)| = %d = " "2|mu4| with order profile %s = D4 (v168); EXACTLY 2 order-4 " "elements, both = the clock or its inverse (%s), both squaring " "to the deck (%s); center = {id, deck} (%s); square roots of the " "deck inside the stabiliser = %d = the two clocks -- 'deck " "central in the mark-D4' <=> clock exists" % (len(stab_mu4), prof_mu4, o4_are_clocks, o4_sq_deck, center_ok, len(roots_in_stab)), len(stab_mu4) == 8 and prof_mu4 == {1: 1, 2: 5, 4: 2} and len(o4) == 2 and o4_are_clocks and o4_sq_deck and center_ok and len(roots_in_stab) == 2) v_s = 3 + 2 * sp.sqrt(2) silver = [(sp.Integer(1), 1), (sp.Integer(-1), 1), (v_s, 1), (-v_s, 1)] lam_s = cross_ratio(silver[0], silver[2], silver[1], silver[3]) j_s = jlam(cross_ratio(*silver)) stab_s = stabilizer(silver) prof_s = order_profile(stab_s) deck_in = [g for g in stab_s if prop_mat(g, DECK)] center_s = [g for g in stab_s if all(prop_mat(mexp(g * hh), mexp(hh * g)) for hh in stab_s)] central_s = [g for g in center_s if not prop_mat(g, sp.eye(2))][0] cperm = mark_perm(central_s, silver) # crosses the +- pairs? central_crosses = sorted(cperm) == [0, 1, 2, 3] and cperm[0] in (2, 3) deck_not_central = not any(prop_mat(g, DECK) for g in center_s) roots_s = [g for g in stab_s if prop_mat(mexp(g * g), DECK)] clock_not_pres = not any(peq(apply_m(CLOCK, silver[0]), q) for q in [silver[1], silver[2], silver[3]]) \ and not peq(apply_m(CLOCK, silver[0]), silver[0]) check("A-S2.7 ALIGNMENT NECESSARY [exact counterexample]: " "{+-1, +-(3+2sqrt2)} is deck-free AND harmonic (j = %s = 1728, " "an ordering has cross-ratio %s) with stabiliser D4 (order %d, " "profile %s) -- BUT the deck z -> -z sits in it NON-centrally " "(deck present: %s, central: %s; the true central involution " "CROSSES the +- pairs, perm %s: %s), so the deck has NO square " "root inside (%d found; in D4 only the central rotation r^2 has " "roots) and the global roots +-iz do not preserve the marks (%s) " "-- harmonic modulus ALONE is insufficient; the residual datum " "is DECK-CENTRALITY (one bit), not the j-invariant" % (j_s, lam_s, len(stab_s), prof_s, len(deck_in) == 1, not deck_not_central, cperm, central_crosses, len(roots_s), not clock_not_pres), j_s == 1728 and lam_s == sp.Rational(1, 2) and len(stab_s) == 8 and prof_s == {1: 1, 2: 5, 4: 2} and len(deck_in) == 1 and deck_not_central and central_crosses and len(roots_s) == 0 and clock_not_pres) fixcfg = [(sp.Integer(0), 1), (1, sp.Integer(0)), (sp.Integer(2), 1), (sp.Integer(-2), 1)] stab_f = stabilizer(fixcfg) deck_fixes = mark_perm(DECK, fixcfg) n_fixed = sum(1 for i, j in enumerate(deck_fixes) if i == j) clock_img = apply_m(CLOCK, fixcfg[2]) clock_fails = not any(peq(clock_img, q) for q in fixcfg) center_f = [g for g in stab_f if all(prop_mat(mexp(g * hh), mexp(hh * g)) for hh in stab_f)] central_f = [g for g in center_f if not prop_mat(g, sp.eye(2))] central_not_deck = all(not prop_mat(g, DECK) for g in central_f) check("A-S2.8 FIXED-TYPE CONTROL [exact]: {0, inf, 2, -2} is harmonic " "but the deck FIXES %d marks (0 and inf) -- the (2,4,4) shadow " "killed by v216 (all marks order 2 / deck-free); consistently " "the global roots +-iz do not preserve it (i*2 = 2i not a mark: " "%s) and the central involution of its D4 (order %d) is NOT the " "deck (%s): no clock from this configuration" % (n_fixed, clock_fails, len(stab_f), central_not_deck), n_fixed == 2 and clock_fails and len(stab_f) == 8 and len(central_f) == 1 and central_not_deck) def sigma_eq_mat(Mm): # conjugation action of z -> 1/conj(z) return sp.Matrix([[sp.conjugate(Mm[1, 1]), sp.conjugate(Mm[1, 0])], [sp.conjugate(Mm[0, 1]), sp.conjugate(Mm[0, 0])]]) eq_clock = prop_mat(sigma_eq_mat(CLOCK), CLOCK) eq_deck = prop_mat(sigma_eq_mat(DECK), DECK) conj_clock = prop_mat(CLOCK.conjugate(), CLOCKINV) marks_fixed = all(peq((sp.conjugate(q), sp.conjugate(p)), (p, q)) for (p, q) in mu4) check("A-S2.9 RP FILTER [exact]: the equatorial real structure sigma: " "z -> 1/conj(z) fixes all four mu4 marks pointwise (real locus = " "unit circle: %s), centralises the deck (%s) AND the clock (%s); " "the other real structure z -> conj(z) conjugates clock -> " "clock^-1 (%s) -- RP consistency passes BOTH roots and selects " "nothing: the Aut(Z4) = {clock, clock^-1} ambiguity is " "irreducible (= v492 NC3 rigidity 'up to Aut(Z4)')" % (marks_fixed, eq_deck, eq_clock, conj_clock), marks_fixed and eq_deck and eq_clock and conj_clock) both_pres = all(any(peq(apply_m(g, p), q) for q in mu4u) for p in mu4u for g in (CLOCK, CLOCKINV)) check("A-S2.10 CONVERSE + ONE-BIT REDUCTION [exact]: for EVERY scale u " "the aligned set u*mu4 is preserved by both roots (%s) -- so " "(marks-preserving square root exists) <=> (marks aligned-" "square). The single existence bit yields AT ONCE: order 4 " "(A-S1.3), uniqueness up to inverse (A-S1.2), free 4-cycle orbit " "(A-S2.5), tau = i pinned with only the scale free (A-S2.5), " "deck = clock^2 (A-S2.6). Without the bit the (2,2,2,2) modulus " "is free (v216 [O]) -- circularity cleanly cut: the bit is the " "input, the clock the output" % both_pres, both_pres) # -------------------------------------------- A-S3: why n = 4 (honest) print(" -- A-S3: n-arithmetic -- which Z_n can live on 4 marks at all?") free_n = [n for n in range(1, 9) if 4 % n == 0] check("A-S3.11 FREE ORBIT ARITHMETIC [exact]: a free Z_n action on 4 " "marks forces all orbits of size n, so n | 4: n in %s; marks-" "TRANSITIVE cyclic (marks = ONE orbit, the v215 K1 reading) " "forces n = 4 exactly" % free_n, free_n == [1, 2, 4] and max(free_n) == 4) s4_orders = sorted({Permutation(list(pm)).order() for pm in permutations(range(4))}) kill = {} for n in range(5, 9): img = max(dv for dv in range(1, n + 1) if n % dv == 0 and dv in s4_orders) kill[n] = img # image order < n => kernel fixes all 4 marks o3_fixed = sorted({sum(1 for i in range(4) if Permutation(list(pm))(i) == i) for pm in permutations(range(4)) if Permutation(list(pm)).order() == 3}) check("A-S3.12 FAITHFULNESS [exact]: S4 element orders = %s; any " "Moebius Z_n preserving 4 marks acts FAITHFULLY on them (a " "kernel element would fix 4 >= 3 points => identity, A-S1.1), so " "n >= 5 dies: max cyclic image order = %s for n = 5..8, always " "< n; n = 3 elements fix exactly %s mark (hexagonal shadow) and " "g^2 has order 3 != 2 -- never a deck square root" % (s4_orders, kill, sorted(o3_fixed)), s4_orders == [1, 2, 3, 4] and all(kill[n] < n for n in kill) and o3_fixed == [1]) lam_x = sp.symbols('lam_x') weights = [sp.Integer(0), sp.Rational(1, 3), sp.Rational(2, 3)] spec = sorted(((1 - wt) ** 6 for wt in weights), reverse=True) gap = spec[1] deg3 = sp.Poly(lam_x ** 3 - 1, lam_x).degree() deg5 = sp.Poly(lam_x ** 5 - 1, lam_x).degree() check("A-S3.13 TRANSFER/CUSP SIDE [exact]: the established cusp weights " "{0,1/3,2/3} have denominator 3 = b1 = #marks - 1 = N_fam; " "transfer spectrum (1-w)^6 = %s with gap %s = (2/3)^6 " "(v54/v56/v215 K4); a 6-mark Z6 world would need cusp class " "lam^5 - 1 (deg %d != %d = deg(lam^3 - 1), v117) -- n = 6 is " "killed INDEPENDENTLY by established cusp data; 6 = |W(A3)|/4 = " "24/4" % ([str(s) for s in spec], gap, deg5, deg3), spec == [sp.Integer(1), sp.Rational(64, 729), sp.Rational(1, 729)] and gap == sp.Rational(2, 3) ** 6 and deg3 == 3 == N_fam and deg5 == 5 and 24 // 4 == 6) wsym = sp.symbols('wsym', nonzero=True) cfg_w = [(sp.Integer(1), 1), (sp.Integer(-1), 1), (wsym, 1), (-wsym, 1)] deck_all = all(any(peq(apply_m(DECK, p), q) for q in cfg_w) for p in cfg_w) check("A-S3.14 DECK IS MODULUS-BLIND [exact, symbolic w]: z -> -z " "preserves EVERY deck-pair configuration {+-1, +-w} (%s) -- " "n = 2 pins NO modulus (v503 B5 made exact); the modulus-pinning " "power of n = 4 is EXACTLY the square-root existence bit " "(A-S2.4/A-S2.10). 'Why n = 4 rather than no clock' has NO " "Moebius-side principle -- the P1-side forcing is fermionic " "(Part B: the NS deck implementation is FORCED to order 4)" % deck_all, deck_all) # -------------------------------------------- A-S4: negative controls print(" -- A-S4: negative controls (n = 8, hexagonal, generic)") zeta8 = sp.exp(I * sp.pi / 4) distinct = all(not iszero(zeta8 ** k - zeta8 ** j) for k in range(8) for j in range(k)) sizes_ok = all((4 - r) % 8 != 0 or (4 - r) == 0 for r in (0, 1, 2)) and \ all(4 - r < 8 for r in (0, 1, 2)) and all(4 - r > 0 for r in (0, 1, 2)) check("A-S4.15 NO ORDER-8 ON THE SPHERE [exact]: z -> zeta8 z has all " "orbits of size 8 off {0, inf} (8 distinct powers: %s), so an " "invariant 4-set could only use fixed points (<= 2 < 4) -- " "impossible; the kernel argument (A-S3.12, image order max %d " "< 8) kills EVERY order-8 element; the Z8 lives UPSTAIRS " "(spin/Fock lift, 8 = 2|mu4| = %d, v492 + Part B), never as a " "sphere symmetry of the marks" % (distinct, kill[8], 2 * 4), distinct and sizes_ok and kill[8] == 4 and 2 * 4 == 8) om = sp.Rational(-1, 2) + sp.sqrt(3) * I / 2 hexcfg = [(sp.Integer(1), 1), (om, 1), (sp.expand(om ** 2), 1), (1, sp.Integer(0))] j_hex = jlam(cross_ratio(*hexcfg)) stab_h = stabilizer(hexcfg) prof_h = order_profile(stab_h) sq_orders = sorted({proj_order(mexp(g * g)) for g in stab_h}) check("A-S4.16 HEXAGONAL KILL [exact]: marks {1, w, w^2, inf} (j = %s " "= 0, equianharmonic) have stabiliser A4: order %d, profile %s " "-- ZERO order-4 elements; squares in the stabiliser have orders " "%s (no involution is a square) => NO involution has a marks-" "preserving square root at j = 0: the dynamical winner " "(hexagonal, v503 A5) can NEVER carry the clock -- v503 C2 " "sharpened from Z6 to the full marked-sphere stabiliser" % (j_hex, len(stab_h), prof_h, sq_orders), j_hex == 0 and len(stab_h) == 12 and prof_h == {1: 1, 2: 3, 3: 8} and sq_orders == [1, 3]) gencfg = [(sp.Integer(1), 1), (sp.Integer(-1), 1), (sp.Integer(2), 1), (sp.Integer(-2), 1)] j_gen = jlam(cross_ratio(*gencfg)) stab_g = stabilizer(gencfg) prof_g = order_profile(stab_g) sq_g = all(prop_mat(mexp(g * g), sp.eye(2)) for g in stab_g) check("A-S4.17 GENERIC KILL [exact]: marks {+-1, +-2} (j = %s, neither " "0 nor 1728) have stabiliser Klein V4: order %d, profile %s, " "exponent 2, squares = {id} (%s) => not even the deck has a " "marks-preserving square root at generic modulus -- no clock, " "matching v503 A7 rigidity" % (j_gen, len(stab_g), prof_g, sq_g), j_gen not in (sp.Integer(0), sp.Integer(1728)) and len(stab_g) == 4 and prof_g == {1: 1, 2: 3} and sq_g) # -------------------------------------------- A-S5: synthesis print(" -- A-S5: synthesis") check("A-S4.18 STABILISER TRICHOTOMY [exact]: 4-mark stabilisers in " "PGL2(C) are V4 (generic, order 4) / D4 (harmonic, order 8 = " "2|mu4|) / A4 (equianharmonic, order 12), with order-4 element " "counts (0, 2, 0) -- 'an order-4 element exists IFF the marks " "are harmonic', and then it is the clock pair; enumeration " "complete via the 24 = |S4| = |W(A3)| ordered triples (the clock " "is the W(A3) Coxeter element, v117/v215)", len(stab_g) == 4 and len(stab_mu4) == 8 and len(stab_h) == 12 and len(o4) == 2 and prof_h.get(4, 0) == 0 and prof_g.get(4, 0) == 0 and 24 == 4 * 3 * 2) verdict = (set(w_sols) == {I, -I} # roots classified and len(roots_in_stab) == 2 # aligned: exactly the clocks and len(roots_s) == 0 # unaligned harmonic: none and prof_h.get(4, 0) == 0 # hexagonal: none and sq_g # generic: none and deck_all) # deck modulus-blind check("A-S5.19 VERDICT [typed]: the input 'order-4 clock with free mu4 " "orbit fixing tau = i' REDUCES to ONE bit: 'the collar deck " "admits a marks-preserving Moebius square root' (equivalently: " "the deck is the CENTRAL involution of the mark-stabiliser D4). " "Given the bit, order 4, uniqueness up to Aut(Z4), the free " "4-cycle, tau = i (scale free) and deck = clock^2 are all " "THEOREMS (A-S1.2-A-S2.10); without it, nothing pins the modulus " "(A-S3.14). Harmonicity alone is NOT the bit (A-S2.7). The " "fermionic side of the bit is computed in Part B", verdict) # --------------------------------------------------------------------------- # PART B: the fermionic / Fock side (Theorem B) # --------------------------------------------------------------------------- def part_b(): print("== PART B: Fock side -- does the 16-Majorana seam content FORCE " "the order-4 deck lift? ==") n = N_SITES # -------------------------------------------- B-S1: one-particle level print(" -- B-S1: one-particle level (16 x 16 exact integer matrices)") D_ns = shift_matrix(n, n // 2, -1) # NS deck: half-rotation, antiperiodic C_ns = shift_matrix(n, n // 4, -1) # NS clock candidate: quarter-shift D_r = shift_matrix(n, n // 2, +1) # R deck (periodic control) Dm, Cm = sp.Matrix(D_ns), sp.Matrix(C_ns) lamv = sp.symbols('lam') chD = sp.factor(Dm.charpoly(lamv).as_expr()) chC = sp.factor(Cm.charpoly(lamv).as_expr()) det_D, det_C = Dm.det(), Cm.det() check("B-S1.1 NS DECK IS ALREADY ORDER 4 ONE-PARTICLE [exact]: the " "half-rotation with antiperiodic wrap has D^2 = -1 (%s), det = " "%s (SO(16)), charpoly = %s = (lam^2+1)^8 -- a pi-rotation " "squares to the 2pi rotation = -1 on NS spinors: the 'Z2' deck " "acts as Z4 on the seam's one-particle fermion data BEFORE any " "Fock choice" % (Dm ** 2 == -sp.eye(n), det_D, chD), Dm ** 2 == -sp.eye(n) and det_D == 1 and sp.expand(chD - (lamv ** 2 + 1) ** 8) == 0) check("B-S1.2 QUARTER-SHIFT = ZETA8 SPECTRUM [exact]: C^2 = D (%s), " "C^4 = -1 (%s), C^8 = 1 (%s), det = %s, charpoly = %s = " "(lam^4+1)^4: eigenvalues are the primitive 8th roots zeta8 -- " "the v492 spin-bridge Z8 (8 = 2|mu4|) appears as the one-" "particle order of the geometric quarter-rotation" % (Cm ** 2 == Dm, Cm ** 4 == -sp.eye(n), Cm ** 8 == sp.eye(n), det_C, chC), Cm ** 2 == Dm and Cm ** 4 == -sp.eye(n) and Cm ** 8 == sp.eye(n) and det_C == 1 and sp.expand(chC - (lamv ** 4 + 1) ** 4) == 0) Dr2 = matmul_i(D_r, D_r) dr2_id = all(Dr2[i][j] == (1 if i == j else 0) for i in range(n) for j in range(n)) check("B-S1.3 SPIN-STRUCTURE PREMISE [exact + typed]: with PERIODIC " "wrap the same half-rotation has D_R^2 = +1 (%s) -- order 2, " "nothing forced. The seam circle bounds (equator of the " "celestial sphere); S^2 has b1 = 0, hence 2^0 = %d spin " "structure(s), whose restriction to any circle is the BOUNDING " "= antiperiodic one: the NS wrap is ESTABLISHED P1 geometry " "(v492 sphere; v490 handles the 4 torus structures of the " "double), not a convention" % (dr2_id, 2 ** 0), dr2_id and 2 ** 0 == 1) clock_mperm = [MARKS.index((m + 4) % 16) for m in MARKS] deck_mperm = [MARKS.index((m + 8) % 16) for m in MARKS] check("B-S1.4 MARK GEOMETRY MATCHES THE MOEBIUS SIDE [exact]: on the " "16-site seam the 4 marks sit at sites %s (one per quadrant); " "the quarter-shift 4-cycles them (%s), the half-shift deck acts " "as the double transposition %s = the Part A pattern [2,3,0,1]; " "the quarter-shift needs 4 | 16 sites (4 x 4 = |mu4| x #marks) " "-- an 'order-8 clock' would shift by 2 = half a quadrant and " "map NO mark to a mark" % ([m + 1 for m in MARKS], clock_mperm, deck_mperm), clock_mperm == [1, 2, 3, 0] and deck_mperm == [2, 3, 0, 1] and 16 % 4 == 0 and 2 not in [(m2 - m1) % 16 for m1 in MARKS for m2 in MARKS]) # -------------------------------------------- B-S2: Fock level (the core) print(" -- B-S2: Fock level -- U^2 computed exactly in Cl(16)") GAMMA = {tuple(range(n)): Fr(1)} g2 = cmul(GAMMA, GAMMA) anti = all(not cadd(cmul(GAMMA, gam(a)), cmul(gam(a), GAMMA)) for a in range(n)) phase_i8 = sp.simplify((-sp.I) ** (n // 2)) check("B-S2.5 FERMION PARITY [exact]: (-1)^F = prod_j(-i g_{2j-1} " "g_{2j}) = (-i)^8 g_1...g_16 with (-i)^8 = %s, so (-1)^F = " "g_1...g_16 = the Cl(16) volume element; ((-1)^F)^2 = 1 (%s), it " "anticommutes with every gamma_a (%s) and is NOT a scalar -- the " "parity operator exists canonically on the 16-Majorana Fock " "space" % (phase_i8, prop(g2, ONE), anti), phase_i8 == 1 and prop(g2, ONE) == (True, Fr(1)) and anti and not is_scalar(GAMMA)) Ut = ONE for j in range(n // 2): Ut = cmul(Ut, cadd(ONE, cscale(cmul(gam(j), gam(j + n // 2)), Fr(-1)))) Ut_inv = ONE for j in range(n // 2): Ut_inv = cmul(Ut_inv, cadd(ONE, cmul(gam(j), gam(j + n // 2)))) impl_ok = implements(Ut, D_ns, n) inv_ok = prop(cmul(Ut, Ut_inv), ONE) even_ok = all(len(m) % 2 == 0 for m in Ut) check("B-S2.6 DECK IMPLEMENTER [exact]: Utilde = prod_j (1 - g_j " "g_{j+8}) (256 monomials: %d) implements the NS deck on ALL 16 " "generators (U g_a U^-1 = D g_a: %s), is even (%s), and Utilde x " "reverse = 256 x 1 (%s) -- U = Utilde/16 is the unitary " "Bogoliubov lift" % (len(Ut), impl_ok, even_ok, inv_ok), len(Ut) == 256 and impl_ok and even_ok and inv_ok == (True, Fr(256))) Ut2 = cmul(Ut, Ut) ok_u2, coef = prop(Ut2, GAMMA) check("B-S2.7 THE CORE RESULT U^2 = (-1)^F [exact]: Utilde^2 = %s x " "g_1...g_16 (single grade-16 monomial: %s), i.e. U^2 = (256/256) " "(-1)^F = (-1)^F EXACTLY; U^4 = 1; U^2 is NOT a scalar, and " "every implementer is c U (irreducibility), with (cU)^2 = c^2 " "(-1)^F never = 1: NO phase choice implements the deck with " "order 2 -- the Z4 lift is FORCED by the NS seam fermions: " "1 -> Z2^{(-1)^F} -> Z4 -> Z2^{deck} -> 1, nonsplit" % (coef, ok_u2), ok_u2 and coef == Fr(256) and not is_scalar(Ut2) and prop(cmul(Ut2, Ut2), ONE) == (True, Fr(256 ** 2))) center_wit = [] for mtest in [(0,), (0, 1), (0, 1, 2), tuple(range(n))]: x = {mtest: Fr(1)} commutes_all = all(not cadd(cmul(x, gam(a)), cscale(cmul(gam(a), x), Fr(-1))) for a in range(n)) center_wit.append(commutes_all) Ut3 = cmul(Ut2, Ut) u3_is_pu = prop(Ut3, cmul(GAMMA, Ut)) check("B-S2.8 CANONICITY + Aut(Z4) [exact]: no nonempty monomial " "commutes with all gammas (witnesses odd/even/full: %s => center " "= scalars => implementer unique up to phase); the forced group " "is = {1, U, (-1)^F, (-1)^F U} with U^3 = (-1)^F U (%s): a " "CANONICAL Z4 on the raw NS seam -- generator ambiguity U <-> " "U^3 = Aut(Z4), the same irreducible ambiguity as the Moebius " "pair {clock, clock^-1} (A-S2.9); groups of order 4 are only Z4 " "(nonsplit) or V4 (split), and U^2 != 1 excludes V4" % (center_wit, u3_is_pu[0]), center_wit == [False, False, False, False] and u3_is_pu[0]) # -------------------------------------------- B-S3: R-sector control print(" -- B-S3: R-sector (periodic) control") Ur = ONE for j in range(n // 2): Ur = cmul(Ur, cadd(gam(j), cscale(gam(j + n // 2), Fr(-1)))) impl_r = implements(Ur, D_r, n) Ur2 = cmul(Ur, Ur) ok_r2, coef_r = prop(Ur2, ONE) check("B-S3.9 R CONTROL: SPLIT Z2 [exact]: U_R = prod_j (g_j - " "g_{j+8})/sqrt2 implements the periodic deck (%s) and U_R^2 = " "(%s/256) x 1 = +1 EXACTLY (scalar!) -- in the R sector the deck " "lifts as an honest Z2, NOTHING is forced: the entire Z4-forcing " "of B-S2 rests on the bounding/NS spin structure (B-S1.3), which " "is exactly the established seam geometry" % (impl_r, coef_r), impl_r and ok_r2 and coef_r == Fr(256)) # -------------------------------------------- B-S4: the clock tower Z8 print(" -- B-S4: the quarter-shift Fock lift V (exact block construction)") Cblk = [[0, 0, 0, -1], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]] even_basis = [(), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (0, 1, 2, 3)] odd_basis = [(0,), (1,), (2,), (3,), (0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)] rows = [] for a4 in range(4): img = apply_lin(Cblk, a4, 4) cols = [] for mb in even_basis: x = {mb: Fr(1)} expr = cadd(cmul(x, gam(a4)), cscale(cmul(img, x), Fr(-1))) cols.append([expr.get(mo, Fr(0)) for mo in odd_basis]) for r_i in range(8): rows.append([sp.Rational(cols[c_i][r_i].numerator, cols[c_i][r_i].denominator) for c_i in range(8)]) A = sp.Matrix(rows) null = A.nullspace() v = {} if len(null) == 1: vec = null[0] * sp.lcm([sp.denom(x) for x in null[0]]) v = {even_basis[k]: Fr(int(vec[k])) for k in range(8) if vec[k] != 0} v2 = cmul(v, v) ublk = cmul(cadd(ONE, cscale(cmul(gam(0), gam(2)), Fr(-1))), cadd(ONE, cscale(cmul(gam(1), gam(3)), Fr(-1)))) ok_v2, lam_blk = prop(v2, ublk) v4 = cmul(v2, v2) ok_v4, sig_blk = prop(v4, {(0, 1, 2, 3): Fr(1)}) v8 = cmul(v4, v4) ok_v8, rho_blk = prop(v8, ONE) impl_v = implements(v, Cblk, 4) check("B-S4.10 BLOCK LIFT [exact, rational nullspace]: the even " "implementer of the signed 4-cycle in Cl(4) is UNIQUE up to " "scale (nullspace dim = %d); it implements the block clock (%s), " "v^2 = %s x (block deck lift) (%s), v^4 = %s x e1e2e3e4 = PURE " "block chirality (%s, nonscalar), v^8 = %s x 1 (scalar, %s) -- " "the block tower is (clock, deck, parity) = orders (8, 4, 2) " "projectively" % (len(null), impl_v, lam_blk, ok_v2, sig_blk, ok_v4, rho_blk, ok_v8), len(null) == 1 and impl_v and ok_v2 and ok_v4 and ok_v8 and not is_scalar(v4) and rho_blk == sig_blk ** 2) def embed(x, j): table = (j, j + 4, j + 8, j + 12) return {tuple(sorted(table[i] for i in m)): c for m, c in x.items()} V = ONE for j in range(4): V = cmul(V, embed(v, j)) impl_V = implements(V, C_ns, n) emb = [embed(v, j) for j in range(4)] blocks_comm = all(not cadd(cmul(emb[a_], emb[b_]), cscale(cmul(emb[b_], emb[a_]), Fr(-1))) for a_ in range(4) for b_ in range(a_ + 1, 4)) V2 = ONE for j in range(4): V2 = cmul(V2, embed(v2, j)) ok_V2, lam_g = prop(V2, Ut) V4 = ONE for j in range(4): V4 = cmul(V4, embed(v4, j)) ok_V4, sig_g = prop(V4, GAMMA) V8 = ONE for j in range(4): V8 = cmul(V8, embed(v8, j)) ok_V8, rho_g = prop(V8, ONE) check("B-S4.11 GLOBAL CLOCK TOWER Z8 [exact]: block lifts commute (%s); " "V implements the quarter-shift on all 16 generators (%s); V^2 = " "%s x Utilde (deck lift: clock^2 = deck at the FOCK level, %s), " "V^4 = %s x (-1)^F (pure grade 16, %s, nonscalar), V^8 = %s x 1 " "(scalar, %s): projective order 8 = 2|mu4| -- the v492 Z8 spin " "bridge is REALISED on the 16-Majorana Fock space; the phase-" "invariant content is the tower Z8 -> Z4 -> Z2 (V -> V^2 prop U " "-> U^2 = (-1)^F)" % (bool(blocks_comm), impl_V, lam_g, ok_V2, sig_g, ok_V4, rho_g, ok_V8), bool(blocks_comm) and impl_V and ok_V2 and ok_V4 and ok_V8 and not is_scalar(V4) and rho_g == sig_g ** 2) gam4prod = ONE for j in range(4): gam4prod = cmul(gam4prod, embed({(0, 1, 2, 3): Fr(1)}, j)) ok_g4, sign_g4 = prop(gam4prod, GAMMA) check("B-S4.12 ARITHMETIC OF THE TOWER [exact]: prod of the 4 block " "chiralities = %s x (-1)^F (%s); orders: |deck lift| = 4 = " "|mu4|, |clock lift| = 8 = 2|mu4| = the c3 = 1/(8 pi) seam " "winding integer; carrier count 16 = 2^(g_car-1) = %d with " "g_car = 5; the 'Z2' -> Z4 -> Z8 doubling chain is 1 -> 2 -> 4 " "-> 8 = the mu4-glue powers of 2" % (sign_g4, ok_g4, 2 ** (g_car - 1)), ok_g4 and sign_g4 == Fr(1) and 2 ** (g_car - 1) == 16 and 2 * 4 == 8) # -------------------------------------------- B-S5: 16-fold way + robustness print(" -- B-S5: 16-fold-way arithmetic + count robustness") nu = 16 theta_v = sp.exp(2 * sp.pi * sp.I * sp.Rational(nu, 16)) theta_8 = sp.exp(2 * sp.pi * sp.I * sp.Rational(8, 16)) check("B-S5.13 16-FOLD WAY [exact]: theta_v = exp(2 pi i nu/16) = %s = " "1 at nu = 16 (v490: vortex condensable, gaugeable), while nu = " "8 gives theta_v = %s != 1; the forced tower period 8 = 2|mu4| " "equals the Fidkowski-Kitaev Z8 of interacting Majorana " "classifications -- the seam sits at the anomaly-free point nu " "= 16 = 0 mod 8 where the Z4-extended deck CAN be gauged " "(consistency), yet the extension itself (U^2 = (-1)^F) remains " "nontrivial" % (sp.simplify(theta_v), sp.simplify(theta_8)), sp.simplify(theta_v - 1) == 0 and sp.simplify(theta_8 + 1) == 0) m8 = 8 D8 = shift_matrix(m8, 4, -1) Ut8 = ONE for j in range(4): Ut8 = cmul(Ut8, cadd(ONE, cscale(cmul(gam(j), gam(j + 4)), Fr(-1)))) G8 = {tuple(range(m8)): Fr(1)} ok8, c8 = prop(cmul(Ut8, Ut8), G8) impl8 = implements(Ut8, D8, m8) check("B-S5.14 COUNT ROBUSTNESS [exact]: on an 8-site NS circle the " "same construction gives an implementer (%s) with U^2 = %s/16 x " "(-1)^F_8 (nonscalar, %s): the Z4-forcing needs ONLY (NS wrap + " "half-rotation), not the number 16 -- 16 is the CARRIER count " "(2^(g_car-1), v156/v175), and it is what places the seam at the " "gaugeable point nu = 16 of B-S5.13" % (impl8, c8, ok8), impl8 and ok8 and c8 == Fr(16)) # -------------------------------------------- B-S6: honest verdict print(" -- B-S6: verdict") forced = (ok_u2 and coef == Fr(256) # U^2 = (-1)^F exactly and ok_r2 # R control splits and ok_V4 and ok_V8 # Z8 tower realised and dr2_id) check("B-S6.15 VERDICT [typed]: FORCED by established seam data (NS " "wrap from the unique S^2 spin structure + half-rotation deck + " "fermions): the deck's Fock implementation has ORDER 4, U^2 = " "(-1)^F (B-S2.7), and the geometric quarter-shift lifts to a " "canonical Z8 with V^2 prop U, V^4 prop (-1)^F (B-S4.11) -- '8 = " "2|mu4|' gets its fermionic explanation. NOT forced: that the " "quarter-shift preserves the MARKED dynamics (DtN/marks) -- the " "alignment bit of Part A (deck central in the mark-D4) remains " "the one residual carrier input; the fermionic Z4 does not by " "itself create a marks-preserving spatial square root. No " "overclaim", forced) # --------------------------------------------------------------------------- def run(): reset() print("v506 SEAM.CLOCK.RIGIDITY.01: clock rigidity, Route B of v503 -- " "Part A (Moebius) + Part B (Fock)") part_a() part_b() return summary("v506 SEAM.CLOCK.RIGIDITY.01: THEOREM A (Moebius) -- the " "deck z -> -z has exactly two square roots z -> +-iz in " "PGL2(C), both automatically of order 4; a marks-" "preserving root exists iff the deck is the CENTRAL " "involution of the mark-D4 (center = {id, deck}, exactly " "2 order-4 elements = the clocks), and then marks = mu4 " "orbit, cross-ratio {2, 1/2, -1}, j = 1728, tau = i, " "free 4-cycle, only the scale free; counterexample " "{+-1, +-(3+2sqrt2)}: harmonic with full D4 but deck " "non-central => 0 roots -- harmonicity alone is NOT " "enough; free orbit => n | 4, transitivity => n = 4, " "faithfulness kills n >= 5, cusp degree 3 kills n = 6, " "trichotomy V4/D4/A4 with order-4 counts (0, 2, 0). " "THEOREM B (Fock, the core) -- the unique S^2 spin " "structure gives NS on every circle; one-particle D^2 = " "-1 ((lam^2+1)^8), quarter-shift C^2 = D, C^8 = 1 " "((lam^4+1)^4); Fock: Utilde^2 = 256 gamma_1...gamma_16 " "=> U^2 = (-1)^F EXACTLY, (cU)^2 never 1 => the Z4 lift " "is FORCED (nonsplit extension); Z8 tower V^2 prop U, " "V^4 prop (-1)^F, projective order 8 = 2|mu4| -- " "fermionically explained; R control U_R^2 = +1 (split); " "theta_v = 1 at nu = 16; forcing robust already at 8 " "sites. THE ONE [C] REST: 'the collar deck is the " "central involution of the mark-D4' -- one alignment " "bit; the fermionic Z4 forces the ORDER, not the " "spatial alignment. QGEO.REALIZE.01 stays [C]/[O], no " "marker moves") if __name__ == "__main__": raise SystemExit(1 if run() else 0)