The Alphabet Code: What Happens When You Run a Simple Rule on the Letter “a”

Here is a string of letters:

gzhlvzggjzyihjgheqvzgzhlvzhlvbjzgyhzizygjzbjzhlvgjzehjdzzgheqv...

It looks like a cat walked across a keyboard. It isn’t. It’s the start of a sequence that runs to thousands of characters, and every letter is fixed in advance by one rule applied to the letter “a.” No randomness, no guessing, no training data. Run the same rule again tomorrow, or on another computer, and you get exactly the same string.

That simple question — what happens when one fixed rule is applied to “a” again and again? — led me into years of studying sequences like this one. I want to show you what I’ve found, what I still haven’t figured out, and why I think a curious person might care.

The idea in one minute

Start with the letter “a” and apply the same fixed rule to it repeatedly. Each round replaces the existing letters with new strings of letters, so the sequence grows. At the same time, the earlier rounds remain embedded within the later ones.

The first seven rounds have 1, 4, 14, 43, 138, 429, and 1361 letters. Mathematicians call this a substitution system.

The unusual feature of the Engineering of Alphabets project is that the rule is applied to the alphabet itself. When I say “alphabet” here, I mean the 26 English letters together with their spoken names. A different language, or a different naming convention, would give a different sequence. I wanted to see whether the letters we use for writing, treated as a mathematical system, produce structures that are interesting, unexpected, or perhaps useful.

How I did it. I wrote a short computer program that applies the rule and records the output. For the results below, I generated several thousand letters — enough to count blocks up to length 30 and to estimate the growth factor. I used the same program to compute the growth factor for each of the 26 starting letters. The degree-13 equation came from fitting the term lengths to a linear recurrence, then factoring the resulting polynomial. A colleague or reader can rerun the program on the public data; the exact rule itself is withheld for now.

What I found

Three observations stand out. I’ll be careful to say how solid each one is.

• The sequence never settles into a loop, but it isn’t chaotic either. Imagine a text that never repeats itself, but in which the number of distinct short phrases grows slowly instead of exploding. In the range I’ve checked, that count grows roughly in a straight line. This is a measured result over a finite range, not a proof that it continues forever.
• The strings grow by a number very close to π. Each round, the sequence gets longer by a factor that converges to about 3.14159322. That is within a few millionths of π (3.14159265…). It cannot actually equal π, because it is the root of a degree-13 equation with whole-number coefficients and π is known not to be algebraic. So this may be a coincidence, or a hint of something deeper. I don’t know yet, and I’d be wary of anyone who claimed to.
• It’s a family, not a one-off. Letter “a” is one of 26 starting letters in the project. For 13 of them, the growth factor obeys the same degree-13 equation. Whether that grouping reflects something deep about the alphabet, or just the way the rule was set up, is still open.

What I am not claiming

I think this matters as much as the findings, so here it is plainly:

• I am not claiming the growth rate is π. It isn’t.
• I am not claiming the sequence is fully understood. Its straight-line behavior is observed, not proven.
• I am not claiming this beats any existing tool for compression, language processing, or character recognition. No such experiment has been run. If you work in those fields, treat any connection as a question, not a result.

Open Questions

Here is my challenge to you. See whether you can answer any of these. If you crack one, or show that I’ve got it wrong, I want to hear about it.

1. What is the equation? The growth factor is the dominant root of a degree-13 polynomial with integer coefficients. What does that polynomial mean? Is it new, or does it match something already known?
2. Is there a simpler rule hiding inside? Certain short stretches keep coming back. Do those recurring pieces follow a smaller, simpler rule of their own?
3. Does the straight line hold? The number of distinct blocks grows roughly in a straight line over the lengths I’ve checked. Does it keep going, or does it bend at longer lengths? Only deeper computation can say.
4. Why 13 of 26? Thirteen starting letters — a, d, e, g, h, i, k, l, q, u, w, y, z — have the same degree-13 minimal polynomial:
   4x¹³ − 21x¹² + 45x¹¹ − 74x¹⁰ + 98x⁹ − 34x⁸ − 116x⁷ + 210x⁶ − 152x⁵ + 26x⁴ + 38x³ − 30x² + 9x − 1
   The rest of the letters have a degree-14 polynomial, which is exactly this one multiplied by (x − 1). So all 26 share a common structure. The 13 listed above are the ones where the extra factor cancels out. Why? Does that split mean something about the alphabet, or is it an artifact of how the rule was set up?
5. Why is the growth factor so close to π? The closeness is striking, but the number is algebraic and cannot be π. Is there a mathematical reason for the resemblance, or is it a coincidence?

Why This Might Matter Beyond Pure Math

These are possible directions, not demonstrated applications. None has been tested yet.

You might be thinking: this is interesting, but what does it have to do with anything? Here are the directions I think are worth exploring.

• Language compression. If sequences generated from letter names have low-complexity structure, that structure might be exploitable for compression. Whether it actually helps would need a real benchmark.
• Natural language research. The alphabet is the foundation of written language. If deterministic structure underlies how letters relate to each other, it could say something about the mathematics of language itself.
• Training-free representation. The encoding is purely algebraic: no training data, no loss function, no randomness. The output is fixed and reproducible for anyone who runs it, which makes it auditable. It handled noisy input well in a separate study, but it’s still unclear whether that matters for other tasks.
• OCR and character recognition. Could truncated EOA vectors outperform the full vector on character recognition tasks? This is an open question, not a result. Standard OCR relies on trained networks and labeled data; whether a training-free encoding adds anything is untested.
• Low-resource languages. Where no tagged text exists, you can’t train a model. If an alphabet can be encoded deterministically, it might support tokenization and compression tools without training data.
• Speech and phonetics. The encoding is phonetic. Could it connect to phoneme-level representations, or help with unseen words? That is a question, not a claim.
• Memory. Low factor complexity suggests the number of distinct patterns stays small, which might mean lower storage needs.
• Research into alphabets. Most alphabet research is historical or linguistic. This treats the alphabet as a formal system rather than a cultural artifact, and the early results are surprising enough to keep going.

No compression, OCR, speech, or language-modeling experiment is reported here.

The Bigger Picture

The Engineering of Alphabets is a research program that studies what happens when you apply deterministic rules to alphabets. The letter “a” is just the beginning. The project includes 13 main sequence families, plus several related cases. Each one has its own structure, properties, and open questions.

The alphabet can be treated as a mathematical object, not only as a tool for writing. Whether that view leads anywhere is what the open questions are for.

Try to break it

Science works when people try to prove each other wrong, so here is what I’d ask of you.

• If you’re curious: download the first 6,260 letters of the sequence and look for patterns I missed. Download the data.
• If you’re a mathematician or computer scientist: check my numbers. Even “your count is wrong” would help me a lot. See the code on GitHub.
• If you work with language, speech, or text: tell me where, if anywhere, you’d test something like this.