Datasets:
Formats:
csv
Languages:
English
Size:
10K - 100K
Tags:
recursive-self-improvement
symmetry-reduction
finite-groups
exact-compilation
dynamic-programming
reproducible-research
| #!/usr/bin/env python3 | |
| """Exact finite-group repair compiler; Python 3.10+, standard library only. | |
| Run development only: python relational_compiler.py --seeds 1:4 --output dev_results | |
| Held-out seeds are NOT generated by that command. All costs are abstract operations, | |
| not processor instructions. Timing includes instrumentation. No GPU or model is used. | |
| The symmetry-aware reference is deliberately algorithmically identical: this code | |
| does not claim novelty for min-plus convolution, memoization, or symmetry reduction. | |
| """ | |
| from __future__ import annotations | |
| import argparse, csv, hashlib, json, math, random, time | |
| from collections import deque | |
| from dataclasses import dataclass, field | |
| from pathlib import Path | |
| INF = 10**12 | |
| class Exhausted(RuntimeError): | |
| pass | |
| class Meter: | |
| limit: int = 10**18 | |
| counts: dict = field(default_factory=dict) | |
| total: int = 0 | |
| def tick(self, name, n=1): | |
| if self.total + n > self.limit: | |
| raise Exhausted() | |
| self.counts[name] = self.counts.get(name, 0) + n | |
| self.total += n | |
| def candidate(self): | |
| self.tick('candidate_additions') | |
| self.tick('candidate_comparisons') | |
| class Group: | |
| """D_m = {(rotation, reflection)}, order 2m; identity is integer zero.""" | |
| def __init__(self, m): | |
| self.m, self.n = m, 2*m | |
| self.mul = [[((a % m + (-1 if a >= m else 1)*(b % m)) % m) | |
| + m*((a//m + b//m) % 2) for b in range(2*m)] | |
| for a in range(2*m)] | |
| self.inv = [next(b for b in range(2*m) if self.mul[a][b] == 0) | |
| for a in range(2*m)] | |
| self.all = frozenset(range(self.n)) | |
| class Kernel: | |
| word: tuple | |
| costs: tuple | |
| split: tuple | |
| left: Kernel | None = None | |
| right: Kernel | None = None | |
| options: tuple = () | |
| support: tuple = () | |
| L: frozenset = frozenset({0}) | |
| R: frozenset = frozenset({0}) | |
| Lg: tuple = () | |
| Rg: tuple = () | |
| generation: int = 0 | |
| uniform: bool = False | |
| def choices(self, z, meter): | |
| meter.tick('witness_traversal') | |
| if not self.support or self.costs[z] >= INF: | |
| return None | |
| if self.left is None: | |
| return [self.split[z]] | |
| a,b = self.split[z] | |
| return self.left.choices(a,meter) + self.right.choices(b,meter) | |
| def subgroup(g, generators, meter): | |
| seen, queue = {0}, deque([0]) | |
| while queue: | |
| x = queue.popleft() | |
| for a in generators: | |
| meter.tick('group_operations') | |
| y = g.mul[x][a] | |
| if y not in seen: | |
| seen.add(y); queue.append(y) | |
| return frozenset(seen) | |
| def stabilizer(k, g, side, meter, known=frozenset({0}), gens=()): | |
| """Exact discovery. Closure skips already certified group elements.""" | |
| if k.uniform: | |
| meter.tick('symmetry_uniform_certificate') | |
| return g.all, (1,g.m) | |
| classes={} | |
| for x,c in enumerate(k.costs): | |
| meter.tick('symmetry_partition');classes.setdefault(c,[]).append(x) | |
| C=min(classes.values(),key=len);meter.tick('symmetry_partition',len(classes)) | |
| if len(C)==1: | |
| meter.tick('unique_value_certificate') | |
| return frozenset({0}),() | |
| anchor=C[0];found,generators=known,list(gens) | |
| for y in C: | |
| meter.tick('group_operations') | |
| a=g.mul[y][g.inv[anchor]] if side=='L' else g.mul[g.inv[anchor]][y] | |
| meter.tick('symmetry_candidates') | |
| if a in found:continue | |
| good = True | |
| for x in range(g.n): | |
| meter.tick('symmetry_comparisons') | |
| y = g.mul[a][x] if side == 'L' else g.mul[x][a] | |
| if k.costs[y] != k.costs[x]: | |
| good = False; break | |
| if good: | |
| generators.append(a) | |
| found = subgroup(g,generators,meter) | |
| return found, tuple(generators) | |
| def finish(k, g, meter, discover, audit): | |
| meter.tick('array_metadata',len(k.costs)) | |
| k.support = tuple(i for i,c in enumerate(k.costs) if c < INF) | |
| k.uniform=True | |
| for c in k.costs: | |
| meter.tick('uniform_comparisons') | |
| if c!=k.costs[0]:k.uniform=False;break | |
| oldL,oldR = len(k.L),len(k.R) | |
| if discover: | |
| k.L,k.Lg = stabilizer(k,g,'L',meter,k.L,k.Lg) | |
| k.R,k.Rg = stabilizer(k,g,'R',meter,k.R,k.Rg) | |
| if len(k.L)>oldL or len(k.R)>oldR: | |
| audit['symmetry_growth'] = audit.get('symmetry_growth',0)+1 | |
| return k | |
| def leaf(tid, options, g, meter, discover, audit): | |
| c,sp = [INF]*g.n,[None]*g.n | |
| meter.tick('array_allocation',2*g.n) | |
| for j,(d,cost) in enumerate(options): | |
| meter.tick('leaf_comparisons') | |
| if cost < c[d]: c[d],sp[d] = cost,j | |
| k = Kernel((tid,),tuple(c),tuple(sp),options=tuple(options)) | |
| return finish(k,g,meter,discover,audit) | |
| def inherited(k, a, b): | |
| k.L,k.Lg,k.R,k.Rg = a.L,a.Lg,b.R,b.Rg | |
| return k | |
| def compose(a,b,g,meter,kind='dense',discover=False,audit=None): | |
| """All-boundary acquisition; symmetry transport uses child witnesses.""" | |
| audit = {} if audit is None else audit | |
| n,mt = g.n,g.mul | |
| meter.tick('role_concatenation',len(a.word)+len(b.word)) | |
| word = a.word+b.word | |
| c,sp = [INF]*n,[None]*n | |
| meter.tick('array_allocation',2*n) | |
| if kind == 'fast' and (a.uniform or b.uniform) and a.support and b.support: | |
| # Strong simple baseline: a constant factor has a closed-form convolution. | |
| if a.uniform: | |
| j = min(b.support,key=lambda x:b.costs[x]); meter.tick('minimum_scan',n) | |
| value = a.costs[0]+b.costs[j] | |
| for z in range(n): | |
| meter.tick('group_operations'); meter.tick('witness_materialization') | |
| c[z],sp[z] = value,(mt[z][g.inv[j]],j) | |
| else: | |
| i = min(a.support,key=lambda x:a.costs[x]); meter.tick('minimum_scan',n) | |
| value = a.costs[i]+b.costs[0] | |
| for z in range(n): | |
| meter.tick('group_operations'); meter.tick('witness_materialization') | |
| c[z],sp[z] = value,(i,mt[g.inv[i]][z]) | |
| elif kind == 'symmetry' and a.support and b.support: | |
| meter.tick('subgroup_intersection',n) | |
| H = a.R & b.L | |
| reps,covered = [],set() | |
| for x in range(n): | |
| meter.tick('coset_membership') | |
| if x in covered: continue | |
| reps.append(x) | |
| for h in H: | |
| meter.tick('group_operations'); covered.add(mt[x][h]) | |
| remaining = set(range(n)) | |
| for z in range(n): | |
| meter.tick('orbit_membership') | |
| if z not in remaining:continue | |
| orbit,queue = {z:(0,0)},deque([z]) | |
| while queue: | |
| x = queue.popleft(); l,r = orbit[x] | |
| for u in a.Lg: | |
| meter.tick('group_operations',2) | |
| y,lr = mt[u][x],(mt[u][l],r) | |
| if y not in orbit: orbit[y]=lr; queue.append(y) | |
| for u in b.Rg: | |
| meter.tick('group_operations',2) | |
| y,lr = mt[x][u],(l,mt[r][u]) | |
| if y not in orbit: orbit[y]=lr; queue.append(y) | |
| best,pair = INF,None | |
| for i in reps: | |
| meter.tick('group_operations'); j = mt[g.inv[i]][z] | |
| if a.costs[i]>=INF or b.costs[j]>=INF: continue | |
| meter.candidate(); value = a.costs[i]+b.costs[j] | |
| if value<best: best,pair=value,(i,j) | |
| for x,(l,r) in orbit.items(): | |
| meter.tick('witness_materialization') | |
| if pair is not None: | |
| meter.tick('group_operations',2) | |
| c[x],sp[x] = best,(mt[l][pair[0]],mt[pair[1]][r]) | |
| remaining.difference_update(orbit) | |
| audit['quotient_compositions'] = audit.get('quotient_compositions',0)+1 | |
| elif kind == 'fast' and a.support and b.support: | |
| # Per-output early stop at a certified lower bound, using smaller support. | |
| floor = min(a.costs)+min(b.costs); meter.tick('minimum_scan',2*n) | |
| leftsmall = len(a.support)<=len(b.support) | |
| for z in range(n): | |
| for q in (a.support if leftsmall else b.support): | |
| meter.tick('group_operations') | |
| i,j = (q,mt[g.inv[q]][z]) if leftsmall else (mt[z][g.inv[q]],q) | |
| if a.costs[i]>=INF or b.costs[j]>=INF: continue | |
| meter.candidate(); value=a.costs[i]+b.costs[j] | |
| if value<c[z]: c[z],sp[z]=value,(i,j) | |
| if value==floor: break | |
| else: | |
| for i in a.support: | |
| for j in b.support: | |
| meter.tick('group_operations'); z=mt[i][j] | |
| meter.candidate(); value=a.costs[i]+b.costs[j] | |
| if value<c[z]: c[z],sp[z]=value,(i,j) | |
| k = inherited(Kernel(word,tuple(c),tuple(sp),a,b, | |
| generation=1+max(a.generation,b.generation)),a,b) | |
| # Check every stored local witness. The unchanged convolution code is trusted | |
| # for optimality; an independent sequential oracle audits outcomes externally. | |
| for z,pair in enumerate(sp): | |
| meter.tick('local_witness_validation') | |
| if pair is not None: | |
| i,j=pair | |
| if mt[i][j]!=z or a.costs[i]+b.costs[j]!=c[z]: | |
| raise AssertionError('invalid transported witness') | |
| return finish(k,g,meter,discover,audit) | |
| def verify(word,target,choices,cost,types,g,meter): | |
| meter.tick('role_validation',len(word)) | |
| if choices is None: return cost>=INF | |
| if len(choices)!=len(word): return False | |
| z,total=0,0 | |
| for tid,j in zip(word,choices): | |
| meter.tick('solution_validation',3) | |
| if not isinstance(j,int) or not 0<=j<len(types[tid]): return False | |
| d,c=types[tid][j]; z=g.mul[z][d]; total+=c | |
| return z==target and total==cost | |
| class Compiler: | |
| def __init__(self,g,types,meter,mode): | |
| self.g,self.types,self.meter,self.mode=g,types,meter,mode | |
| self.audit={}; self.cache={}; self.trie={} | |
| meter.tick('fixed_group_table',g.n*g.n+g.n) | |
| learned = mode in ('recursive','symmetry_reference','flat','closed') | |
| for tid,opts in enumerate(types): | |
| self.insert(leaf(tid,opts,g,meter,learned,self.audit)) | |
| def insert(self,k,charge=True): | |
| if charge:self.meter.tick('dictionary_hash',len(k.word)) | |
| self.cache[k.word]=k; node=self.trie | |
| for t in k.word: | |
| if charge:self.meter.tick('dictionary_insert') | |
| node=node.setdefault(t,{}) | |
| node[None]=k | |
| def plan(self,word): | |
| n=len(word); best=[10**9]*(n+1); paths=[None]*(n+1); best[n]=0 | |
| self.meter.tick('parse_allocation',2*(n+1)) | |
| for i in range(n-1,-1,-1): | |
| node=self.trie | |
| for j in range(i,n): | |
| self.meter.tick('parse_lookup') | |
| node=node.get(word[j]) | |
| if node is None: break | |
| if None in node: | |
| self.meter.tick('parse_comparison') | |
| if 1+best[j+1]<best[i]: best[i],paths[i]=1+best[j+1],(j+1,node[None]) | |
| out=[]; i=0 | |
| while i<n: | |
| j,k=paths[i];out.append(k);i=j | |
| self.audit['planned_atoms']=self.audit.get('planned_atoms',0)+len(out) | |
| return out | |
| def acquire(self,word): | |
| # Flat acquisition never uses learned atoms; it may retain exact whole-word | |
| # results, but learned results cannot assist new operator construction. | |
| if self.mode=='flat': | |
| self.meter.tick('flat_leaf_access',len(word)) | |
| parts=[self.cache[(t,)] for t in word] | |
| else: parts=self.plan(word) | |
| if len(parts)==1: return parts[0] | |
| kind='symmetry' if self.mode in ('recursive','symmetry_reference','static','flat','closed') else ('fast' if self.mode=='fast' else 'dense') | |
| discover=self.mode in ('recursive','symmetry_reference','flat','closed') | |
| made=[]; root=parts[0] | |
| for k in parts[1:]: | |
| root=compose(root,k,self.g,self.meter,kind,discover,self.audit);made.append(root) | |
| # Commit is delayed until the acquisition succeeds within budget. | |
| persist=made if self.mode not in ('frozen','flat') else ([root] if self.mode=='flat' else []) | |
| pending=[] | |
| for k in persist: | |
| if self.mode=='closed': | |
| self.meter.tick('closed_summary_projection',self.g.n) | |
| costs=tuple(c if z==0 else INF for z,c in enumerate(k.costs)) | |
| k=Kernel(k.word,costs,k.split,k.left,k.right,support=(0,) if costs[0]<INF else (),generation=k.generation) | |
| pending.append(k) | |
| # Precharge the whole transaction before publishing any dictionary change. | |
| nkeys=sum(len(k.word) for k in pending) | |
| self.meter.tick('dictionary_hash',nkeys);self.meter.tick('dictionary_insert',nkeys) | |
| for k in pending:self.insert(k,False) | |
| return root | |
| def memory_slots(self): | |
| # Count every retained DAG node, including uncached ancestors of flat roots. | |
| stack=list(self.cache.values());seen=set();slots=0 | |
| while stack: | |
| k=stack.pop() | |
| if id(k) in seen:continue | |
| seen.add(id(k)) | |
| slots+=len(k.word)+len(k.costs)+len(k.support)+2*len(k.options) | |
| slots+=sum(2 if isinstance(x,tuple) else 1 for x in k.split) | |
| slots+=len(k.L)+len(k.R)+len(k.Lg)+len(k.Rg) | |
| if k.left is not None:stack.extend((k.left,k.right)) | |
| return slots | |
| def solve(self,word,target): | |
| k=self.acquire(word); cost=k.costs[target] | |
| choices=k.choices(target,self.meter) if cost<INF else None | |
| if not verify(word,target,choices,cost,self.types,self.g,self.meter): | |
| raise AssertionError('role/witness failure') | |
| return cost | |
| def sequential(word,target,types,g,meter): | |
| """Strong single-target DP: no all-boundary work at its final position.""" | |
| prev=[INF]*g.n;prev[0]=0;history=[] | |
| for pos,tid in enumerate(word): | |
| cur=[INF]*g.n;tr=[None]*g.n;meter.tick('array_allocation',2*g.n) | |
| if pos==len(word)-1: | |
| for j,(d,c) in enumerate(types[tid]): | |
| meter.tick('group_operations');a=g.mul[target][g.inv[d]] | |
| if prev[a]>=INF:continue | |
| meter.candidate();v=prev[a]+c | |
| if v<cur[target]:cur[target],tr[target]=v,(a,j) | |
| else: | |
| for a,old in enumerate(prev): | |
| if old>=INF:continue | |
| for j,(d,c) in enumerate(types[tid]): | |
| meter.tick('group_operations');z=g.mul[a][d] | |
| meter.candidate();v=old+c | |
| if v<cur[z]:cur[z],tr[z]=v,(a,j) | |
| history.append(tr);prev=cur | |
| if prev[target]>=INF:return INF | |
| choices=[];z=target | |
| for tr in reversed(history): | |
| meter.tick('witness_traversal');z,j=tr[z];choices.append(j) | |
| choices.reverse() | |
| if not verify(word,target,choices,prev[target],types,g,meter):raise AssertionError('DP witness') | |
| return prev[target] | |
| def make_world(seed,m,condition): | |
| rng=random.Random(seed);g=Group(m);types=[] | |
| for t in range(12): | |
| if condition=='structured': | |
| # An automorphic copy of f: zero on >half of the rotations, one unique | |
| # cheap reflection, and M elsewhere. f*f has the rotation stabilizer. | |
| u=rng.choice([x for x in range(1,m) if math.gcd(x,m)==1]);v=rng.randrange(m) | |
| w=rng.randrange(1,4);M=11 | |
| zero={(u*i)%m for i in range(m//2+1)} | |
| costs=[0 if x in zero else (w if x==m+v else M) for x in range(g.n)] | |
| elif condition=='asymmetric': | |
| costs=rng.sample(range(1,8*g.n+1),g.n) | |
| else: | |
| S=set(rng.sample(range(g.n),g.n//2+1)) | |
| costs=[0 if x in S else INF for x in range(g.n)] | |
| types.append(tuple((x,c) for x,c in enumerate(costs) if c<INF)) | |
| train=[((t,t),rng.randrange(g.n)) for t in range(12)] | |
| seen={w for w,b in train};test=[] | |
| for length in (4,8,16,32): | |
| for _ in range(6): | |
| while True: | |
| # Fresh full words; repeated role pairs are intentionally disclosed. | |
| labels=[rng.randrange(12) for _ in range(length//2)] | |
| word=tuple(x for t in labels for x in (t,t)) | |
| if word not in seen:break | |
| seen.add(word);test.append((word,rng.randrange(g.n))) | |
| return g,types,train,test | |
| def run_case(seed,m,condition,budget): | |
| g,types,train,test=make_world(seed,m,condition) | |
| # Independent immutable oracle is shared experimental infrastructure. Its cost | |
| # is recorded, and an equal share is added to every method's total-cost figure. | |
| oracle=Meter();start=time.perf_counter_ns() | |
| truth=[sequential(w,b,types,g,oracle) for w,b in train+test] | |
| oracle_ns=time.perf_counter_ns()-start | |
| methods=('recursive','dense','fast','static','frozen','flat','closed','sequential','symmetry_reference') | |
| rows=[];summaries=[] | |
| for method in methods: | |
| meter=Meter(budget);start=time.perf_counter_ns();compiler=None | |
| if method!='sequential':compiler=Compiler(g,types,meter,method) | |
| else:meter.tick('fixed_group_table',g.n*g.n+g.n) | |
| init_work=meter.total;correct=wrong=exhausted=0;train_work=0 | |
| for i,(word,target) in enumerate(train+test): | |
| before=meter.total;tick=time.perf_counter_ns();status='ok';cost=None | |
| try: | |
| cost=sequential(word,target,types,g,meter) if method=='sequential' else compiler.solve(word,target) | |
| if cost!=truth[i]:status='wrong';wrong+=1 | |
| elif i>=len(train):correct+=1 | |
| except Exhausted:status='budget';exhausted+=1 | |
| rows.append(dict(seed=seed,condition=condition,method=method,index=i, | |
| phase='train' if i<len(train) else 'fresh',length=len(word),target=target, | |
| work=meter.total-before,ns=time.perf_counter_ns()-tick,status=status, | |
| cost=cost,oracle_cost=truth[i])) | |
| if i==len(train)-1:train_work=meter.total | |
| if status=='budget': | |
| exhausted+=len(train)+len(test)-i-1;break | |
| elapsed=time.perf_counter_ns()-start | |
| summaries.append(dict(seed=seed,condition=condition,method=method,work=meter.total, | |
| total_with_shared_oracle=meter.total+oracle.total,wall_ns=elapsed, | |
| setup_work=init_work,training_work=train_work,fresh_correct=correct,fresh_total=len(test), | |
| wrong=wrong,budget_failures=exhausted,counters=meter.counts, | |
| kernels=len(compiler.cache) if compiler else 0, | |
| scalar_slots=compiler.memory_slots() if compiler else 0, | |
| audit=compiler.audit if compiler else {})) | |
| return dict(seed=seed,condition=condition,oracle_work=oracle.total,oracle_ns=oracle_ns, | |
| training_words=[list(w) for w,b in train],fresh_words=[list(w) for w,b in test], | |
| summaries=summaries,rows=rows) | |
| def causal_probe(seed,m): | |
| """A strict subgroup ladder: each newly acquired kernel changes its values.""" | |
| if m & (m-1):raise ValueError('causal ladder requires a power-of-two rotation order') | |
| g=Group(m);rng=random.Random(seed);types=[] | |
| u=rng.choice(range(1,m,2));v=rng.randrange(m);c=rng.randrange(1,4);M=11 | |
| for j in range(1,m.bit_length()): | |
| step=m//(2**j);S={(u*step*i)%m for i in range(2**(j-1)+1)} | |
| costs=[0 if x in S else (c if x==m+v else M) for x in range(g.n)] | |
| types.append(tuple(enumerate(costs))) | |
| out=[] | |
| for arm in ('learned','erased','inherited','static'): | |
| meter=Meter();audit={} | |
| leaves=[leaf(t,types[t],g,meter,True,audit) for t in range(len(types))] | |
| a=compose(leaves[0],leaves[0],g,meter,'dense',True,audit) | |
| acquisition_a=meter.total | |
| if arm in ('erased','static'):a.L=a.R=frozenset({0});a.Lg=a.Rg=() | |
| stages=[] | |
| for j,b in enumerate(leaves[1:],start=2): | |
| before=meter.total;old=meter.counts.get('candidate_additions',0) | |
| prior=a.costs | |
| a=compose(a,b,g,meter,'symmetry',arm in ('learned','erased'),audit) | |
| checkmeter=Meter();reference=compose(leaves[j-1],leaves[j-1],g,checkmeter,'dense') | |
| assert a.costs==reference.costs and a.costs!=prior | |
| stages.append(dict(stage='h'+str(j),work=meter.total-before, | |
| candidates=meter.counts.get('candidate_additions',0)-old, | |
| L=len(a.L),R=len(a.R),changed_kernel=True,costs=list(a.costs))) | |
| out.append(dict(seed=seed,arm=arm,acquisition_A_including_leaves=acquisition_a,stages=stages)) | |
| return out | |
| def self_checks(m): | |
| g=Group(m);meter=Meter();audit={};rng=random.Random(991) | |
| # Noncommutative witness transport, including finite/infinite random kernels. | |
| checked=0 | |
| for _ in range(20): | |
| types=[tuple((z,rng.randrange(5)) for z in range(g.n) if rng.random()<.7) for j in range(2)] | |
| a,b=[leaf(t,types[t],g,meter,True,audit) for t in range(2)] | |
| d=compose(a,b,g,meter,'dense');s=compose(a,b,g,meter,'symmetry',True,audit) | |
| assert d.costs==s.costs | |
| for z in s.support: | |
| assert verify((0,1),z,s.choices(z,meter),s.costs[z],types,g,meter) | |
| checked+=1 | |
| # Non-normal reflection subgroup exercises orientation and witness transport. | |
| H=(0,g.m) | |
| types=[tuple((z,0 if z in H else 7) for z in range(g.n)) for _ in range(2)] | |
| a,b=[leaf(t,types[t],g,meter,True,audit) for t in range(2)] | |
| d=compose(a,b,g,meter,'dense');s=compose(a,b,g,meter,'symmetry',True,audit) | |
| assert d.costs==s.costs and len(a.L)==2 | |
| assert any(g.mul[g.mul[x][g.m]][g.inv[x]] not in H for x in range(g.n)) | |
| for z in s.support:assert verify((0,1),z,s.choices(z,meter),s.costs[z],types,g,meter) | |
| g,types,_,_=make_world(1,m,'structured') | |
| a=leaf(0,types[0],g,meter,True,audit);b=compose(a,a,g,meter,'symmetry',True,audit) | |
| assert len(a.L)==len(a.R)==1 and len(b.L)==len(b.R)==m | |
| assert len(set(b.costs[:m]))==1 and len(set(b.costs[m:]))==1 and b.costs[0]<b.costs[m] | |
| # A two-role closed solution cannot be replaced by a one-role identity claim. | |
| toy=[((g.m,1),)] | |
| collapsed_valid=verify((0,0),0,[0],1,toy,g,meter) | |
| # Ordered composition is observably noncommutative in a dihedral group. | |
| order_sensitive=g.mul[1][g.m]!=g.mul[g.m][1] | |
| assert not collapsed_valid and order_sensitive | |
| return dict(random_kernel_equivalence_checks=checked,emergent_stabilizers=[len(a.L),len(b.L)], | |
| role_collapse_rejected=not collapsed_valid,order_sensitive=order_sensitive,nonnormal_subgroup_checked=True, | |
| validation_work=meter.total) | |
| def main(): | |
| parser=argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument('--seeds',default='1:4',help='half-open START:STOP or comma list') | |
| parser.add_argument('--order',type=int,default=16,help='rotation order; group size is twice this') | |
| parser.add_argument('--budget',type=int,default=2000000) | |
| parser.add_argument('--output',default='dev_results') | |
| args=parser.parse_args() | |
| seeds=list(range(*map(int,args.seeds.split(':')))) if ':' in args.seeds else list(map(int,args.seeds.split(','))) | |
| checks=self_checks(args.order);results=[];probes=[] | |
| for seed in seeds: | |
| for condition in ('structured','asymmetric','constant'): | |
| results.append(run_case(seed,args.order,condition,args.budget)) | |
| probes.extend(causal_probe(seed,args.order)) | |
| payload=dict(source_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), | |
| parameters=vars(args),operation_unit='sum of all labeled counters; timing includes instrumentation', | |
| oracle_accounting='shared oracle reported separately and added equally; algorithm budget excludes shared oracle', | |
| checks=checks,results=results,two_hop=probes, | |
| reduction='symmetry_reference is exactly the same algorithm as recursive; no novelty or superiority claim over it') | |
| out=Path(args.output);out.mkdir(parents=True,exist_ok=True) | |
| (out/'results.json').write_text(json.dumps(payload,indent=2)) | |
| rows=[row for r in results for row in r['rows']] | |
| with (out/'tasks.csv').open('w',newline='') as f: | |
| w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows) | |
| for condition in ('structured','asymmetric','constant'): | |
| print(condition) | |
| for method in ('recursive','dense','fast','static','frozen','flat','closed','sequential','symmetry_reference'): | |
| ss=[s for r in results if r['condition']==condition for s in r['summaries'] if s['method']==method] | |
| print(method,'work',round(sum(s['work'] for s in ss)/len(ss)), | |
| 'fresh',sum(s['fresh_correct'] for s in ss),'/',sum(s['fresh_total'] for s in ss), | |
| 'wrong',sum(s['wrong'] for s in ss)) | |
| print('source_sha256',payload['source_sha256']);print('two_hop',json.dumps(probes[0:3])) | |
| if __name__=='__main__':main() | |