"""Reproduce exact certificates and independent numerical checks (no network)."""
from pathlib import Path
import csv,json,sys,platform,time
from itertools import product
import numpy as np
import scipy,sympy as sp
from scipy.linalg import hadamard
from src.continuation import *
ROOT=Path(__file__).resolve().parent; OUT=ROOT/'results';OUT.mkdir(exist_ok=True)
rng=np.random.default_rng(20261023)

def save_csv(name,rows):
    with (OUT/name).open('w',newline='') as f:
        w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)

def serialize(M): return [[str(v) for v in M.row(i)] for i in range(M.rows)]

# Exact rational family audits. Physical positivity, independent transport and spectra.
family=[];certs=[]
for n in [4,8,16,32,64]:
    t=time.perf_counter();m=separation_family(n);r=separation_family(n,sp.Rational(1,10000))
    e=m.F[0,:];f=m.F[1,:];b=m.F[2,:];a=m.F[3,:];alpha=e+m.tau*a
    # Rank certificates are checked directly in invertible Hadamard coordinates.
    # The rows e,f,alpha,b,e4,...,e(n-1) are the required affine closure.
    rows=[sp.eye(n)[0,:],sp.eye(n)[1,:],sp.eye(n)[0,:]+m.tau*sp.eye(n)[3,:],sp.eye(n)[2,:]]
    rows.extend(sp.eye(n)[j,:] for j in range(4,n))
    witness=sp.Matrix.vstack(*rows)
    assert witness.rank()==n
    assert e*(m.A+m.B)==e
    assert min(m.A)>0 and min(m.B)>0 and min(r.B)>0
    assert (r.LB-m.LB).rank()==1
    assert r.LB.charpoly().as_expr()==m.LB.charpoly().as_expr()
    assert (m.LA+m.LB).charpoly().as_expr()==(r.LA+r.LB).charpoly().as_expr()
    # Pairwise exterior transport is verified without forming a D x D compound.
    q1=wedge(f,e);q2=wedge(b,alpha)
    assert wedge(f*m.A,e*m.A)==m.c**2*m.gamma*q2
    assert wedge(b*m.A,alpha*m.A)==m.c**2*m.kappa*q2
    assert wedge(f*m.B,e*m.B)==sp.zeros(1,n*(n-1)//2)
    assert wedge(b*m.B,alpha*m.B)==sp.zeros(1,n*(n-1)//2)
    family.append(dict(n=n,exterior_basis=2,nonlinear_continuous_scalars=2,
                       affine_snapshot_scalars=3,affine_recurrent_scalars=n-1,
                       rewritten_continuous_scalars=n-1,
                       min_A_entry=float(min(m.A)),min_B_entry=float(min(m.B)),
                       min_branch_probability=float(min(e*m.A)),
                       max_rewrite_entry=float(max(abs(v) for v in r.B-m.B)),
                       edit_rank=1,same_B_spectrum=True,same_aggregate_spectrum=True,
                       elapsed_seconds=time.perf_counter()-t))
    if n in [4,8]:
        cert=compile_exterior([m.A,m.B],[f]);assert cert.R.rows==2
        certs.append(dict(n=n,R=serialize(cert.R),H=[serialize(x) for x in cert.transports],
                          A=serialize(m.A),B=serialize(m.B),normalizer=serialize(cert.normalizer),
                          seeds=[dict(beta=serialize(s.numerator),alpha=serialize(s.denominator),word=s.word) for s in cert.seeds],
                          ratios=[dict(beta=serialize(s.numerator),alpha=serialize(s.denominator),word=s.word) for s in cert.ratios]))
save_csv('exact_family.csv',family)
(OUT/'exact_certificates.json').write_text(json.dumps(certs,indent=2))

# Generic strictly positive two-outcome instruments: independent direct-word tests.
generic=[];generic_raw=[]
for n in [3,4,5]:
 for trial in range(10):
    raw=rng.integers(1,8,size=(2,n,n));total=raw.sum(axis=(0,1))
    Ts=[sp.Matrix([[sp.Rational(int(raw[h,i,j]),int(total[j])) for j in range(n)] for i in range(n)]) for h in range(2)]
    f=sp.Matrix([list(map(int,rng.integers(-3,4,n)))])
    cert=compile_exterior(Ts,[f]);assert cert.verify()
    zraw=rng.integers(1,20,n);x=sp.Matrix(list(map(int,zraw)))/int(sum(zraw))
    L=cert.fiber_matrix(cert.signature_exact(x))
    sig=np.array(cert.signature_exact(x),float).ravel()
    maxerr=0.
    for h in range(2):
        direct=np.array(cert.signature_exact(normalize(Ts[h],x)),float).ravel()
        pred=cert.update_float(sig,h)
        maxerr=max(maxerr,float(np.max(np.abs(direct-pred))) if len(direct) else 0.)
    # Audit arbitrary extra words as exact membership in the exported exterior span.
    max_word=7
    for _ in range(12):
        beta=f;alpha=sp.ones(1,n)
        for h in rng.integers(0,2,max_word):beta=beta*Ts[int(h)];alpha=alpha*Ts[int(h)]
        assert sp.Matrix.vstack(cert.R,wedge(beta,alpha)).rank()==cert.R.rows
    generic.append(dict(n=n,trial=trial,exterior_rank=cert.R.rows,
                        signature_jacobian_rank=L.rank(),snapshot_scalars=snapshot_space(cert).rows-1,
                        basis_word_depth=cert.depth,extra_words=12,word_length=max_word,
                        max_LP_representative_update_error=maxerr))
    generic_raw.append(dict(n=n,trial=trial,branches=[serialize(T) for T in Ts],
                         initial_state=serialize(x),readout=serialize(f),R=serialize(cert.R),
                         H=[serialize(H) for H in cert.transports],
                         ratios=[dict(beta=serialize(r.numerator),alpha=serialize(r.denominator),word=r.word) for r in cert.ratios]))
save_csv('generic_compiler.csv',generic)
(OUT/'generic_certificates.json').write_text(json.dumps(generic_raw,indent=2))

# Sharp factor-two cases.
sharp=[]
for r in range(1,7):
 c=factor_two_fixture(r);n=2*r+1
 sharp.append(dict(r=r,n=n,exact_continuous_scalars=r,
                   affine_snapshot_scalars=snapshot_space(c).rows-1,
                   verified_jacobian_rank=jacobian_rank(c,sp.ones(n,1)/n)))
save_csv('snapshot_frontier.csv',sharp)

# Independent coordinate simulator; no physical matrix/compound backend reused.
# Branch labels supplied explicitly, hence no claim to simulate their distributions.
traces=[];rawtraces=[]
n=64;H=hadamard(n);gamma=kappa=1/8;tau=1/4;c=1/2;lam=1/(8*n)
for trial in range(128):
    x=rng.dirichlet(np.ones(n));z=H@x
    compact=np.array([z[1],z[2]/(1+tau*z[3])]);state=z.copy()
    if trial%4==0: labels=np.zeros(256,dtype=int)
    elif trial%4==1: labels=np.ones(256,dtype=int)
    elif trial%4==2: labels=np.arange(256)%2
    else: labels=rng.integers(0,2,256)
    err=0.;qerr=0.;step=2.**-12
    quant=np.round(compact/step)*step
    head=[]
    for t,label in enumerate(labels):
        before=state.copy();v=compact[1];vq=quant[1]
        if label==0:
            out=np.zeros(n);out[0]=c*(before[0]+tau*before[3]);out[1]=c*gamma*before[2];out[2]=c*kappa*before[2]
            compact=np.array([gamma*v,kappa*v]);quant=np.array([gamma*vq,kappa*vq])
        else:
            out=np.zeros(n);out[0]=(1-c)*before[0]-c*tau*before[3]
            out[3:n-1]=lam*before[4:n]
            compact=np.zeros(2);quant=np.zeros(2)
        state=out/out[0];quant=np.round(quant/step)*step
        true=np.array([state[1],state[2]/(1+tau*state[3])])
        err=max(err,float(np.max(np.abs(true-compact))))
        qerr=max(qerr,float(np.max(np.abs(true-quant))))
        if t<12:head.append(dict(t=t,label=int(label),f=float(true[0]),compact_f=float(compact[0]),quantized_f=float(quant[0])))
    bound=(step/2)/(1-kappa)
    assert qerr<=bound+1e-12
    traces.append(dict(trial=trial,n=n,length=256,exact_error=err,
                       quantized_error=qerr,uniform_bound=bound,step=step))
    rawtraces.append(dict(trial=trial,initial_distribution=x.tolist(),labels=labels.tolist(),first_12_steps=head))
save_csv('long_horizon.csv',traces)
(OUT/'long_horizon_raw.json').write_text(json.dumps(rawtraces,indent=2))

# Perturbed decoder stability at vertices and random states, arbitrary B runs.
pert=[]
for delta in [1e-2,1e-4,1e-6]:
 for trial in range(24):
    x=rng.dirichlet(np.ones(n));state=H@x
    compact=np.array([state[1],state[2]/(1+tau*state[3])])
    labels=rng.integers(0,2,128) if trial%2 else np.ones(128,dtype=int)
    worst=0.
    for label in labels:
        before=state.copy();v=compact[1]
        out=np.zeros(n)
        if label==0:
            out[0]=c*(before[0]+tau*before[3]);out[1]=c*gamma*before[2];out[2]=c*kappa*before[2]
            compact=np.array([gamma*v,kappa*v])
        else:
            out[0]=(1-c)*before[0]-c*tau*before[3];out[1]=delta*before[3];out[3:n-1]=lam*before[4:n]
            compact=np.zeros(2)
        state=out/out[0]
        worst=max(worst,abs(state[1]-compact[0]))
    assert worst<=8*delta/3+1e-12
    pert.append(dict(delta=delta,trial=trial,max_readout_error=worst,uniform_bound=8*delta/3))
save_csv('rewrite_approximation.csv',pert)

# Exact recovered hidden histories and witness pair.
inversions=[]
for n in [4,8,16]:
 m=separation_family(n,sp.Rational(1,1000));x=sp.Matrix(range(1,n+1))/(n*(n+1)//2)
 y=x;ys=[]
 for _ in range(n-3):
    y=normalize(m.B,y);ys.append((m.F[1,:]*y)[0])
 got=reconstruct_hidden_from_B_readouts(n,ys,m.delta)
 assert got==(m.F*x)[3:,:]
 inversions.append(dict(n=n,delta=str(m.delta),observations=[str(v) for v in ys],
                        reconstructed=[str(v) for v in got],matches=True))
(OUT/'hidden_reconstruction.json').write_text(json.dumps(inversions,indent=2))
summary=dict(seed=20261023,python=sys.version,numpy=np.__version__,scipy=scipy.__version__,sympy=sp.__version__,
             unit_test_methods=40,exact_family_sizes=len(family),generic_instruments=len(generic),extra_exact_words=sum(t['extra_words'] for t in generic),
             factor_two_cases=len(sharp),long_histories=len(traces),long_history_steps=sum(t['length'] for t in traces),
             max_exact_history_error=max(t['exact_error'] for t in traces),
             max_LP_update_error=max(t['max_LP_representative_update_error'] for t in generic),
             max_quantized_error=max(t['quantized_error'] for t in traces),
             quantized_uniform_bound=traces[0]['uniform_bound'],
             perturbed_histories=len(pert),hidden_reconstruction_sizes=len(inversions),
             claims='Finite mathematical checks; no language-model training or broad RSI superiority experiment.')
(OUT/'summary.json').write_text(json.dumps(summary,indent=2));print(json.dumps(summary,indent=2))