numerical-evidence.md

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

5914 bytes, as of the version from 2026-11-15 23:03 (current). Recorded here, not run.

# T718 numerical evidence from the builder

This is executable build evidence, not an independent critic's verdict.
Read the sources and perform the revision-bound review separately.
Instruction archive: ../20261115T193637Z-build-skills/manifest.json;
core SHA-256 c440c9e106fe2752785dc7189021172e6cf0eb91f89673462ba43e49d57b971f;
matching local/live bundle d6661c2f21613524889fa3a57d3c95f8330344ca62e5a856211c08a282b7dbab.
The archive's resource hashes were checked before any computation or write.

## Quantity and production

D is a nontrivial fundamental discriminant, q=|D|, chi_D(r)=(D/r),
a=0 for D>0 and a=1 for D<0. Lambda(s)=(q/pi)^(s/2)
Gamma((s+a)/2)L(s,chi_D). Li's derivative convention gives
lambda_n=n sum_{k=1}^n binomial(n-1,k-1)c_k, where c_k is the coefficient
of x^k in log Lambda(1+x). These are signed values, not absolute values
or Keiper's lambda_n/n. The local log branch has no effect on positive orders.

The finite Hurwitz identity q^(-s) sum_{r=1}^q chi_D(r) zeta(s,r/q)
is evaluated in acb_series. The common pole is analytically removed from each
Hurwitz summand before the zero-sum character combination is formed. Gamma,
logarithms and exponentials carry Arb ball errors. FLINT 3.6.0, python-flint
0.9.0, numberdb 0.1.10 and Python 3.12.3 were used (versions.json). Work is
at 512 bits, target storage 100 significant decimal digits. Generator results
are native Sage RealBall elements, copied by exact binary midpoint and radius;
no decimal conversion or fixed-precision wrapping is used for that copy.

## Separate theta-Mellin computation

Kedlaya sections 6.1 and 6.2 supply the two parity Mellin formulas. With
Theta(t)=sum_{r in Z} r^a chi_D(r) exp(-pi r^2 t/q), the quadratic Gauss
sum gives root number +1. Split the integral at 1 and apply the functional
equation. In the specified completion, C=(pi/q)^(a/2) and

Lambda(s)=(C/2) integral_1^infinity Theta(t)
    [t^((s+a)/2-1)+t^((1-s+a)/2-1)] dt.

Theta(t)=2 sum_{r>=1} r^a chi_D(r) exp(-c r^2 t), c=pi/q.
Setting t=exp(u) gives the ordinary coefficient F_k=[x^k]Lambda(1+x):

F_k = C integral_0^infinity sum_{r>=1} r^a chi_D(r) exp(-c r^2 exp(u))
  [exp((1+a)u/2)+(-1)^k exp(a u/2)] (u/2)^k/k! du.

The checker implements this formula using an elementary Jacobi/Kronecker
algorithm, independently of Sage/FLINT character enumeration. Arb validated
quadrature integrates u in [0,9], packing two real moments into one complex
integral. No zeta, L-function, log-Gamma, or production helper computes the
checker moments. The two computations do share FLINT's ball arithmetic and
transcendental primitives. Conrey labels are independently matched by testing
all residue classes; exactly one primitive label is found per D.

## Uniform absolute tail bounds, including differentiated weights

For t>=1, (log(t)/2)^k/k! <= sqrt(t). Also C<2 and
[t^((a-1)/2)+t^(a/2-1)] sqrt(t) <= 2t for a=0,1.
Since r^a<=r, every omitted coefficient is therefore bounded by
4 sum r integral t exp(-c r^2 t) dt. No positivity of signed character
weights is used.

Let M=N+1 and rho=exp(-c(2M+1)). Omitted Gaussian terms r>N, integrated
over the whole [1,infinity), contribute at most

B_N = 4(1/c+1/c^2) exp(-c M^2)
       [M/(1-rho)+rho/(1-rho)^2].

This follows from integral_1^infinity t exp(-c r^2 t)dt
=exp(-c r^2)(1/(c r^2)+1/(c^2 r^4)) and
(M+j)^2>=M^2+(2M+1)j. N is chosen with c N^2>520.
For T=exp(9), use r^2-1>=3(r-1) and sum_{r>=1} r x^(r-1)=(1-x)^(-2).
The integration tail, summing all r>=1, is at most

B_T = 4 exp(-c T)(T/c+1/c^2)/(1-exp(-3cT))^2.

Both bounds are computed with outward ball arithmetic. B_N+B_T < 2^-650
for every D. Adding the two bounds double-counts a harmless overlap.
Each integrated moment receives an explicit zero-centered ball of that radius.
Quadrature uses 512 bits and absolute/relative tolerance 2^-450; actual finite
radii, not requested tolerances alone, determine acceptance.

The checker divides F'/F by an independently written triangular recurrence,
h_{j-1}=(j F_j-sum_{i=0}^{j-2} h_i F_{j-1-i})/F_0,
then uses lambda_n=sum_{j=1}^n binomial(n,j)h_{j-1}. This avoids reusing
the generator's log-series computation or binomial-transform code.

## Results, controls and checkpoints

All 520 production values overlap sufficiently narrow theta-derived balls.
The worst checker Li relative accuracy is 433 bits (over 130 decimal digits).
check-results.json is the machine-generated summary; theta-checkpoints.json
holds exact binary midpoint/radius pairs for all 520 check values and all
546 completed-function coefficients. The full retained stdout is offline.log.
The 26-discriminant full independent comparison took about 55 seconds.
No unfinished builder process remains after these results are read.

Known-answer controls enclose Lambda_-3(1)=sqrt(pi)/3,
Lambda_-4(1)=sqrt(pi)/2 and Lambda_5(1)=2 log((1+sqrt(5))/2).
Controls shifted by 10^-60, NaN, and a ball of radius 10^20 are rejected by
the same agreement predicate, which requires finite and narrow balls first.
An exact synthetic entire-function control also tests the Li transform and
rejects the Keiper factor (see control-results.json).

The unchanged agents/table-build/dry_run.py and check.py completed over all
520 native Sage values: imports, exactness/error-carrying types, finiteness,
suspicious exact-looking decimals, prose and size pass. Its conservative
512-bit display measure was 107.3 KiB, longest value 170 characters; 100-digit
stored values are shorter. Readback results and authenticated audit are
preserved separately after filling the draft. verify(sample=None) is a
reproducibility check, not the independent check described here.

Run reproducibly in an environment with Sage, numberdb and python-flint:
    sage -python theta_check.py > theta-results.log
In this campaign every Sage invocation uses agents/sage.sh. The wrapper's
bootstrap and wheel are environment artifacts; neither changes the generator.