# Session 39: Two-rune linear feedback remains too flat

**Result:** No new plaintext. The complete fixed, linear two-ciphertext-rune feedback family tested here cannot reproduce the most-common-rune frequency of our solved LP benchmark. This is an exact finite-corpus calculation under explicit assumptions, not a proof excluding every English message or every cipher with memory.

## Why this test

[Session 32](/sessions/32.html) confirmed the same six ciphertext runes at two locations. Sessions 33–34 bounded fixed and short-cycle rules using the previous ciphertext rune; [Session 35](/sessions/35.html) tested previous-plaintext feedback. Session 4 also searched linear rules with one previous ciphertext rune. None of those tests covers this particular two-rune linear rule.

We test:

```text
p[i] = (A*c[i] + B*c[i-1] + C*c[i-2] + K) mod 29
A and C: 1..28; B and K: 0..28
```

The natural Gematria index order is used. A nonzero A makes encryption invertible; a nonzero C ensures the rule really uses the second preceding rune. Coefficients remain fixed within a section. Words, punctuation and page boundaries do not reset the state. No skipped F, inserted nulls or additional key stream is included.

The eight substantial unsolved sections contain 12,947 runes. Excluding the first two of each section leaves **12,931 scored positions**, independent of the unknown initial states. The nine-rune section 3 remains outside this established scope. These are previously examined data, not a fresh holdout.

## What the repeated phrase forces

Offsets are zero-based and count runes only. These are rune labels, not an English translation.

| LP2 page | Phrase offset | Previous two runes | Repeated phrase |
|---|---:|---|---|
| 27 | 28 | B F, values 17, 0 | D J U · B E I |
| 55 | 70 | K X, values 5, 14 | D J U · B E I |

Subtracting the second location's decoded phrase from the first, assuming the **same coefficients at both locations**, gives:

```text
[15*B + 12*C, 15*C, 0, 0, 0, 0] mod 29
```

Consequently:

- The last four plaintext runes must match.
- The second plaintext rune must differ, since C is nonzero and 29 is prime.
- The first plaintext rune may match or differ.
- Identical six-rune plaintext at both occurrences is impossible under this shared-key model.

The script checks this identity for all 812 permitted B,C pairs. A and K cancel algebraically. Separate keys for the two sections remove this cross-occurrence constraint. This tells us how to reject incompatible guesses; it supplies no plaintext guess itself.

## Exhausting the frequency possibilities

Divide the equation by A modulo 29 and write:

```text
q[i] = c[i] + a*c[i-1] + b*c[i-2] mod 29
a = B/A; b = C/A
p[i] = A*q[i] + K mod 29
```

Multiplication by a nonzero A and addition of K merely permute the 29 histogram bins. They cannot change maximum rune frequency or histogram entropy. Therefore **812 normalized rules cover the frequency possibilities of all 659,344 coefficient settings**. There is no need to rank thousands of apparent words or fit a language model.

| Scope | Highest possible frequency of any decoded rune |
|---|---:|
| One coefficient set shared across all eight sections | **541 / 12,931 = 4.1837%** |
| Independently chosen coefficient set in every section | **698 / 12,931 = 5.3979%** |
| Solved LP1 benchmark, with first two runes per group excluded | **247 / 1,953 = 12.6472%** |
| Solved LP2 page 57, with first two runes excluded | **15 / 93 = 16.1290%** |

The independently keyed maximum is also exact: choose each section's maximizing normalized rule, then choose its K to map its peak bin to the same plaintext rune. The counts sum to 698. This generous allowance still produces a much flatter distribution than the benchmark.

For the shared-key family, the smallest achievable histogram entropy is **4.854649 bits per rune**, compared with **4.261170** in the LP1 benchmark. These are empirical histogram summaries, not estimates of language entropy rate or statistical p-values. The peak and entropy optima occur under different normalized rules.

| Section | Scored runes | Maximum count | Maximum frequency |
|---|---:|---:|---:|
| 0 | 727 | 46 | 6.3274% |
| 1 | 1,143 | 68 | 5.9493% |
| 2 | 1,727 | 93 | 5.3851% |
| 4 | 1,892 | 98 | 5.1797% |
| 5 | 1,019 | 63 | 6.1825% |
| 6 | 1,522 | 89 | 5.8476% |
| 7 | 1,587 | 86 | 5.4190% |
| 8 | 3,314 | 155 | 4.6771% |

## Controls and reproducibility

Two solved rune streams were cycled to the observed section lengths and encrypted under different known keys, including a B=0 case. Both decode exactly, including the first two symbols when their initialization is supplied. Normalized decoding also matches the scored plaintext exactly. Their frequency sweeps admit their true peaks: **12.8451%** and **15.7606%**. The screen therefore does not automatically flatten messages genuinely encrypted by this family.

An independent five-symbol fixture exhausts all **400** full coefficient settings and compares the exact extrema with its **20** normalized rules. Both maximum frequency and minimum entropy agree. These are checks of the mathematics and implementation, not claims of unknown-key cryptanalytic recovery. Cycled control text is not an independent natural-language sample.

The source transcription SHA-256 is:

```text
b0b2e13c3cd35512ee5955a2d9a56c22d7410e283d35dd9c90abbaa7b99279eb
```

- [Executable audit](two_rune_feedback_audit.py)
- [Full results, including every pooled normalized histogram](two_rune_feedback_results.json)
- [Shared rune handling](lp_core.py) and [solved benchmark construction](word_core.py)
- [Source transcription](liber-primus__transcription--master.txt)

Run the audit alongside its inputs with Python 3 and NumPy:

```sh
python3 -B two_rune_feedback_audit.py
```

## Interpretation and limits

This family cannot attain the benchmark's peak frequency on the retained positions. That makes it a poor candidate for a direct decoder into text resembling the solved pages. It does not prove that deliberately balanced writing, another language or intermediate encoded material is impossible.

A fixed substitution **after** this decoder preserves these frequency limits. An arbitrary alphabet permutation **before** the arithmetic, nonlinear feedback, a changing key, longer memory, boundary resets and null handling remain untested by this calculation. More flexibility needs a specific motivating clue and recovery controls; a failure here does not itself point to one of those alternatives.

The useful outcome is a precise constraint and a bounded negative result. We have not decrypted another page or established a previously unknown community discovery.