| """Reproduce all synthetic results. No hardware measurements. |
| Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki |
| """ |
| from pathlib import Path |
| import sys,json,csv,hashlib,time |
| import numpy as np |
| from scipy.linalg import expm |
| import isophase as I |
| ROOT=Path(__file__).resolve().parents[1] |
| R=ROOT/'results';R.mkdir(exist_ok=True) |
|
|
| def write(name,rows): |
| keys=list(dict.fromkeys(k for r in rows for k in r)) |
| with (R/name).open('w',newline='') as f: |
| w=csv.DictWriter(f,keys);w.writeheader();w.writerows(rows) |
|
|
| def main(): |
| summary={'scientific_status':'conditional theory and synthetic computation; no measured material device', 'seed_policy':'all predefined seeds reported; no success filtering'} |
| print('E1 classical concurrent nonlinearity',flush=True) |
| t,base=I.averaged_trajectory(adaptive=False) |
| _,balanced=I.averaged_trajectory(adaptive=True) |
| _,bad=I.averaged_trajectory(adaptive=True,mismatch=.08) |
| _,drive0=I.averaged_trajectory(adaptive=False,protected_drive=.1) |
| _,drive1=I.averaged_trajectory(adaptive=True,protected_drive=.1) |
| eb=np.linalg.norm(I.stokes(balanced[:,:2])-I.stokes(base[:,:2]),axis=1) |
| eu=np.linalg.norm(I.stokes(bad[:,:2])-I.stokes(base[:,:2]),axis=1) |
| ec=np.linalg.norm(I.stokes(drive1[:,:2])-I.stokes(drive0[:,:2]),axis=1) |
| write('concurrent.csv',[dict(time=x,balanced_error=eb[j],mismatch_error=eu[j],additive_drive_error=ec[j],adaptive_occupation=float(np.sum(abs(balanced[j,2:])**2)),raw_field_error=float(np.linalg.norm(balanced[j,:2]-base[j,:2]))) for j,x in enumerate(t)]) |
| summary['E1_concurrent']=dict(max_stokes_error=float(max(eb)),max_raw_field_error=float(np.max(np.linalg.norm(balanced[:,:2]-base[:,:2],axis=1))),mismatch_error=float(max(eu)),additive_drive_error=float(max(ec)),adaptive_occupation_min=float(np.min(np.sum(abs(balanced[:,2:])**2,1))),adaptive_occupation_max=float(np.max(np.sum(abs(balanced[:,2:])**2,1)))) |
| print('E2 full coherent Kerr detuning controls',flush=True) |
| V=I.modal_matrix(4,4);g=np.full(4,3.2) |
| _,av=I.coherent_trajectory(np.zeros(4),g,V,full=False) |
| rows=[] |
| for code,name in [(np.array([0,1,4,10]),'Sidon'),(np.array([0,1,2,3]),'resonant')]: |
| for D in [2,8,32,128]: |
| _,full=I.coherent_trajectory(code*D,g,V) |
| _,idle=I.coherent_trajectory(code*D,g,V,adaptive=False) |
| rows.append(dict(family=name,spacing=D,pair_sum_gap=I.sum_gap(code*D),full_to_average=float(np.max(np.linalg.norm(I.stokes(full[:,:2])-I.stokes(av[:,:2]),axis=1))),concurrent_change=float(np.max(np.linalg.norm(I.stokes(full[:,:2])-I.stokes(idle[:,:2]),axis=1))))) |
| print(name,D,rows[-1]['concurrent_change'],flush=True) |
| write('full_coherent.csv',rows);summary['E2_full_coherent']=rows |
| print('E3 exact 13-phase tensor average and finite cycles',flush=True) |
| rng=np.random.default_rng(71);gd=rng.uniform(.5,5.,4);q=np.array([0,1,3,9]);L=13 |
| maxerr=0. |
| for _ in range(30): |
| z=rng.normal(size=4)+1j*rng.normal(size=4);z/=np.linalg.norm(z) |
| maxerr=max(maxerr,float(np.linalg.norm(I.twirled_kerr(z,V,gd,q,L)-I.average_kerr(z,I.kerr_matrix(V,gd))))) |
| z=np.sqrt([.45,.25,.2,.1])*np.exp(1j*np.array([.1,.5,.8,-.6]));K=I.kerr_matrix(V,g);T=2. |
| reference=z*np.exp(-1j*(K@abs(z)**2)*T) |
| rows=[] |
| for sym in [False,True]: |
| for n in [2,4,8,16,32,64,128]: |
| out=I.phase_cycle(z,V,g,q,L,T,n,sym) |
| rows.append(dict(method='palindrome' if sym else 'forward',cycles=n,exposures=n*L*(2 if sym else 1),field_error=float(np.linalg.norm(out-reference)),protected_error=float(np.linalg.norm(I.stokes(out[:2])-I.stokes(reference[:2]))),norm_error=float(abs(np.vdot(out,out).real-np.vdot(z,z).real)))) |
| slopes={} |
| for key in ['forward','palindrome']: |
| r=[r for r in rows if r['method']==key and r['cycles']>=16] |
| slopes[key]=float(np.polyfit(np.log([r['cycles'] for r in r]),np.log([r['field_error'] for r in r]),1)[0]) |
| wrong=I.twirled_kerr(z,V,g,np.array([0,1,2,3]),13) |
| summary['E3_phase_compiler']=dict(exact_tensor_max_residual=maxerr,min_cyclic_settings=4*3+1,used_settings=L,code=q.tolist(),slopes=slopes,bad_code_field_residual=float(np.linalg.norm(wrong-I.average_kerr(z,K)))) |
| write('phase_cycles.csv',rows) |
| print('E4 exact quantum algebra and negative controls',flush=True) |
| qt,raw0,twi0=I.quantum_experiment(0) |
| _,raw1,twi1=I.quantum_experiment(1.3) |
| _,raw2,twi2=I.quantum_experiment(1.3,asymmetry=.12) |
| qr=[] |
| for j,tj in enumerate(qt): |
| qr.append(dict(time=tj,raw_distance=I.trace_distance(raw0[j],raw1[j]),logical_distance=I.trace_distance(twi0[j],twi1[j]),mismatch_distance=I.trace_distance(twi0[j],twi2[j]),trace_error=float(abs(np.trace(raw1[j])-1)))) |
| write('quantum.csv',qr);summary['E4_quantum']=dict(max_logical_distance=max(r['logical_distance'] for r in qr),max_raw_distance=max(r['raw_distance'] for r in qr),max_mismatch_distance=max(r['mismatch_distance'] for r in qr),max_trace_error=max(r['trace_error'] for r in qr),protected_dimension=10,adaptive_dimension=3) |
| print('E5 calibration feasibility, all seeds',flush=True) |
| cr=[I.calibration_trial(s) for s in range(20)] |
| write('calibration.csv',cr);summary['E5_calibration']=dict(trials=20,feasible=sum(r['success'] for r in cr),infeasible=sum(not r['success'] for r in cr),largest_feasible_residual=max(r['after'] for r in cr if r['success']),controls=8,domains=16,modes=4) |
| print('E6 finite noisy online adaptation',flush=True) |
| lr=[];hist=[] |
| for s in range(8): |
| res=I.finite_online(s) |
| for h in res.pop('hist'):hist.append(dict(seed=s,**h)) |
| lr.append(res) |
| write('learning.csv',hist) |
| (R/'learning_runs.json').write_text(json.dumps(lr,indent=2)) |
| summary['E6_learning']=dict(runs=8,final_rmse_min=min(r['final_rmse'] for r in lr),final_rmse_max=max(r['final_rmse'] for r in lr),final_rmse_median=float(np.median([r['final_rmse'] for r in lr])),linear_baseline=lr[0]['final_linear_baseline_rmse'],max_protected_drift=max(r['max_protected_stokes_drift'] for r in lr),microscopic_binary_slots=6*65536,retained_count_bits=6*np.log2(65537),model_parameters=6,training_batches=600,read_noise_sigma=.005) |
| print('E7 microscopic polariton projection test',flush=True) |
| pr=[] |
| for gap in [2,4,8,16,32,64]: |
| _,u=I.microscopic_trajectory(gap,0) |
| _,v=I.microscopic_trajectory(gap,1.) |
| err=float(np.max(np.linalg.norm(I.total_rail_stokes(u)-I.total_rail_stokes(v),axis=1))) |
| leak=I.hopfield_leak_bound(1.,.5,gap) |
| pr.append(dict(gap=gap,full_model_protected_error=err,constant_shift_linear_branch_bound=leak)) |
| write('polariton_projection.csv',pr);summary['E7_projection']=pr |
| print('E8 mismatch occupation budget and information',flush=True) |
| T=5.;S=T+.6*(1-np.cos(.8*T))/.8 |
| mr=[] |
| for delta in np.logspace(-6,-.5,16): |
| err=2*abs(np.sin(delta*S)) |
| mr.append(dict(row_half_mismatch=delta,integrated_adaptive_occupation=S,exact_stokes_chord=err,linear_bound=2*delta*S)) |
| write('mismatch_budget.csv',mr) |
| qvar=100.;sigma=.03;P=1.;rr=[] |
| for mismatch in [0,.001,.01,.1,1]: |
| variance=2*sigma*sigma+4*mismatch*mismatch*qvar |
| rr.append(dict(mismatch=mismatch,noise_variance=variance,local_bits_per_observation=.5*np.log2(1+P/variance))) |
| write('task_information.csv',rr);summary['E8_mismatch_and_information']=dict(integrated_occupation=S,exact_balanced_noise=rr[0]['noise_variance'],local_capacity_balanced=rr[0]['local_bits_per_observation'],not_a_storage_capacity=True) |
| print('E9 spectral and control resource limits',flush=True) |
| br=[] |
| for m in [2,4,8,16,32,64,128]: |
| br.append(dict(modes=m,minimum_cyclic_settings=m*(m-1)+1,spectral_span_in_gap_units=I.bandwidth_lower_bound(m,1),pair_sums=m*(m+1)//2)) |
| write('resource_scaling.csv',br) |
| co=[] |
| for b in [1e-9,1e-8,1e-7,1e-6,1e-5,1e-4,1e-3]: |
| opt,err=I.cycle_cost_optimum(.1,b) |
| co.append(dict(per_cycle_error=b,optimal_real_cycles=opt,best_proxy_error=err)) |
| write('control_cost.csv',co);summary['E9_resources']=dict(four_modes_minimum_cyclic_settings=13,quadratic_spectral_and_cyclic_scaling=True,phase_switches_not_free=True) |
| print('E10 check microscopic shot statistics',flush=True) |
| rng=np.random.default_rng(91);K=256;n=np.full(40000,100);target=np.full(len(n),.6) |
| out,doses=I.exchange_sample(n,K,target,rng) |
| pi=.995;e=np.exp(-doses[0]);p11=pi+(1-pi)*e;p01=pi*(1-e) |
| var=100*p11*(1-p11)+(K-100)*p01*(1-p01) |
| summary['E10_finite_statistics']=dict(samples=len(n),expected_mean=K*.6,sampled_mean=float(out.mean()),expected_variance=var,sampled_variance=float(out.var()),dose=float(doses[0])) |
| print('E11 branch-complete compiler with full photon/exciton dynamics',flush=True) |
| br=[] |
| ref=I.branch_average_reference(True) |
| for n in [0,2,4,8,16,32,64]: |
| active=I.branch_complete_cycle(n,True) |
| idle=I.branch_complete_cycle(n,False) |
| incomplete=I.branch_complete_cycle(n,True,True) if n in [0,8,32,64] else None |
| row=dict(cycles=n,exposures=26*n,concurrent_stokes_error=float(np.linalg.norm(I.stokes(active[:2])-I.stokes(idle[:2]))),full_to_average_field_error=float(np.linalg.norm(active-ref))) |
| if incomplete is not None: |
| incomplete_idle=I.branch_complete_cycle(n,False,True) |
| row['incomplete_code_error']=float(np.linalg.norm(I.stokes(incomplete[:2])-I.stokes(incomplete_idle[:2]))) |
| br.append(row) |
| write('branch_complete.csv',br) |
| summary['E11_branch_complete']=dict(results=br,full_photon_exciton_evolution=True,branch_projection=False,ideal_instantaneous_polariton_mode_phase_gates=True,unequal_photon_exciton_amplitude_damping=[.03,.11]) |
| print('E12 full-field closed-loop coefficient adaptation',flush=True) |
| fr=[];fh=[] |
| for seed in range(4): |
| item=I.integrated_feedback(seed) |
| for row in item.pop('history'):fh.append(dict(seed=seed,**row)) |
| fr.append(item) |
| bad=I.integrated_feedback(0,incomplete=True) |
| bad.pop('history') |
| refined=I.integrated_feedback(0,subdivisions=8) |
| fine_hist=refined.pop('history') |
| coarse=[r for r in fh if r['seed']==0] |
| grid_error=max(abs(a['protected_error']-b['protected_error']) for a,b in zip(coarse,fine_hist)) |
| write('integrated_feedback.csv',fh) |
| summary['E12_integrated_feedback']=dict(runs=fr,incomplete_control=bad,refined_run=refined,refinement_protected_error_difference=grid_error, |
| ideal_modal_phase_gates=True,controller='fixed phase tracking, not autonomous algorithm invention', |
| finite_memory_updates='endpoint writes at microcycle boundaries',full_two_branch_dynamics=True) |
| print('E13 native phase-gate synthesis and finite-speed Kerr defect',flush=True) |
| V=I.full_polariton_basis();q=np.array([0,1,3,9]);exact=[] |
| for phi in list(2*np.pi*np.arange(13)/13)+[.137,1.217,-.43]: |
| target=V@np.diag(np.exp(1j*phi*q))@V.conj().T |
| exact.append(float(np.linalg.norm(I.native_phase_unitary(phi)-target))) |
| finite=[I.native_gate_with_kerr(strength) for strength in [50,200,800,3200]] |
| write('native_phase_gates.csv',finite) |
| summary['E13_native_phase_synthesis']=dict(max_matrix_residual=max(exact),settings_checked=len(exact), |
| native_control_families=3,primitive_factors=15,finite_speed_results=finite, |
| native_controls_assumed_tunable=True,full_gate_learning_loop_not_simulated=True) |
| (R/'summary.json').write_text(json.dumps(summary,indent=2,sort_keys=True)+'\n') |
| print(json.dumps(summary,indent=2),flush=True) |
|
|
| if __name__=='__main__':main() |
|
|
