# T719 numerical evidence from the builder

This is executable build evidence, not an independent scientific verdict.
Instruction archive: ../20261115T202357Z-build-skills/manifest.json (also
attached as skill-manifest.json); core SHA-256
c440c9e106fe2752785dc7189021172e6cf0eb91f89673462ba43e49d57b971f;
matching local/live bundle
d6661c2f21613524889fa3a57d3c95f8330344ca62e5a856211c08a282b7dbab.
Every archived resource hash was validated before the build.

## Quantity and production

D is a nontrivial fundamental discriminant, q=|D|, chi_D(r)=(D/r),
a=0 for D>0 and 1 for D<0. Lambda(s)=(q/pi)^(s/2)
Gamma((s+a)/2)L(s,chi_D). Define Lambda(1/2+z)=sum gamma_D(m) z^(2m)/m!.
Thus gamma_D(m)=m! Lambda^(2m)(1/2)/(2m)!, with neither (-1)^m nor
s(s-1) factors. The alternative completion with exponent (s+a)/2 on q/pi
would scale the odd-character entries by (q/pi)^(1/2), and is not used.
All input fractions are exact before conversion to balls.

The generator forms q^(-s) sum_{r=1}^q chi_D(r) zeta(s,r/q), at s=1/2+z,
using acb_series through order 40. It multiplies the Gamma and conductor
series, extracts coefficient 2m and multiplies by the exact integer m!.
FLINT's Hurwitz-zeta Euler-Maclaurin bounds and ball operations enclose
rounding/truncation errors. There is no pole at the expansion point.
The quadratic functional equation proves the odd coefficients zero; all
computed odd coefficient balls were also checked to contain zero.

Work: Sage 10.9, Python 3.12.3, numberdb 0.1.10, python-flint 0.9.0,
FLINT 3.6.0. The actual frozen-client archive and bootstrap dependencies
are preserved alongside the run. The generator's mathematical source has
no dependence on the bootstrap: it requires installed numberdb/python-flint.
640 working bits (at least 300 guard bits above requested precision) yield
minimum 427 relative bits over all 546 values, about 128 decimal digits.
Values are native Sage RealBall, copied from exact binary midpoints/radii.

## Separate central theta moments

Kedlaya 6.1-6.2 gives the parity Mellin formulas; Zagier Appendix A3,
printed page 60/PDF page 62, gives the exact quadratic completion and
root number +1. For c=pi/q and C=c^(a/2), let
Theta(t)=2 sum_{r>=1} r^a chi_D(r) exp(-c r^2 t).
Splitting at 1 and using the theta functional equation gives

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

The exponential even coefficient is therefore

gamma_D(m)= C*m!/(2m)! integral_1^infinity Theta(t)
    t^(a/2-3/4) (log(t)/2)^(2m) dt.

For t=exp(u), theta_check.py computes

2*C*m!/(2m)! integral_0^infinity
 sum_{r>=1} r^a chi_D(r) exp(-c r^2 exp(u))
 exp((a/2+1/4)u) (u/2)^(2m) du.

It uses a separately implemented elementary Kronecker/Jacobi algorithm and
validated complex quadrature on u in [0,9], packing two real moments into
each integration. It calls no L-function, Hurwitz-zeta, Gamma or library
character routine for the moment calculation. FLINT ball arithmetic and
exp are shared; the independent representation and character implementation
are different. Character matching against dirichlet_char is a separate
finite check for Conrey metadata, not the evaluator of the moments.

## Uniform absolute truncation bounds

For t>=1 and every 0<=m<=20,
(log(t)/2)^(2m)/(2m)! <= sqrt(t), m!<=20!, C<2,
and t^(a/2-3/4)*sqrt(t)<=t. Since r^a<=r, every absolute coefficient
tail is bounded by 4*20! sum_r r integral t exp(-c r^2 t) dt.
Signed character weights are never assumed positive.

Let M=N+1, rho=exp(-c(2M+1)), K=4*20!. For omitted Gaussian terms
r>N integrated over the whole t>=1, use

B_N=K*(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.
Choose N with c*N^2>650 (N=25 through 91 for this range).
For T=exp(9), bound the whole integration tail by

B_T=K*exp(-c*T)*(T/c+1/c^2)/(1-exp(-3*c*T))^2,

using r^2-1>=3(r-1) and sum_{r>=1} r x^(r-1)=(1-x)^(-2).
Both bounds are computed outward with balls and added to every retained
moment. Double-counting the common omitted corner is harmless.
B_N+B_T<2^-800 for every D. The quadrature requests absolute/relative
tolerance 2^-550 at 640 bits; actual radii determine acceptance, not the
requested tolerance. All integrands are entire in u on finite intervals.

## Results, controls and deterministic checks

All 546 theta coefficients overlap production balls, with no failures.
The checker minimum is 448 relative bits, over 134 decimal digits.
The full check took 85.6 seconds. check-results.json and
control-results.json are parsed actual stdout; theta-checkpoints.json holds
all 546 exact binary ball pairs and per-D bounds/call counts. offline.log
preserves the run; checkpoints allow resumption without recomputing moments.

Known controls newly evaluate Lambda_-3(1)=sqrt(pi)/3,
Lambda_-4(1)=sqrt(pi)/2 and Lambda_5(1)=2 log((1+sqrt(5))/2).
Independent analytic quadrature controls for m=0,1,2,20 use
integral_0^infinity exp(-u)*(u/2)^(2m)*m!/(2m)! du=m!/4^m;
the truncated integral's exact integration-by-parts tail is bounded.
The same narrow-ball predicate rejects a 1e-60 shift, NaN and radius 1e20.
Convention mutations reject ordinary coefficients, raw derivatives,
imaginary-axis signs, shifted indices and the alternative odd completion.
See the actual inputs and booleans in the JSON evidence.

Unchanged agents/table-build/dry_run.py and check.py passed for all 546
native RealBall results: finite enclosures, import discipline, exactness,
suspicious decimal patterns and prose. The measured work-value block was
123.8 KB, longest 209 characters; storage will use 100 significant digits.
This is not an independent actor's scientific or argument-selection verdict.

## Stored-value verification

The upload script requires an empty private draft owned by zeta3 and a matching
base revision; no earlier author's entries are replaced. After filling, it
runs verify(sample=None) and stored_check.py. The latter parses exact decimal
interval endpoints and requires each entire narrow theta ball to be contained
in the stored interval. It also checks all selected identities and rejects a
shifted control. Both checks passed for all 546 entries, with no failures and at least 100
stored significant digits. The entire theta balls fit inside the stored
decimal intervals. Actual outputs are in stored-check-results.json and
verify-results.json. The displayed Programs example was also executed for
D=-4,m=20 and fitted its stored interval at 440-bit working accuracy.
