Experiment 198

“F9.1, second part: a one-to-one substitution, then each move in the three compiled libraries (mixed matrix triples, keyword triples, Nihilist squares): exact”

F9.1's list, the three entries 0197 left out because their builders are compiled into their own testers: 0158's mixed matrix triples (three stages of rows-of-w readings, every width 2-96, now including the all-narrow triples 0134 had covered for keys only), 0162's triples with a keyword columnar, 0167's Nihilist square with three blanks at eight places and every key of each order. Each experiment's own C builder is reused unchanged except its per-route test, swapped for 0106's one-to-one test (equal known letters on equal carved letters, different on different); survivors are counted per text. K4 against the same shuffled copies those experiments used.

revertedstatus
experiment 197parents
38 stime, all phases
0candidates
0/24known letters
unclocked
1

The experiment method

What the method does with the 24 known letters.

The same check as 0197, letter swaps followed by a shuffle, for the three biggest families of shuffles the project has built: about 240 million of them.

1.1

The method at work

The carved letters go in at the top; the reading comes out at the bottom.

OBKRUOXOGHULBSOLIFBBWEASTNORTHEASTOTWTQSJQSSEKZZWATJKLUDIAWINFBBERLINCLOCKWGDKZXTJCDIGKUHUAUEKCARIN: THE COPPER, ALL 97 LETTERS, THE 24 KNOWN PLACES IN ACCENTletters swapped by one code alphabet, then shuffled: what the swap demands of the moveT at 25, 29, 34: after the move all three must show one carved letterE at 22, 31, 65: the sameEASTNORTHEASTBERLINCLOCK24 known letters, 13 different; 9 repeat (ochre). Different letters must land on different carved letters.routes where one code alphabet fits all 24 known letters: the three largest libraries, each run by its own builderthree stages of reading in rows of any width (0158)K410107,012,733 routes; 380 of 380 first stages donethree stages with a keyword columnar (0162)20,370,476 routes; 223 of 223 first stages doneNihilist squares with three blanks, every key order (0167)no route passes116,121,600 routes; 80 of 80 jobs doneeach row: K4, then ten scrambled copies; 243,504,809 routes in all, every job completedOUT: NO READING; A CODE ALPHABET BEFORE ANY BUILT MOVE DOES NOT FIT K4EASTNORTHEASTBERLINCLOCK
the idea

The same question as 0197, a fixed code alphabet first and a shuffle after, for the three largest families of shuffles, whose builders live inside compiled code.

the check

Each library's own builder, unchanged, with its per-route check replaced by the code-alphabet check: repeated known letters must land on one carved letter, different ones on different.

the bound

None of 243 million routes passes on K4 or any copy. With 0106 and 0197, every move the project has built is closed for a code alphabet first. F9.1 closed.

2

Best candidate against the known letters

This experiment produced no candidate: the search ruled everything out before a full text was built. Its product is the bounded negative in section 7.

3

Walkthrough, by hand

Redo the method on a few letters with pencil and paper.

  1. Take one of 0158's triples: rows of 30 read by columns, rows of 9 read by reversed columns, rows of 41 read clockwise.
  2. Follow each known letter to its carved place.
  3. The three Es must all show one carved letter; the other repeated letters likewise; different letters different carved letters.
  4. One mismatch kills the route; a route that passes is counted.
  5. All three libraries, on K4 and on scrambled copies.
the worksheet: the first steps by hand, on squared paper
REUSING A BUILDEREach library generates its routes insidecompiled code and hands each one to asingle check. Only that check isswapped: the routes are exactly thosethe original experiments tested.Every job finished: 380 of 380 firststages for 0158, 223 of 223 for 0162, 80of 80 for the Nihilist squares.243,504,809 routes in 38 seconds; nonepasses on K4 or a copy. The record holdsno planted-text test.
4

Worked example, generated

The same steps run by the code on the real letters.

the one-to-one test inserted into each library's C source:
for (int e = 0; e < 24; e++) land[e] = wh[PIDX[e]];
    {   /* one-to-one substitution test (F9.1): survivors counted at period 0, order A */
        for (int t = 0; t < T; t++) {
            int a_[26], b_[26], ok_ = 1;
            for (int x = 0; x < 26; x++) { a_[x] = -1; b_[x] = -1; }
            for (int e = 0; e < 24 && ok_; e++) {
                int c_ = CI[0][t][land[e]], p_ = PI[0][e];
                if (a_[p_] < 0 && b_[c_] < 0) { a_[p_] = c_; b_[c_] = p_; }
                else if (a_[p_] != c_ || b_[c_] != p_) ok_ = 0;
            }
            if (ok_) live[(0 * T + t) * (PMAX + 1) + 0]++;
        }
        return;
    }
5

Hypothesis, for a cryptanalyst

Family, key space, the constraint under test, and the clues it reads.

F9 (substitution first, transposition last; the Zodiac 340 construction), A9. Model c = route(sigma(p)), sigma any permutation of 26 letters; 24 known letters with 13 different give 11 equalities and the inequalities. Statistic: surviving routes, K4 against copies.

6

Prediction

Written before the run; the result decides it.

No route survives on K4 or the copies. Zero candidates.

7

Method

  1. Load 0158, 0162 and 0167; replace only the per-route test in their C source with the one-to-one test.
  2. Run their own job lists through their own workers (8 processes).
  3. Read survivors per text from the counter slot the periodic test never uses (period 0).
8

Result and bounds

The harness's record: candidates, gates, loss, and the negative result this experiment leaves behind.

0candidates returned
0passed every gate
0/24known letters, best
–lowest loss
nonechampion before

0158 mixed matrix triples: 107,012,733 routes, survivors K4 0 (copies 0-0); 0162 keyword triples: 20,370,476 routes, survivors K4 0 (copies 0-0); 0167 Nihilist: 116,121,600 routes, survivors K4 0 (copies 0-0)

What was searched, as the harness recorded it.

family
one-to-one substitution, then the moves of 0158, 0162 and 0167 (their own builders), exact
per library
0158 mixed matrix triples
routes
107,012,733
first stages done
380
first stages total
380
k4
0
copies
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0162 keyword triples
routes
20,370,476
first stages done
223
first stages total
223
k4
0
copies
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0167 Nihilist
routes
116,121,600
jobs done
80
jobs total
80
k4
0
copies
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
routes total
243,504,809
survivors k4
0
seconds
38
exhaustive
per library as reported (jobs done)

How this experiment sits among the others is on the lineage page; its family's open hypotheses are on the families page.

Rendered from the record on 2026-10-18 12:26 UTC; updated after every experiment.
view on GitHub