Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
convex-geometry
discrete-geometry
illumination-problem
computational-mathematics
exact-arithmetic
| #!/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 | |
| 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] | |
| 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() | |