# Numerical evidence for T531: Airy zeta values

## Instructions and reproducibility

Instruction manifest read for this build:
`agents/runs/20261026T224836Z-build-skills/manifest.json`, copied here as
`skill-manifest.json`. Both archived versions, the canonical source and a fresh
live https://numberdb.org/skill fetch had SHA-256
`b4d51ded0d52cfe3dcc0859de0845c3879b0c2363273ba7e809a7e06ded40b18`.
The attached `checks.py`, `check.py` and `generate.py` reproduce the checks.
All Sage work was executed with the supplied `agents/sage.sh` wrapper.
Measured versions: SageMath 10.9, numberdb 0.1.10, mpmath 1.4.1.

## Local results before filling

- 19 values, in the exact order n=2,...,20.
- The shared `dry_run.py` accepted the generator: named rings, exact
  rational-polynomial coefficients, finite balls, no exact-in-disguise warning.
- Working precision 429 bits, comprising the 333 bits for 100 decimal digits
  and a 96-bit guard. Minimum measured relative accuracy: 402 bits.
  Worst relative radius: 4.2619331e-122 at n=20.
- A separate 629-bit run agreed for every entry. An independently written
  700-bit Taylor quotient, initialized from Arb Ai(0) and Ai'(0), agreed
  for every entry. Both sides were checked finite and narrow before overlap.
- Every 100-digit decimal, interpreted as the exact center plus/minus one
  final-place unit, strictly encloses the independent 700-bit ball.
- Crandall equations 4.12-4.16, divided by 2^n, give the five source formulas
  checked at n=2,...,6. The initializer for this check is the reflection-form
  expression 3^(5/6)*Gamma(2/3)^2/(2*pi). Voros 42.2 and 43.3 also fix
  the signs for n=2 and n=3. All five source checks pass.
- The Riccati recurrence, positivity, strict decrease and strict log convexity
  pass on the whole applicable range. All residual balls are finite,
  contain zero and have radius less than 1e-90.
- The displayed Programs snippet was separately executed and compared on
  every selected order.
- The working balls occupy 3.423 KiB by the common measurement helper,
  with maximum written length 146 characters. The serialized 100-digit
  numbers occupy 2.619 KiB by that helper, with maximum length 107.

The raw values, ball radii, accuracy measurements and spectral partial sums
are in `numerical-evidence.json`.

## Independent spectral check and its limits

The check first tests the nonzero known value
Ai(0)=1/(3^(2/3)*Gamma(2/3)); the direct Arb evaluator agrees at 300 bits.
It then locates 64 negative Ai zeros with mpmath at 70 decimal digits, and
checks opposite Arb signs at rational endpoints within 1e-55 of each
candidate. These brackets are disjoint and ordered. No claim of a certified
root count is made: index assignment is numerical in this auxiliary check.

The positive Dirichlet eigenvalues lambda_k satisfy
lambda_k >= [pi*(k-1/2)]^(2/3). To see this, split the half line at L>lambda
with a Neumann boundary at the split. On [L,infinity), the potential is at
least L, so there are no eigenvalues below lambda. On [0,L], removing the
nonnegative potential only increases the count, leaving the explicit
Dirichlet-Neumann eigenvalues [pi*(j-1/2)/L]^2. Thus
N(lambda) <= L*sqrt(lambda)/pi+1/2. Let L decrease to lambda, and then let
lambda decrease to lambda_k from the right.

For K=64 and p=2n/3>1, decreasing-function integral comparison bounds the tail by

    sum_{k>K} lambda_k^(-n) <= pi^(-p)*(K-1/2)^(1-p)/(p-1).

Every generated value lies strictly above its partial sum and below the
partial sum plus this bound. The bound is about 0.16343 at n=2 and 1.112e-30
at n=20. This deliberately conservative check validates signs and scale;
it is not a 100-digit summation of the roots. The 100-digit enclosures follow
from the exact Airy product/Riccati identities and the ball computation.

## Mathematical derivation behind the generator

The genus-one Airy product gives, near zero,

    log(Ai(z)/Ai(0)) = -kappa*z + sum_{n>=2} (-1)^(n-1)*Z_D(n)*z^n/n.

Ai''(z)=z*Ai(z) implies q'=z-q^2 for q=Ai'/Ai. Consequently q_0=-kappa and
(m+1)q_{m+1}=delta_{m,1}-sum_{j=0}^m q_j*q_{m-j}. The generator performs this
arithmetic in QQ[X] and evaluates X=kappa in balls. It does not approximate
an infinite sum by a finite sum. The independent Taylor-division check shares
these mathematical identities but no coefficient-generation code; the
published source formulas and spectral check provide further independent
validation.

## Subsequent database checks

After filling, run `checks.py` with the key on stdin and
`NUMBERDB_KEY_FROM_STDIN=1`. It reads T531, tests the actual written intervals,
repeats every applicable identity and calls `verify(sample=None)`. The build
handoff records that result and the site's audit. This document records local
pre-fill evidence; it does not assert an independent critique or publication.