# Certified values for T698

Instruction provenance: `skill-manifest.json`, archived at
`agents/runs/20261109T224707Z-build-skills/manifest.json`. Both canonical skills
have SHA-256 `886390324dd1971e381a43cf3b46b822ab0bc67d62f31d8481e29ec79556746b`.

## Interior series

Put a_j=u^j/(j^s binomial(2j,j)). For s>=2 and 0<|u|<4,

    |a_(j+1)/a_j| = |u| j^s / (2(2j+1)(j+1)^(s-1)) <= |u|/4 = r < 1.

After adding a_N, the entire remaining absolute tail is at most
|a_N| r/(1-r). This also bounds the alternating series, without assuming
cancellation. The recurrence b_1=u/2,
b_(j+1)=b_j*u*(j+1)/(2(2j+1)) computes b_j=u^j/binomial(2j,j), and
then a_j=b_j/j^s. All operations are Arb ball operations; no Python-int
division enters. The loop ends when the computed upper-bounding ball for
the tail is strictly below 10^(-digits-60), and adds its upper endpoint as
an error radius. Rational arguments enter exactly through QQ.

## Positive boundary

Let p=s-2 and theta=2 arcsin(sqrt(u)/2). DK equation (1.2), with its
log-sine definition (1.4), gives the equivalent integral for 0<u<=4:

    F_s(u) = 1/p! integral_0^theta v [log(u)-2 log(2 sin(v/2))]^p dv.

At u=4, put v=pi*x and A=log(2/pi). Euler's sine product, DLMF 4.22.1,
gives

    H(x) = sum_{m>=1} zeta(2m) x^(2m)/(m*4^m),
    F_s(4) = 2^p*pi^2/p! integral_0^1 x [A-log(x)+H(x)]^p dx.

The generator multiplies H as a polynomial in x^2, truncating after degree N.
Truncation preserves all lower coefficients. For each retained coefficient
of H^j, it integrates the logarithmic factor analytically:

    J_d(m) = integral_0^1 x^(2m+1) (A-log(x))^d dx,
    J_0(m)=1/(2m+2),
    J_d(m)=(A^d+d J_(d-1)(m))/(2m+2).

The singular endpoint is integrated, not cut off numerically. This endpoint
method adapts the Euler-product construction inspected in the T697 attachment;
its archived source hash is recorded in generate.py. T698 contains a complete
implementation, so it does not depend on future changes to that draft.

For the omitted terms, let B(z)=sum_{m>=1} zeta(2m) z^m/m. Its coefficients
are positive, and B(1/2)<2 log(2)=C since zeta(2m)<2. If c_(j,m) is the
coefficient of B(z)^j, then

    sum_{m>N} c_(j,m)/4^m <= 2^(-N-1) C^j.

This bounds the absolute tail of H(x)^j uniformly for 0<=x<=1. Multiplication
by the other factor and integration uses

    M_d = sum_{l=0}^d binomial(d,l) |A|^(d-l) l!/2^(l+1)
        >= integral_0^1 x |A-log(x)|^d dx.

Thus an absolute error bound for F_s(4) is

    E = 2^p*pi^2/p! sum_{j=1}^p binomial(p,j) 2^(-N-1) C^j M_(p-j).

The bound is evaluated in Arb and its upper endpoint is added to the answer.
The p=0 integral is elementary and has no series remainder. Arb also encloses
pi, the logarithm, zeta coefficients, polynomial products, and all arithmetic.
The code requires finite output and at least bits(digits+20) relative accuracy.
At 100 requested digits it uses 525 working bits and N=532. The evidence
records the measured worst-case accuracy, not just the nominal working precision.

## Independent validation and output rounding

The defining F_2 has the elementary forms
2 asin(sqrt(u)/2)^2 for 0<=u<=4, and -2 asinh(sqrt(-u)/2)^2 for -4<=u<0.
Repeated integration of the absolutely convergent defining series gives,
for s>=3,

    F_s(u) = 2/(s-3)! integral_0^infinity
             y^(2s-5) F_2(u*exp(-y^2)) dy.

The independent checker evaluates this integral at 150 and 200 decimal digits.
It does not use the endpoint polynomial or central-binomial recurrence.
Before comparison it checks the nonzero known integrals obtained by replacing
F_2(u*exp(-y^2)) by exp(-y^2); the result is 1 at s=3 and s=10. A deliberately
wrong answer is rejected. This quadrature does not supply the generator's error
radii and is not described as certified.

Every entry is regenerated at 140 requested digits. Its entire higher-precision
Arb enclosure must fit inside the interval represented by the stored
100-significant-digit decimal (one unit in the last place on each side).
The high-precision independent quadrature value must fit there too. A deliberate
ten-unit perturbation is rejected. The checker tests ten closed-form identities
and forty relations to live companion entries. After filling it repeats these
checks on all read-back decimal intervals and runs Generator.verify(sample=None).
The evidence states exactly which checks ran before and after filling.
