Follow the source behind the result.

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

#!/usr/bin/env python3
"""v603 -- QGEO.SEAMMARKS.01: the seam-and-marks round -- the seam line is a
REAL line of the cover reversed by S_0 (the v590 demand, geometric), the
infinity cusp separates in the unreduced module, the first per-mark Z/3
witness lands (E_1, order 3), and the corpus-transpose translator negatives
are quantified.

Round 7 of the QGEO cover program (after v602).  Executes the follow-up
slate "form translator / infinity cusp / mark classes / two demands":

  (S1) THE SEAM LINE IS FOUND AND IT IS REAL [E]: the line-stabilizer pair
       (U_1, V_1^J) has a unique common eigenline v with U v = 0 and
       V v = v (the compiler seam, span(e_3), transported); explicitly
       v = (0, (sqrt3 - i)/(sqrt3 + i), 1).  The real structure FIXES this
       line (R v ~ v): THE SEAM IS A REAL LINE OF THE COVER.  The
       two-demand involution S_0 REVERSES it (S_0 v = -v): the v590 seam-
       reversal demand holds geometrically on the curve.  Honest scope:
       S_0 does NOT commute with R (the sheet involution is not
       Gamma-even), and the seam's identification with the infinity cusp
       stays open.

  (S2) THE INFINITY CUSP SEPARATED [E]: the UNREDUCED Burau of B_4 at
       t = omega (braid relations machine-verified) contains the invariant
       column (1,1,1,1) -- the trivial line -- and the full twist r^4 acts
       with eigenvalues {1, omega, omega, omega}: the infinity-cusp
       direction (eigenvalue 1) is canonically separated from the reduced
       omega-sheet (the v597 deck identity r^4 = omega restricted).  The
       invariant row is (1, omega, conj(omega), 1).

  (S3) THE FIRST MARK-LOCAL Z/3 WITNESS [E]: the Gamma-even cusp element
       E_1 = G_1 + Gamma(G_1) restricts to an INTEGER matrix on the
       saturated fixed lattice, lies in the seven-word algebra of
       (C_U, C_V) with coefficient denominators of lcm EXACTLY 3 -- an
       ORDER-THREE CLASS in the cokernel P/O of the word order: the first
       exact witness of the per-mark Z/3 mechanism (v566/v597).  Honest
       structure: E_4's class is trivial (integer coefficients) and
       E_2, E_3 lie OUTSIDE the mark-1-anchored algebra -- the naive
       global map fails; the equivariant per-mark framing (each mark's
       class lives in its own rotated frame) is the typed reading.

  (S4) TRANSLATOR NEGATIVES [X, quantified]: the pullback of the corpus
       RP transpose structure along the compiler conjugation is the
       symmetric bilinear form F_2 = g^T Sigma g; F_2 is NOT proportional
       to any member of the canonical menu (B, B*S_0, B*Klein, B*V-polys,
       B*H, ...), and neither B^-1 F_2 nor F_2 B^-1 lies in the word
       algebra -- the corpus-transpose translator genuinely needs a new
       canonical object, named open.

All checks exact (sympy).  Verdict enums (frozen): SEAM-REAL-LANDED
(all), SEAM-REAL-FAILS, MIXED.

FIREWALL: GATE.QGEO does not move; no marker changes.  The seam-infinity
identification, the equivariant completion of the mark map and the
transpose translator stay typed open.

PROVENANCE: discovery probe seam_marks_probe.py (2026-08-01, 15/15,
verdict SEAM-REAL-LANDED).  Python-only, counted per GATE.WOLFRAM.02.
"""

import sympy as sp

t = sp.symbols("t")
x = sp.symbols("x")
OMEGA = sp.Rational(-1, 2) + sp.sqrt(3) * sp.I / 2

CHECKS = []


def check(name, ok, detail=""):
    CHECKS.append((name, bool(ok)))
    print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""))


def burau_gen(i, n=4):
    m = n - 1
    M = sp.eye(m)
    if i - 2 >= 0:
        M[i - 2, i - 1] = t
    M[i - 1, i - 1] = -t
    if i < m:
        M[i, i - 1] = 1
    return M


def burau_unred(i, n=4):
    M = sp.eye(n)
    M[i - 1, i - 1] = 1 - t
    M[i - 1, i] = t
    M[i, i - 1] = 1
    M[i, i] = 0
    return M


I3 = sp.eye(3)
I4 = sp.eye(4)
S = [sp.simplify(burau_gen(i).subs({t: OMEGA})) for i in (1, 2, 3)]
r = sp.simplify(S[0] * S[1] * S[2])
T = [S[0]]
for _ in range(3):
    T.append(sp.simplify(r * T[-1] * r.inv()))
G = [sp.simplify((I3 - T[k]) * (I3 - T[k]).conjugate().T) for k in range(4)]
J = sp.Matrix([[0, 1 + sp.sqrt(3) * sp.I, -1 + sp.sqrt(3) * sp.I],
               [1 - sp.sqrt(3) * sp.I, 2, 1 + sp.sqrt(3) * sp.I],
               [-1 - sp.sqrt(3) * sp.I, 1 - sp.sqrt(3) * sp.I, 0]])
Jinv = J.inv()
M0 = sp.Matrix([[-1, (1 + sp.sqrt(3) * sp.I) / 2, (1 - sp.sqrt(3) * sp.I) / 2],
                [0, 0, 1],
                [0, 1, 0]])
GJ = [sp.simplify((I3 - T[k]) * Jinv * (I3 - T[k]).conjugate().T * J) for k in range(4)]
U1 = sp.simplify(3 * GJ[0])
V1J = sp.simplify(I3 + GJ[3] - GJ[1] * GJ[0])
Uc = sp.Matrix([[3, 0, 0], [3, 0, 0], [3, 0, 0]])
Vc = sp.Matrix([[0, 1, 0], [0, 2, 0], [0, 2, 1]])


def Gamma(A):
    return sp.simplify(M0 * A.conjugate() * M0.inv())


# ---------------------------------------------------------------- S1
print("=" * 72)
print("S1: the seam line -- real, S_0-reversed")
print("=" * 72)

Mst = sp.Matrix.vstack(U1, V1J - I3)
ns = Mst.nullspace()
check("S1.1 unique common eigenline: U v = 0, V v = v (dim 1)", len(ns) == 1)
v = sp.simplify(ns[0])
v = sp.simplify(v / v[2])
target = sp.Matrix([0, (sp.sqrt(3) - sp.I) / (sp.sqrt(3) + sp.I), 1])
check("S1.2 explicit seam vector v = (0, (sqrt3-i)/(sqrt3+i), 1)",
      sp.simplify(v - target) == sp.zeros(3, 1))
Rv = sp.simplify(M0 * v.conjugate())
check("S1.3 THE SEAM IS REAL: R fixes the seam line (R v ~ v)",
      sp.Matrix.hstack(v, Rv).rank() == 1)

P_, D_ = V1J.diagonalize()
order = [D_[i, i] for i in range(3)]
signs = tuple(1 if order[i] == 0 else -1 for i in range(3))
S0c = sp.simplify(P_ * sp.diag(*signs) * P_.inv())
check("S1.4 S_0 reverses the seam: S_0 v = -v (the v590 seam-reversal demand, geometric)",
      sp.simplify(S0c * v + v) == sp.zeros(3, 1))
check("S1.5 honest scope: S_0 does NOT commute with R (not Gamma-even)",
      sp.simplify(Gamma(S0c) - S0c) != sp.zeros(3, 3))

# ---------------------------------------------------------------- S2
print("=" * 72)
print("S2: the infinity cusp in the unreduced module")
print("=" * 72)

Su = [sp.simplify(burau_unred(i).subs({t: OMEGA})) for i in (1, 2, 3)]
ok_braid = (sp.simplify(Su[0] * Su[1] * Su[0] - Su[1] * Su[0] * Su[1]) == sp.zeros(4, 4)
            and sp.simplify(Su[0] * Su[2] - Su[2] * Su[0]) == sp.zeros(4, 4)
            and sp.simplify(Su[1] * Su[2] * Su[1] - Su[2] * Su[1] * Su[2]) == sp.zeros(4, 4))
check("S2.1 unreduced Burau braid relations at t = omega", ok_braid)
col = sp.Matrix([1, 1, 1, 1])
check("S2.2 invariant column (1,1,1,1): the trivial (infinity) line",
      all(sp.simplify(Su[i] * col - col) == sp.zeros(4, 1) for i in range(3)))
row = sp.Matrix([[1, OMEGA, sp.conjugate(OMEGA), 1]])
check("S2.3 invariant row (1, omega, conj omega, 1)",
      all(sp.simplify(row * Su[i] - row) == sp.zeros(1, 4) for i in range(3)))
ru = sp.simplify(Su[0] * Su[1] * Su[2])
full = sp.simplify(ru ** 4)
evs = {}
for ev, mult, _ in full.eigenvects():
    evs[sp.nsimplify(sp.simplify(ev))] = mult
check("S2.4 full twist r^4 eigenvalues {1 (x1), omega (x3)}: infinity line separated "
      "from the omega-sheet", evs.get(1) == 1 and evs.get(sp.nsimplify(OMEGA)) == 3,
      str(evs))

# ---------------------------------------------------------------- S3
print("=" * 72)
print("S3: the first mark-local Z/3 witness")
print("=" * 72)

Sat = sp.Matrix([[1, 2, 2, 0, 0, 0],
                 [0, 1, 1, -1, 0, 0],
                 [0, 0, 1, 1, -1, 1]])
Bs = [sp.Matrix([Sat[i, j] + OMEGA * Sat[i, 3 + j] for j in range(3)]) for i in range(3)]
Bfix = sp.Matrix.hstack(*Bs)
CU = sp.Matrix([[3, 0, 0], [-3, 0, 0], [0, 0, 0]])
CV = sp.Matrix([[2, 1, -1], [-2, -1, 2], [-2, -1, 2]])
words_int = [sp.eye(3), CU, CV, CU * CV, CV * CU, CV * CV, CV * CU * CV]
Wint = sp.Matrix([[wd[i, j] for i in range(3) for j in range(3)] for wd in words_int])


def mark_class(k):
    Ek = sp.simplify(G[k] + Gamma(G[k]))
    CEk = sp.simplify(Bfix.solve(sp.simplify(Ek * Bfix)))
    isint = all(sp.nsimplify(e).is_integer for e in CEk)
    vec = sp.Matrix(9, 1, [CEk[i, j] for i in range(3) for j in range(3)])
    try:
        coeffs, _ = Wint.T.gauss_jordan_solve(vec)
        coeffs = [sp.nsimplify(sp.simplify(c)) for c in coeffs.T]
        L = sp.lcm([sp.fraction(c)[1] for c in coeffs])
        return isint, True, L
    except ValueError:
        return isint, False, None


i1, in1, L1 = mark_class(0)
check("S3.1 E_1 restricts INTEGER, lies in the word algebra, class order = 3 "
      "(the first per-mark Z/3 witness)", i1 and in1 and L1 == 3, "lcm den = %s" % L1)
i4, in4, L4 = mark_class(3)
check("S3.2 E_4 in the algebra with trivial class (integer coefficients)",
      i4 and in4 and L4 == 1)
i2, in2, _ = mark_class(1)
i3, in3, _ = mark_class(2)
check("S3.3 [must-fail for the naive global map] E_2, E_3 lie OUTSIDE the "
      "mark-1-anchored algebra (equivariant per-mark framing typed)",
      i2 and i3 and (not in2) and (not in3))

# ---------------------------------------------------------------- S4
print("=" * 72)
print("S4: translator negatives, quantified")
print("=" * 72)

g_ = sp.Matrix(3, 3, lambda i, j: sp.Symbol("h%d%d" % (i, j)))
eqs = []
for E_ in [sp.expand(g_ * U1 - Uc * g_), sp.expand(g_ * V1J - Vc * g_)]:
    eqs.extend([E_[i, j] for i in range(3) for j in range(3)])
sol = sp.solve(eqs, list(g_), dict=True)
gs = sp.simplify(g_.subs(sol[0]))
fs = sorted(gs.free_symbols, key=str)
g = sp.simplify(gs.subs({f: 1 for f in fs}))
Sig = sp.diag(1, -1, -1)
F2 = sp.simplify(g.T * Sig * g)
check("S4.1 pullback form F2 = g^T Sigma g is symmetric", sp.simplify(F2 - F2.T) == sp.zeros(3, 3))
B = sp.simplify(M0.conjugate().T * J)


def proportional(F, Fr):
    for ii in range(3):
        for jj in range(3):
            if Fr[ii, jj] != 0 and F[ii, jj] != 0:
                lam = sp.simplify(F[ii, jj] / Fr[ii, jj])
                return sp.simplify(F - lam * Fr) == sp.zeros(3, 3)
    return False


H1 = sp.simplify(I3 + (V1J * (V1J - I3)) / 2)
menu = [B, sp.simplify(B * S0c), sp.simplify(S0c.T * B), sp.simplify(B * V1J),
        sp.simplify(B * (V1J - I3)), sp.simplify(B * (I3 - 2 * GJ[0])), sp.simplify(B * H1)]
check("S4.2 [must-fail] F2 not proportional to any canonical menu form (7 tested)",
      not any(proportional(F2, Fr) for Fr in menu))

words_c = [I3, U1, V1J, sp.simplify(U1 * V1J), sp.simplify(V1J * U1),
           sp.simplify(V1J * V1J), sp.simplify(V1J * U1 * V1J)]
Wc = sp.Matrix([[wd[i, j] for i in range(3) for j in range(3)] for wd in words_c])


def in_algebra(X):
    vec = sp.Matrix(9, 1, [X[i, j] for i in range(3) for j in range(3)])
    try:
        Wc.T.gauss_jordan_solve(vec)
        return True
    except ValueError:
        return False


check("S4.3 [must-fail] neither B^-1 F2 nor F2 B^-1 lies in the word algebra "
      "(the translator needs a new canonical object -- named open)",
      not in_algebra(sp.simplify(B.inv() * F2)) and not in_algebra(sp.simplify(F2 * B.inv())))

# ---------------------------------------------------------------- summary
print("=" * 72)
n_pass = sum(1 for _, ok in CHECKS if ok)
print("%d/%d checks passed" % (n_pass, len(CHECKS)))
if n_pass == len(CHECKS):
    print("ALL CHECKS PASSED")
    print("VERDICT: SEAM-REAL-LANDED -- the seam line is a real line of the cover,")
    print("S_0 reverses it geometrically; the infinity cusp is separated in the")
    print("unreduced module; the first per-mark Z/3 witness lands (E_1, order 3);")
    print("the corpus-transpose translator stays honestly open.")
else:
    print("SOME CHECKS FAILED")


def run():
    """run_all.py entry point; the checks execute at import time above."""
    return len([1 for _, ok in CHECKS if not ok])


if __name__ == "__main__":
    raise SystemExit(1 if run() else 0)

6217d67d9640f37ba43fb8e6c58983713f9ab6d4a508b67b2d730d8d0b03ae00

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.