PureOne's picture
Publish verified v5.0.0 research release
b6f1c7f verified
Raw History Blame Contribute Delete
7.2 kB
"""Reproduce the reported small-instance audits, not an asymptotic benchmark."""
from __future__ import annotations
import sys, json, csv, platform, math
from pathlib import Path
from fractions import Fraction as F
from itertools import combinations,product
from functools import lru_cache
ROOT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(ROOT))
import numpy as np
from evefreq.arithmetic import *
from evefreq.quantization import *
from evefreq.spectral import *
from evefreq.examples import *
def encode(x):
if isinstance(x,F): return str(x)
if isinstance(x,np.generic): return x.item()
raise TypeError(type(x).__name__)
def write(name,obj):
(ROOT/'results'/name).write_text(json.dumps(obj,default=encode,indent=2)+'\n')
def atlas_crosscheck():
path=ROOT/'results/exact_atlas.csv'
if not path.exists(): raise FileNotFoundError('run the C++ exact_atlas first')
@lru_cache(None)
def data(A): return bad_primes(A),unimodular(A),cogirth(A,[1]*len(A))[0]
count=0;distances=0;corpus=set()
with path.open(newline='') as f:
for row in csv.DictReader(f):
A=tuple((int(row[f'a{i}0']),int(row[f'a{i}1'])) for i in range(3));q=int(row['Q']);corpus.add(A)
bp,uni,lam=data(A);safe=all(q%p for p in bp)
assert safe==bool(int(row['safe'])) and uni==bool(int(row['unimodular'])) and lam==int(row['cogirth_unit'])
if q in ENERGY:
assert exact_minimum(A,[1]*3,q)['squared_distance']==int(row['exact_squared_distance_unit']);distances+=1
count+=1
# Verify every unimodular arrangement in the corpus against certified lattice enumeration.
lattice_checks=0
for A in sorted(corpus):
if not data(A)[1]:continue
for w in [(1,1,1),(1,2,3)]:
lam,cc=cogirth(A,w);s,ks,_=shortest_vectors(A,w)
assert s==lam and len(ks)==2*len(cc);lattice_checks+=1
return dict(rows_crosschecked=count,primitive_matrices=len(corpus),exact_distance_checks=distances,certified_lattice_checks=lattice_checks),sorted(corpus)
def smith_audit(corpus):
chosen=corpus[::max(1,len(corpus)//32)][:32];checks=0;states=0
for A in chosen:
for size in range(4):
for ii in combinations(range(3),size):
rows=[A[i] for i in ii]
for q in range(2,11):
actual=sum(all(v%q==0 for v in apply(rows,x)) for x in product(range(q),repeat=2))
assert actual==kernel_count(rows,q,d=2);checks+=1;states+=q*q
return dict(submatrix_modulus_cases=checks,enumerated_residue_states=states)
def spectral_audit():
rng=np.random.default_rng(20261012);records=[]
for case in range(24):
d=case%3+1;m=d+case%4
A=np.vstack([np.eye(d,dtype=int),rng.integers(-3,4,size=(m-d,d))]).tolist()
w=[F(int(v),7) for v in rng.integers(1,22,size=m)];theta=rng.uniform(-2,2,size=d);M=5+case%3;gamma=.75
raw=dense_scan(A,w,theta,M,gamma);expected=phase_map(A,w,theta)
recovery=float(np.max(np.abs(decode_scan(raw,m,M,gamma)-expected)))
J=jacobian(A,w,theta);G=np.array(gram(A,w),dtype=float)
metric=float(np.max(np.abs((J.conj().T@J).real-G)))
other=rng.uniform(-2,2,size=d)
chord=float(abs(np.linalg.norm(phi(A,w,theta)-phi(A,w,other))**2-np.linalg.norm(expected-phase_map(A,w,other))**2))
H=cylinder(np.asarray(A)@theta,w,M,gamma);H0=cylinder(np.zeros(m),w,M,gamma)
direct=fourth_trace(H)-fourth_trace(H0)
formula=8*M*gamma**2*sum(math.sqrt(float(wi))*(math.cos(v)-1) for wi,v in zip(w,np.asarray(A)@theta))
trace=float(abs(direct-formula));eigmin=float(np.linalg.eigvalsh(H).min())
assert recovery<1e-10 and metric<1e-10 and chord<1e-10 and trace<1e-8 and eigmin>-1e-10
records.append(dict(case=case,A=A,weights=w,M=M,N=len(raw),matrix_dimension=len(H),
recovery_residual=recovery,metric_residual=metric,chord_residual=chord,trace_residual=trace,least_eigenvalue=eigmin))
write('dense_spectral_cases.json',records)
return dict(cases=len(records),max_recovery_residual=max(r['recovery_residual'] for r in records),
max_metric_residual=max(r['metric_residual'] for r in records),max_chord_residual=max(r['chord_residual'] for r in records),
max_trace_residual=max(r['trace_residual'] for r in records))
def finite_jet_audit():
inputs=[('coprime_harmonics',[[2],[3]],[1,1]),
('curvature_selection',[[1,0],[0,1],[2,0]],[F(1,4),1,F(3,16)]),
('triangle',[[1,0],[0,1],[1,-1]],[1,1,1]),
('mixed_arithmetic',[[1,0],[0,1],[2,3]],[1,1,F(1,5)])]
certs=[];checks=0
for name,A,w in inputs:
c=stabilization_certificate(A,w); trials=[]
for q in [c['Q0'],c['Q0']+1,c['Q0']+7]:
result=numeric_minimum(A,w,q)
predicted={tuple(v%q for v in k) for k in c['selected_vectors']}
assert set(result['winners'])==predicted;checks+=1
trials.append(dict(Q=q,result=result))
certs.append(dict(name=name,A=A,weights=w,certificate=c,numerical_trials=trials))
write('finite_jet_certificates.json',certs)
return dict(exact_threshold_certificates=len(certs),complete_numerical_alphabets_checked=checks,
thresholds={r['name']:r['certificate']['Q0'] for r in certs})
def metric_audit():
rng=np.random.default_rng(9817);records=[]
for d in range(1,5):
for case in range(3):
R=rng.integers(-3,4,size=(d+1,d));G=(R.T@R+np.eye(d,dtype=int)).tolist()
c=realize_rational_metric(G);assert gram(c['A'],c['weights'])==G
records.append(dict(G=G,certificate=c))
write('rational_metric_certificates.json',records)
return dict(exact_realizations=len(records),dimensions=[1,2,3,4])
def examples_audit():
A=cographic_complete_five();lam,cc=cogirth(A,[1]*10);s,short,_=shortest_vectors(A,[1]*10)
assert (lam,len(cc),s,len(short),det(gram(A,[1]*10)))==(3,10,3,20,125)
out=[]
for q in [2,3,4,6]:
r=exact_minimum(A,[1]*10,q);assert r['squared_distance']==ENERGY[q][1]*3
out.append(dict(Q=q,states=r['states'],minimum=r['squared_distance'],nearest_neighbors=len(r['winners'])))
collapse=[]
for q in [2,6,28,496,8128]:
epsilon=F(1,10**6);Aq=[[1],[q]];w=[epsilon,(1-epsilon)/(q*q)];assert gram(Aq,w)==[[1]]
# Every q-grid state is invisible to the second harmonic, so only the first term remains.
assert all((q*x)%q==0 for x in range(q))
collapse.append(dict(Q=q,epsilon=epsilon,metric=1,code_squared_distance=float(4*epsilon)*math.sin(math.pi/q)**2,
ratio_to_standard=math.sqrt(float(epsilon))))
write('worked_examples.json',dict(cographic_K5=dict(determinant=125,cogirth=3,min_cocircuits=10,shortest_lattice_vectors=20,code_results=out),isometric_collapse=collapse))
return dict(cographic_Q_states=sum(r['states'] for r in out),isometric_collapse_alphabets=len(collapse))
def main():
atlas,corpus=atlas_crosscheck()
report=dict(status='passed',python=platform.python_version(),numpy=np.__version__,seed=20261012,
exact_atlas_crosscheck=atlas,smith=smith_audit(corpus),spectral=spectral_audit(),
finite_jet=finite_jet_audit(),rational_metric=metric_audit(),examples=examples_audit(),
limitations=['finite computations are not general proofs','floating-point trials are not interval proofs',
'no formal proof-assistant verification','no independent peer review or exhaustive priority clearance'])
write('python_report.json',report);print(json.dumps(report,indent=2))
if __name__=='__main__':main()