back to table · edit · history · where entries came from · files · download
4721 bytes, as of the version from 2026-11-17 11:46. Recorded here, not run.
"""T737 independent Fourier-interpretation check with an absolute tail bound.
Usage: sage -python automorphy.py (alongside independent.py).
No network writes. Auxiliary norm<=10000 coefficients are private evidence.
The supported coefficients are evaluated by independent local prime phases
and cubic CRT, not the production quotient sums.
For r=|m|, the DR formula gives |tau|<=9*sqrt(3)*r^(1/3).
Bessel's positive integral shows K_(1/3)(t)<=K_(1/2)(t) for t>0.
Thus each term <=C*r^(-1/6)*exp(-A*r), A=4*pi*v/(3*sqrt(3)),
C=9*sqrt(3)*v*sqrt(pi/(2*A)). For k<=r<k+1, a,b coordinates each
have absolute value <=2*(k+1)/sqrt(3); at k>=1 the lattice-point count
is <=16*(k+1)^2. Dropping r^(-1/6)<=1 bounds the entire omitted lattice,
both signs and even zero-support points, by 16*C*sum_(k>=R)(k+1)^2*e^(-A*k).
This deliberately overcounts the shell and includes the boundary r=R.
The point radii are 100,25,50,56 at heights 1/2,2,1,9/10 respectively.
Only the coefficients needed at each height enter that truncated sum.
The geometric-series expression below encloses that convergent bound.
"""
import independent as I
import json,time,sys,os
from pathlib import Path
from sage.rings.rational_field import QQ
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_arb import RealBallField
from numberdb._write import to_text
B=ComplexBallField(320);R=RealBallField(320);w=I.embed(I.W,B);lam=I.embed(I.LAM,B)
pts=[('imaginary-axis',B(0),R(1)/2),('nonreal',w/3,R(1))]
pairs=[]
for name,z,v in pts:
den=(z*z.conjugate()).real()+v*v
pairs.append((name,(z,v),(-z.conjugate()/den,v/den)))
normbound=10000;start=time.time();rows=[];values=[]
checkpoint=Path(__file__).with_name('auxiliary-checkpoint.json')
if checkpoint.exists():
from sage.rings.complex_interval_field import ComplexIntervalField
saved=json.loads(checkpoint.read_text());rows=saved['rows']
values=[B(I.stored_interval(t,ComplexIntervalField(320))) for t in saved['values']]
print('resumed auxiliary',len(values),file=sys.stderr,flush=True)
else:
for m in I.lattice(normbound):
row,reason=I.decompose(m)
if row:
val=I.coefficient(row,320);I.finite_narrow(val,250)
rows.append(row);values.append(val)
print('AUX_CHECKPOINT '+json.dumps({'rows':rows,'values':[to_text(v,80) for v in values]}),flush=True)
def tail(v,k):
A=4*R.pi()*v/(3*R(3).sqrt());q=(-A).exp()
C=9*R(3).sqrt()*v*(R.pi()/(2*A)).sqrt()
s=q**k*((k+1)**2/(1-q)+2*(k+1)*q/(1-q)**2+q*(1+q)/(1-q)**3)
t=16*C*s
assert t>0 and t<R(1)/10**38
return t
# Simultaneous terms allow the negative controls to reuse exactly the same
# coefficients/Bessel evaluations. Each mutation isolates a normalization bug.
def theta_variants(z,v,radius):
const=B(3)**(QQ(5)/2)/2*B(v)**(QQ(2)/3)
total=const;missing=const;phase=const
bynorm={};rowterms=[]
for row,val in zip(rows,values):
n=row['norm_m']
if n>radius**2:continue
if n not in bynorm:
t=4*B.pi()*B(QQ(n)/27).sqrt()*v
bynorm[n]=v*t.bessel_K(QQ(1)/3)
mu=I.embed(tuple(row['m']),B)/(lam**3)
angle=2*B.pi()*(mu*z+(mu*z).conjugate())
# Both signs have equal tau, so their two characters give 2*cos(angle).
term=val*bynorm[n]*2*angle.cos()
total+=term
if row['branch']=='B':missing+=term
# Reverse the j=1 phase while retaining its shifted Gauss sum.
phase+=term*((B(0,4)*B.pi()/9).exp() if row['branch']=='A' and row['j']==1 else 1)
return {'correct':total,'missing_A':missing,'wrong_constant':total+const,'reverse_ninth_phase':phase}
results=[]
for name,left,right in pairs:
lr,rr=(100,25) if name=='imaginary-axis' else (50,56)
lv=theta_variants(*left,lr);rv=theta_variants(*right,rr);tl=tail(left[1],lr);tr=tail(right[1],rr);t=tl+tr
out={'point':name,'tail_left':str(tl),'tail_right':str(tr),'truncation_radii':[lr,rr],'tail_bound_formula':'16*C*q^k*((k+1)^2/(1-q)+2*(k+1)*q/(1-q)^2+q*(1+q)/(1-q)^3)','variants':{}}
for key in lv:
delta=lv[key]-rv[key]
print('PAIR_CHECKPOINT '+json.dumps({'point':name,'variant':key,'difference':str(delta),'left':str(lv[key]),'right':str(rv[key])}),flush=True)
I.finite_narrow(delta,100)
err=R(0).add_error(t)
bounded=delta+B(err,err)
hit=bounded.contains_zero()
out['variants'][key]={'difference':str(delta),'with_tail':str(bounded),'contains_zero':bool(hit)}
if key=='correct':assert hit
elif name=='nonreal' or key in ('missing_A','wrong_constant'):assert not hit
out['left']=str(lv['correct']);out['right']=str(rv['correct']);results.append(out)
print(json.dumps({'bound':normbound,'auxiliary_entries':len(rows),'results':results,'seconds':time.time()-start,'all_correct_pairs_overlap':True,'negative_controls_rejected':True,'auxiliary_coefficients':[{'m':r['m'],'number':to_text(v,80)} for r,v in zip(rows,values)]}))