| """Independent small-matrix checks for the hereditary quantum refusal theorem. |
| Intermediate verification source; NumPy is the only nonstandard dependency. |
| """ |
| from __future__ import annotations |
| import itertools,json,math |
| from pathlib import Path |
| import numpy as np |
|
|
|
|
| def kron_all(xs): |
| out=np.array([[1.0+0j]]) |
| for x in xs: out=np.kron(out,x) |
| return out |
|
|
|
|
| def downset(facets,n): |
| return {s for s in range(1<<n) if any((s & ~f)==0 for f in facets)} |
|
|
|
|
| def probability(q,K): |
| n=len(q) |
| return sum(math.prod(q[i] if (s>>i)&1 else 1-q[i] for i in range(n)) |
| for s in range(1<<n) if s not in K) |
|
|
|
|
| def matrix_checks(seed=20261024,trials=24): |
| rng=np.random.default_rng(seed) |
| max_proj=max_prob=max_allowed=max_dom=0.0 |
| comparisons=0 |
| for run in range(trials): |
| n=3 if run<18 else 4 |
| dims=[3]*n |
| families=[];P=[];Q=[] |
| for i,d in enumerate(dims): |
| A=rng.normal(size=(d,d))+1j*rng.normal(size=(d,d)) |
| U,_=np.linalg.qr(A) |
| rank=1+(run+i)%2 |
| weights=rng.uniform(.3,1.0,rank); weights/=weights.sum() |
| zero=(U[:,:rank]*weights)@U[:,:rank].conj().T |
| B=rng.normal(size=(d,d))+1j*rng.normal(size=(d,d)) |
| one=B@B.conj().T+np.eye(d)*.1; one/=np.trace(one) |
| families.append([zero,one]) |
| P.append(U[:,:rank]@U[:,:rank].conj().T) |
| Q.append(np.eye(d)-P[-1]) |
| facets=rng.integers(0,1<<n,size=2+(run%3)).tolist() |
| K=downset(facets,n) |
| rho=[kron_all([families[i][(x>>i)&1] for i in range(n)]) for x in range(1<<n)] |
| allowed=sum((rho[x] for x in K),start=np.zeros_like(rho[0])) |
| eig,V=np.linalg.eigh(allowed) |
| keep=eig>1e-9 |
| E_global=np.eye(3**n)-V[:,keep]@V[:,keep].conj().T |
| E_local=sum((kron_all([Q[i] if (s>>i)&1 else P[i] for i in range(n)]) |
| for s in range(1<<n) if s not in K),start=np.zeros_like(E_global)) |
| max_proj=max(max_proj,float(np.linalg.norm(E_global-E_local,2))) |
| for x in range(1<<n): |
| q=[float(np.trace(Q[i]@families[i][(x>>i)&1]).real) for i in range(n)] |
| actual=float(np.trace(E_global@rho[x]).real) |
| pred=probability(q,K) |
| max_prob=max(max_prob,abs(actual-pred)); comparisons+=1 |
| if x in K: max_allowed=max(max_allowed,abs(actual)) |
| |
| null=V[:,~keep] |
| if null.shape[1]: |
| A=rng.normal(size=(null.shape[1],null.shape[1]))+1j*rng.normal(size=(null.shape[1],null.shape[1])) |
| H=A@A.conj().T |
| H/=max(1.,float(np.linalg.eigvalsh(H)[-1])) |
| E=null@H@null.conj().T |
| max_dom=max(max_dom,float(max(0.,-np.linalg.eigvalsh(E_global-E)[0]))) |
| return {"trials":trials,"product_input_comparisons":comparisons, |
| "maximum_projector_operator_norm_difference":max_proj, |
| "maximum_probability_absolute_difference":max_prob, |
| "maximum_false_refusal_on_allowed_word":max_allowed, |
| "maximum_lowner_domination_violation":max_dom} |
|
|
|
|
| def polynomial_check(): |
| |
| circuits=[0b00111,0b11100,0b01001] |
| K={s for s in range(32) if not any((s&c)==c for c in circuits)} |
| rng=np.random.default_rng(46) |
| err=0. |
| for _ in range(100): |
| q=rng.uniform(size=5) |
| term=lambda s:math.prod(q[i] for i in range(5) if (s>>i)&1) |
| compact=term(0b01001)+term(0b00111)+term(0b11100)-term(0b01111)-term(0b11101) |
| err=max(err,abs(probability(q,K)-compact)) |
| return {"random_parameter_comparisons":100,"maximum_polynomial_difference":err} |
|
|
|
|
|
|
| def pure_state_checks(seed=864126): |
| rng=np.random.default_rng(seed) |
| max_projector=max_probability=max_sound=0.0 |
| cases=[]; comparisons=0 |
| def forests_k4(): |
| edges=list(itertools.combinations(range(4),2)); K=set() |
| for S in range(1<<len(edges)): |
| parent=list(range(4)); good=True |
| def find(a): |
| while parent[a]!=a: a=parent[a] |
| return a |
| for j,(a,b) in enumerate(edges): |
| if not((S>>j)&1): continue |
| u,v=find(a),find(b) |
| if u==v: good=False; break |
| parent[u]=v |
| if good: K.add(S) |
| return K |
| circuits=[0b00111,0b11100,0b01001] |
| specs=[('sparse_n6_t2',6,{s for s in range(64) if s.bit_count()<=2}), |
| ('graphic_K4_forests',6,forests_k4()), |
| ('nonmatroid_three_forbidden_supports',5, |
| {s for s in range(32) if not any((s&c)==c for c in circuits)}), |
| ('arbitrary_downset_n6',6,downset([0b001111,0b110011,0b101100],6)), |
| ('full_simplex_n4',4,set(range(16))), |
| ('zero_word_only_n4',4,{0})] |
| for name,n,K in specs: |
| zeros=[];ones=[];perps=[] |
| for i in range(n): |
| A=rng.normal(size=(2,2))+1j*rng.normal(size=(2,2)) |
| U,_=np.linalg.qr(A) |
| b=rng.uniform(.2,.9); phase=np.exp(1j*rng.uniform(-np.pi,np.pi)) |
| zeros.append(U[:,0]);perps.append(U[:,1]) |
| ones.append(b*phase*U[:,0]+math.sqrt(1-b*b)*U[:,1]) |
| def state(x,excitation=False): |
| out=np.array([1.+0j]) |
| for i in range(n): |
| v=(perps[i] if excitation else ones[i]) if (x>>i)&1 else zeros[i] |
| out=np.kron(out,v) |
| return out |
| Phi=np.column_stack([state(x) for x in sorted(K)]) |
| U,sv,_=np.linalg.svd(Phi,full_matrices=False) |
| keep=sv>1e-10 |
| E_global=np.eye(1<<n)-U[:,keep]@U[:,keep].conj().T |
| bad=[state(s,True) for s in range(1<<n) if s not in K] |
| E_local=(np.column_stack(bad)@np.column_stack(bad).conj().T |
| if bad else np.zeros_like(E_global)) |
| error=float(np.linalg.norm(E_global-E_local,2)) |
| max_projector=max(max_projector,error) |
| local_err=0.0 |
| for x in range(1<<n): |
| psi=state(x) |
| actual=float(np.vdot(psi,E_global@psi).real) |
| q=[1-abs(np.vdot(zeros[i],ones[i]))**2 if (x>>i)&1 else 0. |
| for i in range(n)] |
| pred=probability(q,K) |
| local_err=max(local_err,abs(actual-pred)); comparisons+=1 |
| if x in K:max_sound=max(max_sound,abs(actual)) |
| max_probability=max(max_probability,local_err) |
| cases.append({'name':name,'coordinates':n,'allowed_words':len(K), |
| 'projector_difference':error,'maximum_probability_difference':local_err}) |
| return {'cases':cases,'word_comparisons':comparisons, |
| 'maximum_projector_operator_norm_difference':max_projector, |
| 'maximum_probability_absolute_difference':max_probability, |
| 'maximum_allowed_false_refusal':max_sound},specs |
|
|
|
|
| def link_bound_checks(specs,seed=29596): |
| rng=np.random.default_rng(seed) |
| worst_violation=0.;saturated_error=0.;checks=0 |
| for name,n,K in specs: |
| full=(1<<n)-1 |
| for S in K: |
| eps=rng.uniform(.005,.15,n) |
| qs=[rng.uniform(.1,.95) if (S>>i)&1 else eps[i] for i in range(n)] |
| actual=probability(qs,K) |
| outside=full^S |
| |
| upper=0. |
| for N in range(1<<n): |
| if N & ~outside: continue |
| if (S|N) in K: continue |
| upper+=math.prod(eps[i] if (N>>i)&1 else 1-eps[i] |
| for i in range(n) if (outside>>i)&1) |
| worst_violation=max(worst_violation,actual-upper) |
| saturated=[1. if (S>>i)&1 else eps[i] for i in range(n)] |
| saturated_error=max(saturated_error,abs(probability(saturated,K)-upper)) |
| checks+=1 |
| return {'allowed_support_checks':checks, |
| 'maximum_false_positive_bound_violation':worst_violation, |
| 'maximum_saturated_equality_error':saturated_error} |
|
|
|
|
| def full_rank_background_check(): |
| |
| rho0=np.diag([.9,.1]); allowed=np.kron(rho0,rho0) |
| w,V=np.linalg.eigh(allowed) |
| E=np.eye(4)-V[:,w>1e-12]@V[:,w>1e-12].conj().T |
| return {'minimum_allowed_state_eigenvalue':float(w.min()), |
| 'maximal_refusal_effect_operator_norm':float(np.linalg.norm(E,2))} |
|
|
|
|
| if __name__=='__main__': |
| pure,specs=pure_state_checks() |
| result={'pure_state_filter':pure,'mixed_state_filter':matrix_checks(), |
| 'five_vertex_overlap_polynomial':polynomial_check(), |
| 'false_positive_link_bound':link_bound_checks(specs), |
| 'full_rank_background_obstruction':full_rank_background_check()} |
| assert pure['maximum_projector_operator_norm_difference'] < 1e-9 |
| assert pure['maximum_probability_absolute_difference'] < 1e-9 |
| assert result['mixed_state_filter']['maximum_projector_operator_norm_difference'] < 1e-9 |
| assert result['mixed_state_filter']['maximum_probability_absolute_difference'] < 1e-9 |
| assert result['false_positive_link_bound']['maximum_false_positive_bound_violation'] < 1e-12 |
| assert result['false_positive_link_bound']['maximum_saturated_equality_error'] < 1e-12 |
| assert result['five_vertex_overlap_polynomial']['maximum_polynomial_difference'] < 1e-12 |
| assert result['full_rank_background_obstruction']['maximal_refusal_effect_operator_norm'] < 1e-12 |
| result['all_numeric_checks_passed']=True |
| out=Path(__file__).with_name('downset_checks.json') |
| out.write_text(json.dumps(result,indent=2)+'\n') |
| print(json.dumps(result,indent=2)) |
|
|
