generate.py

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)