# T757 numerical evidence

## Quantity and source

The sole value is the raw signed moment
mu_n=(1/4) integral_0^infinity exp(-t/2) Psi(t) t^n dt, n>=0,
where Psi=-g in Suzuki's screw-function convention. There is no division by
n!. Suzuki arXiv:2206.03682v4 (1.13),(1.15), Theorem 1.1(3), and Theorem
8.1 (8.1),(8.3) were inspected. Absolute convergence is unconditional; no
positivity assertion or RH assumption enters either computation.

The coordinated archived skill manifest is
/home/ubuntu/numberdb-campaign-20261116-sol/repo/agents/runs/20261118T181011Z-build-skills/manifest.json.
It is also attached as skill-manifest.json. Complete local/live resource hashes
were validated and their bundle hashes match:
b5c3c7985b7c9e178b4899d083a9e3bc4284989dff76f05e5b0e52835d47eed2.

## Production

For s=1+u, form Z(u)=zeta(1+u)-1/u using Sage's native
Polynomial_complex_arb._zeta_series(...,deflate=True). Then
xi(1+u)=(1+u)(1+u Z(u)) Gamma((1+u)/2) pi^(-(1+u)/2)/2.
All factors are ball polynomials, with gamma and exponential series evaluated
natively. The analytic pole is removed before multiplication, rather than
numerically subtracted. Compute the logarithmic series through degree 51.
The branch near xi(1)=1/2 is analytic and real; its derivative is branch
independent. Put sigma_(k+1)=(-1)^k (k+1)[u^(k+1)]log xi(1+u).
The output is n! sum_(k=0)^n (n-k+1)2^(n-k)sigma_(k+1).
This last transform uses exact integer factors and no Python int division.
Truncating at degree 51 is exact for the requested coefficients, not an
analytic-tail approximation.

All 51 native values are Sage RealBall. Measured minimum relative accuracy is
740 bits at 768 working bits. Serialization uses the numberdb 100-significant-
digit decimal convention, with one last-place unit of uncertainty. The largest
serialized value is 103 characters. production.json retains the much narrower
original ball strings and serialized entries. Existing dry_run.py/check.py
passed: correct imports, native bounded types, finite enclosures, no suspicious
exact decimals, no prose findings; 51 entries, approximately 14 KB in native
ball text. The stored decimal block is smaller. No exactness is inferred from
a decimal pattern.

## Independent analytic route and explicit tail bounds

independent_check.py imports no production generator. DLMF 25.5.13–14 gives
xi(s)=1/2+s(s-1)/2 integral_1^infinity
 (x^(s/2)+x^((1-s)/2)) omega(x) dx/x,
where omega(x)=sum_(m>=1)exp(-pi m^2 x). Expanding at s=1+u gives
A_k=integral_1^infinity (sqrt(x)+(-1)^k)(log(x)/2)^k/k! omega(x) dx/x,
and xi(1+u)=1/2+(u+u^2)sum A_k u^k/2.
Coefficient expansion and integration are justified by the following uniform
integrable majorant, which also controls every stored coefficient's tails.

For x>=1 and k>=0,
 (log(x)/2)^k/k! <= exp(log(x)/2)=sqrt(x),
and |sqrt(x)+(-1)^k| <= 2sqrt(x). Thus the absolute coefficient integrand
is at most 2 omega(x). The check sums m=1,...,14 and integrates x=1,...,192
in 896-bit complex-ball quadrature, with absolute/relative goal 2^-760.
All complex auxiliary enclosures have finite components and contain zero in
the imaginary component; the integral is real by its defining real integrand.

For the x tail, m^2 >= 1+3(m-1) implies
 error_x <= 2 exp(-pi L)/(pi(1-exp(-3pi L))), L=192,
whose computed upper bound is less than 7.0e-263.
For m>=a=15, m^2 >= a^2+(2a+1)(m-a), and integration from 1 to infinity gives
 error_m <= 2 exp(-pi a^2)/(pi a^2(1-exp(-pi(2a+1)))),
whose computed upper bound is less than 3.0e-310.
Both are added as ball radii to every coefficient. The missing summands above
L are overcounted rather than omitted. These bounds do not rely on observed
agreement or a finite zeta-zero list. theta-checkpoint.json retains all 51
coefficient enclosures and the evaluated bounds. Its version and numerical
parameters are checked before resume.

The checker substitutes u=w/(1-w) by exact binomial coefficients. It computes
Li coefficients lambda_n using the coefficient recurrence for the logarithmic
derivative of xi(1/(1-w)), without the native log-series routine, and then uses
Suzuki (8.3)'s finite double sum. All 51 resulting moment enclosures have at
least 717 relative bits. All are strictly inside the exact rational endpoints
of the stored NumberDB decimal intervals; checked_entries=total_entries=51,
failures=[]. The parser implements the last-place-unit semantics explicitly,
without converting stored values or endpoints through Python floats.

Both routes share the completed-xi identities, Suzuki's theorem relating the
integral to xi, and Arb/FLINT arithmetic. They differ in analytic representation
(zeta/gamma product versus theta quadrature), coefficient implementation and
final moment transform (sigma versus Li). This is independent builder evidence,
not the mandatory separate-session scientific verdict.

## Controls and readback

The quadrature checker reproduces the nonzero integral of exp(-pi x) from 1
to 192 using its elementary antiderivative, and mu_0=1+(EulerGamma-log(4pi))/2.
It rejects wrong sign, factor 4, index shift, removal of the n=2 factorial,
NaN and a radius-1e100 ball. Both the real quantities and comparisons must
have finite, non-vacuous balls before an overlap can count. check-results.json
contains executed control booleans and every stored comparison.

Authenticated package verify(sample=None) read back T757 and matched 51/51,
with zero differing, missing or extra entries. This checks reproduction, not
independent correctness. The displayed Sage program was executed and its n=50
ball agrees with production, retaining 740 bits. The live document snapshot,
API audit, source hashes and rendered-page evidence are retained separately.

Runtime: SageMath 10.9, Python 3.12.3, numberdb 0.1.10, FLINT 3.4.0;
versions.json gives the exact runtime string and platform. All Sage executions
used agents/sage.sh. No production-web computation occurred.

## Bounded proof-facing experiment

The exact Li polynomials P_j(t) have generating function
sum P_j(t)w^j=(1+w)^2/(1-w)^4 exp(-tw/(1-w)).
P_0=1, P_1=6-t, P_2=19-7t+t^2/2, and leading coefficient (-1)^j/j!.
For H_n=[mu_(i+j)] and the lower triangular coefficient matrix B_n,
the changed Gram matrix is B_n H_n B_n^T. Its determinant is
 det(H_n) product_(j=0)^n (j!)^-2, and its inertia is unchanged.
These are exact linear-algebra facts, not numerical discoveries.

An exploratory calculation tested n=0,...,10, then withheld n=11,...,20.
Generic real-ball matrix determinants lost useful precision at the larger
orders; their failed/insufficient evidence and source are preserved. Switching
to the already available native complex-ball matrix implementation, with
1713-bit moments (400 requested decimal digits), gives non-vacuous overlapping
determinant enclosures in every case, with at least 1520 relative bits. The
larger precision is confined to this ancillary experiment; no determinant
sequence was uploaded as a table.

The exact signed-measure control m_k=1-2^k/8 has
H_1=[[7/8,3/4],[3/4,1/2]], and its Li-basis Gram matrix is
[[7/8,9/2],[9/2,23]]. Both have determinant -1/8, despite positive diagonals.
Thus a diagonal-positivity mechanism fails this control. The basis change
reveals no new positive factorization or all-order inequality; no RH or
positivity theorem is claimed. All basis matrices and outcomes are retained
in basis-results.json, including the development/held-out split.
