# Supplement: certificates for "Hooley's twisted cancellation below level 4/15 does not force primes" This supplement, the anc/ directory of the paper's record, holds the code, the input functions and the stored outputs of the computer-assisted certificates behind Theorem A of the paper and of the upper-bound run of its section on Goldbach; the paper cites their stored full-resolution outputs in `full/`. It also holds, in `thmB/`, the exact computations behind Theorem B's numerical bounds and the Remark on the case (1/11, 1/11), and, in `experiments/`, the floating-point experiments of section 8. Rerunning the full certificates takes from seconds to about 18 hours each (table below); `run_all.sh.txt` instead reruns at a small resolution every certificate except the second-order run of (1/18, 1/6), in about an hour and a quarter in total on one core, and checks that the shipped code and inputs reproduce the stored small-resolution outputs exactly; that run takes about 15 s at full resolution and is checked by rerunning it in full (see "The consistency runs"). `run_all.sh.txt` does not run `thmB/` (see "Theorem B's computations"). ## Layout - `engine2/`: the second-order enclosure engine, in integer arithmetic with directed rounding. `dpl.py` is the enclosure arithmetic; `cert2_v2.py`, `cert2_5c779c07.py` and `cert2_f2.py` are the three versions used for the cases (1/20, 1/5), (1/30, 1/4) and (1/30, 4/15); `cert2_v2.py` also made the second-order run of (1/18, 1/6) (its `TEXTS` entry `v2main` lists the 13 classes of the case's constants; the engine reads their values from the input pickle and checks that these are exactly the classes it uses). `cert2_caps.py` is `cert2_v2.py` plus an upper-bound pass, used for the caps of the case (1/20, 1/5) (the bound a_m <= 5 b'_m of the paper's section on Goldbach): its output adds the certified supremum of f and of F = f/|f(1)| over the same strata as the positivity bounds. Its log prints nearest-rounded decimals as diagnostics; the certified values are the exact fractions in its JSON output. - `exact1/`: the exact-integer first-order certificates for (1/11, 1/10) and (1/14, 1/8) (`cert_p3_binned.py`) and for (1/18, 1/6) (`cert_p4_exact_v3.py`). They were written from the mathematical text of the construction, not from the code that produced the constants. - `sep_p4/`, `sep_p5/`: separately written first-order certificates for (1/18, 1/6) and (1/20, 1/5), written from the mathematical text without sight of the other certificates' code (the text quotes some of their numbers), in validated binary64 arithmetic: every convolution is an exact integer polynomial product (python-flint) of integer images rounded outward, and every other operation is binary64 interval arithmetic, rounded outward after each step. No floating-point transform enters any bound. They read the constants from the TSV files beside them. - `inputs/`: the input functions: Python pickles of `fractions.Fraction` values and numpy arrays, stored base64-encoded as `.pkl.b64.txt` because the archive accepts only certain file types. `run_all.sh.txt` decodes them, and `compare.py` checks that each decoded pickle hashes to the value recorded in the stored outputs. To decode one by hand: `python3 -c 'import base64, sys; open(sys.argv[2], "wb").write(base64.b64decode(open(sys.argv[1]).read()))' X.pkl.b64.txt X.pkl`. Loading a pickle can execute code, so each input is also given as a plain-text export, `inputs/.json`: floats as `float.hex()` strings, fractions as `"p/q"`, tuples, dicts (as ordered key-value pairs) and numpy arrays (dtype, shape and data) tagged, with the SHA-256 of the pickle. A reader can inspect the inputs there, disassemble a pickle without executing it (`python3 -m pickletools X.pkl`), or rebuild the object from the export with `compare.py`'s `rebuild` function; `compare.py` checks that every export rebuilds exactly to its pickle's object. Load the pickles only from this supplement. - `audit/`: the separately written recomputations of the independent audits (see "The audits" below): `p3a/`, `p5/`, `p6/`, `p7/`, one per case, each with the inputs it reads that are not in `full/`. - `experiments/`: the floating-point experiments behind section 8 of the paper, bundled (see `experiments/README.md`), and the exact checks of the window masks of `sep_p5/p5rig.py`. They are not certificates and not part of Theorem A's record, and `run_all.sh.txt` does not run them. - `thmB/`: the exact-integer computations behind Theorem B's numerical bounds (at nu = 3/20, 1/7 and 1/8) and behind the Remark on the case (1/11, 1/11) (at eta = 1/11 and 1/12), made by separately written programs during the audit of Theorem B, and the bound at nu = 0.116, made after the audit by a copy of one of them and by a third, separately written program; bundled as in `experiments/`: `sources.md` holds the two programs, the copy, the third program and the two input files that `exact_certificate.py` reads, `outputs_thmB.log` holds the stored outputs, and `python3 unpack.py OUTDIR` extracts both and checks every SHA-256 (see "Theorem B's computations" below). `run_all.sh.txt` does not run them. - `full/`: the stored full-resolution outputs of the certificates of record and of the upper-bound run (the table below), which the paper cites, with their logs where they exist. Text outputs carry an extra `.txt` extension: `full/cert3_M288000.out.txt` is the stored `cert3_M288000.out`, and likewise in `expected_small/`. - `expected_small/`: the stored outputs of the small-resolution runs of `run_all.sh.txt`. - `run_all.sh.txt` (a bash script: run it with bash), `compare.py`: the consistency runs and the comparison (see below). - `SHA256SUMS.txt`: SHA-256 of every other file; check with `sha256sum -c SHA256SUMS.txt`. ## The certificates of record | Case (eta, alpha') | Implementation and command (run in its directory) | M | Elapsed (rounded) | Peak memory | Stored output | |---|---|---|---|---|---| | (1/11, 1/10) | `cert_p3_binned.py 79200 cont_h1_sol_e11a10b3_reg0.10.pkl "0,3,3;0,4,2;0,4,3;0,5,1;0,5,2;0,5,3;0,6,1;0,6,2;0,6,3;1,2,3;2,3,3" 0,3,3 e11a10b3` | 79,200 | about 20 s (as recorded; the run used 34 s of CPU time) | 514 MiB | `full/certb_e11a10b3_M79200.json` | | (1/14, 1/8) | `cert_p3_binned.py 107520 cont_h1_sol_e14a8_reg0.10.pkl "0,3,1;0,4,1;1,2,1;1,3,1;1,4,1;2,2,1;2,3,1;2,4,1;3,2,1;3,3,1;3,4,1;4,2,1;5,5,1;8,3,1;10,2,1;11,1,1;12,0,0;12,1,1;13,0,0" 0,3,1 e14a8_19c` | 107,520 | about 2 min | 1085 MiB | `full/certb_e14a8_19c_M107520.json` | | (1/18, 1/6) | `cert_p4_exact_v3.py 216000 50 50 cont_h2b_sol_e18a6nb_reg0.065.pkl v2main` | 216,000 | about 14 min | 2199 MiB | `full/cert4v3_v2main_M216000.json` (log `full/v3_v2main_M216000_NB50_NQ50.log`) | | (1/18, 1/6), separate | `p4rig3.py 288000 cert 4` (in `sep_p4/`) | 288,000 | about 11 min | 813 MiB | `full/cert3_M288000.out.txt` | | (1/18, 1/6), second order | `cert2_v2.py 1800 10 cont_h2b_sol_e18a6nb_reg0.065.pkl v2main` (KPROF unset, that is all; blocks refined; g = (0, 3, 1), the engine's default for a single bin) | 1,800 | about 15 s | not recorded | `full/cert2v2_v2main_M1800.json` (log `full/v2_v2main_M1800.log`) | | (1/20, 1/5) | `KPROF=3 cert2_v2.py 7200 40 cont_hmk_sol_e20a5k3_reg0.05.pkl p5frozen` | 7,200 | about 5 min | not recorded | `full/cert2v2_p5frozen_M7200.json` | | (1/20, 1/5), caps | `KPROF=3 GBIN=4 cert2_caps.py 7200 40 cont_hmk_sol_e20a5k3_reg0.05.pkl p5frozen` | 7,200 | about 4 min | not recorded (about 360 MiB in a later rerun) | `full/caps_p5frozen_M7200.json` | | (1/20, 1/5), separate | `p5rig.py 432000 cert 1 72000 16` (in `sep_p5/`) | 432,000 | 2.4 h of CPU time (see below) | 3606 MiB | `full/rig_M432000.out.txt` | | (1/30, 1/4) | `KW=2:1,3:-1 GVEC=2:1,3:1 T0ADJ=1 NBQ=32 NBQLO=64 cert2_5c779c07.py 7680 80 kw23m_binsJ12_reg1040glo93.pkl g93adjQ32` | 7,680 | about 4.6 h | 509 MiB | `full/cert2_g93adjQ32_M7680.json` | | (1/30, 4/15) | `KW=2:1,3:-1 GVEC=2:1,3:1 T0ADJ=1 F1ADJ=1 NBQ=32 NBQLO=64 QOUTER=1 QADAPT=2,1:-1.0147:8:2 cert2_f2.py 23040 80 kw23m_e30a415_reg1030glo93.pkl p7r` | 23,040 | about 17.8 h | 889 MiB | `full/cert2_p7r_M23040.json` | The log `full/v3_v2main_M216000_NB50_NQ50.log` of the exact (1/18, 1/6) run is shipped with the directory paths in its argument and command lines removed (its original SHA-256 is b726a8ef4bfc01e153a5f312f317987885cfc944c6f3481a2d9a5bdac9a3e859); its peak memory, 2199 MiB, is GNU `time`'s maximum resident set size. All runs were single-threaded. Of the five logs that record GNU `time`'s CPU figures, four show 90 to 100 per cent of one CPU; the fifth, of the (1/11, 1/10) run, shows 158 per cent because its recorded wall-clock time is too short (see below). Elapsed times are wall-clock times as recorded by the run (by GNU `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 repeated (1/20, 1/5) run 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. The repeated run of the separate (1/20, 1/5) implementation was paused by the machine for about 50 minutes of its elapsed time, so the time stamps in its stored output run long (the last reads 11,652.6 s); its row gives its CPU time, 8,553 s. Input paths are relative to `inputs/` (after decoding). Each JSON output records, among other things, 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 pickle (and, for the second-order runs, of the engine and of `dpl.py`); the first-order outputs also record the range of each diagonal and forced function, which the second-order runs print only in their logs (nearest-rounded to four decimals). The text outputs of `sep_p4/` and `sep_p5/` give outward-rounded decimals and a binary64 margin, and record no hash. The inputs of the (1/30, 4/15) run were hashed and frozen before it was launched. The (1/30, 1/4) run was made with the engine file named `cert2.py`; it is shipped as `cert2_5c779c07.py`. ## The audits Every certificate except those of (1/11, 1/10) and (1/14, 1/8) was checked by an independent audit: a review, separate from the implementation, that read the certificate's code against the mathematical text of the case and reran it as stated below. The two cases (1/11, 1/10) and (1/14, 1/8) had a review of their formulas and inputs, not of their code. Some audits and the review also recomputed selected quantities with separately written scripts in ball or exact arithmetic (python-flint), which do not use the certificates' code; those scripts are in `audit/`, and `run_all.sh.txt` reruns them. The fixes the audits asked for were applied before the runs of record. Below, each certificate's code is identified by the SHA-256 of the file that was run (the value recorded in the second-order outputs as `script_sha256`; the shipped files differ only as described in the next section). - **(1/11, 1/10) and (1/14, 1/8)** (labels P3a, P3b), `exact1/cert_p3_binned.py`, as run `375896ebf2ead65f63a7e121bfd556775d860f07841bc6f13732d3148aeb127e`. A review checked the formulas, inputs, signs, normalisations and selected parts of the exact arithmetic against the text; it did not read the code bodies and did not rerun the certificates. It recomputed in exact arithmetic the least-margin cell of (1/11, 1/10), using that certificate's enclosures of h and f(1): `audit/p3a/spot_least_cell.py` (scaled margin above 0.0816 on that cell). No cell of (1/14, 1/8) was recomputed. Conclusion: the cases and their lift confirmed, with fixes. - **(1/18, 1/6)** (P4). `exact1/cert_p4_exact_v3.py`, as run `3a743ad15d68e69f82c72c9089c8e8db3e3fc3c94caa12054e1a3c9e60171d19`: the audit checked the formulas against the implementation and replayed the certificate at M = 108,000; every stored field matched except the elapsed time. The run at 216,000 was audited from its output. Conclusion: the case, its lift and the certificate's fit confirmed, with fixes. The second-order run `full/cert2v2_v2main_M1800.json` was made by `engine2/cert2_v2.py`, as run `045cc3ae111cf48e5d02acb0492e68aeecb57bf110d0581a0b2ed053b1fd5564` (the engine of the (1/20, 1/5) record below). It equals in every value field an earlier run with the same settings, made on an earlier state of the engine. The audit of the second-order engine reran that earlier run, and its companions at M = 900 and 3600, on the state of the engine it reviewed, and reproduced every field of their stored outputs. The separate implementation `sep_p4/p4rig3.py`, as first run `41042878919343abedc1c5a92d236fe8504a56becdad999f4e86aa82ffdb824c` (with `vconv.py` `8ddefdbacb2df659dee82a49e9ba8a49d327483b460267a51d2e35768119c28f`): its audit read the code bodies, including the error control of the binary64 steps, replayed it at M = 144,000 (every output byte reproduced except timings) and reran all its integer products at M = 288,000. Conclusion: confirmed with fixes; the arithmetic sound. That audit and the reproduction did not include a complete code-body sweep of the program's moving windows at x = 1/2. A later dedicated sweep checked the window operands, their endpoint conventions and arithmetic, and all their consumers, on the program as shipped before this correction (`p4rig3.py` `3e3d2b6239bd00b9136661649e3a22e30eed983b429fcdb43dbd5f3f5d0f2da4` with `vconv.py` `7cba35a350013bd384350fa168de7c972b0e3886daaadebd5c463c0c80a2fc9f`, which differ from the files as first run only in comments and docstrings: their abstract syntax trees, with docstrings removed, are identical). It found that the helper enclosing the delta term meets its stated contract, which covers closed cells of the large component and almost every value of the integration parameter sigma (it must not be read as a joint closed-rectangle bound), and that every consumer integrates in sigma. It found three things to correct, none on a path the shipped runs use: the docstring of the grid sums gave the U arrays a range they no longer have once their updates stop (their one consumer asks only where they are valid); the program's copy of `vconv.py` lacked two precondition checks (a nonnegative binary scale; M an exactly representable positive integer) that every shipped call satisfies; and the descriptions of the arithmetic and of the underflow argument needed qualifying. On those bytes its exact rational tests pass (2,487 checks), a planted error in the delta mask fails 64 of them, and both stored resolutions were replayed with every printed line reproduced apart from timings. The shipped program, as run `989f20ac9c5f754b0c5f6a3ac7e538bd655ff0417b20848aaf7188abe55e17bb` (with `vconv.py` `146cc23a0df88e2ebba0d1d41fc2426c69e33b7ed0b2ce63fb3cbde65ce7cd33`, the same file as `sep_p5/vconv.py`), differs from those bytes in code only by assertions in the method `_two` that refuse a query of the U arrays outside that range and, in `vconv.py`, by the two checks (in `to_poly` and `Exact.__init__`); its other changes are to the docstring, the header and a section heading. Both stored resolutions were rerun with the shipped program on 13 November 2026: at both, every printed line equals that of the earlier stored output apart from timings (margins 0.029215799282164553 at M = 144,000 and 0.04587857518156368 at M = 288,000), and the stored outputs are now those of the reruns. As a robustness measurement by the sweep, not the run of record, enclosing the delta term on the closed cell of sigma as well gives margins 0.029213799882385368 at M = 144,000 and 0.04587759299775417 at M = 288,000, against 0.029215799282164553 and 0.04587857518156368. - **(1/20, 1/5)** (P5). `engine2/cert2_v2.py`, as run `045cc3ae111cf48e5d02acb0492e68aeecb57bf110d0581a0b2ed053b1fd5564`, with `engine2/dpl.py` `b7f331dad0c06a423fa0f897ac8cb60cc54f36000e7caf9743a865a580f95281`: the audit read the code bodies and reran the certificate at the full resolution M = 7200 and at M = 3600; both runs reproduce every stored field (the M = 7200 output byte for byte: `audit/p5/p5_rerun_M7200.json` has the SHA-256 of `full/cert2v2_p5frozen_M7200.json`). `audit/p5/p5_independent.py` computes T_0(g), the parity coefficient Phi_g and the diagonal at sigma = alpha' as validated integrals, without the engine, and checks that they lie inside the intervals of those reruns: it reads their outputs, shipped beside it (`p5_rerun_M*.json`, and `p5_diagnostics_M*.json`, the internal values the reruns recorded). Conclusion: the engine sound; the specification matched after fixes; the pass confirmed. The caps pass `engine2/cert2_caps.py`, as run `081b0528746e057e24531e26fdbdc02dcbcb0f6a07d9c6036ad9b895ebc5154f`, was read in full with its difference from `cert2_v2.py`, and replayed at M = 7200 (every output field identical) and M = 3600. Conclusion: sound, with fixes to the log's printed decimals only. The separate implementation `sep_p5/p5rig.py`, as first run `aaeeb7f2058b98e255e663ee6c4cccb966abd33a877620d2e16eae2ca10d90e0` (with `vconv.py` `18aa5e3bc8d3cf769af909786ecf5b465e9856e20fad621cd99862bb95bd3d72`): its audit read the code bodies and replayed it at M = 36,000 (every printed field reproduced); the run at 432,000 was audited from its output, not rerun. Conclusion: confirmed with fixes; the arithmetic sound. A later review of the half-point code left one part of this program unchecked: the code that builds the moving windows at x = 1/2. A separate audit of that code found a defect in one of the two masks that compare a range of closed cells of x with the window W(sigma) = [1/2 - sigma, 1/2): for a range whose right end is the point 1/2, where the window's indicator is 0, the mask counted the indicator as 1 on the whole range, so the enclosure of the window term could exclude its value at that endpoint (at M = 120 an upper bound of -1.9999999999999993 for a quantity equal to 0). The program's uses of these enclosures integrate over that endpoint, so the bounds it printed remain valid. The audit's exact tests ran on the program as shipped before this correction, `c654317e11eef2710c98b6c847a94e03d8e92cc3c460f56376addd37af70489a`, which differs from the file as first run only in comments and docstrings (their abstract syntax trees, with docstrings removed, are identical). An exact check of both masks over every combination of cells, whether the program reaches it or not, then showed that the other mask could miss the combination in which the range's right end meets the window's left end at the top of a closed cell of sigma; the program reaches no such combination. Both masks are corrected in the shipped program, as run `c5522ae5b1d4cfc5cacb2b0b8102b2ca29977dd70a8f35728ad33e61706bdb07` (with `vconv.py` `146cc23a0df88e2ebba0d1d41fc2426c69e33b7ed0b2ce63fb3cbde65ce7cd33`, unchanged from the previously shipped copy), whose code differs from the bytes the audit tested only in the method that holds the two masks; its header and comments were also rewritten. With the corrected program, the replay at M = 36,000 reproduces every printed line of the earlier replay apart from times (margin -0.33748404162730133), and the full run at M = 432,000 was repeated with it on 13 November 2026: every printed line equals that of the first run apart from the time stamps that open its lines (margin 0.016096579067180313; PASS), and the stored output is now that of this run. The two checks of the masks, with a command that shows both refusing the masks as first run, are described in `experiments/README.md` ("The window masks of `sep_p5/p5rig.py`"). - **(1/30, 1/4)** (P6). `engine2/cert2_5c779c07.py`, as run `5c779c07fa24f0b6868651ced8434e3714536139ec189e2f0d692670fd6be355`: the audit read the code bodies and reran the certificate at M = 1920 with the run's settings, comparing the result field by field with the stored M = 7680 output: the settings, inputs, constants and code hashes are identical, each interval enclosure at 1920 contains its counterpart at 7680, and the bounds and the margin are better at 7680 (at 1920 the margin is negative, as expected). This checks consistency across resolutions; the full run was audited, not rerun. `audit/p6/p6_independent.py` computes T_0(g), Phi_g(1) and the diagonal (0.8705 <= |B_j| <= 1.8484 on the whole forcing range) as validated integrals, without the engine, and checks T_0(g) against the stored output. Conclusion: the engine sound; the specification matched after fixes; the pass confirmed. - **(1/30, 4/15)** (P7). `engine2/cert2_f2.py`, as run `0ba729809d996adc104405a03d8903c354263db8f216a4dbecf6a28315fce150`: the audits read the code bodies and reran parts of the computation: the forcing chain, the parity solve, f(1), the free bound and the adaptively refined extended class at M = 960, and the diagonals and the parity data at the full resolution M = 23,040, by replaying the certificate's kernel code (its output is `audit/p7/p7_kernels.json`). `audit/p7/p7_independent.py` computes T_0(g), Phi_g and the global diagonal in ball arithmetic, without the engine, and checks that they lie inside the intervals of that kernel replay and of the stored output. The inputs of the full run were checked against a manifest frozen before it was launched. No audit reran the full computation of this case at any resolution, and none recomputed the extended class that binds its margin; that class was checked by reading its code path. Conclusion: the engine sound; the run certified; the specification matched after fixes; the pass confirmed. The consistency run of `run_all.sh.txt` at M = 960 runs this certificate end to end, but it is the author's own reproduction, not an audit. ## Theorem B's computations `thmB/` holds the exact computations behind the numerical bounds of the paper's second theorem and behind the Remark on the case (1/11, 1/11). Except for the bound at nu = 0.116 (below), they were made by two separately written programs during the audit of that theorem: `independent_p1.py` (the bounds at nu = 3/20, 1/7 and 1/8; it imports `exact_certificate.py`) and `exact_certificate.py` (the Remark, at eta = 1/11 and 1/12; it reads the two constants files `cert_p0_eta11_N4400.json` and `cert_p0_eta12_N4800.json`). Both carry every quantity as an integer divided by 10^18 on a mesh of step exactly 1/N, evaluate nonnegative convolutions as exact integer polynomial products and round every division outward. The bound at nu = 0.116, below 1/8, where the term in I_8 enters, was made after the audit by `independent_p1_k8.py`, a copy of `independent_p1.py` that adds that term to the bound and leaves its enclosure arithmetic unchanged; the original audit did not cover this copy. A third, separately written program, `k8_bound.py`, was written after the audit from the paper and the description above, without sight of the code of the other programs here, and the original audit did not cover this program either. It applies the same scheme at nu = 0.116 on a mesh of step 1/1,024,000, forming the convolutions as exact integer polynomial products with python-flint (each product checked modulo two primes and at sampled coefficients), and gives a lower bound of at least 0.0354920736 there; a second rigorous channel of the same program, an integer form of the integral recurrence, gives at least 0.0354930952, and a third channel, in floating point, is a comparison only. The shipped `exact_certificate.py` differs from the program as run in one declared path: it reads its input files from its own directory. After `python3 unpack.py OUTDIR` in `thmB/`, run these in an empty directory; each writes its JSON output there, and the stored outputs are in OUTDIR/outputs/: - `python3 OUTDIR/independent_p1.py --exact` (nu = 3/20 with N = 8000 and nu = 1/7 with N = 9800; its standard output is `exact_p1.log`); - `python3 -c 'import sys, json; sys.path.insert(0, "OUTDIR"); from independent_p1 import exact; print(json.dumps(exact(3, 20, 16000)))'` (`exact_p1_refined.log`: the bound at nu = 3/20 that the paper quotes), and the same with `exact(1, 8, 8000)` (`exact_p1_endpoint.log`: the bound at nu = 1/8); - `python3 OUTDIR/independent_p1_k8.py --point 29/250:32000` (nu = 0.116 with N = 32000 and the term in I_8; it writes `exact_p1_k8_29_250_N32000.json`, and its standard output is `exact_p1_k8.log`). With that term set to zero the copy computes what `independent_p1.py` computes: `python3 -c 'import sys, json; sys.path.insert(0, "OUTDIR"); from independent_p1_k8 import exact; print(json.dumps(exact(1, 8, 8000, 0)))'` prints `exact_p1_endpoint.log` and writes `exact_p1_1_8_N8000.json`; likewise `exact(3, 20, 16000, 0)` gives `exact_p1_refined.log`, and `exact(3, 20, 8000, 0)` followed by `exact(1, 7, 9800, 0)` gives `exact_p1.log`. The copy's own `--exact` is not one of these commands: it runs the audit's points with the term in I_8 and writes files named `exact_p1_k8_*`; - `python3 OUTDIR/k8_bound.py 29 250 1024000 ABC > nu29_250_N1024000_ABC.json` (nu = 0.116 with N = 1,024,000; channels A and B are the two rigorous enclosures and C the floating-point comparison; it needs python-flint, and numpy for channel C); - `python3 OUTDIR/independent_p1_k8.py --quad 3/20 --quad 1/7 --quad 1/8 --quad 3/25 --quad 29/250 --quad 23/200 --quad 57/500` (the copy's floating-point recurrence with the term in I_8, at N = 28,000, 56,000 and 112,000 for each nu; not a certificate; it writes `quadrature_k8.json`, whose field `bound_float_k8` gives the value 0.03551 at nu = 0.116 that the paper quotes, and the change of sign of the paper's bound between nu = 0.114 (57/500, about -0.0323) and nu = 0.115 (23/200, about +0.0022)); - `python3 OUTDIR/exact_certificate.py` (eta = 1/12 with N = 4800, then eta = 1/11 with N = 4400; its output is `exact_certificate.log`). Without `--exact`, `independent_p1.py` runs a floating-point quadrature and sampling check (not a certificate); its output, `independent_p1.log` and `independent_p1_results.json`, gives the floating-point values 0.70749 at nu = 3/20 and 0.62035 at nu = 1/7 that the paper quotes. On 13 Nov 2026 the shipped programs of the audit, run as above from the unpacked bundle, reproduced every stored output of the audit byte for byte, in a few seconds each and under 0.1 GB of memory. On 14 Nov 2026, run the same way, the copy reproduced `exact_p1_k8_29_250_N32000.json` and `quadrature_k8.json` byte for byte and, with the term in I_8 set to zero, `exact_p1.log`, `exact_p1_refined.log`, `exact_p1_endpoint.log` and their four JSON files byte for byte; `k8_bound.py` reproduced `nu29_250_N1024000_ABC.json` in every field except its timings (the `secs` fields and the times in its `log` lines), in about 25 s of CPU time and under 1 GB of memory. ## The shipped code and the code that was run The scripts are the ones that produced the stored outputs, with three kinds of change: comments and module docstrings were rewritten without internal names; the line that sets the import path of the three `cert2` engines now points to the script's own directory; and the output paths (and one unused default input path) are now relative to the working directory. An abstract-syntax-tree comparison of each shipped script with the script as run, with these changes declared, shows the code otherwise identical. Because of these edits, the SHA-256 values of the engines recorded inside the stored JSON outputs are those of the scripts as run, not of the shipped files. The logs in `full/` are as written by the runs, except that machine-specific path prefixes were removed from their `Command being timed` lines and, in `v3_v2main_M216000_NB50_NQ50.log`, also from its first (argument) line (its original SHA-256 is given above). ## The consistency runs The labels P3a, P3b, P4, ..., P7 are those of the paper's table of cases. ``` PY= bash run_all.sh.txt [OUTDIR] ``` copies the code and inputs into OUTDIR (default `./out`), reruns at a small resolution, with the settings of its full run, each certificate except the second-order run of (1/18, 1/6) (the exact first-order certificates at 13,200, 53,760 and 7,200; the second-order engine and its caps pass at 3,600 for (1/20, 1/5), and the engine at 960 for (1/30, 1/4) and (1/30, 4/15); the (1/18, 1/6) separate implementation at its half resolution, 144,000; the (1/20, 1/5) separate implementation at 36,000 with its coarse resolution equal to M), and then runs `compare.py`, which 1. compares every output with `expected_small/` (JSON field by field, exactly, except the elapsed-time field; text outputs line by line after removing elapsed times), and 2. checks that each stored full-resolution output in `full/` except `cert2v2_v2main_M1800.json` has the verdict PASS and a margin at least the value stated in the paper, and 3. checks that each decoded input pickle hashes to a value recorded in `full/`, and 4. checks that each plain-text export `inputs/.json` rebuilds exactly to the object in its pickle. It ends with `ALL REPRODUCED` when every check passes. At these resolutions several margins are negative: the consistency runs check the code and the inputs, not the theorems. 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; no independent audit reran that case end to end (the paper's section on the certificates says what the audits did). Tested with Python 3.14.4, numpy 2.5.2 and python-flint 0.9.0 on Linux; `REPRODUCTION.md` records a run of record. The second-order run of (1/18, 1/6) is not among the consistency runs, and `compare.py` does not check its verdict or margin (only its recorded input hash enters check 3). It takes about 15 s at full resolution: in a copy of `engine2/`, with the input decoded, run the command in its row of the table above, with `KPROF`, `GBIN` and `BLOCKS` unset; it writes `cert2v2_v2main_M1800.json` in the working directory. Compare that file with `full/cert2v2_v2main_M1800.json`: every field agrees except `script_sha256` and `dpl_sha256`, which record the engine and `dpl.py` that were run (the files as run in the stored output, the shipped files in a rerun; see "The shipped code and the code that was run").