check_results.py

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))