Is Voynichese a language, a cipher, or structured pseudo-text?

Reproducible code — reversible battery (autokey + page-keyed)

Both roundtrip-verified (decode(encode(x))==x). Use voynich_lib.py. Pure stdlib.

scripts/voynich_autokey.py

#!/usr/bin/env python3
"""M19: the strongest reversible model -- a stateful AUTOKEY cipher.

c_0 = (p_0 + key) % N ;  c_i = (p_i + c_{i-1}) % N   (continuous over the letter
stream, word boundaries preserved). Decrypt: p_i = (c_i - c_{i-1}) % N. Reversible,
stateful, compact key (one number). Each Latin letter's glyph depends on the running
ciphertext, so the SAME plaintext word produces ever-changing cipher words --
exactly the "verbose / near-variant" behaviour GPT-5.5 wanted, but invertible.

Strict rules: roundtrip verified first; compact key; no post-hoc Voynich tuning;
score the hard features. Plus the information-theoretic check: a bijective cipher
preserves adjacent mutual information, so a substitution's Brown signal EQUALS the
plaintext's -- a reversible map cannot push grammar BELOW the plaintext without
losing information. Does autokey escape that?
"""
import lzma, re, math, random, pathlib
from collections import Counter, defaultdict
from voynich_lib import parse, lev1

rows = parse(); VOY = [r[6] for r in rows]
GLY = sorted({c for w in VOY for c in w}); N = len(GLY)

def latin(path, g=False):
    t = (pathlib.Path("/Users/Shared/AI/detective-desk")/path).read_text(encoding="utf-8", errors="ignore")
    if g:
        a = t.find("*** START"); b = t.find("*** END")
        if a >= 0: t = t[t.find("\n", a)+1:(b if b > 0 else len(t))]
    return re.findall(r"[a-z]+", t.lower())
APIC = latin("data/voynich/apicius_books.txt")
LAT = sorted({c for w in APIC for c in w})
L2I = {c: i for i, c in enumerate(LAT)}; I2L = {i: c for c, i in L2I.items()}   # <= N letters

# --- reversible substitution (MI-invariance demo) ---
rng = random.Random(0); gl = GLY[:]; rng.shuffle(gl)
SUB = {c: gl[i] for i, c in enumerate(LAT)}; INV = {v: k for k, v in SUB.items()}
CIPSUB = ["".join(SUB[c] for c in w) for w in APIC]
assert ["".join(INV[ch] for ch in t) for t in CIPSUB] == APIC

# --- autokey cipher (continuous over letter stream, word boundaries kept) ---
KEY = 7
def autokey_encode(words):
    out = []; prev = KEY
    for w in words:
        cw = []
        for c in w:
            ci = (L2I[c] + prev) % N; cw.append(GLY[ci]); prev = ci
        out.append("".join(cw))
    return out
def autokey_decode(toks):
    out = []; prev = KEY
    for t in toks:
        pw = []
        for ch in t:
            ci = GLY.index(ch); pw.append(I2L[(ci - prev) % N]); prev = ci
        out.append("".join(pw))
    return out
CIPAK = autokey_encode(APIC)
print("roundtrip exact (must be True):", autokey_decode(CIPAK) == APIC, "\n")

def Hf(c):
    t = sum(c.values()); return -sum(v/t*math.log2(v/t) for v in c.values()) if t else 0.0
def exch_signal(tk, Nn=150, KK=10, passes=6, seed=1):
    rnd = random.Random(seed); c = Counter(tk); top = [w for w, _ in c.most_common(Nn)]; tid = {w: i for i, w in enumerate(top)}
    OT = Nn; red = [tid.get(w, OT) for w in tk]
    def mi(seq): return 2*Hf(Counter(seq)) - Hf(Counter(zip(seq, seq[1:])))
    left = defaultdict(Counter); right = defaultdict(Counter)
    for i in range(1, len(red)):
        a, b = red[i-1], red[i]
        if b != OT: left[b][a] += 1
        if a != OT: right[a][b] += 1
    mov = sorted(t for t in set(red) if t != OT); cls = {t: rnd.randrange(KK) for t in mov}
    def cK(t): return KK if t == OT else cls[t]
    Kt = KK+1; CB = [[0]*Kt for _ in range(Kt)]
    for i in range(1, len(red)): CB[cK(red[i-1])][cK(red[i])] += 1
    def cbmi():
        tot = sum(sum(r) for r in CB)
        if not tot: return 0.0
        row = [sum(r) for r in CB]; col = [sum(CB[x][y] for x in range(Kt)) for y in range(Kt)]
        return sum(CB[x][y]/tot*math.log2(CB[x][y]*tot/(row[x]*col[y])) for x in range(Kt) for y in range(Kt) if CB[x][y] and row[x] and col[y])
    def ap(t, a, b):
        for p, n in left[t].items():
            if p != t: x = cK(p); CB[x][a] -= n; CB[x][b] += n
        for q, n in right[t].items():
            if q != t: y = cK(q); CB[a][y] -= n; CB[b][y] += n
        sc = left[t].get(t, 0)
        if sc: CB[a][a] -= sc; CB[b][b] += sc
        cls[t] = b
    for _ in range(passes):
        for t in mov:
            a = cls[t]; best, bm = a, None
            for b in range(KK):
                ap(t, a, b); m = cbmi(); ap(t, b, a)
                if bm is None or m > bm: bm, best = m, b
            if best != a: ap(t, a, best)
    real = mi([cK(x) for x in red]); sh = red[:]; rnd.shuffle(sh)
    return real - mi([cK(x) for x in sh])

def stats(name, tk, rev):
    Ntok = len(tk); types = len(set(tk)); mwl = sum(len(w) for w in tk)/Ntok
    pr = same = one = 0; prev = None
    for w in tk:
        if prev is not None:
            pr += 1
            if w == prev: same += 1
            elif lev1(w, prev): one += 1
        prev = w
    uni = Counter(); big = Counter()
    for w in tk:
        for ch in w: uni[ch] += 1
        for a, b in zip(w, w[1:]): big[(a, b)] += 1
    h1 = Hf(uni); h2 = Hf(big) - h1
    blob = " ".join(tk).encode(); ratio = len(lzma.compress(blob, preset=6))/len(blob)
    print(f"{name:<22}{rev:>5}{types:>7}{mwl:>6.2f}{one/pr*100:>7.1f}%{h2/h1:>7.2f}{exch_signal(tk):>8.3f}{ratio:>8.3f}")

print(f"{'system':<22}{'rev?':>5}{'types':>7}{'wlen':>6}{'drift':>7}{'h2/h1':>7}{'brownS':>8}{'lzma':>8}")
print("-"*72)
stats("Voynich", VOY, "no")
stats("Latin (Apicius)", APIC, "--")
stats("Subst cipher", CIPSUB, "yes")
stats("Autokey cipher", CIPAK, "yes")
print("\nMI-invariance: a bijective substitution leaves adjacent mutual information unchanged")
print("-> its Brown signal EQUALS Latin's. A reversible map cannot push grammar below the")
print("plaintext's without destroying information. Voynich's brownS (0.087) is far below Latin's.")

scripts/voynich_pagecipher.py

#!/usr/bin/env python3
"""M20: page-keyed (book) cipher -- Ford's "each page is its own cipher".

The global reversible ciphers had no page structure, so they couldn't make
page-local vocabulary or line effects. Here each PAGE enciphers with its own key
(derived from the page number) -> the same plaintext word ciphers differently per
page = page-local vocabulary, and it's still reversible (decoder knows page # -> key).
We lay real Latin into Voynich's exact page/line geometry, encipher per page with
two bases (autokey, substitution), verify roundtrip, and score the FULL board
including page-locality and line effects.
"""
import lzma, re, math, random, pathlib
from collections import Counter, defaultdict
from voynich_lib import parse, lev1

rows = parse(); VOY = [r[6] for r in rows]
GLY = sorted({c for w in VOY for c in w}); N = len(GLY)

def latin(p, g=False):
    t = (pathlib.Path("/Users/Shared/AI/detective-desk")/p).read_text(encoding="utf-8", errors="ignore")
    if g:
        a = t.find("*** START"); b = t.find("*** END")
        if a >= 0: t = t[t.find("\n", a)+1:(b if b > 0 else len(t))]
    return re.findall(r"[a-z]+", t.lower())
PLAIN = latin("data/voynich/latin_dbg.txt", True) + latin("data/voynich/apicius_books.txt")
_freq = Counter(c for w in PLAIN for c in w)
KEEP = set(c for c, _ in _freq.most_common(N))            # plaintext alphabet must fit in N glyphs
PLAIN = [w for w in PLAIN if all(c in KEEP for c in w)]   # keep reversibility exact
LAT = sorted(KEEP); L2I = {c: i for i, c in enumerate(LAT)}; I2L = {i: c for c, i in L2I.items()}

# Voynich layout: list of (folio, line, count), folio order
line_items = []; cur = None; cnt = 0
for folio, line, pos, *_ in rows:
    k = (folio, line)
    if k != cur:
        if cur is not None: line_items.append((cur[0], cur[1], cnt))
        cur = k; cnt = 0
    cnt += 1
line_items.append((cur[0], cur[1], cnt))
TOTAL = sum(c for *_ , c in line_items)
PW = [PLAIN[i % len(PLAIN)] for i in range(TOTAL)]      # cycle Latin to fill the geometry
folorder = {}
for f, _, _ in line_items: folorder.setdefault(f, len(folorder))

def lay(enc):
    """enc(folio_index, word) -> cipher token. Returns items + plaintext-by-page for roundtrip."""
    items = []; ppage = defaultdict(list); idx = 0
    for f, line, c in line_items:
        g = folorder[f]
        for _ in range(c):
            pw = PW[idx]; idx += 1
            items.append((f, line, _, enc(g, pw))); ppage[g].append(pw)
    return items

# --- base 1: page-keyed autokey (re-seed per page with page key) ---
def mk_autokey():
    state = {}
    def enc(g, w):
        prev = state.get(g, (7 + 31*g) % N)
        cw = []
        for ch in w:
            ci = (L2I[ch] + prev) % N; cw.append(GLY[ci]); prev = ci
        state[g] = prev; return "".join(cw)
    return enc
def dec_autokey(items):
    state = {}; out = []
    for f, line, pos, t in items:
        g = folorder[f]; prev = state.get(g, (7 + 31*g) % N); pw = []
        for ch in t:
            ci = GLY.index(ch); pw.append(I2L[(ci - prev) % N]); prev = ci
        state[g] = prev; out.append("".join(pw))
    return out

# --- base 2: page-keyed substitution (rotate the cipher alphabet by page) ---
_perm = list(range(N)); random.Random(0).shuffle(_perm)
L2G = {c: _perm[i] for i, c in enumerate(LAT)}            # letter -> base glyph index
G2L = {v: k for k, v in L2G.items()}
GIDX = {g: i for i, g in enumerate(GLY)}
def mk_subst():
    def enc(g, w):
        sh = g % N
        return "".join(GLY[(L2G[ch] + sh) % N] for ch in w)
    return enc
def dec_subst(items):
    out = []
    for f, line, pos, t in items:
        sh = folorder[f] % N
        out.append("".join(G2L[(GIDX[ch] - sh) % N] for ch in t))
    return out

AK = lay(mk_autokey()); SB = lay(mk_subst())
print("roundtrip autokey:", dec_autokey(AK) == PW, "| roundtrip subst:", dec_subst(SB) == PW, "\n")

def Hf(c):
    t = sum(c.values()); return -sum(v/t*math.log2(v/t) for v in c.values()) if t else 0.0
def exch_signal(tk, Nn=150, KK=10, passes=6, seed=1):
    rnd = random.Random(seed); c = Counter(tk); top = [w for w, _ in c.most_common(Nn)]; tid = {w: i for i, w in enumerate(top)}
    OT = Nn; red = [tid.get(w, OT) for w in tk]
    def mi(seq): return 2*Hf(Counter(seq)) - Hf(Counter(zip(seq, seq[1:])))
    left = defaultdict(Counter); right = defaultdict(Counter)
    for i in range(1, len(red)):
        a, b = red[i-1], red[i]
        if b != OT: left[b][a] += 1
        if a != OT: right[a][b] += 1
    mov = sorted(t for t in set(red) if t != OT); cls = {t: rnd.randrange(KK) for t in mov}
    def cK(t): return KK if t == OT else cls[t]
    Kt = KK+1; CB = [[0]*Kt for _ in range(Kt)]
    for i in range(1, len(red)): CB[cK(red[i-1])][cK(red[i])] += 1
    def cbmi():
        tot = sum(sum(r) for r in CB)
        if not tot: return 0.0
        row = [sum(r) for r in CB]; col = [sum(CB[x][y] for x in range(Kt)) for y in range(Kt)]
        return sum(CB[x][y]/tot*math.log2(CB[x][y]*tot/(row[x]*col[y])) for x in range(Kt) for y in range(Kt) if CB[x][y] and row[x] and col[y])
    def ap(t, a, b):
        for p, n in left[t].items():
            if p != t: x = cK(p); CB[x][a] -= n; CB[x][b] += n
        for q, n in right[t].items():
            if q != t: y = cK(q); CB[a][y] -= n; CB[b][y] += n
        sc = left[t].get(t, 0)
        if sc: CB[a][a] -= sc; CB[b][b] += sc
        cls[t] = b
    for _ in range(passes):
        for t in mov:
            a = cls[t]; best, bm = a, None
            for b in range(KK):
                ap(t, a, b); m = cbmi(); ap(t, b, a)
                if bm is None or m > bm: bm, best = m, b
            if best != a: ap(t, a, best)
    real = mi([cK(x) for x in red]); sh = red[:]; rnd.shuffle(sh)
    return real - mi([cK(x) for x in sh])
def scoreboard(name, items):
    tk = [x[3] for x in items]; Nt = len(tk); types = len(set(tk)); mwl = sum(len(w) for w in tk)/Nt
    pr = same = one = 0; prev = pk = None
    for f, l, p, w in items:
        if prev is not None and (f, l) == pk:
            pr += 1
            if w == prev: same += 1
            elif lev1(w, prev): one += 1
        prev, pk = w, (f, l)
    uni = Counter(); big = Counter()
    for w in tk:
        for ch in w: uni[ch] += 1
        for a, b in zip(w, w[1:]): big[(a, b)] += 1
    h1 = Hf(uni); h2 = Hf(big) - h1
    fl = [x[0] for x in items]; pagesz = Counter(fl); Nn = len(fl); pf = {f: pagesz[f]/Nn for f in pagesz}
    wp = defaultdict(Counter); c = Counter(tk)
    for w, f in zip(tk, fl): wp[w][f] += 1
    num = den = 0.0
    for w in c:
        if c[w] >= 10:
            n = c[w]; kl = sum((cf/n)*math.log2((cf/n)/pf[f]) for f, cf in wp[w].items()); num += n*kl; den += n
    ploc = num/den if den else 0
    ini = Counter(); inter = Counter()
    for f, l, p, w in items: (ini if p == 0 else inter)[w] += 1
    elig = {w for w in c if c[w] >= 10}
    ti = sum(ini[w] for w in elig) or 1; tr = sum(inter[w] for w in elig) or 1
    le = sum((ini[w]/ti)*math.log2((ini[w]/ti)/((inter[w]/tr) or 1e-9)) for w in elig if ini[w])
    blob = " ".join(tk).encode(); ratio = len(lzma.compress(blob, preset=6))/len(blob)
    print(f"{name:<20}{types:>7}{mwl:>6.2f}{one/pr*100:>7.1f}%{h2/h1:>7.2f}{ploc:>8.2f}{le:>8.2f}{exch_signal(tk):>8.3f}{ratio:>8.3f}")

print(f"{'system':<20}{'types':>7}{'wlen':>6}{'drift':>7}{'h2/h1':>7}{'pageloc':>8}{'lineeff':>8}{'brownS':>8}{'lzma':>8}")
print("-"*80)
scoreboard("Voynich", [(r[0], r[1], r[2], r[6]) for r in rows])
scoreboard("Page-autokey", AK)
scoreboard("Page-subst", SB)
print("\nBoth reversible (roundtrip True). Does per-page keying add page-locality/line-effects?")

Major update, but I'd phrase it as "reversible ciphers of ordinary prose, under simple/period-plausible families, now look very bad" — weaker than "mathematically impossible," but probably right.

(a) Is there a reversible family that could escape? Yes, but a very narrow hatch. Not a normal cipher — a reversible constrained generator: compressed plaintext bits + shared self-citation generator + current state → choose one legal next Voynich-like token; decrypt reverses the choice (state + observed token → which choice → recover bits). The visible text follows the generator's statistics, not Latin's — so it could have Voynich-like drift, low glyph entropy, low/moderate grammar, page-locality, and exact reversibility. This is steganography / enumerative coding into a Voynich-like language model. The drift is no longer noise; the drift is the alphabet.

So I'd correct the absolute claim "drift requires copying, and copying is not reversible" to: uncontrolled copying is not reversible; choice among controlled copies can be. But here historical plausibility collapses — the scribe needs a shared rule for ranking legal variants, enough choices per step to carry payload, and the discipline to recover the exact choice later. That's coding theory, not a 1400s tool. The hatch exists mathematically; it's not period-plausible unless the payload is small or the "plaintext" isn't ordinary prose.

(b) Does the center of gravity move to structured self-citing signal? Yes, strongly — not "meaningless proven," but structured self-citing signal is now the default model to beat. The reversible failures aren't random: substitution keeps Latin grammar; verbose gets entropy but keeps grammar; autokey kills grammar but raises entropy and kills drift; page-keyed adds locality but explodes types and over-scrambles. That pattern is more convincing than any single failure. Voynich occupies a statistical compromise zone ordinary reversible ciphers don't naturally occupy.

Live models now: (1) non-reversible recursive self-citation — strongest fit; (2) structured ritual/chant/signal — strengthened; (3) reversible constrained generator / steganographic transducer — possible, historically suspicious; (4) ordinary reversible cipher of prose — badly weakened; (5) hoax/gibberish — dead.

One distributional test remains: build the reversible constrained self-citation channel and measure capacity. If it can only carry a tiny payload, the door shuts harder. If it can carry book-scale payload while matching the scoreboard, the door reopens — but with a much stranger mechanism than "cipher of Latin." Then the next leverage is non-distributional: tokenization, scribal hands, quires, the f57v rings, illustration-text correlation, corrections, rare-token behavior, line boundaries.

The clean line: Voynich no longer looks like prose encrypted into weird words. It looks like weird words breeding other weird words. Whether that breeding carries a hidden payload is the last serious decryption question.

Capacity of the reversible constrained channel: book-scale — the door is open, but only by capacity

GPT-5.5's last loophole: a reversible steganographic transducer that embeds payload into the choices of a Voynich-like generator. The decisive measure is its capacity — and the capacity of any reversible cover-text channel equals the cover's own information content, best estimated by its compressed size.

Plain-English first: a hidden-message scheme can only carry as many bits as the text actually contains. We measured how much information is really in Voynich (by compressing it). Answer: about 86,000 words' worth — a whole book. So there is room for a hidden book. But "there's room" is not "there's a message" — random generator-choices fill the same room — and using that room reversibly needs modern coding theory a 15th-century scribe didn't have.

corpus              info(KB)   payload(words)   books
Voynich                63        85,815         1.23
Latin Apicius          13        17,441         0.25
Latin Caesar           39        53,125         0.76
Random (max cap)      128       174,085         2.49
Constant (min cap)      0            77         0.00

(payload = info / ~6 bits-per-plaintext-word; "books" = /70,000-word book.)

Findings: 1. Capacity is book-scale (~1.23 books). Voynich's information density per token matches real Latin — far above a redundant stream, well below random. It is genuinely information-rich, not trivially redundant. 2. So the reversible steganographic loophole is not closed by capacity. A constrained-generation transducer could, in principle, carry a full book while matching the scoreboard. 3. But capacity is necessary, not sufficient: the same ~63 KB is exactly filled by a non-reversible generator's free choices (mutations, copy-selections). Capacity can't tell a hidden book from a book's-worth of meaningless choice-entropy.

Verdict: the decryption door now stands at — ordinary reversible cipher of prose: dead; reversible steganographic transducer: mathematically alive (capacity suffices) but requires enumerative-coding machinery no 1400s scribe had; non-reversible self-citation: the simplest model fitting everything measured. The loophole is open in math, shut in plausibility.

Sources - ZL EVA transliteration — voynich.nu/data/ZL3b-n.txt - Latin controls: Apicius, Caesar. Method: lzma/bz2 as an entropy bound; Timm & Schinner (2019) self-citation.

Reproducible code — channel capacity (compression bound)

Uses voynich_lib.py. Pure stdlib.

scripts/voynich_capacity.py

#!/usr/bin/env python3
"""M21: capacity of the reversible constrained-generation channel (GPT-5.5's last loophole).

A reversible steganographic transducer embeds payload into the *choices* of a
Voynich-like generator. The MAX payload it can carry = the cover text's own
information content (you can't reversibly embed more bits than the cover holds).
The practical estimate of that information content is its compressed size.

So: compress the Voynich token stream (lzma, bz2), convert to a max reversible
payload in plaintext-words, and compare to a real book. References: real Latin
(should be similar), a max-entropy random stream (incompressible = max capacity),
and a near-constant stream (min capacity). This tells us whether the loophole is
book-scale (door reopens, but needs a coding-theory mechanism) or tiny (door shuts).
"""
import lzma, bz2, re, math, random, pathlib
from collections import Counter
from voynich_lib import parse

VOY = [r[6] for r in parse()]
def latin(p, g=False):
    t = (pathlib.Path("/Users/Shared/AI/detective-desk")/p).read_text(encoding="utf-8", errors="ignore")
    if g:
        a = t.find("*** START"); b = t.find("*** END")
        if a >= 0: t = t[t.find("\n", a)+1:(b if b > 0 else len(t))]
    return re.findall(r"[a-z]+", t.lower())
APIC = latin("data/voynich/apicius_books.txt"); CAES = latin("data/voynich/latin_dbg.txt", True)

GLY = sorted({c for w in VOY for c in w}); rng = random.Random(1)
RAND = ["".join(rng.choice(GLY) for _ in range(rng.randint(3, 7))) for _ in range(len(VOY))]   # max entropy
CONST = (["daiin"] * len(VOY))                                                                  # min entropy

BITS_PER_WORD = 6.0   # ~1.1 bits/char (Shannon) x ~5.5 chars/word -> info in a plaintext word
BOOK = 70000          # a ~230-page book, words

def cap(name, toks):
    blob = " ".join(toks).encode()
    lz = len(lzma.compress(blob, preset=9)); bz = len(bz2.compress(blob, 9))
    best = min(lz, bz)
    bits = best * 8
    payload_words = bits / BITS_PER_WORD
    print(f"{name:<20}{len(toks):>7}{len(blob)/1024:>8.0f}{lz/1024:>8.0f}{best/len(blob):>8.3f}"
          f"{bits/1024/8:>9.0f}{payload_words:>11.0f}{payload_words/BOOK:>8.2f}")

print(f"{'corpus':<20}{'toks':>7}{'rawKB':>8}{'lzmaKB':>8}{'ratio':>8}{'infoKB':>9}{'payloadW':>11}{'books':>8}")
print("-"*80)
cap("Voynich", VOY)
cap("Latin Apicius", APIC)
cap("Latin Caesar", CAES)
cap("Random (max cap)", RAND)
cap("Constant (min cap)", CONST)
print(f"\npayloadW = max reversible payload in plaintext words (info / {BITS_PER_WORD} bits-per-word)")
print(f"books = payloadW / {BOOK} (a ~230-page book). >~1 => book-scale capacity; <<1 => only a short message.")

Answering GPT-5.5's two questions with the capacity number in hand:

(a) The escape hatch is real but capacity doesn't close it — plausibility does. The measurement is unambiguous: Voynich carries ~1.23 books of information, the same density as real Latin. So the steganographic-transducer loophole survives the capacity test; there is room for a hidden book. What kills it as a decryption route isn't information — it's mechanism. To embed reversibly into a generator's choices you need a deterministic ranking of legal variants and exact choice-recovery on decode: that's arithmetic/enumerative coding, 20th-century mathematics. A 15th-century scribe with wheels and tables doesn't have it. So GPT-5.5's correction is exactly right and I'd adopt it verbatim: uncontrolled copying isn't reversible; choice among controlled copies can be — but only with coding theory the period didn't have. The hatch is open in principle, shut in practice (barring a small payload or a non-prose plaintext).

(b) Yes — the center of gravity is now structured self-citing signal, decisively. Not "meaningless proven" — that's unprovable — but it's the model to beat, because it's the only one that hit the whole scoreboard from one rule, and because every alternative now has a specific, measured wound: ordinary cipher (the four-family battery), dumb generator (memoryless wheel), and now even the capacity argument doesn't favor a message (random choices fill the same budget). The remaining decryption question is GPT-5.5's: does the breeding carry a payload? Capacity says it could; plausibility says it probably doesn't; and structure alone can't say which.

So the distributional road is genuinely complete. The next decisive evidence is non-statistical, and it's about the manuscript as a physical object: do the scribal hands each preserve the same recurrence rule (self-citation predicts yes); does structure reset by quire; are the f57v rings an inventory or a key; does nearby text correlate with the illustration class (a payload would; pure self-citation wouldn't); and do the corrections look like copying-slips or encoding-edits? Those are the questions that can move the needle now — and several are answerable from the page images we already have.

I mostly agree with this update. The reversible escape hatch survives mathematically but not historically.

That distinction matters. A controlled self-citation channel can be reversible in principle: the plaintext chooses among legal next variants, and the observed variant decodes back to the choice. So drift is not logically incompatible with reversibility. But once you require exact ranking of legal variants, exact recovery of choices, enough payload capacity, and 200+ pages of reliable execution, the model stops looking like a 15th-century paper-machine cipher and starts looking like modern coding theory projected backward.

So I'd state the result this way: - A reversible recursive transducer is possible in principle. - A period-plausible reversible recursive transducer carrying ordinary prose is now very unlikely.

That is enough to move the center of gravity. The important thing is not that "meaninglessness is proven" — it is not. It is that the measured structure no longer needs a hidden message to explain it. Self-citation explains the weird conjunction we kept hitting — low glyph entropy, one-glyph drift, moderate page-local vocabulary, low-but-nonzero class sequencing, line effects, local recurrence, language-like structure without stable semantic access — arriving together rather than as separately tuned knobs. That conjunction was the mystery.

But I'd be cautious with "the distributional road is complete." More precisely: the distributional road is complete for ordinary reversible prose-cipher models under the current tokenization. Three real frontiers remain: 1. Tokenization — are spaces actually word boundaries? If the unit is wrong, some conclusions may shift. 2. Physical manuscript evidence — hands, corrections, line starts/ends, quire resets, section transitions, page layout can distinguish a copying process from an encoding process. 3. Image-text coupling — if nearby text correlates with illustration class in a way self-citation does not predict, the payload side gets new oxygen. If not, self-citation strengthens.

The f57v rings now become especially interesting — not as a magic decryption key, but as a plausible inventory, mnemonic, seed table, training diagram, or production aid. Not "use this ring to read the book," but "this is part of the machine that breeds the text."

So the next question is no longer "can the statistics prove meaning?" (they probably cannot). It is: does the physical object behave like a copied/generated artifact, or like an encoded manuscript? Production signatures to look for: - Do recurrence patterns reset at quire boundaries? - Do different scribal hands preserve the same recurrence rule? - Are rare forms born from nearby forms by visible mutation paths? - Do corrections repair local form-consistency, or semantic/encoding mistakes? - Do f57v-like diagrams match observed glyph inventories or transition rules? - Does text near plants, baths, stars, or recipes show image-specific structure beyond ordinary section drift?

That is the next battlefield.

My updated position: simple gibberish is dead; ordinary encrypted prose is badly weakened; reversible steganographic recursion survives only as a theoretical loophole; structured recursive self-citation is now the strongest working model; meaning is not disproven, but it has lost structure as its main evidence.

The manuscript now looks less like a hidden book and more like a self-similar symbolic organism. The remaining question is whether that organism is carrying a payload — or only breeding form.

The concise version: the reversible door is not locked by information. It is locked by mechanism.

Production signatures: the manuscript behaves like a copied/generated artifact

GPT-5.5 asked: does the object behave like a copied/generated artifact or an encoded one? Two of those tests are answerable now from the transcription metadata.

A) Rare words are born from recent forms by visible mutation. For each rare word-type (count <=2), is there a 1-glyph "parent" in the previous 100 words? - rare types: real 17.2% vs shuffled 10.8% -> 1.6x chance - all tokens: real 65.6% vs shuffled 59.9% -> 1.1x

Rare forms have a recent one-edit ancestor well above chance: weird words are, measurably, bred from nearby weird words. The lift is modest (1.6x), but it is in the direction self-citation predicts and against "rare tokens are independent inventions/plaintext exceptions."

B) Every scribal hand follows the same recurrence rule. Per hand ($H):

hand  tokens  repeat  drift  rare-ancestry
 1    10228   0.9%   4.5%      17.0%
 2    10871   0.9%   3.4%      18.0%
 3    11602   0.7%   3.1%      18.5%
 4     3513   0.6%   3.4%      16.4%

Near-identical across all four hands. The copy-and-mutate process is scribe-independent -- a shared production procedure, not individual authorship. If each hand were composing meaning independently you would not expect the recurrence fingerprint to be this uniform.

Verdict: both production signatures point to a copied/generated artifact over an encoded manuscript, and both are exactly what recursive self-citation predicts. Caveat: the rare-ancestry lift is modest; a window/threshold sweep would sharpen it. Still-open production tests need the page images (corrections, f57v rings, image-text coupling) or a quire-reset parse.

Source: ZL EVA transliteration (hand/section tags) -- voynich.nu/data/ZL3b-n.txt

Production signature: recurrence resets at quire boundaries

Does the text's recurrence respect the physical gatherings (quires)? Using the $Q tags, consecutive-page vocabulary overlap (Jaccard):

within-quire boundary : 0.106  (n=209 page-pairs)
across-quire boundary : 0.062  (n=17 boundaries)
ratio across/within   : 0.58   (~42% drop at the gathering boundary)

Vocabulary recurrence partially resets at quire boundaries -- copying flows within a gathering and weakens between gatherings. That is a production signature: the text-generation tracks the physical batch (a scribe working gathering-by-gathering), which is what a copied/generated artifact does. A continuous encoded message would have no reason to dip at a quire seam.

Caveats: only 17 boundaries (small n), and quire boundaries partly coincide with section changes, so some of the drop is section-vocabulary turnover rather than pure quire-reset. Directionally clear, magnitude approximate.

Together with the rare-token mutation ancestry (1.6x chance) and the scribe-independent recurrence rule, the production signatures consistently say: copied/generated artifact, produced in physical batches -- exactly what recursive self-citation predicts, and unlike an encoded continuous manuscript.

Source: ZL EVA transliteration ($Q/$H tags) -- voynich.nu/data/ZL3b-n.txt

This is the kind of evidence I wanted next. The previous tests showed recursive self-citation can reproduce the text's distributional profile. These ask a better question: does the manuscript behave like a thing physically produced by recurrence? The answer appears to be yes.

The rare-token ancestry result is especially important. Rare words are more likely than chance to have a recent one-glyph ancestor -- exactly what copy-and-mutate predicts: unusual forms are born locally from prior forms. That doesn't prove there's no payload, but it weakens "rare words are plaintext-driven exceptions" -- they look less like independent semantic units and more like descendants in a local mutation chain.

The scribal-hand result matters too. If all four hands preserve similar repeat/drift/ancestry rates, recurrence isn't a personal writing habit -- it's a shared production rule, which pushes away from individual authors composing meaning.

The quire-boundary result I'd calibrate more cautiously: few boundaries, and quire breaks may partly coincide with section breaks. Supporting evidence, not standalone proof.

But the combined pattern is coherent -- rare forms have local ancestors; recurrence is stable across hands; vocabulary continuity weakens at physical batch boundaries; and self-citation already reproduces the hard metrics. Those aren't isolated facts; they point one way.

Updated model: Voynichese is not merely statistically self-similar -- it appears physically produced by a self-citation process. The payload hypothesis now has a harder job: it must explain why the structure looks locally bred, hand-independent, and physically batched. A reversible cipher could still be batch-produced; a meaningful manuscript could still have quire/section effects -- but the simplest explanation is no longer "hidden prose transformed into strange words." It is: a shared scribal procedure generated text by copying, mutating, and locally propagating forms. Meaning isn't disproven -- it has lost another support beam.

Next tests stay physical: (1) corrections -- repair local form-consistency or semantic/encoding mistakes? (2) quire/section disentangling -- quire-boundary drops only where section doesn't change; (3) image-text coupling -- content-specific structure near plants/baths/stars/pharma/recipes beyond section drift; (4) f57v rings -- inventory/seed system or decoding key? (5) mutation genealogy -- can rare forms be arranged into local family trees that follow page/line order? (6) hand transitions -- does recurrence continue smoothly across a hand change?

If those keep pointing the same way, the center of gravity moves to something concrete: a multi-scribe recursive production system. Not gibberish, not ciphered prose -- a manuscript built by a rule.

The phrase I'd underline: physically produced by recurrence. Stronger than "statistically generated" -- it ties the behavior to hands, pages, and quires, exactly where a real production method leaves fingerprints.

So our next move is to look at the images and see if we can use them right? We have 17 quires and about that many potential ciphers I think.

so far our leading hypothesis is recursive self citation of generated text that lacks meaning/message.