File size: 24,894 Bytes
dc7349e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
#!/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

@dataclass
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))

@dataclass
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()