# Numerical evidence for T535

## Skill and selection provenance

The governing archive is
`agents/runs/20261027T024416Z-build-skills/manifest.json`.
Its local and live versions both have SHA-256
`e37efb7e2ededf6c1d7134c673f152f648f26e0267c556aebdf3ec65765d8b4c`.
Both files were read and compared byte for byte. The runner manifest is also
recorded in skill-evidence.json. Family issue 216 was read before screening.
The selected arguments and their independent roles are in argument-selection.md.

## Exact values and extent

There are 48 exact rational values, with nu=0,1,2,3 and n=1,...,12 in increasing
nu then n order. All 48 are finite, positive and in QQ. There is no rounding
error, working precision, or 100-digit approximation claim for stored values.
Exact fractions are stronger than the campaign's usual 100-digit target.

The generator uses the normalized J' series for positive nu and the normalized
J_1 series for nu=0. A linear coefficient recurrence extracts the moments.
The canonical product identifies these coefficients with the convergent
infinite sums. Every division has exact rational operands.

The standard dry_run.py and check.py completed successfully. The largest
fraction, at (nu,n)=(3,12), is
125433050824097/114642337369032895758336000000 (46 characters).
check.measure reports a 2.6504 KiB block with tuple labels; the standard dry
run's string labels report 2.7 KiB. The actual document block is also measured
by the site. Readability is comfortably within the policy and does not motivate
increasing the editorial bounds merely to fill space.

## Independent exact checks

checks.py uses Python Fraction, separately from the generator's Sage QQ.
It specializes Gupta and Muldoon, equations (19)-(21), to a=c=0,b=1,
then uses their nonlinear Riccati recurrence. At nu=0 it independently uses
the Kishore recurrence for J_1 moments. All 48 fractions agree.

Additional checks are the three published low-moment formulas at each of
nu=1,2,3 (9 comparisons), the mixed J/J' convolution on n=2,...,12
(33 comparisons), positivity (48), strict decrease (44), and strict log
convexity (40). Controls give 1/8, 1/192, 1/3072 at nu=0 and 3/8, 17/192,
79/3072 at nu=1; the half-order J moments give 1/6 and 1/90. Changing
one exact value by 10^-30 is detected. The Programs snippet agrees on all
48 values. The order-zero slice matches all twelve entries of the order-one
slice of T533, read through the API. This is equality by J'_0=-J_1, not a
transcription of the same construction; no repeats suppression is declared.

The printed specialized recurrence (23) in arXiv:math/9910128v1 omits two
endpoint terms. Its upper summation limits are k-1 and k-2, whereas specializing
(21) gives k and k-1. At nu=1,k=3, the correct left and right sides are
-349/9216. The printed (23) right side is -4529/73728, a residual of -193/8192.
The downloaded original TeX confirms that this is not PDF text extraction.
The exact computation, general Riccati equation and numerical roots agree.
The table uses the unambiguous defining function and cites the consistent
formulas; the incorrect specialized equation is never used for values.

## Numerical check outside coefficient arithmetic

mpmath independently computes 32 strictly positive J' roots per selected order,
first at 70 and then at 100 decimal digits. Order zero skips the library's
zero root. Every partial sum for n=1,...,12 is smaller than the exact fraction,
up to a stated rounding slack, with the difference smaller than the infinite
tail bound. For these selected orders and K=32 the bound is

    tail <= (K-1)^(1-2*n) / ((2*n-1)*pi^(2*n)).

DLMF 10.21(i),(iv), together with j_(1/2,k)=k*pi, gives
j'_(nu,k)>(k-1)*pi for nu=1,2,3,k>=2. The order-zero positive roots are
j_(1,k)>k*pi. Summing the corresponding decreasing powers and using the
integral from K-1 yields the displayed tail bound.

Controls run first: the independently computed J_(1/2) roots agree with k*pi,
their inverse-square sum and tail contain the known value 1/6, and mpmath's
first J'_0 root is exactly zero. A perturbation of 0.01 in tau_1(1) is rejected.
All 128 root approximations agree between precisions to absolute error below
10^-56. The maximum derivative residual at 100 digits is 4.01032766533e-101.
For (nu,n)=(3,12), the observed tail is about 5.02070085244e-49 and its bound
is 2.54305797547e-48. Thus this finite sum is a useful independent check,
not a 100-digit evaluation of the infinite sum.

Root indexing and floating-point rounding are not certified by this check.
The exact arithmetic and canonical-product argument support `rigour: exact`;
the numerical comparison is supplementary and is not described as a proof.
The logs and JSON evidence retain both root lists, partial sums, remainders
and bounds rather than reporting only a success flag.

## Reproduction and environment

Run `sage -python checks.py` for local values and `sage -python checks.py
--stored` for all values read back from T535. An authenticated NumberDB API
client is needed while the table is a private draft. `generate.py` defaults
to `verify(sample=None)` and writes nothing. The campaign invokes all Sage
computations through agents/sage.sh.

Observed versions: Python 3.12.3, Sage 10.9, numberdb 0.1.10, mpmath 1.4.1.
Under named Sage imports, QQ of even an integer string reached an uninitialized
real_mpfr module. Parsing parameter text with Fraction and converting its
integer numerator and denominator avoids that path. In this runtime direct
Sage-rational/Python-Fraction equality also returned false for identical
fractions. Exact numerator/denominator conversion resolves the comparison;
no numerical discrepancy was dismissed or rounded away.

The build's final readback and audit results are saved in the run handoff.
This document records builder checks; it is not the separate critique or its
argument-selection acceptance sidecar.

## Completed database readback

After filling T535, `verify(sample=None)` reports all 48 stored entries agree.
The full independent checks were repeated on values read through the API: all
48 exact Riccati comparisons, 9 low-order identities, 33 mixed recurrences,
positivity, monotonicity, log convexity and both numerical-root runs pass.
All 12 order-zero values agree with T533's order-one slice read live.
The final generator audit change adds only the installation command; no
arithmetic, enumeration or stored value was changed after this check.
The complete readback evidence is attached as checks-stored.json.