back to table · edit · history · where entries came from · files · download
7574 bytes, as of the version from 2026-11-01 21:05 (current). Recorded here, not run.
"""Zeros of derivatives of the Riemann xi function -- numberdb.org/T660.
Run with SageMath:
sage -pip install numberdb
sage -python generate.py # verify the existing draft/table
The default enumeration is m=1,...,4 and k=1,...,20. Derivatives are with
respect to s, and values are positive critical-line ordinates in increasing
order, counting multiplicity. The origin is excluded. Computation uses
Xi(t)=xi(1/2+it) and the identity Xi^(m)(t)=i^m xi^(m)(1/2+it).
Analytic Arb power series enclose the completed zeta factors. A full interval
cover proves the root numbering without RH; Newton iterations only suggest
narrow brackets. Strict endpoint signs and a nonzero next derivative certify
each final enclosure. See certification.md and argument-selection.md.
"""
import math
import os
import sys
from functools import lru_cache
import numberdb.sage as numberdb
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_arb import RealBallField
from sage.rings.rational_field import QQ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
ISOLATION_BITS = 256
WORKING_BITS = 512
MAX_ORDER = 4
ROOT_COUNT = 20
COVER_HEIGHT = 90
ORIGIN_EDGE = QQ(1)/1024
@lru_cache(maxsize=16)
def fields(bits):
C, R = ComplexBallField(bits), RealBallField(bits)
P = PolynomialRing(C, 'h')
return C, R, P
def jet(t, order=5, bits=WORKING_BITS):
"""Enclose Xi^(j)(t), j=0,...,order, also for a real interval t."""
C, R, P = fields(bits)
s = C(QQ(1)/2, R(t)) + C(0, 1)*P.gen()
length = order+1
f = (s*(s-1)/2 * ((-s/2)*C.pi().log())._exp_series(length)
* (s/2)._gamma_series(length) * s._zeta_series(length))
values = [math.factorial(j)*f[j] for j in range(length)]
assert all(v.is_NaN() or v.imag().contains_zero() for v in values)
return [v.real() for v in values]
def finite(x):
return not x.is_NaN() and not x.lower().is_infinity() and not x.upper().is_infinity()
def sign(x):
if not finite(x):
return 0
return 1 if x > 0 else -1 if x < 0 else 0
def interval(a, b, bits):
R = fields(bits)[1]
return R((a+b)/2)+R(R(0).mid(),R((b-a)/2).upper())
TAYLOR_LENGTH = 96
@lru_cache(maxsize=256)
def taylor_model(centre):
C,R,P=fields(ISOLATION_BITS)
s=C(QQ(1)/2,centre)+C(0,1)*P.gen()
length=TAYLOR_LENGTH
f=(s*(s-1)/2*((-s/2)*C.pi().log())._exp_series(length)
*(s/2)._gamma_series(length)*s._zeta_series(length))
coefficients=[f[j].real() for j in range(length)]
assert all(f[j].imag().contains_zero() for j in range(length))
# Cauchy circle of radius 1. A rectangular ball encloses that circle.
box_s=C(R(QQ(1)/2)+R(R(0).mid(),R(1).upper()),R(centre)+R(R(0).mid(),R(1).upper()))
box=(box_s*(box_s-1)/2 * (-box_s*C.pi().log()/2).exp()
* (box_s/2).gamma()*box_s.zeta())
if finite(box.real()) and finite(box.imag()):
bound=R(abs(box).upper())
else:
# Entire Mellin formula: |I(t)| <= 2 exp(-pi)/pi for |Im t|<=1.
# This fallback also covers the removable poles in the product.
bound=R(1)/2+((abs(R(centre))+1)**2+R(1)/4)*2*(-R.pi()).exp()/R.pi()
global_bound=R(1)/2+((abs(R(centre))+1)**2+R(1)/4)*2*(-R.pi()).exp()/R.pi()
if global_bound < bound:
bound=global_bound
assert finite(bound) and bound>0
return coefficients,bound
@lru_cache(maxsize=8192)
def isolation_jet(a,b):
# One Taylor model for each half-unit cell, reused under subdivision.
# Endpoint cells are chosen consistently and may use a neighbouring model.
centre=QQ((2*((a+b)/2)).floor())/2+QQ(1)/4
coeff,bound=taylor_model(centre)
R=fields(ISOLATION_BITS)[1]
x=interval(a-centre,b-centre,ISOLATION_BITS)
h=max(abs(a-centre),abs(b-centre))
assert h<=QQ(1)/4
vals=[]; N=TAYLOR_LENGTH
for m in range(MAX_ORDER+2):
total=R(0)
for n in reversed(range(m,N)):
total=total*x+coeff[n]*(math.factorial(n)//math.factorial(n-m))
# (N+j)^m <= N^m (j+1)^m and
# sum (j+1)^m h^j <= m!/(1-h)^(m+1).
error=bound*N**m*math.factorial(m)*R(h)**(N-m)/(1-R(h))**(m+1)
vals.append(total+R(R(0).mid(),error.upper()))
return vals
@lru_cache(maxsize=1)
def isolate():
"""Certify all positive roots through COVER_HEIGHT, including simplicity."""
all_brackets, summary = {}, {}
for m in range(1, MAX_ORDER+1):
counts={'zero_free':0,'monotone_empty':0,'simple_root':0,'origin':0,'splits':0}
brackets=[]
def visit(a,b,depth=0):
assert depth < 32, (m,a,b,'isolation failed')
vals=isolation_jet(a,b)
if sign(vals[m]):
counts['zero_free']+=1
return
if sign(vals[m+1]):
sa=sign(isolation_jet(a,a)[m]); sb=sign(isolation_jet(b,b)[m])
if sa and sb:
if sa != sb:
brackets.append((a,b)); counts['simple_root']+=1
else: counts['monotone_empty']+=1
return
counts['splits']+=1
c=(a+b)/2
visit(a,c,depth+1);visit(c,b,depth+1)
if m%2:
# Xi is even: Xi^(m)(0)=0, and strict monotonicity excludes
# another root on (0, ORIGIN_EDGE].
assert sign(isolation_jet(QQ(0),ORIGIN_EDGE)[m+1])
counts['origin']=1
visit(ORIGIN_EDGE,QQ(1)/2)
else:
visit(QQ(0),QQ(1)/2)
for n in range(1,2*COVER_HEIGHT): visit(QQ(n)/2,QQ(n+1)/2)
assert len(brackets)>=ROOT_COUNT
assert all(brackets[i][1]<=brackets[i+1][0] for i in range(len(brackets)-1))
all_brackets[m]=brackets
summary[m]=dict(counts,root_count=len(brackets),height=COVER_HEIGHT)
print('ISOLATED',m,summary[m],flush=True)
return all_brackets,summary
def refine(m,a,b,bits=WORKING_BITS,digits=100):
C,R,P=fields(bits)
# Coarse bisection gives Newton a reliable local start.
sa=sign(jet(R(a),m,bits)[m]); sb=sign(jet(R(b),m,bits)[m])
assert sa*sb==-1
for _ in range(8):
c=(a+b)/2; sc=sign(jet(R(c),m,bits)[m])
assert sc
if sc==sa: a=c
else: b=c
x=R((a+b)/2)
for _ in range(12):
vals=jet(x,m+1,bits)
assert sign(vals[m+1])
x=R((x-vals[m]/vals[m+1]).mid())
centre=QQ(x.mid())
radius=QQ(1)/10**(digits+14)
lo,hi=centre-radius,centre+radius
assert a < lo < hi < b
left=jet(R(lo),m,bits)[m]; right=jet(R(hi),m,bits)[m]
result=interval(lo,hi,bits)
slope=jet(result,m+1,bits)[m+1]
assert sign(left)*sign(right)==-1 and sign(slope)
assert finite(result) and result.rad() > 0
return result
class XiDerivativeZeros(numberdb.Generator):
table='T660'
parameters=('m','k')
type='R'
digits=100
rigour='proven'
def enumerate(self):
for m in range(1,MAX_ORDER+1):
for k in range(1,ROOT_COUNT+1):
yield {'m':str(m),'k':str(k)}
@lru_cache(maxsize=256)
def root(self,m,k,digits=100):
brackets,_=isolate()
a,b=brackets[m][k-1]
return refine(m,a,b,max(WORKING_BITS,numberdb.bits(digits,losing=176)),digits)
def value(self,params,digits):
return self.root(int(params['m']),int(params['k']),digits)
if __name__=='__main__':
if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
numberdb.configure(api_key=sys.stdin.read().strip())
report=XiDerivativeZeros().verify(sample=None)
print(report)
sys.exit(0 if report.ok else 1)