File size: 8,158 Bytes
973efa6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | #!/usr/bin/env python3
"""Independent maximum-principle and residual-certificate checks.
Finite numerical models only; no optical timing or energy claims.
"""
from pathlib import Path
from collections import deque
import json
import platform
import numpy as np
ROOT=Path(__file__).resolve().parent
def vn(v,w): return float(np.max(np.abs(v)/w,initial=0.))
def mn(a,wi,wo=None):
if wo is None: wo=wi
return float(np.max(np.sum(np.abs(a)*wi[None,:],axis=1)/wo,initial=0.))
def on(a,w): return float(np.max(np.sum(np.abs(a)*w[None,:],axis=1),initial=0.))
def distances(t,z):
d=np.full(len(t),np.inf);dq=deque()
for j in z:d[j]=0;dq.append(int(j))
while dq:
j=dq.popleft()
for i in np.flatnonzero(t[:,j]>0):
if d[i]>d[j]+1:d[i]=d[j]+1;dq.append(int(i))
return d
def main():
rng=np.random.default_rng(2026102519)
records=[];max_lift=0.;max_full=0.;max_cert_ratio=0.;max_partial_ratio=0.;max_partial_error=0.;max_dist_violation=0.
for trial in range(240):
n=[8,16,32][trial%3];rho=[.3,.8,.98,.9999][trial%4]
w=np.exp(rng.uniform(-2,2,n))
raw=rng.uniform(0,1,(n,n))*(rng.uniform(0,1,(n,n))<.1)
if trial%3==0:
# An acyclic chain gives genuinely nontrivial graph distances.
raw=np.zeros((n,n));raw[np.arange(1,n),np.arange(n-1)]=1
rows=raw.sum(axis=1);nz=rows>0
raw[nz]*=(rho*rng.uniform(.6,1,n)[nz]/rows[nz])[:,None]
t=w[:,None]*raw/w[None,:];g=np.linalg.inv(np.eye(n)-t)
k=int(rng.integers(1,n));z=np.sort(rng.choice(n,k,replace=False));r=np.setdiff1d(np.arange(n),z)
wz=w[z];e=np.eye(n)[:,z];kmat=g[np.ix_(z,z)];ki=np.linalg.inv(kmat)
lift=g[:,z]@ki
block=np.zeros((n,k));block[z]=np.eye(k);block[r]=np.linalg.solve(np.eye(len(r))-t[np.ix_(r,r)],t[np.ix_(r,z)])
lift_error=mn(lift-block,wz,w);max_lift=max(max_lift,lift_error)
assert lift_error<1e-9
assert lift.min()>-1e-9
assert mn(lift,wz,w)<=1+1e-9
dist=distances(t,z);spatial=np.zeros(n)
finite=np.isfinite(dist);spatial[finite]=rho**dist[finite]
violation=float(np.max((lift@wz)/w-spatial));max_dist_violation=max(max_dist_violation,violation)
assert violation<1e-9
b=w*rng.normal(size=n);q=g@b;theta=np.linalg.solve(kmat,q[z])
obs=rng.normal(0,.1,(3,n))/w[None,:]
opaque=np.ones(n);opaque[z]=0;tm=opaque[:,None]*t*opaque[None,:]
true=np.linalg.solve(np.eye(n)-tm,b)
exact=e@b[z]+q-g[:,z]@theta
full_error=vn(exact-true,w);max_full=max(max_full,full_error)
assert full_error<1e-8
sigma=[1e-5,.001,.1,1.][trial%4]
dk=sigma*wz[:,None]*rng.normal(size=(k,k))/wz[None,:]
dq=sigma*wz*rng.normal(size=k)
khat=kmat+dk;qhat=q[z]+dq
th=theta+sigma*wz*rng.normal(size=k)
defect=khat@th-qhat
eta=mn(dk,wz)*vn(th,wz)+vn(dq,wz)+vn(defect,wz)
zo=obs@g[:,z];y0=obs@q;local=obs@e@b[z]
dz=sigma*.01*rng.normal(size=zo.shape)/wz[None,:]
dy=sigma*.01*rng.normal(size=3);dl=sigma*.01*rng.normal(size=3)
pred=y0+dy-(zo+dz)@th+local+dl
coeff=float(np.max(np.abs(obs)@(w*spatial)))
bound=float(max(abs(dy))+max(abs(dl))+on(dz,wz)*vn(th,wz)+coeff*eta)
actual=float(max(abs(obs@true-pred)))
assert actual<=bound+1e-8
ratio=actual/bound if bound else 0.;max_cert_ratio=max(max_cert_ratio,ratio)
# Stronger componentwise ideal-candidate relation is exact.
ideal=e@b[z]+q-g[:,z]@th
assert vn((true-ideal)-lift@(kmat@th-q[z]),w)<1e-8
# Partial-transmission reconstruction and positive residual barrier.
d=rng.uniform(0,1,k);d[rng.uniform(0,1,k)<.2]=0;d[rng.uniform(0,1,k)<.2]=1
s=np.eye(k)-ki;hmat=np.eye(k)-d[:,None]*s*d[None,:]
rhs=(1-d)*b[z]+d*(ki@q[z]);u=np.linalg.solve(hmat,rhs)
abase=q-lift@q[z];blift=lift*d[None,:]+e*(1-d)[None,:]
mask=np.ones(n);mask[z]=d;mt=mask[:,None]*t*mask[None,:]
ptruth=np.linalg.solve(np.eye(n)-mt,b)
partial_error=vn(abase+blift@u-ptruth,w);max_partial_error=max(max_partial_error,partial_error)
assert partial_error<1e-8
assert mn(blift,wz,w)<=1+1e-9
assert np.min((hmat@wz)-(1-rho*d)*wz)>-1e-8
uh=u+.1*wz*rng.normal(size=k)
dh=.005*wz[:,None]*rng.normal(size=(k,k))/wz[None,:]
dhs=.005*wz*rng.normal(size=k)
hhat=hmat+dh;rhshat=rhs+dhs
eh=np.abs(dh);erhs=np.abs(dhs)
residual_envelope=np.abs(hhat@uh-rhshat)+eh@np.abs(uh)+erhs
beta=float(np.max(residual_envelope/((1-rho*d)*wz)))
pactual=vn(ptruth-(abase+blift@uh),w)
assert pactual<=beta+1e-8
max_partial_ratio=max(max_partial_ratio,pactual/beta if beta else 0.)
records.append({'n':n,'k':k,'rho':rho,'lift_identity_error':lift_error,'occupancy_identity_error':full_error,
'distance_bound_violation':violation,'actual_noisy_output_error':actual,'new_output_certificate':bound,
'partial_identity_error':partial_error,'partial_actual_error':pactual,'partial_residual_barrier':beta})
frontier=[]
for rho in [.9,.99,.999,.9999,.99999]:
t=np.full((2,2),rho/2);g=np.linalg.inv(np.eye(2)-t);k=g[0,0]
exact_lift=float(g[1,0]/k)
old=float(g[1,0]*(1+rho));new=rho
assert exact_lift<=new+1e-9
frontier.append({'rho':rho,'exact_surviving_residual_gain':exact_lift,'old_coarse_output_gain_bound':old,
'maximum_principle_distance_bound':new,'coefficient_improvement_factor':old/new})
# One transparent state rules out a uniform source-equation-residual bound.
rho=.9999;transparent_error=1/(1-rho)
assert transparent_error>9999
result={'project':'ELYSIAEN final maximum-principle boundary certificate','date':'2026-10-25','status':'All assertions passed',
'seed':2026102519,'python':platform.python_version(),'numpy':np.__version__,
'weighted_nonsymmetric_trials':240,'hard_output_certificates':240,'partial_opacity_barrier_certificates':240,
'certificate_violations':0,'maximum_harmonic_lift_identity_error':max_lift,
'maximum_occupancy_response_error':max_full,'maximum_partial_opacity_response_error':max_partial_error,
'maximum_distance_bound_numerical_violation':max_dist_violation,
'maximum_noisy_output_error_to_certificate_ratio':max_cert_ratio,
'maximum_partial_error_to_barrier_ratio':max_partial_ratio,
'near_conservative_frontier':frontier,
'transparent_equation_residual_negative_control':{'rho':rho,'unit_residual_error':transparent_error},
'scope':'Exact finite positive transport and stipulated simultaneous calibration envelopes; no optical performance measurements',
'trials':records}
(ROOT/'v4_error_results.json').write_text(json.dumps(result,indent=2)+'\n')
print(json.dumps({key:value for key,value in result.items() if key!='trials'},indent=2))
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
x=np.array([x['rho'] for x in frontier]);fig,ax=plt.subplots(figsize=(7.5,4.2),constrained_layout=True)
ax.semilogx(1/(1-x),[x['old_coarse_output_gain_bound'] for x in frontier],'-o',color='#6B51B8',label='Separate-factor coarse bound')
ax.semilogx(1/(1-x),[x['maximum_principle_distance_bound'] for x in frontier],'-s',color='#178D9B',label='Maximum-principle distance bound')
ax.semilogx(1/(1-x),[x['exact_surviving_residual_gain'] for x in frontier],'--',color='#273044',label='Exact surviving residual gain')
ax.set_yscale('log');ax.set_xlabel('Reference response scale 1/(1-rho)');ax.set_ylabel('Boundary-defect to output coefficient')
ax.set_title('An avoidable certificate amplification disappears');ax.grid(alpha=.2);ax.legend(fontsize=8)
fig.savefig(ROOT/'v4_error_frontier.png',dpi=200);plt.close(fig)
if __name__=='__main__':
try:from threadpoolctl import threadpool_limits
except ImportError:main()
else:
with threadpool_limits(limits=1):main()
|