checks.py

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

15683 bytes, as of the version from 2026-11-19 23:07 (current). Recorded here, not run.

"""Independent numerical checks and exact certificates for T765.
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 PrimitiveEvenPeriods,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(0,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=PrimitiveEvenPeriods()
    published=json.loads((BASE/'document-T695.json').read_text())['Numbers']
    companion=json.loads((BASE/'T695-T694-roster.json').read_text());comp={(r['N'],r['k'],r['i']):r for r in companion}
    report={'table':'T765','sage':SAGE_VERSION,'pari':str(pari('version()')),'python':platform.python_version(),
      'numberdb':plain.__version__,'controls':controls,'spaces':[],'forms':[],'failures':[],
      'skill_manifest_path':'agents/runs/20261119T212714Z-build-skills/manifest.json',
      'skill_manifest_sha256':hashlib.sha256((BASE/'manifest.json').read_bytes()).hexdigest(),
      'rigour':'heuristic (agreement-checked)','checked_entries':0,'total_entries':36,
      'known_answer_control':True,'negative_control_rejected':True}
    resume_path=BASE/'resume-checkpoints.json';resume={}
    if resume_path.exists():
        packet=json.loads(resume_path.read_text())
        assert packet['generator_sha256']==hashlib.sha256((BASE/'generate.py').read_bytes()).hexdigest()
        assert packet['forms_sha256']==hashlib.sha256((BASE/'forms.py').read_bytes()).hexdigest()
        resume={(v['form']['N'],v['form']['k'],v['form']['i']):v for v in packet['checkpoints']}
        assert all(key[0]==1 for key in resume)
        report['reused_checkpoints']={'identities':[list(key) for key in resume],
            'sha256':hashlib.sha256(resume_path.read_bytes()).hexdigest(),'reason':packet['reason'],
            'original_checks_sha256':packet['original_checks_sha256']}
    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 and p.leading_coefficient()>0 and p(-X)==p(X)
            assert math.gcd(*(int(c) for c in p.list()))==1
            if key in resume:
                saved=resume[key];assert saved['form']['primitive_even_coefficients']==[int(c) for c in p.list()]
                for entry in saved['entries']:
                    v=g.value(entry['params'],100)
                    assert display_value(v,100)==entry['number']
                    native[str(entry['params'])]=v;entries.append(entry)
                report['forms'].append(saved['form']);fourier.append(saved['fourier'])
                report['checked_entries']+=2
                print('REUSED '+json.dumps(list(key)),flush=True)
                continue
            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('36*X^10-691*X^8+2073*X^6-2073*X^4+691*X^2-36')
            reciprocal=sum(QQ(p[w-j])*QQ(N)**(j-w//2)*X**j for j in range(w+1))
            assert QX(p)==-fricke*reciprocal
            vals={}
            for normalization in ('real-scale','path-scale'):
                params=dict(N=N,k=k,i=i,normalization=normalization);v=g.value(params,100)
                assert v.imag==0 if normalization=='real-scale' else v.real==0
                component=v.real if normalization=='real-scale' else v.imag
                assert isinstance(component,numberdb.RealInterval) and component.lower<component.upper
                assert isinstance(component.lower,Fraction) and isinstance(component.upper,Fraction)
                native[str(params)]=v;vals[normalization]=v
                entries.append({'params':params,'number':display_value(v,100)})
            assert vals['real-scale'].real==vals['path-scale'].imag
            text=display_value(vals['real-scale'],100);measurements=[]
            for working,terms in ((150,450),(190,600)):
                mc,tails=mellin(coeff,N,k,epsilon,working,terms);R=mc[w].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)
                scale=mc[w]/R(p[w])
                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_even_coefficients_checked':len(mc),'exact_zero_positions_checked':zero_positions})
            for normalization in ('real-scale','path-scale'):report['checked_entries']+=1
            item={'N':N,'k':k,'i':i,'primitive_even_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[-2:]}),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)==36
    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()