#!/usr/bin/env python3
"""Certified generative pruning (CGP), a bounded symbolic self-improver.

Only the finite candidate-generator automaton is rewritten. Primitive task
semantics, proof checking, objectives, and evaluator are outside that interface.
Python 3.10+; standard library only. No network, subprocess, eval, or exec.
"""
from __future__ import annotations
from collections import deque
from dataclasses import dataclass
import hashlib, json, random, time

Word = tuple[int, ...]
Map = tuple[int, ...]


def family(seed: int, n: int = 8) -> tuple[Map, ...]:
    """Cycle, its inverse, and two adjacent transpositions in a random cycle.

    The alphabet order varies by seed. These generate S_n; no laws are seeded.
    """
    rng = random.Random(seed)
    order = list(range(n)); rng.shuffle(order)
    cycle = list(range(n))
    for i in range(n): cycle[order[i]] = order[(i+1) % n]
    inverse = [0]*n
    for i,j in enumerate(cycle): inverse[j] = i
    swaps = []
    for i in rng.sample(range(n), 2):
        p = list(range(n)); a,b = order[i],order[(i+1)%n]
        p[a],p[b] = p[b],p[a]; swaps.append(tuple(p))
    gs = [tuple(cycle),tuple(inverse),*swaps]; rng.shuffle(gs)
    return tuple(gs)


def ref_eval(word: Word, generators: tuple[Map,...]) -> Map:
    """Independent exact checker: run every boundary input instruction by instruction."""
    n = len(generators[0]); out = []
    for initial in range(n):
        x = initial
        for symbol in word:
            if type(symbol) is not int or not 0 <= symbol < len(generators):
                raise ValueError('invalid instruction')
            x = generators[symbol][x]
        out.append(x)
    return tuple(out)


def shortlex(w: Word) -> tuple:
    return len(w), w


@dataclass(frozen=True)
class Rule:
    lhs: Word
    rhs: Word

    def export(self) -> dict:
        return {'lhs':list(self.lhs),'rhs':list(self.rhs)}


def check_rule(rule: Rule, generators: tuple[Map,...]) -> bool:
    if not rule.lhs or shortlex(rule.rhs) >= shortlex(rule.lhs): return False
    try:
        return ref_eval(rule.lhs,generators) == ref_eval(rule.rhs,generators)
    except (ValueError, IndexError, TypeError):
        return False


class Guard:
    """Aho-Corasick automaton rejecting any certified left-hand-side factor."""
    def __init__(self, forbidden: list[Word], alphabet: int):
        self.alphabet = alphabet
        edges = [{}]; terminal = [False]; self.prefixes = [()]
        for word in forbidden:
            state = 0
            for symbol in word:
                if symbol not in edges[state]:
                    edges[state][symbol] = len(edges)
                    edges.append({}); terminal.append(False)
                    self.prefixes.append(self.prefixes[state]+(symbol,))
                state = edges[state][symbol]
            terminal[state] = True
        self.next = [[0]*alphabet for _ in edges]
        fail = [0]*len(edges)
        q = deque()
        for symbol,state in edges[0].items():
            self.next[0][symbol] = state; q.append(state)
        while q:
            state=q.popleft(); terminal[state] |= terminal[fail[state]]
            for symbol in range(alphabet):
                if symbol in edges[state]:
                    child=edges[state][symbol]
                    fail[child]=self.next[fail[state]][symbol]
                    self.next[state][symbol]=child; q.append(child)
                else:
                    self.next[state][symbol]=self.next[fail[state]][symbol]
        self.bad = terminal

    def scan(self, word: Word) -> int | None:
        state=0
        for symbol in word:
            state=self.next[state][symbol]
            if self.bad[state]: return None
        return state

    def digest(self) -> str:
        raw=json.dumps([self.next,self.bad],separators=(',',':')).encode()
        return hashlib.sha256(raw).hexdigest()


class Improver:
    def __init__(self, generators: tuple[Map,...], rules: list[Rule] | None=None,
                 semantic_dedup: bool=False):
        if not generators or len({len(g) for g in generators}) != 1:
            raise ValueError('incompatible primitive maps')
        n=len(generators[0])
        if any(any(type(x) is not int or not 0 <= x < n for x in g) for g in generators):
            raise ValueError('map outside finite domain')
        self.generators=generators
        self.rules=list(rules or [])
        if not all(check_rule(r,generators) for r in self.rules):
            raise ValueError('unverified initial rule')
        self.guard=Guard([r.lhs for r in self.rules],len(generators))
        ident=tuple(range(n))
        self.frontier=deque([((),ident,0)])
        self.best={ident:()}
        self.seen_for_queue={ident}
        self.pending: dict[Word,Rule]={}
        self.semantic_dedup=semantic_dedup
        self.stats={'popped':0,'semantic_products':0,'guard_probes':0,
                    'guard_rejections':0,'queue_filtered':0,'rules_checked':0,
                    'checker_instruction_steps':0,'rebuild_scan_steps':0,
                    'peak_queue':1,'installations':0,'independent_checks':0}

    def advance(self, expansions: int, product_budget: int | None=None) -> dict:
        before=len(self.best); p0=self.stats['popped']; t=time.perf_counter()
        g=self.guard; gs=self.generators
        product_start=self.stats['semantic_products']
        for _ in range(expansions):
            if not self.frontier: break
            if product_budget is not None and self.stats['semantic_products']-product_start >= product_budget: break
            word,signature,state=self.frontier.popleft(); self.stats['popped']+=1
            for symbol,primitive in enumerate(gs):
                self.stats['guard_probes']+=1
                ns=g.next[state][symbol]
                if g.bad[ns]:
                    self.stats['guard_rejections']+=1; continue
                child=word+(symbol,)
                value=tuple(primitive[x] for x in signature)
                self.stats['semantic_products']+=1
                previous=self.best.get(value)
                if previous is None:
                    self.best[value]=child
                elif shortlex(child) < shortlex(previous):
                    self.best[value]=child
                    self.pending.setdefault(previous,Rule(previous,child))
                elif child != previous:
                    self.pending.setdefault(child,Rule(child,previous))
                if self.semantic_dedup:
                    if value in self.seen_for_queue: continue
                    self.seen_for_queue.add(value)
                self.frontier.append((child,value,ns))
            self.stats['peak_queue']=max(self.stats['peak_queue'],len(self.frontier))
        return {'new_semantics':len(self.best)-before,
                'expansions':self.stats['popped']-p0,
                'wall_seconds':time.perf_counter()-t,
                'known_semantics':len(self.best),'queue':len(self.frontier),
                'semantic_products':self.stats['semantic_products']-product_start}

    def install(self, max_rules: int=600) -> dict:
        """Select sound shortest obstructions; rebuild and replace search-control code.

        Selection is data-driven, deterministic. No hardcoded semantic identities.
        Old forbidden languages are retained; this gives monotone pruning.
        """
        start=time.perf_counter(); old=self.guard.digest(); accepted=[]
        room=max_rules-len(self.rules)
        # Pending laws with a previously forbidden factor cannot add pruning.
        pending=sorted(self.pending.values(),key=lambda r:shortlex(r.lhs))
        self.pending={}
        trial_lhs=[r.lhs for r in self.rules]
        trial=self.guard
        new_lefts=set()
        for rule in pending:
            if len(accepted)>=room: break
            if self.guard.scan(rule.lhs) is None: continue
            if any(rule.lhs[i:j] in new_lefts
                   for i in range(len(rule.lhs))
                   for j in range(i+1,len(rule.lhs)+1)): continue
            self.stats['rules_checked']+=1
            self.stats['checker_instruction_steps']+=len(self.generators[0])*(len(rule.lhs)+len(rule.rhs))
            if not check_rule(rule,self.generators):
                raise AssertionError('untrusted proposal failed verification')
            accepted.append(rule); trial_lhs.append(rule.lhs); new_lefts.add(rule.lhs)
        if accepted:
            self.rules.extend(accepted)
            trial=Guard(trial_lhs,len(self.generators))
            from verifier import verify
            candidate={'generators':self.generators,
                       'rules':[r.export() for r in self.rules],
                       'guard':{'transition':trial.next,'reject':trial.bad,
                                'prefixes':trial.prefixes,'sha256':trial.digest()}}
            receipt=verify(candidate)
            if not receipt['accepted']:
                self.rules=self.rules[:-len(accepted)]
                raise AssertionError('independent checker rejected update: '+str(receipt))
            self.stats['independent_checks']+=1
            self.guard=trial
            filtered=deque()
            for word,value,_ in self.frontier:
                self.stats['rebuild_scan_steps']+=len(word)
                ns=trial.scan(word)
                if ns is not None: filtered.append((word,value,ns))
                else: self.stats['queue_filtered']+=1
            self.frontier=filtered; self.stats['installations']+=1
        return {'accepted':len(accepted),'rules_total':len(self.rules),
                'automaton_states':len(self.guard.next),'before_hash':old,
                'after_hash':self.guard.digest(),
                'wall_seconds':time.perf_counter()-start}

    def export(self) -> dict:
        return {'generators':[list(x) for x in self.generators],
                'rules':[r.export() for r in self.rules],
                'guard':{'transition':self.guard.next,'reject':self.guard.bad,
                         'prefixes':[list(p) for p in self.guard.prefixes],
                         'sha256':self.guard.digest()},
                'stats':self.stats.copy(),'known_semantics':len(self.best)}


def train(seed: int, n: int=8, rounds: int=8, batch: int=300,
          mode: str='recursive', max_rules: int=600, product_batches: bool=False) -> tuple[Improver,list[dict]]:
    if mode not in {'recursive','frozen','oneshot','semantic_bfs','recursive_bfs','oneshot_bfs'}:
        raise ValueError('unknown mode')
    engine=Improver(family(seed,n),semantic_dedup=(mode in {'semantic_bfs','recursive_bfs','oneshot_bfs'}))
    records=[]
    for generation in range(rounds):
        growth=engine.advance(100000,product_budget=batch) if product_batches else engine.advance(batch)
        if mode in {'recursive','recursive_bfs'} or (mode in {'oneshot','oneshot_bfs'} and generation==0):
            upgrade=engine.install(max_rules)
        else:
            # Pending rules may be kept as data in a frozen control; they do not
            # change the generator. Clear to avoid irrelevant memory accumulation.
            engine.pending={}; upgrade={'accepted':0,'wall_seconds':0.0,
                                        'rules_total':len(engine.rules)}
        records.append({'generation':generation+1,'growth':growth,'upgrade':upgrade})
    return engine,records


if __name__=='__main__':
    for mode in ['frozen','oneshot','recursive','semantic_bfs']:
        t=time.perf_counter(); e,h=train(7101,mode=mode)
        print(mode,round(time.perf_counter()-t,4),len(e.best),len(e.rules),
              [r['growth']['known_semantics'] for r in h],
              [r['upgrade']['accepted'] for r in h])


def cold_search(generators: tuple[Map,...], rules: list[Rule], expansions: int,
                dedup: bool=False, product_budget: int | None=None, wall_budget: float | None=None) -> dict:
    """Task deployment: no proof mining or pending-law overhead in either control.

    For dedup=True this is conventional semantic BFS with an optimized inner loop,
    not a deliberately slowed variant of the self-improver.
    Construction of the supplied automaton is included in measured deployment time.
    """
    t=time.perf_counter(); ident=tuple(range(len(generators[0])))
    best={ident:()}; products=0; probes=0; popped=0; peak=1
    if dedup and not rules:
        todo=deque([(ident,())])
        while todo and popped < expansions:
            if product_budget is not None and products>=product_budget: break
            if wall_budget is not None and time.perf_counter()-t>=wall_budget: break
            signature,word=todo.popleft(); popped+=1
            for a,g in enumerate(generators):
                value=tuple(g[x] for x in signature); products+=1
                if value not in best:
                    child=word+(a,);best[value]=child;todo.append((value,child))
            peak=max(peak,len(todo))
        states=0
    else:
        guard=Guard([r.lhs for r in rules],len(generators)); states=len(guard.next)
        todo=deque([(ident,(),0)])
        while todo and popped < expansions:
            if product_budget is not None and products>=product_budget: break
            if wall_budget is not None and time.perf_counter()-t>=wall_budget: break
            signature,word,state=todo.popleft(); popped+=1
            for a,g in enumerate(generators):
                probes+=1; ns=guard.next[state][a]
                if guard.bad[ns]: continue
                value=tuple(g[x] for x in signature);products+=1
                child=word+(a,)
                if value not in best:
                    best[value]=child;todo.append((value,child,ns))
                elif not dedup:todo.append((value,child,ns))
            peak=max(peak,len(todo))
    return {'known_semantics':len(best),'semantic_products':products,'popped':popped,
            'guard_probes':probes,'automaton_states':states,'peak_queue':peak,
            'wall_seconds':time.perf_counter()-t,'best':best}