"""Exact finite checks; not a proof-assistant formalization.
Run from any directory: python tests/verify_release.py
"""
from pathlib import Path
import sys, json, csv, math, random, time, hashlib
from collections import Counter
from itertools import permutations, product
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT/'src'))
from osec import ErasureSystem, sign, dnf_value, is_subsequence
RESULTS=[]
def record(name,detail):
    RESULTS.append({'test':name,'status':'PASS',**detail})
    print(f'PASS {name}: {detail}',flush=True)

def verify_axioms():
    for n in (2,3,4):
        s=ErasureSystem(n);checks=0
        for state in range(s.full+1):
            for a in s.actions:
                out=s.erase(state,a)
                assert out & ~state == 0
                assert s.erase(out,a)==out
                checks+=2
                absent=s.full ^ state
                while absent:
                    bit=absent & -absent
                    assert out & ~s.erase(state|bit,a)==0
                    absent-=bit;checks+=1
        record('operator_axioms',{'n':n,'all_states':s.full+1,'assertions':checks})

def verify_protocols():
    rows=[]
    for n in range(2,9):
        s=ErasureSystem(n);seen=[set() for _ in range(n+1)];counts=[0]*(n+1)
        def visit(state,word,left):
            k=len(word);counts[k]+=1;seen[k].add(state)
            position={i:j for j,i in enumerate(word)};expected=s.full
            for i in word:expected &= ~s.marker(0,i)
            for i in word:
                for j in word:
                    if position[j]<position[i]:expected &= ~s.rail(0,i,j)
            assert expected==state
            assert state.bit_count()==n*n-k*(k+1)//2
            rails=s.parity_rails(state)
            if k<n:assert rails==(True,True)
            else:
                eps=sign(word);assert rails==(eps==1,eps==-1)
            for i in left:visit(s.erase(state,(0,i)),word+(i,),tuple(j for j in left if j!=i))
        visit(s.full,(),tuple(range(n)))
        assert all(len(seen[k])==counts[k]==math.factorial(n)//math.factorial(n-k) for k in range(n+1))
        assert s.parity_rails(0)==(False,False)
        detail={'n':n,'ordered_partial_words':sum(counts),'complete_orders':counts[-1],
                'distinct_protocol_states':sum(counts),'cells':s.cells,'binary_observer_gates':6*(s.pair_count-1)}
        record('all_distinct_action_protocols',detail);rows.append(detail)
    with (ROOT/'results/protocol_counts.csv').open('w',newline='') as f:
        w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)

def verify_universal():
    s=ErasureSystem(3);pp=list(permutations(range(3)));states=[s.saturated([p]) for p in pp]
    for subset in range(1<<len(pp)):
        accepted=[p for k,p in enumerate(pp) if subset>>k&1]
        terms=[states[k] for k in range(len(pp)) if subset>>k&1]
        for k in range(4):
            for word in permutations(range(3),k):
                state=s.run([(0,i) for i in word])[-1]
                assert dnf_value(state,terms)==any(is_subsequence(word,p) for p in accepted)
    record('universal_classifier_and_subsequence_formula',{'n':3,'all_classifiers':64,'partial_words_per_classifier':16})

def verify_guard_optimum():
    rows=[]
    for n in (2,3,4):
        s=ErasureSystem(n);pp=list(permutations(range(n)))
        ends=[s.saturated([p]) >> n for p in pp]
        plus=[a for a,p in zip(ends,pp) if sign(p)==1]
        minus=[a for a,p in zip(ends,pp) if sign(p)==-1]
        feasible=[];universal=[];r=n*(n-1)
        for mask in range(1<<r):
            pe=[a&mask for a in plus];me=[a&mask for a in minus]
            if all(a&b!=a for a in pe for b in me):feasible.append(mask)
            allends=[a&mask for a in ends]
            if all(a&b!=a for i,a in enumerate(allends) for j,b in enumerate(allends) if i!=j):universal.append(mask)
        minimum=min(x.bit_count() for x in feasible)
        assert minimum=={2:1,3:3,4:12}[n]
        assert len(feasible)=={2:2,3:8,4:1}[n]
        assert len(universal)==1 and universal[0]==(1<<r)-1
        detail={'n':n,'guard_architectures_checked':1<<r,'parity_feasible':len(feasible),
                'minimum_order_rails':minimum,'minimum_total_cells':n+minimum,'universal_feasible':len(universal)}
        record('sharp_pair_guard_optimum',detail);rows.append(detail)
    with (ROOT/'results/guard_optimality.csv').open('w',newline='') as f:
        w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
    s=ErasureSystem(3);cycle=[s.rail(0,0,1),s.rail(0,1,2),s.rail(0,2,0)]
    init=sum(s.marker(0,i) for i in range(3))|sum(cycle)
    assert init.bit_count()==6
    def f(x):return sum(bool(x&r) for r in cycle)>=2
    data=[]
    for p in permutations(range(3)):
        states=[init]
        for i in p:states.append(s.erase(states[-1],(0,i)))
        states.append(0);obs=[int(f(x)) for x in states]
        assert obs==[1,1,1,int(sign(p)==1),0]
        data.append({'order':''.join('ABC'[i] for i in p),'sign':sign(p),
                     'cell_counts':[x.bit_count() for x in states],'observation':obs,'extinction':obs.index(0)})
    (ROOT/'results/sharp_triad.json').write_text(json.dumps(data,indent=2)+'\n')
    record('six_cell_sharp_triad',{'complete_orders':6,'initial_cells':6})

def verify_tensor_guard_optimum():
    for n,m in [(2,2),(2,3),(3,2)]:
        s=ErasureSystem(n,m);pp=list(permutations(range(n)))
        tuples=list(product(pp,repeat=m))
        rb=[s.rail(b,i,j) for b in range(m) for i in range(n) for j in range(n) if i!=j]
        ends=[s.saturated(ps) for ps in tuples]
        compressed=[sum((1<<k) for k,bit in enumerate(rb) if state&bit) for state in ends]
        signs=[math.prod(sign(p) for p in ps) for ps in tuples]
        plus=[a for a,eps in zip(compressed,signs) if eps==1]
        minus=[a for a,eps in zip(compressed,signs) if eps==-1]
        feasible=[]
        for mask in range(1<<len(rb)):
            if all((a&mask)&(b&mask)!=(a&mask) for a in plus for b in minus):feasible.append(mask)
        assert feasible==[(1<<len(rb))-1]
        record('tensor_sharp_guard_optimum',{'n':n,'blocks':m,
            'all_guard_architectures':1<<len(rb),'feasible_architectures':1,
            'minimum_order_rails':len(rb),'minimum_total_cells':s.cells})

def verify_dnf():
    rows=[]
    for n,m in [(2,1),(3,1),(4,1),(3,2)]:
        s=ErasureSystem(n,m);pp=list(permutations(range(n)));tuples=list(product(pp,repeat=m))
        states=[s.saturated(ps) for ps in tuples];signs=[math.prod(sign(p) for p in ps) for ps in tuples]
        rb=[s.rail(b,i,j) for b in range(m) for i in range(n) for j in range(n) if i!=j]
        minimal=[];implicants={}
        for small in range(1<<len(rb)):
            mask=sum(bit for k,bit in enumerate(rb) if small>>k&1)
            matched=[i for i,state in enumerate(states) if state&mask==mask]
            if matched and all(signs[i]==1 for i in matched):
                assert len(matched)==1;implicants[small]=matched[0]
                if all((small^(1<<j)) not in implicants for j in range(len(rb)) if small>>j&1):minimal.append(small)
        assert len(minimal)==math.factorial(n)**m//2
        assert all(x.bit_count()==m*(n-1) for x in minimal)
        for ps,eps,state in zip(tuples,signs,states):
            if eps==1:
                chain=s.chain_certificate(ps)
                assert chain.bit_count()==m*(n-1) and state&chain==chain
                assert sum(other&chain==chain for other in states)==1
        detail={'n':n,'blocks':m,'all_positive_terms_checked':1<<len(rb),
                'exact_minimum_DNF_terms':len(minimal),'minimum_live_term_size':m*(n-1)}
        record('exact_DNF_certificate_bound',detail);rows.append(detail)
    (ROOT/'results/certificate_bounds.json').write_text(json.dumps(rows,indent=2)+'\n')

def verify_commuting_no_go():
    for n in (3,4):
        full=(1<<n)-1;funcs=[]
        for table in range(1<<(1<<n)):
            if table&1 or not (table>>full&1):continue
            if all(not (table>>x&1) or all(table>>(x|1<<i)&1 for i in range(n) if not x>>i&1) for x in range(full+1)):
                funcs.append(table)
        for table in funcs:
            hist={1:Counter(),-1:Counter()}
            for word in permutations(range(n)):
                state=full;death=n+1
                for k,i in enumerate(word,1):
                    state &= ~(1<<i)
                    if not table>>state&1:death=k;break
                hist[sign(word)][death]+=1
            assert hist[1]==hist[-1]
        record('commuting_parity_histogram_no_go',{'n':n,'all_nonconstant_monotone_observers':len(funcs),'orders_per_observer':math.factorial(n)})

def verify_tensor():
    for n,m in [(2,2),(2,3),(3,2)]:
        s=ErasureSystem(n,m);counts=[0]*(s.action_count+1)
        def visit(state,word,left):
            k=len(word);counts[k]+=1;rails=s.parity_rails(state)
            if left:assert rails==(True,True)
            else:
                eps=s.induced_sign(word);assert rails==(eps==1,eps==-1)
            for a in left:visit(s.erase(state,a),word+(a,),tuple(z for z in left if z!=a))
        visit(s.full,(),s.actions)
        record('tensor_all_interleavings',{'n':n,'blocks':m,'partial_protocols':sum(counts),'full_interleavings':counts[-1]})
    rng=random.Random(20261007)
    for n,m in [(3,3),(3,9),(3,27),(4,9),(5,3)]:
        s=ErasureSystem(n,m)
        for trial in range(100):
            word=list(s.actions);rng.shuffle(word);trace=s.run(word)
            assert all(s.parity_rails(x)==(True,True) for x in trace[:-1])
            eps=s.induced_sign(word)
            assert s.parity_rails(trace[-1])==(eps==1,eps==-1)
            assert s.parity_rails(0)==(False,False)
        record('tensor_seeded_larger_cases',{'n':n,'blocks':m,'random_full_interleavings':100,'seed':20261007})

def verify_failures_and_boundaries():
    s=ErasureSystem(3);a,b,c=s.actions
    try:s.run([a,b,a])
    except ValueError:pass
    else:raise AssertionError('Repeated actions must be rejected.')
    assert s.erase(s.erase(s.full,a),b)!=s.erase(s.erase(s.full,b),a)
    assert {s.run(w,flush=True)[-1] for w in permutations(s.actions)}=={0}
    terms=[s.chain_certificate([p]) for p in permutations(range(3)) if sign(p)==1]
    counterexample=next((x for x in range(s.full+1) if dnf_value(x,terms)!=s.observe(x)),None)
    assert counterexample is not None
    for k in range(4):
        for w in permutations(s.actions,k):
            x=s.run(w)[-1];assert dnf_value(x,terms)==s.observe(x)
    record('adversarial_boundaries',{'repetition_guard':'PASS','noncommuting_example':'PASS',
        'common_terminal_state':0,'off_protocol_readout_counterexample':counterexample,
        'counterexample_tokens':s.describe(counterexample),'chain_DNF':dnf_value(counterexample,terms),
        'parity_circuit':s.observe(counterexample)})

def main():
    t=time.time();(ROOT/'results').mkdir(exist_ok=True)
    error=None
    try:
        for test in [verify_axioms,verify_protocols,verify_universal,verify_guard_optimum,
                     verify_tensor_guard_optimum,verify_dnf,verify_commuting_no_go,
                     verify_tensor,verify_failures_and_boundaries]:test()
    except Exception as exc:
        error=exc
        RESULTS.append({'test':test.__name__,'status':'FAIL','error':repr(exc)})
    report={'release':'MIND-QX OSEC 1.0.0',
            'verification_type':'exact finite enumeration plus labelled seeded tests',
            'proof_assistant_checked':False,'independent_peer_review':False,'novelty_verified_absent':False,
            'test_groups':len(RESULTS),'passed':sum(r['status']=='PASS' for r in RESULTS),
            'failed':sum(r['status']=='FAIL' for r in RESULTS),
            'elapsed_seconds':round(time.time()-t,3),
            'input_sha256':{str(p.relative_to(ROOT)):hashlib.sha256(p.read_bytes()).hexdigest()
                            for p in [ROOT/'src/osec.py',ROOT/'tests/verify_release.py']},
            'tests':RESULTS}
    (ROOT/'results/verification_report.json').write_text(json.dumps(report,indent=2)+'\n')
    if error is not None:raise error
    print(f'ALL {len(RESULTS)} TEST GROUPS PASSED',flush=True)
if __name__=='__main__':main()