# T746 numerical build evidence

This is the builder's evidence, not an independent scientific verdict.
Skill manifest: ../20261118T055124Z-build-skills/manifest.json (attached as
skill-manifest.json), bundle SHA-256
d6e85d49873fac5bc748d068b0288cf242b0f9aebf3a9a0fff70295019227420.
Both archived complete versions were hash-verified and match.

## Definition and enclosing computation

The checked journal definition (1) uses h=c1+c2+c3-c1c2c3 and normalized
[0,pi]^3 angular measure. On the torus, P_t=8(t-h), so mu=J+log(8).
Corner extrema of this multi-affine h are -2,2. At t=2, journal (2) supplies
J(2)=8 Catalan/pi-3 log(2). All quantities here use real natural logarithms.

For t>2, source (4) gives G(t)=B(4/t^2)/t, with
B(z)=(1-z)^(-1/4) 2F1(1/8,5/8;1;z)^2. Differentiation under the original
integral is valid away from the spectrum since t-h is bounded below by t-2.
Since J(t)-log(t) tends to zero, integrating the positive series gives
J(t)=log(t)-sum_{r>=1} b_r (4/t^2)^r/(2r). Each hypergeometric coefficient
and each binomial coefficient in the three factors lies in [0,1], by its
positive recurrence with multiplier <=1. Thus b_r<=binomial(r+2,2).
For L=M+1 and q=1-z, the omitted majorant is

S=z^L/2 * ((L+1)(L+2)/q + (2L+3)z/q^2 + z(1+z)/q^3).

The omitted J tail is <=S/(2L); the omitted G tail is <=S/t.
These bounds follow by writing r=L+k and summing 1,k,k^2 against z^k.
The generator encloses all operations in Arb, including exact rational inputs,
coefficient recurrences, polynomial convolutions, logarithms and the tail.
It uses 464 bits for the 100-digit selection. At z=256/289 (t=17/8), M=2464
and the J tail bound is 8.5848696602349314e-127; every computed ball is finite.
The largest radius is below 8.584870e-127. No float-valued data are returned.
Bare stored decimal strings have uncertainty one unit in the last place.

## Actual validation

* agents/table-build/dry_run.py and check.py were run in the builder through
  agents/sage.sh: all 134 entries passed native-type/exactness, finite-ball,
  suspicious-decimal, prose, import and size checks. Native results are
  RealBall. At full internal precision, longest result 157 characters;
  the measured block is under 29 KB. See offline2.log.
* checks.py implements journal Theorem 1 (5) independently of the generating
  convolution, at 3000 bits. Every small-positive alpha was enclosed below
  (sqrt(2)-1)^2 before applying the formula. Both conventions at all 66
  exterior arguments were compared against the actual serialized decimal
  intervals. Every interval contained the narrow independent enclosure;
  the largest oracle radius was below 3.170e-190. At the endpoint a separate
  Hurwitz-zeta expression for Catalan was checked, in addition to quadrature.
  This comparison shares the paper's underlying mathematics with the
  generating Green identity, so it is not independent source verification.
* At all 66 exterior arguments, the derivative-series enclosure was compared
  with source (4) and the elliptic-K transformation (9). Positive roots and
  the Legendre parameter alpha (not modulus) were checked explicitly.
* Independent reduction of the third angle gives
  log((a+sqrt(a^2-b^2))/2), a=t-cos(x)-cos(y), b=1-cos(x)cos(y).
  Its normalized double integral was evaluated at
  t=2,17/8,5/2,3,5,10,14,322. Stable factored discriminants handle the endpoint
  corner. SciPy double quadrature is a sampled, non-certified check, not
  evidence for all 100 digits. Maximum difference from the stored interval's
  centre was 4.45e-16; maximum reported quadrature error was 3.35e-12.
* Independently expanding H=4(A_X+A_Y+A_Z)-A_X A_Y A_Z gives exact constant
  terms CT(H^2)=104, CT(H^4)=17880, CT(H^6)=3536960,
  CT(H^8)=748037080. They match the first four generating coefficients
  after the proved scaling b_r=CT(H^(2r))/256^r.
* The source arithmetic identity (15) at t=5/2 was checked by an independent
  eta-product Mellin integral at 560 bits. For
  f(iy)=eta(2iy)^3 eta(6iy)^3, eta inversion gives
  f(iy)=12^(-3/2)y^(-3)f(i/(12y)). Splitting at y0=1/sqrt(12) yields
  L(f,3)=4 pi^3 integral_[y0,infinity] f(iy)*(y^2+12^(-3/2)/y)dy.
  Eta inversion is DLMF 23.18.5 with the S transformation and the positive
  real branch. The product uses 110 factors of each eta on [y0,64].
  For y>=y0, the product error is bounded by
  3*(q2^111/(1-q2)+q6^111/(1-q6))*exp(-2 pi y), with q2=exp(-4 pi y0)
  and q6=q2^3. The remaining integral is bounded using f(iy)<=exp(-2 pi y)
  and 12^(-3/2)/y<=1/12. The upper tail is enclosed by
  exp(-aY)*((Y^2+1/12)/a+2Y/a^2+2/a^3), a=2pi.
  Total integral truncation/product bound is below 1.501e-172.
  Arb analytic quadrature encloses the finite integral and endpoint
  uncertainty. It gives L(f,3)=0.8998925541313732963684248745557452947396709430731043768906737397215...
  with radius below 4.40e-166; the resulting arithmetic J(5/2) is contained
  in its serialized interval. L(2,chi_-3) was evaluated independently by
  the Hurwitz-zeta difference at 1/3 and 2/3, divided by 9.
* Checker controls pass: the zero kernel gives nonzero log(3), with error
  2.23e-16; reversing the triple-product sign at t=5 gives
  1.571270867959551 instead of 1.575031852146238..., and is rejected.
  Omitted probability normalization, a unit shift, a log(8) convention shift,
  and a wrong elliptic parameter are rejected. All comparison balls must be
  finite and narrower than their explicit thresholds; NaN cannot pass.

The completed source and outputs are checks.py and offline-check-results.json.
The final readback repeats these checks on stored-table.json, writing
check-results.json with uses_live_stored_values=true, then runs the package's
verify(sample=None) separately. Reproducibility is not independent correctness.
The controller's separate critic must inspect sources, arguments and numerical
claims and issue the revision-bound verdict; none is written by this build.

## Runtime and reproducibility

Runtime measured: Python 3.12.3, numberdb 0.1.10, SciPy 1.17.1, mpmath 1.4.1;
Linux x86_64. Full exact version strings are in the result JSON. The actual Sage
runtime uses named Sage imports after numberdb.sage initialization. Its fast
Polynomial_real_arb multiplication was probed and used. Computation stayed
on the authorized builder. Final code, results, rendered-page evidence and
SHA-256 manifest remain in this run directory, not in pipeline source.

Commands from the repository (working artifacts in $TMPDIR):

    agents/sage.sh "$TMPDIR/offline.py" "$TMPDIR/generate.py" agents/table-build/dry_run.py agents/table-build/check.py
    agents/sage.sh "$TMPDIR/checks.py" "$TMPDIR/generate.py" "$TMPDIR/stored-table.json"

The wrapper preserves stdout; its RESULTS_JSON record is parsed without
editing into check-results.json. On a local Sage installation the checker also
writes /tmp/chiral-potts-check-results.json, or NUMBERDB_CHECK_OUTPUT.
