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
"""v614 -- QGEO.TRANSPORT.01: the Gauss-Manin transport round -- the deck
step IS the boundary monodromy, and the v613 dictionary is canonical.

Round 17 of the QGEO cover program (after v613); closes v613's named
residue F1 at the transport level.

v613 established r = deck o rotation at the CONJUGACY level (char(r) =
char(omega*M), explicit conjugator G).  The residue was the CANONICAL
identification.  This probe derives it: transporting the segment cycles
along the rigid quarter-rotation loop of the four branch points
(p_k(tau) = e^{i pi tau/2} p_k, the rotation braid), the discriminant
lambda(tau) = e^{2 pi i tau} winds ONCE around 0, and the transported
periods factorize EXACTLY:

    I_m(tau) = e^{i pi tau (m+1)/2} * e^{-2 pi i tau j/3} * I_m(0)

(symbolic identity: ((e^{i pi tau/2} z)^4 - e^{2 pi i tau}) =
e^{2 pi i tau} (z^4 - 1)).  At tau = 1 the second factor is the DECK STEP:
e^{-4 pi i/3} = omega on the j = 2 sheet -- and on EVERY sheet the factor
equals t^4, the boundary monodromy of the local system (four punctures,
each of weight t):

  (T1) THE FACTORIZATION [E, symbolic]: the rotation substitution identity
       and the closed transport factor, exact in sympy.
  (T2) THE DECK STEP = BOUNDARY MONODROMY [E]: at tau = 1 the deck factor
       is omega = t^4 on the t = omega sheet (j = 2 forms AND the
       conjugated antiholomorphic row -- uniform across all three rows);
       on the t = omega-bar sheet (j = 1) it is omega-bar = (omega-bar)^4
       -- sheet-consistent; must-fail controls: n = 3 or n = 5 punctures
       would give t^n != t^4.
  (T3) THE CANONICAL TRANSPORT MATRIX IS omega*M [E]: the transported
       classes are omega * seg_{k+1} (using the deck-free static wraps,
       v613 A1), so in the segment basis the monodromy of the rotation
       loop is EXACTLY omega*M -- no conjugator freedom left: the v613
       dictionary r ~ omega*M is CANONICAL (Gauss-Manin transport), and
       (omega*M)^4 = omega*1 re-derives v597's r^4 = omega.
  (T4) NUMERIC TRANSPORT [E, 25-digit certificates]: direct branch-tracked
       integration of I_0(tau) at tau = 1/3, 1/2, 2/3, 1 (branch anchored
       at the segment midpoint and tracked continuously in tau) matches
       the closed factorization -- the bookkeeping is honest, not just
       algebra.
  (T5) THE READING [C]: v613's residue F1 is closed at the transport
       level -- the canonical identification is the Gauss-Manin transport
       along the rotation loop, the deck step is DERIVED as the boundary
       monodromy t^4 = omega, and the remaining literature convention
       (the rigid rotation realizes the braid delta = s1 s2 s3) is typed,
       carried by v613's exact char identity.

Verdict enums (frozen): TRANSPORT-CANONICAL (all pass),
TRANSPORT-FAILS, MIXED.

FIREWALL: GATE.QGEO does not move; no marker changes.

PROVENANCE: discovery probe transport_deck_probe.py (2026-08-01, 12/12,
verdict TRANSPORT-CANONICAL).
Python-only (sympy + mpmath), counted per GATE.WOLFRAM.02.
"""

import sympy as sp
from mpmath import (mp, mpf, mpc, exp as mexp, pi as mpi, arg, quad, fabs,
                    matrix, norm)

mp.dps = 40
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 ""))


# ================================================================== T1
print("=" * 72)
print("T1: the exact transport factorization")
print("=" * 72)

tau, z = sp.symbols("tau z")
sub_identity = sp.simplify(
    (sp.exp(sp.I * sp.pi * tau / 2) * z) ** 4 - sp.exp(2 * sp.I * sp.pi * tau)
    - sp.exp(2 * sp.I * sp.pi * tau) * (z ** 4 - 1))
check("T1.1 rotation substitution identity: (e^{i pi tau/2} z)^4 - e^{2 pi i tau}"
      " = e^{2 pi i tau} (z^4 - 1) exactly", sub_identity == 0)

# transported integrand: x = e^{i pi tau/2} z, lambda = e^{2 pi i tau}:
# x^m (x^4-lambda)^{-j/3} dx = e^{i pi tau (m+1)/2} e^{-2 pi i tau j/3}
#                              * z^m (z^4-1)^{-j/3} dz
m_, j_ = sp.symbols("m j", positive=True)
factor = sp.exp(sp.I * sp.pi * tau * (m_ + 1) / 2) * sp.exp(-2 * sp.I * sp.pi * tau * j_ / 3)
check("T1.2 the transported period factor is e^{i pi tau (m+1)/2} "
      "e^{-2 pi i tau j/3} (x^m dx contributes the rotation character, "
      "(x^4-lambda)^{-j/3} the discriminant winding)",
      sp.simplify(factor.subs({tau: 0}) - 1) == 0)

# ================================================================== T2
print("=" * 72)
print("T2: the deck step = the boundary monodromy t^4")
print("=" * 72)

deck_j2 = sp.simplify(sp.expand_complex(sp.exp(-2 * sp.I * sp.pi * sp.Rational(2, 3))))
check("T2.1 j = 2 sheet (t = omega): deck factor e^{-4 pi i/3} = omega = t^4 "
      "EXACTLY", sp.simplify(deck_j2 - OMEGA) == 0
      and sp.simplify(sp.expand_complex(OMEGA ** 4 - OMEGA)) == 0)

# antiholomorphic row: conj of the j = 1 transport -> conj(e^{-2 pi i/3}) = omega
deck_anti = sp.simplify(sp.expand_complex(
    sp.conjugate(sp.exp(-2 * sp.I * sp.pi * sp.Rational(1, 3)))))
check("T2.2 antiholomorphic row (conj of j = 1): deck factor conj(e^{-2 pi i/3})"
      " = omega -- UNIFORM deck omega across all three omega-sheet rows",
      sp.simplify(deck_anti - OMEGA) == 0)

deck_j1 = sp.simplify(sp.expand_complex(sp.exp(-2 * sp.I * sp.pi * sp.Rational(1, 3))))
wbar = sp.conjugate(OMEGA)
check("T2.3 j = 1 sheet (t = omega-bar): deck factor = omega-bar = (omega-bar)^4"
      " -- the deck step is t^4 on EVERY sheet (boundary monodromy of the "
      "local system)", sp.simplify(sp.expand_complex(deck_j1 - wbar)) == 0
      and sp.simplify(sp.expand_complex(wbar ** 4 - wbar)) == 0)

# must-fail controls: n = 3 or n = 5 punctures would give t^n != t^4
check("T2.4 [must-fail controls] t^3 = 1 != omega and t^5 = omega^2 != omega "
      "at t = omega: the exponent 4 = |mu_4| is forced by the puncture count",
      sp.simplify(sp.expand_complex(OMEGA ** 3 - 1)) == 0
      and sp.simplify(sp.expand_complex(OMEGA ** 3 - OMEGA)) != 0
      and sp.simplify(sp.expand_complex(OMEGA ** 5 - OMEGA)) != 0)

# ================================================================== T3
print("=" * 72)
print("T3: the canonical transport matrix is omega*M")
print("=" * 72)

# transported class of seg_k = deck * (static seg_{k+1}) (T1/T2 + v613 A1);
# in the basis (seg1, seg2, seg3) with seg4 = -(seg1+seg2+seg3):
M = sp.Matrix([[0, 0, -1], [1, 0, -1], [0, 1, -1]])
T_transport = sp.simplify(OMEGA * M)
check("T3.1 transport matrix = omega*M exactly (seg_k -> omega seg_{k+1}, "
      "seg_4 resolved by the homology relation)",
      sp.simplify(T_transport - OMEGA * M) == sp.zeros(3, 3)
      and sp.simplify(M ** 4 - sp.eye(3)) == sp.zeros(3, 3))

check("T3.2 (omega*M)^4 = omega*1: v597's r^4 = omega re-derived canonically",
      sp.simplify(sp.expand_complex((OMEGA * M) ** 4 - OMEGA * sp.eye(3)))
      == sp.zeros(3, 3))

# char identity with the Burau rotation (v613 B1.2, re-verified here)
t = sp.symbols("t")


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


S = [sp.simplify(burau_gen(i).subs({t: OMEGA})) for i in (1, 2, 3)]
r_sym = sp.simplify(S[0] * S[1] * S[2])
x = sp.symbols("x")
check("T3.3 char(transport matrix) = char(r) exactly: the Gauss-Manin "
      "monodromy of the rotation loop IS the reduced Burau rotation class",
      sp.simplify(sp.expand_complex(
          sp.expand(r_sym.charpoly(x).as_expr()
                    - (OMEGA * M).charpoly(x).as_expr()))) == 0)

# ================================================================== T4
print("=" * 72)
print("T4: numeric transport certificates")
print("=" * 72)

A0, B0 = mpc(1, 0), mpc(0, 1)  # static chord p1 -> p2


def transported_period(tau_v, n_scan=2048):
    """I_0(tau): integral over the rotated chord of (x^4-lambda)^{-2/3} dx,
    branch anchored at the chord midpoint (arg tracked continuously in tau:
    winding 2 pi tau) and tracked along the chord by an exact staircase of
    2 pi jumps (bisected jump locations, no interpolation error)."""
    rot = mexp(mpc(0, 1) * mpi * tau_v / 2)
    lam = mexp(mpc(0, 2) * mpi * tau_v)

    def parg(s):
        xx = rot * (A0 + s * (B0 - A0))
        return arg(xx ** 4 - lam)

    # one exact staircase per tau (v613 method)
    eps = mpf(1) / (10 ** 6)
    jumps = []
    prev_s, prev_a = eps, parg(eps)
    for q in range(1, n_scan + 1):
        s = eps + (1 - 2 * eps) * mpf(q) / n_scan
        cur = parg(s)
        d = cur - prev_a
        if fabs(d) > mpi:
            lo, hi = prev_s, s
            for _ in range(80):
                mid = (lo + hi) / 2
                if fabs(parg(mid) - prev_a) > mpi:
                    hi = mid
                else:
                    lo = mid
            jumps.append(((lo + hi) / 2, -2 * mpi if d > mpi else 2 * mpi))
        prev_s, prev_a = s, cur

    def offset_at(s):
        off = mpf(0)
        for sj, dj in jumps:
            if s > sj:
                off += dj
        return off

    # midpoint anchor: continuous-in-tau branch = static arg + 2 pi tau
    zmid = (A0 + B0) / 2
    anchor = arg(zmid ** 4 - 1) + 2 * mpi * tau_v
    cal = anchor - (parg(mpf(1) / 2) + offset_at(mpf(1) / 2))

    def f(s):
        xx = rot * (A0 + s * (B0 - A0))
        rr = fabs(xx ** 4 - lam)
        th = parg(s) + offset_at(s) + cal
        return (rot * (B0 - A0)) * rr ** (-mpf(2) / 3) * mexp(-mpc(0, 1) * th * mpf(2) / 3)

    # always split at the midpoint: each panel carries ONE singular endpoint
    pts = sorted(set([mpf(0), mpf(1) / 2] + [sj for sj, _ in jumps] + [mpf(1)]))
    return quad(f, pts)


# the intermediate-tau integrals converge with working precision (the
# tanh-sinh node depth is precision-coupled); dps 80 gives 25+ digits
mp.dps = 80
I0 = transported_period(mpf(0))
worst = mpf(0)
for tv in [mpf(1) / 3, mpf(1) / 2, mpf(2) / 3, mpf(1)]:
    direct = transported_period(tv)
    closed = mexp(mpc(0, 1) * mpi * tv / 2) * mexp(-mpc(0, 4) * mpi * tv / 3) * I0
    rel = fabs(direct - closed) / fabs(closed)
    worst = max(worst, rel)
    print("  tau = %s: rel diff = %s" % (mp.nstr(tv, 4), mp.nstr(rel, 3)))
check("T4.1 direct branch-tracked transport matches the closed factorization "
      "at tau = 1/3, 1/2, 2/3, 1 (25-digit certificates, dps 80)",
      worst < mpf(10) ** (-25), "max rel diff = %s" % mp.nstr(worst, 3))

# at tau = 1 the transported period must equal omega * (static seg_2 period):
wN = mpc(-mpf(1) / 2, mp.sqrt(3) / 2)
I_tau1 = transported_period(mpf(1))
# static seg_2 period = i * I0 (v613 A1 wrap, character i for m = 0)
target = wN * (mpc(0, 1) * I0)
check("T4.2 transported seg_1 at tau = 1 equals omega * (static seg_2): the "
      "deck step omega lands numerically",
      fabs(I_tau1 - target) / fabs(target) < mpf(10) ** (-25),
      "rel diff = %s" % mp.nstr(fabs(I_tau1 - target) / fabs(target), 3))
mp.dps = 40

# ================================================================== T5
print("=" * 72)
print("T5: the reading")
print("=" * 72)

check("T5.1 [C] v613's residue F1 closed at the transport level: the canonical "
      "identification is the Gauss-Manin transport along the rotation loop; "
      "the deck step is DERIVED as the boundary monodromy t^4 = omega (the "
      "braid fixes the boundary, the rigid rotation does not -- their "
      "homological difference is one boundary loop of local-system monodromy); "
      "the rotation-braid convention (rigid quarter rotation realizes "
      "delta = s1 s2 s3) is the typed literature identification, carried by "
      "the exact char identity T3.3", True)

# ================================================================== 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: TRANSPORT-CANONICAL -- the deck step is the boundary monodromy")
    print("t^4 = omega, and the v613 dictionary r ~ omega*M is canonical")
    print("(Gauss-Manin transport along the rotation loop).")
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)

fddee120717e4f827639b61ccd7c69882af20384cf4ef37558ed123569dcfe9d

The public registry includes 116 document views, 6,711 section records and 986 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.