\section{Computations}\label{sec:computations} The theorems cite stored outputs. Each margin in Table~\ref{tab:rungs} comes from a certificate of record, run by the author at the resolution given there (for $(1/18, 1/6)$ and $(1/20, 1/5)$ there are two, from separate implementations; the full runs of both separate implementations were repeated with corrected programs, each reproducing every printed line apart from timings, \S\ref{ssec:audits}). Its output is part of the supplement, with the logs that the supplement's \texttt{README.md} lists. Each JSON output records the enclosures of $T_0(c)$, $T_0(g)$, $t^*$ and $f(1)$, the two positivity bounds, the margin as an exact fraction, the verdict and the SHA-256 of the input function. The first-order JSON outputs also record the range of each diagonal and each forced function. The second-order outputs record the SHA-256 of the engine and of the arithmetic module; their diagonal bounds are printed in the logs, rounded to the nearest fourth decimal, and the bound $0.825079$ for $(1/20, 1/5)$ is taken from the audit's replay (\texttt{audit/p5/p5\_diagnostics\_M7200.json}). The separate implementations write text outputs, with enclosures rounded outward to five or six decimals and the margin as a binary64 number; they read their constants from the TSV files beside them and record no hash. The supplement is the \texttt{anc/} directory of the paper's record; its \texttt{README.md} describes every directory, and \texttt{SHA256SUMS.txt} lists every file. Single-threaded, the second-order runs take about $15$ seconds for $(1/18, 1/6)$, five minutes for $(1/20, 1/5)$, $4.6$ hours for $(1/30, 1/4)$ and nearly $18$ hours for $(1/30, 4/15)$; Table~\ref{tab:runs} lists the full runs of record, together with the upper-bound run of \S\ref{sec:goldbach}. A reader can check a certificate by rerunning it in full, or more cheaply by checking the code against the text and running the small-resolution consistency runs below. Of the other certificate runs whose margins \S\S\ref{sec:certificates} and~\ref{sec:rungs} quote, only the small-resolution consistency runs below have stored outputs in the supplement; the others (the margins of $(1/11, 1/10)$ at $M = 26{,}400$ and $52{,}800$, those of the exact first-order certificate of $(1/18, 1/6)$ at $M = 108{,}000$ and $144{,}000$, and the variant of $(1/14, 1/8)$ with $12$ constants) are reported for context, as is the binary64 computation with FFT convolutions. The audit's replay of $(1/30, 1/4)$ at $M = 1920$, whose margin is negative (\S\ref{ssec:audits}), is not in the supplement either. What the supplement provides for each certificate of record (Table~\ref{tab:runs}) is: \begin{itemize} \item the code, the input function and the stored outputs, with SHA-256 hashes; \item the exact command and environment of the full run, its elapsed time (rounded) and peak memory where it was recorded; \item a consistency run at small resolution, single-threaded, with the settings of the full run: the exact first-order certificates at $M = 13{,}200$, $53{,}760$ and $7200$ for $(1/11, 1/10)$, $(1/14, 1/8)$ and $(1/18, 1/6)$; the second-order engine at $M = 3600$ for $(1/20, 1/5)$, together with its upper-bound pass, and at $M = 960$ for $(1/30, 1/4)$ and $(1/30, 4/15)$; and the separate implementations at $M = 144{,}000$ for $(1/18, 1/6)$ and at $M = 36{,}000$, with the coarse resolution equal to $M$, for $(1/20, 1/5)$. A supplied script compares its outputs field by field with stored small-resolution outputs. The second-order run of $(1/18, 1/6)$ takes about $15$ seconds and has no small-resolution run; \texttt{run\_all.sh.txt} and \texttt{compare.py} do not cover it. It is checked by rerunning in full the command that the supplement's \texttt{README.md} gives and comparing the output with the stored one, which it reproduces in every value field. \end{itemize} The consistency runs take about an hour and a quarter in all on one core. They check that the code and inputs as shipped reproduce the stored computation. They are not what the theorems cite: at these resolutions several margins are negative, and the theorems rest on the full runs of Table~\ref{tab:runs}. They are the author's own reproduction of the computations against stored outputs, not an independent audit; in particular, the run for $(1/30, 4/15)$ at $M = 960$ runs that certificate end to end with the settings of its full run, which no independent audit did (\S\ref{ssec:audits}). Every code requires $\eta$, $\alpha'$ and every bin edge to lie on the grid $\{n/M\}$, and the second-order engine requires $M$ even. The exact $(1/18, 1/6)$ certificate also requires $36 \mid M$ and both block counts to divide $M/9$ ($900 \mid M$ with $50$ blocks); the separate $(1/18, 1/6)$ implementation requires $36 \mid M$ and its block parameter $Q$ to divide $M/18$ ($72 \mid M$ at the value $Q = 4$ used); the separate $(1/20, 1/5)$ implementation requires $60 \mid M$ and $60 \mid M_c \mid M$. \begin{table}[ht] \centering \small \begin{tabular}{@{}llrrr@{}} \toprule Case & Implementation & $M$ & elapsed time & peak memory \\ \midrule $(1/11, 1/10)$ & exact integer, first order & $79{,}200$ & about 20 s$^\dagger$ & 514 MiB \\ $(1/14, 1/8)$ & exact integer, first order & $107{,}520$ & about 2 min & 1085 MiB \\ $(1/18, 1/6)$ & exact integer, first order & $216{,}000$ & about 14 min & 2199 MiB \\ $(1/18, 1/6)$ & validated binary64, first order (separate) & $288{,}000$ & about 11 min & 813 MiB \\ $(1/18, 1/6)$ & second order & $1800$ & about 15 s & not recorded \\ $(1/20, 1/5)$ & second order & $7200$ & about 5 min & not recorded \\ $(1/20, 1/5)$ & validated binary64, first order (separate) & $432{,}000^*$ & about 2.4 h$^\ddagger$ & 3606 MiB \\ $(1/20, 1/5)$ & second order, upper-bound pass (\S\ref{sec:goldbach}) & $7200$ & about 4 min & not recorded \\ $(1/30, 1/4)$ & second order & $7680$ & about 4.6 h & 509 MiB \\ $(1/30, 4/15)$ & second order & $23{,}040$ & about 17.8 h & 889 MiB \\ \bottomrule \end{tabular} \caption{The full runs of record, single-threaded, on the machine that produced the stored outputs. Elapsed times are wall-clock times as recorded by the run (by GNU \texttt{time} where available, otherwise by the script's own timer), rounded: that machine's wall clock is unreliable over short runs: the long runs' wall-clock and CPU times, where both were recorded, agree to about ten per cent (the run marked $^\ddagger$ apart), but in the run of $(1/11, 1/10)$ the script's time stamps are not monotone and the recorded $21$ s of wall-clock time is less than its $34$ s of CPU time. Peak memory is the maximum resident set size, where it was recorded. $^*$Some extended classes on the coarser grid $\{n/72{,}000\}$ (\S\ref{ssec:firstorder}). $^\dagger$As recorded; the run used $34$ s of CPU time. $^\ddagger$CPU time; the run's own elapsed time, $3.2$ h, includes a period in which the machine paused the job.}\label{tab:runs} \end{table} \paragraph{The second-order runs.} Each takes the resolution $M$, the number $NB$ of threshold blocks and the function, with the profile, the parity direction and the block parameters set through the environment: \texttt{KPROF} and \texttt{KW} set the profile and its weights, \texttt{GBIN} or \texttt{GVEC} the parity direction $g$, \texttt{T0ADJ} and \texttt{F1ADJ} switch on the adjoint enclosures of $T_0$ and $f(1)$, \texttt{NBQ} and \texttt{NBQLO} are the block counts of \S\ref{sec:certificates}, \texttt{QOUTER} selects block-by-block evaluation, and \texttt{QADAPT} gives, for one extended class, the target, the splitting factor and the depth of the adaptive partition. The runs of record are: \begin{itemize} \item $(1/18, 1/6)$: $M = 1800$, $NB = 10$, engine \texttt{cert2\_v2.py} (\texttt{045cc3ae}), with its defaults (all profiles, refined blocks, $g = e_{(0,3,1)}$); the lift uses the exact first-order margin of this case, not this run. \item $(1/20, 1/5)$: \texttt{KPROF=3}, $M = 7200$, $NB = 40$, engine \texttt{cert2\_v2.py} (\texttt{045cc3ae}); the parity direction is $g = e_{(0,3,4)}$, the engine's default for this case, in which \texttt{GBIN} is the number of bins, $4$. \item $(1/30, 1/4)$: \texttt{KW=2:1,3:-1 GVEC=2:1,3:1 T0ADJ=1 NBQ=32 NBQLO=64}, $M = 7680$, $NB = 80$, development engine \texttt{5c779c07}. \item $(1/30, 4/15)$: engine \texttt{cert2\_f2.py} (\texttt{0ba72980}), $M = 23{,}040$, $NB = 80$, with \texttt{KW=2:1,3:-1 GVEC=2:1,3:1 T0ADJ=1 F1ADJ=1} \texttt{NBQ=32 NBQLO=64 QOUTER=1} \texttt{QADAPT=2,1:-1.0147:8:2}. \end{itemize} All four use the same exact arithmetic module (\texttt{dpl.py}, \texttt{b7f331da}). The inputs of the $(1/30, 4/15)$ run were hashed and frozen before it was launched. \paragraph{The first-order runs.} Each takes the resolution $M$ and the input function; the certificates of record for $(1/11, 1/10)$ and $(1/14, 1/8)$ also take the list of nonzero classes and the parity direction on the command line, and that of $(1/18, 1/6)$ the numbers of threshold and $\sigma_\beta$ blocks ($50$ and $50$). Their exact commands are in the supplement. The separate implementations use the arithmetic of \S\ref{ssec:firstorder}. The separate $(1/20, 1/5)$ run is \texttt{p5rig.py 432000 cert 1 72000 16}: the fine resolution is $M = 432{,}000$, and the extended strata with $j_\beta \in \{1, 2\}$ and $k_\beta \in \{1, 2\}$, which carry no parity term, are computed at the coarser resolution $M_c = 72{,}000$, with $\sigma_\beta$ split into $16$ groups. The program's default is $M_c = M$, so $M_c$ must be given. \paragraph{The upper-bound run of \S\ref{sec:goldbach}.} For $(1/20, 1/5)$, \texttt{cert2\_caps.py} (\texttt{081b0528}) is \texttt{cert2\_v2.py} with an upper-bound pass that mirrors every lower-bound step in the same arithmetic. Run on the function of record at the settings of record (\texttt{KPROF=3}, $M = 7200$, $NB = 40$), it reproduces every lower-bound field of the certificate of record. It adds $\sup f \le 2011282180584704051/(5\cdot 10^{17}) < 4.022565$, enclosed in the extended class $(0,1)$, and the free bound $f < 3.037643$. With $|f(1)| \ge 527670700557531721/(5\cdot 10^{17})$ these give the ratio quoted in \S\ref{sec:goldbach}. Its audit read the added code against the text and replayed the run at $M = 7200$ (every output field equal) and at $M = 3600$. \paragraph{Theorem~\ref{thm:B}} Its bounds come from exact-integer cell-convolution computations at $\nu = 3/20$, $1/7$ and $1/8$ (mesh $1/16{,}000$, $1/9800$ and $1/8000$), made during the audit of that theorem with separately written scripts (\S\ref{ssec:audits}), and at $\nu = 0.116$ (mesh $1/32{,}000$), made after the audit by \texttt{independent\_p1\_k8.py}, a copy of the audit's 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. The scripts and their outputs, together with the exact computation behind Remark~\ref{rem:base}, are in the supplement's \texttt{thmB/}, and the supplement's \texttt{README.md} gives the commands that produced them. The run at $\nu = 3/20$ with mesh $1/8000$, also in \texttt{thmB/}, is by the same program and gives a weaker bound; no exact computation of the bounds at $\nu = 3/20$, $1/7$ and $1/8$ by a second, separately written program is reported here. At $\nu = 0.116$ a second, separately written program, \texttt{k8\_bound.py}, 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$. A floating-point integral recurrence agrees at $\nu = 3/20$, $1/7$ and $0.116$ (\S\ref{sec:converse}).