| """Reproduce every v6 numerical figure and the raw model-results tables. |
| |
| All quantities are dimensionless examples; no hardware data are included. |
| Run from any directory: python src/run_experiments.py [--quick] |
| """ |
| from pathlib import Path |
| import argparse |
| import json |
| import platform |
| import sys |
| import numpy as np |
| import scipy |
| import matplotlib |
| matplotlib.use('Agg') |
| import matplotlib.pyplot as plt |
| from scipy.stats import chi2 |
| from risk_math import (ou_continuous_bounds, survival_fv, mean_exit_fv, |
| mean_exit_time, laplace_exit, laplace_exit_fv, |
| simulate_nested_sampled_exit, poisson_clearance) |
| from calibration import diffusion_upper |
| from quantum_checks import (cat_holonomy, gram_projector_check, |
| cutoff_check, displacement_identity_check) |
|
|
| ROOT=Path(__file__).resolve().parents[1] |
| FIG=ROOT/'figures' |
| RES=ROOT/'results' |
| NAVY='#152642' |
| TEAL='#00787f' |
| GOLD='#bd7632' |
| plt.rcParams.update({'font.family':'DejaVu Sans','font.size':10, |
| 'axes.spines.top':False,'axes.spines.right':False, |
| 'axes.labelcolor':NAVY,'text.color':NAVY, |
| 'figure.facecolor':'white','savefig.facecolor':'white'}) |
|
|
|
|
| def save(name): |
| plt.tight_layout() |
| plt.savefig(FIG/(name+'.pdf'),bbox_inches='tight') |
| plt.savefig(FIG/(name+'.png'),dpi=180,bbox_inches='tight') |
| plt.close() |
|
|
|
|
| def write(name,data): |
| (RES/name).write_text(json.dumps(data,indent=2,allow_nan=False)+'\n') |
|
|
|
|
| def wilson(k,n): |
| z=1.959963984540054 |
| p=k/n |
| denom=1+z*z/n |
| center=(p+z*z/(2*n))/denom |
| half=z*np.sqrt(p*(1-p)/n+z*z/(4*n*n))/denom |
| return [float(center-half),float(center+half)] |
|
|
|
|
| def reliability(): |
| ts=np.geomspace(.05,12,70) |
| cases=[] |
| fig,axes=plt.subplots(1,2,figsize=(10,4)) |
| for ax,d in zip(axes,(.08,.04)): |
| fv=survival_fv(1,ts,1,d,cells=800) |
| rows=[ou_continuous_bounds(1,float(t),1,d) for t in ts] |
| estimate=fv['exit_probability'] |
| mask=estimate>1e-10 |
| ax.loglog(ts,[r['v5_direct_upper'] for r in rows],color=GOLD, |
| label='v5 direct upper') |
| ax.loglog(ts,[r['poisson_upper'] for r in rows],color=TEAL, |
| label='positive-Poisson upper') |
| ax.loglog(ts,[max(r['upper'],1e-16) for r in rows],color=NAVY, |
| linestyle='--',label='best analytic upper') |
| ax.loglog(ts[mask],estimate[mask],color='#a14065', |
| label='survival PDE estimate') |
| ax.set(title=f'R=1, kappa=1, d={d} (beta={1/(2*d):g})', |
| xlabel='Operating time',ylabel='Continuous exit probability') |
| ax.set_ylim(1e-9,1.3) |
| ax.grid(alpha=.15,which='both') |
| if d==.08: ax.legend(fontsize=8) |
| for T in (.03,.2,2.,10.): |
| b=ou_continuous_bounds(1,T,1,d) |
| convergence=[] |
| for cells in (100,200,400,800): |
| p=survival_fv(1,[T],1,d,cells)['exit_probability'][0] |
| mt=mean_exit_fv(1,1,d,cells) |
| lt=laplace_exit_fv(.2,1,1,d,cells) |
| convergence.append({'cells':cells,'exit_estimate':float(p) if np.isfinite(p) else None, |
| 'exit_resolved':bool(np.isfinite(p)), |
| 'mean_relative_error':abs(mt/b['mean_exit_time']-1), |
| 'laplace_relative_error':abs(lt/laplace_exit(.2,1,1,d)-1)}) |
| cases.append({'radius':1,'kappa':1,'diffusion':d,'T':T, |
| 'bounds':b,'grid_convergence':convergence}) |
| save('01_continuous_reliability') |
| write('reliability_comparison.json',{'interpretation':'analytic bounds evaluated in float64; survival grids are estimates, not certified intervals','cases':cases}) |
|
|
|
|
| def monitoring(quick): |
| out=simulate_nested_sampled_exit(1,2,1,.08,.001, |
| sample_strides=(1,5,10,50,100), |
| trials=3000 if quick else 30000,seed=20261013) |
| out['wilson_95']={s:wilson(k,out['trials']) for s,k in out['counts'].items()} |
| out['continuous_pde_estimate']=float(survival_fv(1,[2],1,.08,800)['exit_probability'][0]) |
| write('nested_monitoring.json',out) |
| keys=['1','10','100'] |
| vals=[out['rates'][s] for s in keys] |
| intervals=np.array([out['wilson_95'][s] for s in keys]) |
| err=np.vstack([np.array(vals)-intervals[:,0],intervals[:,1]-np.array(vals)]) |
| plt.figure(figsize=(7,4)) |
| plt.bar(['0.001','0.01','0.1'],vals,color=[TEAL,NAVY,GOLD],width=.6) |
| plt.errorbar(np.arange(3),vals,yerr=err,fmt='none',ecolor=NAVY,capsize=4) |
| plt.axhline(out['continuous_pde_estimate'],color='#a14065',linestyle='--', |
| label='Continuous PDE estimate (800 cells)') |
| plt.ylabel('Detected first-exit fraction') |
| plt.xlabel('Observation interval on the same nested paths') |
| plt.title(f'Sampling misses crossings / {out["trials"]:,} OU trajectories') |
| plt.legend(fontsize=9) |
| save('02_sampling_bias') |
|
|
|
|
| def clearance(): |
| times=np.geomspace(.1,20,65) |
| new=np.array([poisson_clearance(float(t),1,.04,.001) for t in times]) |
| old=np.sqrt(.08*(2*times+np.log(1000))) |
| plt.figure(figsize=(7,4)) |
| plt.semilogx(times,old,color=GOLD,label='v5 direct sufficient margin') |
| plt.semilogx(times,new,color=TEAL,label='positive-Poisson sufficient margin') |
| plt.xlabel('Operating time (kappa=1)') |
| plt.ylabel('Required radius (d=0.04)') |
| plt.title('One-event analytic risk budget: 0.001') |
| plt.legend() |
| plt.grid(alpha=.15) |
| save('03_clearance_design') |
| write('clearance_design.json',{'kappa':1,'diffusion':.04,'budget':.001, |
| 'events':1,'times':times.tolist(), |
| 'poisson_radius':new.tolist(),'v5_direct_radius':old.tolist(), |
| 'T10_poisson':poisson_clearance(10,1,.04,.001), |
| 'T10_v5_direct':float(np.sqrt(.08*(20+np.log(1000))))}) |
|
|
|
|
| def graph_design(): |
| rng=np.random.default_rng(62291) |
| n,G,k,q0=8,4.,1.,2. |
| edges=[(i,j) for i in range(n) for j in range(i+1,n)] |
| incidence=np.zeros((len(edges),n)) |
| for index,(i,j) in enumerate(edges): |
| incidence[index,i]=1;incidence[index,j]=-1 |
| def worst(gains): |
| L=incidence.T@(gains[:,None]*incidence) |
| Sigma=q0/2*np.linalg.inv(k*np.eye(n)+L) |
| return float(np.max(np.diag(incidence@Sigma@incidence.T))) |
| optimum=q0/(k+2*G/(n-1)) |
| uniform=worst(np.full(len(edges),G/len(edges))) |
| random_values=[worst(G*rng.dirichlet(np.ones(len(edges)))) for _ in range(1000)] |
| assert abs(uniform-optimum)<1e-12 |
| assert min(random_values)>=optimum-1e-12 |
| plt.figure(figsize=(7,4)) |
| plt.hist(random_values,bins=32,color=NAVY,alpha=.8,label='1,000 random budget allocations') |
| plt.axvline(optimum,color=TEAL,linewidth=2,label='Proved uniform-complete optimum') |
| plt.xlabel('Worst stationary pair variance (one coordinate)') |
| plt.ylabel('Allocation count') |
| plt.title('Graph stabilization at fixed gain budget / n=8, G=4') |
| plt.legend(fontsize=8) |
| save('04_graph_budget') |
| write('graph_budget.json',{'seed':62291,'nodes':n,'gain_budget':G,'kappa':k, |
| 'noise_covariance_q0':q0,'exact_optimum':optimum, |
| 'uniform_value':uniform,'random_values':random_values, |
| 'scope':'stationary variance in declared linear drift; no global braid action or hardware optimum claimed'}) |
|
|
|
|
| def quantum(): |
| out={'status':'algebra checks; ideal adiabatic branch, no laboratory or gap certification', |
| 'cat_holonomy':[cat_holonomy(A) for A in (.25,.5,1,2,4,6,9)], |
| 'coherent_gram_projector':gram_projector_check(), |
| 'finite_cutoff':cutoff_check(),'shifted_root':displacement_identity_check()} |
| write('quantum_checks.json',out) |
| aa=np.geomspace(.05,10,200) |
| phase=np.pi-2*np.pi*aa/np.sinh(2*aa) |
| fig,ax=plt.subplots(1,2,figsize=(10,4)) |
| ax[0].semilogx(aa,phase/np.pi,color=TEAL) |
| ax[0].set(xlabel='A = |alpha| squared',ylabel='Relative holonomy phase / pi', |
| title='Same root-exchange braid, different gate') |
| ax[1].plot(aa,aa*np.tanh(aa),color=TEAL,label='Even cat mean photons') |
| ax[1].plot(aa,aa/np.tanh(aa),color=GOLD,label='Odd cat mean photons') |
| ax[1].set(xlabel='A = |alpha| squared',ylabel='Parity-jump rate / kappa_1', |
| title='Larger separation also changes loss cost') |
| ax[1].legend(fontsize=8) |
| save('05_quantum_phase_resource') |
| rows=out['finite_cutoff'] |
| plt.figure(figsize=(7,4)) |
| plt.semilogy([r['fock_dimension'] for r in rows], |
| [r['analytic_boundary_residual'] for r in rows], |
| 'o-',color=TEAL,label='Analytic truncated-state boundary residual') |
| plt.semilogy([r['fock_dimension'] for r in rows], |
| [r['normalized_coherent_jump_residual'] for r in rows], |
| 's--',color=GOLD,label='Direct float64 residual (roundoff floor)') |
| plt.xlabel('Fock cutoff dimension') |
| plt.ylabel('Norm of (a_N squared - alpha squared) on truncated coherent state') |
| plt.title('Near-dark convergence does not create an exact finite-cutoff kernel') |
| plt.legend(fontsize=8) |
| save('06_cutoff_diagnostic') |
|
|
|
|
| def calibration(quick): |
| rng=np.random.default_rng(63109) |
| reps=500 if quick else 5000 |
| n,k,h,d=40,1.7,.13,.24 |
| scale=-np.expm1(-2*k*h)/k |
| sample=rng.normal(0,np.sqrt(d*scale),(reps,n)) |
| ss=np.sum(sample*sample,axis=1) |
| upper=ss/(scale*chi2.ppf(.05,n)) |
| covered=int(np.sum(d<=upper)) |
| write('calibration_coverage.json',{'seed':63109,'repetitions':reps, |
| 'scalar_innovations_per_repetition':n, |
| 'kappa':k,'dt':h,'true_diffusion':d, |
| 'confidence':.95,'covered':covered, |
| 'empirical_coverage':covered/reps, |
| 'wilson_95':wilson(covered,reps), |
| 'assumptions':'known kappa and exact uncensored Gaussian state observations'}) |
|
|
|
|
| def main(): |
| parser=argparse.ArgumentParser() |
| parser.add_argument('--quick',action='store_true',help='fewer Monte Carlo/calibration trials; overwrites result files') |
| args=parser.parse_args() |
| FIG.mkdir(exist_ok=True);RES.mkdir(exist_ok=True) |
| reliability(); print('Continuous risk and PDE cross-checks complete',flush=True) |
| monitoring(args.quick); print('Nested observation experiment complete',flush=True) |
| clearance(); graph_design(); quantum();calibration(args.quick) |
| write('runtime.json',{'python':sys.version,'platform':platform.platform(), |
| 'numpy':np.__version__,'scipy':scipy.__version__, |
| 'matplotlib':matplotlib.__version__,'quick':args.quick}) |
| print('All six figures and result tables generated',flush=True) |
|
|
|
|
| if __name__=='__main__':main() |
|
|
