Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
nonlinear-systems
model-reduction
state-representation
exterior-algebra
exact-arithmetic
| """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)) | |