\section{The certificates}\label{sec:certificates} \subsection{What a certificate establishes} Fix a case: the parameters $(\eta, \alpha')$, the profile weights $w_k$, the bins, and the class constants $c$, which are binary64 numbers used at their exact values. The forced functions $h_j$ and the parity correction are then determined (\S\ref{sec:construction}). A certificate is a computation in exact integer arithmetic, in integer arithmetic with directed rounding, or, in the separate implementation of \S\ref{ssec:firstorder}, in binary64 interval arithmetic with exact integer convolutions, that encloses every quantity below and checks the following strict inequalities. \begin{enumerate} \item[(C1)] The weighted diagonals do not vanish: $|B_j(\sigma)| \ge \beta_0 > 0$ for $1 \le j \le m^*$ on the forcing range, with the signs stated in Lemma~\ref{lem:Beff} where it applies. \item[(C2)] The parity direction is effective: $|T_0(g)| \ge \tau_0 > 0$. The solution $t^*$ of $T_0(c + t g) = 0$ is then enclosed in an interval. \item[(C3)] Uniformly over $t$ in that interval, $f(1) \le U < 0$, and $f(u) \ge L$ for every non-prime $\eta$-rough vector $u \ne E$, free or with one component of size at least $1/2$; in the two cases with $m^* = 1$, for every such vector with no subsum equal to $1/2$, as stated after \eqref{eq:target}. On a vector with a large component $a$ and remaining part $\beta$, the value bounded is $f(\beta, a)$ of \S\ref{sec:setting}, including its factor $a$. \end{enumerate} The \emph{margin} is $1 - L/U$, and the lift (Theorem~\ref{thm:lift}) is applied with any fixed $m$ below it. Indeed, if $0 < m \le 1 - L/U$, then $f(u) \ge L = (1 - (1 - L/U))\,U \ge (1 - m)\,U \ge (1 - m) f(1)$, since $U < 0$, $U \ge f(1)$ and $m \le 1 - L/U < 1$, every certified $L$ being negative. The second-order engine and the exact certificate of $(1/18, 1/6)$ also enclose, for the function of record, the parts of each untwisted row $T_j$, $j \ge 1$ (its constant part, its diagonal coefficient, and each coupling applied to the forced $h_{j+i}$), and the untwisted $T_0$. All of these vanish identically by construction, and each enclosure is checked to contain $0$. The engine makes this part of its verdict; the exact certificate records it. The exact certificate of $(1/11, 1/10)$ and $(1/14, 1/8)$ does the same for the constant part and the $h_1$-coefficient of the untwisted row $T_1$, but does not compute the untwisted $T_0$. The separate implementation checks the untwisted rows only in a separate mode, on random data; its certificate runs do not include that mode, and the outputs of that mode are not in the supplement. These checks test the machinery and are not used in the proofs. The enclosed quantities are built from the kernels $1/u$ on $[\eta, \alpha']$ and on $(\alpha', 1/2)$ by convolution, restriction to bins, Lemma~\ref{lem:K}'s fragmentation formula (over all subsets, those of small fragments alone included), and the pointwise forcing $h_j = -(\cdots)/B_j$. Most of them are functions of one variable, the total size of a group of components. Two further variables are handled in blocks: in the couplings and $\Omega$ terms, the subset sum $\varsigma$ of Appendix~\ref{app:kernels}, the total of those small fragments of a large component that belong to the sub-collection $B$ of Lemma~\ref{lem:K} (the rough members of $B$ must then total at least $1/2 - \varsigma$; in this section and in Lemma~\ref{lem:enc-blocks} this variable is written $\tau$ and called the threshold); and, in the positivity bounds for vectors with a large component, the small total $\sigma_\beta$ of the part outside it. A certificate discretises the variable on the grid $\{n/M\}$ and carries rigorous upper and lower enclosures through every operation; \S\ref{ssec:enclosures} states the enclosure lemmas they rest on. Every enclosure is outward. Apart from terms bounded over blocks of fixed width, the first-order methods lose $O(1/M)$ in width and the second-order engine $O(1/M^2)$. The block terms lose an amount of first order in the block width, which does not shrink with $M$; which terms they are is stated for each implementation below. \subsection{First-order certificates}\label{ssec:firstorder} Each kernel is enclosed between first-order bound functions on the grid (step or piecewise linear), using the monotonicity of $1/u$. Their convolutions are exact convolutions of integer vectors, and quotients and products are rounded outward after every operation. Certificates of this kind were written from the mathematical text of each case, not from the code that produced its constants. They certify $(1/14, 1/8)$ and $(1/11, 1/10)$ (the certificates of record for those cases) and $(1/18, 1/6)$. In the certificate of $(1/18, 1/6)$, the couplings and $\Omega$ terms of $h_2$ (in $T_1$, $T_0$, $f(1)$ and the extended vectors) are bounded at every $M$ over $50$ threshold blocks of width $(\alpha' - \eta)/50$, by their values at the block ends; the positivity bounds for extended vectors whose $\beta$-part has one small and at least one rough component range over $50$ blocks of $\sigma_\beta$; and free vectors with two small components are bounded below by the smaller of $c$ and $c$ plus the minimum of $h_2$ over $[2\eta, \alpha']$. Its margins $0.0067$, $0.0179$, $0.0290$ at $M = 108{,}000$, $144{,}000$, $216{,}000$ fit $0.0515 - 4835/M$ to within $6 \cdot 10^{-5}$, so they extrapolate to about $0.051$; the separate implementation's margins extrapolate to about $0.062$. That implementation encloses $T_0$ and $f(1)$ without blocks. Fixed groups of $\sigma_\beta$ and prefix ranges of $h_1$ and $h_2$ enter only its positivity bounds for extended vectors whose $\beta$-part has one or two small components and at least one rough one, and these do not bind. A separate implementation (\S\ref{ssec:status}), written from the mathematical text without sight of the code of these certificates or of the second-order engine, certifies $(1/18, 1/6)$ and $(1/20, 1/5)$ again. It is a first-order certificate in validated binary64 arithmetic: every convolution is an exact integer product of integer images of its operands, scaled by exact powers of two and rounded outward, and every other operation is done in binary64 interval arithmetic, with the error control of Lemma~\ref{lem:enc-binary64}. The step $1/M$ enters only through division by the exact integer $M$. No library transform and no transcendental function enters any enclosure; in the $(1/20, 1/5)$ code a library $\log_2$ is used only to choose indices in a range-extremum table, and its choices were checked against exact integer bit lengths for every length that occurs. This is what separates the implementation from the float computations of \S\ref{ssec:status}, whose convolutions are FFTs bounded a~priori. In its $(1/20, 1/5)$ run at $M = 432{,}000$, the extended vectors whose part $\beta$ has one or two small and one or two rough components are bounded on the coarser grid $\{n/72{,}000\}$: the forced functions enter through unions of their enclosures over the six fine cells of each coarse cell, and $\sigma_\beta$ ranges over $16$ blocks. These lower bounds are valid but wider. Those classes carry no term in the parity direction. The least margin, $0.01609$, is set at the upper end of the parity segment by a class computed on the full grid; one of the coarse classes, $(2,1,1)$, gives the least value at its lower end. The separate implementation does not carry $t$ as an interval through (C3). It evaluates $f(1)$ and the lower bounds of $f(u)$ at the two ends $t_-$, $t_+$ of its enclosure of $t^*$, obtains $U_\pm < 0$ and $L_\pm$ there, and reports $\min(1 - L_-/U_-,\ 1 - L_+/U_+)$. This suffices. Since $g$ leaves every $h_j$ unchanged (\S\ref{sec:construction}), $f(1)$ and every $f(u)$ are affine in $t$. Write $t^* = (1 - \theta)t_- + \theta t_+$ with $\theta \in [0, 1]$, and let $0 < m$ be at most the reported value. Every certified $L_\pm$ is negative, so $m < 1$ and $L_\pm \ge (1 - m)U_\pm$. Hence at $t^*$, $f(u) \ge (1 - \theta)L_- + \theta L_+ \ge (1 - m)\bigl((1 - \theta)U_- + \theta U_+\bigr) \ge (1 - m) f(1)$, and $f(1) < 0$ there. In the three cited runs ($M = 144{,}000$, $288{,}000$ and $432{,}000$) the smaller $L$ and the larger $U$ occur at the same end, $t_+$, so the reported value also equals $1 - L/U$ for the uniform bounds $L = \min L_\pm$, $U = \max U_\pm$ of (C3). \subsection{The second-order engine} To reach the margins at $(1/20, 1/5)$ and beyond at feasible resolution, a second-order engine was built. \begin{itemize} \item \textbf{Representation.} Each enclosure is a pair of functions that are affine on every grid cell and may jump at grid points. They are stored as integers scaled by $10^{18}$. \item \textbf{Convolution.} The convolution of two such functions is a continuous piecewise cubic. Its values at the grid points are exact integer convolutions, three FLINT products per pair. On each cell it differs from its chord by at most $1/(8M^2)$ times a bound for its second derivative, which is itself a convolution of the derivatives, jumps included, and is enclosed exactly (Lemma~\ref{lem:enc-conv}). Signs are handled by splitting each operand into positive and negative parts. On the cells where an operand changes sign the loss is $O(1/M)$ on one cell, so $O(1/M^2)$ in any integral. \item \textbf{Products and quotients} on a cell are enclosed through the four corner products and a second-derivative slack. For the forcing quotient $-N/B$ with $B$ of fixed sign on the cell, the slack is computed exactly in rationals (Lemma~\ref{lem:enc-cell}). \item \textbf{First-order terms that remain.} For each number $b \ge 1$ of small fragments in the sub-collection, the threshold $\tau \in [b\eta, \alpha']$ ranges over at most $NB$ blocks of $\lceil(\alpha' - b\eta)M/NB\rceil$ cells; the last block may be shorter. In the couplings and $\Omega$ terms (the contributions of the forced functions inside a fragmented large component) whose chains carry no rough factor, the blocks are bounded by their narrow and wide ends; elsewhere the block start is exact and the remainder is bounded by the window ranges of Lemma~\ref{lem:enc-blocks}(b). In the positivity bounds of extended vectors, $\sigma_\beta$ ranges over blocks: at most $NBQ$ of them for $j_\beta \ge 3$ and $NBQLO$ for $j_\beta \le 2$, or $NBQJ$ set per level; in the runs of \texttt{cert2\_v2.py}, which has no separate counts, at most $NB$ ($40$ for $(1/20, 1/5)$ and $10$ for the second-order run of $(1/18, 1/6)$). Their widths are fixed by the block counts, not by $M$. The positivity blocks are local. The coupling blocks enter the forced $h_j$ and propagate down the forcing chain; for the cases certified here they are negligible. The positivity loop over $\sigma_\beta$ uses range queries over precomputed extremes of $h_j$ (a fast path whose outward enclosure was audited). \end{itemize} The engine evolved in steps. Each step was audited before a run on it was cited. \begin{enumerate} \item \emph{Weighted profiles.} $h_j$ enters the free data on vectors with $k$ rough components with weight $w_k$, and the diagonal is the weighted one of Lemma~\ref{lem:Beff}. Without weights the code reproduces the earlier unweighted runs exactly; with all weights equal to $1$ on their support the weighted formulas reduce to the unweighted ones. \item \emph{Adjoint enclosures.} $T_0$ and $f(1)$ are linear functionals of the forced functions. Instead of integrating the interval widths of the forcing chain, which grow by a bounded factor per level, the engine also solves the adjoint recursion of Lemma~\ref{lem:enc-adjoint} and integrates each width once against the adjoint solution. Both enclosures are valid; the engine checks that they intersect and uses the intersection. The $(1/30, 1/4)$ run uses the adjoint for $T_0$ only; the $(1/30, 4/15)$ run uses it for $T_0$ and $f(1)$. \item \emph{Adaptive blocks.} At $(1/30, 4/15)$ one extended class had a floor independent of $M$, from the block over which the $\beta$-part's total $\sigma_\beta$ ranges (it enters $h_2$ and the shifted $h_{2+i}$ in the $\Omega$ terms). Finer blocks for the affected levels, and an adaptive partition with explicit targets, reduce the floor below what the margin needs. In the cited run the $\sigma_\beta$-range of that class is cut into $NBQLO = 64$ base blocks, $54$ of which meet the class's feasible range, and $7$ of these were split into $8$. The targets affect work and enclosure width, never the pass criterion. \item \emph{Block-by-block evaluation.} The extended classes with $\sigma_\beta$ blocks are evaluated one block at a time, holding one block's $\Omega$ terms in memory instead of all of a class's blocks. For the same partition this gives the same bounds (only the reported minimiser can differ in exact ties), and it is what lets fine and adaptive partitions fit in memory. \end{enumerate} Steps 3 and 4, with the per-level block counts $NBQJ$, were audited together, as one engine step, before the $(1/30, 4/15)$ run was cited. From the start, the engine bounds each free class $(j, k, b)$ with $1 \le j \le m^*$ and $w_k \ne 0$ below by $c + w_k$ times the extreme of $h_j$ (its minimum if $w_k > 0$, its maximum if $w_k < 0$) over the whole closed interval $[j\eta, \alpha']$, not over the class's realisable range. For $j \ge 2$ it also takes $c$ itself as a candidate, the value on the vectors of the class with $\tau > \alpha'$, which carry no $h_j$, and keeps the smaller of the two; it does this on every such class, whether or not the class has vectors on both sides of $\alpha'$. For $j = 1$ no such candidate is needed, since a single small component never exceeds $\alpha'$. The other free classes ($j = 0$, $j > m^*$ or $w_k = 0$) are bounded by $c$. This is a valid, conservative enclosure: the margin stays valid (it can only be smaller than a bound over realisable ranges would give), but the class reported as binding may be a label that no vector realises. \subsection{The enclosure lemmas}\label{ssec:enclosures} Let $x_n = n/M$ and $K_n = [x_n, x_{n+1}]$ for $0 \le n < M$. A function on $[0, 1)$ is \emph{cellwise affine} if it is affine on each open cell; it may jump at grid points, and it is taken to vanish outside $[0, 1)$. An \emph{enclosure} of $f$ is a pair $F^- \le F^+$ of cellwise affine functions with $F^- \le f \le F^+$ on every open cell. The exact-integer and second-order implementations store their end values as integers over $10^{18}$, rounded down for lower bounds and up for upper bounds. The separate implementation stores binary64 interval endpoints and uses outward integer images for its exact convolutions. Step and continuous piecewise-linear bounds are special cases. The certificates combine exact linear identities, restrictions, reflections, integrals and range hulls with the enclosure operations below. The proofs are in Appendix~\ref{app:enclosures}. \begin{lemma}[Kernels]\label{lem:enc-kernel} For $1 \le i < M$ and $u \in K_i$, $M/(i + 1) \le 1/u \le M/i$ and $\ell_i(u) - M/(4i^3) \le 1/u \le \ell_i(u)$, where $\ell_i$ is the chord of $1/u$ on $K_i$. \end{lemma} \begin{lemma}[Convolutions and correlations]\label{lem:enc-conv} Let $F$ and $G$ be cellwise affine, with end values $a_n = F(x_n+)$, $b_n = F(x_{n+1}-)$ and $c_m$, $d_m$ for $G$, increments $\Delta a_n = b_n - a_n$, $\Delta c_m = d_m - c_m$, and jumps $J^F_n = a_n - b_{n-1}$, $J^G_m = c_m - d_{m-1}$ (with $b_{-1} = d_{-1} = 0$). Then $s = F * G$ is continuous, and: \begin{enumerate} \item[(a)] $s(x_k) = \frac{1}{6M}\sum_{n + m = k - 1}\bigl(a_n c_m + b_n d_m + 2a_n d_m + 2b_n c_m\bigr)$; \item[(b)] on each open cell $K_k^\circ$, $s''$ is affine, with one-sided end values $M X^-_k$ at $x_k$ and $M X^+_k$ at $x_{k+1}$, where \begin{align*} X^-_k &= \sum_{n + m = k - 1}\Delta a_n \Delta c_m + \sum_{n + m = k}\bigl(J^F_n\Delta c_m + \Delta a_n J^G_m\bigr),\\ X^+_k &= \sum_{n + m = k}\bigl(\Delta a_n \Delta c_m + J^F_n\Delta c_m + \Delta a_n J^G_m\bigr); \end{align*} \item[(c)] on $K_k$, with $s_k$ the chord of $s$, $s_k - \frac{1}{8M}\max(0, X^-_k, X^+_k) \le s \le s_k + \frac{1}{8M}\max(0, -X^-_k, -X^+_k)$. \end{enumerate} The correlation $x \mapsto \int F(u)\, G(u - x)\, du$ satisfies the same statements with the knot values $\frac{1}{6M}\sum_{n - m = k}(2a_n c_m + 2b_n d_m + a_n d_m + b_n c_m)$ and second derivative $-\int F'(u)\, G'(u - x)\, du$, the jump of $F$ at $1$ included. Consequently, if $0 \le F^- \le f \le F^+$ and $0 \le G^- \le g \le G^+$ on open cells, then the lower bound of (c) for $F^- * G^-$ and the upper bound of (c) for $F^+ * G^+$ enclose $f * g$, and likewise for correlations. \end{lemma} \begin{lemma}[Signs]\label{lem:enc-sign} If $F^- \le f \le F^+$ on an open cell, then $f^+ = \max(f, 0)$ lies above the function equal to $F^-$ if both end values of $F^-$ are nonnegative and to $0$ otherwise, and below the chord of $\max(F^+, 0)$; and $f^- = \max(-f, 0)$ satisfies the same with $-F^+$ and $-F^-$ in place of $F^-$ and $F^+$. Products and convolutions of signed functions are enclosed by splitting both operands in this way and combining the four nonnegative terms with their signs. \end{lemma} \begin{lemma}[Products and quotients on a cell]\label{lem:enc-cell} Let $p$ and $q$ be enclosed on a cell by affine bounds $p^\pm$ and $q^\pm$, written in the position $\tau \in [0, 1]$ in the cell, with increments $\Delta p^\pm$, $\Delta q^\pm$ over the cell. \begin{enumerate} \item[(a)] For each of the four corner products $r = p^{\pm}q^{\pm}$ put $\sigma_r = |\Delta p^\pm \Delta q^\pm|/4$. Then $pq$ lies above the chord through $\min_r(r(0) - \sigma_r)$ and $\min_r(r(1) - \sigma_r)$, and below the chord through $\max_r(r(0) + \sigma_r)$ and $\max_r(r(1) + \sigma_r)$. \item[(b)] If either $q^->0$ throughout the closed cell or $q^+<0$ throughout it, the same holds for $-p/q$, with the corners $r = -p^\pm/q^\pm$ and the slack $\sigma_r = \frac14|\Delta q|\,|\Delta p\, q_0 - p_0\,\Delta q|/\min(|q_0|, |q_1|)^3$, where $p_0, q_0$ and $p_1, q_1$ are the end values of the corner's bounds; the slack is computed in exact rationals and rounded outward. \end{enumerate} \end{lemma} \begin{lemma}[The forcing chain and the adjoint functionals]\label{lem:enc-adjoint} Let the rows be $T_j = A_j\cdot c + B_j h_j + \sum_{i \ge 1} C_{j,i}[h_{j+i}]$ for $1 \le j \le m^*$, where the couplings $C_{j,i}$ are integral operators, and suppose the enclosure of each $B_j$ excludes zero on every closed cell of $[j\eta,\alpha']$ (this is checked). \begin{enumerate} \item[(a)] Solving $T_j = 0$ for $j = m^*, \dots, 1$ with the operations of Lemmas~\ref{lem:enc-kernel}--\ref{lem:enc-cell} and~\ref{lem:enc-blocks} encloses the exact forced $h_j$ on every cell. \item[(b)] Let a functional have $h$-part $\sum_m \langle \kappa_m, h_m\rangle$, with $\langle u, v\rangle = \int uv$ over the forcing range ($T_0$ and $f(1)$ are of this form), and let $\lambda_m = (\kappa_m - \sum_{j < m} C^*_{j,m-j}[\lambda_j])/B_m$ for $m = 1, \dots, m^*$, where $C^*_{j,i}$ is the transpose of $C_{j,i}$. Then $\sum_m \langle \kappa_m, h_m\rangle = -\sum_m \langle \lambda_m, A_m\cdot c\rangle$. Solving the recursion with the same operations encloses the exact $\lambda_m$, so both sides are enclosed, the right side without the widths of the forcing chain. \end{enumerate} No approximate solution, and so no residual, enters: each side is an enclosure of an exact quantity, and so is their intersection. \end{lemma} \begin{lemma}[Blocks]\label{lem:enc-blocks} Let $[\tau_0, \tau_1]$ be a block of thresholds. \begin{enumerate} \item[(a)] If an integrand depends on $\tau$ only through an indicator $\mathbf 1_{[1/2 - \tau, 1/2)}$ times a nonnegative factor, its integral for $\tau$ in the block lies between its values at $\tau_0$ and at $\tau_1$. \item[(b)] If $X_\tau(x) = X_{\tau_0}(x) + \int_{\tau_0}^{\tau} r(1/2 - t)\, g(x - 1/2 + t)\, dt$ with $r \ge 0$, then for $\tau$ in the block $X_\tau(x) - X_{\tau_0}(x)$ lies between $\rho(\tau)\min g$ and $\rho(\tau)\max g$, the extremes taken over any set containing the arguments $x - 1/2 + t$, $\tau_0 \le t \le \tau$ (the engine takes the cells meeting $[x + \tau - 1/2 - \Delta,\ x + \tau - 1/2]$, with $\Delta$ the largest block width), where $\rho(\tau) = \int_{\tau_0}^\tau r(1/2 - t)\, dt$. Integrated against a signed $H$, this bound is applied to $H^+$ and $H^-$ separately. \item[(c)] A quantity depending on $\sigma_\beta$ is bounded, for $\sigma_\beta$ in a block, by its range over the block. \end{enumerate} The bounds above do not require a rate of continuity. Their additional block losses are $O(\tau_1-\tau_0)$ in (a) when the integrated density is uniformly bounded, and in (c) when the bounded quantity is uniformly Lipschitz on the block. In (b), if $r$ is uniformly bounded and $g$ is Lipschitz on the argument window, the window-range contribution is $O((\tau_1-\tau_0)(\tau_1-\tau_0+1/M))$, in addition to the widths of the input enclosures. A window crossing a jump is bounded by its full range; the Lipschitz rate is not asserted there. \end{lemma} \begin{lemma}[Positivity on closed cells]\label{lem:enc-pos} \begin{enumerate} \item[(a)] If $\Phi \ge L$ on a cell $K_n$ of the large component $a$, with $L$ affine with end values $L_0$, $L_1$, then on $K_n$ \[ a\,\Phi(a) \ge \min(x_n L_0,\ x_{n+1} L_1) - \max(L_1 - L_0, 0)/(4M). \] \item[(b)] Suppose $f=f_c+t f_g$, $t\in[t_-,t_+]$, and on the cell $L_c\le f_c$ and $L_g\le f_g\le U_g$, where all three bounds are affine in $a$. Then $f\ge\min\{L_c+tG:t\in\{t_-,t_+\},\ G\in\{L_g,U_g\}\}$. This minimum is concave in $a$ and lies above the chord through its end values. \item[(c)] An open-cell enclosure also bounds the one-sided limits of the enclosed function at that cell's ends. It bounds the assigned value at a grid point if that value is the corresponding one-sided limit. When either adjacent limit can be selected by a class convention, both must be covered. Values on collapsed feasible strata must be checked separately; an almost-everywhere enclosure alone does not bound them. \end{enumerate} \end{lemma} For the cases in Table~\ref{tab:rungs}, the omitted collapsed free strata have components at extremes of the small interval or at closed upper bin edges. Their constants, parity terms and forced terms are zero, as is checked directly from the class lists and profiles. In the cases with $m^* \ge 2$ the collapsed extended strata with $j_\beta\eta = 1/2$ (all components of $\beta$ equal to $\eta$, and $a = 1/2$; $j_\beta = 9, 10, 15, 15$) also have zero value: every free vector met by the fragmentation of $a$ has at least $j_\beta$ small components, more than any class with a nonzero constant ($6, 7, 12, 12$) and more than $m^*$. At $(1/14, 1/8)$ the stratum $\beta = (1/14, \dots, 1/14)$, $a = 1/2$ does not have zero value (the constants on $(8,3,1)$, $(10,2,1)$, $(11,1,1)$, $(12,0,0)$, $(12,1,1)$, $(13,0,0)$ enter it); it has the subsum $1/2$ and is not part of (C3). At $(1/11, 1/10)$ there is no such stratum. The other relevant boundary values use the prescribed adjacent class or bin and the continuous limits of the convolution kernels. The excluded half-subsum vectors in the two $m^*=1$ cases are not part of (C3). \begin{lemma}[Binary64 steps]\label{lem:enc-binary64} \begin{enumerate} \item[(a)] Let an IEEE~754 binary64 addition, subtraction, multiplication, division or integer conversion have a finite, defined exact result and be rounded to nearest, without overflow. If its returned value is $y$, its exact result lies between the binary64 neighbours of $y$. \item[(b)] Put $u=2^{-53}$ and $\gamma_j=ju/(1-ju)$, for $ju<1$. If $k$ finite binary64 inputs are summed using $k-1$ additions in any order, with no overflow and $(k-1)u<1$, the absolute error is at most $\gamma_{k-1}\sum_i|x_i|$. More generally, suppose each exact term $z_i$ is first formed from exact binary64 inputs by a product or quotient with at most $r$ rounded operations along its evaluation path. If each of those operations has relative error at most $u$, and the subsequent sum has no overflow, then, provided $(k-1+r)u<1$, the absolute error is at most $\gamma_{k-1+r}\sum_i|z_i|$. \item[(c)] Let $x$ be a finite binary64 number and $S \ge 0$ an integer with $|x|\,2^S < 2^{52}$. Then $x\,2^S$ is exact, and $\lfloor x2^S\rfloor$, $\lceil x2^S\rceil$ are exactly representable integers with $\lfloor x2^S\rfloor \le x2^S \le \lceil x2^S\rceil$. \end{enumerate} \end{lemma} The separate implementation moves elementwise interval endpoints outward using (a). Its window accumulators also use ordinary rounded divisions, products and additions, followed by aggregate widening using the product-and-sum form of (b), with a reserve for computing the error bound and the final widened endpoints. It convolves the integer images of (c) exactly. The audits checked, on the runs of record, that the scalings are upward, the required values are finite, no operation overflows, the relevant $ju$ are less than $1$, every product and quotient in these accumulators is normal, or is zero with a zero operand, or underflows to zero and has as an operand a small integer multiple of $2^{-1074}$ that is the outward image of an endpoint equal to $0$ (a lower endpoint of a nonnegative kernel in a lower accumulator, or an upper endpoint in an upper one, where the kernel vanishes), and the implemented widening factors dominate the required bounds as exact rational inequalities for every length that occurs. A term of the last kind is replaced by $0$. In a lower accumulator the true term is nonnegative, so this keeps a lower bound; in an upper accumulator the true term is $0$, so the replacement is exact. (A quotient that underflows in this way removes its whole row of terms.) Part~(b) is applied to the remaining terms, which are nonnegative. For \texttt{p5rig.py}, the preceding nonnegative-accumulator classification applies to the raw updates of \texttt{Win.G}. Their operands are the cell enclosures of $R_1$ and $R_2$. Lower $R_2$ endpoints are clipped to zero. A subnormal upper $R_2$ endpoint in these updates occurs only on a cell where $R_2$ vanishes; a quotient that rounds it to zero therefore removes a true-zero row. This is a source-specific assertion, not a rule for arbitrary nonnegative inputs. Other interval operations may return nonzero subnormal outward endpoints and are justified by part (a). The signed suffix sums in \texttt{kappa\_phi} use an absolute-sum error bound: suffixes whose total absolute input sum is subnormal are exact, and otherwise the reserve in the computed error factor also covers the absolute rounding error of a subnormal error-bound product. For \texttt{p4rig3.py}, this classification refers to the raw updates of \texttt{Win} at the resolutions of record, and to the initial products and suffix sums in \texttt{\_xi\_kappa}. The used window rows have normal positive endpoints of $\rho=R_1+R_2$, and their divisions by $M$ are normal. The other raw window operands are the stated nonnegative combinations $Q^\pm,U^\pm$ of the $R_k$. Outward additions and scalar multiplications can give negative subnormal lower endpoints; their products round to zero at these resolutions, which is safe because the true kernels are nonnegative. Subnormal upper endpoints in those updates occur where the true combined kernel vanishes, so discarding their underflowed products is also safe. These statements concern the actual kernel sources and resolutions, not arbitrary inputs. Individually widened interval operations may retain nonzero subnormal endpoints and are justified by part (a). Signed functional sums use their absolute-sum error bound and explicit underflow padding. At smaller meshes, signed zero-image artifacts may survive the raw products; the lower artifacts are nonpositive and the upper artifacts are nonnegative on true-zero terms, so retaining them is conservative by monotonicity, while part (b) applies to the remaining normal terms. \subsection{Independent audits}\label{ssec:audits} By an \emph{independent audit} we mean a review, separate from the implementation, that reads the code bodies against the mathematical text of the case, and recomputes parts of the computation with separately written scripts. The audits did the following. \begin{itemize} \item $(1/20, 1/5)$, second-order engine: fresh runs at the full resolution $M = 7200$ and at $M = 3600$ reproduce every stored output field exactly. The separate implementation: replays at $M = 36{,}000$ reproduce every printed field; the audit did not rerun the full run. A later dedicated audit of its moving-window code at $1/2$ found that one window mask could omit the assigned value at the right end of a closed window. The consumers of that mask integrate over the endpoint, so the stored bounds remained valid; the audit established the defect and the corrected mask by exact rational checks, replayed $M = 36{,}000$, and bounded the effect on the full run without rerunning it. The author corrected that mask, and a second one in which a further check found a gap that no caller reaches, and reran $M = 36{,}000$ and the full run with the corrected program: every printed line agrees with the earlier outputs apart from timings, and the margin is unchanged. The rerun at $M = 432{,}000$ is the run of record. \item $(1/18, 1/6)$: the exact first-order certificate was replayed at $M = 108{,}000$ and matched every stored field except the elapsed time; the separate implementation's replay at $M = 144{,}000$ reproduces every output byte except timings, and all its integer products at $M = 288{,}000$ were rerun; a later dedicated audit of its window code (see the end of this item) replayed both resolutions end to end with the program as it stood before the corrections described there, reproducing every printed line apart from timings; for the second-order run ($M = 1800$, $NB = 10$) the audit reran the state of the engine it reviewed at $M = 900$, $1800$ and $3600$, reproducing every field of that state's stored outputs, and the run of record, made by the engine as shipped, equals that $M = 1800$ output in every value field (\S\ref{sec:computations}). For the separate implementation, the earlier audit and reproduction did not include a complete code-body sweep of its moving windows at $1/2$. A later dedicated sweep checked the window operands, endpoint conventions, arithmetic and all their consumers. It found that the delta helper's contract, closed in the large component and almost everywhere in the integration parameter, is valid; it must not be read as a joint closed-rectangle bound. It also found a range statement for the stopped $U$ streams that is false outside their used domain, two arithmetic preconditions missing from the program's copy of \texttt{vconv.py}, and qualifications needed in the underflow description (now stated after Lemma~\ref{lem:enc-binary64}). None of these affects the domains that the shipped runs use. The author corrected the program accordingly (the range statement, new assertions, the two guards in \texttt{vconv.py} and the header comments; no numerical path changed) and reran both resolutions with it: every printed line agrees with the earlier outputs apart from timings, with margins $\ge 0.02921$ at $M = 144{,}000$ and $\ge 0.04587$ at $M = 288{,}000$. The rerun at $M = 288{,}000$ is the run of record. \item $(1/30, 1/4)$: a replay at $M = 1920$ with the run's settings, compared field by field with the stored $M = 7680$ output. The fields recording the settings, inputs, constants and code hashes are identical. Each of the five interval enclosures (of $T_0(c)$, $T_0(g)$, $t^*$, $f(1)$ and the untwisted $T_0$ row) contains its $M = 7680$ counterpart. The two positivity bounds and the margin are better at $M = 7680$ (at $M = 1920$ the margin is negative, as expected). This checks consistency across resolutions; it does not reproduce the stored enclosures, and the full run was audited, not rerun. Separately, validated ball-arithmetic integrals that do not use the engine put $T_0(g)$ inside the certified interval and give $0.8705 \le |B_j| \le 1.8484$, with sign $(-1)^j$, on the whole forcing range. \item $(1/30, 4/15)$: replays of the engine's components at $M = 960$ (the forcing chain, the parity solve, $f(1)$, the free bound and the adaptively refined extended class), a replay of the diagonals and the parity data at $M = 23{,}040$, and independent validated integrals; the inputs of the full run were checked against the manifest frozen before launch. The full computation was not rerun at any resolution; the extended class that binds the margin was checked by reading its code path. \item Theorem~\ref{thm:B}: its exact-integer cell-convolution computations at $\nu = 3/20$, $1/7$ and $1/8$ (mesh $1/16{,}000$, $1/9800$ and $1/8000$) were made in the audit itself, with separately written scripts in exact integer arithmetic; no exact computation of these three bounds by a second, separately written program is reported here (at $\nu = 3/20$ the same program was also run with mesh $1/8000$, giving a weaker bound). The one at $\nu = 0.116$ (mesh $1/32{,}000$) was made after the audit by a copy of the same program with the term in $I_8$ added; with that term set to zero the copy reproduces the stored exact outputs at $3/20$, $1/7$ and $1/8$ byte for byte. At $\nu = 0.116$ a second, separately written program, also written and run after the original audit, applies the same scheme with mesh $1/1{,}024{,}000$ and gives a lower bound of at least $0.0354$. The scripts and their outputs are in the supplement's \texttt{thmB/}. \end{itemize} For $(1/11, 1/10)$ and $(1/14, 1/8)$ there was no independent audit in this sense: the code bodies of the certificates were not audited. A separate review checked their formulas, inputs, signs, normalisations and selected parts of the exact arithmetic against the text, and recomputed in exact arithmetic the least-margin cell of $(1/11, 1/10)$, using that certificate's enclosures of $h$ and $f(1)$. No cell of $(1/14, 1/8)$ was recomputed, and neither certificate was rerun. The audits' findings (specification fixes, code fixes and wording fixes) were applied before the runs were cited. The audits' separately written recomputations are in the supplement's \texttt{audit/} directory, and its README describes, for each case, what the audit or review did, the hash of the certificate's code as run, and its conclusion. The scripts and outputs of the audit of Theorem~\ref{thm:B}, with the computation behind Remark~\ref{rem:base}, are in its \texttt{thmB/} directory. \subsection{Certification status of each case}\label{ssec:status} We call two implementations \emph{separate} if neither was written from, or with sight of, the other's code. Separate implementations here still share the mathematical text of the case, its input function and the FLINT library for exact integer products. The second-order engine was developed from the code of the first-order exact-integer certificates (their kernel and row formulas, re-implemented with second-order enclosures), so it is not separate from them. In Table~\ref{tab:status}, ``validated binary64'' is the separate implementation of \S\ref{ssec:firstorder}, and the last column counts separate implementations among the rigorous certificates. \begin{table}[ht] \centering \begin{tabular}{@{}lp{0.52\textwidth}c@{}} \toprule Case $(\eta, \alpha')$ & Rigorous certificates & Separate implementations \\ \midrule $(1/11, 1/10)$ & exact integer, first order; a float computation agrees & 1 \\ $(1/14, 1/8)$ & exact integer, first order; a float computation agrees & 1 \\ $(1/18, 1/6)$ & exact integer, first order, and second-order engine (one implementation); validated binary64, first order & 2 \\ $(1/20, 1/5)$ & second-order engine; validated binary64, first order & 2 \\ $(1/30, 1/4)$ & second-order engine & 1 \\ $(1/30, 4/15)$ & second-order engine & 1 \\ \bottomrule \end{tabular} \caption{Certification status. The base case $(1/11, 1/11)$ of Remark~\ref{rem:base} is contained in the case $(1/11, 1/10)$ and has no row.}\label{tab:status} \end{table} For the two cases marked ``a float computation agrees'', a second computation in binary64 with outward rounding passes. Its rounding control for FFT convolutions rests on an a~priori round-off bound for a library routine. We do not treat that as rigorous, so these cases rest on one certificate. For $(1/30, 1/4)$, a second, independent first-order certificate was attempted. Measured on its own code, it was projected to need $M$ in the millions to reach a positive margin, so it was not run. The cost projection motivates a separately written higher-order implementation; it does not rule out other approaches to a second certificate. No second certificate exists for $(1/30,1/4)$ or $(1/30,4/15)$.