back to table · edit · history · where entries came from · files · download
4948 bytes, as of the version from 2026-11-18 10:41 (current). Recorded here, not run.
"""Compare authoritative stored T750 entries with independent checks.
Inputs are stored.json (API document), bessel-checks.jsonl (all 147 direct-r
Bessel enclosures), parameter-reference.jsonl (secondary
Feynman quadrature), and control-inputs.json (known values and wrong controls).
Place these files beside this program and run `sage -python check_results.py`.
For pre-upload checks, offline-document.json can replace stored.json. The
input filename is recorded in the output, so a pending payload is distinguished
from the later authoritative readback. Redirect stdout to check-results.json.
No write API is used. This builder's check is not an independent critique.
"""
import json
from pathlib import Path
import numberdb.sage as numberdb
from sage.rings.real_mpfi import RealIntervalField
from sage.rings.rational_field import QQ
from numberdb._generate import _stored_entries
R=RealIntervalField(800)
BASE=Path(__file__).resolve().parent
def rows(path):
out=[]
for line in Path(path).read_text().splitlines():
try:d=json.loads(line)
except ValueError:continue
if 'params' in d:out.append(d)
return out
def key(p):return tuple(str(p[k]) for k in ('a','b','c','t'))
def interval(text):
from decimal import Decimal
from fractions import Fraction
if str(text).startswith('['):
a,b=str(text).strip('[]').split(',');return R(a.strip(),b.strip())
if '+/-' in str(text):
v,e=str(text).split('+/-');return R(v.strip())+R(-R(e.strip()).upper(),R(e.strip()).upper())
d=Decimal(str(text));q=QQ(str(Fraction(d)));ulp=QQ(10)**d.as_tuple().exponent
return R(q-ulp,q+ulp)
def finite(v):
try:
QQ(v.lower());QQ(v.upper())
return True
except (ValueError,TypeError,OverflowError):return False
def qualified(v):
if not finite(v):return False
lo,hi=QQ(v.lower()),QQ(v.upper())
return bool((hi-lo)<QQ(1)/10**45*max(QQ(1),abs(lo),abs(hi)))
def execute(document=None,source_name=None):
input_path=BASE/'stored.json'
if not input_path.exists():input_path=BASE/'offline-document.json'
doc=json.loads(input_path.read_text()) if document is None else document;stored={tuple(part.strip() for part in ident.split(',')):interval(value) for ident,value in _stored_entries(doc).items()}
failures=[];comparisons=[];positive_checks=0;min_bessel=10**9
for r in rows(BASE/'bessel-checks.jsonl'):
ident=key(r['params']);v=R(QQ(r['lo']),QQ(r['hi']));s=stored[ident]
is_finite=finite(v) and v.lower()>0
narrow=qualified(v)
ok=is_finite and narrow and v.overlaps(s)
if not ok:failures.append({'method':'Bessel','identity':ident,'finite':bool(is_finite),'narrow':bool(narrow),'overlaps':bool(v.overlaps(s))})
else:positive_checks+=1
min_bessel=min(min_bessel,r['accuracy_bits']);comparisons.append({'method':'Bessel','identity':ident,'accuracy_bits':r['accuracy_bits'],'ok':bool(ok)})
refs=rows(BASE/'parameter-reference.jsonl');high=0
for r in refs:
ident=key(r['params']);v=R(r['value']);e=R(10)**(-r['dps']+15)*max(R(1),abs(v));v+=R(-e.upper(),e.upper());s=stored[ident]
ok=v.overlaps(s)
if r['dps']>=130:
high+=1;ok=ok and v.lower()>=s.lower() and v.upper()<=s.upper()
if not ok:failures.append({'method':'secondary parameter','identity':ident})
comparisons.append({'method':'secondary parameter','identity':ident,'working_dps':r['dps'],'contained':bool(v.lower()>=s.lower() and v.upper()<=s.upper()),'ok':bool(ok)})
controls=json.loads(Path(BASE/'control-inputs.json').read_text());known=[]
if not controls['scaling']['passed']:failures.append({'control':'correct degree -2 scaling'})
for c in controls['known']:
v=R(c['value']);s=stored[key(c['params'])];passed=v.lower()>=s.lower() and v.upper()<=s.upper()
known.append({'identity':key(c['params']),'known_value':c['name'],'contained':bool(passed)})
if not passed:failures.append({'control':c['name']})
negative=[]
for c in controls['negative']:
s=stored[key(c['params'])]
if c['kind']=='nan':passed=not qualified(R('NaN'))
elif c['kind']=='wide':passed=not qualified(R(-10**20,10**20))
else:
v=R(c['wrong_value']);passed=not s.overlaps(v)
negative.append({'name':c['name'],'rejected':bool(passed)})
if not passed:failures.append({'negative_control':c['name']})
# Validate all computations selected exactly the same identities.
allkeys=set(stored);assert allkeys=={key(r['params']) for r in rows(BASE/'bessel-checks.jsonl')}=={key(r['params']) for r in refs}
return {'input_source':source_name or input_path.name,'checked_entries':len(stored),'total_entries':len(stored),'failures':failures,'known_answer_control':all(x['contained'] for x in known),'negative_control_rejected':all(x['rejected'] for x in negative),'bessel_checked':positive_checks,'minimum_bessel_accuracy_bits':min_bessel,'parameter_checked':len(refs),'high_precision_parameter_checked':high,'known_controls':known,'negative_controls':negative,'scaling':controls['scaling'],'comparisons':comparisons}
if __name__=='__main__':print(json.dumps(execute(),indent=2))