check_stored.py

back to table · edit · history · where entries came from · files · download

3323 bytes, as of the version from 2026-11-17 09:48. Recorded here, not run.

"""Read-only full generator verification and identities on live stored values.

Run with the API key on stdin. Requires generate.py, build_check.py and
entries.json. Reuses the exact representations whose phases were exhaustively
validated by build_check.py; it does not repeat that expensive calculation.
Checks every newly downloaded stored interval, including its cube and norm.
"""
import json,sys
from pathlib import Path
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_mpfi import RealIntervalField
import generate
import build_check
B=Path(__file__).resolve().parent
key=sys.stdin.read().strip()
if '=' in key:key=key.split('=',1)[1].strip().strip('"\'')
numberdb.configure(api_key=key)
g=generate.CubicGaussSums();report=g.verify(sample=None)
print('VERIFY',str(report),flush=True)
print('VERIFY_FIELDS',json.dumps({k:str(getattr(report,k)) for k in report.__slots__}),flush=True)
assert report.ok and report.checked==176
rows=json.loads((B/'entries.json').read_text());doc=numberdb.table(g.table)
if (B/'stored-document.json').exists():
 assert doc['Numbers']==json.loads((B/'stored-document.json').read_text())['Numbers']
stored={(int(r['params']['a']),int(r['params']['b'])):r['number'] for r in doc['Numbers']}
assert len(stored)==176
C=ComplexBallField(640);R=RealIntervalField(640)
omega=(C(0,2)*C.pi()/3).exp()
def rational(x):return QQ(x.numerator)/x.denominator
def parse(s):
 real,imag=build_check.stored_parts(s)
 return C(R(rational(real[0]),rational(real[1])),R(rational(imag[0]),rational(imag[1])))
def zero(v):return v.real().contains_zero() and v.imag().contains_zero()
comparisons=[];negative=False
for row in rows:
 a,b=row['params']['a'],row['params']['b'];s=stored[(a,b)]
 assert s==row['number']
 zeta=(C(0,2)*C.pi()/(3*row['norm'])).exp();expected=C(0)
 for coefficient in reversed(row['exact_coefficients']):expected=expected*zeta+coefficient
 assert expected.real().is_finite() and expected.imag().is_finite()
 build_check.stored_contains(s,expected)
 v=parse(s)
 assert v.real().is_finite() and v.imag().is_finite()
 assert v.real().rad()<QQ(1)/10**90 and v.imag().rad()<QQ(1)/10**90
 target=(-1)**len(row['factors'])*row['norm']*(a+b*omega)
 assert zero(v**3-target),(a,b,'stored cube')
 assert row['norm'] in (v.real()**2+v.imag()**2),(a,b,'stored norm')
 if (a,b)==(1,3):
  negative=not zero((v+C(1)/10**60)**3-target)
  assert negative
 comparisons.append({'params':row['params'],'stored_cube':True,'stored_norm':True,'stored_interval_contains_validated_exact_representation':True})
assert stored[(-2,0)]=='2' and negative
result={'checked_entries':176,'total_entries':176,'failures':[],
        'known_answer_control':True,'negative_control_rejected':negative,
        'method':'Fresh API read, full generator.verify(sample=None), 640-bit evaluation of independently phase-validated exact representations, and cube/norm identities on all stored decimal intervals.',
        'reuse':'The immutable exact sums and full independent phase checks are in entries.json and build-check-results.json. Their hashes are preserved with the handoff; no independent phase verdict is inferred from generator.verify().',
        'comparisons':comparisons}
print('RESULT',json.dumps(result),flush=True)