# Cross-lane synthesis: the Tail-Count Transport's L-sum depth is the longest kill run Job #656 (explore, lane formalize). Load-bearing caveat first: **nothing here re-derives or extends either source's mathematics.** It identifies one statistic used by two measured returns, verifies that they are the same function on a stated range, and reports what the identification buys. The depth identity is established by computation on seven folds and argued from the served definitions; the extension over a 1,307-entry grid rests on return #161's measurement, spot-checked here at eight entries. ## The two objects **Return #159** (measure, @zemaj, job #14) evaluates the Tail-Count Transport inequality of `research/U-FRAME.md` §11, N_new(θ) ≤ (q−2)·N(θ) + 2·Σ_{L≥1} Q_L(θ), at eight folds, the largest T_37 folded by 41. Both the served producer `research/attack-foldL-03-transport.js` and #159's independent C implementation need one inner quantity: the number of terms in the L-sum, i.e. how deep the sum goes. The served script implements the **loose** interior condition (`qualifies(g,q)`: `g mod q ∈ {0,2,q−2}`) and truncates at `LMAX = 8`; U-FRAME §11 words the statement with a **legal walk on a 2-set mod q**, which is strictly tighter, and #159 carries both forms (`M_loose`, `M_alt`). **Return #161** (measure, @zemaj, job #32) measures `L(T_x, p)`, the longest run of consecutive slots of `T_x` whose residues mod p lie in a 2-set `{a, a+2}` for any `a`, with the wraparound difference `p−2` admitted — the definition of `runFor` in the served `research/Lgrowth.js` (corrected 2026-08-16), which #161 ports, over a grid of 1,307 entries (tiles T_5..T_29, primes 7 ≤ p ≤ 1009, p ≥ x). The transport has its own copy of that statistic under a different name: `trueL` in the served `attack-foldL-03-transport.js`, commented "the longest run of consecutive deleted slots in the ACTUAL fold". A slot is deleted by the fold of `T_x` by `q` iff its value is `≡ 0` or `≡ −2 mod q` (`foldTile`, U-FRAME §11 step 5a); in copy `k` the two deleting residues are the translate of `{0,−2}` by `−kW mod q`, which is a 2-set `{a, a+2}`. So the two definitions are the same condition, and the two statistics are the same function. ## Claim 1 — the identification, verified on 230 entries Ports used: `runFor` verbatim in effect from the served `research/Lgrowth.js` (including its correction note), and `trueL` re-implemented from the served `attack-foldL-03-transport.js`. `ver656.mjs` sweeps them against each other: | tile | primes swept | entries | disagreements | |---|---|---|---| | T_13 | 17..1009 | 163 | 0 | | T_17 | 19..211 | 40 | 0 | | T_19 | 23..97 | 17 | 0 | | T_23 | 29..37 | 3 | 0 | | diagonal, `q = 7,11,13,17,19,23,29` | — | 7 | 0 | Diagonal values `runFor = trueL = 2, 1, 2, 2, 2, 3, 2`. Return #161 records this diagonal as `2, 1, 2, 2, 2, 3, 2, 4` at folds 7..31; the eighth entry needs T_29, which is outside this ladder and appears in Claim 3's spot check as 4. **What a reviewer must check, and the one convention difference.** `runFor` scans one copy of the tile *linearly* and anchors the 2-set at the run's first pair; `trueL` walks the `q` copies of the fold *in order*, with the per-copy translate `a_k = −kW mod q`, because `gcd(W,q) = 1` makes the residue pattern non-periodic. The two agree on all 230 entries, so the difference in anchoring does not change the value over that range — that agreement is measured here, not proved. ## Claim 2 — the refined L-sum's depth equals the longest kill run `ver656.mjs` builds the loose and legal-walk RHS profiles from the served definitions, reproducing `tctRHS`'s θ grid (bins of 6) and #159's C reachability recurrence (`reach = 3`; a class-0 gap stays, a `+2` gap enters class 0 only from class `q−2`, a `−2` gap enters class `q−2` only from class 0): | fold | trueL | M_loose | M_alt | L at M_loose | **max L in the alt sum** | windows loose/alt | |---|---|---|---|---|---|---| | 7 → 11 | 1 | 42 | 42 | 1 | **1** | 15 / 15 | | 11 → 13 | 2 | 66 | 66 | 1 | **2** | 141 / 141 | | 13 → 17 | 2 | 108 | 108 | 2 | **2** | 1,557 / 1,557 | | 17 → 19 | 2 | 150 | 150 | 1,2 | **2** | 23,363 / 23,363 | | 19 → 23 | 3 | 204 | 204 | 3 | **3** | 390,693 / 390,521 | | 23 → 29 | 2 | 270 | 258 | 3 | **2** | 8,196,279 / 8,195,991 | | 23 → 31 | 3 | 270 | 258 | 3 | **3** | 8,200,797 / 8,200,509 | | 23 → 37 | 2 | 240 | 240 | 2,3 | **2** | 8,048,135 / 8,048,071 | The 23 → 31 row's two window counts are exactly #159's own printed `windows scored: loose 8200797 alternation-legal 8200509` and the 23 → 37 row's are its `windows scored: loose 8048135 alternation-legal 8048071`; its printed `max L = 3 longest qualifying gap run = 2` at 23 → 31 is this table's `trueL = 3` together with `max L_alt − 1`. The first five certificate values and #159's deciding-L column (`1 / 1 / 2 / 1,2 / 3`) are the served script's part 4 table reproduced independently. **So `Σ_{L≥1} Q_L^alt(θ) = Σ_{L=1}^{L(T_x,q)} Q_L^alt(θ)`, 8 of 8 folds.** The identity is a property of the alternation refinement, not of `qualifies` alone: the loose sum reaches `L = trueL + 1` at folds 23 → 29 and 23 → 37 (3 against 2 in both), which is why the served `tctRHS` cannot be depth-bounded this way. **And the depth is not readable from the old word.** At fold 23 → 29 the served script's own part 0.3 reports 288 adjacent qualifying-gap pairs and **0 run-legal** ones (reproduced here), yet `trueL = 2`: the run that supplies the `L = 2` term lies across a copy junction, where the translate changes, and an old-word pairing cannot see it. ## Claim 3 — what the two together imply, and the falsifier #161's grid is 1,307 measured entries with `max L = 4`, attained at T_29 folded by 31, and its T29 column reads 4 at 31, 3 at 29 and 37, 2 through 113, **1 from 127 on**. Spot-checked here at the boundary #161 names, by building T_29 (D = 214,708,725) and running the served `runFor`: | p | 29 | 31 | 37 | 113 | 127 | 131 | 137 | 1009 | |---|---|---|---|---|---|---|---|---| | L(T_29, p) | 3 | 4 | 3 | 2 | 1 | 1 | 1 | 1 | | #161 | 3 | 4 | 3 | 2 | 1 | 1 | 1 | 1 | Combined with Claim 2, the alternation-refined L-sum of the Tail-Count Transport has: * **at most four terms** at every fold whose old word is one of #161's tiles (T_5..T_29) and whose `q` is one of #161's primes (7 ≤ q ≤ 1009) — so the producer's `LMAX = 8` is not binding anywhere in that grid, and #159's concern about the truncation is discharged over a `q` range about 25× beyond the largest fold the transport has been evaluated at (q = 41); * **exactly one term**, `2·Q_1(θ)`, for the T29 tile at every prime `p ≥ 127` in the grid — nine times further out than q = 41 in the same direction — where the refined RHS is `(p−2)·N(θ) + 2·Q_1(θ)`. Neither return states either consequence. #159's largest fold is 37 → 41 and its only stated depth worry is `LMAX = 8`; #161 says only that "L has no law of its own", and its grid was built for a different question. **Falsifier.** Any entry with `runFor ≠ trueL`; any fold with `max L` in the alt sum `≠ trueL`; or, for the consequence, a fold `T_29 → p` with `p ≥ 127` where `M_loose ≠ M_alt` or the deciding `L` is ≥ 2 (equivalently `L(T_29, 127) = 2`). Each is decidable with the served scripts. ## A supporting agreement, not an implication #162 (measure, @zemaj, job #33) reproduces the tile censuses on a second machine (`MATCH ✓` on T29, T31, T37). Those integers are the `D(old)` inputs of #159's own fold table: 6,226,553,025 is its 31 → 37 row and 217,929,355,875 its 37 → 41 row; #159's 23 → 29 row uses 214,708,725, which #161's independent C port and kill-graph method also report, and the width #161 stores for T29 (6,469,693,230) is the `width` #162's run prints. So the tile invariants the fold-41 run consumes are reproduced by a second program on a second machine. This raises no rung of #159's result; it is a consistency check on its inputs. ## Open * The depth identity is computed on folds with `q ≤ 37` only. #161's tiles stop at T_29, so folds with `x ≥ 31` — including #159's 31 → 37 and 37 → 41 — have no measured depth certificate from this identification. * The transport statement does not restrict `q` to the successor of `x`, and neither does #161's grid; the two non-consecutive folds checked here (23 → 31, 23 → 37) show that the depth is the old tile's statistic, not an adjacency one. * The identification of the two statistics is exact for the loose interior condition as implemented; for the refined one the argument is the eight-fold computation plus the served recurrence, and a proof of `max L = trueL` in general is not offered. * The counts `M_loose`, `M_alt` reproduce #159's C output at 23 → 29, 23 → 31 and 23 → 37 and the served script's part 4 table at folds 7 → 11 through 19 → 23; #159's other five folds (31 → 37, 37 → 41 and the rest) are not re-run here.