\chapter{The ancillary files}\label{s:ancillary} In this appendix, we describe the ancillary files of this paper and explain how to run them. They contain the programs, the data, and the recorded outputs of the computations that prove \zcref{t:inputs}, which states that the hypotheses (H1), (H2), and (H3) hold at $(\cs, \ct) = (961/1000, 187/200)$. The mathematics behind these computations is given in \zcref{s:computer} for (H2), in \zcref{s:local} for (H1), and in \zcref{s:tail} for (H3), together with an account of what each program must be trusted to do. We only describe here the files, the commands, and the computing environment. The driver of \zcref{s:ancillary-driver} repeats the computations, fully or in part, and compares their outputs with the recorded ones. \section{Contents of the folder}\label{s:ancillary-contents} The ancillary files are in the folder \texttt{anc} of the source archive of the paper. The folder has three subfolders \texttt{anc/h1}, \texttt{anc/h2}, and \texttt{anc/h3}, one for each hypothesis, and two files at the top. The file \texttt{anc/manifest.yaml} lists every file of the folder with its role, what it checks, the command that runs it, the expected output, the time and memory needed, and the SHA-256 digest of each file other than the manifest itself. The script \texttt{anc/run\_all\_checks.py} runs the checks; we describe it in \zcref{s:ancillary-driver}. The folder contains $34$ files. The archive may contain, besides the source of the paper, only data files of a few formats (among them JSON, YAML, and plain logs) and scripts in a few interpreted languages, such as Python. For this reason, we store each of the three programs in C used for (H3) verbatim, as a string, inside a Python script of the same name. When it is run, the script checks the SHA-256 digest of the stored source, writes the C file to a directory, compiles it with the options of \zcref{s:ancillary-H3}, and runs the compiled program with the arguments it was given. With the option \texttt{-{}-print-source}, it prints the C source instead. For the same reason, we store all recorded outputs with the extension \texttt{.log}. The scripts need Python~3.8 or later, and those in \texttt{anc/h1} also need the package NumPy. The C programs need the compiler GCC with support for OpenMP. We ran the checks described below on a computer with four x86-64 cores and $15$ gigabytes of memory, under Linux, with Python~3.13, NumPy~2.5, and GCC~13.3. The scripts locate their bundled data relative to their own folders. We give the commands as they are typed in the folder that contains \texttt{anc}. The recorded outputs come from the original runs. In the archived Python scripts we made file paths relative to the script folder and added optional arguments to some commands. We also added checks for successful changes of the rounding mode in the C programs and synchronized the accesses to the proposed function in the parallel sweeps of \texttt{bellman.c}. The transition weights, enumerations, and inequalities checked by these programs are the same as in the recorded runs. The driver rejects invalid hypothesis selections. The Python checkers that require assertions refuse to run with them disabled. We list the changes in \texttt{anc/manifest.yaml}. \section{The driver}\label{s:ancillary-driver} To repeat the computations, it suffices to run the script \texttt{anc/run\_all\_checks.py}, which has two modes. \begin{verbatim} python3 anc/run_all_checks.py --quick python3 anc/run_all_checks.py --full \end{verbatim} It prints one line for each check, with the result and the time the check took. If at least one check runs and all checks pass, the last line is \texttt{ALL CHECKS PASS}. The option \texttt{-{}-only} takes a nonempty comma-separated list of hypotheses from \texttt{h1}, \texttt{h2}, and \texttt{h3}, as in \texttt{-{}-only h1,h3}. Using the option \texttt{-{}-workdir}, we can keep the compiled programs and the outputs of all runs in a given directory. The quick mode is the default. A historical run took about six minutes on one core and at most $0.6$ gigabytes of memory. This mode runs the exact check of (H2) and the checks of \zcref{s:ancillary-H1}, except that it verifies only $80$ of the $7{,}962$ certificates. Further, it compiles the three C programs, runs the independent enumeration of the short trails in the five cases of \zcref{tab:tail}, and runs the two programs for (H3) with small parameters, which we describe at the end of \zcref{s:ancillary-H3}. Finally, it recomputes \zcref{tab:tail} from the recorded outputs. The full mode also verifies all $7{,}962$ certificates, in four processes by default (option \texttt{-{}-parts}). The recorded one-process verification took about $23$ minutes. The full mode also repeats the ten recorded runs of the two programs for (H3), which originally took about $70$ minutes in total and up to $3.1$ gigabytes of memory. In both modes, the driver leaves the files in \texttt{anc} unchanged. The magnitude guards in \texttt{anc/h1/cert.py} and the certificate checks in \texttt{anc/h2/h2\_check.py} use assertions. The driver, \texttt{anc/h1/verify\_all.py}, and the standalone (H2) checker require assertions to be enabled and reject \texttt{python -O}. \section{The local inequalities}\label{s:ancillary-H1} We now turn to the folder \texttt{anc/h1}, which contains the data and programs for (H1); we refer to \zcref{s:local-computation} for their description. The file \texttt{patterns.json} lists the $7{,}962$ patterns of $\Pext$, up to the reflection and the duplicates of \zcref{s:local-computation}. For each pattern, it records an index, the out-neighbor $o$, the present bonds, and the status of every ring site that is an end of a present bond. Coordinates are taken relative to the passage site, and the trail arrives from $\sS = (0, -1)$, so that a straight pattern has $o = \sN = (0, 1)$ and a turn has $o = \sE = (1, 0)$. The statuses $0$ and $1$ are written \texttt{u} and \texttt{d}. The file \texttt{certificates.jsonl} contains one certificate for each pattern, on one line, in the format of \zcref{s:local-computation}. The program \texttt{verify\_all.py} checks the certificates. It uses the module \texttt{ring.py}, which reads the patterns, and the module \texttt{cert.py}, which carries out the integer computation of \zcref{s:local-integer}. The program \texttt{run\_prod.py} produced the certificates; it uses floating-point arithmetic only to choose them and is not needed to check them. To check (H1), we run the following commands, where $k \in \{0, 1, 2, 3\}$ in the third line. \begin{verbatim} python3 anc/h1/check_certificate_file.py python3 anc/h1/verify_all.py python3 anc/h1/verify_all.py anc/h1/certificates.jsonl k 4 python3 anc/h1/enumerate_patterns.py \end{verbatim} The first command checks the file of certificates against the list of patterns. It verifies that every pattern has exactly one certificate, that every certificate is stated for the ring functional of \zcref{s:local} (field \texttt{model} with the value \texttt{covered}) and for the tip radius $3/5$, which is also the value in \texttt{ring.py}, and that the certificate of every pattern $\pi$ carries the threshold $c_\pi$, with $c_\pi = 961/1000$ for the straight patterns and $c_\pi = 187/200$ for the turns. These properties of the file are part of the proof, since \texttt{verify\_all.py} checks each certificate on its own, at the threshold written in it. The command takes less than a second and ends with \texttt{CERTIFICATE FILE CHECK PASS}. The second command is the main check, which verifies all certificates. In the recorded run, it printed \texttt{certificates 7962 verified 7962 failed []} after $1{,}354$ seconds in one process, and this output is the file \texttt{verify\_all\_output.log}. The third command checks the certificates in positions $k$, $k + 4$, $k + 8$, and so on, so that four such commands share the work. The last command runs the independent enumeration of the patterns described in \zcref{s:local-computation}. It takes about $80$ seconds and reports $106{,}101$ assignments before the choice of an out-neighbor and $7{,}962$ classes ($2{,}696$ straight patterns and $5{,}266$ turns), which agree with \texttt{patterns.json} class by class. The script \texttt{closed\_exact.py} contains a test in rational arithmetic for the $4{,}735$ patterns whose ring polynomial factors once the pendant sites are removed. It is not part of the proof, since all certificates in the file are operator certificates. However, when it is run as a script, it checks these patterns a second time, in about two seconds. \section{The trail growth}\label{s:ancillary-H2} The folder \texttt{anc/h2} contains the script \texttt{h2\_check.py}, the vector $\mathsf v$ of \zcref{s:computer-H2} in the file \texttt{h2\_vector.json}, and the recorded output \texttt{h2\_output.log}. The check of \zcref{p:H2} is the command \begin{verbatim} python3 anc/h2/h2_check.py \end{verbatim} which took less than a second in the recorded run. It checks the inequalities in integer and rational arithmetic, then prints rounded decimal diagnostics. The driver compares this output with \texttt{h2\_output.log}, whose last line reads \texttt{H2 CHECK PASS: q = 2499/2500, C\_V = 10}. By default the script reads \texttt{anc/h2/h2\_vector.json} and leaves it unchanged. With \texttt{-{}-make}, it first computes a new vector by power iteration in floating-point arithmetic and writes it to that file before checking it. The option \texttt{-{}-vector FILE} selects a different file for reading and for writing when \texttt{-{}-make} is supplied. \section{The weighted trail sums}\label{s:ancillary-H3} The folder \texttt{anc/h3} contains three programs. The script \texttt{tailmem5.py} contains the program \texttt{tailmem5.c}, which enumerates the trails of length at most $20$ exactly and bounds their sums by rounding upward. The script \texttt{bellman.py} contains \texttt{bellman.c}, which proves the bounds for the longer trails, one case $(\mathfrak t, \mathsf e_0)$ at a time. The script \texttt{exact75.py} contains \texttt{exact75.c}, the independent enumeration of the short trails used in check (1) of \zcref{s:tail-trust}. The scripts compile the programs with the commands \begin{verbatim} gcc -O2 -frounding-math -ffp-contract=off tailmem5.c -lm -o tailmem5 gcc -O2 -fopenmp -frounding-math -ffp-contract=off bellman.c -lm -o bellman gcc -O2 -frounding-math -ffp-contract=off exact75.c -lm -o exact75 \end{verbatim} The programs use the C library function \texttt{fesetround} to set the rounding mode and check that each call succeeds. The certification assumes that the compiler and the floating-point environment honor the selected rounding mode \cite{IEEE754}. With GCC we use \texttt{-frounding-math} to request this behavior. GCC documents the option as experimental.\footnote{\url{https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html}} The option \texttt{-ffp-contract=off} disables contraction of a product and a sum into a single operation. The file \texttt{jobs.yaml} lists the command lines of the fifteen recorded runs and of the short runs of the quick mode. For example, the recorded runs for the collinear type and the first direction $\sN$ are the following. \begin{verbatim} python3 anc/h3/tailmem5.py B 10 20 28 109 109 22 0.961 0.935 \ 0.16666666666666667 0.36 1 1.25 1 > short_trails_B_1.log 2>&1 python3 anc/h3/bellman.py B 1 70 600 > bellman_B_1.log python3 anc/h3/exact75.py B 20 0.961 0.935 0.16666666666666667 0.36 \ 1 1.25 1 20 > exact75_B_1.log \end{verbatim} We store the recorded outputs in the files \texttt{short\_trails\_X\_d.log}, \texttt{bellman\_X\_d.log}, and \texttt{exact75\_X\_d.log}. Here $\texttt X = \texttt B$ stands for the collinear type $\tcoll$ and $\texttt X = \texttt C$ for the diagonal type $\tdiag$, and $\texttt d = 1, 2, 3$ stands for the first direction $\mathsf e_0 = \sN, \sW, \sS$. There are five cases (the first direction $\sE$ leads from $u$ into $c$, and the case $(\tcoll, \sS)$ follows from $(\tcoll, \sN)$ by the symmetry used in the proof of \zcref{p:tail}). The labels of the phases in the outputs are given in \zcref{s:tail-trust}. Recall that a run of \texttt{bellman.py} is valid only if it reports \texttt{violated rows = 0} and ends with \texttt{PASS}. We now explain how the entries of \zcref{tab:tail} are read off from these files. Each line \texttt{E n value} of \texttt{short\_trails\_X\_d.log} reports an upward-rounded upper bound for the sum over trails of length $n$. The line \texttt{\# EXACT} reports the aggregate bound rounded separately. The driver computes the first row by adding the decimals from the \texttt{E} lines as exact rationals. For $\tcoll$, it counts the lines of \texttt{short\_trails\_B\_1.log} twice and those of \texttt{short\_trails\_B\_2.log} once. For $\tdiag$, it counts the lines of the three files \texttt{short\_trails\_C\_d.log} once each. The entry of the case $(\mathfrak t, \mathsf e_0)$ in the second, third, and fourth rows comes from the bound in the last line of \texttt{bellman\_X\_d.log}, with reflection for $(\tcoll, \sS)$. The driver rounds each result upward to six decimal places. The printed decimals bound the binary64 numbers from above because the GNU C library converts to decimals in the current rounding direction. For instance, the \texttt{\# tailmem5} line prints the binary64 upper bound on $\bar\beta$ as $0.360001$. The lines \texttt{D n value}, for $22 \le n \le 108$, come from the periodic-quotient calculation described in \zcref{s:tail-trust}. In the empirical comparison for the five cases, the ratio of their sum to the corresponding entry of the table ranged from $0.948$ to $0.951$. With the recorded arguments, \texttt{tailmem5.c} needs $3.1$ gigabytes of memory, almost all of it for the computation of the lines \texttt{D}, and about three minutes on one core. The program \texttt{bellman.c} needs about $1.3$ gigabytes and about ten minutes on four cores for each case; these are the times of the recorded runs. The program \texttt{exact75.c} needs a few seconds. In earlier checks with these compiler options, the outputs of \texttt{exact75.py} in the five cases and of \texttt{tailmem5.py} in the case $(\tcoll, \sW)$ agreed with the recorded files byte for byte. The archive preserves the outputs of the original five runs of \texttt{bellman.py} with $R = 70$. The original parallel sweeps accessed the shared array for $\mathsf U$ without synchronization. The current code synchronizes those accesses. The sweeps propose $\mathsf U$, and their results can depend on the order of updates. The final verification runs in one thread and checks the inequalities for the resulting $\mathsf U$. The full mode of the driver requires a passing final verification, a bound at most the corresponding entry of \zcref{tab:tail}, and free-vector and prefix diagnostics that match the recorded run. The quick mode runs the two programs with small parameters. It runs \texttt{tailmem5.py} with histories of $4$ steps and a quotient of side $7$, instead of $10$ and $28$. The depth-first search that computes the lines \texttt{E} is the same for all values of these two parameters. In earlier checks, these runs took less than $20$ seconds for each case, and the lines \texttt{E} agreed with the recorded ones for all five cases. They also agreed with the last column of the output of \texttt{exact75.py}, up to a relative error of at most $8.3 \cdot 10^{-13}$. Next, the quick mode runs \texttt{bellman.py} with the box of radius $R = 23$ and without sweeps, so that $\mathsf U$ keeps its initial values in the box: the prescribed values at $c$ and $v$, and $\mathsf Z$ stored in binary32 elsewhere. In earlier checks, each run took about $25$ seconds and used $0.6$ gigabytes of memory. These runs reproduced the number of prefixes and the slack of $\mathsf Z$ of the recorded runs and passed the final verification with bounds much larger than the table entries. With the last argument \texttt{1}, \texttt{bellman.py} also prints the value for $n = 22$ of check (2) of \zcref{s:tail-trust}. In the earlier runs this value agreed with the line \texttt{D 22} of the corresponding file \texttt{short\_trails\_X\_d.log} up to a relative error between $1.7 \cdot 10^{-6}$ and $2.5 \cdot 10^{-6}$. This option requires $R \ge 23$.