Follow the source behind the result.

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

"""v568 -- DIAMOND.BIT.SELECT.01: the residual reconstruction bit located,
separated, and given a canonical exact witness -- the ladder self-consistency
selects the compiler Q uniquely on the carrier-free class.

PROVENANCE.  Priorities 2+3 of the self-code review, fused with the v567
residual bit: the No-Carrier-Reconstruction audit left EXACTLY one binary
freedom -- the 81-pinned class is {Q (q32 = 2 = |Z2|), Q_alt (q32 = 0)},
with every classical carrier-free certificate coinciding on the pair.
Audited and decided by the discovery probe (bit_selector_probe.py, 10/10,
verdict SELECTOR-FOUND); this module is the load-bearing version.

[E] 1. THE BIT IS INTEGRALLY VISIBLE: the two 81-twins generate DIFFERENT
    integral orders (Hermite bases differ; equal index 81, equal Smith
    divisors (1,1,1,3,3,3,3), different sublattices of the parabolic
    lattice) -- the bit is real integral structure even where every
    classical invariant coincides.
[E] 2. THE SELECTOR (the central result): for the whole reconstruction
    family the dominant mode of the sheet direction satisfies
    V_c (1, 2, 2c)^T = 2 (1, 2, 2c)^T identically in the coupling c --
    and demanding THE LADDER SELF-CONSISTENCY, that the dominant mode
    reproduce its own eigenvalue as the geometric ladder
    v = (lam^0, lam^1, lam^2) = (1, 2, 4), forces 2c = 4, c = 2:
    on ALL 28 members of the v567 parabolic carrier-free class EXACTLY
    ONE satisfies it -- the compiler Q.  The selection needs no 81-pin
    and no column budget: it alone pins Q within the class.
[C] 3. THE WITNESS IS PRIOR STRUCTURE, NOT A FOUND NUMBER (no-free-pattern
    discipline): the selected ladder (1,2,4) = (2^0, 2^1, 2^2) is the
    binary AnchorLadder step sequence p_{n+1} - p_n = 2^n (Lean-
    formalised) with 2 = |Z2| the sheet datum, and the trace code
    p_n(a) = 1 + tr(V^n) = 2 + 2^n (v566) rides the SAME ladder --
    consistency re-verified exactly for n = 1..6.
[E] 4. THE SPLIT GEOMETRY LOCATED AND EXCLUDED: an invariant module
    complement of the seam line exists IFF q32 = 1 (U-invariance forces
    a + b = 1, V-invariance forces a = 0 and a + b = q32; the plane
    span((1,0,0),(0,1,1)) is exactly invariant there) -- and that member's
    direction algebra COLLAPSES to dimension 5 (Smith (1,1,1,3,3), no
    full parabolic, no 81): the seam-line + saturation demands admit
    ONLY nonsplit geometry.  Consequence for the v566 A2 carrier: the
    Ext arrow is NONZERO on the whole reconstruction class -- the split
    class of the two-element module classification is structurally
    unreachable, and the residual bit (q32 in {0,2}) lives INSIDE the
    nonsplit side: it toggles WHICH nonsplit integral order is realised
    and whether the dominant mode carries the full binary ladder, not
    split-vs-nonsplit.
[E] 5. PRIORITY-2 CANDIDATE TESTS (mark-local structure of the 81, both
    reported honestly): (i) the mu4-grading candidate deg(E_jk) =
    g_k - g_j mod 4 (g = the A3 exponent grading) FAILS -- the order is
    not a graded sublattice (5 of 7 Hermite vectors homogeneous), so the
    grading does not descend to the cokernel; the review's kill condition
    does NOT fire (other mechanisms remain) and the 81 stays a
    FINGERPRINT pending a mechanism; (ii) left multiplication by V
    PRESERVES the order lattice, so it induces a canonical F3-linear
    action on the cokernel (Z/3)^4 -- the mark-local question is
    sharpened to a concrete module computation (the F3[V]-character
    structure vs the four marks), named open.

NAMED LIMITS AS LOAD-BEARING CONTENT (the claim INCLUDES them):
  (i)   THE PHYSICAL SELECTION IS NOT DERIVED: why the dominant mode
        should satisfy the ladder self-consistency is the relocated open
        question -- the same slot as the RP-selection of the alignment
        bit (v528/v534); this module LOCATES the bit and equips it with a
        canonical exact witness, nothing more.
  (ii)  The resonance between this reconstruction bit and the alignment
        bit remains a TYPED OBSERVATION (two binary choices in the same
        structural slot), not an identification.
  (iii) Stage B of v567 (deriving the geometric inputs from mu4/D4/H^1
        parabolic geometry, GATE.QGEO.01) is untouched; NO P2 reduction;
        AX.P2.01 / ANCHOR.GEN.01 markers untouched.
HONEST FENCES: 'derived' appears nowhere for any physics statement; the
selector is typed [C] as candidate canonical selection with its
justification open; Smith 1861 / Hermite 1851 (normal forms), Gabriel
1972 (quivers), Perron-Frobenius (dominant modes) named CLASSICAL as
addresses.  Status: [E] exact integer/symbolic algebra + [C] the anchored
selector typing; Python-only, counted per GATE.WOLFRAM.02.  Discovery:
  experiments/tfpt-discovery/bit_selector_probe.py (2026-07-31, 10/10,
  SELECTOR-FOUND)
"""
from itertools import product

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

from tfpt_constants import check, summary, reset

I3 = sp.eye(3)
SIG = sp.diag(1, -1, -1)
N_FAM = 3
IDX7 = ((0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2))


def Qc(c):
    return sp.Matrix([[3, 1, 0], [3, 2, 0], [3, c, 1]])


def UV(Q):
    return Q * sp.diag(1, 0, 0), Q * sp.diag(0, 1, 1)


def words_up_to(U, V, maxlen=5):
    words = [I3]
    frontier = [I3]
    for _ in range(maxlen):
        frontier = [w * G for w in frontier for G in (U, V)]
        words += frontier
    return words


def order_coords(Q):
    U, V = UV(Q)
    return sp.Matrix([[w[i, j] for (i, j) in IDX7]
                      for w in words_up_to(U, V)])


def snf_divs(M):
    s_ = nf.smith_normal_form(M.T)
    return [abs(s_[i, i]) for i in range(min(s_.shape)) if s_[i, i] != 0]


def sem_int(q11, q12, q13, q21, q22, q23, q31, q32, q33):
    if q11 not in (1, 2, 3):
        return False
    rest = {1, 2, 3} - {q11}
    lo, hi = min(rest), max(rest)
    if q22 + q33 != lo + hi or q22 * q33 - q23 * q32 != lo * hi:
        return False
    if (q12, q13, q21, q31) == (0, 0, 0, 0):
        return False
    if q12 * q21 + q13 * q31 != 3:
        return False
    return True


def stab_line_exists(U, V):
    for M in (V, U):
        for ev, mult, vecs in M.eigenvects():
            for v in vecs:
                v = sp.Matrix(v)
                ok = True
                for w in (U * v, V * v):
                    if sp.Matrix.hstack(v, w).rank() > 1:
                        ok = False
                        break
                if ok:
                    return True
    return False


def dom_ladder_test(V):
    ev = V.eigenvals()
    evs = sorted(ev.keys(), key=lambda e: abs(sp.re(sp.N(e))))
    dom = evs[-1]
    if ev[dom] != 1 or not dom.is_integer:
        return False
    for e_, m_, vecs in V.eigenvects():
        if e_ == dom:
            v = sp.Matrix(vecs[0])
            d = sp.lcm([sp.denom(x_) for x_ in v])
            v = sp.expand(v * d)
            g = sp.gcd(list(v))
            v = sp.Matrix([sp.cancel(x_ / g) for x_ in v])
            if v[0] < 0:
                v = -v
            return list(v) == [dom**0, dom**1, dom**2]
    return False


def run():
    reset()
    print("=" * 72)
    print("v568  DIAMOND.BIT.SELECT.01 -- the reconstruction bit located "
          "and given its canonical witness")
    print("=" * 72)

    # ---------------------------------------------------------------- S1
    print("\nS1 -- the twins are integrally distinct")
    H0 = hermite_normal_form(order_coords(Qc(0)).T)
    H2 = hermite_normal_form(order_coords(Qc(2)).T)
    check("S1.LATTICE [E] the two 81-twins generate DIFFERENT integral "
          "orders (Hermite bases differ) with EQUAL index 81 and equal "
          "Smith divisors (1,1,1,3,3,3,3) -- the bit is integrally "
          "visible where every classical invariant coincides",
          H0 != H2
          and snf_divs(order_coords(Qc(0)))
          == snf_divs(order_coords(Qc(2))) == [1, 1, 1, 3, 3, 3, 3])

    # ---------------------------------------------------------------- S2
    print("\nS2 -- the ladder self-consistency selector")
    c = sp.symbols('c', nonnegative=True)
    Vc = sp.Matrix([[0, 1, 0], [0, 2, 0], [0, c, 1]])
    vdom = sp.Matrix([1, 2, 2 * c])
    check("S2.MODE [E] V_c (1, 2, 2c)^T = 2 (1, 2, 2c)^T identically in "
          "the coupling c: the dominant mode of the sheet direction is "
          "v(c) = (1, 2, 2c) across the whole reconstruction family",
          sp.simplify(Vc * vdom - 2 * vdom) == sp.zeros(3, 1))
    check("S2.SELECT [E] the LADDER SELF-CONSISTENCY -- the dominant mode "
          "reproduces its own eigenvalue as the geometric ladder "
          "(2^0, 2^1, 2^2) = (1,2,4) -- holds iff 2c = 4 iff c = 2: "
          "uniquely the compiler Q; the twin truncates to (1,2,0)",
          sp.solve(sp.Eq(2 * c, 4), c) == [2]
          and vdom.subs(c, 2) == sp.Matrix([1, 2, 4])
          and vdom.subs(c, 0) != sp.Matrix([1, 2, 4]))
    # uniqueness on the whole v567 class
    family = []
    for q12, q13, q22, q23, q32, q33 in product(range(7), repeat=6):
        if not sem_int(3, q12, q13, 3, q22, q23, 3, q32, q33):
            continue
        Q = sp.Matrix([[3, q12, q13], [3, q22, q23], [3, q32, q33]])
        if Q * (I3 + SIG) != 2 * N_FAM * sp.Matrix([[1, 0, 0], [1, 0, 0],
                                                    [1, 0, 0]]):
            continue
        Qp = (Q + SIG * Q * SIG) / 2
        if Qp.eigenvals() != {sp.Integer(1): 1, sp.Integer(2): 1,
                              sp.Integer(3): 1}:
            continue
        Qm = (Q - SIG * Q * SIG) / 2
        P_ = Qm * Qm / N_FAM
        if P_ == sp.zeros(3, 3) or sp.expand(P_ * P_ - P_) \
                != sp.zeros(3, 3):
            continue
        U, V = UV(Q)
        if stab_line_exists(U, V):
            Mc = sp.Matrix([[w[i, j] for i in range(3) for j in range(3)]
                            for w in words_up_to(U, V, 4)])
            if Mc.rank() <= 7:
                family.append(Q)
    ladder_members = [Q for Q in family
                      if dom_ladder_test(Q * sp.diag(0, 1, 1))]
    check("S2.UNIQUE [E] on ALL 28 members of the v567 parabolic "
          "carrier-free class EXACTLY ONE satisfies the ladder "
          "self-consistency, and it is the compiler Q -- the selection "
          "needs neither the 81-pin nor any column budget",
          len(family) == 28 and len(ladder_members) == 1
          and ladder_members[0] == Qc(2))
    check("S2.ANCHOR [C, anchored -- no-free-pattern] the witness ladder "
          "(1,2,4) = (2^0,2^1,2^2) is PRIOR load-bearing structure: the "
          "binary AnchorLadder steps p_{n+1} - p_n = 2^n "
          "(Lean-formalised), 2 = |Z2| the sheet datum, and the v566 "
          "trace code p_n(a) = 1 + tr(V^n) = 2 + 2^n rides the same "
          "ladder (n = 1..6 re-verified exactly)",
          all(((Qc(2) * sp.diag(0, 1, 1))**n_).trace() == 1 + 2**n_
              for n_ in range(1, 7)))

    # ---------------------------------------------------------------- S3
    print("\nS3 -- the split geometry located and excluded")
    a_, b_, c0 = sp.symbols('a_ b_ c0')
    sol = sp.solve([sp.Eq(a_ + b_, 1), sp.Eq(a_, 0), sp.Eq(a_ + b_, c0)],
                   [a_, b_, c0])
    Us, Vs = UV(Qc(1))
    L1, L2 = sp.Matrix([1, 0, 0]), sp.Matrix([0, 1, 1])
    inv_ok = all(sp.Matrix.hstack(L1, L2, M * w).det() == 0
                 for M in (Us, Vs) for w in (L1, L2))
    d1 = order_coords(Qc(1))
    check("S3.SPLIT [E] a module complement of the seam line exists IFF "
          "q32 = 1 (solve: a = 0, b = 1, q32 = 1; the plane "
          "span((1,0,0),(0,1,1)) is exactly (U,V)-invariant there) -- "
          "and that member's algebra COLLAPSES to dim 5 (Smith "
          "(1,1,1,3,3), no full parabolic, no 81): the seam-line + "
          "saturation demands admit ONLY nonsplit geometry -- the v566 "
          "A2 Ext arrow is NONZERO on the whole reconstruction class",
          sol == {a_: 0, b_: 1, c0: 1} and inv_ok
          and d1.rank() == 5 and snf_divs(d1) == [1, 1, 1, 3, 3])
    check("S3.TWINS [E] neither twin splits: for q32 in {0, 2} the "
          "complement system (a + b = 1, a = 0, a + b = q32) is "
          "inconsistent -- the residual bit does NOT toggle "
          "split/nonsplit; it toggles WHICH nonsplit integral order is "
          "realised (S1) and whether the dominant mode carries the full "
          "binary ladder (S2)",
          sp.solve([sp.Eq(a_ + b_, 1), sp.Eq(a_, 0), sp.Eq(a_ + b_, 0)],
                   [a_, b_]) == []
          and sp.solve([sp.Eq(a_ + b_, 1), sp.Eq(a_, 0),
                        sp.Eq(a_ + b_, 2)], [a_, b_]) == [])

    # ---------------------------------------------------------------- S4
    print("\nS4 -- Priority-2 candidate tests (the 81's mark-local "
          "structure)")
    H2T = H2.T
    g_ = (1, 2, 3)
    deg = {p: (g_[p[1]] - g_[p[0]]) % 4 for p in IDX7}
    homog = 0
    for j in range(H2T.shape[0]):
        supp = [IDX7[k] for k in range(7) if H2T[j, k] != 0]
        if len({deg[p] for p in supp}) <= 1:
            homog += 1
    check("S4.GRADE [E, candidate FAILS -- reported honestly] the "
          "mu4-grading candidate deg(E_jk) = g_k - g_j mod 4 does NOT "
          "make the order a graded sublattice (only %d of 7 Hermite "
          "vectors homogeneous): the grading cannot descend to the "
          "cokernel -- this natural 'one Z/3 per mark' candidate fails; "
          "the kill condition does NOT fire, the 81 stays a fingerprint "
          "pending a mechanism" % homog,
          homog < 7)
    Vb = Qc(2) * sp.diag(0, 1, 1)
    Hs = H2
    img_ok = True
    for j in range(Hs.shape[1]):
        x = sp.zeros(3, 3)
        for k, (i2, j2) in enumerate(IDX7):
            x[i2, j2] = Hs[k, j]
        y = Vb * x
        yv = sp.Matrix([[y[i2, j2]] for (i2, j2) in IDX7])
        t_ = Hs.solve(yv)
        if not all(x_.is_integer for x_ in t_):
            img_ok = False
            break
    check("S4.VACT [E] left multiplication by V PRESERVES the order "
          "lattice (V O subset O), so it induces a canonical F3-linear "
          "action on the cokernel (Z/3)^4 -- the mark-local question is "
          "sharpened to a concrete module computation (the "
          "F3[V]-character structure vs the four marks)",
          img_ok)

    # --- the F3[V]-character computation, executed ------------------------
    def smith_with_transforms(M):
        M = sp.Matrix(M)
        A = M.copy()
        S_ = sp.eye(A.rows)
        T_ = sp.eye(A.cols)

        def minaij(A_, t_):
            best = None
            for i_ in range(t_, A_.rows):
                for j_ in range(t_, A_.cols):
                    if A_[i_, j_] != 0 and (
                            best is None
                            or abs(A_[i_, j_]) < abs(A_[best[0], best[1]])):
                        best = (i_, j_)
            return best

        t_ = 0
        while t_ < min(A.rows, A.cols):
            p_ = minaij(A, t_)
            if p_ is None:
                break
            A.row_swap(t_, p_[0])
            S_.row_swap(t_, p_[0])
            A.col_swap(t_, p_[1])
            T_.col_swap(t_, p_[1])
            done = False
            while not done:
                done = True
                for i_ in range(t_ + 1, A.rows):
                    if A[i_, t_] != 0:
                        q_ = A[i_, t_] // A[t_, t_]
                        A[i_, :] = A[i_, :] - q_ * A[t_, :]
                        S_[i_, :] = S_[i_, :] - q_ * S_[t_, :]
                        if A[i_, t_] != 0:
                            A.row_swap(t_, i_)
                            S_.row_swap(t_, i_)
                            done = False
                for j_ in range(t_ + 1, A.cols):
                    if A[t_, j_] != 0:
                        q_ = A[t_, j_] // A[t_, t_]
                        A[:, j_] = A[:, j_] - q_ * A[:, t_]
                        T_[:, j_] = T_[:, j_] - q_ * T_[:, t_]
                        if A[t_, j_] != 0:
                            A.col_swap(t_, j_)
                            S_.col_swap(t_, j_)
                            done = False
            t_ += 1
        return A, S_, T_

    x = sp.symbols('x')
    results = {}
    for cx in (2, 0):
        Hx = hermite_normal_form(order_coords(Qc(cx)).T)
        Dx, Sx, Tx = smith_with_transforms(Hx)
        dd = [Dx[i, i] for i in range(7)]
        tor = [i for i in range(7) if abs(dd[i]) == 3]
        Vb_ = Qc(cx) * sp.diag(0, 1, 1)
        Ub_ = Qc(cx) * sp.diag(1, 0, 0)
        LV = sp.zeros(7, 7)
        LU = sp.zeros(7, 7)
        for k, (i2, j2) in enumerate(IDX7):
            E = sp.zeros(3, 3)
            E[i2, j2] = 1
            colV = [(Vb_ * E)[i3, j3] for (i3, j3) in IDX7]
            colU = [(Ub_ * E)[i3, j3] for (i3, j3) in IDX7]
            for r_ in range(7):
                LV[r_, k] = colV[r_]
                LU[r_, k] = colU[r_]
        subV = (Sx * LV * Sx.inv())[tor, tor].applyfunc(
            lambda v_: sp.Integer(v_) % 3)
        subU = (Sx * LU * Sx.inv())[tor, tor].applyfunc(
            lambda v_: sp.Integer(v_) % 3)
        cp = sp.Poly(subV.charpoly(x), x, modulus=3).as_expr()
        results[cx] = (cp, subU == sp.zeros(4, 4))
    check("S4.VCHAR [E, candidate (ii) FAILS THE MARK PATTERN -- reported "
          "honestly] the induced F3[V]-action on the cokernel has "
          "characteristic polynomial x(x - 1)^2(x + 1) mod 3 -- "
          "eigenvalues {0, 1, 1, -1}, NOT the regular mu4 pattern "
          "x^4 - 1 that 'one Z/3 per mark' would require (the action is "
          "not even invertible), and U acts as ZERO on the cokernel; "
          "both twins give the identical structure (the cokernel action "
          "separates nothing).  Priority-2 status after two candidates: "
          "grading fails, V-action exists but is non-regular -- the 81 "
          "stays a FINGERPRINT; the kill condition (no canonical local "
          "decomposition exists at all) is closer but not proven",
          all(sp.expand(results[cx][0]
                        - (x**4 - x**3 - x**2 + x)) == 0
              and results[cx][1] for cx in (2, 0)))

    # ---------------------------------------------------------------- S5
    print("\nS5 -- the fences, restated as a check")
    check("S5.FENCE: THE PHYSICAL SELECTION IS NOT DERIVED -- why the "
          "dominant mode should satisfy the ladder self-consistency is "
          "the relocated open question (the same slot as the "
          "RP-selection of the alignment bit, v528/v534); the resonance "
          "between the reconstruction bit and the alignment bit is a "
          "TYPED OBSERVATION, not an identification; Stage B of v567 "
          "(GATE.QGEO.01) untouched; NO P2 reduction; AX.P2.01 and "
          "ANCHOR.GEN.01 markers untouched; the selector is typed [C] "
          "as candidate canonical selection; Smith 1861 / Hermite 1851 "
          "/ Gabriel 1972 / Perron-Frobenius named CLASSICAL as "
          "addresses",
          True)

    print("\nv568 anchors: twins integrally distinct (equal index 81, "
          "different lattices); dominant mode v(c) =")
    print("  (1, 2, 2c) with the ladder self-consistency picking c = 2 "
          "uniquely on all 28; split member at")
    print("  q32 = 1 excluded (dim 5); mu4-grading candidate fails, "
          "F3[V]-action exists (Priority 2 sharpened)")
    return summary("DIAMOND.BIT.SELECT.01 reconstruction bit selector")


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

2c4d803060a9f3652f791e007a967281e45f4fca5ff53766443a353ffd986d73

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.