What was decided, run, found and left open

2026-11-05

F14.2 (ticket #93)

The AWS leg finished all 697 units at 13:06, but the laptop had slept; on waking its first polls failed and the silence check cut the machine off and fell back to the laptop from 96 units (#119). Alexis's session fixed the check, put the 697-unit checkpoint from S3 in place and restarted; the resume took 88 s.

K4's one edge cell (order A, length 10: one setting fits, every shuffle none) led to a flaw. At route 'two turns cw 17,95 inverse' three of the first six checks repeat a known letter (E with E, A with A). Those checks hold for every alphabet pair, so the index keyed on three informative checks, 2.4 million pairs passed, over the listing cap, and the code counted them without testing the other eight checks and never ran the key-word step. The true setting always passes repeated-letter checks, so a true key on such a setting would have been missed. 41,986 of 1,363,532 listed settings are affected (every order-B length-9 setting among them); plants missed it because none fell there. F14.2a reruns those settings with repeated-letter checks tested directly and the index on informative checks only.

F14.2a started at 15:35 on AWS. A 1/40 desk dry run had confirmed the flaw: of 12 plants on the affected settings 0271's code finds 2, the fixed test 12, and the two agree on 1,800 unaffected checks. The laptop lost its network for 90 minutes; the machine kept running, as #119 intended, but the run was stopped for Alexis's graceful stop at 18:05 with only 5 of 140 blocks saved on the laptop: no record. F14.2a's attack.py is kept in drafts/ to resume unchanged.

F6.1 (ticket #77)

The first AWS leg died after 65 min on S3's RequestTimeTooSkewed: the laptop had slept and woke with a stale clock, and aws_run handed the run to the laptop. Stopped it with stop_experiment.sh and restarted unchanged; it resumed from 1,028 saved units on AWS (#115). The laptop then slept again at 23:46; caffeinate -s -w <run pid> kept it awake for the rest of the run and exited with it.

2026-11-04

F1.4 (ticket #77), first loop run on AWS (#115)

F15: K1-K3 as a guide to content (ticket #118, pivot P23)

F15.1 written by reading (reports/f15.1-content-model.md): seven content hypotheses (a paced location, a meeting at the World Clock, the crowds of 1989, two breaches, light and shadow, K3 continued, a pointer onward). F15.2: 329 corpus drafts (Opus) and 28 held-out (Sonnet, another prompt), each exactly 97 letters with the known words in place, about $14 (data/drafts/, tools/f15_drafts.py).

The drafts are narrower than the held-out set: 316 of 329 put THE at 61-63 (held-out 15 of 28). Opus wrote one kind of sentence before BERLINCLOCK; a prior built on it rewards that habit, not Sanborn's.

Mistake: 0268's hypothesis_expert cites "C2" and "C20(a)" for "instructions in the earlier text" and "come back to the first part"; those are C7 (and C13, C14 for the content). The register was updated under C7, C13 and C14.

F1.14's gate (ticket #77)

Mistake: three wait calls (and a desk smoke test) outran the 10-minute tool limit and went to the background; all stopped. tools/wait_experiment.sh takes its own limit as an argument; calls now pass 480.

Mistake: one wait call chained two tools/wait_experiment.sh calls, overran the tool limit and went to the background; stopped at once (the run was untouched). One wait per call.

2026-10-31

F1.13 desk note (drafts/F1.13-design.md): the autokey forms are linear in the alphabet's numbering, so the numbering splits mod 13 and mod 2. A climb over which two letters share each residue mod 13, with the remaining 13 bits solved exactly per pairing, replaces 0256's climb over the whole alphabet, which lost its plants to search failure. Not measured yet: the laptop slept on battery from about 03:00 to 09:40, and 0267 went from 405 to 430 of 5,930 settings (#109).

Laptop on AC from 11:11 (#109 closed); 0267 back to about 80 settings an hour. F1.13 measured on the desk (b2f38cb): the split climb, the split with exact pairings, 0256's check-keeping climb past lag 12 (0 of 8) and a constructive beam along the chains (right when seeded with the true alphabet, dead unseeded at 200,000 states) all miss the bar. The useful finding is a ceiling: 0256's climbs already beat the true reading at ct lags 66-73 and pt lags 32-52, so about half of K4's 130 cells are capped by the score, not the search. F1.13 stays open for the other 63.

Mistake: three desk probes run as a background group outlived the tool's stop and kept three cores from 0267 for about 18 minutes (514 settings at 12:04 against about 530 expected). Desk probes now run one at a time in the foreground, under 10 minutes each.

2026-10-30

F5 (ticket #77)

F6 (ticket #100)

The morning's Modal leg was judged slow from too little to go on: resumed on Modal it did the remaining 43% in 20 minutes ($0.54). The laptop, at load 50 from other work, managed about a million primers a second. A measured rate on a run's first minutes is a poor guide on either machine.

F1.13 desk work (autokey on one free alphabet, a better climb): the consistent alphabets per K4 cell number 10^12.7 to 10^25 (rank of the known-letter equations mod 2 and 13), so no exact enumeration. On ciphertext-autokey plants 0256's tempering stops 1.0-1.5 quadgram units under the true reading; ten times the rounds or ten runs reach it in 1 of 5; the check-keeping climb is no better; climbing first on the coincidence rate of the difference stream overfits by a factor of 3-5. F1.13 stays open for a new search.

The record's '1,346 two-alphabet settings' for F1.4 counted distinct partitions of the 24 known places (0127, 0128). A climb reads the whole slot map, so the cell is the 4,706 slot maps over all 97 places that fit K4 on two free alphabets (desk count): about 98,000 tempering runs, 330-410 core-hours. Drafted (drafts/attack-f1.4-two-draft.py, self-check against 0144 passes, plants read in part on one run).

Open at close of session (2026-10-30, about 21:20)

• Running: 0267, F1.4's two-alphabet residue (4,706 slot maps, D1b's four runs, 20 stand-ins x 60, 24 plants), on the laptop (the Modal credit, about $2.6 after the margin, is short of its about $5.6). 390 of 5,930 units at 21:16. It ran at about 80 units an hour until the laptop went on battery and to sleep (about 19:49; issue #109 asks Alexis to plug it in). Do not edit attack.py until it is recorded; partial counts so far: K4 above all 12 copies in about 8.6% of its settings, stand-ins about 7%.
• Next, in order: F6.1 at 6-10 (drafted, drafts/attack-f6.1-draft.py, laptop, about 230-300 core-hours); F1.13 (needs a new search for autokey on one free alphabet, see the desk note above); F14.2 last (design in drafts/F14.2-design.md, about 460 core-hours).
• Mistake: waits on tools/wait_experiment.sh overran the tool limit while the laptop slept and were moved to the background, against the house rule; they were stopped. With the laptop asleep, a wait of any length can overrun.

2026-10-29

D2's re-costed cells (ticket #77). The morning's 0253 attempt was lost to a DNS outage and stopped by hand (#104); the harness gained checkpoints (#105) and the run was restarted with them.

D2 and F1.4 (ticket #77)

F13 (ticket #85), after pivot P22

The pre-registered rule for 0260 had the direction backwards: I assumed rotating a planted message would destroy it, so 'rotations at chance' would mean a positional, message-like effect. The planted messages showed the move library absorbs a cyclic shift. The control decided the reading, which is what it is for; the rule is recorded as written and the verdict as the control gives it.

F1 (ticket #77)

Open at close of session (2026-10-30, about 11:00)

• Running: 0262, F5.2 (the Gromark rules 0195 left, exact, 2.34 x 10^11 primers). Started on Modal, stopped with tools/stop_experiment.sh when its throughput there put it at about $5.4 against about $3.4 of credit left, switched to the laptop (tools/compute.sh local), resumed from its 96 saved slices. The laptop is shared and loaded (load average 20-77), so it runs at about one slice a minute on the largest bases; several hours left. Do not edit attack.py until it is recorded.
• Next, in order: F6.22 (drafted, drafts/attack-f6.22-draft.py, local, about 1-2 core-hours); F1.4's two-alphabet residue (1,346 settings, four runs per D1b, with stand-ins: about 160 core-hours on the laptop, to draft from 0253's attack with 0144's climb); F6.1 at 6-10 (7,443 settings with stand-ins, about 350 core-hours on the laptop, to draft from 0252/0253); F1.13 (desk work first: a climb that recovers autokey plants); then F14.2 last (about 1,000 core-hours on the laptop, about a week).
• Modal credit: about $21.8 of $25.59 spent since 2026-10-29 10:37 (two runs' Modal costs estimated from wall time because they finished on the laptop); about $3.4 left after the margin; compute is set to the laptop.
• Lessons: a count of settings where K4 beats its copies needs stand-ins (0254, 0255); a pre-registered reading can be overturned by its own positive control, and the control wins (0260); don't commit while a Modal run uploads the repository (0258).

The excess is spread over the whole cell (K4 beat its first copy in 61% of settings, not 50%), and no reading is English, which points at the test rather than at a message: the settings were chosen because K4 fits them, and a shuffle that also fits need not have the same freedom. A desk check of the letters the witness pins did not show it (K4 21, copies 20.7). 0254 runs the procedure on four shuffles of K4 as stand-ins, each on its own fitting settings, beside K4 with fresh copies: if the stand-ins show the excess too, it belongs to the test.

Desk work while 0253 ran: the F1.7 draft's climb was broken (it never reached a state with all 24 known letters at short plaintext-autokey lags and left the true alphabet when started on it); fixed with the full chain equations (0149 used only pairs L apart) and 0139's repair moves; on ciphertext autokey no variant reached a plant's own score, so its power there will be low and is measured in the run. Drafts written and smoke-tested: D1b, F5.2 (27 core-hours), F13.4c at 6-19 for D3, F13.4h, F1.12. D3's cells listed: six were already run on K4 against its own copies in their closing experiments and are closed as sampled at their measured power, three tell nothing, one (F13.4c 6-19) is drafted.

What 0254 taught: whenever a statistic is counted over many settings of one text, the settings are not independent draws, because they all read the same 24 known places of the same text; the null has to be a distribution over texts put through the whole procedure (stand-ins), not a binomial over settings. 0255 ranks K4 among 40 stand-ins.

Mistake: 0254 was started with one failing test (0253's figures not yet drawn); the exit code was hidden by a pipe through tail. The figures were drawn while it ran and the suite passes.

2026-10-28

F13 continues (ticket #85). F13.4f is next in the queue; D1 still waits on Alexis (#100).

F13 (ticket #85)

F14 (ticket #93), after pivot P21

Open at close of day

F14 is done apart from F14.2, blocked by cost with a decision asked (#102, about $50 of Modal time, or about $10 with 10 shuffles). Every other row still open (D1, D2, F1.1 Beaufort 23 and 26, F1.2 length 13) waits on Alexis's decision about D1's power margin (#100); they are marked blocked on it, which leaves the backlog empty under the 2026-10-27 stop rule (#92), so the loop stops here (data/loop-stop.json). The 0237-0239 table-then-move excess waits on #101. Most promising to unblock: #100 (one free alphabet at about 32 times cheaper reopens F1.1's cells and starts D2's re-costing of F1.4, F1.7, F6.1, F6.2, F5.2), then #102.

0241 went far better than I predicted (I expected the screen to lose the word from about length 15). Requiring the key to be a real word is worth more than the letter counts lose: among 2 million rotations the true one wins its own setting even with columns of five letters, and the full reading then stands 7-10 times above the shuffles. The general lesson for F13: a key drawn from a word list is decidable from the ciphertext alone where a free key of the same length is not (0235, 0236).

Caught in 0243's dry run: 0210's source 'right panel K1-K4' contains K4's own carved letters, so as a running key it reads K4 as all A under Beaufort, and would have flagged K4 against shuffles that do not contain themselves. Left out. Any self-referential source needs that check when the known letters no longer filter.

F13.6 blocked at the desk after a probe on 0243's search: a mask either keeps the reading English, and then the English statistic already finds it (X every kth, nulls: read exactly 4 of 4), or breaks it, and then the search never keeps that reading (every nth place, affine: 0 of 4). The battery has nothing left to add on readings chosen by English. That ends F13 apart from D1/D2, which wait on #100.

F14.1 turned out cheap: a same-slot check between two known places splits into a gap on the cipher alphabet and a gap on the plain alphabet, so the pairs never need to be enumerated, only filed and looked up (0244 ran in 94 s). The pre-registered prediction said no pair below 23; K4 had 5 at 16, which the dry run had already shown. Since every slot at 16 holds a known place, those pairs fix the whole reading, so I added full readings for K4 and copies before the run and said so in the method. The count replicated weakly (0245, p 0.009), short of the corrected line; the readings are junk.

F14.6c's dry run caught a bug of mine: with the move first, the table runs over carved places, so the puzzle word has to be read at each known letter's landing place, not its message place; the order-A plants were missed (0 of 2) until that was fixed. 0250 ran 2.8 h on Modal, five times my local estimate: 32 processes on 32 vCPUs run at about half a core each.

Mistake: I started 0245 with a test failing (0244's crib map not yet drawn); the pipe into tail hid pytest's exit status from the && chain. From here on pytest runs on its own line before a start.

F13.4f's second half (two dictionary key-word alphabets) and F13.4g (Chaocipher) closed as blocked at the desk. For Chaocipher a short probe showed why: once the left wheel is guessed the rest is a simple substitution, but an annealer over the left wheel finds wrong wheels whose index stream looks more English than the true one's, on every plant.

The cheaper decider, D2 (ticket #77), after Alexis's decision on #100

At short lengths with many checks, 0140's random depth-first start sometimes fails where the exact decider finds an alphabet; the climb then returns -99 and any plant would beat such a copy. Found in a desk test before the run; the climb now falls back to the decider's witness after 200 failed starts (0 climbs without a start in 0252). F5.2's base 26 lag 6 turned out to be blocked by the 30-minute budget of its day, not by a decider: about two of 0195's runs. The 0130 record's zero fits at length 9 (order B) are real; the recount agrees.

2026-10-27

Stage 2, step 4 (A6, ticket #84). Step 3 closed on 2026-10-25; a draft of A6.1 had been left in attack.py unrun.

A6 (ticket #84)

The judge cannot rescue a climbed reading: design 2's readings of planted English get about a third of the letters right, and the judge, reading for words, sees no more in them than in the copies'. So F1.1 and F1.2's sampled closes rest on the quadgram power alone; A6.2 asks whether that power holds on Sanborn-style text. Where the reading is fixed by the setting (0125's forced running key), the judge is stronger than quadgrams.

Fixed in the left draft before running: gate 4 was handed judge scores (0-100) against a quadgram score; it now gets the copies' quadgram scores. The re-submitted K4 readings re-encrypt through their own frozen encrypt instead of a hand-written one-alphabet rule. A6.2's dry run hung in 0123's witness search on one key draw; the search now runs under a 20-second alarm and the key is redrawn on timeout.

A6.2 (0226) turned out the other way from my prediction: the climbs lose little on Sanborn-style text, because a climb scored by quadgrams is pulled toward English and an X stop or a misspelling costs the true reading only a few quadgrams. The one cell that falls under its bar, F1.2 at length 13 (9 of 12 against 4 of 5), falls by less than one plant, and K4 ranked last of 13 there; the pre-registered rule still sends it back to open, waiting for Alexis. D1 measures design 2 on these same plants, so a cheaper decider with more power would settle it. 0226 called no ctx.progress (drafted before #97); A6.3's draft now does.

A6.3 (0227) surprised me on reversal: the climb finds reversed messages as often as forward ones (7 of 8). A reversed text keeps English letter frequencies and many common quadgrams are also common read backwards, so the true key still scores above the copies. The two masks that dilute the message, an X every kth letter and junk between message letters, are not found by any of the three ways, so the free-alphabet closes are now stated as 'for unmasked or reversed English'. Going further would need a search that keeps the mask; the queue has none, and I add none. 0227 calls uv run --with numpy itself for A13's battery, since start_experiment.sh runs without numpy. The judge's own masking of places 22-34 and 64-74 would have hidden 24 unmasked letters, so spacers were inserted there. My record script for 0227 stopped half way on a stale anchor and the commit went ahead; the clue register and this entry followed in a second commit.

0228 changed what I believe about design 2. Its power was measured on 5-8 plants per cell and quoted as 5/5 or 6/8; redrawn here it is 2/5 at L13 and 6/12 on Sanborn-style text at L23. Pooled with the earlier draws both sit under their bars, so F1.1 Beaufort 23 joins F1.2 13 as reopened, waiting for Alexis. Power per run does not climb with more runs because the copies' best climbs as well; at L23 one full run is as good as ten. The next D1 measurement should bound single-run power with two dozen plants per class, and look for a different lever for two alphabets. A graceful stop was requested during 0228 and the request was gone by the end of the run.

0229 settles what 0228 hinted: design 2's power for one free alphabet does not depend on how many runs it gets, because each extra run lifts the copies as much as the plant. At length 26 (one check) it is barely above a coin toss on clean Carter, 13 of 24, against the 5 of 6 that closed the cell. Every free-alphabet sampled close now rests on a power figure that, redrawn with enough plants, is lower than the bar it claimed: F1.1 23 and 26 and F1.2 13 are open and wait for Alexis. D1's strict rule ('at least design 2's power') cannot be met by a noisy comparison; a margin is his decision (🛑 issue).

F13.1 closed with no run (reports/f13-solvability-map.md): without the 24 known letters, 97 letters of English carry about 173 bits by quadgrams. Most cells the known letters decided exactly fall into the 'better model' column without them; F13 adds little where they hold and matters where they may not. Pivot P20 to F13.

Mistakes today, both mine. A run chained after a file write that failed recorded a duplicate (0223): check the header of attack.py before every run, in its own command. 0224 handed gate 4 a smaller set of controls than the reading had already failed against, and the harness kept it: the same gap as #88, now #94. champion.json names 0224 until Alexis decides; from here on no experiment re-submits an older reading.

F13 (ticket #85)

F13.4e's other families were blocked at the desk with reasons (Gromark by cost, trifid and M-94 by power). Session ends here with F13.4f designed but not built (drafts/F13.4f-design.md); #100 and #101 wait for Alexis.

The first result in the record to beat its copies twice. My reading of it: the excess lives where every one of K4's earlier oddities lives, in the order of the carved letters (the width-7 doublets, the width-21 repeats, now a width-19 read with a period-2 key), and the n-gram model rewards that texture; the judge, which reads for words, barely separates it, and no ordering puts a known word in place. I wrote the rule for 0239 as 'at most 15 of 300'; it came out 14, so by my own rule it is word-level. I report it as such and as weak.

What F13.2 says: at 97 letters, statistics can tell K4 is not an alphabet swap, a transposition, a short periodic key or (fairly surely) a Hill or trifid, which the cribs already said; among the flat families nothing in the statistics separates them, and against its own shuffles the classifier has no power for any of them (0 of 12 plants found). The ciphertext-autokey cell rode on K4's known width-7 pattern and its uneven letter counts by quarter, the same features 0056 and 0168 already reported. My second run of the day was started with one test failing (the missing crib map of the errored 0230); the test only checks figures, but the rule is all tests pass first, and the chain pytest | tail hid the exit code. From here: run the tests as their own command and read the result before starting.

0233's first dry run gained 0.6 bits per letter with n-grams trained on Carter's first 70%, scored on its last 20%: the book's own words. I added a no-Carter arm and moved the rule to it before the real run, and said so in the record. The honest number for a message not written like Carter is 1.95, not 2.38; on K1+K2 even the Carter-trained model gives 2.00.

0235 ran on Modal for 29 minutes and was then cancelled, at the moment one of my wait calls, which I had piped through tail and given no maximum, was moved to the background and stopped. The harness fell back to the laptop and started again (4.1 hours). From here every wait is tools/wait_experiment.sh 540 with nothing piped, so no call outlives its limit.

2026-10-25

Stage 2, step 3 (A13, ticket #75), resumed. The 2026-10-21 to 10-24 sessions closed A13.1 and A13.2 (no run; see reports/a13-structure-check.md), regenerated pass 1's copies, and ran 0215 and 0216 but left no notebook entry; they are recorded here.

A13 (ticket #75)

A13.3 is marked blocked as a test of masks, not closed: across 0216 and 0217, 1 of 22 masked plants survived the climbs (unmasked 3 of 6). A climb fills the free letters with forward-English junk and overwrites the mask, so the battery on climbed readings cannot see one. Mistake carried from 0216's design: its plants were added only after the copies, so the battery's power on climbed readings was unknown when the 112 cells were pre-registered.

Mistakes today: an interactive cp and rm stalled two commands (use /bin/cp -f); 0218 loaded a frozen routine whose paths are relative to its own folder; 0219's controls came from one experiment for readings of four, which the harness kept. A run that re-submits another experiment's readings must give gate 4 that experiment's controls.

Left by the last session and done today: 0216's figures (drawn, header and worksheet overflow fixed), the copy-tool fix and regenerated copies committed (6917a1f), the comment on #75.

2026-10-20

Stage 2's control table had no open rows, so the loop went back to the family items reopened on 2026-10-19 and 2026-10-20 (#78, #73): F6.20, F6.21, F2.4, F11.5, F5.3, in rank order.

F6 (ticket #13, reopened)

F2 (after pivot P17, ticket #20 reopened)

F11 (after pivot P18, ticket #58)

F11.5, the poem code as SOE agents used it, blocked by cost without a run. Two five-word picks from K1-K3's 163 words, one per pass, are 8.1 x 10^17 key pairs (59.5 bits). The 24 known letters could decide that only at short table keys (14 or more checks), and nothing narrows the search: a known letter's carved place depends on both whole keys, so there is no constraint to propagate, and enumeration would take tens of thousands of years. A single pass with one five-word key (9 x 10^8 keys) would run in about an hour, but it is not the agents' method, so it was not run as a stand-in (the instruction: a weak test is marked blocked, not run). F11 closed again; pivot P19 to F5.

F5 (after pivot P19, ticket #15 reopened)

F9 has no open item: every open item in order-of-work.md is now closed or blocked (STOP_AFTER).

How the grille search works. A turning grille is not a sweep: 10^15 cards per procedure. The search walks the top half of the grid; each cell and its 180-degree partner share one prefix count, so both of their message places are known at once and about two thirds of the early cells land a known letter. With a key word every landing is a check and the tree stays tiny; with a free key a slot is only checked once it repeats, which is why free keys stop at 6 letters (rows) and 4 (columns). Counts are distinct landing maps: cards that differ only where unknown letters go are one reading of the known letters.

Mistakes. - Counting cards instead of landing maps. The first design counted cards; a planted card then showed 1,000 fitting "cards", all equivalent on the known letters. Fixed before 0199 ran. - 0200's budget. I scaled one measured setting to the whole column-mode key-word arm, assumed full speed on 8 workers (they ran at about 72%), and left the arm without a clock check: the run was killed at 3,660 s with no record, and its 8 pool workers kept running until I stopped them by hand. - A check that lied. The single-card check in the self-check capped its walk at 1,000 nodes, which column mode's guesses exceed, so it reported false misfits. The self-check caught it, as designed. 0199 (rows) does no guessing and is unaffected. - A dead end. One walk per word over all 48 key-word settings at once (a bitmask) was slower, 13 s per setting against 5.8: with 48 settings alive, some setting survives nearly every landing, so the tree barely prunes. - Plants queued last. 0201's clock guard cut its English key-word plants because I queued them after the copies. Queue plants first. - Figures before the next run. I started 0200 while 0199's crib map was still missing (one failing test). - 0202's six families did not fit in 30 minutes; its time check skipped three, run as 0203.

Stage 2, step 2: slips at the known places (A1, ticket #76)

| 210 | A1.3 | Running keys from the named texts with up to 7 slips, exact. 0004/0017/0021/0045/0047/0078 in one pass (1.36 x 10^9 trials) through a pigeonhole index (7 slips leave one of 8 blocks of 3 known places whole): no setting on K4 or any of 20 copies; three planted slipped messages found, judged 90-96. Prediction held. | | 211 | A1.3 | 0117's shifts and moves with up to 3 slips, exact, compiled. Both orders, 27,852 routes, 12 tables, 26 shifts: nothing on K4 or 10 copies; both plants found. 0098's free alphabet blocked without a run (one slip: copies fit 0.4-1.6% of 80,676 settings, reading undetermined). A1.3 closed on fixed and keyword tables. Prediction held. |

| 212 | A1.4 | Ciphertext autokey and progressive key with slips, exact, compiled. 487,734 autokey table setups, every lag, 2 slips at known places or one lost step: nothing below lag 68 on K4 (copies 67-69); progressive key on the tables, 2 slips: nothing below 25. Judge: K4 4, copies 12. Five plants found (60-93). Prediction held. | | 213 | A1.4 | Plaintext autokey with 2 broken links or one lost step, exact, compiled. Lags 1-52 on 35,343 tables: nothing below 24 (copies 17-24); lags 26-29 read in bulk and judged: K4 4, copies 12. Three plants found, one whose slip runs on through its chain (85 against at most 18). A1.4 closed. Prediction held. |

| 214 | A1.5 | A move then the table, two slips, exact, compiled. 1,847,590 distinct landings (0110-0114 and the type-1 library), both orders, 8 tables, keys 1-26: shortest fit 18 after the move, 16 before, as the copies (16-18, 16-17); K4 above every copy in 1 cell (copies 0-3); judge K4 6, copies 12; plants found (70-92). The free alphabet after a move (0129) blocked without a run. Stage 2, step 2's table has no open row. Prediction held. |

What a slip costs a free alphabet. With the sculpture's tables a slip is expensive: below length 24 at least 7 checks remain and three slips cannot clear them. With a free alphabet the 24 equations already leave room, and two or three dropped equations are enough for an alphabet to fit almost any text from about length 10 (one alphabet) or 4 (two). The plants show it from the other side: a message planted with three slips at length 12 fits with none. So "nothing found" there says nothing; the cells are blocked, not closed. The judge cannot help, because a free alphabet that fits leaves most letters undetermined.

Mistakes. - Plants placed where they cannot be told apart. 0209's pre-registered plants (4, 5, 7) sat where the copies already fit; the dry run showed it, and plants at 3 and 9 were added before the real run, with the change written in changed. The prediction stayed as registered and failed for the first three. 0208's length-12 plants failed the same way. - Plant texts read back in the wrong order. 0211's first dry run laid the plants out as [plant 1, plant 2, copies] and read them as [plant 1, its copies, plant 2]: a plant "not found" and a copy "with a hit". Found in the dry run, before the record. - Ran 0211 with a test failing. 0210's crib map was not drawn yet and tests/test_figures.py failed; I chained the test and the run with ; instead of stopping. The cipher tests passed and the run is unaffected, but it is the same slip as 0200's (figures before the next run). Stop on any failing test. - Slips applied after enciphering. 0212's first ciphertext-autokey plant changed carved letters after the whole text was enciphered; by hand the next key letter is the letter he wrote, so the slip belongs inside the chain. Fixed before the run. (In plaintext autokey the key is the message, so changing the carved letter afterwards is the right model.) - ctypes and big arrays. Building C arrays by unpacking millions of Python ints, and passing a Python int for a C long without argtypes, both crashed (segfault); arrays now come from array.array buffers with explicit argtypes. - 0214 killed before its record. The judge stage stalled on slow API replies (one 30-minute gap) and the background shell's 40-minute limit killed the harness after the attack had finished, before the record was written. The partial folder (raw.json only, never committed) was moved aside and the run repeated unchanged with --budget 3600; deterministic seeds and the judge cache gave the same readings and scores in 438 s, no new calls. - cp is cp -i in this shell: a background copy of the new attack.py silently declined to overwrite, and a dry run tested the previous experiment's file. Use command cp -f.

2026-10-19

Stage 2, step 1: a positive control for every closed item (A3, issue #73). The queue is empty: every row of the table is passed, cited to an own plant, not applicable, or failed for lack of power with the item blocked.

What changed. - F1/2 is blocked above period 53. The failed row from 2026-10-18 (C-F1-2b) was the check, not the search. Judged the way 0034 judged K4, against its own shuffled copies, a planted text is told apart at 53 (margin 0.74 against at most 0.34 for an unplanted period). At 80 it is not (0.03 against 0.12). This is 0136's bound in practice. - F12.2, F12.4 and F12.6 move from closed to blocked. Their tests do not see planted structure of the kind they look for. A period-7 key gives p 0.004 and is not outside 1,000 shuffles; real probable-word placements leave a planted text below its copies. Their "nothing found" says little. - New item F5.3, found while writing C-F5-1d: 0054 tested Gromark growth rules only up to base 15 on its alphabets, so bases 16-25 there are untested.

Mistakes. - Concurrent runs. The helpers I started to write specs ran short controls side by side, load average 89, while hour-long clock-bound climbs ran. Stopped; the climbs still finished. - Three specs judged wrongly and were rerun: - C-F1.6: 0147 lists only 200 fits. - C-F1.6c: its plant found no place for seed 7373. - C-F6-2: wrong keys into 0081's counts. My first fix was also wrong: levels are ints inside the run and strings in JSON. - Two checks were stricter than the attack's own verdict and were matched to it, with the first judgement kept as result.failed-1.json: C-F1-2 (95/97 letters required) and C-F4-1 (the reading required where 0040 judges by cubes). - The opposite case, one check looser than the evidence: C-F1-2d first passed by a margin smaller than an unplanted period's. It was re-judged as no power, with result.passed-1.json kept.

Weaker identifications, recorded in the table. - C-F6.9 and C-F6.9b by the top survivor's check count. - C-F6-5b by variant only. - C-F6.7: copies counted to 8 checks only. - C-F4-1: cubes found, reading not returned (5,000-cube cap). - Several own plants report counts, not the planted setting: 0187, 0191, 0192, C-F5-1d.

2026-10-17

F1 continued (ticket #14), after the run that started on 2026-10-16 (0136-0153 are recorded there).

F6 again (after pivot P7, ticket #13)

F12, Stein's way (after pivot P8, ticket #53)

F12.1 blocked without a run: no image of the copper's K4 section at letter resolution is in the repository (Panel4Grid is a blurred video frame of a worksheet; the Blender model needs Blender); the NYT 2010 typeset clue agrees with the transcription at all 97 places.

F12.7 closed by subsumption without a run: Stein's column method (every shift of each column, scored by letter frequencies, then a crib) finds periodic keys on a known table; the exact sweeps of 0005 test every such key on the standard and KRYPTOS tables against the 24 letters, and the lengths they leave live (27-29, 53 up) were shown to fit coppers equally (0034). F12 is finished: F12.1 blocked, F12.2-F12.7 closed. Pivot P9 to F3.

F3 two-part key with a combiner (after pivot P9, ticket #16)

F3 is finished: F3.1-F3.7 closed (0173-0180), with two weak residues blocked: the sandwich's 8 long length pairs (1-2 checks) and the stack's few-check cells; 'the point' as a place blocked without a survey. Pivot P10 to F2.

F2 masked plaintext (after pivot P10, ticket #20)

F2 is finished: F2.1-F2.3 closed (0181-0183); a code layer, phonetic spelling or another language stay blocked (they change the known letters or need a codebook). Pivot P11 to F4.

F4 Sanborn's visual systems (after pivot P11, ticket #21)

F4.4 closed by subsumption without a run: what the extra L, read with HILL as a marker matching YAR, could select is a row or key letter (a key of length 1-4 such as L, HILL, YARL on the KRYPTOS table: every periodic key to 26 is dead, 0005), a starting place in the tableau (running keys from the tableau rows at every start, forward and backward: 0017), or a plate to lay over K4 (0089); its place as a number is in 0186.

F4.5: the spelling difference (Antipodes' UNDERGROUND makes K2's carved RTBJ into ETBJ, one carved letter, R to E, at place 178) as a key fragment is a one- or four-letter key (dead, 0005), and place 178 was a reading in 0178; closed by subsumption. "The order is shifted a little" as a reading order needs Antipodes' own line layout for the K4 section, which is not in the repository: blocked until a transcript or photographs of Antipodes are supplied.

F4 is finished: F4.1-F4.4 closed (0184-0186, F4.4 by subsumption), F4.5 closed for the spelling and blocked for the layout. Pivot P12 to F10.

F10 alphabets that change after every letter (after pivot P12, ticket #57)

F10.3 blocked without a run: deck-of-cards key streams (Solitaire 1999, Mirdek 2000) postdate the sculpture (1990), against A9 (the method had to be known to its creators in 1990); and a free deck (54!, about 237 bits) far exceeds what 24 known key values (about 113 bits) and the English bound (130 bits) can pin down; no published known-plaintext attack recovers a deck from 24 outputs.

F10 is finished: F10.1 and F10.2 closed (0187, 0188), F10.1's free left wheel and F10.3 blocked. Pivot P13 to F11.

F11 agency hand systems (after pivot P13, ticket #58)

F11 is finished: F11.1-F11.4 closed (0189-0192), with the Jefferson wheel and M-138-A strips blocked (alphabets not to hand), free word picks for the poem code and free tables for the boxes not run. Pivot P14 to F8.

F8 Hill (after pivot P14, ticket #17)

F8 is finished: F8.1 closed for 2x2 (0194), blocked for 3x3 (too few equations); the older undecided Hill settings stay blocked. Pivot P15 to F5.

F5 Gromark (after pivot P15, ticket #15)

F5 is finished: F5.1 and F5.2 closed (0195, 0196); base 26 with lag 6 and longer two-term lags blocked by cost. Pivot P16 to F9.

F9 substitution, then a move (after pivot P16, ticket #18)

F9.1's list, the hand moves built since 0106 with their sizes: compass readings and pairs 110,820 (0159); keyword-disrupted 327,440, triangle 654,876, interrupted 332,817, trapezoid 89,708 (0164); keyed blanks 1,450,196, row reshuffles 361,698, French diagonal 2,264,476 (0165); EVA 3,840, Chiffre XIII's mask 4,497,024, YAR 24 (0166); the copper's layout 73 (0184); poem-code double columnars 6,118 (0190); mixed matrix triples about 105.5 million (0158); keyword triples 20.4 million (0162); Nihilist squares 116 million (0167). Counts include inverses. None of these is among 0106's 1.86 million.

F9 is finished: F9.1 closed (0197, 0198); routes outside every built library stay unbounded. This is the last family before STOP_AFTER (F9).

2026-10-16

Family F1 under the fixed order of work (order-of-work.md, issue #29), items F1.1 to F1.4, ticket #14.

Paragraph on 0126-0128 (F1.4). The list of hand key schedules, written before the tests. From C20 'layer two': (c) the second plate as a running key, already done with the sculpture's texts (0017, 0090, 0117); (d) the tableau's row two, taken as every carved tableau row used as a repeating key (A); (e) K5 as key, blocked (no text). Hand rules for a key word W of unknown letters: (B) skip one letter of W every m letters; (C) use each letter r times; (D) W forward then backward; (E) step through W by triangle or square numbers; (F) restart W at each carved line of the plate. Already covered: the Berlin clock (0079), Carter dates (0038), progressive per repeat (0011, 0042), restart at each word (0101), autokeys, a shift per carved line plus a word (0088). Every rule on the list is dead on the standard and KRYPTOS tables. On free alphabets the rules leave consistent settings at the coppers' rate, which by 0120 no climb can tell apart, so that residue is blocked like F1.2's.

Mistakes in 0126: I estimated the run from K4 alone, where the decider takes about 1 ms. On a few copper groupings it ran to its million-node limit, the clock check broke out of each rule's loop, and the record shows zeros for four rules it never tested, without recording coverage. 0127 and 0128 lowered the node limit, counted undecided cases, recorded coverage and ran texts in parallel. Lesson: record coverage in the bounds whenever a loop can stop on the clock.

Paragraph on 0123-0124 (F1.2). Two free alphabets are closed exactly at 18 of the 26 lengths. At the eight that stay consistent (8, 13, 16, 19, 20, 23, 24, 26) nothing cheaper than an English climb remains, and 0120 showed a climb on one free alphabet already has weak power at 23 and none at 26; two alphabets add 25 free places, so a climb here would be weaker still. Recorded blocked, not run. Length 19 was the one result outside the coppers (3 of 100); against 1,000 fresh coppers it is about 1 in 40, and the look-elsewhere statistic I chose was generous to K4 (lengths 15 and 17 are as rare but missed the cut by one copper), so the honest reading is p of a few percent, like 0102's period-3 cell. It rests on one coincidence in the known letters (R under P at 28 and at 66, 38 apart), which any key repeating every 19 or 38 letters would produce, but which also happens by chance once in 26 tries. Noted in the tree, not chased.

Paragraph on 0120. The climb cannot find a planted answer at these lengths. In dry runs before the run (recorded in the record's hypothesis) it could not even return to the true alphabet from two swaps away: one swap moves letters in every slot and changes the forced key values with them, so the landscape is close to random. The pre-registered "found" criterion (a plant's climbed score above every copper) measures detection, not recovery, and at 23 it was met 3 times in 6 only because English under the cipher climbs a little better than shuffled letters, not because the text came back. So length 23 is a weak test, about even odds of noticing a true Beaufort-23 message, with K4 near the bottom of its coppers; length 26 (one check) cannot be decided by any climb this size. Also found while preparing the run: the harness drops the attack's controls list (_runner.py never copies it), so the shuffled-copper gate reports "controls 0" for every candidate; filed as #45, not worked around.

Paragraph on 0119. The added form dies for a reason one can check by hand: S sits under S at 33 and K under K at 74, and with one alphabet on both sides and the key added, a letter that encrypts to itself needs key 0 in its slot. At every key length from 1 to 26 another known letter shares the slot of 33 or 74 and is not its own carved letter, so that slot would need key 0 and a non-zero key at once. This is new for free alphabets (0097 tested only lengths 3, 7 and 21, by a relaxation that can refute but not confirm). The first exact solver, a plain search with propagation, blew up on the dead lengths (product of independent choices); it was replaced before the run by linear algebra mod 13 and mod 2 with an exhaustive search of the mod-13 solutions, and cross-checked on 40 coppers against the plain search (no fit it found was called dead). The prediction, written before the solver existed, guessed "fewer checks than free places, so most lengths fit"; it ignored that a one-to-one alphabet packs about 20 letters into 13 residue classes mod 13, which the known letters make tight.

F6: a move, then the table (after pivot P5, ticket #13)

F1.1 blocked first: its last cells (Beaufort 23 and 26) can only be judged by an English climb, which 0120 showed recovers no planted text at that size, so the item was marked blocked rather than tested weakly. Every F1 item is closed or blocked; pivot P5 to F6, ranking unchanged.

List for F6.4, written before 0135 ran: the hand ways of padding a grid of 97 letters, per stage. Where the h w - 97 blank cells go: P1 end of the last row (the usual ragged grid, 0008, 0083); P2 start of the first row (0082); P3 start of the last row; P4 end of the first row; P5/P6 down the last column from the top or the bottom; P7/P8 down the first column from the top or the bottom (only when there are no more blanks than rows). Between two grids the blanks either vanish (drop: the second grid gets 97 letters again) or are copied out as dummy letters and struck out at the very end (keep: the second grid gets h w symbols). Completing the grid with nulls that stay in the carved text is not on the list, because 97 is prime and every rectangle would leave nulls among the 97 carved letters, which the known places rule out only case by case; the "?" as the 98th cell is 0086.

Paragraph on 0133. The cell that keeps coming back: two unknown alphabets, the move first, key length 3. 0097 (by a relaxation), 0100 (50 fresh coppers) and now 0133 (exact, 10 more) all put K4 at or above the top of its coppers there (16 moves here against 1-12). These are not three independent replications of a signal: K4's count is the same object each time and only the coppers are fresh, and the cell was first picked out of 52 by looking. 0102 measured it against 400 shuffles at p 0.043 and against 400 copies keeping the width-21 columns at p 0.10. By the rule fixed before this run (K4's count of cells above every copper against each copper's count against the rest) it is inside chance, so the queue did not stop. Recorded as the most persistent marginal cell in F6, not chased.

Mistake in 0131. I timed the two-alphabet decider on 60 moves while 0130 was running and read 0.46 s per move as "about 0.2 s unloaded", then sized the run on that. The cost is not spread evenly: lengths 1-10 take about 3 ms per move, 11 and 12 about 0.2 s, and the long lengths more, with rare 60-second searches at the node limit. The workers stopped on the clock with the coppers' share of moves barely started, and the comparison needs moves done for every text, so it came out empty. Lesson: time each part of the parameter range separately, unloaded, before sizing a run, and make the comparison robust to a short run. 0132 repeated the mistake in a new form: I timed 60 K4 moves, saw a mean of 1.2 s on the long sample, and did not look at the shuffled texts' tail at short keys, where one setting in a few hundred costs seconds. 0133 caps the search at 2,000 nodes (undecided counted per text) and groups each move's eleven texts in one worker, so a cut-off still leaves whole moves to compare.

Paragraph on 0129-0130. 0129 and 0130 are one test split in two, because both orders did not fit one 30-minute budget: the exact decider costs about 7 ms per fitting setting and most settings from length 10 up fit. A random witness hunt before the search, meant to speed up fits, made them slower (300 failed tries cost more than the search saved); numpy is not in the environment, so it was dropped rather than vectorised. The comparison with coppers uses a statistic fixed before the run: the number of cells where K4 is above every copper, against the same count for each copper against the rest (so a copper's luck sets the bar, not a guessed threshold).

F1.5, then every family through F9 (after pivot P6, ticket #14 and the family tickets)

Paragraph on 0137-0138. 0137 looked like the first decider with power: ten planted texts in twelve climbed above every scrambled copy of K4. Reading the result, I saw the comparison was unfair. A planted ciphertext differs from K4 in its letters, not only their order (index of coincidence 0.039 against K4's 0.036; shuffles of a plant fit length 23 43% of the time, shuffles of K4 rarely), and the climb rewards those letters. 0138 compared each plant only with shuffles of itself: 6 of 12, against 11 of 12 for the same plants versus K4's copies. The climb does read some English order (6 against the 1.7 luck gives), but at even odds, and never gets a planted text back. Mistake: 0120's bar, which 0137 kept, compares plants with the target's copies; power must be measured against each plant's own copies. 0120's 3 of 6 has the same flaw. Lesson: a power test compares like with like, changing only the property the decider is meant to read.

Paragraph on 0136 and step 2. The bound says which cells a decider could judge, not whether a search can find the key. Before designing step 2 I measured the landscape on planted Beaufort-23 texts (scratch, not a record): the true alphabet scores -4.26 to -4.41 on the full text, one swap away averages -5.2, the level 0120's climb reached from random starts. But a climb that keeps the known letters consistent at every step (swap two letters, repair with a second swap if a check breaks) returns to the exact plaintext from up to about 12 such swaps, and rarely from 15-20; 0120's "cannot return from two swaps" came from its penalty, not from the cell. A random alphabet is about 24 swaps away, so the question for design 1 is the success rate per restart.

2026-10-15

Plan for the day: run to experiment 50. Priorities, in order: explain the three statistics no generator reproduces (the width-7 doublet column, the eleven width-21 vertical repeats, Bean's closeness), then the untouched families (2 masking, 4 visual), then the one-letter error reruns of the strongest sweeps. Every diagnostic experiment gets ten or more shuffled controls. The notebook gets a line per experiment as it lands.

Lesson from 0025: every sweep must check the clock inside its innermost loop that can run long; the harness budget is advisory, not a kill switch.

From 0037: a diagnostic's controls must run at the same trial count as the real search. The record's two controls used 6,000 triples against 200,000, which made a chance result look like a lead; thirteen full-size shuffles put it back inside the noise.

From 0027: the width-7 doublet column is reproduced by nothing, random letters included, so it is either a fluke of about one in 300 or the trace of a construction outside everything simulated. Doublets at 19, 26, 33, 47, 68 are all 5 mod 7; in a period-7 additive system a doublet is a plaintext digraph with a fixed letter difference falling in one column, which is a natural mechanism, but period 7 is dead under every alphabet by the cribs alone (R and C both to P at 66 and 73). Gromark base 2 reproduces the width-21 repeats; 0013 tested only bases 10 and 26, so bases 2 to 9 are 0028.

From 0033: simulated annealing over trifid cubes with crib hits, even at coordinate level, plateaus at about 17 of 24 on a planted cube. A proper trifid solver needs constraint propagation on the cube coordinates, not local search. Built as 0039 and 0040: the equalities plus the all-different rule leave no cube at all for K4, while planted texts are recovered. The lesson generalises: when a cipher's key is a structure the cribs constrain algebraically, solve, do not search.

From 0034: the loss function's key-cost term is too weak. A 95-letter random key with 71 free slots climbed to fit English gives a crib-perfect text that the harness scores at loss 4.4, below the crib gate, and keeps as champion. The text is overfitting, as the identical score on shuffled K4 shows. Per program.md the ruler is not changed mid-run: the case is in issue #11 for a human decision, and the champion stands as a warning until then. Also: the key alphabet does not affect decryption under a fixed plain and cipher alphabet, so the 24 conventions were 8 distinct classes here; the extra 16 were wasted time.

Experiments 80 to 88: types 1 and 2 of directions.md (2026-10-15 night)

Alexis away; worked off type 1 (change plus move) and type 2 (sevens) in order, each checked first against the prior-work database. All nine reverted; no champion. Run issue #24.

Findings worth keeping: - Type 1 is closed for its four cheap gaps. Two repeating keys around a move, solved as a linear system (0080); autokeys of both kinds with K3's rule, grid turns and columnar (0081); hand padding, blanks on top or fillers carried through a second turn (0082); every triple quarter turn, 1.7 million routes (0083). All at the scrambled-copper rate. - Type 2's open items are closed too. Double columnar with one width of 7 in all 5,040 orders (0084); the ? as a 98th symbol in a full 7 x 14 grid, with autokeys (0086); a column word plus a row key, the one construction found that lines doublets up by column by design (0087), and the same with a shift per stretch of m letters or per carved 31-letter line (0088). The width-7 doublet column still has no construction that also fits the cribs. - Issue #26: ten records (0006-0081) read keyword column shuffles by the rank list, the inverse of the key order. 0085 reran true keyword columnar, single and double, with periodic and autokey keys: chance. The library's keyword order also drops repeated letters (ABSCISSA reads as ABSCI); 0084 and 0085 test the whole-word reading as well.

Mistakes: - Three predictions failed in detail at the margin (0080 low at three checks; 0081 four settings at four checks; 0082 and 0083 a period just above the control range, 0083 one coincidence at period 18 that decrypts to noise). In each case the excess was examined after the run, not before. - 0086's three-check excess came from 34 distinct check sets repeated by look-alike routes. Counting distinct check sets, not settings, should be the default for route sweeps. - Starting 0085 the first time, cp and rm prompted interactively and did nothing, so two aborted runs (0085 on 0084's code, then 0086) were started and killed within seconds and their folders removed before any record was written. Use /bin/cp -f and /bin/rm -f. - Family 6 took seven reverts in a row (0080-0086), past the five-revert pivot rule, because directions.md fixes the order of types; noted in the pivot log. - 0087's phase clock was not ticked, so it shows as unclocked.

Open: - Type 1 left: the two stages on different alphabets (not linear), two free alphabets at periods 13-26 (needs English scoring), turns with one carving error (type 7). Type 2 left: width 7 with two free alphabets, and a joint simulation that must make both fingerprints and fit the cribs. - Next in directions.md: type 3, keys read off the sculpture.

Experiments 89 to 118: types 3 to 8, the free-alphabet follow-up, then hand routes keyed by the dictionary (2026-10-15 night)

Alexis away overnight, asked to continue past 100. Worked through types 3-8 of directions.md once each, then followed the one cell that stood out. All eighteen reverted; no champion. Issue #24; issue #28 (source-text search).

Findings worth keeping: - Types 3-8 have each had a first exact pass, all at chance. Keys read off the sculpture by position (0089) or as running keys joined to every move (0090, and on an unknown alphabet, 0098); the Berlin clock with every move (0091); the message written along grid paths (0092); one wrong, missing or extra carved letter through moves (0093, 0094); riddle words dragged under every live periodic key (0095, weak); an interrupted key (0101); the copper or the message as its own key through K3's rule (0103, 0104). - Type 5 is closed by algebra, not by a run. Any reading of a cyclic table (by columns, diagonals, mirrored, from another start row) is an affine map of the alphabets with the key scaled or shifted; those are covered by 0071 and 0074, and a diagonal reading only restricts the key to even values. - No published text carries both cribs (issue #28: Internet Archive full text, 44 Gutenberg books, the web). - The width-21 repeats have a cheap explanation: any key repeating every 3, 7 or 21 carved letters, after any move, makes them about 50 times more often than chance (0096). On fixed alphabets those periods are dead; on free alphabets the test is weak (0097). The one free-alphabet cell above the coppers (Quagmire IV, period 3, after a move) went from p < 0.02 against 50 coppers (0100) to 0.043 against 400, and 0.10 against copies that keep K4's width-21 columns (0102): not a signal, and partly the repeats themselves. - 0087's premise was wrong (0096): a column word plus a row key does not line doublets up by column, because the row letter cancels inside a row. - Family 9 and the affine Hill are closed for every route set built so far (0105, 0106).

Mistakes: - My wait loops used pgrep -f run_experiment.py, which matched their own command lines, so they never ended and were killed by hand. Wait on the run log's decision= line instead. - 0089 and 0090 recorded misspelt family slugs (4-visual-systems, 6-matrix-transposition-then-tableau); the dashboard maps them. Check cut -f3 results.tsv | sort -u before choosing a slug. - 0090's worked example crashed (the Morse text is shorter than K4), so that record has none; the figure rebuilt one from the record's own functions. - 0092, 0093, 0096, 0101, 0102 and 0103 missed their predictions in detail; 0096's miss is the 0087 correction. - 0095's first dry run let words overlap the cribs and counted those as checks; fixed before the run.

Open: - Free alphabets at periods 7 and 21 need a stronger test than consistency (English scoring cannot beat its controls; a test on the forced partial alphabets might). - Routes outside every set built so far; three-term Gromark rules; plaintext masks that change letters by a code.

Experiments 50 to 64, run in the background (2026-10-15 afternoon)

All fifteen reverted; nothing was kept, and the champion is still experiment 34. Every run finished well inside the 30-minute budget (longest 0050 at 5 minutes).

Findings worth keeping: - The two fingerprints are real (0056). The width-7 doublet column and the width-21 repeats survive the look-elsewhere correction over widths 2-48 against 10,000 shuffles: corrected p 0.005 (0.018 among six-doublet shuffles) and 0.010. The pre-registered prediction said they would not. They still lack a construction. - Only ciphertext feedback makes the width-21 mark (0062). Of fourteen generators, only ciphertext autokey at lag 21 raises the repeats well above chance (5.4% against 0.2%); none makes the doublet column, and none makes both. Ciphertext autokey stayed dead when combined with columnar routes in either order (0063) and on tables rebuilt from K1-K3 words (0064). - Two structural exclusions, no key search needed. Pure transposition is dead because the cribs need three Es and the copper has two (0051). Every cipher with at most 25 output letters or an even-length rule (Playfair, bifid, four-square, ADFGVX, a 24-letter Weltzeituhr ring) is dead because K4 uses all 26 letters and has 97 (0052). - Tables rebuilt from every K1-K3 word and the 2025 letter's words add nothing for periodic keys (0053), Gromark (0054, smallest base 17), Hill (0055), two-word keys (0059) or ciphertext autokey (0064). The vocabulary was not the limiting factor. - The copper off by one letter through the two-word test (0050), filler letters chosen by letter (0057), the table then keyed column shuffles from K1-K3 words (0058), the K2 coordinates as a Hill matrix (0060) and the misspelt letters as a second key (0061): all at chance.

Mistakes: - Walkthrough arithmetic slipped four times and was caught by checking the numbers before the run (0053, 0054, 0055, 0056), and once after it: 0052's record puts I at place 16, not 17. Checking the walkthrough against the code before running is now routine. - Two predictions were wrong in detail: 0057 and 0058 expected nothing below period 26 and got periods 24-25 at chance rates; 0058 ran no control to measure that rate, and the forced fragments at 24-25 were not word-checked in 0057. - 0050's pre-registered count of distinct crib tuples was corrected to "about 50" before the run; the measured value is 48.

Open questions: - What construction makes both fingerprints? Ciphertext feedback at lag 21 plus a stage that also lines up doublets at period 7 is the lead; it must still pass the cribs. - Family 3 has now reverted seven times in a row (0014-0061) and family 6 eleven times; both should rest until a new key source appears. - The scorer decision (key cost, shuffled baseline) is still pending in issue #11; no key-completion climbs were run.

Experiments 65 to 79, run in the background (2026-10-15 evening)

All fifteen reverted; nothing was kept, and the champion is still experiment 34. Every run finished inside the budget (longest 0077 at 4 minutes). Run issue #22.

Findings worth keeping: - The fingerprint constructions are dead under the cribs. Only one recipe was found that lines doublets up in sevens: ciphertext autokey at lag 1 with a period-7 key, and it does so weakly (1.5% of samples against 0.1-0.3% by chance, 0065). Tested exactly, ciphertext autokey plus a periodic key at any lag and period is dead (0066), and so are lag 1 with period 7 and lag 21 at every period. Two-lag letter feedback, the one-stage way to make both marks, is at chance (0067); so is ciphertext autokey with one carved letter wrong, missing or extra (0068), and every block-of-seven reshuffle joined to it, in both orders (0077). The two fingerprints remain real and unexplained. - Gromark is closed for two-term rules whatever the alphabet. With a completely free mixed alphabet, base 10 (lags up to 6, 0069) and bases 2-16 and 26 (lags up to 5, 0076) leave no consistent primer on K4 or on shuffled coppers; planted texts are recovered. Same-letter cribs fix exact digit differences, which makes the test decisive. Family 5 marked exhausted-bounded; three-term rules with a free alphabet stay open. - New key sources revive nothing: alphabets one swap or one move from KRYPTOS, the C27(c) 'slightly different tableau' (0071); the 32 compass points and the 'what's the point?' letter's words (0072); plaintext autokey plus a periodic key on 161 word alphabets (0073); affine masks, Atbash included (0074); Sanborn's 1989 letter, the 1991 dedication pages and the 2025 open letter as running keys (0078, best 15 mismatches as on shuffles); key schedules from the Berlin set-theory clock (0079, best 8 of 24 agreeing, as on shuffles). - The doublets are real letters. QQ, SS and TT inside the known stretches carry NO, ST and IN, so the doublets cannot be fillers, and striking out the other three changes nothing (0075). - A block-of-seven reshuffle before or after a periodic key admits no period below 25 beyond chance (0070).

Mistakes: - Pre-registered counts were wrong four times and corrected before the run only once: 0071's variant count (975 to 925, corrected before), 0066's case count (294,912 counted lags with no equations; 221,184 tested), 0069's primer total (5,432,200 for 5,432,100), 0067's case count (5.2 million counted cases with no check; 1.93 million tested). - Two predictions failed in detail at the three-check level, 0067 (15 survivors against 3-12) and 0073 (12 against 0-6). Both resolve into scattered or nested coincidences, but a prediction should allow for chance survivors at three checks when millions of cases run. - 0068's substitution tally counts the residuals a replacement letter is fitted to as checks, overstating redundancy by one or two. - 0070's fragments at periods 25-26 were word-checked only after the run. - 0079's prediction carried a numeric guess (19-20 mismatches) that a dry run on the copper showed wrong (16); it was removed before the run and is disclosed here. - The recorder stopped once on a clue-register match (0071) after writing families.md and the notebook; the commit was finished by hand. - The harness once hung on an interactive cp prompt when restoring attack.py; /bin/cp -f avoids it.

Open questions: - What makes the width-7 doublet column? Every construction with a period-7 element that passes the cribs has now failed; one not yet tried is a second, independent stage such as nulls placed by a period-7 rule after encryption, or a homophonic substitution. - The width-21 repeats: ciphertext autokey at lag 21 made them, but it is dead with every addition tried (periodic key, second lag, one error, block reshuffle, word alphabets). - Three-term Gromark with a free alphabet; Hill with a free numbering; Sanborn's own charts (C27) beyond the alphabet. - The scorer decision (key cost, shuffled baseline) is still pending in #11; no key-completion climbs were run.

Scoring settled (2026-10-15, afternoon)

Alexis decided the open scoring questions (issue #23). First version, same afternoon: a hard gate on key size (100 bits). Withdrawn within the hour. Alexis asked where the requirement came from: it was criterion 4 of our own success definition ("a key a person could remember"), justified by K1-K3's short keywords and Sanborn's "words without a method is not solved". Neither holds up as a basis for a size limit. Three sections are a thin precedent and do not agree (K3 has no keyword), and Sanborn's remark is about showing the method, not the size of the key. A long key can have a short description: a running key from a named book.

Final rules: (1) the original four gates; (2) a reading must beat the same method on at least ten shuffled coppers (run() returns "controls"); no controls, no keep; (3) the harness counts the key by the length of its description (key words a few bits each, a named text and offset a few bits, arbitrary letters 4.7 bits each) and charges it in the loss, not as a gate; (4) lowest loss wins. Criterion 4 of the success definition now reads: a hand procedure from 1990, written down step by step, keyed by something with a short description rather than letters fitted to the known places; its source is Scheidt's 2011 remark (secondhand, via Bean, C5): "simple, can be remembered, and executed years later when used with the correct key word/s".

All records re-scored (tools/replay_rules.py, records untouched): no past reading passes the baseline, because no record carries a set of ten or more controls. Experiment 34 would fail on its own numbers anyway (its reading -3.70 against a shuffled best of -3.23). Experiment 48's best, -6.14, beat its smaller control set (-6.36 to -6.88), but that set was not ten full-size runs. There is no champion. The dashboard now recomputes every loss under the current rules, keeping each record's own figure as history, so one number shows everywhere.

Lessons: a success criterion has to be a gate or a score in the harness from day one, or the loop optimises around it; and a criterion needs its source written next to it, or it hardens into a rule nobody chose.

2026-10-14

Decisions

• Success means a reproducible method, not words: the 97 letters must carry the cribs at 22-34 and 64-74, read as English, re-encrypt exactly, and come from a memorable key and a 1990 hand method. No external oracle. Every experiment leaves a bounded negative.
• Loss is lexicographic: ten points per wrong known letter, then the English deficit, then key cost. The crib gate at ten is where a solution first becomes visible.
• Records carry four prose fields written before the run: expert hypothesis, plain-words version, prediction, walkthrough. They are not edited after the result; corrections go to the families table and the issue thread.
• Phase clock: design, implement, test, with run and record added by the harness, and a pause tick for time handed back to a person.

Built

Harness (run_experiment.py, _runner.py, gates, scorer, 19 tests), the frozen cipher library, the knowledge base of 72 sources with a clue register of 30 entries, the families list, the dashboard, the phase clock. Dashboard changes from review: plain words first on each record, walkthrough beneath, numeric ids, crib gate explained beside the chart with the 24-letter strip, axis in loss points with "n wrong" readings, unclocked phases named, record tables that wrap.

Experiments 1 to 20, all reverted

Findings worth keeping

• The crib-consistency test for tableau systems depends only on the plain and cipher alphabets and on Beaufort versus the other modes; the key alphabet drops out. The 24 conventions are 8 distinct cases for any such sweep (0006).
• Substitution then transposition is the only construction simulated that reproduces the width-21 repeats, and it is dead for every enumerable route (0018, 0019). The repeats remain unexplained, as does the width-7 doublet column, under every generator including random letters.
• A crib-fitted construction passes the crib gate by design (a Hill matrix solved from the blocks, a fully chained autokey). The English deficit must carry the verdict, and the record must say when the cribs were built in rather than found (0012, 0015).

Mistakes

• 0007's phases were ticked back to back in one command, so its design time is lost.
• 0016 and 0010 set prediction tolerances from two shuffled controls; the max of two is too noisy. Ten or more from now on.
• 0017's record says the carved panel is 869 letters; it is 865.
• 0018's design clock ran across a pause between turns. The pause tick now exists.

Open at close of day

The three unexplained statistics. Family 2 untouched for want of a concrete mask. Family 4 touched only by the 25-letter-square exclusion. Routes outside the enumerable sets. Alphabets built from words outside the 61-word vocabulary.