back to table · edit · history · where entries came from · files · download
13873 bytes, as of the version from 2026-11-19 23:07 (current). Recorded here, not run.
"""Independent numerical checks and exact certificates for T766.
Run with SageMath/numberdb: sage -python checks.py, keeping the named input
JSON files and forms.py/generate.py alongside this file. Each CHECKPOINT line
is resumable evidence for one form. No website writes occur. The numerical
route is an explicit split Mellin sum of exact Sage Fourier coefficients;
it does not call PARI's L-function, symbol or period evaluator. PARI and Sage
exact newform constructions are also compared through each Sturm bound.
"""
import os,sys,json,math,hashlib,platform
from pathlib import Path
from fractions import Fraction
from decimal import Decimal
from functools import lru_cache
import numberdb.sage as numberdb
import numberdb as plain
from sage.env import SAGE_VERSION
from sage.libs.pari import pari
from sage.rings.rational_field import QQ
from sage.rings.integer_ring import ZZ
from sage.rings.real_arb import RealBallField
from sage.rings.real_mpfr import RealField
from sage.rings.real_mpfi import RealIntervalField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.qqbar import AA
from sage.arith.misc import euler_phi
from generate import PrimitiveOddPeriods,scalar_at,pari_form,display_value
from forms import selected_spaces,space_data,exact_polynomial,QX,X
from check import exactness,names_its_rings,exact_in_disguise,prose,measure
BASE=Path(__file__).resolve().parent
P=PolynomialRing(QQ,'x')
def finite_narrow(v,digits):
return bool(v.is_finite() and (v==0 or v.accuracy()>numberdb.bits(digits)))
def decimal_ball(text,R):
text=text.strip();center=Fraction(text)
exponent=Decimal(text).as_tuple().exponent
ulp=Fraction(10)**int(exponent)
return R(QQ(center.numerator)/center.denominator).add_error(R(QQ(ulp.numerator)/ulp.denominator)),ulp
def enclosure_contains(text,ball):
center=Fraction(text);ulp=Fraction(10)**int(Decimal(text).as_tuple().exponent)
lo=center-ulp;hi=center+ulp
return (finite_narrow(ball,110) and QQ(ball.lower())>=QQ(lo.numerator)/lo.denominator
and QQ(ball.upper())<=QQ(hi.numerator)/hi.denominator)
def eta_delta(nmax):
# Independent integer convolution, q*product(1-q^m)^24.
a=[1]+[0]*(nmax-1)
for m in range(1,nmax):
b=[0]*nmax
for j in range(min(24,(nmax-1)//m)+1):
c=(-1)**j*math.comb(24,j)
for n in range(nmax-j*m):b[n+j*m]+=c*a[n]
a=b
return [0]+a
@lru_cache(None)
def dimensions(N,k):
# Exact independent Gamma_0 dimension formulas, Stein 6.1 and 6.4.
primes=ZZ(N).prime_divisors();mu=QQ(N)
for p in primes:mu*=1+QQ(1)/p
e2=0 if N%4==0 else math.prod(1+int(ZZ(-4).kronecker(p)) for p in primes)
e3=0 if N%2==0 or N%9==0 else math.prod(1+int(ZZ(-3).kronecker(p)) for p in primes)
cusps=sum(euler_phi(math.gcd(d,N//d)) for d in ZZ(N).divisors())
genus=1+mu/12-QQ(e2)/4-QQ(e3)/3-QQ(cusps)/2
full=(k-1)*(genus-1)+(k//2-1)*cusps+e2*(k//4)+e3*(k//3)
new=full-sum(len(ZZ(N//d).divisors())*dimensions(int(d),k)[1] for d in ZZ(N).divisors() if d<N)
return int(full),int(new)
def pari_roster(N,k,B):
mf=pari.mfinit([N,k],0);rows=[]
for f in pari.mfeigenbasis(mf):
fp=P(str(pari.lift(pari.mfparams(f)[3])).replace('y','x'))
cs=[P(str(pari.lift(c)).replace('y','x')) for c in pari.mfcoefs(f,B)]
for z in fp.roots(AA,multiplicities=False):
rows.append({'sort':tuple(c(z) for c in cs),'f':f,'degree':int(fp.degree()),
'field_poly':str(fp),'root_interval':[str(QQ(z.interval(RealIntervalField(128)).lower())-QQ(1)/2**128),str(QQ(z.interval(RealIntervalField(128)).upper())+QQ(1)/2**128)],
'coefficients':[[str(a) for a in c.list()] for c in cs]})
rows.sort(key=lambda r:r['sort'][2:]);return mf,rows
def upper_integrals(coeff,T,R,k,terms):
# Integral_T^infinity f(iy)*y^(s-1)dy, exact integer s>=1.
twopi=2*R.pi();v=[R(0) for _ in range(k)]
for n in range(1,terms+1):
a=twopi*n;z=a*T;decay=(-z).exp();partial=R(1);term=R(1);fact=1
for s in range(1,k):
if s>1:term*=z/(s-1);partial+=term;fact*=s-1
v[s]+=R(coeff[n])*decay*fact*partial/a**s
return v
def tail_bounds(N,k,T,R,terms):
# For normalized holomorphic newforms, |a_n|<=d(n)*n^((k-1)/2)
# and d(n)<=2*sqrt(n), so |a_n|<=2*n^(k/2), also at bad primes.
# For each incomplete-gamma monomial, n^(k/2+j-s)<=n^D,
# D=k/2-1. At n=M+1+l, (M+1+l)^D <= (M+1)^D*exp(D*l/(M+1)).
# Sum the resulting positive geometric majorant, with ball arithmetic.
twopi=2*R.pi();D=k//2-1;n0=terms+1
ratio=(-twopi*T+R(D)/n0).exp()
assert ratio.upper()<1
common=2*R(n0)**D*(-twopi*T*n0).exp()/(1-ratio)
tails=[R(0)]*k
for s in range(1,k):
partial=sum((twopi*T)**j/math.factorial(j) for j in range(s))
tails[s]=common*math.factorial(s-1)*partial/twopi**s
assert tails[s].is_finite() and tails[s].lower()>0
return tails
def mellin(coeff,N,k,epsilon,working,terms):
R=RealBallField(numberdb.bits(working,losing=32));T=1/R(N).sqrt()
upper=upper_integrals(coeff,T,R,k,terms)
tails=tail_bounds(N,k,T,R,terms)
bounded=[upper[s].add_error(tails[s]) for s in range(k)]
moments={s:bounded[s]+epsilon*R(N)**(k//2-s)*bounded[k-s] for s in range(1,k)}
coeffs={k-2-m:math.comb(k-2,m)*(-1)**(m//2)*moments[m+1] for m in range(1,k-1,2)}
return coeffs,tails
def control_tests():
assert eta_delta(5)==[0,1,-24,252,-1472,4830]
R=RealBallField(numberdb.bits(180,losing=32));T=R(1);a=2*R.pi();e=(-a).exp()
got=upper_integrals([0,1],T,R,4,1)
known=[None,e/a,e*(a+1)/a**2,e*(a*a+2*a+2)/a**3]
for s in (1,2,3):
assert got[s].is_finite() and got[s].lower()>0 and finite_narrow(got[s],150)
assert (got[s]-known[s]).contains_zero()
control,ulp=decimal_ball('1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890',R)
assert enclosure_contains('1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890',R(control.center()))
assert not enclosure_contains('1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890',R(2))
assert not finite_narrow(R('nan'),110)
assert not finite_narrow(R(1).add_error(R(100)),110)
return {'known_answer_control':True,'negative_control_rejected':True,'nonzero_exponential_integrals':3,'nan_and_wide_balls_rejected':True,'eta_delta_coefficients':100}
def run():
controls=control_tests();g=PrimitiveOddPeriods()
published=json.loads((BASE/'document-T696.json').read_text())['Numbers']
companion=json.loads((BASE/'T696-T694-roster.json').read_text());comp={(r['N'],r['k'],r['i']):r for r in companion}
report={'table':'T766','sage':SAGE_VERSION,'pari':str(pari('version()')),'python':platform.python_version(),
'numberdb':plain.__version__,'controls':controls,'spaces':[],'forms':[],'failures':[],
'skill_manifest_path':'agents/runs/20261119T222759Z-build-skills/manifest.json',
'skill_manifest_sha256':hashlib.sha256((BASE/'manifest.json').read_bytes()).hexdigest(),
'rigour':'heuristic (agreement-checked)','checked_entries':0,'total_entries':18,
'known_answer_control':True,'negative_control_rejected':True}
all_roster=[];fourier=[];native={};entries=[]
for N,k in selected_spaces():
M,C,S,rows=space_data(N,k);B=max(2,int(M.sturm_bound()))
assert dimensions(N,k)==(int(C.dimension()),int(S.dimension()))
mf,other=pari_roster(N,k,B)
assert len(rows)==len(other)==int(S.dimension())
assert int(pari.mfdim(mf))==int(S.dimension())
sp={'N':N,'k':k,'cusp_dimension':int(C.dimension()),'new_dimension':int(S.dimension()),'rational_forms':0}
for r,pr in zip(rows,other):
assert r['sort']==pr['sort'] and r['field_degree']==pr['degree']
old=comp[(N,k,r['i'])];fp=P(old['field_poly']);lo,hi=map(QQ,old['root_interval'])
roots=[z for z in fp.roots(AA,multiplicities=False) if lo<z<hi];assert len(roots)==1
assert tuple(P([QQ(c) for c in cs])(roots[0]) for cs in old['coefficients'])==r['sort'][:len(old['coefficients'])]
assert old['field_degree']==r['field_degree']
record={key:pr[key] for key in ('field_poly','root_interval','coefficients')}
record.update(N=N,k=k,i=r['i'],field_degree=r['field_degree'],sturm_bound=B,source_label=old.get('companion_label'))
all_roster.append(record)
if r['field_degree']!=1:continue
sp['rational_forms']+=1;i=r['i'];key=(N,k,i);w=k-2
p=exact_polynomial(*key);pub=published[str(N)][str(k)][str(i)]
if isinstance(pub,dict):pub=pub['number']
assert p==QX(pub),'Published exact-shape dependency disagrees'
assert p.degree()<=w-1 and p.leading_coefficient()>0 and p(-X)==-p(X)
assert math.gcd(*(int(c) for c in p.list()))==1
raw_fricke=QQ(r['factor'].atkin_lehner_operator(N).matrix()[0,0])
normalized_fricke=raw_fricke/QQ(N)**(k//2-1)
assert normalized_fricke in (QQ(-1),QQ(1))
fricke=int(normalized_fricke)
atkin=pari.mfatkininit(mf,N,precision=128);assert atkin[2]==1
assert all(a==fricke*b for a,b in zip(pari.mfcoefs(pari.mfatkin(atkin,pr['f']),B),pari.mfcoefs(pr['f'],B)))
epsilon=(-1)**(k//2)*fricke
qs=r['factor'].q_eigenform(601,names='a');coeff=[QQ(c) for c in qs.padded_list(601)]
assert coeff==[QQ(c) for c in pari.mfcoefs(pr['f'],600)]
if key==(1,12,1):
assert [int(c) for c in coeff[:101]]==eta_delta(100)
assert p==QX('4*X^9-25*X^7+42*X^5-25*X^3+4*X')
reciprocal=sum(QQ(p[w-j])*QQ(N)**(j-w//2)*X**j for j in range(w+1))
assert QX(p)==fricke*reciprocal
params=dict(N=N,k=k,i=i);v=g.value(params,100)
assert isinstance(v,numberdb.RealInterval) and v.lower<v.upper
assert isinstance(v.lower,Fraction) and isinstance(v.upper,Fraction)
native[str(params)]=v
text=display_value(v,100);measurements=[]
entries.append({'params':params,'number':text})
for working,terms in ((150,450),(190,600)):
mc,tails=mellin(coeff,N,k,epsilon,working,terms);R=next(iter(mc.values())).parent();claim,ulp=decimal_ball(text,R)
maximum=R(0);zero_positions=[]
for j,v in mc.items():
assert v.is_finite()
if p[j]:
scale=v/R(p[j]);assert enclosure_contains(text,scale),(key,working,j,'stored interval excludes independent coefficient',str(scale),text)
residual=(scale-R(QQ(Fraction(text).numerator)/Fraction(text).denominator)).abs()/R(QQ(ulp.numerator)/ulp.denominator)
maximum=max(maximum,residual)
else:
assert v.contains_zero(),(key,j,'exact zero disagreement');zero_positions.append(j)
lead=int(p.degree());scale=mc[lead]/R(p[lead])
assert not enclosure_contains(text,2*scale)
assert not enclosure_contains(text,-scale)
measurements.append({'working_digits':working,'working_bits':int(R.precision()),'terms':terms,
'max_residual_in_stored_ulp':str(maximum),'max_upper_integral_tail_bound':str(max(tails)),
'independent_scale':str(scale),'minimum_scale_accuracy_bits':int(scale.accuracy()),
'all_odd_coefficients_checked':len(mc),'exact_zero_positions_checked':zero_positions})
report['checked_entries']+=1
item={'N':N,'k':k,'i':i,'primitive_odd_coefficients':[int(c) for c in p.list()],
'fricke':fricke,'sage_raw_fricke':str(raw_fricke),'sage_fricke_normalizer':str(QQ(N)**(k//2-1)),'epsilon':epsilon,'pari_working_digits':[160,220],
'pari_working_bits':[numberdb.bits(d,losing=32) for d in (160,220)],
'pari_scales':[str(scalar_at(N,k,i,d)) for d in (160,220)],'stored_real_scale':text,
'independent_mellin':measurements,'negative_scale_and_factor_two_rejected':True,
'fourier_coefficients_crosschecked':600,'published_shape_matches':True}
report['forms'].append(item);fourier.append({'N':N,'k':k,'i':i,'coefficients':[str(c) for c in coeff]})
print('CHECKPOINT '+json.dumps({'form':item,'fourier':fourier[-1],'entries':entries[-1:]}),flush=True)
report['spaces'].append(sp);print('SPACE '+json.dumps(sp),flush=True)
assert len(all_roster)==33 and len(report['forms'])==18 and len(entries)==18
assert not exactness(native),exactness(native)
assert not names_its_rings(BASE/'generate.py') and not names_its_rings(BASE/'forms.py')
assert not exact_in_disguise(native) and not prose(native)
report['measure']=measure({str(e['params']):e['number'] for e in entries})
report['native_return_types']=sorted({type(v).__name__ for v in native.values()})
report['exact_companion_indices_checked']=len(all_roster)
# Artifacts are printed to stdout for the restricted builder and also
# written when this script is run on a normal writable local filesystem.
data={'numerical-evidence.json':report,'roster.json':all_roster,'fourier.json':fourier,'entries.json':entries,
'dependency-versions.json':{k:report[k] for k in ('sage','pari','python','numberdb')}}
for name,value in data.items():
try:(BASE/name).write_text(json.dumps(value,indent=2))
except OSError:pass
print('ARTIFACT '+json.dumps({'name':name,'data':value}),flush=True)
return report
if __name__=='__main__':run()