Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
harmonic-analysis
inverse-problems
arithmetic-matroids
flat-tori
finite-jet-reconstruction
License:
Download release/tools/experiments.py from PureOne/Eves-Impossible-Complex-Frequencies-v5.0.0: direct link, hf CLI and curl.
- Browser
- Download file 7.2 kB
-
https://huggingface.co/datasets/PureOne/Eves-Impossible-Complex-Frequencies-v5.0.0/resolve/main/release/tools/experiments.py
- Command line
-
hf download hf://datasets/PureOne/Eves-Impossible-Complex-Frequencies-v5.0.0/release/tools/experiments.py
-
curl -L -o experiments.py https://huggingface.co/datasets/PureOne/Eves-Impossible-Complex-Frequencies-v5.0.0/resolve/main/release/tools/experiments.py
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') | |
| 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() | |