code/check_independent.py

#!/usr/bin/env python3
"""Read-only verification by full-space signed inequalities and Cramer's rule.
No import from verify_primary, legacy checkers, scipy, or discovery code.
The catalogue orbit enumeration is inherited metadata, not re-proved here.
"""
from __future__ import annotations
import itertools, json, math, time
from fractions import Fraction
from functools import lru_cache
from pathlib import Path
from collections import Counter
F=Fraction
ROOT=Path(__file__).resolve().parents[1]
COUNTS=Counter()
def insist(c,m):
    if not c:raise AssertionError(m)
def scalar(v,w):
    s=F(0)
    for i in range(len(v)):s+=v[i]*w[i]
    return s
@lru_cache(None)
def det(rows):
    n=len(rows)
    if n==0:return 1
    t=[list(r) for r in rows];sign=1;div=1
    for k in range(n-1):
        if not t[k][k]:
            p=next((i for i in range(k+1,n) if t[i][k]),None)
            if p is None:return 0
            t[k],t[p]=t[p],t[k];sign=-sign
        pivot=t[k][k]
        for i in range(k+1,n):
            for j in range(k+1,n):
                z=pivot*t[i][j]-t[i][k]*t[k][j]
                insist(z%div==0,'nonexact Bareiss division');t[i][j]=z//div
            t[i][k]=0
        div=pivot
    return sign*t[n-1][n-1]
@lru_cache(None)
def reconstruct_positive(normalized_rows):
    n=len(normalized_rows[0]);integer=[];rhs=[]
    for r in normalized_rows:
        den=math.lcm(*(x.denominator for x in r))
        integer.append(tuple(int(x*den) for x in r));rhs.append(den)
    for i in range(n):integer.append(tuple(-int(i==j) for j in range(n)));rhs.append(0)
    verts=set()
    for ix in itertools.combinations(range(len(integer)),n):
        COUNTS['full_orthant_bases']+=1
        mat=tuple(integer[i] for i in ix);dv=det(mat)
        if dv==0:continue
        b=tuple(rhs[i] for i in ix)
        sol=tuple(F(det(tuple(tuple(b[i] if j==k else mat[i][j] for j in range(n)) for i in range(n))),dv) for k in range(n))
        if min(sol)<0:continue
        if all(scalar(r,sol)<=1 for r in normalized_rows):verts.add(sol)
    return tuple(sorted(verts))
def signs(v):
    ss=[i for i,x in enumerate(v) if x]
    for word in itertools.product((-1,1),repeat=len(ss)):
        w=list(v)
        for i,s in zip(ss,word):w[i]=s*v[i]
        yield tuple(w)
def inspect(c,rows,points):
    n=c['dimension'];savedrows=tuple(tuple(map(F,r)) for r in c['positive_rows'])
    insist(tuple(rows)==savedrows,'description mismatch')
    insist(set(points)=={tuple(map(F,v)) for v in c['positive_generators']},'incomplete generator set')
    normals=tuple(sorted({u for r in rows for u in signs(r)}))
    directions=[tuple(map(F,d)) for d in c['directions']]
    insist(all(max(map(abs,d))==1 for d in directions),'direction normalization')
    insist(len(directions)==c['direction_count'] and len(set(directions))==len(directions),'cardinality')
    products=[[scalar(u,d) for d in directions] for u in normals]
    A=max(sum(map(abs,u)) for u in normals);B=max(abs(z) for p in products for z in p)
    gaps=[]
    for v in points:
        for u in normals:
            g=1-scalar(u,v);insist(g>=0,'generator outside')
            if g:gaps.append(g)
    g=min(gaps);allmargins=[];checks=[]
    for pv in points:
        for v in signs(pv):
            active=[j for j,u in enumerate(normals) if scalar(u,v)==1]
            if not active:continue
            mm=[min(-products[j][i] for j in active) for i in range(len(directions))]
            a=max(mm);insist(a>0,'unilluminated boundary generator')
            allmargins.append(a);checks.append((v,mm.index(a)))
            COUNTS['signed_boundary_generators']+=1
    a=min(allmargins);eta=min(F(1,2),g/F(2*n+2));t=eta/(a+B);h=t*a/(3*A)
    for key,val in [('g',g),('a',a),('A',A),('B',B),('eta',eta),('tau',t),('closed_Hausdorff_radius',h),('blocking_slack_lower_bound',3*h),('open_Hausdorff_radius',3*h/2),('inner_core_factor',1-2*A*h)]:
        insist(F(c[key])==val,f'constant mismatch {key}')
    target=1-2*A*h
    for v,di in checks:
        w=tuple(v[i]+t*directions[di][i] for i in range(n))
        for u in normals:
            insist(scalar(u,w)<=target,'signed inequality landing failure')
            COUNTS['signed_inequality_landing_checks']+=1
        COUNTS['uniform_landings']+=1
    COUNTS['certificates']+=1
    return h

def main():
    start=time.perf_counter()
    cat=json.loads((ROOT/'data/legacy_catalogue.json').read_text())
    atlas=json.loads((ROOT/'data/robust_atlas_360.json').read_text())
    insist(len(atlas)==360,'atlas size')
    radii=[]
    for i,(old,c) in enumerate(zip(cat['certificates'],atlas)):
        unit=tuple(tuple(F((mask>>j)&1) for j in range(5)) for mask in old['facets'])
        pv=reconstruct_positive(unit)
        rows,points=(unit,pv) if old['body']=='P' else (tuple(v for v in pv if any(v)),unit)
        radii.append(inspect(c,rows,points))
        if (i+1)%60==0:print(f'Independent atlas: {i+1}/360',flush=True)
    c=json.loads((ROOT/'data/cyclic_certificate.json').read_text())
    rows=tuple(tuple(map(F,r)) for r in c['positive_rows']);pv=reconstruct_positive(rows)
    model_h=inspect(c,rows,pv)
    # The actual saved landing vectors are checked, not merely recomputed summaries.
    normals=tuple(sorted({u for r in rows for u in signs(r)}));ds=[tuple(map(F,d)) for d in c['directions']];tau=F(c['tau'])
    for rec in c['landings']:
        v=tuple(map(F,rec['point']));di=rec['direction_index'];w=tuple(map(F,rec['landing']))
        insist(w==tuple(v[i]+tau*ds[di][i] for i in range(5)),'saved displacement mismatch')
        insist(all(scalar(u,w)<=F(c['inner_core_factor']) for u in normals),'saved landing fails')
        COUNTS['saved_model_landings']+=1
    rec=c['landings'][0];v=tuple(map(F,rec['point']))
    insist(any(scalar(u,v)==1 for u in normals),'zero-direction mutation did not hit boundary')
    report={'status':'PASS','arithmetic':'exact integers, Bareiss determinants, Cramer fractions','stats':dict(COUNTS),
            'atlas_minimum_closed_radius':str(min(radii)),'model_closed_radius':str(model_h),
            'zero_direction_mutation_rejected':True,'imports_previous_or_primary_verifiers':False,
            'orbit_enumeration_repeated':False,'unrestricted_5d_theorem_proved':False,
            'elapsed_seconds':round(time.perf_counter()-start,3),'determinant_cache':str(det.cache_info())}
    (ROOT/'verification/independent_report.json').write_text(json.dumps(report,indent=2)+'\n');print(json.dumps(report,indent=2))
if __name__=='__main__':main()