Run 082 was withdrawn on a mis-written control, but what its lab saw before stopping reshapes the ladder: rung 1 is wall-bound at the carpet's sizes (the threshold within 2.8 widths of 1 at L = 729), its slopes sit below both the carpet and the one-bit map and in the wrong order (X below T), and the one-bit map sits above the carpet. So the rung-k family approaches the carpet from below as k grows. At the first rung whose threshold is clear of the wall, does the ladder recover the carpet's order of T and X, and does T's skewness turn there while X's does not?

Sealed 2026-10-01, after run 082 was withdrawn and before any rung-2, -3 or -5 quantity existed (codifier). Known at sealing, beyond run 082's seal: everything its lab saw before stopping, listed in run 082's scoring. Rung 1: wall guard 1.88, 2.78 (T) and 1.89, 2.58 (X) at L = 81 and 729; rough slopes 0.33 (T), 0.30 (X); the F4 share identically 1. The rung-2 state does not close on 8 terminals (its higher-level joins fall on the midpoint), so P-049's "4,140 partitions at k = 2" is wrong (it would be a partition of 12 cells) and k = 2 is not a rung of this run. The carpet: 1/ν 0.3743 (T), 0.5508 (X); g₁ steps 729→6561 −0.191 (T), +0.146 (X). The one-bit map: y₉ 0.4392, 0.5533; its g₁ steps k = 3→4 +0.118 (T), +0.049 (X). The gasket: 1/ν 0.26.

What changed from run 082. Three things. The rung is chosen by the wall guard in a committed stage, because rung 1 showed the guard fails before the pattern's shape can be read. Clause B of 082 ("between y₉ and the measured value") is replaced: the family lies below the carpet, so the question is whether it recovers the carpet's order of the two patterns, which rung 1 reversed. Control (i) is a goodness of fit over the grid, not a per-point threshold (OPS.md, 2026-10-01).

The codifier's lead, held with conviction, and where it was wrong. The one-bit map is not the ladder's bottom rung; it is on the far side of the carpet from the whole family. So the carpet is squeezed between a sequence rising from below (rungs) and one object above (the map). The lead now: the order of T and X comes back at a small rung (k* = 2 or 3), because the order is a slope and slopes are set by how much boundary a block exposes; the turn comes back at the same rung, because the route that makes it (through a block without crossing it) exists from k = 1 and only needs the wall out of the way to show. Where it breaks: if the guard clears only at k = 5, the rung has 20 terminals per block and the "finite number of boundary bits, and that number is small" clause of PG-01's conjecture is already strained; if it clears nowhere below 7, the ladder says the carpet's finite-size behaviour needs most of the boundary, and PG-01's conjecture is in trouble.

Power, stated. The recursion's g₁ error at 10⁶ draws is about 0.001–0.005, so B's margin is set by effect size, not noise, as in 082. A's margin of +0.05 against slope errors near 0.002 (recursion) is likewise an effect-size threshold; the carpet's gap is 0.18. A reads the 729→6561 slope because the guard is checked at levels 3 and 4 only; rung 1's guard at level 2 was 1.9, so the three-size slope would carry a wall-bound point.

The reductio this seal passed first. By construction: the rung is chosen on the guard alone, before any clause quantity is read, and the guard is a function of p* and w, not of the order or the turn. A is not implied by the guard: a rung can be clear of the wall and still order the patterns wrongly. Negation: if the turn needs the full boundary, every rung below 7 rises on T, and B's falsifier fires at the first clear rung; if the order needs it, A's does. A wall residue works against B's T clause and for its X clause: the guard rises with level (1.88 → 2.78 at rung 1), so a residual wall makes the 3→4 step positive; and the pattern that clears last (X at rung 1) is the more wall-shaped at k*. What a lone clause decides is in the falsifier line. Cost: stage 1, minutes per rung; stage 2's recursion is 2–3× run 082's per draw at k = 3 and 5–6× at k = 5 (more terminals, 84k joining bonds, 64 random reads into the level-g sample), so about 100 chain-hours at k = 3 and 250 at k = 5 across the 21 chains, parallel across chains; memory is one partition sample per worker with the per-grid-point organisation. The two L = 6561 lattices take about 45 minutes each on the M5 at 8 threads and share the machine with run 083's remaining lattices.

Reported, not scored. - Stage 1 in full: p*(g), w(g), G(g) for k = 3, 5, both patterns, g = 1 … 4; the rungs that qualified. - At k*: everything run 082 reported. The F4 share (R − R̃)/R is expected identically 1 on both patterns at k = 3 and 5 (a projected block passes only straight through along a designated row; T has a hole in every row 1–7, and X keeps only rows 2 and 6, which are not designated at these k); it is reported, not read. The slopes s₂₃, s₃₄ and their mean at k* beside rung 1's rough values, the carpet and the one-bit map, in one table; the connectivity among the midpoint terminals reported separately. - Every rung below k*: the coarse pass's slopes and steps, so the approach is visible where it is not scored. - Control (i)'s rms z restricted to grid points with N·R(1 − R) ≥ 10, with the count of points stated.

Reviewed before commit by a second reader (OPS.md); its edits are folded in: k = 2 dropped (its state does not close on 8 terminals); the terminal flags and R stated identically for both computations; clause A moved to the guarded local slope; the stage-1 rule given a resolution step and a margin; the F4 share correctly called trivial at these rungs; the stage-2 organisation and cost restated.

Scored 2026-10-03 — falsified

Scored by the codifier from RESULTS084.md, rung084.json and lattice084.json (3913aa1), as written. A scoring reader (OPS.md) read the note against the results before commit; its edits are folded in.

Controls first — all three pass. (i) The level-1 recursion against the exact polynomial: rms z 0.982 on both patterns (sealed band [0.90, 1.10]), largest |z| 3.91 (T) and 3.98 (X) against 4.5, over 1,083 and 1,358 grid points; the designated-terminal crossing is at or below the column-to-column one at every point on both. (ii) Construction on all six lad3 lattices: 3 bonds on every aligned segment between kept blocks, 84 bonds per level-1 block, terminal flags on the three designated cells of each side. (iii) Recursion against lattice at levels 2 and 3, g₁ and w on both patterns: all eight within 3 combined errors (largest +2.26). Stage 1 chose k* = 3 on the wall guard before any stage-2 draw (guards 9.4 and 22.3 on T, 11.3 and 23.6 on X at levels 3 and 4).

(A) Falsified. s₃₄(X) − s₃₄(T) = −0.131 ± 0.007 by the recursion (0.3005 against 0.4318), at or below 0: rung 3 has X below T, as rung 1 did, where the carpet has X above T by 0.18. The lattice agrees (0.315 against 0.444). (B) Falsified. T's skewness rises from level 3 to level 4 by +0.510 ± 0.006 (0.322 → 0.832), at or above +0.03: the first clear rung rises, and steeply. X's rises by +1.366 (the X half held as predicted; B falls on T alone). Both clauses falsified; the run is falsified. The codifier's lead — the order and the turn both come back at a small rung — was wrong on both.

What the numbers say beyond the clauses.

1. The instrument works; the object is not the carpet. The rung-3 recursion and the rung-3 lattice agree within 3 combined errors on p*, w and g₁ at every level they share, level 4 included (p* 0.85650 against 0.85648 on T, 0.83809 against 0.83804 on X; level-4 widths within 1.6%, under one combined error; level-4 g₁ within one lattice error). The largest difference is in p* at level 2, the recursion lower by 2.2 (T) and 2.5 (X) combined errors — same sign, not a control quantity, gone by level 4. The boundary state closes and the resampled recursion reproduces its lattice. What fails is the resemblance: the rung-3 lattice has neither the carpet's order of slopes nor its shapes.

1. The rung has no scaling regime at these sizes. p* rises at every level (T 0.741, 0.821, 0.847, 0.856; X 0.710, 0.794, 0.825, 0.838); P-049 says it continues to 1 at finite k, which four levels do not themselves show (the increments shrink by a factor 0.33–0.44 per level). The local slope falls with it (T 0.507 → 0.432; X 0.440 → 0.301). A slope read on a rung is a local slope, not an exponent, as P-049 said. Clause A compared local slopes over the same step (the carpet's 0.545 against 0.365); what the seal did not anticipate is that the rung's slope falls by 0.07–0.14 per level while the carpet's sits near its 1/ν (0.365 against 0.374; 0.545 against 0.551).

1. The shapes run away. X's skewness is +0.22, +1.19, +2.56 at 81, 729, 6561 with excess kurtosis 17 at the last, by recursion and lattice alike; T's is +0.03, +0.32, +0.83. By the seal's guard the rise is not a wall residue (p* is 20–24 widths from 1 at level 4, 10–11 at level 3; sealed 3.1). A reading, in L11's terms: a rung joins blocks through three bonds per side, so its cheapest blocking cut is small at every scale and the upper tail is the heavy one, increasingly — the same sign as the carpet's but growing with level, where the carpet's skewness stays below 0.5 on T and X at these sizes (run 073).

1. The rung's designated rows miss X's routes — a design caveat on clause A. The seal's own reported list notes that X keeps only rows 2 and 6 whole and that neither is designated at k = 3 (S₃ = {1, 4, 7}) or k = 5. So on X every designated row is interrupted (rows 1 and 7 keep 4 of 9 cells, row 4 keeps 6) and the two whole rows carry no join; T has no whole interior row to miss. Rung 3 as built tests "these three cells", not "three cells": the reversed order may be the choice of S. S₃′ = {2, 4, 6} contains the midpoint and is symmetric, so by P-049's rule its state closes on 12 terminals — controls (ii) and (iii) and a stage-1 guard on the new lattices have to show it — and it is the rung that tests the other reading. It is not neutral either: X gets two whole designated rows and T none, so the F4 share stops being trivially 1 on X. (P-024's chase paragraph counted S₃ = {1, 4, 7} among the sets that see the side of a hole and named k = 3 as the first rung where the turn could show. It did not show; that goes to P-024's look-back.)

1. The boundary state at threshold: flat on X, slowing on T. The four midpoint terminals' all-separate share at p*(g) is 0.500, 0.503, 0.504 at levels 2–4 on X (flat to 0.004) and 0.174, 0.246, 0.272, 0.285 on T (steps +0.072, +0.026, +0.013: slowing, not settled at level 4). No replicate error is recorded for these (b = 0 only). A reading, not a result: the recursion may have a stationary boundary law while its threshold rises. Reported; nothing is read from it yet.

1. The coarse pass at k = 5 (stage 1, 2 × 10⁴ draws, not a measurement): s₃₄ 0.451 (T), 0.416 (X) — the gap −0.035 against rung 3's coarse −0.055 and fine −0.131. The coarse slopes miss the fine ones by up to 0.07 on X at k = 3, so nothing is read from the k = 5 gap; it is listed because the lab reported stage 1 in full (the seal asked for coarse slopes only of rungs below k*, and there are none).

What it does to PG-01. L2's first scorable rung recovers neither the order nor the turn, so scaffold S1's first removal attempt fails: three boundary cells per side, at these rows, do not make the block's recursion resemble the carpet's lattice. That is not yet "it falls at every finite k" — the carpet is no finite rung but the limit in which the designated set grows with the level (P-049), and item 4 says the rows may matter — but the conjecture's "that number is small" now has one scored rung, on one choice of rows, against it and none for it. The next seal under L2 is the same rung on S₃′ = {2, 4, 6}: if the order returns there, the boundary datum is which cells and not how many; if it does not, the next rung is 5 — whose S₅ = {1, 3, 4, 5, 7} also omits rows 2 and 6 — and the conjecture's last clause is strained.

Lab notes. M5, with runs 083, 085, 087 and 092's short runs sharing the machine at times; the 40 replicate chains and one lattice were suspended in place for two hours on 1 October so run 083 could finish, with no stream changed. The level-up kernel was replaced before any stage-2 result by one bit-identical to stage 1's on six test points at 2–3× the speed. Replicates finished 2 October 15:16 local (22:16 UTC on the log).