| """Seeded property checks and exact Gaussian-rational certificates.""" |
| from __future__ import annotations |
| import itertools, json, pathlib, sys, time |
| import numpy as np |
| import sympy as sp |
| sys.path.insert(0,str(pathlib.Path(__file__).resolve().parents[1]/'src')) |
| from lioraen_omega import * |
| ROOT=pathlib.Path(__file__).resolve().parents[1] |
| SEED=16102026 |
| rng=np.random.default_rng(SEED) |
| REPORT={"seed":SEED,"numerical_tolerance":1e-7,"groups":{},"exact":{}} |
|
|
| def record(name,cases,error=0.,**kwargs): |
| REPORT['groups'][name]=dict(passed=True,cases=int(cases),max_error=float(error),**kwargs) |
|
|
| def rh(n,real=False): |
| a=rng.normal(size=(n,n)) |
| if not real:a=a+1j*rng.normal(size=(n,n)) |
| return herm(a)/max(1,np.sqrt(n)) |
|
|
| def numerical(): |
| errs=[] |
| for q in range(1,7): |
| for _ in range(20): |
| X=rng.normal(size=(q,q))+1j*rng.normal(size=(q,q)) |
| S=rh(q)-1j*(adj(X)@X+np.eye(q)) |
| z=complex(rng.normal(),.4+rng.random()) |
| L,C=realize_one_value(S,z) |
| errs.append(np.linalg.norm(sigma(L,C,z)-S)) |
| assert np.linalg.norm(L-adj(L))<1e-9 |
| assert max(errs)<1e-7;record('one_frequency_physical_realization',len(errs),max(errs)) |
| for reciprocal in [False,True]: |
| errs=[]; counts=[] |
| for k in range(1,5): |
| ts=controls(k,reciprocal); N=(k+1)*(k+2)//2 if reciprocal else (k+1)**2 |
| assert len(ts)==N;counts.append(N) |
| for _ in range(15): |
| q=k+1;d=q+2;H=rh(q,reciprocal);L=rh(d,reciprocal) |
| C=rng.normal(size=(d,q))*.3 |
| if not reciprocal:C=C+1j*rng.normal(size=(d,q))*.3 |
| z=.2+1.2j; fs=[full_response(H,L,C,z,t) for t in ts] |
| c=recover(ts,fs,reciprocal);K=z*np.eye(q)-H-sigma(L,C,z) |
| errs.append(np.linalg.norm(c['K']-K)) |
| for _ in range(3): |
| t=rng.normal(size=k) |
| if not reciprocal:t=t+1j*rng.normal(size=k) |
| errs.append(abs(quadratic_value(c,t)-full_response(H,L,C,z,t))) |
| assert max(errs)<1e-7 |
| record('reciprocal_tomography' if reciprocal else 'complex_tomography',len(errs),max(errs),setting_counts=counts) |
| errs=[] |
| for q in [2,3,4]: |
| k=q-1;z=.2+1j;H=rh(q);S=rh(q)-2j*np.eye(q) |
| K=z*np.eye(q)-H-S;c=coefficients(K) |
| x=np.r_[c['alpha'],c['r'],c['c'],c['Y'].ravel()] |
| ts=controls(k)[:-1];M=np.vstack([feature(t) for t in ts]) |
| _,_,vh=np.linalg.svd(M,full_matrices=True);v=vh[-1].conj() |
| for epsilon in [1e-4,1e-5,1e-6]: |
| xx=x+epsilon*v |
| cc=dict(alpha=xx[0],r=xx[1:1+k],c=xx[1+k:1+2*k],Y=xx[1+2*k:].reshape(k,k)) |
| KK=reconstruct_matrix(cc);SS=z*np.eye(q)-H-KK |
| assert np.linalg.eigvalsh(-imag_part(SS)).min()>1 |
| L1,C1=realize_one_value(S,z);L2,C2=realize_one_value(SS,z) |
| err=max(abs(full_response(H,L1,C1,z,t)-full_response(H,L2,C2,z,t)) for t in ts) |
| errs.append(err);assert np.linalg.norm(K-KK)>1e-8 |
| assert max(errs)<1e-8;record('physical_short_design_ambiguities',len(errs),max(errs)) |
| errs=[];extension_errors=[];defect_cases=0 |
| for q in [1,2,3]: |
| for d in [q,2*q+1,3*q+2]: |
| for _ in range(5): |
| L=rh(d);C=(rng.normal(size=(d,q))+1j*rng.normal(size=(d,q)))/np.sqrt(d) |
| zs=np.linspace(-2,2,5)+1j*np.linspace(.9,1.5,5) |
| ranks=[] |
| for m in range(1,6): |
| ss=[sigma(L,C,z) for z in zs[:m]] |
| base=canonical(zs[:m],ss,atol=2e-11,rtol=2e-11) |
| errs.append(base.interpolation_residual);ranks.append(base.rank) |
| previous=0 if m==1 else ranks[-2] |
| assert base.defect==base.rank-previous |
| defect_cases+=1 |
| if base.defect: |
| Dh=np.diag([3.,4.,5.]);Q=rng.normal(size=(3,base.defect))*.1 |
| Le,Ce=compatible_extension(base,Dh,Q) |
| extension_errors.append(max(np.linalg.norm(sigma(Le,Ce,z)-s) for z,s in zip(zs[:m],ss))) |
| else: |
| for z in [-.7+.3j,2.1+.8j]:errs.append(np.linalg.norm(base.value(z)-sigma(L,C,z))) |
| increments=np.diff([0]+ranks) |
| assert np.all(increments[:-1]>=increments[1:]) |
| assert max(errs)<1e-7 and max(extension_errors)<1e-7 |
| record('canonical_and_flatness',len(errs),max(errs));record('extension_interface',len(extension_errors),max(extension_errors),defect_identities=defect_cases) |
| rejected=0 |
| for zs,ss in [([1j],[np.array([[1.]])]),([1j],[np.array([[1j]])]), |
| ([1j,1j],[np.array([[-1j]]),np.array([[-1j]])]), |
| ([0j],[np.array([[-1j]])])]: |
| try: canonical(zs,ss) |
| except ValueError: rejected+=1 |
| assert rejected==4;record('admissibility_and_input_rejections',rejected) |
| L=np.diag([-3,-2,-1,0,1,2,3]);C=np.zeros((7,3));C[:3,0]=1;C[3:5,1]=1;C[5:,2]=1 |
| profiles=[] |
| for nodes in [np.arange(4)+1j, -np.arange(4)+2j, np.arange(4)*.7+(.5+np.arange(4)*.2)*1j]: |
| profiles.append([canonical(nodes[:m],[sigma(L,C,z) for z in nodes[:m]]).rank for m in range(1,5)]) |
| assert profiles==[[3,6,7,7]]*3;record('node_independent_rank_profiles',3,profiles=profiles) |
| zs=np.arange(6)*.5+.8j;gamma=.3 |
| damped=[np.array([[1/(z+1j*gamma)]]) for z in zs] |
| K,_,_=pick_matrices(zs,damped) |
| eigen=np.linalg.eigvalsh(K);assert min(eigen)>1e-10 |
| shifted=[z+1j*gamma for z in zs] |
| Kc,_,_=pick_matrices(shifted,damped) |
| assert np.linalg.matrix_rank(Kc,tol=1e-9)==1 |
| record('damped_rank_and_known_linewidth_repair',2,smallest_unshifted_eigenvalue=float(min(eigen))) |
| errs=[] |
| for _ in range(50): |
| d=4;q=2;H=rh(d);R=rh(d);Gamma=adj(R)@R+.2*np.eye(d);A=H-1j*Gamma |
| C=rng.normal(size=(d,q))+1j*rng.normal(size=(d,q));zs=np.array([-.7+.8j,.4+1.1j,1.6+.9j]) |
| ss=[sigma(A,C,z) for z in zs];K,_,_=pick_matrices(zs,ss) |
| expected=np.zeros_like(K) |
| for i,zi in enumerate(zs): |
| Ri=np.linalg.inv(zi*np.eye(d)-A) |
| for j,zj in enumerate(zs): |
| Rj=np.linalg.inv(zj*np.eye(d)-A) |
| expected[i*q:(i+1)*q,j*q:(j+1)*q]=adj(C)@Ri@(np.eye(d)+2j*Gamma/(zi-zj.conjugate()))@adj(Rj)@C |
| errs.append(np.linalg.norm(K-expected));assert np.linalg.eigvalsh(K).min()>1e-10 |
| assert max(errs)<1e-8;record('dissipative_kernel_identity',len(errs),max(errs)) |
| errs=[] |
| for phi in np.linspace(-2,2,25): |
| H,L,C=phase_model(phi);H2,L2,C2=phase_model(-phi);z=.17+.12j;tau=.2 |
| for t in [-.4,0,.3]:errs.append(abs(full_response(H,L,C,z,[t])-full_response(H2,L2,C2,z,[t]))) |
| D=(z*np.eye(2)-H-sigma(L,C,z))[1,1] |
| prediction=4*tau*.3**2*np.sin(phi)/((z-.6)*D) |
| delta=full_response(H,L,C,z,[1j*tau])-full_response(H2,L2,C2,z,[1j*tau]) |
| errs.append(abs(delta-prediction)) |
| assert max(errs)<1e-8;record('mixed_pole_phase_and_contrast',len(errs),max(errs)) |
| errs=[];cases=0 |
| for _ in range(40): |
| zs=np.array([-.8+.7j,.2+1.1j,1.2+.9j]);roots=[-.4,.5];a=rational_weights(zs,roots) |
| for t in [-2.,-.4,.1,.5,1.9]: |
| lhs=sum(a/(zs.conj()-t));rhs=np.prod(t-np.array(roots))/np.prod(zs.conj()-t) |
| errs.append(abs(lhs-rhs)) |
| L=np.diag(rng.uniform(-2,2,6));C=rng.normal(size=(6,2))+1j*rng.normal(size=(6,2)) |
| ss=[sigma(L,C,z) for z in zs];K,_,_=pick_matrices(zs,ss);E=witness_matrix(K,a,2) |
| X=sum(a[i]*np.linalg.solve(zs[i].conjugate()*np.eye(6)-L,C) for i in range(3)) |
| errs.append(np.linalg.norm(E-adj(X)@X)) |
| bound=spectral_mass_bound(zs,roots,K,2,2.,.15)['bound'] |
| outside=np.min(abs(np.diag(L)[:,None]-np.array(roots)[None,:]),axis=1)>.15 |
| true=float(np.linalg.norm(C[outside])**2);assert true<=bound+1e-8;cases+=1 |
| assert max(errs)<1e-7;record('rational_witness_and_mass_bounds',cases,max(errs)) |
| |
| for _ in range(100): |
| q=4;X=rng.normal(size=(3,5,q))+1j*rng.normal(size=(3,5,q)) |
| residues=[adj(x)@x for x in X];W=np.diag(np.exp(1j*rng.normal(size=q))) |
| changed=[adj(W)@M@W for M in residues] |
| for a,b in [(0,1),(1,2),(0,2)]: |
| before=residues[a][0,1]*residues[b][1,0] |
| after=changed[a][0,1]*changed[b][1,0] |
| assert abs(before-after)<1e-8 |
| record('joint_gauge_invariance',300) |
|
|
| def exact(): |
| I=sp.I;z=sp.symbols('z');ss=lambda L,C,w:C.conjugate().T*(w*sp.eye(L.rows)-L).inv()*C |
| def simplify_matrix(M):return M.applyfunc(sp.simplify) |
| def zero(M):return simplify_matrix(M)==sp.zeros(M.rows,M.cols) |
| def exact_pick(nodes,values): |
| q=values[0].rows;m=len(nodes) |
| K=sp.BlockMatrix([[(values[i]-values[j].conjugate().T)/(sp.conjugate(nodes[j])-nodes[i]) for j in range(m)] for i in range(m)]).as_explicit() |
| J=sp.BlockMatrix([[sp.conjugate(nodes[j])*K[i*q:(i+1)*q,j*q:(j+1)*q]-values[i] for j in range(m)] for i in range(m)]).as_explicit() |
| return simplify_matrix(K),simplify_matrix(J),sp.Matrix.vstack(*values) |
| L=sp.diag(-2,0,3);C=sp.Matrix([[1,0],[1,1],[0,1]]);nodes=[I,1+I,2+I] |
| vals=[ss(L,C,w) for w in nodes];K,J,D=exact_pick(nodes,vals) |
| rank=K.rank();assert rank==3 and K[:4,:4].rank()==3 |
| piv=list(K.rref()[1]);G=K.extract(piv,piv);A=J.extract(piv,piv);B=D.extract(piv,range(2)) |
| out=B.conjugate().T*(z*G-A).inv()*B |
| assert zero(out-ss(L,C,z)) |
| REPORT['exact']['descriptor_identity']=dict(passed=True,rank=rank,pivots=piv, |
| gram=str(G),shifted_gram=str(A),data=str(B),identity='D* (zG-J)^(-1) D = C* (zI-L)^(-1) C') |
| L2=sp.Matrix([[0,1],[1,0]]);C2=sp.Matrix([1,-I]) |
| assert ss(L2,C2,I)[0]==-I |
| assert sp.simplify(ss(L2,C2,z)[0]-1/z)!=0 |
| REPORT['exact']['one_sample_distinct_visible_dimensions']=dict(passed=True,functions=['1/z','2*z/(z**2-1)'],common_value_at_i='-I') |
| for added in [1,2,3,4]: |
| V=sp.ones(added,1);Dh=sp.diag(*range(2,2+added)) |
| LL=sp.BlockMatrix([[sp.zeros(1),V.T],[V,Dh]]).as_explicit();CC=sp.Matrix.vstack(sp.ones(1,1),-I*V) |
| assert sp.simplify(ss(LL,CC,I)[0]+I)==0 |
| ctr=sp.Matrix.hstack(*[LL**j*CC for j in range(1+added)]) |
| assert ctr.rank()==1+added |
| REPORT['exact']['unbounded_extension_family']=dict(passed=True,added_dimensions_tested=[1,2,3,4],all_visible=True) |
| K,J,D=exact_pick([I,2*I],[sp.Matrix([[-I]]),sp.Matrix([[-I/2]])]);assert K.rank()==1 |
| REPORT['exact']['flat_two_sample_certificate']=dict(passed=True,K=str(K),ranks=[1,1]) |
| K,J,D=exact_pick([I],[sp.Matrix([[1]])]);assert K.rank()==0 and D.rank()==1 |
| REPORT['exact']['range_condition_counterexample']=dict(passed=True,Pick='0',data='1') |
| M1=sp.ones(2);M2=sp.Matrix([[1,I],[-I,1]]) |
| assert M1.det()==0 and M2.det()==0 and M1[0,1]*M2[1,0]==-I |
| REPORT['exact']['two_channel_cross_pole_invariant']=dict(passed=True,value='-I',residue_ranks=[1,1]) |
| |
| ranks=[] |
| for m in range(1,7): |
| nodes=[j+I for j in range(m)];values=[sp.Matrix([[1/(w+I)]]) for w in nodes] |
| K,_,_=exact_pick(nodes,values);ranks.append(K.rank());assert K.det()!=0 |
| REPORT['exact']['damped_kernel_ranks']=dict(passed=True,internal_damped_order=1,ranks=ranks) |
| |
| points=[j+I*j*j for j in range(6)] |
| M=sp.Matrix([[1,-t,-sp.conjugate(t),-sp.conjugate(t)*t] for t in points]) |
| minor_count=0 |
| for ix in itertools.combinations(range(6),4): |
| assert M.extract(ix,range(4)).det()!=0;minor_count+=1 |
| REPORT['exact']['MDS_all_maximal_minors']=dict(passed=True,minors=minor_count,distance=3) |
| |
| nodes=[I,1+I,2+I];roots=[-1,1];w=[sp.conjugate(x) for x in nodes] |
| aa=[sp.prod(wi-r for r in roots)/sp.prod(wj-wi for j,wj in enumerate(w) if j!=i) for i,wi in enumerate(w)] |
| expr=sum(aa[i]/(w[i]-z) for i in range(3))-(z*z-1)/sp.prod(wi-z for wi in w) |
| assert sp.simplify(expr)==0 |
| REPORT['exact']['rational_annihilator_identity']=dict(passed=True,weights=[str(sp.simplify(a)) for a in aa]) |
|
|
| if __name__=='__main__': |
| start=time.time();numerical();exact() |
| REPORT['elapsed_seconds']=time.time()-start |
| REPORT['summary']={'numerical_groups':len(REPORT['groups']), |
| 'numerical_cases':sum(x['cases'] for x in REPORT['groups'].values()), |
| 'exact_groups':len(REPORT['exact']),'all_passed':True, |
| 'formal_proof_assistant':'not available; symbolic checks are not formalized proofs'} |
| (ROOT/'results').mkdir(exist_ok=True) |
| (ROOT/'results'/'verification.json').write_text(json.dumps(REPORT,indent=2)) |
| print(json.dumps(REPORT['summary'],indent=2)) |
|
|
