back to table · edit · history · where entries came from · files · download
6189 bytes, as of the version from 2026-11-15 19:16 (current). Recorded here, not run.
"""Builder checks for T716; imports no generating code.
sage -python checks.py offline-rows.json check-results.json
Uses independent 500-bit analytic quadrature of the Mellin moment of the
harmonic generating function, with two explicit tail bounds. Shared assumptions
are CGLXZ (2.8), the moment identity, and Arb arithmetic. Direct exact-rational
coefficient sums check the 16 interior rows and the two Sun identities.
This is executable builder evidence, not an independent critic verdict.
"""
import json,math,pathlib,sys,time
from fractions import Fraction
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_mpfi import RealIntervalField
R=RealBallField(500);C=ComplexBallField(500);I=RealIntervalField(650)
def rational(s):
f=Fraction(str(s));return QQ(f.numerator)/f.denominator
def bounds(s):
mant,_,e=str(s).lower().partition('e')
places=len(mant.split('.')[1]) if '.' in mant else 0
ulp=QQ(10)**(int(e or 0)-places);center=rational(s)
return center-ulp,center+ulp,ulp
def narrow(y):
return bool(y.is_finite() and R(y.rad())<R(10)**-115)
def contained(s,y):
if not narrow(y):return False
lo,hi,_=bounds(s);iv=I(y)
return bool(iv.lower()>=lo and iv.upper()<=hi)
def mellin(p,v):
v=rational(v)
def f(x,analytic):
t=x.exp()
delta=2*(-t).exp()*t.sinh() # 1-exp(-2t), stable also as t tends to zero
s=(1-4*C(v)+4*C(v)*delta).sqrt(analytic=analytic)
G=((1+s)/(2*s*s)).log(analytic=analytic)/s
return (p*x-t).exp()*G/math.factorial(p-1)
cuts=[-800,-64,-16,-4,0,R(160).log()]
y=sum((C.integral(f,cuts[i],cuts[i+1],abs_tol=R(10)**-132,rel_tol=R(10)**-132)
for i in range(len(cuts)-1)),C(0))
a=R(p)-R(1)/2
low=R(2).sqrt()*(-800*a).exp()*((R(2).log()+800)/a+1/a**2)/math.factorial(p-1)
high=R(3)**(1-p)*R(-480).exp()*sum((R(480)**k/math.factorial(k) for k in range(p)),R(0))
assert y.real().is_finite() and y.imag().is_finite() and y.imag().contains_zero()
return y.real().add_error(low+high)
def direct(p,v,harmonic=True):
v=rational(v);assert abs(v)==QQ(1)/16
c=QQ(1);h=QQ(0);s=R(0);N=260
for n in range(N):
if n:
c*=QQ(2*(2*n-1))/n
h+=QQ(1)/(2*n-1)+QQ(1)/(2*n)
s+=R(c*(h if harmonic else 1)*v**n/(2*n+1)**p)
q=R(4*abs(v))
# H_(2n)<=2n, binomial(2n,n)<=4^n; denominator >=1.
tail=2*q**N*(N/(1-q)+q/(1-q)**2) if harmonic else q**N/(1-q)
return s.add_error(tail)
def main(inp,out):
data=json.loads(pathlib.Path(inp).read_text());rows=data['rows'];comp=[];fail=[];cache={};start=time.time()
for row in rows:
p=int(row['params']['p']);v=row['params']['v'];y=mellin(p,v);cache[p,v]=y
ok=contained(row['number'],y)
d=direct(p,v) if abs(rational(v))==QQ(1)/16 else None
direct_ok=contained(row['number'],d) if d is not None else None
if not ok or direct_ok is False:fail.append(row['params'])
_,_,ulp=bounds(row['number'])
comp.append({'params':row['params'],'integral_ball':str(y),'accuracy_bits':int(y.accuracy()),'stored_contains_integral':ok,'direct_ball':str(d) if d is not None else None,'stored_contains_direct':direct_ok,'residual_stored_ulps':str((R(rational(row['number']))-y)/R(ulp))})
print('CHECK_ROW_JSON='+json.dumps(comp[-1]),flush=True)
catalan=2*C(0,1).polylog(2).imag()
known=[bool(narrow(catalan) and cache[1,'1/4'].overlaps(catalan))]
sun_positive=9*cache[3,'1/16']+41*direct(4,'1/16',False)-40*C(0,1).polylog(4).imag()-QQ(5)/12*R.pi()*R(3).zeta()
sun_negative=5*cache[2,'-1/16']+17*direct(3,'-1/16',False)-14*R(3).zeta()
known.extend([bool(narrow(sun_positive) and sun_positive.contains_zero()),bool(narrow(sun_negative) and sun_negative.contains_zero())])
ref=rows[0];y=cache[int(ref['params']['p']),ref['params']['v']];_,_,ulp=bounds(ref['number'])
neg={'wrong_sign':not contained(ref['number'],-y),'add_one':not contained(ref['number'],y+1),'five_ulps':not contained(ref['number'],y+5*R(ulp)),'vacuous_radius':not contained(ref['number'],y.add_error(100)),'nan':not contained(ref['number'],R('nan'))}
# Repeat identities with the stored decimal intervals, not just their midpoints.
stored={}
for row in rows:
lo,hi,_=bounds(row['number']);stored[int(row['params']['p']),row['params']['v']]=R(I(lo,hi))
stored_controls={
'catalan':bool((stored[1,'1/4']-catalan).contains_zero()),
'sun_positive':bool((9*stored[3,'1/16']+41*direct(4,'1/16',False)-40*C(0,1).polylog(4).imag()-QQ(5)/12*R.pi()*R(3).zeta()).contains_zero()),
'sun_negative':bool((5*stored[2,'-1/16']+17*direct(3,'-1/16',False)-14*R(3).zeta()).contains_zero())}
result={'table':'T716','checked_entries':len(rows),'total_entries':len(rows),'failures':fail,'known_answer_control':all(known) and all(stored_controls.values()),'negative_control_rejected':all(neg.values()),'known_answer_controls':known,'negative_controls':neg,'stored_controls':stored_controls,'sun_positive_residual':str(sun_positive),'sun_negative_residual':str(sun_negative),'comparisons':comp,'seconds':time.time()-start,'method':'500-bit Arb analytic Mellin quadrature on log(t) in [-800,log(160)], bounded tails; direct rational coefficients on all 16 interior rows','skill_manifest':'skill-manifest.json','skill_bundle_sha256':'d6661c2f21613524889fa3a57d3c95f8330344ca62e5a856211c08a282b7dbab','limitations':'Builder evidence, not critic verdict. Quadrature and generator share Arb and the same source generating function, but no numerical implementation. Direct coefficient checks are confined to the interior.'}
pathlib.Path(out).write_text(json.dumps(result,indent=2));print('CHECK_RESULT_JSON='+json.dumps(result),flush=True)
assert not fail and result['known_answer_control'] and result['negative_control_rejected']
return result
if __name__=='__main__':
here=pathlib.Path(__file__).parent
main(sys.argv[1] if len(sys.argv)>1 else here/'offline-rows.json',sys.argv[2] if len(sys.argv)>2 else here/'check-results.json')