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
# -*- coding: utf-8 -*-
r"""v796 -- CURVE.CODE.OUTERSPIN.01: the canonical OUTER bridge between the code's duad side and the curve's syntheme side of the S6 duality (24/24 checks, ~11 s; discovery probe duad_syntheme_bridge_probe.py, 2026-08-05, verdict BRIDGE-CANONICAL).  THE CONSTRUCTION (Sylvester duality made explicit): a bridge is a bijection beta: Omega_code -> T_curve (code odd Arf forms -> curve isotropic spreads/totals), canonically inducing the incidence-preserving duality Delta_beta: V\{0} -> IsoLines(A[2]) through the K6 duad model and the shared-syntheme rule (every pair of totals shares exactly one line -- verified).  THE CENSUS: 18 + 18 bridges intertwine sigma with tau|T resp. tau^2|T (each family a torsor under C_S6(3-cycle), order 18); after pinning beta(q*) = S* -- the UNIQUE curve spread fixed by the FULL <tau, rho> automorphism image (rho = the mu4 rotation = the complex structure J = mult by zeta^9; existence + uniqueness COMPUTED, not assumed) -- exactly 6 + 6 remain = ONE ORBIT (torsor) under the order-6 code joint stabilizer, with the tau/tau^2 families exchanged by an inner code symmetry (one statement).  B2 ARF RESOLUTION: the pullback of the curve's even q_Theta through the two frozen even<->3|3-split dictionaries is CONSTANT over all 36 B1 bridges and equals q_even* = the unique sigma-invariant even code refinement, with the NAMED operation q* = q_even* + hbar(., A) EXACT -- the anchor shift resolves the v784 Arf mismatch canonically.  THE OUTER WITNESS exact: sigma is [3,1,1,1] on odds but [3,3] on spreads, tau the reverse, the anchor transvection t_A is [2,1,1,1,1] on odds but [2,2,2] on spreads, and the class swap is UNIFORM (0 violations over all 720 group elements) -- the twist IS the outer automorphism of S6, not an inner accident.  TRANSPORTS (structure labels only): {q* = 0}\{0} maps EXACTLY onto the 5 lines of S* (5bar) and the 10 onto the complement; the 3+2 split maps onto the [3,1,1] tau-orbit structure of S*; t_A maps to rho = J on every census bridge; chi_NSR transports as an honest exact TWO-VARIANT torsor ('incidence with one of the two tau-fixed lines of S*') -- it is pinned code-side by the v752 NS/R lattice parity, a datum the bare quadruple (V, hbar, sigma, q*) does not carry, and rho swaps the two candidate lines (the two-fold ambiguity intrinsic).  CONTROLS: inner cross-side census 0 (class mismatch), same-side census 0, no bridge pulls q_Theta to an ODD form (never to q*), scrambled sigma census 0.  The v784 INNER identification stays dead (CURVE-CODE-PARTIAL untouched); the bridge is a NEW statement about the outer twist.  NO matter semantics (5bar/10, 3+2, chi_NSR are structure labels; ROOTCLASS-MIXED v775 stands).  No marker move, NO RH claim.  Python-only per GATE.WOLFRAM.02.

PROVENANCE: discovery probe duad_syntheme_bridge_probe.py (2026-08-05, 24/24, ~11 s, BRIDGE-CANONICAL; no spec corrections disclosed); re-run identically at promotion (2026-08-06).  Promoted verbatim; the probe's top-level statements are wrapped in a function scope _probe() (v791 precedent 'top-level statements moved into main()'), its final SystemExit replaced by a return of (n_pass, n_tot, verdict); numbers unchanged; run() encodes the pattern (v757 precedent).  The curve side is the exact certified model of curve_code_2torsion_probe / v784 (period-lattice recognition certified there at dps 120; nothing numerical recomputed here).

Original duad_syntheme_bridge_probe.py docstring (verbatim):
duad_syntheme_bridge_probe -- CURVE.CODE.BRIDGE.01 (follow-up to
curve_code_2torsion_probe, verdict CURVE-CODE-PARTIAL): is there a
CANONICAL outer bridge between the code's duad side and the curve's
syntheme side of the S6 duality?

STRUCTURAL RESIDUE OF THE KILL (input facts, re-verified here):
  * code side (V, hbar, sigma, q*): sigma = family 3-cycle, fixed-space
    dim 2, cycle type [3,1,1,1] on the 6 odd refinements (duad side);
    q* odd/Arf-1 with decomposition 1+5bar+10.
  * curve side (A[2], e_2, tau, q_Theta): deck tau acts freely, cycle
    type [3,3] on the 6 odd theta characteristics (syntheme side);
    q_Theta even/Arf-0 with decomposition 1+6+9.
  * the two order-3 classes are exchanged only by the OUTER automorphism
    of S6; Arf is a transport invariant: joint inner census was 0.

THE FROZEN BRIDGE CONSTRUCTION (Sylvester duality, made explicit):
  On each side the doily GQ(2,2) has 6 ovoids = odd refinements
  ("points" Omega of the six-set), 15 points = duads of Omega (v <-> D(v),
  the K6 duad model), 15 isotropic lines = synthemes (perfect matchings),
  and 6 isotropic spreads = totals (1-factorizations).  The action of
  Sp(4,2) = S6 on the 6 totals is the OUTER twist of its action on the 6
  points.  A BRIDGE is a bijection
        beta : Omega_code -> T_curve   (code odd forms -> curve spreads),
  which canonically induces the duality
        Delta_beta : V\{0} -> IsoLines(A[2]),
        v -> D(v) = {o, o'} -> the UNIQUE line shared by the spreads
        beta(o), beta(o')   (every pair of totals shares exactly one
        syntheme -- verified),
  incidence-preserving for every beta (purely set-theoretic; all 720
  dualities arise this way).

FROZEN BRIDGE CONDITIONS:
  (B1) twisted equivariance on the distinguished order-3 elements:
       beta o (sigma|Omega_code) o beta^{-1} = tau|T_curve  (tau^2 variant
       reported as the family related by an inner code symmetry).
  (B2) Arf resolution (consequence, must be CONSTANT over the census):
       the pullback of q_Theta along the bridge -- via the two frozen
       dictionaries below -- equals q_even* := the unique sigma-invariant
       EVEN code refinement, and the NAMED operation
             q* = q_even* + hbar(., A)      (the anchor shift)
       relates it to q* exactly.
       Transport note (frozen expectation): chi_NSR = hbar(., F_Sigma)
       is pinned on the code side by the v752 NS/R LATTICE parity, a
       datum the bare quadruple (V, hbar, sigma, q*) does not carry (the
       joint stabilizer swaps F_Sigma <-> F_Sigma + A); its transport is
       therefore required to be an exact TWO-variant torsor whose
       variants are 'incidence with one of the two tau-fixed lines of
       S*' -- not a constant.
  (B3) distinguished-element pinning: beta(q*) = S*, where S* := the
       UNIQUE spread of the curve fixed by the FULL curve-automorphism
       image <tau, rho> mod 2 (rho = the mu4 rotation = the complex
       structure J = mult by zeta^9; existence+uniqueness of S* is part
       of the CANONICAL criterion and is computed, not assumed).

FROZEN DICTIONARIES (both sides, canonical and equivariant):
  * evens <-> 3|3-splits of the six POINTS: for an even refinement q,
    join odd forms o, o' iff q(v_{oo'}) = 1 where v_{oo'} is the duad
    vector (D(v_{oo'}) = {o,o'}); the graph must be two disjoint
    triangles (6 within-block duads carry q = 1, the 9 cross duads
    q = 0) -- verified, bijective onto the 10 splits.
  * evens <-> 3|3-splits of the six TOTALS: join spreads S, S' iff their
    shared line lies entirely in {q = 0} (each spread contains exactly 2
    of the 6 generator lines of the even quadric, and disjoint
    generators lie in one regulus) -- verified, bijective.

VERDICT ENUM (frozen):
  BRIDGE-CANONICAL      B1-census = torsor under C_{S6}(sigma) (18 per
                        family), S* exists uniquely, full census
                        B1+B3 = |code joint stabilizer| = 6 per family
                        (one orbit incl. the tau/tau^2 swap under code
                        symmetries), and the B2 pullback is constant
                        q_even*: the outer twist canonically identifies
                        the two sides.
  BRIDGE-NONCANONICAL   the exchange exists (B1-census > 0) but the
                        pinning fails (S* not unique, or the census is
                        not a single stabilizer-torsor): the exact
                        ambiguity census is reported.
  BRIDGE-DEAD           B1-census = 0: no equivariant exchange.
  TEST-VOID             a must-fire control does not fire.

CONTROLS (frozen, must fire):
  C1a  inner instead of outer, cross-side: bijections Omega_code ->
       Omega_curve intertwining sigma with tau: 0 (class mismatch
       [3,1,1,1] vs [3,3]).
  C1b  inner instead of outer, same-side: bijections Omega_code ->
       T_code intertwining sigma|Omega with sigma|T: 0.
  C2   wrong Arf target: no B1 bridge pulls q_Theta back to an ODD code
       form (in particular never to q*): the dictionaries are
       even-to-even.
  C3   scrambled sigma: tau|T composed with a frozen transposition of
       two tau-fixed spreads has the wrong cycle type: B1 census 0.
  (positive control = the main census itself: nonzero AND exactly the
  stabilizer torsor, with the explicit orbit verification.)

FENCES (honesty, frozen):
  *  Finite exact algebra only.  The curve side is the exact certified
     model of curve_code_2torsion_probe (E* = Tr(zeta^3 x conj y)/2 of
     type (1,3) on O/2O, O = Z[zeta_12]; period-lattice recognition was
     certified there at dps 120, residuals < 1e-41; nothing numerical is
     recomputed or needed here).
  *  NO matter semantics: the names 5bar/10, 3+2, chi_NSR are used as
     STRUCTURE LABELS only.  The root-level matter reading is separately
     DEAD per gaussian_class_d5_purity_probe (ROOTCLASS-MIXED) and is
     not resurrected in either direction.
  *  This probe does not modify the CURVE-CODE-PARTIAL verdict: the
     inner identification stays dead; the bridge (if canonical) is a NEW
     statement about the outer twist.

FIREWALL: experiments/tfpt-discovery probe; ONE new file; writes
nothing; touches no verification/, paper, ledger, changelog or website
surface; report only.

Sources (read-only): experiments/tfpt-discovery/curve_code_2torsion_probe.py
(both frozen models), arf_spinor_compiler_probe.py (code layer, K6 duads),
verification/v752/v753 (code provenance), v610/v611 (curve provenance).

Run:
    experiments/tfpt-discovery/.venv/bin/python \
        experiments/tfpt-discovery/duad_syntheme_bridge_probe.py
"""

def _probe():
    import itertools
    import time

    T0 = time.time()
    CHECKS = []
    KILLS = []


    def check(name, ok, detail="", kill=None):
        CHECKS.append((name, bool(ok)))
        if kill and not ok:
            KILLS.append(kill)
        print("[%s] %s%s" % ("PASS" if ok else "FAIL", name,
                             (" -- " + detail) if detail else ""), flush=True)
        return bool(ok)


    def section(title):
        print("=" * 78)
        print(title)
        print("=" * 78, flush=True)


    # ======================================================================
    # exact Z[zeta_12] layer (frozen copy from curve_code_2torsion_probe)
    # ======================================================================
    ZPOW = [(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1),
            (-1, 0, 1, 0), (0, -1, 0, 1), (-1, 0, 0, 0)]
    CONJ_BASIS = [(1, 0, 0, 0), (0, 1, 0, -1), (1, 0, -1, 0), (0, 0, 0, -1)]
    E_K = [(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]


    def kmul(a, b):
        conv = [0] * 7
        for i in range(4):
            if a[i]:
                for j in range(4):
                    conv[i + j] += a[i] * b[j]
        out = [0, 0, 0, 0]
        for k in range(7):
            if conv[k]:
                for t in range(4):
                    out[t] += conv[k] * ZPOW[k][t]
        return tuple(out)


    def kconj(a):
        out = [0, 0, 0, 0]
        for i in range(4):
            if a[i]:
                for t in range(4):
                    out[t] += a[i] * CONJ_BASIS[i][t]
        return tuple(out)


    def ktrace(a):
        return 4 * a[0] + 2 * a[2]


    def kpow_zeta(k):
        out = (1, 0, 0, 0)
        for _ in range(k % 12):
            out = kmul(out, (0, 1, 0, 0))
        return out


    def mult_matrix_mod2(g):
        return [[kmul(g, E_K[j])[i] % 2 for j in range(4)] for i in range(4)]


    def Estar(x, y):
        t = ktrace(kmul(kmul(kpow_zeta(3), x), kconj(y)))
        assert t % 2 == 0
        return t // 2


    # ======================================================================
    # generic side builder: vectors = 4-bit ints, bit k = basis coeff k
    # ======================================================================
    def build_tables(gram):
        tab = [[0] * 16 for _ in range(16)]
        for x in range(16):
            for y in range(16):
                xv = [(x >> k) & 1 for k in range(4)]
                yv = [(y >> k) & 1 for k in range(4)]
                tab[x][y] = sum(xv[i] * gram[i][j] * yv[j]
                                for i in range(4) for j in range(4)) % 2
        return tab


    def all_refinements(tab):
        refs = []
        for mask in range(1 << 16):
            q = [(mask >> i) & 1 for i in range(16)]
            ok = True
            for i in range(16):
                row = tab[i]
                qi = q[i]
                for j in range(16):
                    if q[i ^ j] ^ qi ^ q[j] != row[j]:
                        ok = False
                        break
                if not ok:
                    break
            if ok:
                refs.append(tuple(q))
        return refs


    def iso_lines(tab):
        out = set()
        for a in range(1, 16):
            for b in range(a + 1, 16):
                if tab[a][b] == 0 and (a ^ b) != 0:
                    out.add(frozenset({a, b, a ^ b}))
        return sorted(out, key=sorted)


    def spreads_of(lines):
        pts = set(range(1, 16))
        by_pt = {}
        for L in lines:
            for p in L:
                by_pt.setdefault(p, []).append(L)

        def rec(cov, used):
            if len(cov) == 15:
                return [frozenset(used)]
            p = min(pts - cov)
            res = []
            for L in by_pt[p]:
                if cov & L:
                    continue
                res += rec(cov | L, used + [L])
            return res

        return sorted(set(rec(frozenset(), [])), key=lambda S: sorted(map(sorted, S)))


    def linear_transporters(src_tab, dst_tab):
        out = []
        for m in range(1 << 16):
            cols = [(m >> (4 * k)) & 15 for k in range(4)]
            img = [0] * 16
            for x in range(16):
                v = 0
                for k in range(4):
                    if x & (1 << k):
                        v ^= cols[k]
                img[x] = v
            if len(set(img)) != 16:
                continue
            ok = True
            for x in range(1, 16):
                for y in range(x, 16):
                    if dst_tab[img[x]][img[y]] != src_tab[x][y]:
                        ok = False
                        break
                if not ok:
                    break
            if ok:
                out.append(tuple(img))
        return out


    def perm_cycle_type(p):
        seen, ct = set(), []
        for s in range(len(p)):
            if s in seen:
                continue
            ln, cur = 0, s
            while cur not in seen:
                seen.add(cur)
                cur = p[cur]
                ln += 1
            ct.append(ln)
        return sorted(ct, reverse=True)


    def inv_perm16(g):
        gi = [0] * 16
        for x in range(16):
            gi[g[x]] = x
        return gi


    class Side(object):
        def __init__(self, name, gram, dist3):
            self.name = name
            self.tab = build_tables(gram)
            self.dist3 = dist3                      # image table of the order-3
            self.refs = all_refinements(self.tab)
            self.zeros = {q: sum(1 for b in q if b == 0) for q in self.refs}
            self.odds = sorted(q for q in self.refs if self.zeros[q] == 6)
            self.evens = sorted(q for q in self.refs if self.zeros[q] == 10)
            self.lines = iso_lines(self.tab)
            self.spreads = spreads_of(self.lines)
            self.sp = linear_transporters(self.tab, self.tab)
            # duad vector for each pair of odds
            self.duad_vec = {}
            for v in range(1, 16):
                dv = [i for i, q in enumerate(self.odds) if q[v] == 0]
                assert len(dv) == 2
                self.duad_vec[frozenset(dv)] = v
            # shared line for each pair of spreads
            self.shared = {}
            for i in range(6):
                for j in range(i + 1, 6):
                    inter = self.spreads[i] & self.spreads[j]
                    self.shared[frozenset({i, j})] = inter

        def odd_perm(self, g):
            gi = inv_perm16(g)
            return [self.odds.index(tuple(q[gi[v]] for v in range(16)))
                    for q in self.odds]

        def spread_perm(self, g):
            out = []
            for S in self.spreads:
                Sg = frozenset(frozenset(g[p] for p in L) for L in S)
                out.append(self.spreads.index(Sg))
            return out

        def split_pts(self, q):
            """even refinement -> 3|3 split of the 6 odds (frozen dictionary)."""
            adj = {i: set() for i in range(6)}
            for i in range(6):
                for j in range(i + 1, 6):
                    if q[self.duad_vec[frozenset({i, j})]] == 1:
                        adj[i].add(j)
                        adj[j].add(i)
            comp = []
            seen = set()
            for s in range(6):
                if s in seen:
                    continue
                blk, stack = set(), [s]
                while stack:
                    u = stack.pop()
                    if u in blk:
                        continue
                    blk.add(u)
                    stack += list(adj[u] - blk)
                seen |= blk
                comp.append(frozenset(blk))
            return frozenset(comp)

        def split_tot(self, q):
            """even refinement -> 3|3 split of the 6 spreads (frozen dict)."""
            adj = {i: set() for i in range(6)}
            for key, inter in self.shared.items():
                i, j = sorted(key)
                (L,) = inter
                if all(q[p] == 0 for p in L):
                    adj[i].add(j)
                    adj[j].add(i)
            comp = []
            seen = set()
            for s in range(6):
                if s in seen:
                    continue
                blk, stack = set(), [s]
                while stack:
                    u = stack.pop()
                    if u in blk:
                        continue
                    blk.add(u)
                    stack += list(adj[u] - blk)
                seen |= blk
                comp.append(frozenset(blk))
            return frozenset(comp)


    # ======================================================================
    # S1 -- both sides rebuilt, base censuses
    # ======================================================================
    section("S1: both sides rebuilt exactly -- base censuses")

    # code side: Gram J - I in (F1,F2,F3,A); sigma = family 3-cycle on bits
    GJI = [[0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 0, 1], [1, 1, 1, 0]]
    SIG_B = [0] * 16
    for x in range(16):
        b = [(x >> k) & 1 for k in range(4)]
        nb = (b[2], b[0], b[1], b[3])
        SIG_B[x] = nb[0] | (nb[1] << 1) | (nb[2] << 2) | (nb[3] << 3)
    code = Side("code", GJI, SIG_B)

    # curve side: E* Gram mod 2 (frozen (1,3) polarization); tau = M(zeta^4)
    ESTAR = [[Estar(E_K[i], E_K[j]) % 2 for j in range(4)] for i in range(4)]
    MT = mult_matrix_mod2(kpow_zeta(4))
    MR = mult_matrix_mod2(kpow_zeta(9))     # rho = J = mult by zeta^9
    TAU_B = [0] * 16
    RHO_B = [0] * 16
    for x in range(16):
        xv = [(x >> k) & 1 for k in range(4)]
        it = [sum(MT[i][j] * xv[j] for j in range(4)) % 2 for i in range(4)]
        ir = [sum(MR[i][j] * xv[j] for j in range(4)) % 2 for i in range(4)]
        TAU_B[x] = it[0] | (it[1] << 1) | (it[2] << 2) | (it[3] << 3)
        RHO_B[x] = ir[0] | (ir[1] << 1) | (ir[2] << 2) | (ir[3] << 3)
    curve = Side("curve", ESTAR, TAU_B)

    check("S1.1 refinement censuses: 16 = 6 odd + 10 even on BOTH sides",
          len(code.refs) == 16 and len(code.odds) == 6
          and len(curve.refs) == 16 and len(curve.odds) == 6, kill="K")
    check("S1.2 doily counts on BOTH sides: 15 isotropic lines, exactly 6 "
          "isotropic spreads (= the 6 totals/1-factorizations); every pair "
          "of spreads shares exactly one line; every line lies in exactly 2 "
          "spreads",
          len(code.lines) == 15 and len(code.spreads) == 6
          and len(curve.lines) == 15 and len(curve.spreads) == 6
          and all(len(v) == 1 for v in code.shared.values())
          and all(len(v) == 1 for v in curve.shared.values())
          and all(sum(1 for S in code.spreads if L in S) == 2
                  for L in code.lines)
          and all(sum(1 for S in curve.spreads if L in S) == 2
                  for L in curve.lines), kill="K")

    A_INT = 0b1000          # anchor A = (0,0,0,1)
    FSIG_INT = 0b0111       # F_Sigma = (1,1,1,0)
    QSTAR = [q for q in code.odds
             if all(q[SIG_B[x]] == q[x] for x in range(16))
             and q[A_INT] == 1 and q[FSIG_INT] == 0]
    sig_inv_evens = [q for q in code.evens
                     if all(q[SIG_B[x]] == q[x] for x in range(16))]
    tau_inv_refs = [q for q in curve.refs
                    if all(q[TAU_B[x]] == q[x] for x in range(16))]
    check("S1.3 distinguished data: q* unique (%d); q_even* = the UNIQUE "
          "sigma-invariant even code form (%d); q_Theta = the unique "
          "tau-invariant curve refinement (%d), even"
          % (len(QSTAR), len(sig_inv_evens), len(tau_inv_refs)),
          len(QSTAR) == 1 and len(sig_inv_evens) == 1
          and len(tau_inv_refs) == 1
          and curve.zeros[tau_inv_refs[0]] == 10, kill="K")
    QSTAR = QSTAR[0]
    QEVEN = sig_inv_evens[0]
    QTHETA = tau_inv_refs[0]

    shifted = tuple((QEVEN[x] + code.tab[x][A_INT]) % 2 for x in range(16))
    check("S1.4 NAMED OPERATION exact: q* = q_even* + hbar(., A) (the anchor "
          "shift relates the even and odd distinguished forms)",
          shifted == QSTAR, kill="K")

    # ======================================================================
    # S2 -- the six-set actions and the outer witness
    # ======================================================================
    section("S2: the two six-set actions of Sp(4,2) and the OUTER witness")

    code_odd_perms = set()
    code_spr_perms = set()
    pair_types = set()
    for g in code.sp:
        po = tuple(code.odd_perm(g))
        ps = tuple(code.spread_perm(g))
        code_odd_perms.add(po)
        code_spr_perms.add(ps)
        pair_types.add((tuple(perm_cycle_type(list(po))),
                        tuple(perm_cycle_type(list(ps)))))
    curve_odd_perms = set()
    curve_spr_perms = set()
    for g in curve.sp:
        curve_odd_perms.add(tuple(curve.odd_perm(g)))
        curve_spr_perms.add(tuple(curve.spread_perm(g)))
    check("S2.1 both actions faithful + surjective onto S6 on BOTH sides: "
          "odd-perms %d/%d/%d/%d spread-perms all == 720"
          % (len(code_odd_perms), len(code_spr_perms),
             len(curve_odd_perms), len(curve_spr_perms)),
          len(code_odd_perms) == 720 and len(code_spr_perms) == 720
          and len(curve_odd_perms) == 720 and len(curve_spr_perms) == 720,
          kill="K")

    sigO = code.odd_perm(SIG_B)
    sigT = code.spread_perm(SIG_B)
    tauO = curve.odd_perm(TAU_B)
    tauT = curve.spread_perm(TAU_B)
    rhoO = curve.odd_perm(RHO_B)
    rhoT = curve.spread_perm(RHO_B)
    # a code transvection t_A(x) = x + hbar(x, A) A (canonical: the anchor)
    T_A = [x ^ (code.tab[x][A_INT] * A_INT) for x in range(16)]
    tAO = code.odd_perm(T_A)
    tAT = code.spread_perm(T_A)
    print("    cycle types  (on 6 odds | on 6 spreads):")
    print("      code sigma      : %s | %s" % (perm_cycle_type(sigO),
                                               perm_cycle_type(sigT)))
    print("      code t_A        : %s | %s" % (perm_cycle_type(tAO),
                                               perm_cycle_type(tAT)))
    print("      curve tau       : %s | %s" % (perm_cycle_type(tauO),
                                               perm_cycle_type(tauT)))
    print("      curve rho (= J) : %s | %s" % (perm_cycle_type(rhoO),
                                               perm_cycle_type(rhoT)))
    check("S2.2 OUTER WITNESS: the point-action and total-action differ by "
          "the outer automorphism: sigma is [3,1,1,1] on odds but [3,3] on "
          "spreads; tau is [3,3] on odds but [3,1,1,1] on spreads; the "
          "anchor transvection t_A is [2,1,1,1,1] on odds but [2,2,2] on "
          "spreads (transposition <-> triple transposition)",
          perm_cycle_type(sigO) == [3, 1, 1, 1]
          and perm_cycle_type(sigT) == [3, 3]
          and perm_cycle_type(tauO) == [3, 3]
          and perm_cycle_type(tauT) == [3, 1, 1, 1]
          and perm_cycle_type(tAO) == [2, 1, 1, 1, 1]
          and perm_cycle_type(tAT) == [2, 2, 2], kill="K")
    n_3cyc_swap = sum(1 for a, b in pair_types
                      if a == (3, 1, 1, 1) and b != (3, 3))
    check("S2.3 class swap is UNIFORM: every code element of type [3,1,1,1] "
          "on odds is [3,3] on spreads (violations: %d) -- the twist is the "
          "outer automorphism, not an inner accident" % n_3cyc_swap,
          n_3cyc_swap == 0, kill="K")

    # ======================================================================
    # S3 -- the frozen dictionaries evens <-> splits
    # ======================================================================
    section("S3: dictionaries -- evens <-> 3|3 splits of points and totals")


    def dict_ok(side):
        d_pts, d_tot = {}, {}
        for q in side.evens:
            sp_ = side.split_pts(q)
            st_ = side.split_tot(q)
            if sorted(len(b) for b in sp_) != [3, 3]:
                return None
            if sorted(len(b) for b in st_) != [3, 3]:
                return None
            d_pts[q] = sp_
            d_tot[q] = st_
        if len(set(d_pts.values())) != 10 or len(set(d_tot.values())) != 10:
            return None
        return d_pts, d_tot


    dc = dict_ok(code)
    du = dict_ok(curve)
    check("S3.1 both dictionaries are well-defined 3|3 splits and BIJECTIVE "
          "onto the 10 splits, on both sides (the within-block duads carry "
          "q = 1; the within-block shared lines lie in {q = 0})",
          dc is not None and du is not None, kill="K")
    DPTS_CODE, DTOT_CODE = dc
    DPTS_CURVE, DTOT_CURVE = du

    # equivariance spot check over 60 group elements per side
    ok_eq = True
    for side, dp in ((code, DPTS_CODE), (curve, DPTS_CURVE)):
        for g in side.sp[::12]:
            gi = inv_perm16(g)
            po = side.odd_perm(g)
            for q in side.evens[:4]:
                qg = tuple(q[gi[v]] for v in range(16))
                want = frozenset(frozenset(po[i] for i in blk) for blk in dp[q])
                if dp[qg] != want:
                    ok_eq = False
    check("S3.2 dictionary equivariance (spot check, 60 elements x 4 evens "
          "per side)", ok_eq, kill="K")

    tau_fixed_spr = [i for i in range(6) if tauT[i] == i]
    split_qT = DTOT_CURVE[QTHETA]
    tau_inv_split = frozenset({frozenset(tau_fixed_spr),
                               frozenset(set(range(6)) - set(tau_fixed_spr))})
    check("S3.3 q_Theta's split of the curve totals == the unique "
          "tau-invariant split {3 fixed spreads | 3 cycled spreads}: %s"
          % (sorted(map(sorted, split_qT)),),
          split_qT == tau_inv_split and len(tau_fixed_spr) == 3, kill="K")
    sig_fixed_odds = [i for i in range(6) if sigO[i] == i]
    split_qE = DPTS_CODE[QEVEN]
    sig_inv_split = frozenset({frozenset(sig_fixed_odds),
                               frozenset(set(range(6)) - set(sig_fixed_odds))})
    check("S3.4 q_even*'s split of the code odds == the unique "
          "sigma-invariant split {3 fixed odds | 3 cycled odds}",
          split_qE == sig_inv_split and len(sig_fixed_odds) == 3, kill="K")

    # ======================================================================
    # S4 -- the distinguished spread S*
    # ======================================================================
    section("S4: the distinguished spread S* (fixed by the full <tau, rho> "
            "image)")

    rho_fixed_spr = [i for i in range(6) if rhoT[i] == i]
    S_STAR_SET = [i for i in tau_fixed_spr if i in rho_fixed_spr]
    print("    tau-fixed spreads: %s; rho-fixed spreads: %s; joint: %s"
          % (tau_fixed_spr, rho_fixed_spr, S_STAR_SET))
    sstar_unique = check(
        "S4.1 S* UNIQUE: exactly one curve spread is fixed by BOTH tau and "
        "rho (the full C12 curve-automorphism image mod 2): %s"
        % S_STAR_SET, len(S_STAR_SET) == 1)
    S_STAR = S_STAR_SET[0] if S_STAR_SET else None
    qstar_idx = code.odds.index(QSTAR)

    # ======================================================================
    # S5 -- THE BRIDGE CENSUS
    # ======================================================================
    section("S5: the bridge census over all 720 bijections beta: "
            "Omega_code -> T_curve")

    tauT2 = [tauT[tauT[i]] for i in range(6)]
    B1_tau, B1_tau2 = [], []
    for beta in itertools.permutations(range(6)):
        if all(beta[sigO[i]] == tauT[beta[i]] for i in range(6)):
            B1_tau.append(beta)
        if all(beta[sigO[i]] == tauT2[beta[i]] for i in range(6)):
            B1_tau2.append(beta)
    check("S5.1 B1 census: %d bridges intertwine sigma with tau|T, %d with "
          "tau^2|T -- each family a torsor under C_S6(3-cycle), order 18"
          % (len(B1_tau), len(B1_tau2)),
          len(B1_tau) == 18 and len(B1_tau2) == 18, kill="K")


    def pullback_even(beta):
        """pull q_Theta back through the bridge via the two dictionaries."""
        binv = [0] * 6
        for i in range(6):
            binv[beta[i]] = i
        split_code = frozenset(frozenset(binv[t] for t in blk)
                               for blk in DTOT_CURVE[QTHETA])
        cands = [q for q in code.evens if DPTS_CODE[q] == split_code]
        return cands[0] if len(cands) == 1 else None


    pb_all = {pullback_even(b) for b in B1_tau} | \
             {pullback_even(b) for b in B1_tau2}
    check("S5.2 B2 ARF RESOLUTION: the pullback of q_Theta is CONSTANT over "
          "all 36 B1 bridges and equals q_even* (hence q* = pullback + "
          "hbar(., A): the outer bridge resolves the Arf mismatch by the "
          "canonical anchor shift)", pb_all == {QEVEN}, kill="K")

    FULL_tau = [b for b in B1_tau if S_STAR is not None
                and b[qstar_idx] == S_STAR]
    FULL_tau2 = [b for b in B1_tau2 if S_STAR is not None
                 and b[qstar_idx] == S_STAR]
    # code joint stabilizer (order 6) acting on bridges by precomposition
    stab_code = [g for g in code.sp
                 if all(g[SIG_B[x]] == SIG_B[g[x]] for x in range(16))
                 and all(QSTAR[g[x]] == QSTAR[x] for x in range(16))]
    stab_odd_perms = {tuple(code.odd_perm(g)) for g in stab_code}
    orbit0 = {tuple(b[p[i]] for i in range(6))
              for b in FULL_tau[:1] for p in stab_odd_perms} if FULL_tau else set()
    torsor_ok = (len(FULL_tau) == 6 and len(FULL_tau2) == 6
                 and orbit0 == {tuple(b) for b in FULL_tau})
    check("S5.3 FULL census (B1 + B3: beta(q*) = S*): %d (tau family) + %d "
          "(tau^2 family); the tau family is ONE orbit (torsor) under the "
          "order-%d code joint stabilizer" % (len(FULL_tau), len(FULL_tau2),
                                              len(stab_code)),
          torsor_ok and len(stab_code) == 6, kill="K")

    # tau <-> tau^2 swap realized by an inner code symmetry:
    # g fixes q* and inverts sigma, i.e. g(sigma(x)) = sigma^2(g(x))
    sw = [g for g in code.sp
          if all(QSTAR[g[x]] == QSTAR[x] for x in range(16))
          and all(g[SIG_B[x]] == SIG_B[SIG_B[g[x]]] for x in range(16))]
    sw_moves = False
    if sw and FULL_tau:
        p = tuple(code.odd_perm(sw[0]))
        b0 = FULL_tau[0]
        b_moved = tuple(b0[p[i]] for i in range(6))
        sw_moves = b_moved in {tuple(b) for b in FULL_tau2}
    check("S5.4 the tau/tau^2 families are exchanged by an inner code "
          "symmetry (g fixes q*, inverts sigma): %d such g; the two families"
          " are ONE statement" % len(sw), len(sw) > 0 and sw_moves, kill="K")

    # ======================================================================
    # S6 -- transports under the canonical bridge (structure labels only)
    # ======================================================================
    section("S6: structure transport under the canonical bridge (NO matter "
            "semantics -- ROOTCLASS-MIXED stands)")


    def duality_map(beta):
        """Delta_beta: nonzero vectors of V -> isotropic lines of A[2]."""
        out = {}
        for v in range(1, 16):
            pair = frozenset(i for i, q in enumerate(code.odds) if q[v] == 0)
            i, j = sorted(beta[i] for i in pair)
            (L,) = curve.shared[frozenset({i, j})]
            out[v] = L
        return out


    ok_equiv15 = True
    ok_5bar = True
    ok_orbits = True
    chi_tables = set()
    lsig_lines = set()
    for b in FULL_tau:
        D = duality_map(b)
        # full 15-point twisted equivariance: Delta(sigma v) = tau(Delta v)
        for v in range(1, 16):
            Lt = frozenset(TAU_B[p] for p in D[v])
            if D[SIG_B[v]] != Lt:
                ok_equiv15 = False
        # 5bar -> the 5 lines of S*, 10 -> the complement
        img5 = {tuple(sorted(D[v])) for v in range(1, 16) if QSTAR[v] == 0}
        sstar_lines = {tuple(sorted(L)) for L in curve.spreads[S_STAR]}
        if img5 != sstar_lines:
            ok_5bar = False
        # 3+2 split: sigma orbits on the 5bar words are [3,1,1] and map to
        # tau orbits on the S* lines
        fixed_w = [v for v in range(1, 16) if QSTAR[v] == 0 and SIG_B[v] == v]
        fixed_l = [L for L in curve.spreads[S_STAR]
                   if frozenset(TAU_B[p] for p in L) == L]
        if not (len(fixed_w) == 2 and len(fixed_l) == 2
                and {tuple(sorted(D[v])) for v in fixed_w}
                == {tuple(sorted(L)) for L in fixed_l}):
            ok_orbits = False
        # chi_NSR transport
        chi = tuple(code.tab[v][FSIG_INT] for v in range(16))
        chi_lines = tuple(sorted(tuple(sorted(D[v]))
                                 for v in range(1, 16) if chi[v] == 0))
        chi_tables.add(chi_lines)
        lsig_lines.add(tuple(sorted(D[FSIG_INT])))

    check("S6.1 full twisted equivariance of the induced duality on all 15 "
          "vectors: Delta(sigma v) = tau(Delta v) for every census bridge",
          ok_equiv15, kill="K")
    check("S6.2 5bar/10 TRANSPORT: {q* = 0}\\{0} maps EXACTLY onto the 5 "
          "lines of the distinguished spread S*; the 10 maps onto the 10 "
          "non-S* lines -- the 1+5bar+10 decomposition becomes 'S* lines vs "
          "the rest'", ok_5bar, kill="K")
    check("S6.3 3+2 TRANSPORT: the two sigma-fixed 5bar words (F_Sigma, "
          "F_Sigma+A) map onto the two tau-fixed lines of S*; the cycled 3 "
          "map onto the tau-3-cycle of S* lines ([3,1,1] orbit match)",
          ok_orbits, kill="K")

    # chi_NSR is pinned on the code side by the v752 NS/R LATTICE parity --
    # a datum the bare quadruple (V, hbar, sigma, q*) does not carry: the
    # joint stabilizer swaps F_Sigma <-> F_Sigma + A.  The determinate
    # statement is therefore a TWO-variant torsor:
    chi_geom_all = True
    sfix_lines = [tuple(sorted(L)) for L in curve.spreads[S_STAR]
                  if frozenset(TAU_B[p] for p in L) == frozenset(L)]
    for b in FULL_tau:
        D = duality_map(b)
        LSIG = D[FSIG_INT]
        meets = {tuple(sorted(D[v])) for v in range(1, 16)
                 if D[v] == LSIG or (D[v] & LSIG)}
        chi0 = {tuple(sorted(D[v])) for v in range(1, 16)
                if code.tab[v][FSIG_INT] == 0}
        if meets != chi0:
            chi_geom_all = False
    check("S6.4 chi_NSR TRANSPORT (two-variant torsor): the census produces "
          "exactly %d chi tables and %d candidate lines Delta(F_Sigma) = the"
          " two tau-fixed lines of S* (the code stabilizer swaps F_Sigma <->"
          " F_Sigma + A: chi_NSR is pinned by the v752 NS/R LATTICE parity, "
          "which the bare 2-torsion quadruple does not carry); per variant "
          "the geometric form holds: chi = 0 exactly on the 7 lines meeting "
          "l_Sigma = Delta(F_Sigma)"
          % (len(chi_tables), len(lsig_lines)),
          len(chi_tables) == 2 and len(lsig_lines) == 2
          and set(lsig_lines) == set(sfix_lines) and chi_geom_all, kill="K")
    rho_on_lsig = {tuple(sorted(frozenset(RHO_B[p] for p in set(L))))
                   for L in lsig_lines}
    print("    [reported] rho maps the two candidate l_Sigma lines to: %s "
          "(swaps them: %s -- the two-fold chi ambiguity is intrinsic even "
          "with the full curve C12 data)"
          % (sorted(rho_on_lsig),
             rho_on_lsig == set(lsig_lines)
             and not all(tuple(sorted(frozenset(RHO_B[p] for p in set(L))))
                         == L for L in lsig_lines)))

    # bonus (reported, not frozen): does the bridge relate the code anchor
    # transvection t_A to the curve rotation rho?
    tA_on_T = set()
    for b in FULL_tau:
        p = tuple(b[tAO[i]] for i in range(6))
        # conjugated permutation of T_curve: beta o t_A|Omega o beta^{-1}
        binv = [0] * 6
        for i in range(6):
            binv[b[i]] = i
        conj = tuple(b[tAO[binv[t]]] for t in range(6))
        tA_on_T.add(conj)
    print("    [reported] Psi_beta(t_A) over the census: %d distinct perms "
          "of T_curve; equal to rho|T: %s"
          % (len(tA_on_T), tuple(rhoT) in tA_on_T))

    # ======================================================================
    # S7 -- controls (must fire)
    # ======================================================================
    section("S7: controls")

    n_inner_cross = sum(1 for beta in itertools.permutations(range(6))
                        if all(beta[sigO[i]] == tauO[beta[i]]
                               for i in range(6)))
    check("C1a FIRES: inner (point-to-point) exchange sigma|Omega_code <-> "
          "tau|Omega_curve: census %d == 0 (class mismatch [3,1,1,1] vs "
          "[3,3])" % n_inner_cross, n_inner_cross == 0, kill="K7")

    n_inner_same = sum(1 for beta in itertools.permutations(range(6))
                       if all(beta[sigO[i]] == sigT[beta[i]]
                              for i in range(6)))
    check("C1b FIRES: same-side exchange sigma|Omega_code <-> sigma|T_code: "
          "census %d == 0 (the duad and syntheme actions of the SAME element"
          " are never identified)" % n_inner_same, n_inner_same == 0,
          kill="K7")

    n_odd_pull = sum(1 for b in B1_tau + B1_tau2
                     if pullback_even(b) in code.odds
                     or pullback_even(b) == QSTAR)
    check("C2 FIRES: no B1 bridge pulls q_Theta back to an ODD form (never "
          "to q*): %d == 0 -- a wrong Arf-type target is impossible, the "
          "dictionaries are even-to-even" % n_odd_pull, n_odd_pull == 0,
          kill="K7")

    t0, t1 = tau_fixed_spr[0], tau_fixed_spr[1]
    tau_scr = list(tauT)
    tau_scr[t0], tau_scr[t1] = tau_scr[t1], tau_scr[t0]
    n_scr = sum(1 for beta in itertools.permutations(range(6))
                if all(beta[sigO[i]] == tau_scr[beta[i]] for i in range(6)))
    check("C3 FIRES: scrambled sigma (tau|T composed with a transposition of"
          " two tau-fixed spreads, cycle type %s): B1 census %d == 0"
          % (perm_cycle_type(tau_scr), n_scr), n_scr == 0, kill="K7")

    # ======================================================================
    # S8 -- verdict (frozen rule)
    # ======================================================================
    section("S8: VERDICT (frozen enum: BRIDGE-CANONICAL / "
            "BRIDGE-NONCANONICAL / BRIDGE-DEAD; TEST-VOID on control "
            "failure)")

    n_pass = sum(1 for _, ok in CHECKS if ok)
    n_tot = len(CHECKS)
    controls_ok = all(ok for nm, ok in CHECKS if nm.startswith("C"))
    print("%d/%d checks passed" % (n_pass, n_tot))

    # frozen rule (docstring): CANONICAL iff the B1 census is the C(sigma)
    # torsor, S* is unique, the FULL census is the joint-stabilizer torsor
    # (one orbit incl. the tau/tau^2 swap), the B2 pullback is constant
    # q_even*, and no structural kill fired.
    if not controls_ok:
        verdict = "TEST-VOID"
    elif len(B1_tau) + len(B1_tau2) == 0:
        verdict = "BRIDGE-DEAD"
    elif (sstar_unique and len(B1_tau) == 18 and len(B1_tau2) == 18
          and len(FULL_tau) == 6 and len(FULL_tau2) == 6
          and torsor_ok and sw_moves and pb_all == {QEVEN} and not KILLS):
        verdict = "BRIDGE-CANONICAL"
    else:
        verdict = "BRIDGE-NONCANONICAL"

    print("VERDICT: %s" % verdict)
    if verdict == "BRIDGE-CANONICAL":
        print()
        print("THE CANONICAL OUTER BRIDGE (theorem-candidate statement,")
        print("exploration grade -- promotion is a separate decision):")
        print("  * The Sylvester duality beta: Omega_code -> T_curve with")
        print("    beta sigma = tau beta and beta(q*) = S* (the unique")
        print("    <tau, rho>-fixed spread) exists and is UNIQUE up to the")
        print("    order-6 joint stabilizer (one orbit incl. tau/tau^2).")
        print("  * It resolves the Arf mismatch canonically: q_Theta pulls")
        print("    back to q_even* = q* + hbar(., A) -- the anchor shift.")
        print("  * It transports 1+5bar+10 to {S*} + {5 lines of S*} +")
        print("    {10 other lines}, the 3+2 split to the [3,1,1] tau-orbit")
        print("    structure on S*, and it sends the code anchor")
        print("    transvection t_A to the curve rotation rho = J mod 2")
        print("    (constant over the census).")
        print("  * chi_NSR transports as an exact TWO-variant torsor")
        print("    ('incidence with one of the two tau-fixed lines of S*'):")
        print("    it is pinned on the code side by the v752 NS/R lattice")
        print("    parity, which the bare 2-torsion quadruple lacks.")
        print("  * NO matter semantics claimed (ROOTCLASS-MIXED stands);")
        print("    the inner identification stays CURVE-CODE-PARTIAL/dead.")
    elif verdict == "BRIDGE-NONCANONICAL":
        print("  ambiguity census: S* candidates %s; full census %d + %d"
              % (S_STAR_SET, len(FULL_tau), len(FULL_tau2)))
    print("Runtime: %.1f s" % (time.time() - T0))
    print("ALL CHECKS PASSED" if n_pass == n_tot
          else "CHECKS FAILED: %d" % (n_tot - n_pass))
    return n_pass, n_tot, verdict


def run():
    """run_all entry point (v757 precedent): expected pattern 24/24 with
    verdict BRIDGE-CANONICAL."""
    n_pass, n_tot, v = _probe()
    ok = (n_pass == n_tot == 24 and v == "BRIDGE-CANONICAL")
    print("\n[%s] PATTERN GATE: expected 24/24 with verdict "
          "BRIDGE-CANONICAL; got %d/%d, verdict: %s"
          % ("PASS" if ok else "FAIL", n_pass, n_tot, v))
    print("\nCOMBINED ADJUDICATION: %s -- BRIDGE-CANONICAL: the Sylvester "
          "duality beta: Omega_code -> T_curve with beta sigma = tau beta "
          "and beta(q*) = S* (the unique <tau, rho>-fixed spread) exists "
          "and is unique up to the order-6 joint stabilizer (one orbit "
          "incl. the tau/tau^2 swap); it resolves the v784 Arf mismatch "
          "canonically (q_Theta pulls back to q_even* = q* + hbar(., A) "
          "-- the anchor shift), transports 1+5bar+10 to the S*-line "
          "geometry and t_A to rho = J, and types chi_NSR as an exact "
          "two-variant torsor pinned by the v752 NS/R parity.  The inner "
          "identification stays dead; no matter semantics.  NO RH claim."
          % ("PASS" if ok else "FAIL"))
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(run())

06c40f938d5c69a8349c76fd408c68fdb7a49f263ca6f8a7511fff744b85d6d0

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.