research/check_downset.py

"""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))
        # Random sound effect supported in the complement must lie below E_global.
        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():
    # Minimal nonfaces {1,2,3}, {3,4,5}, {1,4}; coordinates numbered 0 below.
    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
            # Probability of forbidden S union N, N has outside independent clicks.
            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():
    # Any full-rank all-zero allowed state rules out nonzero sound effect.
    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))