20-10-2025, 05:50 AM
How I Built the DAI Anchor Method (My Working Notes)
Why I went hunting for an anchor
I didn’t try to “solve” the Voynich head-on. I looked for
a fixed point first—something I could trust across pages. In the EVA transcription, one trigraph kept showing up like a heartbeat: d-a-i. Then I noticed its family—dai / dain / daiin / dair—cycling over and over. That became my foothold.
My basic rule: treat “dai” as a cryptographic anchor
In classical codebreaking, anchors are the little boring things that secretly run the language (articles, prepositions, suffixes). “dai” behaved like that: small, everywhere, structurally placed. I decided to pin my analysis to it and radiate outward.
What made it anchor-worthy (my checklist):
High frequency across multiple sections (not just in one topic domain).
Low internal variation (spelled steadily; surrounding context changes more than it does).
Positional spread (line-end, mid-line, near labels—i.e., not constrained).
Productive morphology (clean expansions: dai → dain → daiin → dair).
That’s exactly the behavior I expect from a function word or a grammatical morpheme.
My workflow (the skeleton)
Normalize the EVA tokens (strip obvious layout artifacts, keep line boundaries).
Run n-gram sweeps (uni/bi/tri/quad), rank by frequency.
Flag candidate anchors; stress-test them for cross-folio stability.
Lock “dai” in as the anchor; build co-occurrence windows around it.
Map positional behavior (line-initial, line-final, paragraph-initial).
Track morphological neighbors (suffixes/prefixes that consistently latch onto “dai”).
Build local transition matrices (Markov-style) centered on the anchor.
Do ablation tests (shuffle text, remove “dai,” swap anchors) to see what breaks.
What I saw (the patterns that mattered)
3.1 Frequency & family behavior
Relative frequency (conceptual sketch)
Daiin ████████████████████
Dain ████████
Dai ██████
Dair ████
(others) …
Daiin is a monster; dain and dai trail it; dair shows up enough to be real, not noise.
This family clustering screams “morphology,” not random noise.
3.2 Positional logic
… qokeedy qokedy daiin
↑ frequent line-final anchor
“dai” family lands mid-line and line-final more often than not—exactly where languages park connectors or endings.
It doesn’t behave like a content noun (those tend to clump near labels or diagrams); it behaves like glue.
3.3 Co-occurrence neighborhood (my mental map)
Chedy
│
Qokedy — dai — ol
│
Ain
The same handful of neighbors keep orbiting “dai.”
I treat that as a semantic neighborhood—not “meaning” yet, but relational function (e.g., linkers, case markers, genitives).
3.4 Transition fingerprints (anchor-centered)
I built a tiny transition matrix around the anchor family: what tends to appear before/after dai/dain/daiin. The point wasn’t to “translate” but to stabilize the local grammar. When I permuted the text or swapped the anchor to some other frequent token, that stability collapsed. That’s how I falsified false anchors.
The working hypothesis I tested
Treat “dai” as a function carrier—something like an article, linker (and/of/in), or a grammatical suffix. Then check if:
Its expansions (dai → dain → daiin) behave like inflection/derivation (e.g., plural/possessive/case).
Its neighborhood stays consistent across sections (herbal, astro, pharma).
If a token keeps its grammatical job across wildly different topics, it’s probably not a plant name—it’s grammar.
Result: It stayed consistent.
How I actually used the anchor to “read outward”
Step A — Lock the anchor
Fix dai in place (conceptually) on a line.
Step B — Expand the ring
Collect ±3–4 tokens around every anchor hit; compute:
PMI/collocation scores
Conditional probs (P(next|dai), P(prev|dai))
Line position weights (begin/mid/end; paragraph-initial)
Step C — Identify stable attachments
Mark affixes that prefer to attach to dai (e.g., -in, -r, -dy families).
This gave me morphological templates.
Step D — Test semantic roles (without over-claiming)
I slotted trial meanings like and/of/in/this into the anchor family and checked whether the syntax flow improved (fewer contradictions in where these should appear).
I didn’t force a translation; I forced consistency.
Step E — Cross-folio verification
If the anchor = grammar, then its positional + neighbor stats shouldn’t drift much across sections.
They didn’t.
More testing needed.
Why I went hunting for an anchor
I didn’t try to “solve” the Voynich head-on. I looked for
a fixed point first—something I could trust across pages. In the EVA transcription, one trigraph kept showing up like a heartbeat: d-a-i. Then I noticed its family—dai / dain / daiin / dair—cycling over and over. That became my foothold.My basic rule: treat “dai” as a cryptographic anchor
In classical codebreaking, anchors are the little boring things that secretly run the language (articles, prepositions, suffixes). “dai” behaved like that: small, everywhere, structurally placed. I decided to pin my analysis to it and radiate outward.
What made it anchor-worthy (my checklist):
High frequency across multiple sections (not just in one topic domain).
Low internal variation (spelled steadily; surrounding context changes more than it does).
Positional spread (line-end, mid-line, near labels—i.e., not constrained).
Productive morphology (clean expansions: dai → dain → daiin → dair).
That’s exactly the behavior I expect from a function word or a grammatical morpheme.
My workflow (the skeleton)
Normalize the EVA tokens (strip obvious layout artifacts, keep line boundaries).
Run n-gram sweeps (uni/bi/tri/quad), rank by frequency.
Flag candidate anchors; stress-test them for cross-folio stability.
Lock “dai” in as the anchor; build co-occurrence windows around it.
Map positional behavior (line-initial, line-final, paragraph-initial).
Track morphological neighbors (suffixes/prefixes that consistently latch onto “dai”).
Build local transition matrices (Markov-style) centered on the anchor.
Do ablation tests (shuffle text, remove “dai,” swap anchors) to see what breaks.
What I saw (the patterns that mattered)
3.1 Frequency & family behavior
Relative frequency (conceptual sketch)
Daiin ████████████████████
Dain ████████
Dai ██████
Dair ████
(others) …
Daiin is a monster; dain and dai trail it; dair shows up enough to be real, not noise.
This family clustering screams “morphology,” not random noise.
3.2 Positional logic
… qokeedy qokedy daiin
↑ frequent line-final anchor
“dai” family lands mid-line and line-final more often than not—exactly where languages park connectors or endings.
It doesn’t behave like a content noun (those tend to clump near labels or diagrams); it behaves like glue.
3.3 Co-occurrence neighborhood (my mental map)
Chedy
│
Qokedy — dai — ol
│
Ain
The same handful of neighbors keep orbiting “dai.”
I treat that as a semantic neighborhood—not “meaning” yet, but relational function (e.g., linkers, case markers, genitives).
3.4 Transition fingerprints (anchor-centered)
I built a tiny transition matrix around the anchor family: what tends to appear before/after dai/dain/daiin. The point wasn’t to “translate” but to stabilize the local grammar. When I permuted the text or swapped the anchor to some other frequent token, that stability collapsed. That’s how I falsified false anchors.
The working hypothesis I tested
Treat “dai” as a function carrier—something like an article, linker (and/of/in), or a grammatical suffix. Then check if:
Its expansions (dai → dain → daiin) behave like inflection/derivation (e.g., plural/possessive/case).
Its neighborhood stays consistent across sections (herbal, astro, pharma).
If a token keeps its grammatical job across wildly different topics, it’s probably not a plant name—it’s grammar.
Result: It stayed consistent.
How I actually used the anchor to “read outward”
Step A — Lock the anchor
Fix dai in place (conceptually) on a line.
Step B — Expand the ring
Collect ±3–4 tokens around every anchor hit; compute:
PMI/collocation scores
Conditional probs (P(next|dai), P(prev|dai))
Line position weights (begin/mid/end; paragraph-initial)
Step C — Identify stable attachments
Mark affixes that prefer to attach to dai (e.g., -in, -r, -dy families).
This gave me morphological templates.
Step D — Test semantic roles (without over-claiming)
I slotted trial meanings like and/of/in/this into the anchor family and checked whether the syntax flow improved (fewer contradictions in where these should appear).
I didn’t force a translation; I forced consistency.
Step E — Cross-folio verification
If the anchor = grammar, then its positional + neighbor stats shouldn’t drift much across sections.
They didn’t.
More testing needed.