# anc/manifest.yaml -- the ancillary files of the paper # "Uniform Spectral Gap for the AKLT Model on the Square Lattice" (P. M. Aronow and P. Lopatto). # The files check the three computer-assisted inputs (H1), (H2), (H3) of Theorem t:inputs (Section 8, Appendices B # and C of the paper; Appendix E describes these files). This manifest lists every file of anc/ with its role, what # it checks, the command that runs it, the expected output, and the time and memory it needs. The release # packager checks the file list, byte sizes and SHA-256 digests. This manifest lists itself without a digest. # # Commands below are written relative to the directory anc/. Scripts locate their bundled data relative to their # own files. Python 3.8 or later, NumPy for the scripts in h1/, and GCC with OpenMP for h3/. requirements: python: "3.8 or later (tested with 3.13.18)" python_packages: "numpy (h1/ring.py, h1/cert.py; tested with 2.5.3); nothing else outside the standard library" compiler: "gcc with OpenMP and the C math library (tested with gcc 13.3.0, x86-64 Linux)" floating_point: "IEEE 754 binary64 and binary32 with directed rounding (fesetround), including upward conversion to decimal by the C library; see Appendix E for the compiler flags and their scope." assertions: "Run without python -O. The magnitude guards in h1/cert.py and the checks in h2/h2_check.py use assertions." driver: quick: "python3 run_all_checks.py --quick (about 6 minutes on one core, at most 0.6 GB of memory)" full: "python3 run_all_checks.py --full (adds about 25 CPU-minutes for (H1) and about 70 minutes for the (H3) runs; up to 3.1 GB)" hexagon_note: >- Hexagon accepts as ancillary files only data files (.json, .jsonl, .csv, .tsv, .yaml, .yml, .log) and scripts (.py, .sage, .gp, .m2, .magma, .gap). The three C programs of (H3) are therefore stored verbatim, each in a Python script, as a string whose sha256 digest the script checks before use. The script writes the .c file to a directory, compiles it with the flags given below and runs it with the given arguments, or prints the source (--print-source). Outputs of runs are stored with the extension .log. hardware_of_recorded_runs: >- Recorded runs: the verification of all 7,962 (H1) certificates took 1,354 s in one process; each bellman.py run with the recorded arguments took about ten minutes on four cores and about 1.3 GB. Re-runs before the revision (2026-11-17, Linux, four x86-64 cores, 15 GB): a tailmem5.py run with the recorded arguments takes 184 s on one core and 2.9 GB resident (3.1 GB allocated); all other programs run in seconds or minutes on one core (see the entries below). conventions: h1_step_type: >- A pattern is placed with its passage site x at (0, 0); the trail arrives from s = (0, -1) (paper: \sS). Its out-neighbor 'out' is (0, 1) = N for a straight step and (1, 0) = E for a turn (a turn to W is represented by its mirror image). The threshold is 961/1000 (= c_s) for a straight pattern and 187/200 (= c_t) for a turn. This is the convention of ring.py (N = (0, 1)), closed_exact.py (threshold cs if out == (0, 1)), run_prod.py (TGT = {(0, 1): 961/1000, (1, 0): 187/200}) and enumerate_patterns.py (straight = out N). h1_sites: >- Ring sites E, c0, N, c1, W, c2, s, c3 = (1,0), (1,1), (0,1), (-1,1), (-1,0), (-1,-1), (0,-1), (1,-1); tips (2,0), (0,2), (-2,0), (0,-2). Kinds: 'u' = status 0 (site measure dn), 'd' = status 1 (site measure 3/5 dn + 2/5 delta_0); removed sites (status 2) do not occur. A 'slot' is an exterior unit vector at a corner, a 'tip' the exterior vector of a tip, of radius 3/5 (TIPRAD). h1_options: "The options 'refined', TIPRAD = 37/65 and level 2 are not used by the paper." h3_pair_types: "X = B: collinear pairs (\\tcoll in the paper); X = C: diagonal pairs (\\tdiag). Center c = (0,0), u = (-1,0), v = (1,0) (type B) or (0,1) (type C)." h3_directions: "D0 = d0, the first direction of the trail: 0 = E (empty class), 1 = N, 2 = W, 3 = S. Type B, class S equals class N by the reflection x_2 -> -x_2." h3_phases: "The phases A, B, C, D of the programs are the paper's t^-, s^-, t^+, s^+ (before a turning response, before a straight response, after a turning response, after a straight response)." h3_constants: >- c_s = 0.961, c_t = 0.935, coefficients 1/6 and 9/25 (entered as 0.16666666666666667 and 0.36), weights h = (1, 5/4). In the two proof programs, tailmem5 and bellman, c_s and c_t are moved down one unit in the last place and the coefficients are moved up one unit. The independent comparison program exact75 uses a relative margin of 1e-15 instead. h3_file_names: "short_trails_X_d.log, bellman_X_d.log, exact75_X_d.log: type X in {B, C}, first direction d in {1, 2, 3}." table_tab_tail: description: >- Table tab:tail (Appendix C) is computed from the logs by exact rational summation of the printed decimals, which are upward rounded; every entry is rounded up in the sixth decimal, and the last two rows are computed from the rounded entries. run_all_checks.py --quick recomputes the table and compares it with these values. row_exact_B: "0.582353 from twice the sum of the E lines of h3/short_trails_B_1.log plus the sum of the E lines of h3/short_trails_B_2.log, rounded upward to six decimal places. Each # EXACT line reports a separately rounded aggregate." row_exact_C: "0.823644 = sum of the lines E of h3/short_trails_C_1.log, short_trails_C_2.log, short_trails_C_3.log" row_N: "B 0.111332, C 0.078222: last line (TAIL ... PASS) of h3/bellman_B_1.log, h3/bellman_C_1.log" row_W: "B 0.118181, C 0.114607: last line of h3/bellman_B_2.log, h3/bellman_C_2.log" row_S: "B 0.111332 (= row N, by reflection; no run), C 0.107712: last line of h3/bellman_C_3.log" row_sum: "B 0.923198, C 1.124185 (sums of the rounded entries; type B counts the exact row and rows N, W, S once each)" row_K: "K_B(1) <= 0.923198, K_C(1) <= 1.124185 / (5/4) = 0.899348" independent_check: "The last column (optimal_h) of h3/exact75_X_d.log agrees with the lines E of h3/short_trails_X_d.log to a relative error below 1e-12 (largest 8.3e-13, type C, d = 2)." quotient_walk_lines: >- The lines 'D n value' (22 <= n <= 108) of the short_trails logs give values of a separate dynamic program in tailmem5.c on a periodic quotient of the lattice. It discards steps from u and a_0 when the history already records a visit there, and for the longer lengths it can count paths to translates of v. These outputs are used for the empirical comparisons (2) and (3) of Appendix C. The line 'D 22' agrees with the value printed by bellman.py with DEBUG = 1 to a relative difference of 1.7e-6 to 2.5e-6. The sum of the D lines is 94.8% to 95.1% of the table entry for the case. The line '# TAIL(22- The 7,962 patterns of the class \Pext (2,696 straight, 5,266 turn): a list of records with 'pid' (= position), 'out' (out-neighbor), 'kinds' (status of the sites, 'u' or 'd'), 'present' (present bonds). The field 'min57' is a floating-point estimate of the minimum of the ratio, used by run_prod.py only to order its work; the fields 'thr', 'dim', 'k950' come from an earlier stage and are read by no program here (the thresholds are fixed by the type, see check_certificate_file.py). bytes: 2316400 sha256: "fd0866f455505e2cd6317f4a5cc4ec45a1f7d6ed5816786cb6500c3b773caba2" - path: h1/certificates.jsonl role: data checks: >- One exact certificate per pattern (7,962 lines), all of kind 'operator', model 'covered', tip radius 3/5: the threshold 'target' (961/1000 or 187/200), the inversion set 'S' (slot indices), and 'leafred' (whether corners with one present bond are replaced by a single slot). The other fields ('n', 'float_bound', 'sectors') are descriptive. The file collects the records written by run_prod.py in two production runs (the 3,227 patterns whose ring does not decouple, and, with WHICH=decoupled, the other 4,735), with the field cS renamed float_bound. bytes: 1731625 sha256: "a3e83622530be8383c9a7989dc78461d76fda512025b458a6d61ead8d49bf309" - path: h1/ring.py role: module checks: >- Reads patterns.json (function load) and builds a pattern (class Pattern: sites, slots, present bonds, the ring). Its floating-point evaluation of the ratio and its minimizer are used only by run_prod.py to choose certificates; verify_all.py uses only the pattern structure. command: "python3 h1/ring.py [pid ...] (prints floating-point minima of the ratio for a few patterns; not a check)" bytes: 7628 sha256: "a6ad36a91408f7421cfd71e8ff4e02109e2314952f2068b5ab5452c637ba072b" - path: h1/cert.py role: module checks: >- Exact integer tensors of the reduced ring integrals (3 D Z_cur and 5 D Z_next), the operator of the inverted multi-affine polynomial on the spin sectors, and the exact positive-definiteness test of 5 q W_cur - 3 p W_next by fraction-free (Bareiss) elimination in Python integers (method Certificate.exact). int64 arithmetic with asserted magnitude bounds and a fallback to Python integers. command: "python3 h1/cert.py PID [P Q] (diagnostics for one pattern; with P Q, the exact check at c = P/Q)" bytes: 23990 sha256: "96fa550928efe0ffe9133eee41ebe83008054fdfe0d3f1c51b0acad320c9d5a8" - path: h1/closed_exact.py role: module and check checks: >- Exact rational closed-form check for the patterns whose ring decouples after pruning pendant trees; used by verify_all.py for records of kind 'closed' (none in certificates.jsonl) and by run_prod.py to split the patterns. As a script it gives a second, independent proof of (H1) for these 4,735 patterns. command: "python3 h1/closed_exact.py" expected: "first line: tip radius 3/5 | covered : decoupled patterns 4735 certified exactly at (961/1000, 187/200): 4735 fails [] (the second line concerns the unused refined model)" time: "2 seconds" memory: "60 MB" bytes: 4062 sha256: "c98fc3ab323a569a30ffdeac18f1cfee0cd2d2c2a65e47088bcfacaa138644a1" - path: h1/verify_all.py role: checker checks: >- For every record of the certificate file: rebuilds the integer tensors of the pattern from patterns.json, applies the inversion set S, and checks the certificate exactly at the threshold of the record (positive definiteness on the sector of least |S^3_tot| of each exchange-parity block, after checking exactly that the matrices are symmetric, real and block diagonal). The matrix test is exact. The magnitude assertions for the coefficient contractions use binary64 copies. Refuses to run under python -O. command: "python3 h1/verify_all.py [h1/certificates.jsonl [part nparts]] (part nparts: only the records part, part + nparts, ...)" expected: "certificates 7962 verified 7962 failed [] time ... (h1/verify_all_output.log)" time: "1,354 s for all 7,962 certificates in one process (recorded run); the slice 0 100 (80 certificates) about 25 s" memory: "about 100 MB" bytes: 1790 sha256: "df673f53915b849b1891d3626cd2fcab93c8e2740cb2e5f5d5b8469ef0599ba4" - path: h1/check_certificate_file.py role: checker checks: >- What verify_all.py does not check: that patterns.json has the 7,962 patterns with pid = position and out-neighbor N or E; that every pid occurs exactly once in certificates.jsonl; that every record is in the covered model; that every record and ring.TIPRAD have tip radius 3/5; that the threshold of every record is 961/1000 for a straight pattern and 187/200 for a turn; that every record is a well-formed operator or closed-form certificate; that assertions are enabled. command: "python3 h1/check_certificate_file.py [patterns.json [certificates.jsonl]]" expected: "seven lines ending in ok, then CERTIFICATE FILE CHECK PASS" time: "under 1 second" memory: "70 MB" bytes: 5647 sha256: "ba08e0fda35c205e93b0d2729880648e74b5e69abb5cbfb1cee814ad0c92ae17" - path: h1/run_prod.py role: producer (not needed for checking) checks: >- Produces the certificates: for each pattern, a floating-point minimizer proposes the inversion set S (with a greedy search over S if needed), the floating-point bound c_S is computed, and the exact check of cert.py is run at the target. Floating-point minimization and eigenvalue estimates guide the choices. The certificate is the exact matrix check, which verify_all.py repeats. command: "python3 h1/run_prod.py part nparts OUTFILE covered (and WHICH=decoupled python3 h1/run_prod.py ... for the other patterns)" time: "about 34 CPU-minutes for all patterns (original run)" bytes: 4710 sha256: "3bc644848804f4407417e0b8d22b276f7885d9eda44217804e0ef5d7558e8261" - path: h1/enumerate_patterns.py role: independent check checks: >- Enumerates the pattern class again from its definition (statuses of the eight ring sites, consistency of the kept bonds, effective pattern up to the mirror x -> -x), independently of the program that produced patterns.json, and compares the canonical keys with patterns.json. command: "python3 h1/enumerate_patterns.py [patterns.json]" expected: |- consistent raw configurations 106101 effective patterns 7962 straight 2696 turn 5266 certified list: records 7962 distinct canonical keys 7962 in enumeration but not in list: 0 in list but not in enumeration: 0 time: "80 seconds" memory: "75 MB" bytes: 4404 sha256: "182e75b2768ed4b2a23fae71d0acb77d99116b4043ec1b159e47b481e07f2e9d" - path: h1/verify_all_output.log role: log checks: "Recorded output of python3 verify_all.py certificates.jsonl on all 7,962 certificates (one process, before the paths in the scripts were made relative)." bytes: 53 sha256: "539b4acdad8f7acda0984f52f2fc411c9e2dbfe2ec502fe3897799d8459f0f20" # ------------------------------------------------------------------ (H2), Proposition p:H2 - path: h2/h2_check.py role: checker checks: >- Regenerates the 916 histories of memory 6 and their admissible steps, reads the positive integer vector of h2_vector.json, and checks in integer arithmetic that A_6 v <= (2499/2500) v and (max v / min v) (x_t 2500/2499)^6 <= 10. With --make it first proposes a vector by floating-point power iteration, writes it to --vector PATH (default h2/h2_vector.json), and checks it. The inequalities are checked exactly and the printed diagnostics are rounded. Refuses to run under python -O. command: "python3 h2/h2_check.py [--make] [--vector PATH]" expected: "h2/h2_output.log (last line: H2 CHECK PASS: q = 2499/2500, C_V = 10)" time: "under 1 second" memory: "15 MB" bytes: 3697 sha256: "5117e8b9457e8af2884c46bbb8b4399307fb48bfdd942129829b1e75bda112f4" - path: h2/h2_vector.json role: data checks: "The positive integer vector v on the 916 histories of memory 6 (key 'vector', in the order in which h2_check.py generates the histories)." bytes: 12957 sha256: "405ccf10634771d92caefbb4a0e9ec837478f66074844ee871ea44b536c32571" - path: h2/h2_output.log role: log checks: "Recorded output of python3 h2/h2_check.py." bytes: 201 sha256: "2a521303a058593480d9fc4e68d9a58e9a1f594860cabc324dbefd040c3cf8f4" # ------------------------------------------------------------------ (H3), Appendix C - path: h3/tailmem5.py role: program (C source tailmem5.c stored verbatim) checks: >- Exact enumeration, by depth-first search, of the closed trails of length at most 20 for one type X and one first direction d0. It sorts the first-visit steps by rounded approximations to the optimal-order keys, then evaluates the weight in that order with upward rounding. The 'E n value' upper bounds give the first row of Table tab:tail. c_source_sha256: "4946f4c78703e82e76f7a3bd01d56c3853508dcabc0855b9a42500aba282380a" recorded_c_source_sha256: "070f1bf697ccd9dd51ee0ba55ff549f6f10201411553caf6c28637144c386118" compile: "gcc -O2 -frounding-math -ffp-contract=off tailmem5.c -lm -o tailmem5" command: "python3 h3/tailmem5.py X m L K T AT NEX cs ct a b hB hC D0 (recorded arguments in h3/jobs.yaml)" expected: "h3/short_trails_X_d.log (with 2>&1: the first line is written to standard error)" time: "about 3 minutes on one core with the recorded arguments; 13-20 seconds with m = 4, K = 7, T = AT = 25" memory: "3.1 GB with the recorded arguments (the quotient walk, lines D); 15 MB with m = 4, K = 7" bytes: 24582 sha256: "de7a41f3f41e17bfe718ec3099802a4dccc0861fda93ddcacda9a646dfac7262" - path: h3/bellman.py role: program (C source bellman.c stored verbatim) checks: >- Supersolution certificate for the closed trails longer than 20, for one type X and one first direction d0: prefix weights of length 20, the free vector Z with positive slack, a function U on the box of radius R = 70 proposed by sweeps (OpenMP atomic accesses), and a final single-threaded verification of the inequalities of the box lemma (Lemma l:box). It uses downward rounding for the slack subtraction and upward rounding for the rows, outer ratios, and final bound (rows 2-4 of Table tab:tail). A run is valid only if it reports 'violated rows = 0' and ends with PASS. The sweeps run in parallel, so the proposed U and the last digits of the bound may differ between runs; the verification itself is deterministic. c_source_sha256: "7f5d7287f0c4ed4a74a9a04a75221224676e53b79cbb26bd021a9dd4d5b8f198" recorded_c_source_sha256: "9f409cb3dbf7c01e1ec6dd0dfa1974f2aca87e5807a7fa44aa9ff146518ea84b" compile: "gcc -O2 -fopenmp -frounding-math -ffp-contract=off bellman.c -lm -o bellman" command: "python3 h3/bellman.py X D0 R SWEEPS [DEBUG] (recorded: X D0 70 600)" expected: "Same check protocol as h3/bellman_X_d.log. The full driver requires a passing bound at most the table entry and free-vector and prefix diagnostics matching the recorded run." time: "about ten minutes on four cores per case with R = 70; about 25 seconds with R = 23, SWEEPS = 0" memory: "about 1.3 GB with R = 70; 0.55 GB with R = 23" bytes: 23030 sha256: "5ed67318435ca538204ba8b5f3c2424d624bd5f1523450a1ea4af96091a0867b" - path: h3/exact75.py role: program (C source exact75.c stored verbatim) checks: >- Independent enumeration of the closed trails of length at most N, written from the definition of the weighted trail sums; the last column (optimal_h) is the quantity of the lines E of tailmem5. Check of the first row of Table tab:tail. c_source_sha256: "6a01e44d63085e4fdc0a6a8aea81376e9e9fa85f4b70069c71a83abe6052a94b" recorded_c_source_sha256: "e8e0adb431b308707fa5c409e4aa5f6e191387106da14d58efa234840a6c1fbe" compile: "gcc -O2 -frounding-math -ffp-contract=off exact75.c -lm -o exact75" command: "python3 h3/exact75.py X N cs ct a b hB hC D0 NOPT (recorded: X 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 d 20)" expected: "h3/exact75_X_d.log" time: "2 seconds per case" memory: "30 MB" bytes: 13443 sha256: "64301645691699bb780a28cc61f6b2e9864ef7a20cd9bac72203a342a854daa8" - path: h3/jobs.yaml role: data checks: "Command lines of the fifteen recorded runs (section 'recorded') and of the ten short runs of run_all_checks.py --quick (section 'quick'), with log files, time and memory." bytes: 8296 sha256: "3fc2ef75ae55f57f2078039411902b501dc1ce8ea8fedcdd08a1fd2c226de623" - path: h3/short_trails_B_1.log role: log checks: "Recorded output of python3 h3/tailmem5.py B 10 20 28 109 109 22 0.961 0.935 0.16666666666666667 0.36 1 1.25 1, standard error (first line) and standard output. The lines E and their sum, the line # EXACT, enter the first row of Table tab:tail; the lines D enter only checks (2) and (3) of Appendix C; the line # TAIL is not used." expected: "reproduced exactly by the same command (python3 run_all_checks.py --full); the lines E also by the quick run in jobs.yaml" bytes: 1671 sha256: "e9cd5fba943467c6c5c00b2a8de6e41be6066401e321216d6d32b0279b9667e1" - path: h3/short_trails_B_2.log role: log checks: "Recorded output of python3 h3/tailmem5.py B 10 20 28 109 109 22 0.961 0.935 0.16666666666666667 0.36 1 1.25 2, standard error (first line) and standard output. The lines E and their sum, the line # EXACT, enter the first row of Table tab:tail; the lines D enter only checks (2) and (3) of Appendix C; the line # TAIL is not used." expected: "reproduced exactly by the same command (python3 run_all_checks.py --full); the lines E also by the quick run in jobs.yaml" bytes: 1648 sha256: "bc4da9f255a6ab2a70ba94be058309d1142e19b97e7503a188774e6ca7725945" - path: h3/short_trails_C_1.log role: log checks: "Recorded output of python3 h3/tailmem5.py C 10 20 28 109 109 22 0.961 0.935 0.16666666666666667 0.36 1 1.25 1, standard error (first line) and standard output. The lines E and their sum, the line # EXACT, enter the first row of Table tab:tail; the lines D enter only checks (2) and (3) of Appendix C; the line # TAIL is not used." expected: "reproduced exactly by the same command (python3 run_all_checks.py --full); the lines E also by the quick run in jobs.yaml" bytes: 1694 sha256: "1f271b5bb7d9db0a85f9c6332d46d0ffcd4d7cfe55e0117bdd20150ff9384237" - path: h3/short_trails_C_2.log role: log checks: "Recorded output of python3 h3/tailmem5.py C 10 20 28 109 109 22 0.961 0.935 0.16666666666666667 0.36 1 1.25 2, standard error (first line) and standard output. The lines E and their sum, the line # EXACT, enter the first row of Table tab:tail; the lines D enter only checks (2) and (3) of Appendix C; the line # TAIL is not used." expected: "reproduced exactly by the same command (python3 run_all_checks.py --full); the lines E also by the quick run in jobs.yaml" bytes: 1671 sha256: "f83546ce36a8e72af9551da800c07d79e10707849f54d133d45cbbd0ad894404" - path: h3/short_trails_C_3.log role: log checks: "Recorded output of python3 h3/tailmem5.py C 10 20 28 109 109 22 0.961 0.935 0.16666666666666667 0.36 1 1.25 3, standard error (first line) and standard output. The lines E and their sum, the line # EXACT, enter the first row of Table tab:tail; the lines D enter only checks (2) and (3) of Appendix C; the line # TAIL is not used." expected: "reproduced exactly by the same command (python3 run_all_checks.py --full); the lines E also by the quick run in jobs.yaml" bytes: 1648 sha256: "533b1b05a6b7c5b8974c91203e376b2d67f89bdcf6c5320b69ef03585fd9241e" - path: h3/bellman_B_1.log role: log checks: "Recorded output of python3 h3/bellman.py B 1 70 600. It reports violated rows = 0 and ends with PASS; the bound in its last line is the entry of Table tab:tail for this case." expected: "a re-run must pass with a bound at most the table entry (the sweeps are parallel, so the last digits may differ)" bytes: 2240 sha256: "e246581f98d7b4ff42f34a4dbafbb63fd10f810573c7a7a30e66c40c43aaff0b" - path: h3/bellman_B_2.log role: log checks: "Recorded output of python3 h3/bellman.py B 2 70 600. It reports violated rows = 0 and ends with PASS; the bound in its last line is the entry of Table tab:tail for this case." expected: "a re-run must pass with a bound at most the table entry (the sweeps are parallel, so the last digits may differ)" bytes: 2200 sha256: "7330ac916eab9621c353dddf573ba2a4dd7ee4b03e80bcca7de0231471f58285" - path: h3/bellman_C_1.log role: log checks: "Recorded output of python3 h3/bellman.py C 1 70 600. It reports violated rows = 0 and ends with PASS; the bound in its last line is the entry of Table tab:tail for this case." expected: "a re-run must pass with a bound at most the table entry (the sweeps are parallel, so the last digits may differ)" bytes: 2200 sha256: "7605893039803a47e3ac5fea9e8ca812521add87b39028eebbb8c338523dfd5e" - path: h3/bellman_C_2.log role: log checks: "Recorded output of python3 h3/bellman.py C 2 70 600. It reports violated rows = 0 and ends with PASS; the bound in its last line is the entry of Table tab:tail for this case." expected: "a re-run must pass with a bound at most the table entry (the sweeps are parallel, so the last digits may differ)" bytes: 2200 sha256: "0a02d94514db6643f5382cf3e16550ae8f5d37616a1779a2d631228477473443" - path: h3/bellman_C_3.log role: log checks: "Recorded output of python3 h3/bellman.py C 3 70 600. It reports violated rows = 0 and ends with PASS; the bound in its last line is the entry of Table tab:tail for this case." expected: "a re-run must pass with a bound at most the table entry (the sweeps are parallel, so the last digits may differ)" bytes: 2200 sha256: "5186aeaf3bd83aa67c0486c89c36c05ffa51a21eab0e70607f39f8a8237332ce" - path: h3/exact75_B_1.log role: log checks: "Recorded output of python3 h3/exact75.py B 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 1 20; the last column agrees with the lines E of short_trails_B_1.log to a relative error below 1e-12." expected: "reproduced exactly by the same command" bytes: 1201 sha256: "c58d9962bb941f41f64b4001f3f75efc5226bb4381f6a7daf777e1f578967086" - path: h3/exact75_B_2.log role: log checks: "Recorded output of python3 h3/exact75.py B 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 2 20; the last column agrees with the lines E of short_trails_B_2.log to a relative error below 1e-12." expected: "reproduced exactly by the same command" bytes: 1087 sha256: "99b1eafa1f2310305020f741757f73e7d03152c34fbe5266e746640f9e0dc8c3" - path: h3/exact75_C_1.log role: log checks: "Recorded output of python3 h3/exact75.py C 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 1 20; the last column agrees with the lines E of short_trails_C_1.log to a relative error below 1e-12." expected: "reproduced exactly by the same command" bytes: 1314 sha256: "27b12f8c91be9e5461b9f219616770eb5bc931ec6e8ec226317bc58ce73fa45a" - path: h3/exact75_C_2.log role: log checks: "Recorded output of python3 h3/exact75.py C 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 2 20; the last column agrees with the lines E of short_trails_C_2.log to a relative error below 1e-12." expected: "reproduced exactly by the same command" bytes: 1201 sha256: "5f82f80223f809879e6b37759758a3a8a83e4d774315afa2c333e1849e00404a" - path: h3/exact75_C_3.log role: log checks: "Recorded output of python3 h3/exact75.py C 20 0.961 0.935 0.16666666666666667 0.36 1 1.25 3 20; the last column agrees with the lines E of short_trails_C_3.log to a relative error below 1e-12." expected: "reproduced exactly by the same command" bytes: 1087 sha256: "bd8f630e67c810aab5c1d138ed98ea72b8bd00c8ad2a4b12c59651d588c8eb01" changes: description: >- Adaptations made when the programs were copied into anc/, and revisions to the embedded C sources. The recorded output files are byte-identical copies of the historical logs. h1/ring.py: "The absolute path of the pattern file (constant P63) is replaced by the path of patterns.json in the directory of the script; the second, redundant 'import os' is removed." h1/cert.py: "Removed the absolute sys.path insertion and corrected the description of the integer contractions and separate magnitude checks." h1/closed_exact.py: "The line sys.path.insert(0, ) is removed." h1/run_prod.py: "The line sys.path.insert(0, ) is removed." h1/verify_all.py: "The line sys.path.insert(0, ) is removed; the certificate file argument is optional (default: certificates.jsonl in the directory of the script); the script exits with an error message under python -O (its overflow guards are assert statements); usage line updated; 'import os' added." h1/enumerate_patterns.py: "Copy of the independent enumerator of the audit of (H1), renamed. The absolute path of the list it compares with (a file equal record by record, in the fields out, kinds and present, to patterns.json) is replaced by patterns.json in the directory of the script, or the file given as first argument." h1/check_certificate_file.py: "New file (checks of the certificate file that verify_all.py does not make)." h2/h2_check.py: "The default vector file moved beside the script. Added --vector PATH for reading and for writing with --make, and a guard against running with assertions disabled." h3/tailmem5.py, h3/bellman.py, h3/exact75.py: >- The original wrappers stored the recorded C sources verbatim and added file handling, compilation and argument passing. In the revision all three C programs check for failure of fesetround. Bellman also uses atomic accesses to the shared U during OpenMP sweeps and rejects DEBUG before allocation when the box radius is below 23. The final Bellman verification remains single-threaded. The programs were not rerun after these revisions. The wrappers check the current embedded-source hashes listed as c_source_sha256. The historical C source hashes are recorded_c_source_sha256. run_all_checks.py: "The release driver validates the arguments before setup, rejects an empty check list, and identifies the quotient-walk comparison as empirical." documentation: "Script comments refer to the manuscript. The label of the covered model in the output of closed_exact.py and the expected label in the driver were shortened." h3/jobs.yaml, manifest.yaml: "Added in the original release." renamed_files: "patterns.json (was pext7962.json), certificates.jsonl (was certificates_covered_operator_only.jsonl), short_trails_X_d.log (was rA_X_d.txt), bellman_X_d.log (was bellman_X_d.txt), exact75_X_d.log (was eXd_20_new.txt), h2_output.log (was h2_output.txt), verify_all_output.log (the line for this certificate file in the original verification record)." tested: scope: "Historical test results, from before the C source and checker revisions listed above." date: "2026-11-17" machine: "Linux x86-64, 4 cores, 15 GB, Python 3.13.18, numpy 2.5.3, gcc 13.3.0" results: - "run_all_checks.py --quick: 22 checks, all PASS, 315 s on one core, at most 0.55 GB (the per-check results below)" - "h2/h2_check.py: output identical to h2/h2_output.log (under 1 s)" - "h1/check_certificate_file.py: CERTIFICATE FILE CHECK PASS (0.3 s). Negative tests on modified copies: a duplicated and a missing pid, a swapped threshold, model 'refined', TIPRAD=37/65 and python -O are each reported as FAILED" - "h1/verify_all.py: slices 0 200 and 7 200 (40 certificates each, 1 s) and 0 100 (80 certificates, 25 s): all verified, none failed; under python -O it refuses to run. Not re-run on all 7,962 certificates for this release (recorded run: h1/verify_all_output.log, 1,354 s)" - "h1/closed_exact.py: 4,735 of 4,735 decoupled patterns certified by the closed form, 2 s" - "h1/enumerate_patterns.py: the three expected lines, 82 s" - "Original h3 wrappers: --print-source and --write-source gave files byte-identical to the original C sources (recorded_c_source_sha256 above); all three compiled with the flags above (gcc 13.3.0, no messages); a one-character change in a stored source was rejected" - "h3/exact75.py, the five recorded jobs: outputs byte-identical to h3/exact75_X_d.log, 1-2 s each" - "h3/tailmem5.py, the recorded job B ... 2 (short_trails_B_2): standard error and standard output byte-identical to the log, 184 s, 2.9 GB resident. The other four full jobs were not re-run" - "h3/tailmem5.py with m = 4, K = 7, T = AT = 25 (jobs.yaml, quick), five cases: lines E and # EXACT identical to the logs, 13-20 s each; largest relative deviation from the last column of exact75: 8.3e-13 (C, d = 2)" - "h3/bellman.py with R = 23, SWEEPS = 0, DEBUG = 1 (jobs.yaml, quick), five cases, 17-25 s and 0.55 GB each: lines '# free vector' and '# prefixes' identical to the recorded logs, violated rows = 0, PASS; bound for n = 22 against the line D 22 of short_trails: relative difference 1.7e-6 to 2.5e-6. With R = 22 and DEBUG = 1 the program writes outside its arrays and aborts: DEBUG needs R >= 23 (no effect on the recorded runs, which have R = 70 and DEBUG off). The five runs with R = 70 were not repeated" - "Table tab:tail recomputed from the logs by exact rational arithmetic: all twelve entries equal to the table; the sums of the lines D (22 <= n <= 108) are 0.948 to 0.951 times the table entries" - "Driver negative test on a modified copy of anc (h2_output.log, exact75_C_3.log and bellman_C_2.log changed): exactly the three corresponding checks FAIL" - "Code paths of --full exercised on a modified copy of anc (certificate file cut to 40 lines, small recorded jobs): the parallel verify_all.py parts are summed, a tailmem5 job is compared with its log (equal), a bellman job is compared with the table entry (rejected, as it must be for a run without sweeps). The full mode itself (about 25 CPU-minutes for (H1), about 70 minutes for (H3)) was not run" - "Historical run_all_checks.py --quick --only h3: 17 checks, all PASS, 214 s" - "h3/jobs.yaml: the parser of run_all_checks.py gives the same structure as PyYAML"