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"""v834 -- PG32.FLAGS.01: the PG(3,2) flag normal form for the 105 + 35 vacuum completion, with the incidence kill test typed as a split, ONE module from one probe (26/26 checks, verdict PG32-FLAGS-EXACT + INCIDENCE-SPLIT; discovery probe pg32_flag_completion_probe.py, 2026-08-07, re-run identically at promotion, promoted VERBATIM with no downscoping, < 1 s).  THE COUNTING NORMAL FORM (exact): the Gaussian binomial [4 choose 2]_2 = 35 = the census of 2-dim subspaces of F2^4; each subspace has 4 cosets, so 140 affine 2-flats of AG(4,2) = 35 through the origin + 105 not; PG(3,2) has 15 points, 35 lines, 105 = 35 x 3 point-line flags, canonically bijective to the C(15,2) = 105 point pairs via {x,y} <-> (x+y, {x,y,x+y}).  THE RM LAYER (v819 S4 / v821 S1-S2 / v822 rebuilt, all set equalities): shortened RM(2,4) = [15,10,4] has weight enumerator 1 + 105z^4 + 280z^6 + 435z^8 + 168z^10 + 35z^12 EXACT, and its 105 weight-4 words ARE the indicators of the 105 flats avoiding 0; the 140 weight-4 words of RM(2,4) ARE all 140 flats; Grams entrywise H105^T H105 = 22I + 6J, H35^T H35 = 6I + J, A140^T A140 = 28 I_16 + 7 J_16 (the v822 unshortening identity).  THE VACUUM READING: the 35 origin planes puncture to weight 3, NONE lies in the shortened code (min distance 4), ONE origin plane unshortens dim 10 -> 11, and in RM(2,4) the vacuum coordinate restores weight 4 -- the vacuum coordinate is ORIGIN RESTORATION.  THE INCIDENCE SPLIT (the kill test, typed): with the corpus symplectic form hb(v,w) = (sum v)(sum w) - v.w mod 2 (v774), the 105 = 45 + 60 split is the Sp(4,2)-ORBIT decomposition on BOTH sides (|Sp(4,2)| = 720 by brute force; flats and flags each split 45 + 60); on the 60 NON-ISOTROPIC rungs the polarity map PHI: (U,t) -> ((t+U) n U^omega, U^omega) is well-defined (unique intersection on all 60), bijective, Sp(4,2)-EQUIVARIANT (all 60 x 720) and INCIDENCE-PRESERVING; on the 45 DOILY rungs the obstruction is typed: U^omega = U (doily self-polarity) and (t+U) n U = EMPTY for 45/45 flats -- NO flag can put its point inside its own check support -- and the unique abstract equivariant bijection matches flags whose support n line = 0; the flag incidence Gram is 18I + 3J != 22I + 6J, so no flag reading reproduces the corpus check Gram.  THE TYPED CONCLUSION: '105 checks = 105 flags' is exact as a deck-equivariant BIJECTION, NOT as an incidence isomorphism -- the obstruction sits exactly on the doily (the typed reason v822's continuum dilation died).  VACUUM CARRIER CONTENT: the zero class of L/(1+i)L carries NO E8 root (0/240 rebuilt, v689 [E]) -- the vacuum point repairs the label Gram (+6I+J) but adds no carrier content; v822's frozen continuum kill (UNSHORTEN-DEAD / DILATION-DEAD) cited as the companion negative.  Controls fire (a scrambled plane row breaks the 22I+6J Gram; a degenerate form breaks the doily census; the 45-sector obstruction fires as its own control vs 0/60 empty on the non-isotropic side).  Exact integer arithmetic; no floats, no RNG, no fit.  Python-only per GATE.WOLFRAM.02.

PROVENANCE: discovery probe pg32_flag_completion_probe.py (26/26,
verdict PG32-FLAGS-EXACT + INCIDENCE-SPLIT, 2026-08-07, re-run
identically at promotion); this module runs the frozen protocol
VERBATIM (< 1 s).  The original probe docstring and frozen protocol
live in the probe file verbatim (experiments/tfpt-discovery/).  Corpus
sources rebuilt inline: v819 S4 ([15,10,4] enumerator), v821 (140 =
105 + 35, Grams), v822 (unshortening identity, code dims; its
continuum kill cited, not recomputed), v774 (corpus symplectic form),
note_e8_gaussian_code / v689 (zero-class census).
"""
import itertools
import time
from collections import Counter

EXPECTED_VERDICT_HEAD = "PG32-FLAGS-EXACT + INCIDENCE-SPLIT"


def run():
    t_start = time.time()
    checks = []

    def check(name, ok, detail=""):
        checks.append(bool(ok))
        print("  [%s] %s%s" % ("PASS" if ok else "FAIL", name,
                               ("  -- " + detail) if detail else ""))
        return bool(ok)

    def section(title):
        print("\n== %s ==  (t=%.1fs)" % (title, time.time() - t_start))

    print("v834 PG32.FLAGS.01 -- the PG(3,2) flag normal form for "
          "105 + 35")

    PTS = list(range(16))               # F2^4 as ints (bit k = coord k)
    NZ = [v for v in PTS if v]

    def pc(v):
        return bin(v).count("1")

    # ==================================================================
    section("S1: Gaussian binomial and the 140 = 105 + 35 flats")
    # ==================================================================
    gb = ((2 ** 4 - 1) * (2 ** 4 - 2)) // ((2 ** 2 - 1) * (2 ** 2 - 2))
    subspaces = set()
    for u1, u2 in itertools.combinations(NZ, 2):
        subspaces.add(frozenset([0, u1, u2, u1 ^ u2]))
    subspaces = sorted(subspaces, key=sorted)
    check("S1.1 [4 choose 2]_2 = (15*14)/(3*2) = %d == 35 == census of "
          "2-dim subspaces of F2^4 (%d)" % (gb, len(subspaces)),
          gb == 35 == len(subspaces))

    flats = []                          # (U, frozenset coset)
    for U in subspaces:
        cosets = set()
        for t in PTS:
            cosets.add(frozenset(t ^ u for u in U))
        assert len(cosets) == 4
        for cs in cosets:
            flats.append((U, cs))
    through0 = [(U, cs) for U, cs in flats if 0 in cs]
    not0 = [(U, cs) for U, cs in flats if 0 not in cs]
    check("S1.2 each U has 4 cosets -> %d affine 2-flats; %d through "
          "the origin + %d not; 105 + 35 = 140"
          % (len(flats), len(through0), len(not0)),
          len(flats) == 140 and len(through0) == 35
          and len(not0) == 105)

    # ==================================================================
    section("S2: PG(3,2) points, lines, flags")
    # ==================================================================
    lines = [frozenset(U - {0}) for U in subspaces]
    flags = [(p, ln) for ln in lines for p in ln]
    npairs = len(list(itertools.combinations(NZ, 2)))
    check("S2.1 PG(3,2): %d points, %d lines, 3 points per line, "
          "%d point-line flags = 35 x 3; flags ~= point pairs "
          "(C(15,2) = %d) via {x,y} <-> (x+y, {x,y,x+y})"
          % (len(NZ), len(lines), len(flags), npairs),
          len(NZ) == 15 and len(lines) == 35
          and all(len(ln) == 3 for ln in lines)
          and len(flags) == 105 and npairs == 105)
    pair_bij = {frozenset((a, b)): (a ^ b, frozenset((a, b, a ^ b)))
                for a, b in itertools.combinations(NZ, 2)}
    check("S2.2 the pair<->flag map is a bijection onto the 105 flags",
          sorted(pair_bij.values(), key=str) == sorted(flags, key=str)
          or set(pair_bij.values()) == set(flags))

    # ==================================================================
    section("S3: the RM layer (v819 S4 / v821 S1-S2 / v822 rebuilt)")
    # ==================================================================
    def eval_word(func):
        """evaluate a boolean function on all 16 points -> 16-bit
        word."""
        return tuple(func(v) for v in PTS)

    monos1 = [eval_word(lambda v, k=k: (v >> k) & 1) for k in range(4)]
    monos2 = [eval_word(lambda v, k=k, l=l:
                        ((v >> k) & 1) * ((v >> l) & 1))
              for k, l in itertools.combinations(range(4), 2)]
    ONEW = tuple(1 for _ in PTS)

    def span(gens):
        out = set()
        for bits in itertools.product((0, 1), repeat=len(gens)):
            w = tuple(sum(b * g[k] for b, g in zip(bits, gens)) % 2
                      for k in range(len(gens[0])))
            out.add(w)
        return out

    rm24 = span([ONEW] + monos1 + monos2)          # RM(2,4), dim 11
    short_gens = [tuple(w[v] for v in NZ) for w in monos1 + monos2]
    c1perp = span(short_gens)                      # shortened RM(2,4)
    check("S3.1 dims: |RM(2,4)| = %d == 2^11, |shortened| = %d == 2^10 "
          "(v822 code dims 11 / 10)" % (len(rm24), len(c1perp)),
          len(rm24) == 2048 and len(c1perp) == 1024)

    we = Counter(sum(w) for w in c1perp)
    check("S3.2 weight enumerator of [15,10,4] = 1 + 105z^4 + 280z^6 + "
          "435z^8 + 168z^10 + 35z^12 EXACT (census: %s)"
          % dict(sorted(we.items())),
          dict(we) == {0: 1, 4: 105, 6: 280, 8: 435, 10: 168, 12: 35})

    w4_words = {w for w in c1perp if sum(w) == 4}
    flat_ind = {tuple(1 if v in cs else 0 for v in NZ)
                for U, cs in not0}
    check("S3.3 the 105 weight-4 words of [15,10,4] ARE the indicators "
          "of the 105 flats avoiding 0 (set equality, %d = %d)"
          % (len(w4_words), len(flat_ind)), w4_words == flat_ind)

    w4_full = {w for w in rm24 if sum(w) == 4}
    all_flat_ind = {tuple(1 if v in cs else 0 for v in PTS)
                    for U, cs in flats}
    check("S3.4 the 140 weight-4 words of RM(2,4) ARE all 140 affine "
          "2-flats (v821 S1; %d = %d)"
          % (len(w4_full), len(all_flat_ind)),
          w4_full == all_flat_ind)

    H105 = sorted(w4_words)
    H35 = [tuple(1 if v in U else 0 for v in NZ) for U in subspaces]

    def gram(cols):
        n = len(cols[0])
        return [[sum(c[i] * c[j] for c in cols) for j in range(n)]
                for i in range(n)]

    def is_aIbJ(G, a, b):
        return all(G[i][j] == (a + b if i == j else b)
                   for i in range(len(G)) for j in range(len(G)))

    G105 = gram(H105)
    G35 = gram(H35)
    check("S3.5 GRAMS entrywise: H105^T H105 == 22I + 6J, H35^T H35 == "
          "6I + J (v821 S2 / v822: 28 planes through a point, 6 "
          "through a pair; 7 lines through a point, 1 through a pair)",
          is_aIbJ(G105, 22, 6) and is_aIbJ(G35, 6, 1))
    A140 = sorted(w4_full)
    G140 = gram(A140)
    check("S3.6 UNSHORTENING IDENTITY: A140^T A140 == 28 I_16 + 7 J_16 "
          "entrywise on all 16 coordinates (diag 35 = planes through a "
          "point, offdiag 7 = through a pair; v822 [E])",
          is_aIbJ(G140, 28, 7))

    w3_punct = {tuple(w[v] for v in NZ) for w in w4_full
                if w[0] == 1}           # origin planes punctured at 0
    check("S3.7 VACUUM READING: the 35 origin planes puncture to "
          "weight 3 (%d words, all weight 3), NONE lies in the "
          "[15,10,4] shortened code (min distance 4), and in RM(2,4) "
          "the vacuum coordinate restores weight 4"
          % len(w3_punct),
          len(w3_punct) == 35 and all(sum(w) == 3 for w in w3_punct)
          and not (w3_punct & c1perp)
          and all(sum(w) == 4 for w in w4_full if w[0] == 1))
    one_unshort = span(short_gens + [sorted(w3_punct)[0]])
    check("S3.8 ONE origin plane unshortens dim 10 -> 11: "
          "|span| = %d == 2^11 = |punctured RM(2,4)| (v822 'ONE origin "
          "plane unshortens')" % len(one_unshort),
          len(one_unshort) == 2048
          and one_unshort == {tuple(w[v] for v in NZ) for w in rm24})

    # ==================================================================
    section("S4: the incidence check (the kill) -- Sp(4,2) and the "
            "doily")
    # ==================================================================
    def hb(v, w):
        # corpus form (v774 GJI = J - I): v^T(J-I)w
        return ((pc(v) & 1) & (pc(w) & 1)) ^ (pc(v & w) & 1)

    rad = [v for v in NZ if all(hb(v, w) == 0 for w in NZ)]
    check("S4.1 hb is alternating (hb(v,v) = 0 all v) and "
          "nondegenerate (radical %s empty)" % rad,
          all(hb(v, v) == 0 for v in PTS) and not rad)

    iso_lines = [U for U in subspaces
                 if all(hb(u, w) == 0 for u in U for w in U)]
    noniso = [U for U in subspaces if U not in iso_lines]
    check("S4.2 DOILY: %d isotropic lines + %d non-isotropic = 35 "
          "(GQ(2,2) has 15 lines)" % (len(iso_lines), len(noniso)),
          len(iso_lines) == 15 and len(noniso) == 20)

    flats45 = [(U, cs) for U, cs in not0 if U in iso_lines]
    flats60 = [(U, cs) for U, cs in not0 if U not in iso_lines]
    iso_line_set = {frozenset(U - {0}) for U in iso_lines}
    flags45 = [(p, ln) for p, ln in flags if ln in iso_line_set]
    flags60 = [(p, ln) for p, ln in flags if ln not in iso_line_set]
    check("S4.3 THE 105 = 45 + 60 SPLIT on BOTH sides: flats %d + %d, "
          "flags %d + %d (45 = 15 x 3 doily-line flags)"
          % (len(flats45), len(flats60), len(flags45), len(flags60)),
          len(flats45) == 45 and len(flats60) == 60
          and len(flags45) == 45 and len(flags60) == 60)

    E = [1, 2, 4, 8]
    SP = []
    for a in NZ:
        for b in NZ:
            if b == a:
                continue
            if hb(a, b) != hb(1, 2):
                continue
            for c in NZ:
                if c in (a, b):
                    continue
                if hb(a, c) != hb(1, 4) or hb(b, c) != hb(2, 4):
                    continue
                span3 = {0, a, b, a ^ b, c, a ^ c, b ^ c, a ^ b ^ c}
                if len(span3) != 8:
                    continue
                for d in NZ:
                    if d in span3:
                        continue
                    if hb(a, d) != hb(1, 8) or hb(b, d) != hb(2, 8) \
                       or hb(c, d) != hb(4, 8):
                        continue
                    m = [0] * 16
                    for v in PTS:
                        x = 0
                        if v & 1:
                            x ^= a
                        if v & 2:
                            x ^= b
                        if v & 4:
                            x ^= c
                        if v & 8:
                            x ^= d
                        m[v] = x
                    SP.append(tuple(m))
    check("S4.4 |Sp(4,2)| = %d == 720 (brute force; the deck action "
          "on V)" % len(SP), len(SP) == 720)

    def act_flat(m, fl):
        U, cs = fl
        return (frozenset(m[u] for u in U),
                frozenset(m[x] for x in cs))

    def act_flag(m, fg):
        p, ln = fg
        return (m[p], frozenset(m[x] for x in ln))

    def orbits(objs, act):
        rem = set(objs)
        out = []
        while rem:
            x = next(iter(rem))
            orb = {act(m, x) for m in SP}
            out.append(len(orb))
            rem -= orb
        return sorted(out)

    ofl = orbits([(U, cs) for U, cs in not0], act_flat)
    ofg = orbits(flags, act_flag)
    check("S4.5 Sp(4,2) ORBITS: flats %s == [45, 60], flags %s == "
          "[45, 60] -- the 45/60 split IS the orbit decomposition on "
          "both sides" % (ofl, ofg), ofl == [45, 60] and ofg == [45, 60])

    def omega(U):
        return frozenset(v for v in PTS
                         if all(hb(v, u) == 0 for u in U))

    phi = {}
    ok_unique = True
    for U, cs in flats60:
        Uw = omega(U)
        inter = [x for x in cs if x in Uw]
        if len(inter) != 1:
            ok_unique = False
            break
        phi[(U, cs)] = (inter[0], frozenset(Uw - {0}))
    check("S4.6 60-SECTOR polarity map PHI: (U,t) -> ((t+U) n U^omega, "
          "U^omega): intersection unique for all 60 (%s), image = the "
          "60 non-isotropic flags, bijective" % ok_unique,
          ok_unique and len(set(phi.values())) == 60
          and set(phi.values()) == set(flags60))
    equi = all(phi[act_flat(m, fl)] == act_flag(m, phi[fl])
               for fl in flats60 for m in SP)
    check("S4.7 PHI is Sp(4,2)-EQUIVARIANT (all 60 x 720 checks) and "
          "INCIDENCE-PRESERVING: the flag point lies IN the check "
          "support and the flag line meets the support in EXACTLY "
          "that point",
          equi and all(phi[fl][0] in fl[1]
                       and len([x for x in fl[1]
                                if x in phi[fl][1]]) == 1
                       for fl in flats60))

    empty_iso = sum(1 for U, cs in flats45
                    if not any(x in omega(U) for x in cs))
    check("S4.8 45-SECTOR OBSTRUCTION: U^omega = U for isotropic U "
          "(doily self-polarity) and (t+U) n U = EMPTY for %d/45 flats "
          "-- on the doily sector NO flag can put its point inside its "
          "own check support via the polarity" % empty_iso,
          all(omega(U) == U for U in iso_lines) and empty_iso == 45)

    fl0 = flats45[0]
    stab_fl0 = [m for m in SP if act_flat(m, fl0) == fl0]
    n_equib = 0
    match_types = []
    for fg in flags45:
        if all(act_flag(m, fg) == fg for m in stab_fl0):
            n_equib += 1
            match_types.append(fg)
    support_hits = [sum(1 for x in fl0[1] if x == fg[0]
                        or x in fg[1]) for fg in match_types]
    check("S4.9 ABSTRACT G-SET CENSUS (45-sector): |Stab(flat0)| = %d "
          "(= 720/45); equivariant images of flat0 among the 45 flags "
          "= %d -> %d equivariant bijection(s) flats45 -> flags45 "
          "exist(s); matched flag(s) %s share their LINE with flat0's "
          "direction U but support n line = %s (the incidence fails "
          "pointwise)"
          % (len(stab_fl0), n_equib, n_equib,
             [(f[0], sorted(f[1])) for f in match_types],
             support_hits),
          len(stab_fl0) == 16
          and all(fg[1] == frozenset(fl0[0] - {0})
                  for fg in match_types)
          and all(h == 0 for h in support_hits))

    Gflag = gram([tuple(1 if (v == p or v in ln) else 0 for v in NZ)
                  for p, ln in flags])
    check("S4.10 GRAM OBSTRUCTION: flag->line incidence Gram = "
          "18I + 3J (diag %d, offdiag %d) != 22I + 6J of the corpus "
          "checks -- the flag reading does NOT reproduce H105^T H105"
          % (Gflag[0][0], Gflag[0][1]),
          is_aIbJ(Gflag, 18, 3) and not is_aIbJ(Gflag, 22, 6))

    # ==================================================================
    section("S5: vacuum carrier content (zero class has no E8 root)")
    # ==================================================================
    G_NAIVE = ((1, 0, 0, 0, 0, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1),
               (0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 0, 1, 1, 1, 1, 0))
    C_NAIVE = frozenset(
        tuple(sum(m[k] * G_NAIVE[k][j] for k in range(4)) % 2
              for j in range(8))
        for m in itertools.product((0, 1), repeat=4))
    PI_J = (1, 0, 3, 2, 5, 4, 7, 6)
    PI_SIG = (2, 3, 4, 5, 0, 1, 6, 7)

    def code_image(code, p):
        return frozenset(tuple(c[p[k]] for k in range(8)) for c in code)

    placements = set()
    for perm in itertools.permutations(range(8)):
        placements.add(code_image(C_NAIVE, perm))
    both = [c for c in placements
            if code_image(c, PI_J) == c and code_image(c, PI_SIG) == c]
    CSTAR = next(c for c in both if (1, 0, 1, 0, 1, 0, 1, 0) in c)
    ROOTS = []
    for k in range(8):
        for s in (2, -2):
            v = [0] * 8
            v[k] = s
            ROOTS.append(tuple(v))
    for c in (c for c in CSTAR if sum(c) == 4):
        sup = [k for k in range(8) if c[k]]
        for signs in itertools.product((1, -1), repeat=4):
            v = [0] * 8
            for k, s in zip(sup, signs):
                v[k] = s
            ROOTS.append(tuple(v))

    def in_pi2L(v):
        w = [0] * 8
        for k in range(4):
            w[2 * k] = v[2 * k] + v[2 * k + 1]
            w[2 * k + 1] = v[2 * k + 1] - v[2 * k]
        if any(x % 2 for x in w):
            return False
        return tuple((x // 2) % 2 for x in w) in CSTAR

    n_zero = sum(1 for r in ROOTS if in_pi2L(r))
    check("S5.1 the ZERO CLASS carries NO E8 root: %d/240 roots in "
          "(1+i)L (v689 [E] rebuilt) -- the vacuum point repairs the "
          "label Gram (+6I+J, S3.5/S3.6) but adds no carrier content; "
          "v822's frozen continuum kill (UNSHORTEN-DEAD / "
          "DILATION-DEAD) cited as the companion negative" % n_zero,
          len(ROOTS) == 240 and n_zero == 0)

    # ==================================================================
    section("C: controls (must fire)")
    # ==================================================================
    bad_word = tuple(1 if v in (1, 2, 4, 8) else 0 for v in NZ)
    H105_bad = [bad_word] + H105[1:]
    check("C1 scrambled plane row (weight-4 non-plane word "
          "{e1,e2,e3,e4}): H105'^T H105' != 22I + 6J (%s) -- the Gram "
          "identity needs the plane structure"
          % (not is_aIbJ(gram(H105_bad), 22, 6)),
          bad_word not in w4_words
          and not is_aIbJ(gram(H105_bad), 22, 6))

    def hb_deg(v, w):
        """rank-2 alternating form using only coords 0,1 (radical
        dim 2)."""
        return ((v & 1) * ((w >> 1) & 1)
                + (w & 1) * ((v >> 1) & 1)) % 2

    iso_deg = [U for U in subspaces
               if all(hb_deg(u, w) == 0 for u in U for w in U)]
    check("C2 degenerate alternating form (rank 2, radical dim 2): "
          "isotropic-line census %d != 15 -- the doily needs the "
          "nondegenerate corpus form" % len(iso_deg),
          len(iso_deg) != 15)

    check("C3 the 45-sector obstruction FIRES as a control: empty "
          "polarity intersection on 45/45 isotropic flats (S4.8), vs "
          "0/60 empty on the non-isotropic side",
          empty_iso == 45
          and all(any(x in omega(U) for x in cs) for U, cs in flats60))

    # ==================================================================
    n_all = len(checks)
    n_fail = n_all - sum(checks)
    if n_fail == 0:
        verdict = ("PG32-FLAGS-EXACT + INCIDENCE-SPLIT (60-sector "
                   "exact via the symplectic polarity; 45-sector = the "
                   "doily lines obstructed: (t+U) n U^omega = EMPTY, "
                   "and the flag Gram 18I+3J != 22I+6J)")
    else:
        verdict = "PG32-FLAGS-BROKEN (see FAILs)"
    print("\nv834: %d/%d checks passed, %d failed  (%.1f s)"
          % (n_all - n_fail, n_all, n_fail, time.time() - t_start))
    print("VERDICT: %s" % verdict)
    pattern_ok = verdict.startswith(EXPECTED_VERDICT_HEAD)
    print("[%s] PATTERN GATE: expected verdict head %s"
          % ("PASS" if pattern_ok else "FAIL", EXPECTED_VERDICT_HEAD))
    return n_fail + (0 if pattern_ok else 1)


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

3c07a7e6c02acf39021499e5ee0648e56d768b9432bc5bad4660ddc23ae037a4

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.