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
"""v605 -- QGEO.TRANSLATOR.01: the translator round -- the corpus RP
anti-automorphism IS the J-adjoint twisted by an explicit inner element
(14c integral); the seam is nonzero 3-torsion at infinity; the 81 survives
frame-joining as the saturation defect; the J_fix duality is certified
(with Lean addendum).

Round 9 of the QGEO cover program (after v604).  Executes the follow-up
slate "omega-bar translator / seam-infinity bridge / 81-27 sequence /
Lean addendum":

  (T1) THE TRANSLATOR EXISTS [E, the centerpiece]: pulling the corpus RP
       anti-automorphism theta(X) = Sigma X^T Sigma back along the
       compiler conjugation and composing with the J-adjoint gives an
       algebra AUTOMORPHISM phi = Jadj o theta_pull -- and phi is INNER:
       the intertwiner space is 1-dimensional, its generator c is
       invertible, and phi(A) = c A c^-1 holds EXACTLY on the pair.
       Hence THE CORPUS RP STRUCTURE IS THE J-ADJOINT COMPOSED WITH THE
       INNER TWIST BY c: the RP anti-automorphism is fully expressed in
       curve language (polarization + one explicit element).  The
       normalization 14 c is Z[omega]-INTEGRAL (denominator 14 = 2 x 7,
       the parabolic dimension).  Honest scope: c is unique-up-to-scale
       by construction, but not Gamma-even and not in the word algebra
       -- its independent geometric identity is the named open.

  (T2) THE SEAM IS 3-TORSION AT INFINITY [E]: in the Smith coordinates
       of coker(1 - T_inf) = Z^2 + (Z/3)^3 (v604), the seam lift
       (-conj(omega), -conj(omega), 0, -omega) has FREE coordinates
       (0, 0) and torsion coordinates (2, 2, 0) mod 3: the seam line is
       a NONZERO pure-torsion class of the infinity monodromy cokernel
       -- the integral seam <-> infinity bridge.

  (T3) THE 81 SURVIVES FRAME-JOINING [E]: inside the frame-1 span, the
       order chain O_1 subset (O_joint intersect span_1) subset P_1 has
       indices 3^5 = 243 and 3^4 = 81: joining all four frames refines
       each frame's order by exactly 3^5, and the residual saturation
       defect is EXACTLY the v566 index 81.

  (T4) THE J_FIX DUALITY CERTIFIED [E]: C_V^T J_fix = J_fix C_Vdual with
       the explicit integer C_Vdual = [[1,0,0],[-2,0,0],[2,1,2]] (char
       x(x-1)(x-2), dual joint trace tr(C_U C_Vdual) = 3, char(C_U +
       C_Vdual) = x(x-2)(x-4)); Lean addendum in
       TfptCarrier/CoverEmbedding.lean (Jfix_symmetric, Jfix_det = 72,
       CV_dual_certificate, CVdual_cubic, dual_joint_trace; lake build
       green).

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

FIREWALL: GATE.QGEO does not move; no marker changes.  The independent
geometric identity of c and the completion of the seam/mark program stay
typed open.  Companion Lean addendum: Jfix_symmetric, Jfix_det = 72,
CV_dual_certificate, CVdual_cubic, dual_joint_trace in
TfptCarrier/CoverEmbedding.lean (lake build green).

PROVENANCE: discovery probe translator_probe.py (2026-08-01, 11/11,
verdict TRANSLATOR-LANDED).  Python-only, counted per GATE.WOLFRAM.02.
"""

import sympy as sp
from sympy.matrices.normalforms import hermite_normal_form

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


def zw_coords(e):
    e = sp.expand(e)
    b = sp.nsimplify(2 * sp.im(e) / sp.sqrt(3))
    a = sp.nsimplify(sp.re(e) + sp.im(e) / sp.sqrt(3))
    return a, b


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()))
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]])
Sig = sp.diag(1, -1, -1)

# ---------------------------------------------------------------- T1
print("=" * 72)
print("T1: the translator -- theta_corpus = Jadj o inner(c)")
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}))
gi = g.inv()


def theta_pull(A):
    return sp.simplify(gi * Sig * (g * A * gi).T * Sig * g)


def Jadj(A):
    return sp.simplify(Jinv * A.conjugate().T * J)


phiU = sp.simplify(Jadj(theta_pull(U1)))
phiV = sp.simplify(Jadj(theta_pull(V1J)))
check("T1.1 phi = Jadj o theta_pull preserves the spectra (algebra automorphism data)",
      sp.expand(sp.factor(sp.expand((x * I3 - phiU).det())) - x ** 2 * (x - 3)) == 0
      and sp.expand(sp.factor(sp.expand((x * I3 - phiV).det())) - x * (x - 1) * (x - 2)) == 0)

c_ = sp.Matrix(3, 3, lambda i, j: sp.Symbol("c%d%d" % (i, j)))
eqs = []
for A, phiA in [(U1, phiU), (V1J, phiV)]:
    E_ = sp.expand(c_ * A - phiA * c_)
    eqs.extend([E_[i, j] for i in range(3) for j in range(3)])
solc = sp.solve(eqs, list(c_), dict=True)
cs = sp.simplify(c_.subs(solc[0]))
fsc = sorted(cs.free_symbols, key=str)
check("T1.2 the intertwiner space is 1-dimensional (c unique up to scale)",
      len(solc) == 1 and len(fsc) == 1)
cmat = sp.simplify(cs.subs({f: 1 for f in fsc}))
ok_inner = (sp.simplify(cmat.det()) != 0
            and sp.simplify(cmat * U1 * cmat.inv() - phiU) == sp.zeros(3, 3)
            and sp.simplify(cmat * V1J * cmat.inv() - phiV) == sp.zeros(3, 3))
check("T1.3 phi is INNER: phi(A) = c A c^-1 exactly -- the corpus RP structure "
      "IS Jadj twisted by c", ok_inner)
c14 = sp.simplify(14 * cmat)
ok_int = all(all(v.is_integer for v in zw_coords(e)) for e in c14)
check("T1.4 14 c is Z[omega]-INTEGRAL (denominator 14 = 2 x 7)", ok_int)


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


words = [I3, U1, V1J, sp.simplify(U1 * V1J), sp.simplify(V1J * U1),
         sp.simplify(V1J * V1J), sp.simplify(V1J * U1 * V1J)]
Wm = sp.Matrix([[wd[i, j] for i in range(3) for j in range(3)] for wd in words])
vec = sp.Matrix(9, 1, [cmat[i, j] for i in range(3) for j in range(3)])
try:
    Wm.T.gauss_jordan_solve(vec)
    in_alg = True
except ValueError:
    in_alg = False
check("T1.5 honest scope: c not Gamma-even, not in the word algebra (identity open)",
      sp.simplify(Gamma(cmat) - cmat) != sp.zeros(3, 3) and not in_alg)

# ---------------------------------------------------------------- T2
print("=" * 72)
print("T2: the seam is 3-torsion at infinity")
print("=" * 72)

Su = [sp.simplify(burau_unred(i).subs({t: OMEGA})) for i in (1, 2, 3)]
ru = sp.simplify(Su[0] * Su[1] * Su[2])
Tinf = sp.simplify(ru ** 4)
D_ = sp.simplify(I4 - Tinf)
cols = []
for j in range(4):
    for mult in (1, OMEGA):
        v = sp.zeros(4, 1)
        v[j] = mult
        img = sp.expand(D_ * v)
        col = []
        for i in range(4):
            a, b = zw_coords(img[i])
            col.extend([a, b])
        cols.append([sp.Integer(e) for e in col])
Mz = sp.Matrix(cols).T


def snf_transforms(A):
    A = A.copy()
    m, n = A.shape
    U = sp.eye(m)
    V = sp.eye(n)
    k = 0
    while k < min(m, n):
        while True:
            best = None
            pos = None
            for i in range(k, m):
                for j in range(k, n):
                    if A[i, j] != 0 and (best is None or abs(A[i, j]) < best):
                        best = abs(A[i, j])
                        pos = (i, j)
            if pos is None:
                break
            pi, pj = pos
            A.row_swap(k, pi)
            U.row_swap(k, pi)
            A.col_swap(k, pj)
            V.col_swap(k, pj)
            done = True
            for i in range(k + 1, m):
                q = A[i, k] // A[k, k]
                if q != 0:
                    A[i, :] -= q * A[k, :]
                    U[i, :] -= q * U[k, :]
                if A[i, k] != 0:
                    done = False
            for j in range(k + 1, n):
                q = A[k, j] // A[k, k]
                if q != 0:
                    A[:, j] -= q * A[:, k]
                    V[:, j] -= q * V[:, k]
                if A[k, j] != 0:
                    done = False
            if done:
                break
        k += 1
    return A, U, V


D8, U8, V8 = snf_transforms(Mz.copy())
seam = sp.Matrix([-sp.conjugate(OMEGA), -sp.conjugate(OMEGA), 0, -OMEGA])
sv = []
for i in range(4):
    a, b = zw_coords(seam[i])
    sv.extend([a, b])
sv = sp.Matrix(8, 1, [sp.Integer(e) for e in sv])
y = sp.expand(U8 * sv)
free_ok = True
tor = []
for i in range(8):
    d = D8[i, i]
    if d == 0:
        if y[i] != 0:
            free_ok = False
    elif abs(d) == 3:
        tor.append(int(sp.Mod(y[i], 3)))
check("T2.1 seam lift has ZERO free coordinates in coker(1 - T_inf)", free_ok)
check("T2.2 seam lift is a NONZERO 3-torsion class (torsion coords (2,2,0) pattern)",
      sorted(tor) == [0, 2, 2], str(tor))

# ---------------------------------------------------------------- T3
print("=" * 72)
print("T3: the 81 survives frame-joining")
print("=" * 72)

pair0 = words
frames = [pair0]
rk = I3
for _ in range(3):
    rk = sp.simplify(r * rk)
    frames.append([sp.simplify(rk * wd * rk.inv()) for wd in pair0])


def to18(wd):
    out = []
    for mult in (1, OMEGA):
        rr = []
        for e in (mult * wd):
            a, b = zw_coords(e)
            rr.extend([a, b])
        out.append([sp.Integer(v_) for v_ in rr])
    return out


O1_vecs = []
for wd in pair0:
    O1_vecs.extend(to18(wd))
OJ_vecs = []
for fr in frames:
    for wd in fr:
        OJ_vecs.extend(to18(wd))
O1 = sp.Matrix(O1_vecs)
OJ = sp.Matrix(OJ_vecs)
HB = hermite_normal_form(sp.Matrix(OJ).T)
Bjoint = HB.T
Kcols = sp.Matrix.hstack(*O1.nullspace())
Cmat = sp.expand(Bjoint * Kcols)
ker = sp.Matrix.hstack(*(Cmat.T).nullspace())
den = sp.lcm([sp.fraction(sp.nsimplify(e))[1] for e in ker])
kerZ = sp.Matrix([[sp.Integer(e * den) for e in row] for row in ker.T.tolist()])
Dk, Uk, Vk = snf_transforms(kerZ.copy())
sat_rows = []
for i in range(14):
    rowv = sp.zeros(1, 18)
    rowv[0, i] = 1
    sat_rows.append(list(rowv * Vk.inv()))
kerSat = sp.Matrix([[sp.Integer(e) for e in row] for row in sat_rows])
Lbasis = sp.expand(kerSat * Bjoint)
X = sp.zeros(14, 14)
LT = Lbasis.T
ok_membership = True
for i in range(14):
    solx = LT.gauss_jordan_solve(O1[i, :].T)[0]
    for j in range(14):
        X[i, j] = sp.nsimplify(solx[j])
        if not X[i, j].is_integer:
            ok_membership = False
check("T3.1 O_1 sits inside O_joint^span_1 with integer transition", ok_membership)
check("T3.2 index [O_joint^span_1 : O_1] = 243 = 3^5, hence [P_1 : O_joint^span_1] = "
      "3^9/3^5 = 81 = 3^4: THE 81 SURVIVES", abs(X.det()) == 243,
      "|det| = %s" % abs(X.det()))

# ---------------------------------------------------------------- T4
print("=" * 72)
print("T4: the J_fix duality certificate")
print("=" * 72)

Jfix = sp.Matrix([[16, 2, 4], [2, -2, 2], [4, 2, -2]])
CU = sp.Matrix([[3, 0, 0], [-3, 0, 0], [0, 0, 0]])
CV = sp.Matrix([[2, 1, -1], [-2, -1, 2], [-2, -1, 2]])
CVd = sp.Matrix([[1, 0, 0], [-2, 0, 0], [2, 1, 2]])
check("T4.1 C_V^T J_fix = J_fix C_Vdual (explicit integer dual)",
      sp.simplify(CV.T * Jfix - Jfix * CVd) == sp.zeros(3, 3))
check("T4.2 dual carries the binary code: char C_Vdual = x(x-1)(x-2), tr(C_U C_Vdual) = 3, "
      "char(C_U + C_Vdual) = x(x-2)(x-4)",
      sp.expand(sp.factor(sp.expand((x * I3 - CVd).det())) - x * (x - 1) * (x - 2)) == 0
      and sp.trace(CU * CVd) == 3
      and sp.expand(sp.factor(sp.expand((x * I3 - (CU + CVd)).det())) - x * (x - 2) * (x - 4)) == 0)

# ---------------------------------------------------------------- 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: TRANSLATOR-LANDED -- the corpus RP anti-automorphism is the")
    print("J-adjoint twisted by the explicit inner element c (14c integral); the")
    print("seam is nonzero 3-torsion at infinity; the 81 survives frame-joining as")
    print("the saturation defect; the J_fix duality is certified (Lean green).")
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)

dbab863bf23797d0ed88c0f2347b77642d4482a5e36865286a4d45c60f4efc17

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.