Follow the source behind the result.

The registered Python source is shown as text. Displaying it does not execute the code.

"""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<U> -> 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<U> -> 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 <U> = {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)

3f8605fb91c96583072913c5f2546cdd491a73f3ad2494c907a0115dcd3d450b

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.