#!/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()