# Experiments behind section 8 These files record the experiments behind section 8 ("Limits of the construction"). Most are floating-point diagnostics; the whole-shape "none" cases additionally use rigorous all-shape dual bounds, and two whole-shape "yes" cases have exact computer-assisted certificates (`outputs_grid_certificates.log`). None is part of Theorem A's certificate record or of `thmB/` (the rest of this supplement). Nothing in Theorems A or B depends on them. The bundle also carries the exact checks of two lines of the separately written program `sep_p5/p5rig.py`, which belong to that program's consistency run, not to section 8 (see "The window masks of `sep_p5/p5rig.py`" below). ## Layout and how to unpack - `sources.md`: every script and recipe that produced the outputs, verbatim except as stated for each file, with two SHA-256 values per file: "as run" (the file that produced the outputs) and "as shipped" (the text in `sources.md`). - `outputs_*.log`: the outputs, grouped by the statement they support; each section is one output file, headed by its name, its original SHA-256 and its shipped SHA-256. - `p8_candidate_constants.json`: the constants of the floating-point design at (eta, alpha') = (1/36, 17/60), the input of the engine diagnostics (see "The next-case candidate" below), as a plain-text export of the design's pickle (the same tagged encoding as `../inputs/*.json`; `../compare.py`'s `rebuild` function rebuilds the object). - `K36_s3_solution.json` (inside `outputs_free_problem.log`; `unpack.py` writes it to OUTDIR/outputs/): the zero of the K = 36 lever family that resolves the three largest small parts, as a plain-text export of the `.npz` that its run saved (arrays as dtype, shape and flat data, floats as `float.hex`); `numpy.savez` with the same keys rebuilds an equivalent file for `verify_fake_v2.py`. - `K72_fake_start.json`: the floating-point zero of the K = 72 family that resolves the three largest small parts (the solution saved by the run in `rk_K72_thT26_cap4_ct+s3.out`), as a plain-text export of its `.npz`; it is the input of `verify_K72_26_s3.out` and the starting point of the K = 72 certificate. - `K72_basis_hint.json` (inside `outputs_grid_certificates.log`; `unpack.py` writes it to OUTDIR/outputs/): the basis hint used for the K = 72 certificate (an untrusted column selection made by an earlier version of `rigfam.py`, which the shipped version cannot regenerate), as a plain-text export of the `.npy` (`numpy.save` of the array rebuilds it). - `example_F_n72_a25.json`, `example_G_n72_a25.json`, `example_M_n72_a25.json`: one small primal/dual example per family, shipped inside `outputs_families.log` (`unpack.py` restores them byte for byte to OUTDIR/outputs/; see "Primal/dual examples" below); `check_example.py` checks each of them. - `unpack.py`: `python3 unpack.py [OUTDIR]` writes the scripts and recipes to OUTDIR and the outputs to OUTDIR/outputs, checks every file against its shipped SHA-256, and copies `../engine2/dpl.py`, which `cert2_f3*.py` import. 141 of the 149 outputs are recovered byte for byte (their original and shipped hashes are equal); 8 carry the declared substitutions listed below. - Run extracted scripts from OUTDIR: `wall_check.py` reads its companion `cont_hm.py` by a working-directory-relative name. `unpack.py` does not reconstruct the design's pickle, decode the control pickle, recreate the machine's directory tree or install the guard scripts. Rebuild `p8_candidate_constants.json['value']` with `../compare.py`'s `rebuild` function and pickle it as `c_lp_sol_e36a1760_w2_r050_b010_N1800.pkl`; this preserves values and types, and need not reproduce the original pickle bytes or hash. Decode `../inputs/kw23m_e30a415_reg1030glo93.pkl.b64.txt` to obtain the control pickle. `analyse_diag2.py` needs a levels pickle regenerated by `cert2_f3_diag2.py`. `verify_fake_v2.py` needs a solution `.npz` regenerated by `famrk.py` (for K = 36 it can instead be rebuilt from `K36_s3_solution.json`, and for K = 72 from `K72_fake_start.json`). All Python companion sources for these operations are in the supplement. ## What the shipped files differ in - **Scripts.** Docstrings and comments are rewritten without names or internal references. Where listed in `sources.md`, a machine-specific path is replaced by a relative one (the path of `cont_hm.py` read by `wall_check.py`, the directory of the raw logs read by `rec6_table.py`, the import paths of `agg_lp5.py`, `agg_lp7.py`, `famrk.py`, `verify_fake_v2.py` and the `cert2_f3*.py` engines, and the engines' output files). Parsed with docstrings dropped, each shipped script is identical to the script as run with those path changes applied. `wall_check.py` reads its companion file from the working directory. - **Recipes.** The shell recipes (`run_rec*.sh`, `run_gsweep.sh`, `run_sec8_F.sh`, `run_diag*.sh`, `run_p7ctl.sh`, `lane_rerun.sh`) are records of the commands run, with new comment headers and machine paths replaced by `.`, `python3` and the helper names shown. They depend on the unshipped helpers `cpulimit.sh` (a CPU-time limiter) or `guard_run.sh` (a memory and time guard) of the machine that ran them, and are not portable launchers. `run_gsweep.sh` also reads `cont_hms_rec6x.py` from a `gsweep` directory, which `unpack.py` does not create. `lane_rerun.sh` also assumes a `twist/rk/rerun` directory tree and an alias `famrk_v3_0a34eca9.py`, neither created by `unpack.py`. That alias was a byte copy of the as-run source; the shipped `famrk.py` has rewritten comments and docstrings and its own recorded hash. For reproduction, invoke the shipped scripts directly, as in the commands given below, with local foreground resource controls. - **Outputs** are verbatim, except for the declared substitutions stated in each section's header line: names removed from four of them (two hand-kept run notes, `diag_runs.txt` and `p8_pricing_runs.txt`; a recipe's summary line, `sec8_F.out`; and the title line of `K72_indep_README.md`), and machine directory paths removed in four (`verify_K72_26_s3.out`, `lane_rerun.sha256` and `verify_K36_13_s3_audit.log`, which record the SHA-256 of the files they name, those values unchanged; and the two input paths of `v4_capture_K36.log`). - **Not shipped:** the solution pickles and floating-point vectors of the linear programs (including the solution and dual vectors that each run of record saved beside its log, except one primal/dual example per family, shipped inside `outputs_families.log`; the fake solutions of the discretised whole problem and of the lever families; the two lever-family zeros that `verify_fake_v2.py` checks are shipped as `K36_s3_solution.json` and `K72_fake_start.json`), the dual vectors behind the whole-shape "none" certificates, the data of the exact grid certificates (see below), and the per-level dumps of the diagnostic runs (their analyses, `G_analyse_*.log`, are shipped). The earlier sampled, relaxed and invalid-bin family experiments are superseded by the runs of record. Their complete earlier record is not shipped, but `sec8_F.out` in `outputs_lemma_check.log` retains a historical summary, including invalid-bin and sampled runs. Only its separately identified wall checks support the rewritten section 8; its old sweep and family values are not current results. Apart from the one-line summaries F2–F4 in `sec8_F.out` (runs of `cont_hm_copy.py`, `cont_hm.py` and `cont_hmg.py`, kept as history only; their raw outputs are not shipped), every family record made before `cont_hms_rec6.py` (with lowered constant bounds, an earlier kernel at a = 1/2, or H fixed on the interval of Lemma 8.1) is superseded and not shipped. This supplement supplies sources, logs and regeneration inputs, but not a direct replay archive of the four positive dual certificates or of the two exact-zero numerical proof-data bundles. Regeneration may produce different floating data; acceptance by the independent checkers is the criterion for the exact-zero claims. ## Numerical conventions **The family programmes.** The runs of record of the three families of section 8 are made by `cont_hms_rec6.py` (recipes `run_rec6.sh` and `run_records_fix6.sh`) on grids of step 1/N, with the grid conventions listed under "Conventions of the family programmes" below. Each programme minimises f(1) over the class constants and the added functions, subject to the quadrature approximations to the twisted rows and to f >= -1 at every generated point of the grid, free and extended, except the prime and the extended point E (a rough 1/2 plus a large 1/2) (ASUB = SSUB = MSUB = 1); there is no upper positivity condition. The constants lie in [-1, U] and the added functions are bounded by C in absolute value; the recipes give U and C for each run. Coefficients of absolute value below 1e-9 are deleted from the row matrices and the objective (CONT_TINY); on the resulting matrices the rows of Lemma 8.1 are imposed with absolute residual at most 1e-9 (scaled by 1024 for the solver) and the other twisted rows as equalities. Each solve uses HiGHS's interior point method without crossover, first without presolve and, if that solve is not accepted, with presolve. A solve is accepted when HiGHS reports Optimal, the equality residuals on the modified matrices are at most 1e-7, the rows of Lemma 8.1 hold within 1e-9 + 1e-10, and the positivity and box violations are at most 1e-7. Each summary line (`REC: ...`) gives the status, the objective on the matrices after and before the deletion, the residuals and positivity violations on both, the acceptance flag, and binary64 weak-duality lower bounds with net multipliers for the rows of Lemma 8.1 on both (the bound on the matrices before the deletion is the one for the stated programme); these bounds are floating-point quantities, not certificates. The older labels that the raw logs still print (`PRIME-FREE after rescaling`, `NOT prime-free, C- >= ...`) are strict floating comparisons of the objective with -1, not feasibility tests or certified bounds. In `recR6_Fdrop72.out` the rows of Lemma 8.1 instead have tolerance 1e9 and are inactive diagnostics; their residuals, about 6.5 and 10.1, are not included in the retained-row tolerance claims. `rec6_table.py` reads the raw logs, keeps the accepted solve of each point, requires the gate's PASS line, and writes `rec6_table.json`. The original 31 family records and the four quoted sweep points are checked by `check_sec8_values.py`. It reads their raw logs and checks Optimal status and the gate; on the matrices after coefficient deletion, equality, positivity and box errors at most 1e-7 and the retained rows of Lemma 8.1 within 1e-9 + 1e-10 (the Fdrop comparison instead uses its stated inactive tolerance 1e9); on the matrices before deletion, residuals and positivity errors at most 5e-6 (the rows of Lemma 8.1 are exempt in the explicitly stated Fdrop comparison); FREEMIN_CLOSED >= -1 - 1e-9; and a finite raw dual estimate. Its stored log records all 35 values passing and both excluded sweep controls refused. Its fixed list does not include the additional E-fixed diagnostics in Table 3 and its caption. The same `check()` function verifies all ten shipped E-fixed raw logs; all ten pass. After unpacking, run these commands from OUTDIR to check both sets. These are floating-point acceptance checks, not certificates: ```sh python3 -B check_sec8_values.py outputs python3 -B - <<'PY' from pathlib import Path from check_sec8_values import check files = sorted(Path('outputs').glob('*_efix0_p0.raw')) assert len(files) == 10 good = True for file in files: stem = file.name.removesuffix('_p0.raw') line, ok = check(['outputs'], stem, stem) print(line) good = good and ok raise SystemExit(0 if good else 1) PY ``` `e_report.py` reads the solution vectors that the runs saved beside their raw logs (`.rec.npz`, not shipped), so it reruns only after they are regenerated with CONT_SAVEX set. `compare_gexact.py` takes the directories of the `cont_hms_rec6.py` and `cont_hms_rec6g.py` raw logs; after unpacking both are OUTDIR/outputs: `python3 -B compare_gexact.py OUTDIR/outputs OUTDIR/outputs` (its log is `compare_gexact.out`). `gsweep.out` (recipe `run_gsweep.sh`) records the one-rough family at 25/72 for U = C from 50 to 20000 and the forced family with bins of one grid step at U = 10^4; it also records three diagnostic solves at U = C = 1000 (tags `keepE` and `fixvac`), made by `cont_hms_rec6x.py`, a diagnostic copy of `cont_hms_rec6.py` that restores one earlier default at a time (CONT_KEEP_E, CONT_FIX_VAC), shipped with their raw logs; the keepE solves were not accepted (a solve error without presolve, status Unknown with it), so the figure with the positivity row at E quoted below is indicative only. Section 8 quotes the sweep only at the points whose accepted solve passes the same checks as the runs of record: U = C = 50, 200, 1000 and 5000, where the values agree to 4e-6. Two accepted solves do not pass. G at U = C = 20000 has raw residuals of 3.3e-6 on the other twisted rows and 8.5e-6 on the rows of Lemma 8.1, and a raw floating dual estimate of approximately -1.961162. The forced family with bins of one grid step at U = 10^4 has 8.3e-6 on the rows of Lemma 8.1. Both residuals come from deleting coefficients below 1e-9 at large boxes, and neither value is quoted (`check_sec8_values.py` refuses both). At U = C = 5000 the accepted solve, retried with presolve, has a raw dual bound of -0.80, weaker than its value. **Primal/dual examples.** `example_F_n72_a25.json`, `example_G_n72_a25.json` and `example_M_n72_a25.json` each hold the primal vector x, the HiGHS row duals y and the column bounds lb, ub of one accepted run of record at N = 72, eta = 1/36, alpha = 25/72 and U = 4, with presolve off: the forced family F (`recR6_F72.out`), G (`recR6_G72.out`) and the family whose data also see the largest small component, M (`recR6_M72.out`), all made by `cont_hms_rec6.py`. The field `how` names the script (with its as-run hash, see `sources.md`), its arguments and the output, and `common` the environment. To use an example, rerun the named script with the environment in `common` and the arguments in `how`. This rebuilds the matrices, which the script keeps as module-level variables (for instance after `python -i`): `A_`, the equality rows (the twisted rows, followed by the tie rows where CONT_TIEM is set) stacked over the <= rows; `bub`, the right-hand sides of the <= rows (the equality rows have right-hand side 0); `f1`, the objective q; and `lb`, `ub`. Coefficients below 1e-9 are deleted, and the dead rows enter multiplied by 1024 (CONT_DEADSCALE), so their duals refer to the scaled rows; the script stores the positivity rows, as -(row).x <= 1, and both dead copies as <= rows, so their duals are <= 0. On those matrices, x satisfies the equality rows to 1e-7, the rows of Lemma 8.1 to 1e-9 + 1e-10, every positivity row at >= -1 - 1e-7, and the box lb <= x <= ub to 1e-7; q.x reproduces the printed pruned objective (the raw objective, on the matrices before the coefficient deletion, is printed beside it). For y, clip the positivity-row duals to <= 0 and combine each dead-row pair into one net multiplier lambda = y(+ copy) - y(- copy), placing min(lambda, 0) and min(-lambda, 0) on the two copies. With d = q - A^T y and t_j = min(d_j lb_j, d_j ub_j), the sum S = b.y + sum_j t_j then exceeds the printed pruned float dual lower bound by the script's allowance 1e-13 (sum_i |b_i y_i| + sum_j |t_j|), a heuristic allowance for floating-point rounding, not a rigorous error bound; the examples are floating-point solver output, not certificates. The shipped script `check_example.py` carries out this check: after `python unpack.py OUTDIR`, run `python OUTDIR/check_example.py OUTDIR/outputs/example_F_n72_a25.json OUTDIR` (likewise for G and M). It reruns the named program, checks the example as above against the original run's printed line, and then runs two negative controls (x, and then y, with one entry changed by 1e-3), each of which must fail; the exit status is 0 only when the example passes and both controls fail. Its logs for the three examples, `check_example_F.log`, `check_example_G.log` and `check_example_M.log` in `outputs_families.log`, record a run on 13 Nov 2026 from the unpacked bundle: each example passed, each control failed, and each rerun printed the same `REC:` line as the original run (26-37 s of CPU time per example in the program itself, plus its gate re-check, one thread). Kernels use half-weight endpoint bands, with convolutions computed by scipy's fftconvolve (floating point); support comparisons have a 1e-12 allowance. The untwisted (Type I) rows are not imposed as additional equalities; `cont_hms_rec6.py` checks them as a gate before each solve (see the conventions below). The family LP assembly uses binary64. The floating-point check of Lemma 8.1 (`wall_check.py`) evaluates the matrices of an earlier discretisation of the forced family (`cont_hm.py`) on grids of step 1/360 and 1/720. **The whole-shape programme.** B(u) = 1/(product of the integer parts times the factorial of each multiplicity), c(u, v) is the product of the multiset binomial coefficients, and psi(u) = B(u) phi(u), where phi(u) = x(u) - 1. For every v through total K/2 the Type I row is sum_u c(u, v) psi(u) = 0; through total alpha K the twisted row inserts (-1)^len(u). Both levels are inclusive and include v = (). Composite x values lie in [0, 4] (caps 4; the one run with cap 100 is listed in the table below); the prime has no upper cap, which is redundant for this minimisation because the baseline is feasible. Column generation fixes inactive phi to zero and normally excludes B < 1e-11 from active columns; it adds 4000 columns per round, overridden to 30000 in the K = 72 logs. The all-shape dual calculation includes every excluded column. Positive restricted primal values are not certificates. Accepted floating zeros require the documented objective, residual and bound checks; their residuals quoted in the paper are absolute, unscaled residuals. The certified lower bounds of the four "none" cases (caps 4 and the Type I level closed at 1/2, as above) are printed rounded to the nearest ninth decimal (`CERT: certified C- >= ...`), so a printed decimal can exceed the certified binary64 bound by up to 5e-10; rounded downward, the certified bounds are at least 0.019978598 (K = 30, 11/30), 0.054153430 (K = 36, 14/36), 0.106956667 (K = 60, 22/60) and 0.000977835 (K = 72, 27/72). Their dual vectors are not included in this supplement; `twist_otf.py` regenerates such vectors, and its all-shape evaluation accepts any dual vector, since weak duality does not require optimality. **The next-case candidate.** `p8_candidate_constants.json` holds the constants of a floating-point design on a grid of step 1/1800, shipped only as the input of the engine diagnostics; the design's code and evaluation logs are not shipped: the code failed a representation-invariance test, and a repaired run gives a margin between 0.03 and 0.05 at the two resolutions (floating point, one design code, not independently recomputed). Width runs use NB = 80, plus NB = 160 at M = 1800; the comparison M = 3600/5400 uses NB = 80. All diagnostic and pricing logs stop before a completed certification. The corrected evaluation uses FIX_K1=1 as well as the two half-point kernel repairs. The default branch of the private diagnostic file without that switch still fails representation invariance. The residual of about 8.5e-5 in the mixed k=2,3 coefficient-shift test comes from a closure vector on which that shift changes the free value; it is not a free-null direction. ## Conventions of the family programmes Section 8 of the paper prints the free data of the three families: f(u) = c[j,k,b] + 1[tau <= alpha'] H_j(tau, m) + 1[k = 1] G_j(tau, m) Here m is the largest small component, written \mathfrak m in the paper. The forced family is the case where H_j does not depend on m and G = 0. The one-rough family is the case where neither H nor G depends on m. The paper's definitions (sections 2 and 3 and the appendix on the kernels) are continuum definitions, so they leave the following grid conventions open. The programmes fix them as below. Every entry of f1, the twisted rows and the positivity rows of the four family programmes shipped here (M at alpha' = 24/72 and 25/72, F and G at 25/72; N = 72, eta = 1/36, the stated bins and boxes; matrices taken before the deletion of coefficients below 10^-9) was recomputed, to 2.1·10^-14 or better, by two separately written evaluators from the paper's definitions and the conventions below (their kernel code was first written for the predecessor programme, whose matrices fixed its boundary weights); their variables, bounds, row labels and positivity points, generated from those conventions, coincide with the shipped ones (for F, counting its 3,047 rows c(j,1,b) + G ≥ −1 on G fixed at 0, which repeat the constant bound), the tie rows of F and G were checked as constraint sets, and a third, exact-rational enumeration confirmed that every grid point whose value involves an added function has a positivity row (except E = (1/2, 1/2), by design) and reproduced the H coefficients of every extended-point row to 2·10^-16. Nothing was solved, so no objective value, residual or weak-duality bound has been recomputed; nor have the matrices after deletion, the untwisted gate, F and G at 24/72, any other α', N, η, bins, boxes or family, or the lattice programmes. 1. **Grid and quadrature.** - Values are tabulated at the points i/N. - Every integral over a closed range is a composite trapezoid sum: weight h at interior points and h/2 at the two end points. - This applies to the small range [eta, alpha'], each rough bin, and the range [1/2, 1] of a large component. - Convolution powers are taken with the multiset weight: N prod(rho_i / n_i) / prod(multiplicity!). This is the trapezoid value of s^{*j}/j! and r^{*k}/k!. - The multiplicity counts identical labelled items: a component exactly alpha' read as small and one read as rough are different items, as are a bin-edge component read in bin 1 and one read in bin 2. For example, (alpha' rough, alpha' rough) carries 1/2! and (alpha' small, alpha' rough) carries 1. 2. **Closure points.** A component on a boundary is counted on both sides, half on each: - a component exactly alpha' is half small and half rough (bin 1); - a component exactly at a bin edge is half in each bin; - a component exactly 1/2 is half rough (top bin) and half large; - eta is an end node with weight h/2. - Each reading is a separate labelled vector, weighted by the product of the half-weights of its boundary components. Its class is (j, k, b), with b the largest bin label among that reading's own rough components. The base of an extended point (item 8) is read the same way, and each reading of the base gives its own extended point. 3. **Lemma 2.1 on the grid.** - A proper sub-collection with sum exactly 1/2 counts with weight 1/2. - The full fragment set at a = 1/2 counts with weight 1, the closed indicator. This holds for the class constants and the added functions alike, so each programme depends on the data only through the values of f at the grid points. - The boundary term N_{1/2} of Lemma 2.1 is dropped: it vanishes on the continuum, and the appendix on the kernels notes that it integrates to zero. 4. **The node a = 1/2.** - In the twisted rows it is the end node of the a-range, weight 1/2. - The term with no free remainder (a = 1 - sigma) has weight 1. - The positivity rows at extended points take point values at a = 1/2. 5. **The rows.** - Twisted rows are imposed for every label (j_D, sigma, m_D): the count, total and largest component of the tuple s, with sigma a grid point and sigma <= alpha'. For this family a row depends on its tuple only through this label. - The tuple's components are always read as small. - The rows of Lemma 8.1 (sigma in [1 - 2 alpha', alpha']) are held to |T x| <= 1e-9. The others are equalities. - 'Held to |T x| <= 1e-9' is how the solver imposes these rows; in the matrices they are rows like the others. At sigma = 1 - 2 alpha' each such row contains the H of its own label, H(j_D, sigma, m_D), with coefficient (-1)^{j_D} 2 R_2(2 alpha') = (-1)^{j_D} N (1/(2 alpha' N))^2 (+-0.03125 at 24/72, +-0.0288 at 25/72), through the closure node (alpha', alpha'). On the grid these rows are therefore not conditions on the constants alone. At 24/72 this holds for every row of Lemma 8.1. - H_0 is identically zero and has no column. - Each H or G entry of a row is obtained by substituting the free-data formula into (6.3), with the full-set and proper-subset weights of item 3, and then applying the product quadrature of items 1-4 in the twisted functional. - A row label is kept only when its small tuple is feasible (an exact integer test). 6. **The point E = (1/2, 1/2).** - In T_0 the completion (1/2, 1/2) enters through two readings: - as two rough components, with the constant c(0, 2, top bin), which no other vector carries; - as a rough component plus a large component, through (6.3) at node weight 1/2. - The reading as two large components is not used. - The positivity row at E read as a rough 1/2 plus a large 1/2 is dropped (the paper's target excludes E). E read as two rough components is, however, the only vector of class (0, 2, top bin). That class is empty in the continuum. Its constant appears in no row except T_0, where its coefficient is N (1/2 * 1/36)^2 / 2! = 1/144 at N = 72 (its coefficient in f(1) is 0 on the grid), and it is bounded only by the constant box [-1, U]: below by -1, the positivity bound every free node has. So that reading of E is bounded, and on the grid T_0 = 0 holds as -U/144 <= T_0' x <= 1/144, where T_0' is the parity row without this term: [-1/36, 1/144] for U = 4 and [-125/18, 1/144] for U = 1000. - Measured: at every optimum of record (35 quoted values and the two refused sweep solves; `e_report.py`, log `e_report.out`, from the saved solutions and row duals) that constant is at its lower bound -1, in all three families. So the bound at E is active and the parity row reads T_0' x = 1/(2N): 1/144 at N = 72, 1/180 at N = 90, 1/192 at N = 96 and 1/216 at N = 108 (the coefficient of that constant in T_0, printed by `cont_hms_rec6e.py`'s EINFO line, log `einfo.out`). Fixing the constant at 0, which makes T_0' x = 0, raises f(1) by 0.0029 to 0.0033 at the five N = 72 points listed here (G at 25/72 for U = C = 1000 and for U = 4, C = 50; F at 25/72, U = 4; M at 24/72 and 25/72, U = 4; `cont_hms_rec6e2.py` with CONT_ECAP=0 CONT_ELO=0, log `ediag.out`), as the row duals predict (about 0.003 at every optimum). Capping it at 4 instead changes nothing (G at 25/72, U = C = 1000: -0.410359). The values of record are stated with this bound, which is the positivity bound that every other free node has. - Earlier programmes also carried a positivity row at E, read as a rough 1/2 plus a large 1/2; dropping it moved the forced-family values by at most 4e-6 with two bins and by about 7e-4 with bins of one grid step (floating point; diagnostic runs of a predecessor script with the same kernels and with H fixed on the interval of Lemma 8.1, not shipped). The one-rough family depends on it more: at 25/72 with U = C = 1000 it gives -0.410 without the row and about -0.29 with it (that solve was not accepted, so the second figure is indicative only). Its value is stated without that row. 7. **Absent and fixed added functions.** - G_j(1/2, m) has no column: there a vector with one rough component 1/2 has the value c(j, 1, top bin) alone. - Nor does G at some feasible keys with many small components. The script admits a G column (j, tau) only when the floating-point convolution value S[j][tau] is positive; for 20 or more small components that value is of order 1e-28 and can round to a non-positive number. Each omitted key is the value of f at a free grid vector (for example G(20,40,2): twenty components 2/72 and one rough component 32/72), where f is then c(j,1,b) alone (bounded below by -1). This is a restriction of the reported finite programmes, not a statement that those free vectors are infeasible. The keys (j, tau, m), in grid indices, are printed by the diagnostic variant `cont_hms_rec6g.py` (its `GEXACT` line) and listed in `keys.out`: - N = 72, eta = 1/36: at alpha' = 24/72, (20,40,2),(21,42,2),(22,44,2),(22,45,3),(23,46,2),(23,47,3),(23,48,3),(23,48,4),(24,48,2); at 25/72, (20,40,2),(21,42,2),(21,43,3),(22,44,2),(22,45,3),(23,46,2),(23,47,3); this removes G_23 at both points and G_24 at 24/72, and the G-gauges j = 20-22 no longer hold; 5 keys at 26/72 and 4 at 27/72; - 63 and 54 keys at 31/90 and 32/90 (eta = 1/45), 100 at 34/96 (eta = 1/48); - none at 35/96, on the grids of step 1/108 (eta = 1/36 and 1/27), or at eta = 1/30. Every shipped run of the one-rough family and of the family that sees the largest small component on an affected grid carries this restriction; the forced family does not (its G is 0). - The restriction has been measured. `cont_hms_rec6g.py` differs from `cont_hms_rec6.py` only in deciding the support of a G column by exact integer feasibility (j components in [eta, alpha'] with total tau). Rerun on all 12 affected runs of record (`gexact_runs.out`, `gexact_runs2.out`; compared by `compare_gexact.py`, log `compare_gexact.out`), every value changes by at most 1.2e-06, and every rerun passes section 8's acceptance checks. The values of record are those of `cont_hms_rec6.py`. - Neither this restriction nor E (item 6) explains why the one-rough family moves from -0.272 at U = 4, C = 50 to -0.410 at U = C = 50. At U = 4 its optimum has 15 class constants at the upper bound 4, all of one-rough classes: c(j,1,b) for 4 <= j <= 10 in both bins, and c(3,1,2). The saved solution for U = C = 50 is an interior point of its optimal face (HiGHS's interior-point method, without crossover) and has 211 constants above 4, so it does not show which of them the move needs. - H_j(tau, m) on the interval of Lemma 8.1, [1 - 2 alpha', alpha'], is a free variable bounded by C, like H elsewhere. No free vector of the continuum carries it there. On the grid it enters only at tau = 1 - 2 alpha', through the closure nodes (small part of total 1 - 2 alpha' plus two rough components exactly alpha', class (j, 2, 1)), where positivity rows c(j,2,1) + H(j, 1 - 2 alpha', m) >= -1 are imposed. It also enters the extended points whose values reach those nodes (234 at 24/72, 179 at 25/72), which have their own rows, and the rows of Lemma 8.1 with that sigma (item 5). For tau in (1 - 2 alpha', alpha'] (tau = 23, 24 and 25/72 at alpha' = 25/72: 267 columns) it enters no value of f and so no row; the matrices carry rounding of at most 1.4e-16 there, which the 1e-9 deletion removes, so these columns are inert. - Earlier programmes fixed it at 0, a restriction. Freeing it lowered the forced-family values by at most 0.0022 (at alpha' = 1/3; floating point; diagnostic runs of the same predecessor script, not shipped) and the value of the family that sees the largest small component at 24/72, U = 4, by 3.0e-04 (`cont_hms_rec6x.py` with CONT_FIX_VAC=1, log `ediag.out`). The shipped `cont_hms_rec6x.py` restores either default singly (CONT_KEEP_E=1, CONT_FIX_VAC=1) and can repeat both comparisons at the forced family's settings of record (CONT_TIEM=1 CONT_NOGREC=1). - The absent G columns are a restriction of the one-rough family and of the family that sees the largest small component (not of the forced family, where every G is 0). Their values are quoted with that restriction. 8. **The positivity point set.** - Every reading (item 2) of a free grid vector whose value involves an H or G column, one row per (class, column): c(j,k,b) + H >= -1 or c(j,k,b) + G >= -1. F keeps the rows c(j,1,b) + G >= -1 although its G is fixed at 0; they repeat the constant bound (3,047 rows at 25/72), and F also ties its fixed G (2,592 tie rows), which is redundant. - Every extended grid point (a base vector with its small total and largest small component, plus one large component a = i/N >= 1/2), with the base read as in item 2, closure readings included. The only base with a component 1/2 is (1/2) itself, at a = 1/2: that point is E read as a rough 1/2 plus a large 1/2, which has no row (E read as two rough components is bounded through its constant; item 6). The prime vector (empty base, a = 1) gives f(1), not a positivity point. - Constants are bounded below by -1, so free nodes with no added variable also satisfy f >= -1. 9. **The untwisted rows as a gate.** - The untwisted functionals vanish identically on the continuum. With the weights above they are exact (<= 1e-13) for G; for the constants and H they carry an O(h) quadrature residual (at most 6.4 h and 1.5 h in the runs of record). - In the production (trapezoid) pass `cont_hms_rec6.py` requires the constant block <= 10 h, the H diagonal <= 2 h, and the G block divided by h <= 1e-9. It prints the integrated (off-diagonal) H block divided by h but sets no threshold on it in this pass. - It then reruns itself with CONT_HALFCLOSE=closed and CONT_GATEONLY=1: the rough component's upper end point 1/2 is removed and the large and proper-subset half-point cut-offs get full weight. There the constant block, the H diagonal, the integrated H block divided by h and the G block divided by h must each be <= 1e-9. - A failure in either pass stops the programme before solving. CONT_NOGATE bypasses the gate; it is not used for the runs of record. The closed pass is a diagnostic of the kernels: it imposes no untwisted equalities on the production programme, and passing the gate establishes neither the continuum Type I identity nor exact finite Type I rows under the trapezoid weights. - The evaluators of the re-run did not check this item (the untwisted rows are not in the dumps). 10. **The variables and the ties.** - Constants c(j,k,b) for 0 <= j <= 37 and k <= 4 (24/72) or 3 (25/72). Only 100 of 341 and 95 of 265 are carried by a grid vector; the others have coefficients at most 2.2e-15. - H(j, tau, m) for every signature of j >= 1 parts in [eta, alpha'] with tau <= alpha'. - G(j, tau, m) for 37/72 <= tau <= 1 - alpha' (one rough component in [alpha', 35/72], the closure at alpha' included), less the absences of item 7. - The tie rows of F and G join consecutive m within each (j, tau); F also ties its fixed G, which is redundant. ## What each statement of section 8 rests on | Statement of section 8 | Outputs (in `outputs_*.log`) | Code and recipe (in `sources.md`) | |---|---|---| | The candidate at (1/36, 17/60): a positive numerical margin between 0.03 and 0.05 on grids of step 1/1440 and 1/2160 (floating point, one design code, not independently recomputed) | not part of the supplement: the design's code and evaluation logs are not shipped (see "The next-case candidate"); its constants are `p8_candidate_constants.json` | — | | The first-order loss in the one-step couplings on the cells straddling the rough kernel's jump, scaling with the block width and not with M | `diag_dnb80_M1800.log`, `diag_dnb160_M1800.log`, `diag2_d2m3600_M3600.log`, `G_analyse_diag2_d2m3600_M3600.log`, `diag_runs.txt` | `cert2_f3_diag.py`, `cert2_f3_diag2.py`, `analyse_diag2.py`, `run_diag.sh`, `run_diag2.sh` | | The control at (1/30, 4/15): no comparable loss | `diag2_p7ctl_M3840.log`, `G_analyse_diag2_p7ctl_M3840.log` | `cert2_f3_diag2.py`, `analyse_diag2.py`, `run_p7ctl.sh`; input `../inputs/kw23m_e30a415_reg1030glo93` (the function of the case (1/30, 4/15)) | | The widths produced by the second-order engine compounding down the forcing chain, the width of h_1 at M = 3600, and the shrinkage between M = 3600 and 5400 | `dev_p8w2f3600_M3600.log`, `dev_p8w2s5400_M5400.log`, `p8_pricing_runs.txt` | `cert2_f3.py` (pricing runs, stopped by hand once measured) | | The floating-point check of Lemma 8.1 in an earlier discretisation (the forced functions' coefficients in its rows are binary64 rounding away from the endpoint) | `F1_wall_*.raw`, `sec8_F.out` (`outputs_lemma_check.log`) | `wall_check.py`, `cont_hm.py`, `run_sec8_F.sh` | | The forced family (profile w_k = 1) at eta = 1/36 on the grid of step 1/72: values at 23/72, 1/3, 25/72 and 13/36 with two bins for U = 4 and U = 1000, with bins of one grid step, and without the rows of Lemma 8.1 | `recR6_F72.out`, `recR6_Fbin72.out`, `recR6_Fdrop72.out` and their `.raw` files; `rec6_table.json`; `check_sec8_values.out` | `cont_hms_rec6.py`, `rec6_table.py`, `run_rec6.sh`, `run_records_fix6.sh`, `check_sec8_values.py` | | The one-rough family G at 25/72 for U = 4, C = 50 and for U = C = 50, 200, 1000 and 5000 (the sweep's runs at U = C = 20000, and of the forced family with bins of one grid step at U = 10^4, fail the residual checks and are not quoted) | `recR6_G72.out`, `gsweep.out` and their `.raw` files (`G25_UC*_p*.raw`, `Fbin25_U10000_p0.raw`); `rec6_table.json`; `check_sec8_values.out` | `cont_hms_rec6.py`, `rec6_table.py`, `run_rec6.sh`, `run_records_fix6.sh`, `run_gsweep.sh`; `cont_hms_rec6x.py` (the two diagnostics), `check_sec8_values.py` | | Free data that also see the largest small component (U = 4, C = 50; on the step-1/72 grid also U = C = 1000): the ten records of Table tab:richer; for eta <= 1/36, at the least level computed at or past 1/3 on each grid, values within 0.05 of -1 (below it with either treatment of E at 1/3 for N = 108 and at 31/90; within 0.003 of it, side not resolved, at 1/3 for N = 72 and at 17/48), and between -0.96 and -0.78 at the next grid point; at 1/3 for eta = 1/30 and 1/27 (no conclusion is drawn) | `recR6_M72.out`, `recR6_Mbig.out`, `ediag.out` and the `efix0` raw logs, with the other `.raw` files; `rec6_table.json`; `check_sec8_values.out` | `cont_hms_rec6.py`, `rec6_table.py`, `run_rec6.sh`, `run_records_fix6.sh`, `check_sec8_values.py`; `cont_hms_rec6e.py`, `cont_hms_rec6e2.py`, `run_ediag.sh` (the treatment of E) | | The discretised problem with fully free data (caps 4, and the Type I level closed at 1/2: rows for every v of total at most K/2): prime-free floating-point solutions past 1/3 on three of the four grids computed (13/36 at K = 36, 21/60 at K = 60, 26/72 at K = 72); on the fourth, K = 30, one at 1/3 and none at 11/30; on all four grids, certified lower bounds showing none at the next grid point | `tw_K*_*.out` (`outputs_free_problem.log`) | `twist_otf.py`, `modm_otf_lowmem2.py` | | With the Type I level just below 1/2 (thI = 17) at K = 36, caps 4: a prime-free solution at 14/36 and a certified none at 15/36 | `tw_K36_thI17_thT14_cap4.out`, `tw_K36_thI17_thT15_cap4.out` (`outputs_free_problem.log`) | `twist_otf.py` (THETA_RULE=below_half), `modm_otf_lowmem2.py` | | With values up to 100 times the baseline, at eta = 1/30 and K = 60: a prime-free solution at 22/60 | `tw_K60_m2_thI30_thT22_cap100.out` (`outputs_free_problem.log`) | `twist_otf.py`, `modm_otf_lowmem2.py` | | The lever families on the same grids | `agg5_K36_thT13_cap4.out`, `agg5_K72_thT26_cap4.out` | `agg_lp5.py`, `twist_otf.py`, `modm_otf_lowmem2.py` | | For K = 36, the family that resolves the three largest small parts: an accepted zero, and a check of that zero against every row of the free problem | `famrk_K36_thT13_cap4_ct+s2_ct+s3_audit.log`, `verify_K36_13_s3_audit.log` (`outputs_free_problem.log`); the zero in `K36_s3_solution.json` | `famrk.py 36 1 18 13 4 ct+s2 ct+s3` with ETA=1/36, ALPHA=13/36, THETA_RULE=half, VERIFY=1; then `verify_fake_v2.py famrk_K36_m01_thI18_thT13_cap4_ct+s3.npz 36 1 18 13 4 3` | | For K = 36 and K = 72 at eta = 1/36, alpha = 13/36: exact prime-free solutions of the whole-shape programme | `outputs_grid_certificates.log` (see the section on the exact grid zeros) | `rigfam.py`, `indep_export.py`, `v4_capture_K36.py`; checkers `v4_exact_grid.py`, `v4_independent_K36_bound.py`, `v4_independent_K72.py` | | For K = 72, the families that resolve the two and the three largest small parts (0.096, and zero to solver tolerance), and a check of that zero against every row of the free problem | `rk_K72_thT26_cap4_ct+s2.out`, `rk_K72_thT26_cap4_ct+s3.out`, `verify_K72_26_s3.out`, `lane_rerun.log`, `lane_rerun.sha256` (`outputs_free_problem.log`) | `famrk.py`, `verify_fake_v2.py`, `agg_lp7.py` (its `features()`), `twist_otf.py`, `modm_otf_lowmem2.py`, `lane_rerun.sh` | The older K = 36 `agg_lp5.py` output (`agg5_K36_thT13_cap4.out`) has a near-zero objective for the three largest small parts but fails its residual test (1.34e-9 > 1e-9). The accepted K = 36 zero comes from the `famrk.py` run in the table: row-equilibrated residual 8.82e-13, with separate all-row absolute residuals 6.11e-15 (Type I) and 2.44e-14 (twisted). An independent audit of this supplement ran both K = 36 commands with the shipped scripts, from an unpacked copy, under a single-thread resource harness whose environment and usage lines open and close the two logs. ## The exact grid zeros at K = 36 and K = 72 **What is certified.** For (K, m0, thI, thT) = (36, 1, 18, 13) and (72, 2, 36, 26), that is eta = 1/36, alpha = 13/36, Type I level 1/2 and cap 4, the whole-shape programme described above has a rational feasible point whose prime coordinate is exactly phi=-1, so its baseline weight x=1+phi is exactly zero and the least weight on the primes is zero. The point takes one value per class of the lever family that resolves the three largest small parts (classes by the number and total of the small parts, the number of rough parts, the largest rough part, the large part and the three largest small parts, with no restriction on the number of small parts), and is lifted to every shape by its class; every row of the whole-shape programme is a positive multiple of a row of that family (twisted rows up to sign). The certificate is a dyadic point on the 2^-60 grid, a basis, and an exactly computed residual; a verified solve encloses the exact correction. Three separately written checkers, which import none of the producing code, check it from the stored data: `v4_exact_grid.py` enumerates the shapes directly and checks every coefficient enclosure and every exact residual integer; `v4_independent_K36_bound.py` and `v4_independent_K72.py` bound the contraction ||I - C B|| and the correction with outward rounding and check every class against its bounds with exact fractions. An independent review did not establish `rigfam.py` as a sound general verifier, so the conclusion rests on these checkers, not on `rigfam.py`. Not covered: other caps, grids or levels, other programmes, and the continuum. These are computer-assisted proofs; the remaining trust is in Python integer and fraction arithmetic, the IEEE binary64 error model of NumPy and SciPy, and the machine. **The stored record** (`outputs_grid_certificates.log`): the runs that produced the two certificates (`rigv4_K36_13.out`, `rigv4_K72_26.out`), the K = 36 capture (`v4_capture_K36.log`), the K = 72 export (`indep_export_K72.out`, with the export's own description `K72_indep_README.md`, its claims `K72_indep_claims.json` and its hash list `K72_indep_READY.txt`), and the checks (`v4_exact_grid_K36.log`, `v4_independent_K36_bound.log`, `K36_independent_bounds.json`, `v4_independent_K72.log`, `K72_independent_bounds.json`). **Regenerating the data and rerunning the checks.** The data are not in this supplement: binary arrays (one of 1.87 GB) cannot be deposited with it. In OUTDIR (the directory `unpack.py` writes), with one thread per process: - K = 36. `python3 -B rigfam.py verify 36 1 18 13 4 3 full` (no hints; about 8 s of CPU time, 0.3 GB) writes `rigfam_cert_K36_m01_thI18_thT13_cap4_r3_full_.npz`, where `` is the first eight hex digits of the SHA-256 of the `rigfam.py` that ran; rename it `rigfam_cert_K36.npz`. Then `python3 -B v4_capture_K36.py` (seconds) writes `review_v4/K36_core_inputs.npz`, `review_v4/K36_C.npy` and `review_v4/K36_basis_hint.npy`, and `python3 -B v4_exact_grid.py` and `python3 -B v4_independent_K36_bound.py` (seconds each) run the checks; the second writes `review_v4/K36_independent_bounds.json`. - K = 72. Rebuild the starting point FAKE from `K72_fake_start.json` as `famrk_K72_m02_thI36_thT26_cap4_ct+s3.npz` (`numpy.savez` with its keys; it can also be recomputed by `ETA=1/36 ALPHA=26/72 THETA_RULE=half SAVE=1 AGG_TL=14000 python3 -B famrk.py 72 2 36 26 4 ct+s3`, about 20 minutes of CPU time and 3.8 GB, but that is a floating-point solve whose result may differ on another machine), and the basis hint by saving the array of OUTDIR/outputs/`K72_basis_hint.json` as `S_K72_26_s3_hint.npy`. With `FAKE=famrk_K72_m02_thI36_thT26_cap4_ct+s3.npz BASIS=S_K72_26_s3_hint.npy` in the environment, `python3 -B rigfam.py verify 72 2 36 26 4 3 full` (about 280 to 310 s of CPU time, 3.9 GB peak) writes the certificate; rename it `rigfam_cert_K72.npz`. With the same environment, `python3 -B indep_export.py K72_indep` (about 540 to 620 s, 3.6 to 3.9 GB) writes the export, including the approximate inverse `C.npy` (1.87 GB on disk). Write the hash list with `cd K72_indep && sha256sum *.npy Rex_hex.txt claims.json > READY`, make sure `review_v4/` exists in OUTDIR (the K = 36 capture creates it; the K = 72 checker writes `review_v4/K72_independent_bounds.json` there), then run `python3 -B v4_independent_K72.py` from OUTDIR (about 41 s; peak resident memory about 4 GB; the original run used an address-space limit of 8 GB). - With the scripts as run, a rerun on the machine that made the originals reproduced both certificates and every array of the K = 72 export byte for byte, `C.npy` included; the export's `claims.json` differed only in the FAKE and BASIS path strings it records. **Data files of the original runs**, with their SHA-256 (the hashes of the K = 72 export are in `K72_indep_READY.txt`): | File | Bytes | SHA-256 | Made by | |---|---:|---|---| | `rigfam_cert_K36_m01_thI18_thT13_cap4_r3_full_1a212ad4.npz` | 474912 | 7efe044f74914a8e0884d3852e5447edb0c0a3876c158d29cdbdf923bb2e9e26 | `rigfam.py verify` (K = 36) | | `review_v4/K36_core_inputs.npz` | 2753406 | 23002b36ba80992280a469170d7a6317873d79841706eab57e4f7147e52b8e37 | `v4_capture_K36.py` | | `review_v4/K36_C.npy` | 28849736 | 3d1e2e192ec7558b745fa3d30064f7838f6d95cb91a7ffd7e7f7922f8cb61d48 | `v4_capture_K36.py` | | `review_v4/K36_basis_hint.npy` | 15320 | 369f9d9f654a6021014c1703dcce36bca1d7308f3ccdef1bf0903b08c9067eac | `v4_capture_K36.py` | | `famrk_K72_m02_thI36_thT26_cap4_ct+s3.npz` (FAKE) | 1099318 | 0f092f413140eb62ad1f7a917e21d5be3db80b2e1ff9a8eb40bcb89f95dd6f3b | `famrk.py` (K = 72, ct+s3); shipped as `K72_fake_start.json` | | `S_K72_26_s3_hint.npy` (BASIS) | 122384 | 38a1c6c5130014a9b640a00e2042452d303a91a65ca12f61dd39094ab233eace | an earlier `rigfam.py`; shipped as `K72_basis_hint.json` | | `rigfam_cert_K72_m02_thI36_thT26_cap4_r3_full_1a212ad4.npz` | 7093112 | 68b3da5fe80cb97d7f4e7e2e57f195a33f2d10827b0d55a1fdc2f14ed941b1a8 | `rigfam.py verify` (K = 72) | | `K72_indep/` (18 files, 1.93 GB in all) | | see `K72_indep_READY.txt` | `indep_export.py` | **Reproducibility.** A certificate records the SHA-256 of `rigfam.py`, `famrk.py` and `modm_otf_lowmem2.py` as they ran, and its name records the first digits of `rigfam.py`'s; the shipped scripts differ from the files as run in comments and paths, so a certificate regenerated with them differs from the original in that field and in its name, and the export's `claims.json` and `READY` differ accordingly. Regenerated with the shipped scripts on the machine that made the originals, the K = 36 certificate agreed with the original in every other field, and `K36_core_inputs.npz`, `K36_C.npy`, `K36_basis_hint.npy` and `K36_independent_bounds.json` were identical byte for byte; the three checks passed. The K = 72 certificate, regenerated there with the shipped scripts from the starting point and basis rebuilt from `K72_fake_start.json` and `K72_basis_hint.json` (one thread, nice 10, an address-space limit of 4.4 GB; about 360 s of CPU time and 3.9 GB peak), was verified and agreed with the original in every field except the recorded source hashes. The shipped `indep_export.py` then reproduced every array of the K = 72 export and `Rex_hex.txt` byte for byte, `C.npy` included (about 615 s and 3.9 GB, address-space limit 4.5 GB); its `claims.json` differed only in the source hashes and the FAKE and BASIS paths. On those files the shipped `v4_independent_K72.py` (about 35 s and 3.9 GB, address-space limit 8.3 GB) reported `K72 VERIFIED HERE`, with the same bounds as the original check. On other machines or library builds, given the same starting point and basis hint, the exactly computed data (the classes, the basis, the dyadic point g, the row scaling p2, the row keys, the index arrays of B and dB and the exact residual integers) are expected to be identical, and so are r and dr, which are correctly rounded quotients of exact integers; the values of B and dB are deterministic floating-point sums, expected to be identical with the same NumPy; but the inverse C, the correction x~ and the bounds computed from them come from LAPACK and BLAS and are not byte-reproducible across builds. For K = 36 the starting point is the verifier's own floating-point solve and the basis a floating-point selection, so another machine may certify a slightly different rational point. Where the data differ, acceptance by the three checkers, not the listed hash, is the reproduction criterion. ## The window masks of `sep_p5/p5rig.py` These are not experiments of section 8: they check two lines of the separately written program for (1/20, 1/5) (top-level README, "The consistency runs"). In its method `zcomb`, the masks `sure` and `maybe` compare a range of closed cells of x with the window W(sigma) = [1/2 - sigma, 1/2) for sigma in a closed cell: `sure` may hold only if x is in W(sigma) for every such (x, sigma), and `maybe` must hold whenever x is in W(sigma) for some. `mask_check.py` reads the two lines from a program file and checks this contract exactly, with fractions, for every combination of cell indices at M = 40 and M = 120, whether the program reaches it or not; it prints "CONTRACT HOLDS" or "VIOLATIONS", and its exit status is 0 either way. `exact_windows.py` (with `audit_common.py`) evaluates the program's own window enclosures at M = 120 against exact rational references (936 checks) and exits with status 1 if any enclosure excludes its reference. Its checks of the masked window terms use only the index combinations that the program's callers form (c0 = aidx - l - 1 and c1 = aidx - l, with aidx from M/2 + l - 2 to M/2 + l + 1, at l = M/20, M/10, 3M/20 and M/5 - 1), so it tests the closed-endpoint contract of `sure` (24 of its checks fail with `sure` as first run) and exercises `maybe` only on combinations where `maybe` as first run and as corrected agree (c1 >= M/2 - 2); the correction of `maybe` is checked by `mask_check.py` alone. `run_p5_window.sh` runs both checks on the shipped `sep_p5/p5rig.py` and on a copy with the two masks as first run, which it makes with `sed` (it writes `p5rig_oldmasks.py` in the current directory). After unpacking, run it from the supplement's top directory: `PY= sh OUTDIR/run_p5_window.sh OUTDIR`. Its record `p5_window_runs.txt` (in `outputs_window_checks.log`) shows the shipped program passing both checks (CONTRACT HOLDS at M = 40 and 120; 0 failures in 936) and the copy refused by both: at M = 40 and 120, there are 190 and 1770 false `sure` classifications, respectively, and 190 and 1770 missed `maybe` classifications. Of these, 18 and 58 false `sure` classifications, and no missed `maybe` classifications, satisfy the check's caller-form filter `c1 == c0 + 1` and `c1 + l >= M/2`. This filter does not enforce the actual loop limits `M/20 <= l < M/5` or the certificate's requirement that M be divisible by 60; at the supported M = 120 only 18 false `sure` classifications are reached by callers (the script's second line for each M counts the classifications reached by the actual calls; at M = 40, which the certificate does not admit, it gives 6). Of the 936 exact enclosure checks, 24 fail. `exact_shipped.json` and `exact_oldmasks.json` are the full reports. `audit_common.py` ships with four machine paths replaced by relative ones (declared in `sources.md`). ## Resources and run notes - Most runs take seconds to a few minutes on one thread and under 1 GB of memory (the recipes record the limits used). - Heavy runs: the free problem's cells at K = 72 (about an hour and 3.3 GB for 26/72; the run for 27/72 was stopped by its memory guard at about 4.8 GB in its sixth round, after its certificate had been printed); K = 60 about 20 minutes. The lever families at K = 72 were stopped by a memory guard after the second family (about 3 GB). - The diagnostic runs of the candidate and of the control, and the pricing runs, were stopped by hand once they had produced what they were run for (`diag_runs.txt`, `p8_pricing_runs.txt`). - The runs of record of the families take about 50 to 65 s of CPU time each and at most 0.8 GB at N = 72, and up to about 390 s and 2.6 GB at N = 90 to 108, one process each, at nice 10 with an address-space limit of 4.5 GB (GNU `time`, which includes the gate's re-check). The outputs also record solves that were not accepted, usually a first attempt without presolve that was then retried with presolve. - The K = 72 values of the families that resolve the two and the three largest small parts come from one recipe, `lane_rerun.sh`: `famrk.py` for ct+s3 and then ct+s2, then `verify_fake_v2.py` on the ct+s3 solution that the first run saved (an `.npz` whose arrays are shipped as `K72_fake_start.json`). `lane_rerun.sha256` records the SHA-256 of the two scripts at the start, `verify_K72_26_s3.out` records the SHA-256 of every module it imported, and the first line of each `famrk.py` output records the parameters as the script checked them. These runs are a rerun: the version of `famrk.py` that first computed the ct+s3 value was not kept. The rerun reproduces the earlier values, and the ct+s3 solution byte for byte. The ct+s3 run took about 18 minutes of CPU time and 3.8 GB, ct+s2 about 3 minutes and 1.5 GB, and the check about 26 seconds and 1.6 GB; the K = 36 runs take seconds. `famrk.py` reports a family value as zero when the optimum is at most 1e-7 with row residuals at most 1e-9 (floats); its "Lagrangian bound" is a floating-point lower bound from the row duals, not a certificate. - Some elapsed-time stamps in the family and diagnostic logs are negative or out of order because the machine's wall clock stepped. Use recorded CPU times where available; the uncorrected elapsed stamps do not support a cost model. - Software: Python 3.14.4, numpy 2.5.2, scipy 1.18.0 (with its HiGHS), and python-flint 0.9.0 for `cert2_f3*.py`, on Linux.