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"""v809 -- CURVE.CODE.DOILY.01: the certified outer bridge sharpened into an incidence-operator statement with a spectral payoff, one probe (21/21 checks incl. the 3 must-fire controls, ~1 s; discovery probe curve_code_doily_probe.py, 2026-08-06, verdict DOILY-EXACT).  THE EXACT IDENTITY: the K6 doily incidence N (15 duads x 15 synthemes on the six odd Arf refinements) satisfies NN^T = 3I + A_KG(6,2) = B + 2I entrywise, with B the certified v752/v774 symplectic incidence (synthemes <-> isotropic lines bijectively; row and column sums 3; two duads share a syntheme iff disjoint, then exactly one).  THE SPECTRAL PAYOFF: spec(NN^T) = spec(N^T N) = {9^1, 4^9, 0^5} exact (annihilating polynomial + traces + rank over Q), so the normalized channel N/3 has singular values {1, 2/3, 0} -- THE RECOVERY BASE RATE 2/3 (v221) as the unique nontrivial singular value of the canonical duad-to-syntheme incidence; the identification with the corpus rate (2/3)^6 = 64/729 is TYPED [H neu -> decidable, not decided here]: it requires the six-step composition semantics (the hexagon).  PETERSEN LOCALIZATION: at the q*-distinguished point the 15 duads split 5 + 10, the 10 internal duads form the Petersen graph, and syntheme -> internal pair is a BIJECTION onto E(Petersen) 15/15 -- Petersen vertices = code duads, Petersen edges = curve synthemes under the certified bridge.  THE REFINED BRIDGE: every census bridge (rebuilt with the frozen BRIDGE-CANONICAL conditions, census 6) factors EXACTLY through N -- Delta(d) = {Gamma(s) : d in s} and the matrix identity N_code = P_Delta^T N_curve^T P_Gamma: the outer bridge conjugates the code incidence to the TRANSPOSE of the curve incidence, a DUALITY, not an isomorphism (control C3: 720 symplectic isomorphisms exist, 0 intertwine sigma with tau -- the inner route stays dead).  THE ARF LAYER in doily coordinates: the switch set T6 = the six within-block duads of the q_Theta point-split, bijective onto the 6 odd theta characteristics -- the census-6 anchor.  N/3 is doubly stochastic (typed CLASSICAL incidence channel, not CPTP; 1 + 9 + 5 spectral decomposition, rate 2/3 on the 9-dim window) -- measured, no descent claim.  No matter semantics (ROOTCLASS-MIXED, v775); the inner identification stays CURVE-CODE-PARTIAL/dead.  No marker move, NO RH claim.  Python-only per GATE.WOLFRAM.02.

PROVENANCE: discovery probe curve_code_doily_probe.py (2026-08-06, 21/21, ~1 s, DOILY-EXACT; no spec corrections disclosed); re-run identically at promotion.  Promoted verbatim, the script-style probe body wrapped in a function scope (v789/v795 precedent); a module-level _LAST verdict capture inserted (v791 precedent); numbers unchanged; run() encodes the pattern (v757 precedent).

Original curve_code_doily_probe.py docstring (verbatim):
curve_code_doily_probe -- CURVE.CODE.DOILY.01: the certified outer
bridge (duad_syntheme_bridge_probe, BRIDGE-CANONICAL, 24/24) sharpened
into an incidence-operator statement with a spectral payoff.

FROZEN CLAIMS:
 1. DOILY INCIDENCE.  On the 6 points (= the six Arf-1 refinements of
    the code side), 15 duads and 15 synthemes with N_{d,s} = [d in s].
    Each duad lies in exactly 3 synthemes; two duads share a syntheme
    iff disjoint (then exactly one).  Hence the EXACT matrix identity
        N N^T = 3I + A_{KG(6,2)} = B + 2I,
    where B = I + A_{KG(6,2)} is the certified v752/v774 symplectic
    incidence (B[x][y] = [hbar(x,y) = 0] under the K6 duad dictionary
    v <-> D(v)); synthemes <-> isotropic lines bijectively.
 2. SPECTRAL PAYOFF.  spec(N N^T) = {9^1, 4^9, 0^5} (from the v774
    charpoly (x-7)(x-2)^9(x+2)^5 of B, shifted by +2); the normalized
    point-to-line channel N/3 has singular values {1, 2/3^(x9), 0^(x5)}
    -- THE RECOVERY BASE RATE 2/3 as the unique nontrivial singular
    value of the canonical duad-to-syntheme incidence.
    TYPED IDENTIFICATION [H neu -> decidable, NOT decided here]: the
    corpus recovery rate is (2/3)^6 = 64/729 (v221 seam recoverability
    code, spectrum {1,(2/3)^6,(1/3)^6} from cusp weights {0,1/3,2/3}
    and the SIX-fold transfer (1-w)^6; v240 OS gap Delta = 6 ln(3/2);
    v425 native flow e^{-Delta} = (2/3)^6).  The doily channel supplies
    the PER-STEP number 2/3 exactly; identification with the corpus
    rate additionally requires the six-step composition semantics (the
    hexagon; conceptually the C6 = distance-2 shell of the parallel
    Petersen probe -- cited as a pointer only, NOTHING here depends on
    its output).  This probe verifies the number and TYPES the gap.
 3. PETERSEN LOCALIZATION.  With the q*-distinguished point the 15
    duads split 5 + 10 (5bar = duads at q* = {q*(v) = 0}\{0}; internal
    10 = {q*(v) = 1} = Petersen vertices, adjacency = disjointness,
    3-regular, 15 edges, girth 5).  Each syntheme contains exactly one
    distinguished-point duad and one disjoint internal pair = a
    Petersen EDGE; syntheme -> internal pair is a BIJECTION onto
    E(Petersen).  Petersen vertices = code duads, Petersen edges =
    (under the bridge) curve synthemes: the incidence object BETWEEN
    the two sides.
 4. REFINED BRIDGE.  For every census bridge beta (rebuilt here with
    the identical frozen conditions: beta sigma = tau beta, beta(q*) =
    S* the unique <tau, rho>-fixed spread; census must again be 6 per
    family), the induced duality has two components Delta (code duads
    -> curve lines) and Gamma (code synthemes -> curve points, the
    unique common point of {Delta(d) : d in s}), and the factorization
        Delta(d) = { Gamma(s) : N[d][s] = 1 }        (exact, all d)
    reproduces the bridge; equivalently the EXACT matrix identity
        N_code = P_Delta^T  N_curve^T  P_Gamma
    -- the outer bridge conjugates the code incidence to the TRANSPOSE
    of the curve incidence (a duality, not an isomorphism).  The Arf
    translation layer re-verified in doily coordinates: the switch set
    T6 = {t != 0 : q_Theta(t) = 1} has |T6| = 6, q_Theta + e2(t, .) is
    odd exactly for t in T6, t -> shifted form is a bijection onto the
    six odd theta characteristics, and T6 = the six WITHIN-BLOCK duads
    of the q_Theta point-split (the two triangles) -- the census-6
    anchor in doily coordinates.
 5. INTERTWINER CANDIDATE (reported, measured -- NO descent claim):
    N/3 is a doubly stochastic (unital, row and column sums 1)
    classical incidence channel; N^T N has the same spectrum
    {9^1, 4^9, 0^5}; both compositions (N N^T)/9 and (N^T N)/9 have
    spectrum {1, (2/3)^2 x9, 0 x5}: a rank-10 channel with a 1-dim
    fixed space (uniform), a 9-dim window contracted by exactly 2/3
    per application, and a 5-dim annihilated complement.  What it
    OFFERS for the prime front: a canonical, basis-free carrier
    intertwiner between the duad register (code side) and the syntheme
    register (= the curve side of the certified outer bridge) whose
    unique nontrivial rate is the recovery base rate.  What it does
    NOT provide (typed): CPTP on a quantum register (it is classical
    stochastic on the 15-dim function space), and the sixth power.

CONTROLS (must fire):
  C1 wrong incidence (one membership bit flipped): row/column sums
     break and N N^T != B + 2I.
  C2 scrambled synthemes (frozen deterministic corruption: in each
     syntheme replace the lex-highest duad by the lex-next duad that
     meets another member): the Petersen edge bijection breaks.
  C3 inner recomposition: census of point-to-point symplectic
     isomorphisms g: V -> A[2] with g sigma = tau g is 0 (the earlier
     inner kill; only the outer/transpose route exists).

VERDICT ENUM (frozen): DOILY-EXACT (all identities exact, spectra
exact, Petersen bijection 15/15, refactorization exact for the full
census, Arf layer verified, controls fire; the 2/3 identification
typed with its exact requirement = six-step composition) /
DOILY-PARTIAL (incidence core holds, a named layer fails) /
DOILY-DEAD (the core identity N N^T = B + 2I fails).  TEST-VOID on
control failure.

FENCES: finite exact algebra (integers/Fractions; no floats in any
load-bearing check); the curve side is the certified exact model of
curve_code_2torsion_probe (periods certified there at dps 120); NO
matter semantics (ROOTCLASS-MIXED, v775, stands); the inner
identification stays dead (CURVE-CODE-PARTIAL); nothing here modifies
the corpus recovery modules v221/v240/v425 -- claim 2 is a typed
cross-reference, not a re-derivation.  EXPLORATION ONLY: one new file
in experiments/tfpt-discovery/, report only, no promotion.

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

_LAST = {}


import itertools
import time
from fractions import Fraction

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)


# ======================================================================
# frozen machinery (identical to duad_syntheme_bridge_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


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 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):
        self.name = name
        self.tab = build_tables(gram)
        self.refs = all_refinements(self.tab)
        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 zeros[q] == 6)
        self.evens = sorted(q for q in self.refs if zeros[q] == 10)
        self.lines = iso_lines(self.tab)
        self.spreads = spreads_of(self.lines)
        self.duad_of = {}      # vector -> frozenset of 2 odd indices
        self.duad_vec = {}     # frozenset of 2 odd indices -> vector
        for v in range(1, 16):
            dv = frozenset(i for i, q in enumerate(self.odds) if q[v] == 0)
            assert len(dv) == 2
            self.duad_of[v] = dv
            self.duad_vec[dv] = v
        self.shared = {}
        for i in range(6):
            for j in range(i + 1, 6):
                inter = self.spreads[i] & self.spreads[j]
                assert len(inter) == 1
                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):
        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 mat_mul(A, Bm):
    n, m, p = len(A), len(Bm), len(Bm[0])
    out = [[0] * p for _ in range(n)]
    for i in range(n):
        Ai = A[i]
        for k in range(m):
            a = Ai[k]
            if a:
                Bk = Bm[k]
                Oi = out[i]
                for j in range(p):
                    Oi[j] += a * Bk[j]
    return out


def mat_rank_q(M):
    A = [[Fraction(x) for x in row] for row in M]
    n, m = len(A), len(A[0])
    rank, row = 0, 0
    for col in range(m):
        piv = None
        for r in range(row, n):
            if A[r][col] != 0:
                piv = r
                break
        if piv is None:
            continue
        A[row], A[piv] = A[piv], A[row]
        pv = A[row][col]
        A[row] = [x / pv for x in A[row]]
        for r in range(n):
            if r != row and A[r][col] != 0:
                f = A[r][col]
                A[r] = [x - f * y for x, y in zip(A[r], A[row])]
        row += 1
        rank += 1
        if row == n:
            break
    return rank


def spectrum_945(M, label):
    """certify spec(M) = {9^1, 4^9, 0^5} exactly (integer arithmetic)."""
    n = len(M)
    I = [[int(i == j) for j in range(n)] for i in range(n)]
    M4 = [[M[i][j] - 4 * I[i][j] for j in range(n)] for i in range(n)]
    M9 = [[M[i][j] - 9 * I[i][j] for j in range(n)] for i in range(n)]
    annih = mat_mul(mat_mul(M, M4), M9)
    ann_ok = all(x == 0 for row in annih for x in row)
    tr1 = sum(M[i][i] for i in range(n))
    M2 = mat_mul(M, M)
    tr2 = sum(M2[i][i] for i in range(n))
    rk = mat_rank_q(M)
    # eigenvalues in {0,4,9}; m9*9 + m4*4 = tr1, m9*81 + m4*16 = tr2,
    # m9 + m4 = rank -> unique solution (1, 9, 5)
    ok = (ann_ok and tr1 == 45 and tr2 == 225 and rk == 10)
    print("    %s: annihilator M(M-4)(M-9)=0: %s; tr=%d tr2=%d rank=%d"
          % (label, ann_ok, tr1, tr2, rk))
    return ok


# ======================================================================
# S1 -- the doily incidence N and the exact identity NN^T = B + 2I
# ======================================================================


def main():
    """Probe body, promoted verbatim in a function scope (v789/v795 precedent; the probe is script-style)."""
    section("S1: doily incidence N (15 duads x 15 synthemes) and the exact "
            "identity NN^T = 3I + A_KG = B + 2I (v752/v774 object)")

    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)

    DUADS = sorted(map(sorted, itertools.combinations(range(6), 2)))
    DUADS = [frozenset(d) for d in DUADS]
    SYNTHEMES = []
    for m in itertools.combinations(DUADS, 3):
        if len(m[0] | m[1] | m[2]) == 6:
            SYNTHEMES.append(frozenset(m))
    SYNTHEMES.sort(key=lambda s: sorted(map(sorted, s)))
    check("S1.1 K6 census: 15 duads, %d synthemes (perfect matchings)"
          % len(SYNTHEMES), len(SYNTHEMES) == 15, kill="K")

    # syntheme <-> isotropic line dictionary
    syn_line = {}
    for s in SYNTHEMES:
        trip = frozenset(code.duad_vec[d] for d in s)
        match = [L for L in code.lines if frozenset(L) == trip]
        syn_line[s] = match[0] if len(match) == 1 else None
    check("S1.2 synthemes <-> isotropic lines BIJECTIVE via the duad "
          "dictionary v <-> D(v): every matching is an isotropic line and "
          "all 15 lines are hit",
          all(v is not None for v in syn_line.values())
          and len(set(map(frozenset, syn_line.values()))) == 15, kill="K")

    N = [[1 if DUADS[i] in SYNTHEMES[j] else 0 for j in range(15)]
         for i in range(15)]
    rows3 = all(sum(N[i]) == 3 for i in range(15))
    cols3 = all(sum(N[i][j] for i in range(15)) == 3 for j in range(15))
    check("S1.3 each duad lies in exactly 3 synthemes and each syntheme "
          "contains exactly 3 duads (row and column sums 3)",
          rows3 and cols3, kill="K")

    NNt = mat_mul(N, [list(r) for r in zip(*N)])
    share_ok = True
    for i in range(15):
        for j in range(15):
            dis = (i != j and not (DUADS[i] & DUADS[j]))
            want = 3 if i == j else (1 if dis else 0)
            if NNt[i][j] != want:
                share_ok = False
    check("S1.4 two duads share a syntheme iff DISJOINT, then exactly one: "
          "NN^T = 3I + A_KG(6,2) entrywise", share_ok, kill="K")

    Bmat = [[1 if code.tab[code.duad_vec[DUADS[i]]][code.duad_vec[DUADS[j]]]
             == 0 else 0 for j in range(15)] for i in range(15)]
    b_id = all(NNt[i][j] == Bmat[i][j] + 2 * (i == j)
               for i in range(15) for j in range(15))
    kg_id = all(Bmat[i][j] == (1 if (i == j or not (DUADS[i] & DUADS[j]))
                               else 0) for i in range(15) for j in range(15))
    check("S1.5 EXACT MATRIX IDENTITY: NN^T == B + 2I where B[x][y] = "
          "[hbar(x,y) = 0] is the certified v752/v774 symplectic incidence, "
          "and B == I + A_KG entrywise (re-verified)", b_id and kg_id,
          kill="K")

    # ======================================================================
    # S2 -- spectra and the 2/3 payoff (typed identification)
    # ======================================================================
    section("S2: spectra -- spec(NN^T) = {9,4^9,0^5}, singular values of "
            "N/3 = {1, 2/3, 0}; the corpus (2/3)^6 cross-check TYPED")

    Nt = [list(r) for r in zip(*N)]
    NtN = mat_mul(Nt, N)
    ok_a = spectrum_945(NNt, "NN^T (duad side)")
    ok_b = spectrum_945(NtN, "N^T N (syntheme side)")
    check("S2.1 spec(NN^T) = spec(N^T N) = {9^1, 4^9, 0^5} EXACT "
          "(annihilating polynomial + traces + rank over Q; consistent with "
          "v774 charpoly of B = (x-7)(x-2)^9(x+2)^5 shifted by +2)",
          ok_a and ok_b, kill="K")
    sv2 = sorted({Fraction(e, 9) for e in (9, 4, 0)}, reverse=True)
    check("S2.2 singular values of the normalized channel N/3: squared "
          "values {1, 4/9, 0} -> {1, 2/3, 0}: THE RECOVERY BASE RATE 2/3 is "
          "the unique nontrivial singular value of the duad-to-syntheme "
          "incidence", sv2 == [Fraction(1), Fraction(4, 9), Fraction(0)],
          kill="K")
    rate6 = Fraction(2, 3) ** 6
    check("S2.3 corpus cross-check EXACT AT NUMBER LEVEL: (2/3)^6 = %s = "
          "64/729 = the v221 seam recovery rate ((1-w)^6 at cusp weight "
          "w = 1/3; v240 OS gap Delta = 6 ln(3/2); v425 native flow)"
          % rate6, rate6 == Fraction(64, 729), kill="K")
    print("    TYPED [H neu -> decidable, NOT decided here]: the doily")
    print("    channel supplies the PER-STEP 2/3; identification with the")
    print("    corpus rate requires the SIX-step composition semantics")
    print("    (the hexagon / C6 = distance-2 shell of the parallel")
    print("    Petersen probe -- conceptual pointer only, no dependence).")

    # ======================================================================
    # S3 -- Petersen localization at q*
    # ======================================================================
    section("S3: Petersen localization at the q*-distinguished point")

    QSTAR = [q for q in code.odds
             if all(q[SIG_B[x]] == q[x] for x in range(16))
             and q[0b1000] == 1 and q[0b0111] == 0]
    assert len(QSTAR) == 1
    QSTAR = QSTAR[0]
    qs_idx = code.odds.index(QSTAR)
    at_q = [i for i, d in enumerate(DUADS) if qs_idx in d]
    internal = [i for i, d in enumerate(DUADS) if qs_idx not in d]
    split_ok = (len(at_q) == 5 and len(internal) == 10
                and all(QSTAR[code.duad_vec[DUADS[i]]] == 0 for i in at_q)
                and all(QSTAR[code.duad_vec[DUADS[i]]] == 1
                        for i in internal))
    check("S3.1 duad split 5 + 10 at q*: the 5 duads at q* = the 5bar words "
          "{q* = 0}\\{0}; the 10 internal duads = the 10 words {q* = 1}",
          split_ok, kill="K")

    pet_adj = {i: set() for i in internal}
    for i in internal:
        for j in internal:
            if i != j and not (DUADS[i] & DUADS[j]):
                pet_adj[i].add(j)
    n_edges = sum(len(v) for v in pet_adj.values()) // 2


    def girth(adj):
        best = None
        for s in adj:
            dist, par = {s: 0}, {s: None}
            queue = [s]
            while queue:
                u = queue.pop(0)
                for w in adj[u]:
                    if w not in dist:
                        dist[w] = dist[u] + 1
                        par[w] = u
                        queue.append(w)
                    elif par[u] != w:
                        c = dist[u] + dist[w] + 1
                        if best is None or c < best:
                            best = c
        return best


    check("S3.2 internal graph (adjacency = disjointness) IS Petersen: 10 "
          "vertices, 3-regular, %d edges, girth %d (3-regular girth-5 on 10 "
          "vertices is Petersen, Moore uniqueness)"
          % (n_edges, girth(pet_adj)),
          all(len(v) == 3 for v in pet_adj.values()) and n_edges == 15
          and girth(pet_adj) == 5, kill="K")

    syn_edge = {}
    pet_ok = True
    for j, s in enumerate(SYNTHEMES):
        dq = [d for d in s if qs_idx in d]
        di = [d for d in s if qs_idx not in d]
        if not (len(dq) == 1 and len(di) == 2 and not (di[0] & di[1])):
            pet_ok = False
            continue
        syn_edge[j] = frozenset({DUADS.index(di[0]), DUADS.index(di[1])})
    edges = {frozenset({i, j}) for i in pet_adj for j in pet_adj[i]}
    bij_ok = (len(syn_edge) == 15
              and set(syn_edge.values()) == edges
              and len(set(syn_edge.values())) == 15)
    check("S3.3 PETERSEN EDGE BIJECTION: every syntheme = one q*-duad + one "
          "disjoint internal pair; syntheme -> internal pair is a bijection "
          "onto the 15 Petersen edges (census %d/15 valid, %d/15 distinct)"
          % (len(syn_edge), len(set(syn_edge.values()))),
          pet_ok and bij_ok, kill="K")

    # ======================================================================
    # S4 -- the refined bridge: factorization through N
    # ======================================================================
    section("S4: refined bridge -- the census bridges factor through N "
            "(N_code = P_Delta^T N_curve^T P_Gamma)")

    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))
    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)

    code.sp = linear_transporters(code.tab, code.tab)
    sigO = code.odd_perm(SIG_B)
    tauT = curve.spread_perm(TAU_B)
    rhoT = curve.spread_perm(RHO_B)
    S_STAR_SET = [i for i in range(6) if tauT[i] == i and rhoT[i] == i]
    assert len(S_STAR_SET) == 1
    S_STAR = S_STAR_SET[0]
    FULL_tau = [beta for beta in itertools.permutations(range(6))
                if all(beta[sigO[i]] == tauT[beta[i]] for i in range(6))
                and beta[qs_idx] == S_STAR]
    check("S4.1 census bridges rebuilt with the identical frozen "
          "conditions: %d (must be 6, the BRIDGE-CANONICAL torsor)"
          % len(FULL_tau), len(FULL_tau) == 6, kill="K")

    N_curve = [[1 if p in L else 0 for L in curve.lines]
               for p in range(1, 16)]     # 15 points x 15 lines
    fact_ok = True
    matid_ok = True
    petersen_bridge_ok = True
    for beta in FULL_tau:
        Delta = {}
        for v in range(1, 16):
            i, j = sorted(beta[i] for i in code.duad_of[v])
            (L,) = curve.shared[frozenset({i, j})]
            Delta[v] = L
        Gamma = {}
        for s_idx, s in enumerate(SYNTHEMES):
            pts = None
            for d in s:
                P = set(Delta[code.duad_vec[d]])
                pts = P if pts is None else (pts & P)
            if pts is None or len(pts) != 1:
                fact_ok = False
                continue
            Gamma[s_idx] = pts.pop()
        # factorization Delta(d) = {Gamma(s) : d in s}
        for i, d in enumerate(DUADS):
            v = code.duad_vec[d]
            img = {Gamma[j] for j in range(15) if N[i][j] == 1}
            if img != set(Delta[v]):
                fact_ok = False
        # matrix identity N_code[d][s] == N_curve[Gamma(s)][Delta(d)]
        for i, d in enumerate(DUADS):
            v = code.duad_vec[d]
            Lidx = curve.lines.index(Delta[v])
            for j in range(15):
                if N[i][j] != N_curve[Gamma[j] - 1][Lidx]:
                    matid_ok = False
        # Petersen blocks under the bridge: 5bar duads -> lines of S*,
        # internal (Petersen vertex) duads -> the 10 non-S* lines
        img5 = {Delta[code.duad_vec[DUADS[i]]] for i in at_q}
        img10 = {Delta[code.duad_vec[DUADS[i]]] for i in internal}
        if img5 != set(curve.spreads[S_STAR]) or \
           img10 != set(curve.lines) - set(curve.spreads[S_STAR]):
            petersen_bridge_ok = False

    check("S4.2 FACTORIZATION exact for all 6 census bridges: Gamma(s) = "
          "the unique common curve point of {Delta(d) : d in s}, and "
          "Delta(d) = {Gamma(s) : N[d][s] = 1} for every duad -- the bridge "
          "IS 'apply N, then the outer duality on synthemes'", fact_ok,
          kill="K")
    check("S4.3 EXACT MATRIX IDENTITY for all 6 census bridges: N_code = "
          "P_Delta^T N_curve^T P_Gamma -- the outer bridge conjugates the "
          "code incidence to the TRANSPOSE of the curve incidence (a "
          "duality, not an isomorphism)", matid_ok, kill="K")
    check("S4.4 Petersen blocks transport: the 5 duads at q* -> the 5 lines "
          "of S*, the 10 Petersen vertices -> the 10 non-S* lines (all "
          "census bridges) -- Petersen vertices = code duads, Petersen "
          "edges = curve synthemes", petersen_bridge_ok, kill="K")

    # Arf translation layer in doily coordinates (curve side)
    QTHETA = [q for q in curve.refs
              if all(q[TAU_B[x]] == q[x] for x in range(16))]
    assert len(QTHETA) == 1
    QTHETA = QTHETA[0]
    T6 = [t for t in range(1, 16) if QTHETA[t] == 1]
    shift_odds = {}
    arf_layer_ok = len(T6) == 6
    for t in range(1, 16):
        qt = tuple((QTHETA[x] + curve.tab[t][x]) % 2 for x in range(16))
        is_odd = qt in curve.odds
        if t in T6:
            if not is_odd:
                arf_layer_ok = False
            shift_odds[t] = qt
        else:
            if is_odd:
                arf_layer_ok = False
    arf_layer_ok = arf_layer_ok and sorted(shift_odds.values()) == curve.odds
    split_qT = curve.split_pts(QTHETA)
    within = set()
    for blk in split_qT:
        for pair in itertools.combinations(sorted(blk), 2):
            within.add(curve.duad_vec[frozenset(pair)])
    check("S4.5 ARF TRANSLATION LAYER in doily coordinates: |T6| = %d "
          "switch points {q_Theta = 1}; q_Theta + e2(t, .) is odd EXACTLY "
          "for t in T6 and t -> shifted form is a bijection onto the 6 odd "
          "theta characteristics; T6 == the 6 WITHIN-BLOCK duads of the "
          "q_Theta point-split (the two triangles) -- the census-6 anchor"
          % len(T6), arf_layer_ok and within == set(T6), kill="K")

    # ======================================================================
    # S5 -- the intertwiner candidate (reported, measured)
    # ======================================================================
    section("S5: the intertwiner candidate N/3 (reported, measured -- no "
            "descent claim)")

    ds_ok = (all(sum(Fraction(x, 3) for x in N[i]) == 1 for i in range(15))
             and all(sum(Fraction(N[i][j], 3) for i in range(15)) == 1
                     for j in range(15)))
    check("S5.1 N/3 is DOUBLY STOCHASTIC (unital classical channel on the "
          "15-dim function space): all row and column sums exactly 1",
          ds_ok, kill="K")
    check("S5.2 both compositions have spectrum {1, (2/3)^2 x9, 0 x5}: "
          "1-dim fixed space (uniform), 9-dim window contracted by exactly "
          "2/3 per application, 5-dim annihilated complement (rank 10)",
          ok_a and ok_b, kill="K")
    print("    OFFERED for the prime front (measured): a canonical,")
    print("    basis-free carrier intertwiner between the duad register")
    print("    (code side) and the syntheme register (= the curve side of")
    print("    the certified outer bridge), unique nontrivial rate = the")
    print("    recovery base rate 2/3 on the 9-dim window.")
    print("    NOT PROVIDED (typed): CPTP on a quantum register (this is")
    print("    classical stochastic incidence), and the sixth power --")
    print("    the six-step composition is the open identification of S2.")

    # ======================================================================
    # S6 -- controls
    # ======================================================================
    section("S6: controls")

    N_bad = [row[:] for row in N]
    N_bad[0][0] ^= 1
    NNt_bad = mat_mul(N_bad, [list(r) for r in zip(*N_bad)])
    c1 = (sum(N_bad[0]) != 3 or sum(N_bad[i][0] for i in range(15)) != 3) \
        and any(NNt_bad[i][j] != Bmat[i][j] + 2 * (i == j)
                for i in range(15) for j in range(15))
    check("C1 FIRES: one flipped membership bit breaks the count-3 "
          "structure AND NN^T != B + 2I", c1, kill="K7")

    scr_ok_cols = 0
    for s in SYNTHEMES:
        ds = sorted(map(sorted, s))
        keep = [frozenset(d) for d in ds[:2]]
        top = frozenset(ds[2])
        repl = None
        for d in DUADS:
            if d != top and d not in keep and (d & keep[0]):
                repl = d
                break
        scr = keep + [repl]
        dq = [d for d in scr if qs_idx in d]
        di = [d for d in scr if qs_idx not in d]
        if len(dq) == 1 and len(di) == 2 and not (di[0] & di[1]):
            scr_ok_cols += 1
    check("C2 FIRES: scrambled synthemes (lex-highest duad replaced by a "
          "MEETING duad, frozen rule): only %d/15 corrupted synthemes still "
          "satisfy the Petersen-edge property (bijection broken)"
          % scr_ok_cols, scr_ok_cols < 15, kill="K7")

    inner = linear_transporters(code.tab, curve.tab)
    n_inner_eq = sum(1 for g in inner
                     if all(g[SIG_B[x]] == TAU_B[g[x]] for x in range(16)))
    check("C3 FIRES: inner recomposition -- %d symplectic isomorphisms "
          "V -> A[2] exist but %d intertwine sigma with tau (the inner "
          "route stays DEAD; only the outer/transpose factorization exists)"
          % (len(inner), n_inner_eq),
          len(inner) == 720 and n_inner_eq == 0, kill="K7")

    # ======================================================================
    # S7 -- verdict (frozen rule)
    # ======================================================================
    section("S7: VERDICT (frozen enum: DOILY-EXACT / DOILY-PARTIAL / "
            "DOILY-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"))
    core_ok = all(ok for nm, ok in CHECKS if nm.startswith("S1"))
    print("%d/%d checks passed" % (n_pass, n_tot))

    if not controls_ok:
        verdict = "TEST-VOID"
    elif not core_ok:
        verdict = "DOILY-DEAD"
    elif n_pass == n_tot:
        verdict = "DOILY-EXACT"
    else:
        verdict = "DOILY-PARTIAL"

    _LAST["verdict"] = verdict
    print("VERDICT: %s" % verdict)
    if verdict == "DOILY-EXACT":
        print()
        print("RECOMMENDED CONTRACT TEXT (exploration grade -- promotion is")
        print("a separate decision):")
        print("  * The K6 doily incidence N (15 duads x 15 synthemes) on the")
        print("    six odd refinements satisfies NN^T = B + 2I exactly, with")
        print("    B the certified v752/v774 symplectic incidence; spec =")
        print("    {9, 4^9, 0^5} and the normalized channel N/3 has singular")
        print("    values {1, 2/3, 0}: the recovery base rate 2/3 (v221) is")
        print("    the unique nontrivial singular value of the canonical")
        print("    duad-to-syntheme map.  Identification with the corpus")
        print("    rate (2/3)^6 requires the six-step composition semantics")
        print("    [H neu -> decidable, typed, not decided here].")
        print("  * At the q*-point the 10 internal duads form the Petersen")
        print("    graph and syntheme -> internal pair is a bijection onto")
        print("    E(Petersen): Petersen vertices = code duads, Petersen")
        print("    edges = curve synthemes under the certified bridge.")
        print("  * Every census bridge factors EXACTLY through N:")
        print("    Delta(d) = {Gamma(s) : d in s} and N_code = P_Delta^T")
        print("    N_curve^T P_Gamma -- the outer bridge is transpose-")
        print("    conjugation of the incidence channel; the Arf layer is")
        print("    the 6-point switch set T6 = within-block duads of the")
        print("    q_Theta split.")
        print("  * N/3 is a doubly stochastic carrier intertwiner (1 + 9 +")
        print("    5 spectral decomposition, rate 2/3 on the window) --")
        print("    measured; no CPTP/quantum or descent claim.")
        print("  * NO matter semantics (ROOTCLASS-MIXED, v775, stands); the")
        print("    inner identification stays CURVE-CODE-PARTIAL/dead.")
    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 0 if n_pass == n_tot else 1


def run():
    """run_all entry point (v757 precedent): expected pattern 21/21 with
    verdict DOILY-EXACT."""
    rc = main()
    n_pass = sum(1 for _n, ok in CHECKS if ok)
    fails = [n for n, ok in CHECKS if not ok]
    v = _LAST.get("verdict", "")
    ok = (rc == 0 and n_pass == len(CHECKS) == 21 and not fails
          and v == "DOILY-EXACT")
    print("\n[%s] PATTERN GATE: expected 21/21 with verdict "
          "DOILY-EXACT; got %d/%d, fails: %s, verdict: %s"
          % ("PASS" if ok else "FAIL", n_pass, len(CHECKS),
             fails or "none", v))
    print("\nCOMBINED ADJUDICATION: %s -- DOILY-EXACT: NN^T = B + 2I "
          "entrywise with spec {9, 4^9, 0^5}, so the recovery base "
          "rate 2/3 is the unique nontrivial singular value of the "
          "canonical duad-to-syntheme channel N/3 (the (2/3)^6 "
          "identification typed, pending the six-step composition); "
          "Petersen edges = synthemes 15/15 at the q*-point; every "
          "census bridge factors exactly as N_code = P_Delta^T "
          "N_curve^T P_Gamma -- a duality, not an isomorphism (the "
          "inner route stays dead, 0/720); the Arf switch set T6 = the "
          "six within-block duads; N/3 doubly stochastic, typed "
          "classical, not CPTP.  NO RH claim."
          % ("PASS" if ok else "FAIL"))
    return 0 if ok else 1


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

55e1651ed2411079e058a2585e7f1d5b9c36ee7fe6eebf7f113f359716fe1540

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.