| |
| """Structured-operator retention study. Standard robust linear algebra. |
| |
| All uncertainty operators are supplied to the solver; this is not shift prediction. |
| The protocol is written before experiments, and hashes source and assumptions. |
| """ |
| from __future__ import annotations |
| import csv,hashlib,json,time |
| from pathlib import Path |
| import numpy as np |
|
|
| HERE=Path(__file__).resolve().parent |
| RHO=.25;TAU=.03;RIDGE=.01 |
| SEEDS=range(16) |
| CONFIGS=[(p,n,r,m,False) for p in (64,128) for n in (96,256) for r in (2,4) for m in (2,4)] |
| CONFIGS.append((64,96,4,16,True)) |
| METHODS=['nominal_null_ridge','robust_projector_ridge','optimized_robust_basis_ridge','scalar_budget_nominal','no_change'] |
|
|
|
|
| def dump(path,obj):Path(path).write_text(json.dumps(obj,indent=2,allow_nan=False)) |
| def sha(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest() |
|
|
|
|
| def nullspace(a): |
| _,s,v=np.linalg.svd(a,full_matrices=True) |
| tol=max(a.shape)*np.finfo(float).eps*(s[0] if len(s) else 1.) |
| rank=int(np.sum(s>tol)) |
| return v[rank:].T,rank |
|
|
|
|
| def orthonormal_rows(rng,r,p): |
| q,_=np.linalg.qr(rng.normal(size=(p,r))) |
| return q.T |
|
|
|
|
| def basis_ridge(x,y,b): |
| basis,rank=nullspace(b) |
| if not basis.shape[1]:return np.zeros(x.shape[1]),rank |
| z=x@basis |
| w=np.linalg.solve(z.T@z+len(y)*RIDGE*np.eye(z.shape[1]),z.T@y) |
| return basis@w,rank |
|
|
|
|
| def projector_ridge(x,y,b): |
| basis,rank=nullspace(b) |
| projector=basis@basis.T |
| k=projector@x.T@x@projector+len(y)*RIDGE*np.eye(x.shape[1]) |
| w=projector@np.linalg.solve(k,projector@x.T@y) |
| return w,rank |
|
|
|
|
| def certificate(d,b0,bs,radius=RHO): |
| nominal=float(np.linalg.norm(b0@d)) |
| directions=np.column_stack([b@d for b in bs]) |
| u,s,vt=np.linalg.svd(directions,full_matrices=False) |
| sigma=float(s[0]) if len(s) else 0. |
| theta=radius*vt[0] if len(s) else np.zeros(len(bs)) |
| shift=b0+sum(t*b for t,b in zip(theta,bs)) |
| attained=float(np.linalg.norm(shift@d)) |
| reverse_attained=float(np.linalg.norm((b0-sum(t*b for t,b in zip(theta,bs)))@d)) |
| |
| return {'nominal_norm':nominal,'uncertainty_spectral_norm':sigma, |
| 'certified_uniform_upper_bound':nominal+radius*sigma, |
| 'nominal_null_exact_worstcase':radius*sigma, |
| 'top_singular_adversary_norm':max(attained,reverse_attained), |
| 'top_singular_theta':theta.tolist()} |
|
|
|
|
| def problem(seed,p,n,r,m): |
| rng=np.random.default_rng(np.random.SeedSequence([1200000+seed,p,n,r,m])) |
| b0=orthonormal_rows(rng,r,p);bs=[orthonormal_rows(rng,r,p) for _ in range(m)] |
| stack=np.vstack([b0]+bs);basis,rank=nullspace(stack) |
| target=rng.normal(size=p);target/=np.linalg.norm(target) |
| |
| safe=basis@(basis.T@target) if basis.shape[1] else np.zeros(p) |
| conflict=stack.T@rng.normal(size=len(stack));conflict/=max(np.linalg.norm(conflict),1e-12) |
| if np.linalg.norm(safe)>1e-12:safe/=np.linalg.norm(safe) |
| target=safe+conflict;target/=np.linalg.norm(target) |
| x=rng.normal(size=(n,p));y=x@target+rng.normal(0,.1,n) |
| test=rng.normal(size=(1024,p));ytest=test@target+rng.normal(0,.1,1024) |
| |
| theta=rng.normal(size=(64,m));theta/=np.linalg.norm(theta,axis=1)[:,None] |
| theta*=RHO*rng.uniform(size=(64,1))**(1/m) |
| return x,y,test,ytest,b0,bs,theta,rank |
|
|
|
|
| def compose_example(): |
| b=np.array([[1.,0.,0.]]) |
| a1=np.zeros((3,3));a1[0,1]=1. |
| a2=np.zeros((3,3));a2[1,2]=1. |
| d=np.array([0.,0.,1.]) |
| first=np.vstack([b,b@a1,b@a2]);closed=np.vstack([first,b@a1@a2,b@a2@a1]) |
| return {'b0':b.tolist(),'a1':a1.tolist(),'a2':a2.tolist(),'update':d.tolist(), |
| 'one_step_stack_residual':float(np.linalg.norm(first@d)), |
| 'ordered_two_step_retention_residual':float(np.linalg.norm(b@a1@a2@d)), |
| 'reverse_order_retention_residual':float(np.linalg.norm(b@a2@a1@d)), |
| 'one_step_rank':nullspace(first)[1],'composition_closure_rank':nullspace(closed)[1], |
| 'interpretation':'Known observability/invariant-subspace issue: single-step kernels do not guarantee preservation under unmodeled compositions.'} |
|
|
|
|
| def tests(): |
| rng=np.random.default_rng(765) |
| b0=orthonormal_rows(rng,3,17);bs=[orthonormal_rows(rng,3,17) for _ in range(2)] |
| basis,rank=nullspace(b0);d=basis@rng.normal(size=basis.shape[1]);c=certificate(d,b0,bs) |
| assert c['nominal_norm']<1e-12 |
| assert abs(c['top_singular_adversary_norm']-c['nominal_null_exact_worstcase'])<1e-12 |
| for _ in range(100): |
| theta=rng.normal(size=2);theta*=RHO*rng.random()/np.linalg.norm(theta) |
| assert np.linalg.norm((b0+sum(t*b for t,b in zip(theta,bs)))@d)<=c['certified_uniform_upper_bound']+1e-12 |
| stack=np.vstack([b0]+bs);x=rng.normal(size=(50,17));y=rng.normal(size=50) |
| a,_=basis_ridge(x,y,stack);b,_=projector_ridge(x,y,stack) |
| assert np.max(np.abs(a-b))<1e-10 |
| assert np.linalg.norm(stack@a)<1e-12 |
| ex=compose_example();assert ex['one_step_stack_residual']==0 and ex['ordered_two_step_retention_residual']==1 |
| return {'passed':5,'scope':'exact spectral adversary;100 bounded random shifts; projected/basis ridge equality; common-kernel residual; noncommuting composition counterexample'} |
|
|
|
|
| def boot(a,seed=326): |
| a=np.asarray(a,float);rng=np.random.default_rng(seed) |
| b=a[rng.integers(len(a),size=(4000,len(a)))].mean(1) |
| return {'mean':float(a.mean()),'median':float(np.median(a)), |
| 'mean_ci95':[float(v) for v in np.quantile(b,[.025,.975])]} |
|
|
|
|
| def main(): |
| out=HERE/'results';out.mkdir(exist_ok=True) |
| protocol={'source_sha256':sha(__file__),'status':'frozen before measurements','seed_range':list(SEEDS), |
| 'configs_p_n_r_m_stress':CONFIGS,'rho':RHO,'tau':TAU,'ridge':RIDGE,'methods':METHODS, |
| 'known_model':'B(theta)=B0+sum theta_l B_l; all B_l are supplied exactly; ||theta||2<=rho', |
| 'target':'fixed equal norm mixture of common-kernel and conflicting known-operator rowspace components', |
| 'test':'1024 fresh Gaussian inputs;16 independent seeds per config', |
| 'claim':'standard robust linear algebra, no novelty or prediction of unknown shift directions', |
| 'outside_model':'2rho along top singular adversary, and worst arbitrary new unit-norm operator rho*||d||', |
| 'composition':'predeclared 3D noncommuting one-step/composed preservation counterexample', |
| 'runtime':'solver/factorization per method timed independently; shared synthetic data generation excluded'} |
| dump(out/'protocol.json',protocol) |
| print('Frozen protocol',sha(out/'protocol.json'),flush=True) |
| checked=tests();rows=[];details=[];order=np.random.default_rng(1009) |
| for seed in SEEDS: |
| for p,n,r,m,stress in CONFIGS: |
| x,y,xt,yt,b0,bs,theta,stackrank=problem(seed,p,n,r,m) |
| stack=np.vstack([b0]+bs);solutions={} |
| for method in order.permutation(METHODS): |
| start=time.perf_counter() |
| if method=='nominal_null_ridge':d,rank=basis_ridge(x,y,b0) |
| elif method=='robust_projector_ridge':d,rank=projector_ridge(x,y,stack) |
| elif method=='optimized_robust_basis_ridge':d,rank=basis_ridge(x,y,stack) |
| elif method=='scalar_budget_nominal': |
| d,rank=basis_ridge(x,y,b0);c=certificate(d,b0,bs) |
| d*=min(1.,TAU/max(c['certified_uniform_upper_bound'],1e-15)) |
| else:d=np.zeros(p);rank=stackrank |
| solve=time.perf_counter()-start |
| c=certificate(d,b0,bs);outside=certificate(d,b0,bs,2*RHO) |
| random_norms=[np.linalg.norm((b0+sum(t*b for t,b in zip(th,bs)))@d) for th in theta] |
| residual=float(np.linalg.norm(stack@d)) |
| te=float(np.mean((xt@d-yt)**2));tr=float(np.mean((x@d-y)**2)) |
| row={'seed':seed,'p':p,'n':n,'r':r,'uncertainty_components':m,'rank_exhaustion_stress':stress, |
| 'method':method,'stack_rank':stackrank,'robust_nullity':p-stackrank, |
| 'generic_minimum_support_circuit_arity':stackrank+1, |
| 'solver_s':solve,'test_nmse':te/max(float(np.var(yt)),1e-12),'train_mse':tr, |
| 'update_norm':float(np.linalg.norm(d)),'stack_residual':residual, |
| 'nominal_retention_norm':c['nominal_norm'], |
| 'uniform_retention_upper_bound':c['certified_uniform_upper_bound'], |
| 'exact_worstcase_given_nominal_null':c['nominal_null_exact_worstcase'], |
| 'attained_top_singular_retention':c['top_singular_adversary_norm'], |
| 'max_64_random_shift_retention':float(max(random_norms)), |
| 'within_tau_uniform_certificate':c['certified_uniform_upper_bound']<=TAU+1e-10, |
| 'strict_common_kernel_preservation':residual<1e-10, |
| 'outside_2rho_top_singular_retention':outside['top_singular_adversary_norm'], |
| 'outside_2rho_violates_tau':outside['top_singular_adversary_norm']>TAU+1e-10, |
| 'outside_arbitrary_new_unit_operator_worstcase':RHO*float(np.linalg.norm(d))} |
| rows.append(row);solutions[method]=d |
| details.append({**row,'update':d.tolist(),'within_radius_top_singular_theta':c['top_singular_theta']}) |
| err=float(np.max(np.abs(solutions['robust_projector_ridge']-solutions['optimized_robust_basis_ridge']))) |
| assert err<1e-8 |
| for row in rows[-len(METHODS):]:row['robust_projector_basis_max_update_difference']=err |
| print('Seed completed',seed,flush=True) |
| with (out/'rows.csv').open('w') as f: |
| w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows) |
| dump(out/'details.json',details) |
| summary={'self_tests':checked,'source_matches_protocol':sha(__file__)==protocol['source_sha256'], |
| 'protocol_sha256':sha(out/'protocol.json'),'main':{},'rank_exhaustion_stress':{},'by_config':{}, |
| 'maximum_projector_basis_update_difference':max(r['robust_projector_basis_max_update_difference'] for r in rows), |
| 'composition_counterexample':compose_example()} |
| keys=['test_nmse','solver_s','uniform_retention_upper_bound','attained_top_singular_retention', |
| 'max_64_random_shift_retention','within_tau_uniform_certificate','strict_common_kernel_preservation', |
| 'outside_2rho_top_singular_retention','outside_2rho_violates_tau','outside_arbitrary_new_unit_operator_worstcase'] |
| for stress,label in [(False,'main'),(True,'rank_exhaustion_stress')]: |
| for method in METHODS: |
| rs=[r for r in rows if r['method']==method and r['rank_exhaustion_stress']==stress] |
| summary[label][method]={k:boot([r[k] for r in rs]) for k in keys} |
| for p,n,r,m,stress in CONFIGS: |
| key=f'p{p}_n{n}_r{r}_m{m}';summary['by_config'][key]={} |
| for method in METHODS: |
| rs=[a for a in rows if (a['p'],a['n'],a['r'],a['uncertainty_components'],a['method'])==(p,n,r,m,method)] |
| summary['by_config'][key][method]={k:boot([a[k] for a in rs]) for k in keys} |
| dump(out/'summary.json',summary) |
| print('Finished',json.dumps({'main':{k:{q:v[q]['mean'] for q in ['test_nmse','within_tau_uniform_certificate','solver_s']} for k,v in summary['main'].items()},'equivalence':summary['maximum_projector_basis_update_difference']}),flush=True) |
|
|
|
|
| if __name__=='__main__':main() |
|
|
