repair_numerical_check.py

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

4320 bytes, as of the version from 2026-11-18 01:45 (current). Recorded here, not run.

"""Read-only checkpoint replay and conversion checks after an anchor-only repair.

Run with agents/sage.sh and mount generate.py, values.json, the unchanged
computation source, both document captures, and repair skill-validation.json.
No quadrature is requested; all ten mathematical inputs and compute code are
unchanged. This is regression evidence, not a new independent verdict.
"""
import sys,json,re,hashlib,importlib.metadata
from pathlib import Path
from decimal import Decimal
from fractions import Fraction
import numberdb.sage as numberdb
from sage.rings.real_arb import RealBallField
from sage.rings.rational_field import QQ
from sage.env import SAGE_VERSION
import generate
w=Path(__file__).parent
key=sys.stdin.read().strip()
if re.match(r'^[A-Z_][A-Z0-9_]*\s*=',key): key=key.split('=',1)[1].strip().strip('\"\'')
before=json.loads((w/'before-document.json').read_text());after=json.loads((w/'after-document.json').read_text())
assert before['Numbers']==after['Numbers']
cp=json.loads((w/'values.json').read_text())
assert cp['computation_sha256']==generate.calculation_fingerprint()
assert cp['computed_source_sha256']==hashlib.sha256((w/'generate-compute-v2.py').read_bytes()).hexdigest()
assert len(cp['records'])==20
expected=[(str(4*m),str(j),conv) for m in range(1,5) for j in range(m,2*m) for conv in ('bessel','period')]
actual=[(n,j,conv) for n,js in after['Numbers'].items() for j,cs in js.items() for conv in cs]
assert expected==actual
R=RealBallField(460)
def rational_decimal(s): return Fraction(Decimal(s))
def ulp(s): return Fraction(10)**Decimal(s).as_tuple().exponent
def rb(s):
 v=rational_decimal(s);e=ulp(s)
 return R(QQ(v.numerator)/v.denominator).add_error(R(QQ(e.numerator)/e.denominator))
containments=[]
for record in cp['records']:
 p=record['params'];n,j,conv=str(p['n']),str(p['j']),str(p['normalization'])
 s=after['Numbers'][n][j][conv];center,radius=record['enclosure'].split(' +/- ')
 c=rational_decimal(center);r=rational_decimal(radius)
 assert r>0
 r+=ulp(center)+ulp(radius)
 v=rational_decimal(s);e=ulp(s)
 assert v-e<c-r and c+r<v+e
 # Deliberate one-percent shifted interval must exclude the checkpoint.
 false=v*Fraction(101,100)
 assert false+e<c-r or c+r<false-e
 containments.append({'n':n,'j':j,'normalization':conv,'outer_checkpoint_strictly_inside_stored_interval':True,'one_percent_shift_rejected':True})
pairs=[]
for m in range(1,5):
 for j in range(m,2*m):
  n=4*m;row=after['Numbers'][str(n)][str(j)];f=rb(row['bessel']);g=rb(row['period'])
  factor=(-1)**m*R(2)**(n-2*j)*R.pi()**(2*m);res=g-factor*f
  assert res.is_finite() and 0 in res
  relative_radius=R(res.rad())/abs(g)
  assert relative_radius<R('1e-95') and not (0 in g*R(QQ(101)/100)-factor*f)
  pairs.append({'n':n,'j':j,'residual':str(res),'relative_radius':str(relative_radius),'one_percent_shift_rejected':True})
# A nonzero known-answer control tests the decimal interval parser.
a=rb('1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
assert a.is_finite() and 1 in a and not(0 in a) and R(a.rad())<R('1e-95')
generator=generate.RegularizedBesselMoments();report=generator.verify(sample=None,client=numberdb.Client(api_key=key))
assert report.ok and report.checked==20 and report.matched==20 and not report.differing and not report.missing
out={'table':'T741','method':'Unchanged source-fingerprinted certified-checkpoint replay with Generator.verify(sample=None), exact rational checkpoint containment, and all ten signed period conversion identities; no full integrations rerun','independence':'Regression and source-identity checks only; uses retained builder checkpoints and the unchanged generator. Does not replace fresh independent critique.','checked_entries':20,'total_entries':20,'verify':{'ok':report.ok,'checked':report.checked,'matched':report.matched,'differing':report.differing,'missing':report.missing},'checkpoint_containments':containments,'period_conversion_pairs':pairs,'known_answer_control':True,'negative_control_rejected':True,'failures':[],'numbers_exactly_unchanged':True,'computation_sha256':generate.calculation_fingerprint(),'versions':{'SageMath':SAGE_VERSION,'numberdb':importlib.metadata.version('numberdb')},'skill':json.loads((w/'skill-validation.json').read_text())}
print(json.dumps(out,indent=2))