# qqww-t4 bundle — CHANGES The standalone evaluator `eval_row35.py` and the files beside it (the nonplanar T4 branch of two-loop q qbar -> W+ W-, row 35). Entries in date order; `MANIFEST.sha256` is the bundle's integrity file. ## 2026-09-05 — eval_row35.py: the second line L2 = (17/2, 7/4) — `--line L2 --verify-exact`, the exact check of the L2 reconstruction against its two withheld Kira reductions - The 79x79 connection's exact y-dependence was reconstructed along a SECOND kinematic line, (x, z) = (17/2, 7/4), from 91 Kira differential-equation points (three computed first at y = 1/3, 1/2, 3/5, then 88 more; 89 in the fit, the two of largest y, 296/101 and 306/103, withheld). On either line the plain fit closes 1220 of the 1240 entries and the same known-denominator rescue fit closes the twenty of masters 75-78 (the same twenty on both lines: (75,5), (75,6), (75,23), (75,26), (76,5), (76,6), (76,23), (76,26), (77,3), (77,4), (77,5), (77,6), (77,19), (77,20), (77,23), (77,26), (78,5), (78,6), (78,23), (78,26)). The bundle now ships that reconstruction under `row35_L2/`: `connection_L2.json` (fd83c63b685adb69; the record fit file's 1240 entries in the same N(d,y)/Q(d,y) form as `row35_data.json`, with the line's kinematics, the 79 master names and the fit's 24 + 3 d-nodes), the two withheld reductions `withheld_y296o101.json` (c214d927c2c16db2) and `withheld_y306o103.json` (15d2af53d7687182) byte for byte as the record holds them (each the reduction at one withheld y: 1240 rational entries in d over the same 79 masters), `points.json` (the 91 points: every y, its role, the sha256 of its reduction, the d-nodes, the known-denominator closure's 40 + 4 d-samples) and `lines.json` (both lines by their kinematics with the record's verdicts). Every `row35_L2/` file is sha256-pinned in the script. - `python3 eval_row35.py --line L2 --verify-exact`: every entry of the shipped L2 connection is evaluated at d = 7/3 (outside the fit's 27 d-nodes and the closure's 44 d-samples) and at each withheld y in exact Fraction arithmetic and compared entry by entry with the withheld reduction, whose record strings are evaluated exactly at the same d — no transport, no node bank, no floating point. Measured on the delivered bytes (one core, a shared 96-core host at loadavg ~170-260): y = 296/101 at d = 7/3: 1240/1240 exact; y = 306/103 at d = 7/3: 1240/1240 exact; the verdict line reads `1240/1240 and 1240/1240 exact at both withheld points (y = 296/101 and 306/103) at d = 7/3 -- the shipped L2 connection reproduces the withheld Kira reductions entry by entry in exact arithmetic`; rc 0; 5.55 s. This is an exactness check of the one-variable reconstruction on that line; the two-variable function is not established by it and remains open (`lines.json` says so). - The value tiers (default, `--point`, `--gate-full`, `--master`, `--check`, `--cached`) and `--check-expression` are the first line's: the certified node bank, the base point y = 1/3, the compare-cache strings and the reference values were all computed at (x, z) = (17/2, 5/3), and the record holds no boundary data on L2, so under `--line L2` they refuse by name (rc 2). `--line L1` is the default and leaves every documented tier exactly as before, apart from the one defect cured in the next bullet: on the served bytes and the delivered bytes, 11/11 documented L1 tiers other than `--check` give byte-identical output after masking walls and stamps (the quick default 18.98 / 21.53 s; `--point 17/40` over all 79 rows 434.75 / 222.70 s), with equal exit codes. - Pre-existing defect cured: `--check` in quick mode paired a y-tag the pass did not gate (KeyError); now pairs only the tags present. The dps + 60 rerun paired its two passes by the fixed list of both reference points (y = 1/2 and y = 3/5) while the quick default gates y = 1/2 only, so `python3 eval_row35.py --check` (the documented rerun of the quick default) raised `KeyError: 'y35'` after the rerun (measured on the served bytes: rc 1 with the traceback, at the script's line 1800); the pairs are now the tags the pass gated. On the delivered bytes the same command completes: the dps 40 and dps 100 passes print the same 19 lines as the served run up to its crash (byte-identical after masking walls), then `# --check agreement: 999.0 digits (floor: printed-coefficient precision / arithmetic; truncation errors are deterministic and cancel)`, rc 0, 61.32 s. `--check` with `--point` was never affected, and `--master 33 --check` (both reference points gated) prints byte-identical output on the served and the delivered bytes (rc 0 both, agreement 999.0 digits). - Controls: `--line L2 --verify-exact --mutate` changes one digit of one vendored entry in memory (entry (3,3) N[0] numerator coefficient '-5/2' -> '-6/2' (one digit changed in memory; the shipped file is untouched)) and FAILS by name (rc 1: 1239/1240 at y=296/101 and 1239/1240 at y=306/103; y=296/101: MISMATCH at (3,3); y=306/103: MISMATCH at (3,3)); on copies of the bundle, one digit of one shipped connection entry changed and re-pinned → FAIL naming the entry (rc 1: `# --line L2 --verify-exact: FAIL -- 1239/1240 at y=296/101 and 1239/1240 at y=306/103; y=296/101: MISMATCH at (10,0); y=`); the same change without the re-pin → rc 3 by name (`[L2] PIN MISMATCH: row35_L2/connection_L2.json sha256 fd4b38bdd7b184b1... != pinned fd83c63b685adb69`); a withheld file removed → rc 4 by name; one digit of a withheld reduction entry changed and re-pinned → FAIL naming the entry at that y only (rc 1); and the record's own limitation reproduced by object: the pre-rescue fit (1220 entries) put in place of the connection gives 1220/1220 exact at both withheld points and names the twenty unclosed entries (rc 1). - The commands of record (the fit chain, run in the record's fit directory): the withheld verification of the plain fit `python3 fit/heldout_verify_L2.py fit/A_of_y_L2.json fit_heldout/pt_*/A_point.json` → `HELDOUT_VERIFY_L2: PASS [('296/101', 1220, 1220), ('306/103', 1220, 1220)]`; the closure `python3 rescue_fit_L2.py` → `RESCUE: 20/20 in 74s` (73 s in the fit file's own field); the withheld verification of the completed file, the same verifier on `A_of_y_L2_rescued.json` and the two `A_point.json` files at `--fresh-d 7/3` (its default) → `HELDOUT_VERIFY_L2: PASS [('296/101', 1240, 1240), ('306/103', 1240, 1240)]`. The served tier reproduces the last line from the shipped bytes. - `MANIFEST.sha256` regenerated (`sha256sum -c MANIFEST.sha256` in the bundle directory: 15 files OK); the nine data and engine files are byte-identical to the previous bundle. Exit codes on the new tier: 0 PASS / 1 FAIL / 2 refused / 3 a pinned file's sha256 differs / 4 a pinned file missing. ## 2026-09-05 — CONTAINERS.md and containers.json added; `--boundary-recompute` runs from the chain container beside the script - files/qqww-t4 (row 35): `CONTAINERS.md` + `containers.json` added — every not-hosted file named by sha256 and byte size (row35_radical_feed_b421.json 508,033,204 B, row35_radical_feed_b453.json 486,957,056 B, row35_chain.tar.gz 1,769,919 B, row35_fresh_pair.tar.gz 776,107 B); `eval_row35.py`: `--boundary-recompute [DPS]` now runs (GATE-D0 replay, `--gate-bc-only`, `--regenerate-node Q`) from `row35_chain/` unpacked beside the script and refuses with exit code 4 naming the container (sha256 + size) when it is absent, exit code 3 when a container or a chain member does not match its manifest; a closed-form container found beside the script is size- and sha256-checked at load before use; `--containers` prints the status of every entry; the default, `--point`, `--master`, `--cached`, `--mutate` and `--check-expression` tiers print the same numbers as before (one wording change in the CHECK line: "containers not beside this script (CONTAINERS.md)"). `FAN_CLAIM_CAP` stays 40 (the measured 24-node bank capacity; lifts when the containers are distributable). `MANIFEST.sha256` regenerated. ## 2026-09-06 — CHANGES.md created; the chain lines of `--boundary-recompute` print paths relative to the script; the checkpoint-rerun wording; exit code 5 documented - This file created, carrying the two earlier entries of this bundle (the second line L2; the containers and the served `--boundary-recompute` path) and this one; it is listed in `MANIFEST.sha256` from this regeneration on. - `eval_row35.py`: the `# CHAIN RUN:` line and the `--regenerate-node` checkpoint lines print every path under the script's own directory relative to it (`row35_chain/...`, `row35_chain_work/...`) instead of the absolute directory of the download; the arguments handed to the chain drivers are unchanged. A `--regenerate-node` rerun that finds its node file complete now ends `from the checkpoint (solve skipped), worst agreement ...` instead of `regenerated from definition ...` (the line before it already said the solve was skipped). Measured on the delivered bytes against the previous bundle: 12/16 documented tiers byte-identical after masking walls and stamps (the quick default 20.02 / 31.82 s; `--point 17/40` over all 79 rows 231.50 / 236.79 s; `--check` 24.26 / 26.27 s; `--line L2 --verify-exact` 15.00 / 2.52 s), with equal exit codes; on the chain tiers run from `row35_chain/` (`--gate-bc-only`, the 5-row GATE-D0 replay, `--regenerate-node 1013` at dps 60 and its checkpoint-honoured rerun) the only differing lines are the 6 chain lines named above, every gate figure and every digit line equal. - `CONTAINERS.md`: exit code 5 (a chain gate below its bar) documented beside 3 and 4. - The first line's withheld reductions (d = 890/223; y = 29/211 and 17/139) stay quoted in `row35_L2/lines.json` and are not shipped: the two reduction files behind the recorded 1240/1240 verdict were not retained with the fit, so `--line L1 --verify-exact` still refuses by name. - `MANIFEST.sha256` regenerated (18 files; `sha256sum -c MANIFEST.sha256` OK in the bundle directory). ## 2026-09-06 — the first line's withheld reductions ship under `row35_L1/`; `--verify-exact` runs on the default line - The two Kira reductions withheld from the first line's fit, at y = 29/211 and 17/139 on (x, z) = (17/2, 5/3), now ship under `row35_L1/` as `withheld_y29o211.json` (cad512ab6abedc62, 676,783 bytes) and `withheld_y17o139.json` (ccf6e06a7f6fb7a0, 678,088 bytes) — the record objects byte for byte, in the same form as the second line's (`row35_L2/withheld_*.json`: the point, the 79 master names and their hash, the 1240 rational entries in d). The reduction files behind the record's 1240/1240 verdict had not been retained with the fit (the previous entry); the two points were re-reduced on 2026-09-06 with the first line's own reduction harness (its files by sha manifest) and the same Kira 3.1 build as the second line's record, and the record's own verdict step, re-run on the new objects, gives every entry of the first-line connection at d = 890/223 and at each y exactly equal to the new reduction: 1240/1240 at both, the record's verdict reproduced, with a planted-digit control caught. Both files are sha256-pinned in the script (`PINS_L1`); `row35_L2/lines.json`'s first-line block now says `shipped: true` and carries the two files, the tier, the master hash and the objects' provenance (its note that they were not part of the download is gone; nothing else in the file changes). - `python3 eval_row35.py --verify-exact` (the default line; `--line L1 --verify-exact` is the same call) is the first line's twin of the second line's exact tier: pins first (the two `row35_L1/` files, `row35_L2/lines.json` and `row35_L2/connection_L2.json` against the script's tables, then `row35_data.json` against the sha256 that `lines.json` records for it), then every entry of `row35_data.json` evaluated at d = 890/223 and at each withheld y in exact Fraction arithmetic and compared entry by entry with the withheld reduction, whose record strings are evaluated exactly at the same d — no transport, no node bank, no floating point. Measured on the delivered bytes (one core, a shared 96-core host at loadavg ~120-170): 1240/1240 and 1240/1240 exact at both withheld points (y = 29/211 and 17/139) at d = 890/223, rc 0, walls 2.3 to 6.3 s over four runs; two runs byte-identical, the bare `--verify-exact` identical to the `--line L1` form. The served refusal of `--line L1 --verify-exact` is gone. Exit codes: 0 PASS / 1 FAIL / 2 refused / 3 a pinned file's sha256 or a header differs / 4 a pinned file missing. - Controls, on copies of the delivered bundle: `--verify-exact --mutate` changes one digit of one connection entry in memory ((3,3) '-5/2' -> '-6/2') and FAILS by name (rc 1: 1239/1240 at y=29/211 and 1239/1240 at y=17/139; y=29/211: MISMATCH at (3,3); y=17/139: MISMATCH at (3,3)); one byte of `withheld_y29o211.json` changed with the pin untouched → rc 3 naming the file; the file `withheld_y17o139.json` absent → rc 4 naming it; the master-hash header of a withheld file changed and the file re-pinned → rc 3 naming the file; the record's planted-digit control reproduced (one digit of the reduction entry (10,0) of `withheld_y29o211.json` changed, the file re-pinned) → rc 1 naming the entry at y = 29/211 only, y = 17/139 still 1240/1240; the first-line block of `lines.json` altered and re-pinned → rc 3; one byte of `row35_data.json` changed → rc 3 naming it. - Every other tier is unchanged: on the served bytes and the delivered bytes, 10/10 documented tiers (the quick default 19.86 / 22.74 s, `--cached`, `--mutate`, `--check-expression`, `--containers`, the `--boundary-recompute` refusal, `--line L2 --verify-exact` twice (2.28 / 2.18 s; 1240/1240 and 1240/1240 both sides), its `--mutate` control and the `--line L2` value refusal) give byte-identical output after masking walls and stamps, with equal exit codes; `--help` differs only in the re-cut `--line` / `--verify-exact` help text. The second line's tier `verify_exact_L2` is untouched (identical under a masked-AST comparison); the first line's value tiers are untouched. - Two notes from the previous entry's review folded: the `--regenerate-node` refusal for a node file left incomplete by a solve prints its path relative to the script (the one checkpoint-path print the previous entry had missed), and `CONTAINERS.md` names that case as the fifth exit-5 condition. - `MANIFEST.sha256` regenerated (20 files: the two `row35_L1/` files added, `eval_row35.py`, `CONTAINERS.md`, `row35_L2/lines.json` and this file re-pinned, every other pin unchanged; `sha256sum -c MANIFEST.sha256` OK in the bundle directory). ## 2026-09-06 — the canonical-basis census of the two lines ships (`row35_L1/blocks_epsform.json`, `row35_L2/blocks_epsform.json`, `row35_L2/canonical_gauge_L1_L2.json`); `--canonical-blocks` re-checks it exactly on either line - On each line the 36 diagonal blocks of the connection were run through the eps-factoriser one at a time (sector 481, the elliptic sector, is outside any dlog form and was not run): 28 admit a rational rotation T(eps, y) to an eps-factorised dlog form eps * Atilde(y) on the first line and the same 28 on the second; the same seven sectors stop on both lines -- 417, 449, 487 Moser-irreducible (the input is not Fuchsian and the Moser reduction stalls) and 421, 453, 482, 483 at the eps^0 obstruction (Fuchsian, the balances exhaust, no constant eps-decoupling) -- with the identical stop string on the two lines; the 28 block forms of the two lines are related letter by letter, through the restriction of the 36-letter alphabet to each line, by a constant gauge G (the identity on 23 blocks, nontrivial on 227, 321, 327, 355, 485), and the first line's forms are identical field by field to the July record. The bundle now ships that census: `row35_L1/blocks_epsform.json` (607ae4316fabaaee, 47,786 bytes) and `row35_L2/blocks_epsform.json` (35458111c3e5dbeb, 47,566 bytes) -- per block the sector, size, rows, masters, the engine's verdict, the stop string verbatim for the seven stopped blocks and, for the 28 factorised blocks, T and Atilde as the engine's own strings, the letters as rational poles named by their alphabet letter, the quadratic letter, the exact residue matrices and the (U y + V)/q kernel -- and `row35_L2/canonical_gauge_L1_L2.json` (7c5943f498c4f654, 49,169 bytes) with the letter map, G, det G and the matched residue pairs of every block (50 pairs: 37 equal, 13 conjugated). All three are sha256-pinned in the script (`PINS_CANON`); `row35_L2/lines.json` gains a `canonical_blocks` block per line (the files by sha256, the counts, the stop classes, the check points, the gauge file, the provenance) and is re-pinned; nothing else in it changes. - `python3 eval_row35.py --canonical-blocks` (the default line; `--line L1 --canonical-blocks` is the same call) and `--line L2 --canonical-blocks`: pins first (the line's blocks file, the gauge file and `lines.json` against the script's tables, the connection against its pin), then for every factorised block the identity T A T^-1 + (dT/dy) T^-1 == eps * Atilde entrywise in exact Fraction arithmetic -- A the block of the line's shipped connection at d = 4 - 2 eps, dT/dy by dual numbers on the engine's strings -- at (eps, y) = (1/223, 29/211) and (5/6, 17/139), Atilde eps-free (re-evaluated at eps + 1/97), the dlog form Atilde == sum_p R_p/(y - p) + (U y + V)/q(y) from the shipped residues at both y, the residue at infinity, and the gauge (the line's residues against its side of every pair, G R1 G^-1 == R2 on every pair); every block prints its verdict or its stop class by name and its letters as restrictions of the alphabet. Measured on the delivered bytes (one core, a shared 96-core host at loadavg ~110-140): L1 `28 OK / 7 stopped (3 Moser-irreducible + 4 eps^0) / 1 elliptic`, rc 0, walls 2.7 to 3.4 s over five runs; L2 the same census line, rc 0, walls 2.6 to 3.0 s over four runs; two runs identical on each line after masking the printed wall; the bare `--canonical-blocks` identical to the `--line L1` form; `--verbose` prints the seven stop strings verbatim (equal to the record's on both lines). A statement about each line's blocks by themselves, not about the two-variable function. Exit codes: 0 PASS / 1 FAIL (the failing blocks named) / 2 a usage error / 3 a pinned file's sha256 or a header differs / 4 a pinned file missing. - Controls, on copies of the delivered bundle: `--canonical-blocks --mutate` changes one digit of one T entry in memory (block 321, entry (0,0), '2' -> '3') and FAILS naming the block on both lines (rc 1, the census line 27 OK / 7 stopped); one byte of `row35_L1/blocks_epsform.json` changed with the pin untouched -> rc 3 naming the file; `row35_L2/blocks_epsform.json` absent -> rc 4 naming it; one digit of one T entry of block 485 changed and the files re-pinned -> rc 1 naming the block at both check points; one entry of G for block 321 changed and re-pinned -> rc 1 naming the block on either line (G R1 G^-1 != R2); one residue entry of block 321 changed and re-pinned -> rc 1 naming the block (the dlog form at both y); the stop class of block 417 relabelled and re-pinned -> rc 1 naming the block; a check point in `lines.json` altered and re-pinned -> rc 3; one byte of `row35_data.json` changed -> rc 3 naming it; a master name of block 262 changed and re-pinned -> rc 1 naming the block. - Every other tier is unchanged: on the served bytes and the delivered bytes, 10/10 documented tiers (the quick default 22.47 / 21.61 s, `--cached`, `--mutate`, `--check-expression`, `--containers`, the `--boundary-recompute` refusal, `--verify-exact` on both lines (L1 2.72 / 2.50 s, L2 2.32 / 2.73 s; 1240/1240 and 1240/1240 both sides) and their `--mutate` controls) give byte-identical output after masking walls and stamps, with equal exit codes; `--help` differs only in the new `--canonical-blocks` / `--verbose` help and the re-cut `--line` help; the `--line L2` value refusal now names both L2 tiers (its exit code 2 unchanged). `verify_exact_L1`, `verify_exact_L2` and every value-path unit are untouched (identical under a masked-AST comparison). - `MANIFEST.sha256` regenerated (23 files: the three census files added, `eval_row35.py`, `row35_L2/lines.json` and this file re-pinned, every other pin unchanged; `sha256sum -c MANIFEST.sha256` OK in the bundle directory). ## 2026-09-06 — the Mellin-Barnes corner rows 69 / 42 / 43 of the boundary ship as provenance objects (`vendor_row35_mb_corner/`); `--mb-corner-provenance` prints them by object - Three rows of the boundary basis -- 69 (sector 484), 42 and 43 (sector 227) -- are the corner rows whose Mellin-Barnes representations were written as explicit five-fold integrals at the base point of this line. They are provenance objects, not value sources: the value path of every tier stays the eta-transport from the certified node bank, and nothing printed by the new tier enters `--check` or any other served gate. The bundle now ships those objects under `vendor_row35_mb_corner/` (16 record files + `MB_CORNER_MANIFEST.sha256` d5cba029eaeeaf80, every one sha256-pinned in the script, `PINS_MB_CORNER`; 2 files verbatim by sha256 and 14 re-cut of only their register-hitting strings -- paths to file names, the record's working vocabulary to this bundle's -- with every numeric leaf and every formula string byte-equal to the record object, whose sha256 the vendored manifest's header records file by file): row69/ the record's written representation `mb_row69.py` (11426e57e6320be2), its gate at eps = 1/1013 (`GATE_row69_q1013.json` 48a8bef7553b5de2), the second point eps = 1/1117 at two working precisions (`GATE_row69_q1117_dps20.json` f966f3f1f88d3936, `GATE_row69_q1117_dps30.json` 85e08032b8914644), the collapse certificates (`CERTS_row69_collapse.json` c92b92e79b532f82) with their producer as text (`r69_collapse_certs.py` bb6124436079dcd7), the independent collapsed-integrand library `r69_lib.py` (3c4b64ebe5a72a6a) and the gates' producer as text (`r69_gate_v2.py` fa2540cfa363e913); row42/ the written representation `mb_row42.py` (26558d0361496d0c), the library `r42_lib.py` (92f7a32ee1edab38), the pilot certificates (`PILOT_R42.json` 77006d8c14c327cf), the s2 closure pilot (`PILOT_R42_CLOSURE.json` c45042aba32aafb1) and the ray scan (`RAYSCAN.json` 37f65689caef5c0f); row43/ the written representation (`ROW43_MB_REPRESENTATION.json` 298ea04dd6c0c23b), the recipe of record (`MB_ROWS.json` c5ffcef390c0ffd9) and the record's relabel note (`RELABEL_NOTE.md` 3c07fc6d7bc4bd25). The enumerated pole-crossing tree of the row-43 delta walk (106,817 bytes) is named in the vendored manifest by sha256 (d5519673492c8322) and not shipped. - `python3 eval_row35.py --mb-corner-provenance [--row 69|42|43|all]`: pins first (every vendored file against `PINS_MB_CORNER`, the vendored manifest's own lines against the same pins; rc 3 / rc 4 by name before any print), then, row by row, the representation -- for rows 69 and 42 the Gamma lists, contours, bases and closure sides read from the record module's `build()` as text (the module is never imported: its engine is not shipped) beside the RESULT block of its docstring verbatim, the two compared (the Gamma counts and the contour tuple); for row 43 the 13 + 3 Gammas, the powers, the exact factor -1-s1, the pinches, the delta-regulated defining point and the walk specification, the argument vectors re-rendered against the argument strings -- and the certificates by object, each figure read from the vendored file by key and named with its source file and sha256: row 69 the record's eps = 1/1013 gate (matched digits against the node bank at two bank precisions), the eps = 1/1117 gates at working precisions 20 and 30 with their planted-digit controls (FAIL by name), the pair of the two precisions computed here from the two value strings (the roundoff floor of the pair), the collapse certificates at the record test point, the sha links between the objects (the certificates name the representation, the gates name their producer and library, the two gates name the same bank files, which sit beside this script), and the evaluator's refusal of a point the bank does not hold (rc 5, quoted from its text); row 42 the certified collapses (s3 -> 2F1, b2 -> Meijer G with the u-channel phase and its wrong-phase control), the continuation control, the growth of every b1 residue closure, the power-law upper s2 tail against the exponential decay of the rotated rays, and the s2 closure pilot -- then `NOT EVALUATED: no bank digit`; row 43 then `WRITTEN, NOT EVALUATED: no straight-contour defining point at any eps; the pinch argument sums -eps and eps + delta`. The closing line: `this tier enters no digit into --check; the served gates are the eta-transport + node bank`. Measured on the delivered bytes (one core, a shared 96-core host at loadavg ~100-140): 0.27 s (every row), twice identical after masking the printed walls; the single rows are the sections of the full run. Exit codes: 0 PASS / 1 a re-derivation FAIL or a record inconsistency (named) / 2 refused (the tier combines with no other flag) / 3 a pinned file's sha256 differs / 4 a pinned file missing. - `--mb-corner-provenance --rederive`: the three seconds-class certificates re-derived at the objects' working precision (30) and compared with the record figure within 0.1 digits, PASS or FAIL by name (rc 1 on FAIL): row 69 s3 -> 2F1 by the vendored producer's own contour and breakpoints read from its text (30.5 d, record 30.5 d), row 42 s3 -> 2F1 (30.4 d, record 30.4 d) and b2 -> Meijer G with the phase (31.0 d, record 31.0 d; the wrong-phase control -0.9 d, record -0.9 d) by the vendored library; the quadrature and closed-form strings equal the objects' own. Measured 4.13 s; `--dps D` moves the precision (compared only at the record's). Still no effect on `--check`. - Not established by these objects, in the record's own words: - row 42: any bank digit (the three-fold quadrature is in flight) - row 43: any bank digit (representation written, not evaluated; no straight-contour defining point; the delta walk is a residue tree without a walker) - Controls, on copies of the delivered bundle: one byte of a vendored file changed with the pin untouched -> rc 3 naming the file on the tier AND on the quick default (the pins are checked on every value run: the download is one bundle); a vendored file absent -> rc 4 naming it on both; a certificate figure of `PILOT_R42.json` changed by one digit and the copy re-pinned -> `--row 42 --rederive` FAILS by name (rc 1) while the plain tier prints the planted figure as the object's own; a matched-digits figure of a row-69 gate changed and re-pinned -> the printed figure differs from the record by name; one digit of a row-69 value string changed and re-pinned -> the printed pair drops; `--mb-corner- provenance --check` -> rc 2 by name. - Every other tier is unchanged: on the served bytes and the delivered bytes, 14/14 documented tiers (the quick default 22.18 / 21.66 s, `--check` 67.91 / 67.42 s, `--cached`, `--mutate`, `--check-expression`, `--containers`, the `--boundary-recompute` refusal, `--verify-exact` on both lines and its `--mutate` control, `--canonical-blocks` on both lines and its `--mutate` control, the `--line L2` value refusal) give byte-identical output after masking walls and stamps, with equal exit codes; `--help` differs only in the new `--mb-corner-provenance` / `--row` / `--rederive` help. Every value-path unit is untouched (identical under a masked-AST comparison; only the module docstring and the dispatch in main() differ, with the new units added). - `MANIFEST.sha256` regenerated (40 files: the seventeen vendored files added with their roles, `eval_row35.py` and this file re-pinned, every other pin unchanged; `sha256sum -c MANIFEST.sha256` OK in the bundle directory). ## 2026-09-09 — the ring pass over the 40 transport-defined boundary constants ships by object (`qqww-t4-ring-pass.json`); `qqww-t4-boundary.json` carries its 22 leading rationals as pins beside the row definitions - Forty of the 79 boundary constants are defined by the eta-transport from the certified node bank and have no closed form in the record. A ring pass searched them for integer relations: at the record node (eps = 1/1013, the dps130/dps160 pair, 128 to 141 certified digits over the 63 real and imaginary parts) no part of any of the forty has a relation with a twelve-member Gamma-vacuum/radical ring at height 10^4 / 10^5 or with the eleven derived closed-form rows' values at height 10^4 (planted and recognised controls found, a random negative null at the same settings); at the Laurent level (the vendored 110-digit strings) the leading coefficient of 22 of the 40 is an exact rational (height at most 10^8, re-verified at 105 digits and by direct substitution), the leading coefficient of two more (rows 75 and 78, sector 487) is an exact weight-one logarithm form in the base-point ring, and the next order lies in neither weight-one logarithm ring tested. The bundle now ships that pass as `qqww-t4-ring-pass.json` (ccd53209a9807a79, 119,377 bytes; the record object byte for byte): the four ring bases as two-precision digit strings, the relations found, and per row and order the verdict, the certified null height and the margin. It is provenance, not a value source: no tier of the evaluator reads it, and nothing in it enters `--check` or any served gate. - `qqww-t4-boundary.json` (89101ed152f061bf -> cb3bcfb7f6f0df3f, 102,360 -> 107,662 bytes): each of the 22 rows whose leading coefficient the pass found rational (rows 10, 11, 16, 30, 31, 32, 34, 37, 38, 40, 49, 52, 55, 56, 57, 58, 59, 61, 62, 67, 68, 77) gains ONE key `leading_coefficient_pin` beside its definition (after `leading_order`) with the order, the rational as a string, the ring, the pass's re-verification residual and the source file's name; a top-level block `_ring_pass` (after `_producer`) names the source by sha256, the pinned rows and the two weight-one logarithm rows (named from the pass, not pinned as rationals). Every existing key and every digit string of the served file is unchanged (the producer strips the new keys and asserts equality with the served object before writing; the served serialization is reproduced). Each pin was checked against the row's own leading coefficient string before it was written: the rational agrees with the displayed real part to every displayed digit (the largest difference 3.3e-60 against 60 displayed digits) and the imaginary part is below the row's ball radius; the pinned order equals the row's `leading_order`, and the pass's own per-row table reads FOUND with the same value. - `eval_row35.py` is unchanged (f1ad409f4f080254): it reads neither `qqww-t4-boundary.json` nor the ring-pass file, so no accommodation was needed. Measured on copies of the served and the delivered bundle (two cores each under a compute fence, a shared 96-core host at loadavg ~190-210): the quick default 19.29 / 18.62 s (rc 0 both; the three master lines 46.7 / 43.2 / 43.2 digits vs the independent reference, CHECK y12 min 43.20 d, E4 FAN [CERTIFIED]) and `--master 3 --point 1/2` 17.36 / 16.22 s (rc 0 both) print identical lines on the two bundles after masking the walls. - Not established by these objects, in the pass's own words: closed forms beyond the leading Laurent order for any of the forty rows (a null excludes only the frozen ring at the printed height); a scan of the six sector-481 rows in their own ring (their thimble columns carry 39 to 51 digits, below any certifiable height for a six-member ring); a two-precision certification of the 110-digit strings beyond the record's own fan; relations with eps-dependent coefficients beyond the printed heights; weight-two and higher rings at the Laurent level. - `MANIFEST.sha256` regenerated (41 files: `qqww-t4-ring-pass.json` added with its role, `qqww-t4-boundary.json` and this file re-pinned, every other pin unchanged; `sha256sum -c MANIFEST.sha256` OK in the bundle directory). ## 2026-09-09 — `vendor_row35_p6_point/`: the one-point shelf — the exact Kira connection at (x, y, z) = (8, 1/3, 3/2) off both delivered lines, the seeded compare of its 28 diagonal blocks against the first line's eps-form seed (15 of 28 lift exactly, 13 do not), the pre-registered prediction and the negative control, with the compare script as this point's row script; no change to `eval_row35.py`; `MANIFEST.sha256` re-emitted - NEW `vendor_row35_p6_point/` (39 files; README.md names each and gives the reproduction commands): the data behind the row's one-point sentence of 2026-09-09 (the statement object sha256 e3044a08ecefb8b7…). `A_point.json` 39a3357f3f783e8f… (byte-identical to the object as run) — the exact Kira differential-equation connection in y at (x, y, z) = (8, 1/3, 3/2), 79 masters, 1240 rational entries P(d)/Q(d) in d; `SEEDED_compare_x8o1_y1o3_z3o2_20260909T105706Z.json` d630196357620976… (as run 73f0f38db157466b…; 1 label field withheld; every figure as emitted) — the compare receipt of record, exact in rational arithmetic over Q(sqrt k) at three rational eps (d = 890/223, 386/97, 7/3): `blocks_tested` 28, `L0_strict_pass` 12 (the first line's rotation and residues verbatim), `L1_rescaled_pass` 12, `blocks_T_liftable_by_letters` 15, `L0b_lifted_pass` 15 (the rotation lifted letter by letter: every liftable block agrees exactly; `blocks_passing_L0b` = 98, 225, 231, 262, 294, 322, 353, 358, 359, 384, 388, 416, 480, 484, 486), `blocks_T_not_liftable` = 161, 167, 227, 321, 326, 327, 354, 355, 420, 422, 423, 455, 485 (13 blocks whose first-line rotations carry apparent singularities or eps-dependent roots; all fail L0, their mismatch classes under `diag`), `entries_pass_L0_at_sample0` 44 of 100; `PREDICTION_P6_x8o1_y1o3_z3o2_20260909T102252Z.json` 44caa06ba2278902… (as run cdc147ea980510d8…; 1 label field withheld) — the pre-registered prediction, stamp 2026-09-09T10:23:05Z, before the point existed (the compare's stamp 2026-09-09T10:57:06Z): `predicted_L0b_pass` (15) and `predicted_L0_fail_not_liftable` (13) equal the sets the compare found, element for element; `SEEDED_negative353_landed_p_20260909T105728Z.json` 951f36c1116b4e0d… (byte-identical to the object as run) — the negative control: block 353's residue entry (0,0) shifted by +1 → `L0b_lifted_pass` 14 of 15, block 353 in `blocks_failing_L0`, `negative_control_as_expected` True, every other block unchanged. - THE ROW SCRIPT `seeded_blocks_P6.py` 1b8a8d0fafba55fa… — a register succession of the script as run 38f3546597ef21cc… (the `PRODUCER.script_sha256` of the compare receipt and of the prediction; the copy the compare's launcher ran, found in its stamped directory): one trailing comment re-cut to `# withheld`, no other byte moved (masked AST 29 of 29 units identical in place, code units identical). It reads its seed and its evaluator under the directory named by `P6_LANE`, so the group carries them in the layout it expects: `scripts/vendor/verify_epsform_point.py` 857543b36073fe10… (the record evaluator byte for byte), `basis/T4_ALPHABET.json` 3cb2bef9b2e5554a… (as run 5bdeb22885698b7a…; 3 narrative fields withheld, every letter as emitted), `basis/laneF/BLOCK_EPSFORMS.json` 8dc50e8b35d96594… and the 28 `basis/laneF/blocks/out_b.json` engine files (the July line-1 record objects byte for byte — the same T, Atilde, rows, masters and residues, block for block, as the bundle's `row35_L1/blocks_epsform.json`, whose per-block `source.sha256` names its own later engine run's out files, so the seed ships in the form the script reads). `seeded_blocks_P6_negative_block.py` 218563bdfd4ba416… (as run 04e679ae945179e6…; the same one-comment re-cut) is the later revision that wrote the negative control (`--negative-block SEC`), vendored for that control's reproduction, not the row script. - REPRODUCTION FROM THE SHELF (measured on copies, one 200 % scope each, exit 0): `P6_LANE="$PWD" python3 seeded_blocks_P6.py --mode compare --point '8 1/3 3/2' --apoint A_point.json --out ` (0:01.39) writes a receipt equal to the vendored compare receipt on every figure leaf (1660 leaves; 0 figure differences; the 5 differing leaves are the stamp, the label, the connection's path as given, the alphabet's sha256 and the script's sha256) and prints `L0 12 / 28 | L1 12 | lifted 15 / 15`; `--mode predict` reproduces the prediction (856 leaves, 0 figure differences; 0:01.23); the revision with `--negative --negative-block 353` reproduces the negative control (1672 leaves, 0 figure differences; 0:01.25). Controls: one entry of a copy of `A_point.json` (the diagonal entry of block 353) shifted by exactly 1 → L0 11 of 28, L0b 14 of 15, block 353 failing by name with an eps-independent delta of 1 (0:01.28); the positive control `--mode control-L1 --y 29/211` on the bundle's own `row35_data.json` (its `A_entries` equal leaf for leaf to the connection the record read) → L0 28 of 28, entries 100 of 100 (0:01.30). - NO CHANGE TO `eval_row35.py` (f1ad409f4f080254…): it reads nothing in the group; `--help` on the bundle with the group present is byte-identical to the served run (0:00.23); every value, exact and census tier is untouched (the same bytes). Every one of the 41 served rows of `MANIFEST.sha256` is unchanged. - Not established here: the two-variable form (open); the transport to the point (not bounded at one point); the 13 non-liftable rotations off the first line; any value of the integrals at this point. - `MANIFEST.sha256` (was 2665b2716b2c3e4b…): re-emitted by the bundle's generator with the 39 rows of `vendor_row35_p6_point/` as a group (one role line per file in the header, one row per file); every served row kept; `sha256sum -c MANIFEST.sha256` OK in the bundle directory; `sha256sum -c VENDOR_MANIFEST.sha256` OK in the group. ## 2026-09-10 — sector 487 is an eps-factorised dlog form in the basis with [1,1,1,-1,-1,1,1,1,1] in place of [1,1,1,-2,0,1,1,1,1]: the canonical-basis census of both lines succeeds (28 OK / 7 stopped (3 Moser-irreducible + 4 eps^0) / 1 elliptic -> 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic), `row35_L1/blocks_epsform.json`, `row35_L2/blocks_epsform.json`, `row35_L2/canonical_gauge_L1_L2.json`, `row35_L2/lines.json`, `eval_row35.py` (its pins, stop classes, walls and census literals; no value path) and `qqww-t4-expression.md` re-pinned by succession with the previous bytes under `superseded_607ae4316fabaaee/`; `vendor_row35_sec487/` added as a data shelf; `MANIFEST.sha256` re-emitted - THE EFFECT (the object fact): on each line, the sector-487 block (rows 75-78; masters `wpairT4[1,1,1,0,0,1,1,1,1]`, `wpairT4[1,1,1,-1,0,1,1,1,1]`, `wpairT4[1,1,1,-2,0,1,1,1,1]`, `wpairT4[1,1,1,0,-1,1,1,1,1]`) stops in the eps-factoriser in the Laporta basis carrying [1,1,1,-2,0,1,1,1,1] -- the served stop string `input not Fuchsian and Moser reduction failed: all higher-order poles are stuck (no kernel/cokernel shear reduces rank) — Moser-irreducible or needs full Barkatou pencil` -- and is an eps-factorised dlog form in the basis with [1,1,1,-1,-1,1,1,1,1] in its place: an exact cut reduction on each line (the cut-IBP dictionary C of the dictionary receipts, det C = `-66*(d - 3)/(125*d - 434)` on the first line and `-18*(d - 3)/(37*d - 130)` on the second) followed by a rational rotation (the transcribed rotation with r1 = r2 = 1). The source of the effect is the basis of the audited external computation, [1,1,1,-1,-1,1,1,1,1] in place of [1,1,1,-2,0,1,1,1,1]. The eps-factoriser named by the census's sources field (runner 6e497c73cda9a1da, verifier 857543b36073fe10, Normalize.jl 4c5772a76f92d0d2, Fuchsia.jl 8a8c7369f13e5dcb; the instrument receipt's match fields all true) returns ok on the g-basis block of both lines (report already_epsform true, T = identity relative to that block, t_factor 6.0 s / 7.5 s), with the two letters `18*x^2 + 93*x + 50` and `18*x^2 + 93*x + 203` on the first line and `16*x^2 + 80*x + 49` and `16*x^2 + 80*x + 185` on the second, no rational pole, and the residue at infinity `[['8/3', '0', '0', '8/3'], ['0', '0', '0', '0'], ['0', '0', '0', '0'], ['-2/3', '0', '0', '-2/3']]` on both lines (equal); the served verifier passes at (eps, y) = (1/223, 29/211) and (5/6, 17/139) on both lines (PASS / PASS). Controls in the same run: the served block reproduces the served stop string verbatim (True / True); the I-basis alone (the dictionary without the rotation) stops at the eps^0 obstruction on both lines; the planted block (1/x^2 added to A[0][0]) stops with `input not Fuchsian and Moser reduction failed: irregular singularity at x = 0 (non-nilpotent leading matrix)`. - `row35_L1/blocks_epsform.json` (607ae4316fabaaee -> 21eb27ed546e582e, 47,786 -> 55,830 bytes) and `row35_L2/blocks_epsform.json` (35458111c3e5dbeb -> 71df8217cd2b071c, 47,566 -> 55,530 bytes): blocks[34] (sector 487) is an OK entry in the served OK-block form -- its `T` is S = T_transcribed . C, the transformation FROM THE SERVED BASIS, every entry cancelled to a rational function of x over Q(eps) and written in the engine's string grammar (p//q literals, ^ powers; column-major), so the tier's own identity T A T^-1 + T' T^-1 = eps Atilde against the served connection verifies the claim by itself (the identity also asserted symbolically over Q(eps)(y) at the build, and every T string read back by a copy of the tier's parser); `Atilde` is the engine's out (`out_b487_g.json`, sha256 5a5556dd0c29e420 / 494baa8865deb75e) verbatim; `letters`: poles [], the two quadratic factors as algebraic_factors, the served two-variable letter of the first quadratic, `quad_kernels` U / V by exact partial fractions over the integer-form quadratics (asserted symbolically and at both check points), `Rinf` the engine's inf matrix with the served convention Rinf == -(sum_q U_q / lead(q)) asserted before the write, and `quadratic_alphabet_letters` stating the two-variable form of each quadratic as a restriction check to the line; `basis_change` (the masters, C, det C, T_transcribed, S, the receipts by sha256, the engine report, the verifier verdicts) and `served_basis_stop` (the served entry's stop_class / stop / source verbatim, 'in the basis carrying [1,1,1,-2,0,1,1,1,1]') beside; `source` = the engine's out. The census: n_ok 28 -> 29, n_stopped 7 -> 6, ok_sectors + 487, stopped_by_class Moser-irreducible [417, 449, 487] -> [417, 449], line_text `29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic`; the what-text counts follow; sources gains p1c_receipt_sha256_16 875b7217badfe6e2 and live_receipt_sha256_16 e9ba6a61677fdec5. - THE RIPPLE. `row35_L2/canonical_gauge_L1_L2.json` (7c5943f498c4f654 -> 8aebbcc7f3a00ead): sources.blocks_epsform -> the succeeded files' sha256; blocks["487"] in the file's own OK form -- the two residues at infinity equal (True), G = the identity (computed and asserted a gauge: True), nullspace_dim 10 (the dimension of the constant matrices commuting with the residue at infinity, by exact row reduction), charpolys equal, the one residue pair `inf -> inf [infinity]`; the counts re-counted from the file: n_ok_both 29, n_residues_identical 24, identity_G_blocks 24, nontrivial_G_blocks [321, 327, 355, 227, 485] (unchanged), nullspace_dim_histogram {'1': 19, '2': 1, '4': 5, '9': 3, '10': 1}, n_stopped_both 6, residue_pairs 51 (38 equal, 51 conjugation-verified); the what-text counts follow. `row35_L2/lines.json` (b0caa391d8241f95 -> ba95dd02f9e09675): per line the canonical_blocks block's sha256, bytes, n_ok, n_stopped, stopped_by_class, line_text and its gauge's sha256, bytes and identity_G_blocks (18 fields; every other byte as before). `eval_row35.py` (f1ad409f4f080254 -> 72e50dbe6dce0ff8): PINS_CANON (the two census files and the gauge file) and PINS_L2['row35_L2/lines.json'] follow; CANON_STOP_CLASSES 'Moser-irreducible' (417, 449, 487) -> (417, 449); CANON_WALL_S '2.66' / '2.63' -> '2.51' / '2.53' (the median of 3 fenced runs per line of the tier on the succeeded bytes: 2.64, 2.51, 2.51 s on L1, 2.6, 2.4, 2.53 s on L2); the census literals of the module docstring, the --canonical-blocks and L2-refusal help texts and the PASS print move to the new counts with the basis note in the paper's words; the masked syntax tree is identical on 128 of 129 top-level units, the one differing unit the CANON_STOP_CLASSES assignment (a three-element tuple -> two); no value path moves -- the quick default before / after is identical after masking the printed walls (0 differing lines, every one a wall figure; walls 0:18.91 / 0:19.64). `qqww-t4-expression.md` (ffd7c997b5067756 -> 9e5c98e6aad8dc4b): the block table's row 487 reads `dlog (in the basis with [1,1,1,-1,-1,1,1,1,1] in place of [1,1,1,-2,0,1,1,1,1]; Moser-irreducible only in the Laporta basis carrying [1,1,1,-2,0,1,1,1,1])`, the class legend lists 487 by its own clause instead of among the radical sectors, the heading and the traced count read 29 dlog / 6 radical / 1 elliptic and 36 blocks = 29 + 6 + 1, and the alphabet paragraph gains one sentence with the two letters of the sector-487 form on this line (7 lines replaced by 14); every other line as served. - THE EVALUATOR CHANGE, STATED: the note that accompanied this leg read 'no evaluator edit'. The served tier pins the two census files, the gauge file and lines.json by sha256 (PINS_CANON, PINS_L2) and hard-codes the stop classes and the census counts, so a data-only succession would leave `--canonical-blocks` refusing with rc 3 (a pin mismatch) on the succeeded bytes; the constants and literals above are the whole change, and no served VALUE moves (every value tier reads none of the moved files; the quick default is masked-identical). - THE TIER, BEFORE / AFTER (fenced copies, a foreign working directory): before, `# --line L1 --canonical-blocks: 28 OK / 7 stopped (3 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised block...` (rc 0 / 0; walls 0:02.49 on L1, 0:02.63 on L2); after, `# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised block...` (rc 0 / 0; walls 0:02.55 / 0:02.16); the b487 line on L1 `# b487 n=4 rows 75-78: OK | letters (none); quadratic 18*x^2 + 93*x + 203 [x*y + y**2 - 2*y*z + z**2], 18*x^2 + 93*x + 50 [x*y + y**2 - 2*y*z + z**2] | identity (1/223, 29/211) PASS, (5/6, 17/139) PASS; eps-free PASS; dlog partial fractions PASS; Rinf PASS | g` and on L2 `# b487 n=4 rows 75-78: OK | letters (none); quadratic 16*x^2 + 80*x + 49 [x*y + y**2 - 2*y*z + z**2], 16*x^2 + 80*x + 18...`; `--mutate` on both lines FAILS by name (rc 1 / 1: `# MUTATE CONTROL (L1): block b321 T entry (0,0) character 3 '2' -> '3' (one digit changed in memory; the shipp`); `--verbose` prints the two stop strings of 417 and 449 verbatim (6 stopped lines with the engine's string on L1). - THE EFFECT RECEIPTS of this succession: the engine re-run of the shelf's g block by a copy of the served runner inside the fence (ok True / True; Atilde, T, report and letters equal to the vendored out entry by entry: True / True; t_factor 6.6 / 6.8 s; the whole julia call 2:45.72 / 2:41.71 inside a 200 % scope: with HOME = the run directory the julia launcher found no channel file, installed julia 1.12.7 there and precompiled the packages before the run, so the compile is inside those walls and the run executed julia 1.12.7 against the engine sources the census names, not the 1.12.6 the instrument receipt names; a second re-run of both blocks with the julia 1.12.6 binary the instrument receipt names (rc 0 / 0; walls 0:16.71 / 0:16.28; t_factor 6.5 / 5.9 s) equal to the vendored out entry by entry on both lines); the served verifier on the shelf's g block and out: PASS rc 0 on both lines, the row-major control FAIL rc 3 (verifier_L1 rc 0, verifier_L1_rowmajor_control rc 3, verifier_L2 rc 0). - NEW `vendor_row35_sec487/` (43 files; README.md names each and gives the reproduction commands): 33 of the 34 rows of the manifest of record (329c350fced45e93: the two dictionary receipts, the instrument receipt, the run receipts, the eight engine outs and their logs, the two verifier receipts and logs, the two statement objects, the sweep, the two logs, the two scripts) plus the eight block inputs the instrument receipt pins by sha256 in its files field (not rows of the manifest of record: stated); every object re-cut by field / line under the bundle's release rule (14 byte-identical; the record note of the emission named by the manifest of record is not on the shelf); `VENDOR_MANIFEST.sha256` (86394dfa537f424b) pins the group's bytes and names every original by sha256 in its header. - `superseded_607ae4316fabaaee/`: the previous bytes of the six succeeded files under their bundle-relative names, with README.md (what changed, by sha256, from -> to) and SHA256SUMS (7 rows; `sha256sum -c SHA256SUMS` inside it, rc 0); an unpinned companion named in the manifest header, not a manifest row. - SERVE ORDER: this entry applies on the bundle that carries `vendor_row35_p6_point/` (the one-point shelf: MANIFEST.sha256 69037a759cbead2e, CHANGES.md dc6900da273352ba); on the bundle served before that shelf (MANIFEST.sha256 2665b2716b2c3e4b) the manifest re-emitted here would list the 39 files of that group as absent. Sector 481 and the one-point shelf are untouched by this entry. - `MANIFEST.sha256` (was 69037a759cbead2e): re-emitted by gen_manifest_sha256_v10.py (the one-point shelf's generator plus the second group, the seven re-pinned rows and the unpinned-companion line): 80 + 43 rows, the seven rows above moved, every other row byte-identical; `sha256sum -c MANIFEST.sha256` OK in the bundle directory, `sha256sum -c VENDOR_MANIFEST.sha256` OK in the group. - Not established here: the two-variable form of the sector-487 block (each census entry is a statement on its line by itself); any value of the integrals (no value tier reads the moved files). ## 2026-09-10 — sector 481's label re-scoped to its maximal-cut curve: the curve is elliptic (j non-constant in z5) while the sector's eps^0 block is REDUCIBLE TO FIRST ORDER — a chain of six exact hyperexponential factors on both served lines and along two mass-scaling rays; `row35_L1/blocks_epsform.json` and `row35_L2/blocks_epsform.json` succeed (the what clause and a new `sector_481` entry carrying the chain receipt; the census counts unchanged), `row35_L2/canonical_gauge_L1_L2.json`, `row35_L2/lines.json`, `eval_row35.py` (its pins and four label literals; no value path) and `qqww-t4-expression.md` re-pinned by succession with the previous bytes under `superseded_21eb27ed546e582e/`; `qqww-t4-sec481-chain.py` added as the row's "verify the chain" script with its two effect receipts; `vendor_row35_sec481/` added as a data shelf; `MANIFEST.sha256` re-emitted - THE OBJECT FACT: the served text now reads (Sec. 2.18) "(sector $481$) has an elliptic maximal-cut curve: its fibrewise curve has non-constant $j$ (an order-two Picard--Fuchs operator in the fibre variable $z_5$; $j$ non-constant along the mass-scaling ray as well), while its $\eps^0$ differential-equation block is reducible to first order." The first-order factorisation of the sector-481 eps^0 block (rows 54-59; masters `wpairT4[1,0,0,0,0,1,1,1,1]`, `wpairT4[1,-1,0,0,0,1,1,1,1]`, `wpairT4[1,0,-1,0,0,1,1,1,1]`, `wpairT4[1,0,0,-1,0,1,1,1,1]`, `wpairT4[1,0,0,0,-1,1,1,1,1]`, `wpairT4[1,-2,0,0,0,1,1,1,1]`) at d = 4 in the line variable y returns REDUCIBLE_TO_FIRST_ORDER with 6 factors and remainder rank 0 on the first line ((x, z) = (17/2, 5/3); receipt a0e2ca3ad58b9627, wall 164.489 s) and REDUCIBLE_TO_FIRST_ORDER with 6 factors and remainder rank 0 on the second ((17/2, 7/4); receipt c9865676ce7c75eb, wall 159.928 s); along the mass-scaling rays P and E (the eps^0 block over Q(lam)) likewise REDUCIBLE_TO_FIRST_ORDER / REDUCIBLE_TO_FIRST_ORDER with 6 / 6 factors (receipts 1f0966cdba026953 / ac0fbc4280da4f74). The exponents lie in (1/2)Z: on L1 the exponent -3/2 at the conic quadratics `y**2 + 358*y/15 + 19801/225` (factor 3); `y**2 - 203*y/15 - 7751/900` (factor 5), integers elsewhere; two rational solutions (the rates u'/u of factors [1, 2] are 0); on L2 the exponent -3/2 at `y**2 - 185*y/14 - 7663/784` (factor 3); `y**2 + 325*y/14 + 63737/784` (factor 5), the rational solutions at factors [1, 2]. The record's certified thimble column lies in the chain's solution space: 39.89 digits by the full transport (dps 60 and 90 alike; a perturbed thimble 20.61), the last factor's closed-form transport 39.04 digits (a planted wrong exponent 1.61); the gauge to the chain upper-triangular exact with the chain rates on its diagonal (thimble receipts ce0bfd3610401724 / bd0fcdc21b7a8037; the thimble re-evaluated at dps 40, DE-certified 39.37 digits at y = 1/3). The maximal-cut curve is unchanged: elliptic, j non-constant in z5 (the X_0(2) material of the expression file stands). A REDUCIBLE verdict is exact whatever the candidate bounds (every factor an exact hyperexponential solution, the quotient asserted); the search was bounded (the blocks are not Fuchsian at infinity) -- the bounds weaken a negative verdict only. - `row35_L1/blocks_epsform.json` (21eb27ed546e582e -> cb024530118f65af, 55,830 -> 84,629 bytes) and `row35_L2/blocks_epsform.json` (71df8217cd2b071c -> d2ab2c1ab2d072e3, 55,530 -> 83,796 bytes): the what clause `sector 481 is the elliptic sector (rows 54-59, n = 6), not run` -> `sector 481 (rows 54-59, n = 6): the maximal-cut curve is elliptic (j non-constant in z5); the eps^0 block is reducible to first order -- six exact hyperexponential factors, see the sector_481 entry`; a NEW top-level key `sector_481` beside blocks[] (the sector is not a blocks[] entry: not run through the eps-factoriser) carrying the label, the maximal-cut curve statement in the served words, `eps0_block_chain` = the line's chain receipt (verdict, size, remainder_rank, the six factors verbatim -- exponents per singular factor, degree_bound, P, n_solutions_at_this_exponent, rate_u_prime_over_u, rate_partial_fractions -- the search log, the bounds EB 3 / NB 12 / MAXCOMBO 20000, sympy 1.14.0, python_flint 0.8.0, wall_s; the input = the served connection by basename + sha256; the receipt by vendored and original sha256), `rays` (the two ray blocks and their chain receipts by sha256 with their verdicts), `controls` (the S-vs-N control, the thimble receipts with their figures, the served script's built-in C1-C4) and `provenance_scripts`; the form header gains the key `sector_481` describing the entry. census.elliptic_not_run {"sector": 481, "rows": [54, 59], "n": 6} and the census line `29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic` UNCHANGED (the sector is still the one not run through the eps-factoriser; the count keeps one such sector); every block entry byte-identical (the object diff: form/sector_481 (added), sector_481 (added), what). - THE RIPPLE. `row35_L2/canonical_gauge_L1_L2.json` (8aebbcc7f3a00ead -> f6f43002a32b342c): sources.blocks_epsform -> the succeeded files' sha256 (sources/blocks_epsform/row35_L1/blocks_epsform.json, sources/blocks_epsform/row35_L2/blocks_epsform.json); no block and no count moves (counts unchanged True, blocks unchanged True). `row35_L2/lines.json` (ba95dd02f9e09675 -> 832888a4cac190b5): per line the census file's sha256 and bytes and the gauge file's sha256 (6 fields: lines/L1/canonical_blocks/bytes, lines/L1/canonical_blocks/gauge/sha256, lines/L1/canonical_blocks/sha256, lines/L2/canonical_blocks/bytes, lines/L2/canonical_blocks/gauge/sha256, lines/L2/canonical_blocks/sha256; the gauge's byte count does not move); elliptic_not_run 481 and every label text as before (lines.json carries no 'elliptic sector' text: []). `eval_row35.py` (72e50dbe6dce0ff8 -> 246b0990a28e170a): PINS_CANON (the two census files and the gauge file) and PINS_L2['row35_L2/lines.json'] follow; the four LABEL literals move -- the module docstring's `(sector 481, the elliptic sector, is outside any dlog form and was not run)`, the CANON_ELLIPTIC comment `the elliptic sector, outside any dlog form (not run)`, the sec481 transport comment `The sec481 elliptic block stays on transport`, the tier's print `sector 481 elliptic (not run)` -> the maximal-cut curve is elliptic, the eps^0 block reducible to first order, not run through the eps-factoriser; 8 replacements; the masked syntax tree IDENTICAL on every one of the 129 top-level units ([] differing; text-changed units ['ModuleDocstring', 'Assign:PINS_L2', 'Assign:PINS_CANON', 'FunctionDef:canonical_blocks']); the census prints `35 non-elliptic diagonal blocks` and `/ 1 elliptic` unchanged; no value path moves -- the quick default before / after is masked-identical (0 differing lines; walls 0:19.54 / 0:20.30), --help masked-identical (0 differing lines). `qqww-t4-expression.md` (9e5c98e6aad8dc4b -> 190aafb48291bf0c): the block table's row 481 reads `elliptic maximal-cut curve (the eps^0 differential-equation block is reducible to first order: six exact hyperexponential factors on both lines)`, the class legend and the section heading (its label re-cut to the served paragraph title's words, `the sector-481 block with an elliptic maximal-cut curve`; its X_0(2) tail as before) follow the served words, and the section gains the chain sentence with the objects named (4 replacements, 5 lines replaced by 18); the heading count `(29 dlog / 6 radical / 1 elliptic)` and `36 blocks = 29 + 6 + 1` kept (the one sector with the elliptic maximal-cut curve); the X_0(2) material and every other line as before. - THE EVALUATOR CHANGE, STATED: the note that accompanied this leg read 'eval_row35.py UNCHANGED (values do not move)'. No served VALUE moves. The served tier pins the two census files, the gauge file and lines.json by sha256 (PINS_CANON, PINS_L2), so a data-only succession would leave `--canonical-blocks` refusing with rc 3 (a pin mismatch) on the succeeded bytes; the four pins and the four label literals above are the whole change (masked syntax tree identical on every unit). - THE SERVED SCRIPT `qqww-t4-sec481-chain.py` (be4a21ee8fe9e839, 467 lines): a SUCCESSION of the script of record p2_reducibility.py (2eb65015d73bce59; vendored as text under vendor_row35_sec481/scripts/) as the row's "verify the chain" entry point -- the value path (the singular factors, the candidate exponents from the residue eigenvalues, the FLINT nullspace, the gauge quotient and the iteration, the four controls C1-C4, the served-block extraction at d = 4) IDENTICAL by masked syntax tree and byte for byte (17 units: stamp, sha, singular_factors, inf_order, rational_roots, residue_exponents, inf_exponents, poly_solutions, find_hyperexp, quotient, reduce_chain, controls, served_L1_block, R, EB, NB, MAXCOMBO); the units that differ: the module docstring and main (argparse: --controls, --line L1|L2, --block, --reference, --out, --tag; the inputs resolved from the script's own directory with row35_data.json and row35_L2/connection_L2.json pinned by sha256 and refused by name on a mismatch, rc 2; the two vendored ray blocks pinned likewise; --out default a fresh directory under the working directory, refused inside the bundle; the receipt's producer and inputs by basename + sha256, the recipe citation kept; exit 0 iff REDUCIBLE_TO_FIRST_ORDER and, with --reference, the chain equal to the reference factor by factor -- exponent lists and rates deciding, the partial fractions, degree bounds, P vectors and solution counts reported -- else 3), plus 17 added helper units (the pins, the refusal, the comparison, the O_EXCL receipt writer); the record's --served-planted form (the served block (+) the Legendre companion under NB 8 / MAXCOMBO 400: 1773.074 s on an 1800-s clock, exit code 7 -- NO_FIRST_ORDER_FACTOR_BOUNDED_REMAINDER_RANK_5 after 3 factors, the expected rank-2 remainder after six factors not reached inside the truncated candidate set) is DROPPED: `--planted-served` refuses by name with those figures; the seconds-class planted control is C1 of --controls. - THE EFFECT RUNS of the served script on these bytes (fenced copies, a foreign working directory; every chain leaf equal to the vendored receipt of record leaf by leaf: 404 / 404 / 372 / 372 leaves compared on L1 / L2 / P / E, 0 mismatched; the differing leaves are the stamps, the tag, the mode, the producer, the input's basename form, the wall and the reference block): --controls rc 0, wall 0:03.25, C1-C4 as expected; --line L1 --reference rc 0, wall 2:50.22 (receipt wall 169.516 s against the record's 164.489 s); --line L2 rc 0, wall 2:51.89 (171.176 s against 159.928 s); --block P rc 0, wall 1:18.85 (77.902 s against 72.939 s); --block E rc 0, wall 1:15.05 (74.367 s against 70.348 s); the pin-mismatch control (one byte of a copy of row35_data.json changed) refused by name rc 2; --out inside the bundle refused rc 2 (no directory written); --planted-served refused rc 2. The two --line receipts are served beside the script as its effect receipts: `qqww-t4-sec481-chain-run_L1_20260910T032257Z.json` (ece10d1430b5d58f) and `qqww-t4-sec481-chain-run_L2_20260910T032257Z.json` (a30836767d876e5c). - THE TIER, BEFORE / AFTER (fenced copies): before, `# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised blo...` (rc 0 / 0; walls 0:02.59 on L1, 0:02.62 on L2); after, `# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised blo...` (rc 0 / 0; walls 0:02.60 / 0:02.44); the objects line after reads `# L1 objects: 3/3 sha256 pins OK; row35_L1/blocks_epsform.json cb024530118f65af: 35 blocks on (x, z) = (17/2, 5/3), 29 factorised + 6 stopped, sector 481 with an elliptic maximal-cut curve (its eps^0 block reducible to first order; not run); row35_L2...`; `--mutate` on both lines FAILS by name (rc 1 / 1); the quick default before / after rc 0 / 0 masked-identical. - NEW `vendor_row35_sec481/` (18 objects + README.md + VENDOR_MANIFEST.sha256; README.md names each and gives the reproduction commands): every one of the 18 rows of the manifest of record (e47e6f65a402f1e8) -- the two ray blocks and their chain receipts (rays/), the two served-line chain receipts and the S-vs-N control (lines/), the thimble receipts (thimble/), the four run receipts (receipts/), the two statement objects (statements/, written as STATEMENT_SEC481_* / STATEMENT_SEC481_RESIDUE_*), the script of record and the two provenance scripts as text (scripts/); every object re-cut by field / line under the bundle's release rule (1 byte-identical); `VENDOR_MANIFEST.sha256` (d1edcfa6f2b0b1b1) pins the group's bytes and names every original by sha256 in its header. The run receipt S1 names p2_reducibility.py ff6b468659849861 -- the earlier copy of the factorisation script, which differs from the script of record 2eb65015d73bce59 in its --served / --served-planted line forms only; the manifest of record and every chain receipt name 2eb65015d73bce59. - `superseded_21eb27ed546e582e/`: the previous bytes of the six succeeded files under their bundle-relative names -- the bytes of this bundle's sector-487 succession staging, not yet served at this build -- with README.md (what changed, by sha256, from -> to) and SHA256SUMS (7 rows; `sha256sum -c SHA256SUMS` inside it, rc 0); an unpinned companion named in the manifest header, not a manifest row; `superseded_607ae4316fabaaee/` (the sector-487 succession's copy) stays as it is. - SERVE ORDER: this entry applies on the bundle that carries `vendor_row35_p6_point/` (the one-point shelf) AND `vendor_row35_sec487/` with `superseded_607ae4316fabaaee/` (the sector-487 succession: MANIFEST.sha256 44ea4e09808639ff, CHANGES.md f50bee680f8ee59b); on the bundle served before those two, the manifest re-emitted here would list their files as absent and the census files' sector-487 entries would be missing. The one-point shelf and the sector-487 objects are untouched by this entry. - `MANIFEST.sha256` (was 44ea4e09808639ff): re-emitted by gen_manifest_sha256_v11.py (the sector-487 generator plus the third group, the script row and its two effect-receipt rows, the seven re-pinned rows and the second unpinned-companion line): the seven rows above moved, every other row byte-identical; `sha256sum -c MANIFEST.sha256` OK in the bundle directory, `sha256sum -c VENDOR_MANIFEST.sha256` OK in the group. - Not established here: a Fuchsian form of the block (not needed on a positive verdict); the two-variable form of the sector-481 block (each chain is a statement on its line or ray by itself); any value of the integrals (no value tier reads the moved files). ## 2026-09-11 -- `vendor_row35_sec487/scripts/`: two record scripts re-quoted so that they parse; pins follow (no value, census or evaluator byte moves) - `vendor_row35_sec487/scripts/p1c_make_blocks.py` 7c6cf145e5aac260 -> d0638061c24b4779 and `vendor_row35_sec487/scripts/p1c_receipt.py` 576dc618dd5ffa63 -> 83eb8e58dfa76168: the one line `ROOT = '(the objects' directory ...)'` of the 2026-09-10 re-cut carried an apostrophe inside a single-quoted literal, so `python3 -m py_compile` failed on both files (they are provenance copies, not run from this shelf, and the defect was in the quoting alone); the literal is now double-quoted, the string it holds unchanged, every other line byte for byte (the parsed module equals the intended text statement by statement). - `vendor_row35_sec487/README.md` 38c8ee14055ad778 -> c5f9f7213a6c027a: the two 'served sha256' tokens of those scripts follow; `vendor_row35_sec487/VENDOR_MANIFEST.sha256` 86394dfa537f424b -> 929fbf4bb3a7a89e re-emitted by its generator of record (three rows and the two matching header comments moved; `sha256sum -c` exits 0). - NOT touched, stated: `vendor_row35_sec481/scripts/p2_make_config.py` (line 110, the same class of quoting defect in a re-cut note) still does not parse; its sha256 is cited inside `row35_L1/blocks_epsform.json` and `row35_L2/blocks_epsform.json` (sector_481 provenance_scripts), which `eval_row35.py` pins, so its re-quote rides the next entry that re-pins those census files rather than a cascade of its own. Every other `.py` of this bundle (19 of 20) passes `py_compile`. - `eval_row35.py`, both census files, the gauge file, `lines.json`, every data object: byte for byte. Smoke on these bytes: `python3 eval_row35.py --line L1 --canonical-blocks` exit 0 (0:02.41; `# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised block passes the exact identity T A T^-1 + T'`) and `--line L2 --canonical-blocks` exit 0 (0:02.24). - `MANIFEST.sha256` re-pinned by gen_manifest_sha256_v12.py (the re-pin form of the generators of record: five rows differ -- the four files above and `CHANGES.md` -- every other row and header line kept; `sha256sum -c MANIFEST.sha256` exits 0, 146 rows). ## 2026-09-11 -- eval_row35.py: the imaginary parts of the 36 complex rows get a served comparison tier (`--gate-im`, with `row35_reference_im.json` beside the script); the honesty notes count 36 complex rows and every compared eps-order; the `--point` / `--master` printer starts at eps^-3 on the rows that lead there; the `--check` line names what it compares; the sector-481 provenance script re-quoted so that it parses, its sha256 followed through both census files, the gauge file, `row35_L2/lines.json` and the script's pins, the previous bytes under `superseded_246b0990a28e170a/`; two wording pairs (`qqww-t4-expression.md` line 25, the script's docstring); `MANIFEST.sha256` re-emitted, one role line re-cut - THE COUNT. The honesty note of `eval_row35.py` read `the imaginary parts of the ~12 complex rows are certified separately`; by object, 36 of the 79 rows are complex on the line (|Im| > 1e-30 |Re| at some reference order): rows 19-22, 27-29, 33-35, 39-44, 54-59, 63-68, 70-73 and 75-78 -- the same 36 in the boundary constants of `qqww-t4-boundary.json`, at every node of the certified node bank and in both independent reference runs. The note now reads: `36 of the 79 rows are complex on the line (...), and their imaginary parts are compared separately against the complex reference values (--gate-im below; the connection is real-rational, so Re and Im solve the same equation)`. - THE COMPARED ORDERS. The note `Compared eps-orders: -2..1` under-stated the served gate: `gate_point` compares every reference order below eps^2, and 11 rows lead at eps^-3 (rows 10, 11, 18, 21, 22, 40, 44, 52, 75, 77, 78; the leading-order census of the base-point expansion: eps^-3 x 11 / eps^-2 x 50 / eps^-1 x 12 / eps^0 x 6). The note now reads `every oracle order below eps^2 (eps^-3..eps^1; eps^-3 is present on 11 rows and is compared uncapped); the E4 certified-fan sub-window stays -2..1`; `KC_LO, KC_HI = -2, 1` carries the same note as a comment (the syntax tree does not move). - NEW `row35_reference_im.json` (20450635a86ddca6, 72,513 bytes): the imaginary parts of the independent reference values at y = 1/2 and y = 3/5 -- per row and eps-order the midpoint string of the reference run's imaginary part, in the row order and the [order, string] form of `row35_data.json`'s `gate_oracles`, whose strings are the same two runs' real parts (out_gate_y12.json 4c9904e575953c57 and out_gate_y35.json d518d56128753834, the certified recompute archive's reference runs already named in `row35_data.json`'s gate_oracles provenance; parsed with the house ball parser amf_result.py 3064ec57183ee85a, amf_ball midpoint strings cross-checked value by value against amf_laurent; the real-part strings equal `gate_oracles` string for string, 382 of 382 (row, order) pairs at each point; the row order equal to `masters`); the 36 complex rows listed with their criterion; sha256-pinned in the script (PINS_IM) and checked on every value run like the corner-row pins (rc 3 / rc 4 by name); a row of `MANIFEST.sha256` with its role line. `row35_data.json` is untouched (6acf455def673854): eleven files of this bundle name its sha256 -- `qqww-t4-sec481-chain.py` (a pin) and its run receipt `qqww-t4-sec481-chain-run_L1_20260910T032257Z.json`, `row35_L1/blocks_epsform.json` and `row35_L2/lines.json` (source citations), `vendor_row35_p6_point/README.md`, `vendor_row35_sec487/scripts/p1c_make_blocks.py` and five vendored record receipts (two under `vendor_row35_sec481/`, three under `vendor_row35_sec487/`) that cannot be re-pinned truthfully -- so the imaginary strings ride a file of their own beside it rather than a re-emission of it (the new file's provenance names that sha256 as a twelfth). - NEW TIER `--gate-im [--im-point y12|y35|both] [--im-control]` (the first line, like every value tier; `--line L2` refuses it, rc 2). The line connection is real-rational, so the imaginary part of the 79-vector solves the same equation as the real part: the tier seeds the SAME `transport()` (`leg_im`, the twin of `leg`: 24 legs per point from y = 1/3, 532 bits and order 60 at dps 40, all 79 rows) with the node bank's imaginary parts (dps160 sweep; the bank's manifest, two-precision certificate and compare-cache gates run first, as on every value run), re-extracts with the SAME `extract()` (20 fit + 4 verify nodes, dps_x 420), and compares on the 36 complex rows every reference order below eps^2 with the reference imaginary parts: relative digits per (row, order); a reference imaginary part below 1e-40 gscale (gscale = the row's largest real reference coefficient below eps^2) is a zero-class order where the transported |Im|/gscale must sit below 1e-30 (the served absolute zero floor); on the 43 real rows the transported |Im|/gscale must sit below the same floor; pass bar 37 d per complex row (the default tier's bar). Measured on these bytes under the build's 2-core fence: at y = 1/2: min 42.46 d (row 73 wpairT4[1,0,1,0,-1,1,1,1,1], eps^1; per order eps^-3 59.65 / eps^-2 55.55 / eps^-1 50.38 / eps^0 46.67 / eps^1 42.46), 30 zero-class orders at most 1.67e-52 of gscale, the 43 real rows at most 1.30e-147 (row 52), self-consistency (verify nodes) min over the complex rows 52.9 d; rc 0, GNU wall 5:09.81 (march 292.4 s at 8 legs a time, per-leg 38.6 / 75.8 / 167.5 s min / median / max, extract 2.3 s; max RSS 231056 kB); at y = 3/5: min 42.14 d (row 73, eps^1; per order eps^-3 59.64 / eps^-2 55.57 / eps^-1 49.90 / eps^0 46.61 / eps^1 42.14), 30 zero-class orders at most 1.64e-52 of gscale, the 43 real rows at most 1.13e-147, self-consistency min 52.9 d; rc 0, GNU wall 9:13.62 (march 533.4 s at 8 legs a time, per-leg 55.9 / 189.0 / 244.7 s min / median / max, extract 2.4 s, max RSS 233208 kB). The digits equal the comparison receipts of record figure for figure (worst 42.46 / 42.14 d at row 73 eps^1; per-leg walls there, one core per leg on a loaded host: 20-23 s to y = 1/2, 35-56 s to y = 3/5). - CONTROLS of the tier. `--gate-im --im-point y12 --im-control` negates row 54's imaginary seed (sector 481) at the q = 1013 node before the transport: rc 1, `# --gate-im: FAIL (IM CONTROL) -- y12 y=1/2: 20 complex rows below 37 d: row 54 wpairT4[1,0,0,0,0,1,1,1,1] -4.7d, row 55 ...` -- row 54 at -4.7 d, 20 complex rows below the bar (rows 54-59, 63-68, 70-73 and 75-78: sector 481 and the rows coupled to it downstream), the other 16 complex rows at their un-planted digits (unchanged); GNU wall 6:13.50. One digit of `row35_reference_im.json` changed in a copy: `--gate-im` rc 3 and the default tier rc 3, both `PIN MISMATCH: row35_reference_im.json sha256 ... != pinned 20450635a86ddca6...`. Refusals: `--gate-im --check` rc 2 (`--gate-im is a tier of its own ...`), `--line L2 --gate-im` rc 2 (the L2 refusal of the value tiers, which lists `--gate-im` among them), `--im-control` without `--gate-im` rc 2. - THE PRINTER. `--point` / `--master` printed eps^-2..eps^1 for every row; it now starts at the row's own leading order when that is eps^-3 (the quoted window -2..1 is always printed). `--master 0,10,22,44 --point 1/2` (rows 10, 22, 44 lead at eps^-3, row 0 at eps^-2; the 23-row closure): before 16 coefficient lines, after 19 -- the three added lines `wpairT4[1,1,1,0,0,0,1,0,1] eps^-3 -0.11764705882...`, `wpairT4[1,1,1,0,0,1,0,1,-1] eps^-3 0.431372549019...`, `wpairT4[1,1,1,0,0,1,1,1,0] eps^-3 0.004488896694...` (coefficient strings cut here at 14 characters) -- every common line byte for byte, the header line reworded; rc 0 / 0, GNU walls 1:27.62 / 1:25.78. - THE `--check` LINE. Two bank-seeded passes print the same 80-digit coefficient strings at any dps (one node bank, one node design, deterministic truncation), so the served `# --check agreement: 999.0 digits (floor: printed-coefficient precision / arithmetic; truncation errors are deterministic and cancel)` was a count of nothing; the line now reads `# --check: identical at the capped 40-digit claim -- the dps 40 and dps 100 passes print the same coefficient strings over the quoted window (the printed digits of this path do not depend on dps); the two-precision certificate of this path is the node bank's 124.2 d (its dps130 and dps160 sweeps, compared at load)` (the 124.2 d read live from the bank's certificate at load; a non-identical pair would still print its digit count). `--check` rc 0 / 0 before / after, GNU walls 1:11.13 / 1:12.10, every other line masked-identical. - THE WORDS. `qqww-t4-expression.md` 190aafb48291bf0c -> e8a4b6630b2a1fb3: line 25 `76 canonical masters + 3 sector-487 auxiliaries` -> `76 master integrals + 3 sector-487 auxiliaries` (the 76 are the master integrals of the reduction; the script's docstring already counted `76 master integrals`); every other line byte for byte. The script's docstring: `the branch (fig 1d) that the planar computation of arXiv:2409.08879 set aside` -> `... did not treat`. The `--line L2` refusal text lists `--gate-im` with the other value tiers it refuses (`(default, --point, --gate/--gate-full, --gate-im, --master, --check, --cached)`); a string only, the syntax tree does not move. Measured on these bytes after the three text edits, under the same 2-core fence: the quick default rc 0 (GNU wall 0:22.60; its 13 printed lines masked-identical to the run above), `--line L1 --canonical-blocks` / `--line L2 --canonical-blocks` rc 0 / 0 (0:02.99 / 0:02.79), `--canonical-blocks --mutate` rc 1 by name, `--line L2 --gate-im` and `--line L2` rc 2 / 2 with the new list, `--gate-im --check` rc 2, `--help` rc 0, `--gate-im --im-point y12` rc 0 (GNU wall 4:51.36; min 42.46 d at row 73 eps^1, per order eps^-3 59.65 / eps^-2 55.55 / eps^-1 50.38 / eps^0 46.67 / eps^1 42.46 -- the figures above, digit for digit; max RSS 226160 kB). - `vendor_row35_sec481/scripts/p2_make_config.py` fdb609b15e61c31a -> f470c0f68ab3e848: line 110 carried an apostrophe (`that computation's point`) inside the single-quoted `'note'` literal of the 2026-09-10 re-cut, so the file did not parse (SyntaxError: unterminated string literal (detected at line 110)); the literal is now double-quoted, the string it holds unchanged (the parsed module carries it as exactly one constant), every other line byte for byte; `python3 -m py_compile` passes. Every `.py` of this bundle now parses: 21 of 21 (the 20 of the base plus the superseded evaluator copy). - THE RIPPLE of that sha256. `row35_L1/blocks_epsform.json` cb024530118f65af -> edbc1f375f48699b and `row35_L2/blocks_epsform.json` d2ab2c1ab2d072e3 -> 90bc8a28c9fa2cd8: `sector_481.provenance_scripts[1].vendored_sha256` only (84,629 / 83,796 bytes, unchanged; every block, count, label and string byte for byte); `row35_L2/canonical_gauge_L1_L2.json` f6f43002a32b342c -> 58ed5dfa4f2fc92b: `sources.blocks_epsform` (the two census shas); `row35_L2/lines.json` 832888a4cac190b5 -> f56f0fe7009dddb1: `lines.L1.canonical_blocks.sha256`, `lines.L2.canonical_blocks.sha256` and the gauge sha256 on both lines (4 fields; the byte counts do not move); `eval_row35.py` PINS_CANON (three) and PINS_L2['row35_L2/lines.json'] follow; `vendor_row35_sec481/VENDOR_MANIFEST.sha256` d1edcfa6f2b0b1b1 -> fa5dbfd8c03fe386 re-emitted by its generator of record (one row and the PRODUCER stamp moved, `sha256sum -c` rc 0); `vendor_row35_sec481/README.md` unchanged (it names the script's original sha256 only). - `eval_row35.py` 246b0990a28e170a -> 19e7a752eefd0ca7 (3986 -> 4351 lines). By masked syntax tree (string constants masked): 128 of the 129 base top-level units identical, the one changed unit `main` (argparse gains --gate-im / --im-point / --im-control; the tier's refusals and dispatch; the pin on every value run; the printer's lower bound; the --check line); 15 units added (IM_REF_FILE, IM_POINTS, IM_COMPLEX_ROWS, IM_BAR_D, IM_ZERO_ORACLE, IM_ZERO_FLOOR, IM_CONTROL, IM_LEG_WALL_S, PINS_IM, _im_pins, _im_reference, _bank_im_seeds, leg_im, gate_point_im, gate_im); none removed. Unmasked, the docstring, PINS_CANON and PINS_L2 change as well and nothing else: `transport`, `A_at_d0`, `parse_entries`, `leg`, `extract`, `run_point`, `gate_point`, `fan_certify`, `_bank_load_and_gate`, `_bndval_refresh`, `radical_overrides`, `canonical_blocks`, `verify_exact_L1/L2`, `check_expression` and every other unit byte for byte. The quick default before / after: rc 0 / 0, 13 printed lines masked-identical (walls only; GNU walls 0:27.58 / 0:30.32; `# CHECK y12 y=1/2: min 43.20d over 3 masters x orders -2..1 vs the independent reference values`); `--line L1 --canonical-blocks` rc 0 (0:03.00; `# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic`), `--line L2 --canonical-blocks` rc 0 (0:03.06), `--canonical-blocks --mutate` rc 1 by name. - `superseded_246b0990a28e170a/`: the previous bytes of the six succeeded files (`eval_row35.py` 246b0990a28e170a, `row35_L1/blocks_epsform.json` cb024530118f65af, `row35_L2/blocks_epsform.json` d2ab2c1ab2d072e3, `row35_L2/canonical_gauge_L1_L2.json` f6f43002a32b342c, `row35_L2/lines.json` 832888a4cac190b5, `qqww-t4-expression.md` 190aafb48291bf0c) under their bundle-relative names with README.md (what changed, from -> to, by sha256) and SHA256SUMS (7 rows; `sha256sum -c SHA256SUMS` inside it, rc 0); an unpinned companion named in the manifest header, not a manifest row; keyed by the previous evaluator's sha256 prefix; `superseded_607ae4316fabaaee/` and `superseded_21eb27ed546e582e/` stay byte for byte (the latter's README names the bytes now kept here as its successors: history, as printed). The previous `p2_make_config.py` bytes are not kept (they do not parse). - NOT DONE here, stated. (a) The optional leading-coefficient pins of rows 18, 21, 22 and 44 in `qqww-t4-boundary.json`: that file's pin schema is the ring pass's (`leading_coefficient_pin` with source `qqww-t4-ring-pass.json`, 22 exact rationals over the 40 transport-defined rows); the four rows lie outside that pass and two of the four values are weight-one logarithm forms, so they belong to a successor of the ring-pass object, not to an edit of the boundary file under the present schema; their eps^-3 coefficients are printed by `--point` / `--master` and compared by the gates. (b) The census files' `what` text: nothing to do (the 2026-09-10 successions already carry `29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic` with the elliptic maximal-cut curve wording). (c) `--gate-full` is unchanged (the imaginary comparison is a tier of its own rather than a leg inside it, so every documented figure and wall of the full suite stands). (d) The per-master and CHECK prints of the value tiers keep `orders -2..1`, the quoted window; the docstring states the eps^-3 comparison. - `MANIFEST.sha256` (was 182da8e60e0f8128): re-emitted by gen_manifest_sha256_v14.py (the re-pin form of the generators of record plus an added row, an added unpinned-companion line and a role line re-cut in place): 9 rows re-pinned (`eval_row35.py`, `row35_L1/blocks_epsform.json`, `row35_L2/blocks_epsform.json`, `row35_L2/canonical_gauge_L1_L2.json`, `row35_L2/lines.json`, `vendor_row35_sec481/scripts/p2_make_config.py`, `vendor_row35_sec481/VENDOR_MANIFEST.sha256`, `qqww-t4-expression.md`, `CHANGES.md`), the row `row35_reference_im.json` added after `row35_data.json` with its role line, the `superseded_246b0990a28e170a/` companion line added, the role line of `row35_L2/blocks_epsform.json` re-cut to that file's own census -- 29 blocks with an eps-factorised form, 6 stopped (2 Moser-irreducible + 4 eps^0), the sector_481 entry beside blocks[] -- where it had read `28 ... the 7 stopped blocks` since the 2026-09-10 sector-487 succession; 147 rows (was 146); every other row and header line byte for byte; `sha256sum -c MANIFEST.sha256` rc 0. This entry applies on the bundle whose `MANIFEST.sha256` is 182da8e60e0f8128 and `CHANGES.md` 9328fb80817fd50c (the 2026-09-11 sector-487 record-script re-quote, the previous entry). ## 2026-09-11 -- `row35_chain.tar.gz`, the boundary-regeneration chain that `--boundary-recompute` drives, is hosted beside the script (its text members re-cut for release; `containers.json` / `CONTAINERS.md` re-emitted; the evaluator's docstring, help and refusal text follow); sector 481: the full block's function class stated (`qqww-t4-expression.md` class column, block table, Sector 481 section; `eval_row35.py` docstring and one comment); the previous bytes under `superseded_19e7a752eefd0ca7/`; `MANIFEST.sha256` re-emitted with one new row - THE CONTAINER. `row35_chain.tar.gz` (sha256 7ee667ab9f1a586ab706d632ead3c8de9b249a94148d9a5be5431d3e43941244, 1,769,338 bytes) now sits beside `eval_row35.py` in this bundle: unpack it there with `tar xzf row35_chain.tar.gz`, which creates `row35_chain/` (763 members, every one listed with sha256 and size in `row35_chain/MANIFEST.sha256.json`; 1006 tar entries = 764 files + 242 directories). `--boundary-recompute` verifies every member against that manifest before any run, as before. The tarball is packed deterministically (members in the original order, owner 0/0 with empty names, the untouched members' original mtimes, one fixed mtime on the re-cut members, gzip without name or time stamp; a second pack reproduced the same bytes). It succeeds the container that `CONTAINERS.md` listed as available on request (f70bc8f7da19cca76e9906b2d201347b5f522585e8af13e30cda866bc48424a1, 1,769,919 bytes): 736 of the 763 listed members are byte for byte that container's; 27 text members and the member manifest differ, as follows. - THE RE-CUT (no solve path moved). The previous container was research code as recorded: comments, docstrings, two provenance notes and several default path constants named directories of the machine it was written on. For release, 175 line sites in 25 members were re-cut byte-exactly (only the named fragment of each line moves): 48 internal path / machine-location fragments became neutral provenance (e.g. `Source: AMFlow (C++ port), src/pipeline/amfsystem.cpp`; `Original generation (2026-07-01)`), 102 working-vocabulary words became neutral ones, 11 code default literals now resolve inside the unpacked chain (the gate driver `t4_chain.py`: TOOLS / HEXA_DEFAULT / HEXA_PARKED = its own directory, its fail-closed message re-worded to match; the production driver `production/t4_chain.py`: the T4_TOOLS / T4_HEXA / T4_DATA defaults = the chain directory above it, the env keys unchanged; `chain_transport.py`: TOOLS = its own directory, DEFAULT_AMF_ROOT = '' (the hexabox reduction tree its own command line reads is not part of the container: `--amf-root` must be given, and its command line now refuses by name, exit 2, when it is not: one guarded statement after its argument parser); `fastclosure_tested.py`: one `import os` + a sys.path line of its own directory; `extract/job_extract79.json`: `work_dir` = the relative directory name), and 14 adjacent lines were re-worded for grammar. Two members were replaced whole: `detransport/epsfan.py` is now the body of this bundle's served `epsfan_vendored.py` (adb8af7402ff538d) without its 3-line vendored-copy header -- the same file's public re-cut, already served beside the script (member sha256 a82c0847f6e17b36); `production/PROVENANCE.md` (a 10-line sidecar, 4 of whose lines were sites) was rewritten to keep the production driver's archived sha256 (c8e0054d741ea358..., the one `row35_nodes/PROVENANCE.md` names) and to state this re-cut, since the hosted copy's own sha256 is now the one the member manifest lists. By syntax tree with string constants masked, 19 of the 23 edited `.py` members are identical unit for unit to the previous bytes and the others differ only in the units named here (chain_transport.py: assign TOOLS, def main (that one refusal); fastclosure_tested.py: the sys.path statement (unit 3), import os, the sys.path statement (unit 2); production/t4_chain.py: assign TOOLS, assign HEXA, assign DATA; t4_chain.py: assign TOOLS, assign HEXA_PARKED, assign HEXA_DEFAULT); all 23 `.py` members of the hosted container parse (py_compile), as did the previous ones. `row35_chain/MANIFEST.sha256.json` was re-emitted in its own form (json, indent 1, sorted keys): exactly the 27 re-cut members' rows moved (2d7b1f180189b697 -> 3d0af25281bc1268). Register: the three patterns of the hosting receipt found 34 lines in 11 members before and 0 after; the house register lists over all 738 text members (50,708 lines) leave 0 unclassified lines after (173 before), with 289 lines classified as homonyms or identifiers (the Frobenius arrival of the march at eta = 0, the transport's base point, exponent / rung classes, Kira's own temporary output directories inside the vendored reduction (directories it names tmp), an English verb that coincides with a house term, the extraction engine's verify nodes, numbered algorithm steps). - `containers.json` a210d1ddcb05d611 -> a4ddadc81f743705 and `CONTAINERS.md` 9bbd303bdadff475 -> 957b0846588604a6, re-emitted by build_containers_v2.py (the successor of the pair's producer) from the bytes on disk: the `row35_chain.tar.gz` row keeps its role (`required by --boundary-recompute (all forms)`) and now carries the hosted container's sha256 / bytes / 763 members, an availability of its own (`hosted with the bundle (beside eval_row35.py; unpack there)`) and a register sentence stating the re-cut; the two sector containers and the regenerated node pair keep every field and stay `available on request until a Zenodo-class home exists` (each row now says so; the top sentence names which is which); `CONTAINERS.md` gains an availability column, the opening sentence and title to match, one note on the hosting, and keeps the mode table, the exit-code note and every other line. `eval_row35.py` reads the new pair unchanged in code: `--containers` with the tarball beside the script and not unpacked prints `row35_chain.tar.gz: present, sha256 OK (not yet unpacked)` (rc 0); `--boundary-recompute 60 --gate-bc-only` in that state exits 4 asking for `tar xzf row35_chain.tar.gz`; after `tar xzf`, `--containers` prints `unpacked as row35_chain/, 763/763 members verified` (rc 0). - THE TIER FROM THE HOSTED BYTES. `python3 eval_row35.py --boundary-recompute 60 --gate-bc-only` on a copy of this bundle with `row35_chain/` unpacked from the hosted tarball, under a 2-core fence with an empty environment (env -i; PYTHONPATH empty): rc 0, GNU wall 0:53.05, max RSS 170488 kB; `# CHAIN: row35_chain/ beside this script, 763/763 members verified against its sha manifest (row35_chain.tar.gz sha256 7ee667ab9f1a586a...)`; GATE-BC at the first grid eps, entries / mu / sub-values per system: system 2: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0); system 9: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0); system 11: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0); system 4: 39.7 / 40.0 / 39.7 d (recorded 39.7 / 40.0 / 39.7); system 1: 39.4 / 40.0 / 39.6 d (recorded 39.4 / 40.0 / 39.6); system 0: 39.4 / 39.4 / 39.6 d (recorded 39.4 / 39.4 / 39.6); the recorded GATE-D0 reports re-read from the verified chain directory; then the quick default value tier as always (`# CHECK y12 y=1/2: min 43.20d over 3 masters x orders -2..1 vs the independent reference values`). The capture carries no host-directory string: the drivers import `detransport`, `chain_transport` and `flint_march` from `row35_chain/` itself. Imported directly, outside the evaluator (which sets the chain's env keys itself), the four re-cut modules put no directory outside the unpacked chain on sys.path and resolve those imports inside it; the previous bytes, imported the same way on the build host, put 2 host directories on sys.path. Controls, by name: one byte of `row35_chain/ALGO_NOTES.md` changed -> `--boundary-recompute` rc 3 (`[boundary-recompute] row35_chain/ALGO_NOTES.md does not match row35_chain/MANIFEST.sha256.json (1 of 763 mismatching) — REFUSED; re-obtain row35_chain`) and `--containers` rc 3; one byte of the tarball changed (same size), not unpacked -> `--containers` rc 3 (`present, sha256 MISMATCH`) and `--boundary-recompute` rc 3 (`[containers] row35_chain.tar.gz: sha256 ... != manifest ...`); one member absent -> rc 4 (`[boundary-recompute] row35_chain/: 1 of 763 member(s) missing (first: fastclosure_tested.py) — unpack row35_chain.tar.gz`); the tarball and `row35_chain/` both absent -> rc 4 with the refusal text below. - `eval_row35.py` 19e7a752eefd0ca7 -> e98770f5d36cb9e4 (4351 -> 4357 lines), text only. Hosting: the docstring's `row35_chain.tar.gz` paragraph moves out from under `NOT HOSTED WITH THIS BUNDLE` to a new `HOSTED SEPARATELY IN THIS BUNDLE (unpack beside the script):` heading above it, text otherwise unchanged; the module comment of the containers section lists the chain as hosted beside the script and the two closed-form containers and the node pair as not hosted; the `--boundary-recompute` refusal (chain absent) now reads `... this mode needs the boundary-regeneration chain row35_chain.tar.gz (a download of this bundle, to be placed beside this script).` (was `..., which is not hosted with this bundle.`); the `--boundary-recompute` help reads `unpacked from row35_chain.tar.gz, hosted with this bundle, CONTAINERS.md` (was `the not-hosted row35_chain.tar.gz`); that refusal's status list, which includes the hosted chain, is headed `status of every container of containers.json beside this script:` (was `status of every not-hosted container beside this script:`); the chain-runner helper's docstring says the container directory is put first on the module path and its three modules are imported from it before the driver starts (the drivers carry no machine-default search path after the re-cut). Sector 481: the CANONICAL BLOCKS docstring sentence on why the elliptic sector was not run through the eps-factoriser gains `-- and its full block is regular singular with the exponent -3/2 at the chain's two conic letters, so no rational-letter eps-form exists on the line` (line 208), and the comment above the transport table gains `its full block admits no rational-letter eps-form on the line` (line 828). By syntax tree: all 144 top-level units identical with string constants masked (0 changed, 0 added, 0 removed); unmasked, exactly , def _chain_require, def _run_chain, def main differ (the docstring, string constants in the refusal / help, one helper docstring). Fenced on copies of the previous and the new bytes with `row35_nodes/` unpacked: the quick default rc 0 / 0 (GNU walls 0:21.07 / 0:19.12; `# CHECK y12 y=1/2: min 43.20d over 3 masters x orders -2..1 vs the independent reference values`), printed lines identical modulo walls (13 / 13); `--line L1 --canonical-blocks` rc 0 / 0 (0:03.00 / 0:03.07) and `--line L2 --canonical-blocks` rc 0 / 0 (0:02.54 / 0:03.16), identical modulo walls (`# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic`); `--check` rc 0 / 0 (1:02.42 / 1:06.60), identical modulo walls. - `qqww-t4-expression.md` e8a4b6630b2a1fb3 -> 7ae3afcd95a4a6b4, three sentences (333 lines, unchanged count). The served papers now state, for the sector-481 block on the first line: regular singular at every singular point; local exponents in Z + Z eps at every letter except the eps^0 chain's two conic letters 225y^2+5370y+19801 and 900y^2-12180y-7751, where the exponent is -3/2 independent of the dimension; hence no eps-factorised form with rational letters, an eps-form over the two conic square roots not excluded. The expression file carries the same clause in the class column's definition of the 481 class (line 127), in the block table's row 481 (line 163) and, with the two conics written out, in the Sector 481 section (line 257); the evaluator docstring as above. No value, pin, tier or data file changes for this clause. - `superseded_19e7a752eefd0ca7/`: the previous bytes of the four succeeded files (`eval_row35.py` 19e7a752eefd0ca7, `qqww-t4-expression.md` e8a4b6630b2a1fb3, `CONTAINERS.md` 9bbd303bdadff475, `containers.json` a210d1ddcb05d611) under their bundle-relative names with README.md (what changed, from -> to, by sha256) and SHA256SUMS (5 rows; `sha256sum -c SHA256SUMS` inside it, rc 0); an unpinned companion named in the manifest header, not a manifest row; keyed by the previous evaluator's sha256 prefix; the three older companions stay byte for byte (`sha256sum -c` rc 0 / 0 / 0). - NOT DONE here, stated. (a) The page's two sentence pairs and the write-up's `available on request` clause that wait on this hosting belong to the page and to the write-up, not to this bundle; they follow this install. (b) The evaluator's other `not-hosted` wordings (the usage line `--containers # status of the not-hosted containers`, the `--containers` help and docstring, the section comment's title) describe `containers.json` generically and stand; the two closed-form containers (about a gigabyte) and the regenerated node pair remain on request. (c) The census files' `sector_481` label could carry the same clause only through a re-emission of both `blocks_epsform.json` files and their pins; not proposed for a label. (d) `row35_fresh_pair.tar.gz` and the two sector containers are untouched (their rows keep every field). (e) The per-literal table helper of `row35_chain/detransport/gate.py` keeps its public function name (renaming it would be a code change); its docstring and two output labels were re-worded. The remaining internal notes in comments and docstrings of 17 members (working notes cited by slug, packaging vocabulary in one provenance header, four restoration-log phrases, the slang word for a silent-error trap, one threshold label) were re-worded to their technical content in a second pass -- 62 line sites in 16 members, 19 of them on lines of the first pass; two of those sites are message strings inside function bodies (the Zeno-abort text of `detransport/transport.py`, one reason string of that table helper), the rest comments, docstrings and markdown; the masked syntax tree of each of the 16 `.py` members among them is identical to its first cut except `chain_transport.py` (def main, the refusal above). One line of `detransport/epsfan.py` keeps that slang word where the served `epsfan_vendored.py` beside the script carries it (the member is that file's body). - `MANIFEST.sha256` (was 14d3ef88a768e36d): re-emitted by gen_manifest_sha256_v15.py (the re-pin form of the generators of record; v15 = v14 in behaviour): 5 rows re-pinned (`eval_row35.py`, `qqww-t4-expression.md`, `containers.json`, `CONTAINERS.md`, `CHANGES.md`), the row `row35_chain.tar.gz` added after `row35_nodes.tar.gz` with its role line (`the boundary-regeneration chain (763 members + its own sha manifest; unpack beside the script; drives --boundary-recompute)`), the `superseded_19e7a752eefd0ca7/` companion line added, the role line of `containers.json` re-cut (it had read `the files NOT hosted with this bundle`; it now names the hosted chain and the three files not hosted); 148 rows (was 147); every other row and header line byte for byte; `sha256sum -c MANIFEST.sha256` rc 0. This entry applies on the bundle whose `MANIFEST.sha256` is 14d3ef88a768e36d and `CHANGES.md` 98d3d11e3adfceb5 (the imaginary-part comparison tier, the previous entry). ## 2026-09-11 -- register re-cut: the hosted chain's text members, the served extraction engine, the evaluator's container wordings, one record-object phrase, one data-file convention string and seven record-object key names re-worded to their technical content (no value, pin-set, tier or figure change) - WHAT AND WHY. After the chain-hosting entry below, downloadable files of this bundle still carried working vocabulary and citations of internal design notes: inside the hosted `row35_chain.tar.gz`, comments and docstrings cited design notes, work-plan tags, result files and a speed-up plan by their working names, three unported-code markers were written as to-do notes (one in a docstring, two inside refusal messages), a slang word stood for a numerical pitfall, and the extraction engine's named error class was referred to by the design note's name; the served `epsfan_vendored.py` (whose body is that engine member, byte for byte) carried the same lines; `eval_row35.py` kept one such comment, one such docstring citation, and four generic 'not-hosted' wordings (usage line, `--containers` help and docstring, two section comments) that predate the hosting of the chain; one value of the sector-487 count statement named the page and script changes it defers by their working names, one convention string of the main-tower layers file carried a work-group tag, and seven vendored record objects carried a work-tree key named by a working word. Each site is re-worded to its technical content by exact byte replacement on its line (no line removed or added anywhere); no statement of any solve path, no value, no pin set, no tier and no figure changes. The history entries below were swept with the house register lists and needed no re-cut (their only flagged words are a served file name and the word for the write-up). - `row35_chain.tar.gz` 7ee667ab9f1a586a -> 89d64799b6ddda59d6971f4989003e10b8e21df142e2bd6bb88f5e56d8005185 (1,769,338 -> 1,769,154 bytes; 1006 tar members = 764 files + 242 directories, unchanged; 763 members listed in its own manifest). 62 line sites in 19 text members (chain_transport.py, detransport/__init__.py, detransport/acb_fast_attach.py, detransport/acbfast.py, detransport/boundary.py, detransport/conic_thirdkind.py, detransport/de_load.py, detransport/epsfan.py, detransport/frob_scalar.py, detransport/frobenius.py, detransport/gate.py, detransport/quad.py, detransport/ratfun.py, detransport/tailcut.py, detransport/transport.py, detransport/two_sector.py, flint_march.py, production/t4_chain.py, t4_chain.py): 54 in comments, docstrings and changelog text, 8 in message or label string constants inside function bodies or a module-level table (two refusal texts of detransport/boundary.py, the singular-point assertion text of detransport/transport.py at its two raise sites, the --targets usage error of chain_transport.py, the refusal constant and two diagnostic labels of detransport/epsfan.py) -- the same messages without the citation. By syntax tree with string constants masked every one of the 19 edited `.py` members is identical unit for unit to the previous member (0 changed, 0 added, 0 removed); unmasked, the units that differ beyond module docstrings are: chain_transport.py: , def main; detransport/boundary.py: def vacuum_ending_seed; detransport/de_load.py: class DESystem; detransport/epsfan.py: , assign _R0_REFUSAL, def eps_analyticity_radius, def cauchy_laurent_certified, def vandermonde_laurent_certified, def extract_node_counts; detransport/gate.py: def ; detransport/transport.py: , def , def . All 23 `.py` members parse (py_compile) before and after. `row35_chain/MANIFEST.sha256.json` re-emitted in its own form (json, indent 1, sorted keys): exactly the 19 re-cut members' rows moved (3d0af25281bc1268 -> 0c0e39e501323d1a). Re-packed with the hosting entry's deterministic recipe (members in the original order and header form, re-cut members stamped 2026-09-11T00:00:00Z, numeric owner 0, gzip mtime 0): two packs byte-identical; a fresh unpack verifies 763/763 against the member manifest and equals the edited tree file by file. detransport/epsfan.py stays byte-identical to the body of the served `epsfan_vendored.py` (asserted before and after the re-cut). Probes over all 738 text members (50,711 lines): the working-word list 9 -> 0, the design-citation list 60 -> 0; the house register lists leave 0 unclassified lines with 289 lines in the classes the hosting entry names (the Frobenius arrival term, the transport's base point, exponent classes, Kira's own temporary member names, the English verb, the engine's verify nodes, numbered algorithm steps). - `epsfan_vendored.py` adb8af7402ff538d -> 48272293d9a34b1d2f2c1c609960b43798f8a636ffe2b3841068a8daf983d406 (1610 lines, unchanged count): the same 15 line sites as the chain member at a three-line offset (its provenance header); masked syntax tree identical on all 27 units; unmasked exactly , assign _R0_REFUSAL, def eps_analyticity_radius, def cauchy_laurent_certified, def vandermonde_laurent_certified, def extract_node_counts differ (docstrings, the refusal constant, two diagnostic labels). `eval_row35.py` e98770f5d36cb9e4 -> 36dc34a92f00e588c71e6f66e8a76e276f2e40938645e4b2e25cf836479c3443 (4357 lines, unchanged count), 7 line sites: the usage line's `--containers` gloss, the `--containers` help text and the containers_cmd docstring now say 'the containers listed in containers.json' (the chain is hosted; the two closed-form containers and the regenerated node pair stay on request, and the docstring paragraph and the radical-fold comment that say so are unchanged because they are true); the two section comments likewise; the comment on the precision assignment after argparse names the pitfall plainly; the certified-fan docstring cites the E4 design rule instead of the note's working name. Masked syntax tree identical on all 144 units; unmasked exactly , def fan_certify, def containers_cmd, def main differ. - VALUE SAFETY (fenced 2-core scope, empty environment, scratch copies of the previous and the new bundle with `row35_nodes/` unpacked): the quick default rc 0 / 0 (GNU walls 0:19.15 / 0:17.05; `# CHECK y12 y=1/2: min 43.20d over 3 masters x orders -2..1 vs the independent reference values (never used in any fit; self-consistency min 53.1d, worst master wpairT4[0,1,0,0,0,1,1,1,1], 1 masters closed-form-folded — sectors 421/453 containers not beside this script (CONTAINERS.md), their masters ride the transport, wall 6.3s)`), printed lines identical modulo walls (13 / 13); `--line L1 --canonical-blocks` rc 0 / 0 (0:02.75 / 0:02.60) and `--line L2 --canonical-blocks` rc 0 / 0 (0:02.68 / 0:02.51), identical modulo walls (`# --line L1 --canonical-blocks: 29 OK / 6 stopped (2 Moser-irreducible + 4 eps^0) / 1 elliptic -- every factorised block passes the exact identity T A T^-1 + T' T^-1 = eps Atilde at both check points, Atilde eps-free, the dlog form from the shipped residues exact, the constant gauge to the other line verified on every letter; the six stopped blocks in their named classes [PASS] (wall 2.3s)`); `--check` rc 0 / 0 (1:00.95 / 1:00.58), identical modulo walls. - THE HOSTED TIER FROM THE NEW BYTES (hostile T4_* / ROW35_CHAIN_TRANSPORT values pointing at a nonexistent directory, PYTHONPATH empty): `--containers` with the container beside the script and not unpacked prints `# row35_chain.tar.gz: present, sha256 OK (not yet unpacked) — sha256 89d64799b6ddda59d6971f4989003e10b8e21df142e2bd6bb88f5e56d8005185, 1,769,154 bytes; required by --boundary-recompute (all forms)` (rc 0); after `tar xzf row35_chain.tar.gz`, `# row35_chain.tar.gz: unpacked as row35_chain/, 763/763 members verified — sha256 89d64799b6ddda59d6971f4989003e10b8e21df142e2bd6bb88f5e56d8005185, 1,769,154 bytes; required by --boundary-recompute (all forms)` (rc 0); `--boundary-recompute 60 --gate-bc-only` rc 0 / 0 (previous / new; GNU walls 0:48.14 / 0:49.63, max RSS 178132 / 176648 kB), `# CHAIN: row35_chain/ beside this script, 763/763 members verified against its sha manifest (row35_chain.tar.gz sha256 89d64799b6ddda59...)`, GATE-BC at the first grid eps, entries / mu / sub-values per system: system 0: 39.4 / 39.4 / 39.6 d (recorded 39.4 / 39.4 / 39.6); system 1: 39.4 / 40.0 / 39.6 d (recorded 39.4 / 40.0 / 39.6); system 2: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0); system 4: 39.7 / 40.0 / 39.7 d (recorded 39.7 / 40.0 / 39.7); system 9: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0); system 11: 40.0 / 40.0 / 40.0 d (recorded 40.0 / 40.0 / 40.0) -- equal to the previous bytes' run figure for figure and to the recorded values; 0 host-directory strings in the output. Control, by name: one byte of `row35_chain/ALGO_NOTES.md` changed in an unpacked copy -> `--boundary-recompute 60 --gate-bc-only` rc 3 (`[boundary-recompute] row35_chain/ALGO_NOTES.md does not match row35_chain/MANIFEST.sha256.json (1 of 763 mismatching) — REFUSED; re-obtain row35_chain.tar.gz (sha256 89d64799b6ddda59d6971f4989003e10b8e21df142e2bd6bb88f5e56d8005185, 1,769,154 bytes).`) and `--containers` rc 3. - `containers.json` a4ddadc81f743705 -> ede8fab2a65edb2df19e7622a14e6ddb851e5022a600cebe35210fd1641846a5 and `CONTAINERS.md` 957b0846588604a6 -> 0f6521b802e4edf42b0a50ae2613df87f03a9add238090fc6617b8ab9d568a49, re-emitted by build_containers_v2.py (the pair's producer of record, unchanged) from its base of record -- the pre-hosting pair kept under `superseded_19e7a752eefd0ca7/` -- with the new container: only the emitted stamp, the chain row's sha256 / bytes and the hosting note's sha256 / bytes move (4 lines of CONTAINERS.md; the fields containers/row35_chain.tar.gz/bytes, containers/row35_chain.tar.gz/sha256, emitted of containers.json); the same producer run with the previous container reproduces the previous pair except those stamps (checked first). - RECORD OBJECTS, BY FIELD. `vendor_row35_sec487/statements/STATEMENT_COUNTFOLD_v3_20260910T003746Z.json` a99f19ca899c37f2 -> 4b657896af3462dc0c25e30dc7c4718f29df8c2de0bd8d2a99d70d91bc74630d: one string of its NOT_ESTABLISHED list re-worded (the deferred page and script changes named by their working names -> 'the page and script changes ... a later addition to the page'); the structural diff against the previous object is exactly that value. `qqww-t4-tower12-layers.json` 98c9544a9218ac4d -> 34d88f8d3d56418f8f242169e5c991b319fb6a1055534e729a21e149e94f743a: one string under meta.conventions (the solution convention, line 34) re-worded, a work-group tag in parentheses after the boundary-column symbol BND[j][v] replaced by the words 'the boundary column'; the structural diff against the previous object is exactly that value and its json form (indent 1, insertion order, no trailing newline) is kept; no served script reads this file (the evaluator names it in its docstring's file list only), so no tier's output can move. Seven record objects carried a work-tree KEY whose name was a working word; the key now reads `source` at the same position with the same value (a directory basename), the structural diff exactly that key name, no served script reading it: `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_E_20260910T012709Z.json` b3d530d4c31c7415 -> e2048366d31bbf7b4820bd7e66b9a54582a3eb44968071c3485b3fbb60dbda92 (a top-level key); `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S1_20260910T011509Z.json` 6ac9e83852f743c1 -> ebdd1340ce55fba27bac0a347a8a09a66fdf7de7fa1cbc4cd6372255b584d822 (a top-level key); `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S1c_20260910T012117Z.json` 965a23b812d3e1a2 -> 66b465588ff8f3831fd0bcd9d44d8a7fed2f081d3bc10805617d5852d6a55d31 (a top-level key); `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S2R_20260910T012404Z.json` f7ec7ddf9d8c92cd -> 76b2d668d46690856de9867dc980fd7e2c1f3627c510d5afc704c0afef58ba9f (a top-level key); `vendor_row35_sec481/statements/STATEMENT_SEC481_20260910T021848Z.json` edc41ef0517cce6d -> 165403c73a51f3275ff3f67398dc40c38fb70eae2173aff0b00dff81d6e6640b (the key under prep_objects); `vendor_row35_sec481/statements/STATEMENT_SEC481_RESIDUE_20260910T022905Z.json` 05cd1c00d5ee90ca -> 9dcce30c28304d8cf6aff76ed7516a2c6d8788a94a5b580a9c286a578566daad (the key under prep_objects); `vendor_row35_sec487/receipts/LIVE_RECEIPT_P1C_20260910T003410Z.json` 192889c5695a7910 -> 7ac0dd48798db639ee2b8f9507bd0fbbacd5f4d4ec93fdc39c4769bf835c757f (a top-level key). Every object keeps its json form (indent 1, insertion order, no trailing newline). `vendor_row35_sec487/README.md` c5f9f7213a6c027a -> 1611808842fdb0b8dec69815f1323cae29535c07f86aaa8ae0245ec4fa1da2f9 (the served-sha256 clauses of the two sector-487 objects on lines 68 and 75; its re-cut rule sentence states both changes); `vendor_row35_sec481/README.md` c489a94cc2f72879 -> e60d1ea1cb4b6ce5435238eb8ba2de11b8ba9292d48ac36c3734e2d8d19bb5f2 (two sentences stating the key rename, lines 12 and 13; that README prints no served sha256 for these objects); `vendor_row35_sec487/VENDOR_MANIFEST.sha256` 929fbf4bb3a7a89e -> 8319bb403957c702a93e587406bb98718efd88dc0df3b860595bddd1f1262eb4 and `vendor_row35_sec481/VENDOR_MANIFEST.sha256` fa5dbfd8c03fe386 -> 0b576ccdab75baee2d20f179c8c174e643e081dff2641a3c942c84bb58bcd1d0 re-emitted by gen_vendor_manifest_v5.py (the groups' generator of record, unchanged): the PRODUCER stamp, the moved rows (3 and 7) and, in the sector-487 manifest, the two vendored_from header lines that quote the README's served-sha256 clauses; every other line byte for byte; `sha256sum -c VENDOR_MANIFEST.sha256` rc 0 / 0. - `superseded_19e7a752eefd0ca7/README.md` d4dead3f69d2600e -> f557f7ae214c93cd730c2c7b39a73f41d11b517548a3a139e7d142f90e74c70a: its 'Succeeded by' sentence names the fifth hosting text site of its successor (the chain-runner helper's docstring) beside the four it listed; `superseded_19e7a752eefd0ca7/SHA256SUMS` 975a42b47a2c7447 -> 450f60365e269f34a21619b6f247e40a8dd8e09076d90bb3fe890e3d2f612c5c (row 1 follows; `sha256sum -c` rc 0); its four previous-bytes copies untouched. `superseded_e98770f5d36cb9e4/` (new; an unpinned companion named in the manifest header, not a manifest row; keyed by the previous evaluator's sha256 prefix): the previous bytes of `eval_row35.py` e98770f5d36cb9e4, `epsfan_vendored.py` adb8af7402ff538d, `containers.json` a4ddadc81f743705 and `CONTAINERS.md` 957b0846588604a6 under their bundle-relative names with README.md (2dffbb6208c20176) and SHA256SUMS (d2898ca7953d5182; `sha256sum -c` rc 0); the four older companions byte for byte (rc 0 / 0 / 0 / 0). - `MANIFEST.sha256` (was 51f8cb4a622819ad): re-emitted by gen_manifest_sha256_v16.py (the re-pin form of the generators of record; v16 = v15 in behaviour): 19 rows re-pinned (`eval_row35.py`, `epsfan_vendored.py`, `row35_chain.tar.gz`, `containers.json`, `CONTAINERS.md`, `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_E_20260910T012709Z.json`, `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S1_20260910T011509Z.json`, `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S1c_20260910T012117Z.json`, `vendor_row35_sec481/receipts/LIVE_RECEIPT_P2_S2R_20260910T012404Z.json`, `vendor_row35_sec481/statements/STATEMENT_SEC481_20260910T021848Z.json`, `vendor_row35_sec481/statements/STATEMENT_SEC481_RESIDUE_20260910T022905Z.json`, `vendor_row35_sec487/receipts/LIVE_RECEIPT_P1C_20260910T003410Z.json`, `vendor_row35_sec487/statements/STATEMENT_COUNTFOLD_v3_20260910T003746Z.json`, `vendor_row35_sec481/README.md`, `vendor_row35_sec481/VENDOR_MANIFEST.sha256`, `vendor_row35_sec487/README.md`, `vendor_row35_sec487/VENDOR_MANIFEST.sha256`, `qqww-t4-tower12-layers.json`, `CHANGES.md`; the two `superseded_19e7a752eefd0ca7/` files are companion files, not rows), the `superseded_e98770f5d36cb9e4/` companion line added, no row added, no role line re-cut; 148 rows; every other row and header line byte for byte; `sha256sum -c MANIFEST.sha256` rc 0. Every `.py` file of the bundle parses (24 files including the companions' copies, py_compile, 0 failures). This entry applies on the bundle whose `MANIFEST.sha256` is 51f8cb4a622819ad and `CHANGES.md` c1100fe5f99907a6 (the chain-hosting entry, the previous one). - NOT DONE here, stated. (a) The previous-bytes copies under the five `superseded_*/` directories keep their bytes by construction, including the lines this entry re-words in their successors. (b) The page's sentences are the page's, after this install. (c) The two closed-form containers and the regenerated node pair remain on request; the docstring paragraph headed 'NOT HOSTED WITH THIS BUNDLE' and the radical-fold comment describe them and stand. (d) Other key names of the vendored record objects (script names inside scripts_sha256, for instance) are the objects' own and stay; only the work-tree key carried a working word.