DEV Community: Bahaa Budargham

The Alphabet as a Sequence Engine: A Census of What Letter Names Generate, and What the OEIS Has Never Seen

Bahaa Budargham — Tue, 27 Oct 2026 21:09:20 +0000

Abstract
We evaluate the integer sequences generated across 36 human writing systems under the Engineering of Alphabets (EOA) operator. Auditing all 1,056 resulting sequences against the On-Line Encyclopedia of Integer Sequences (OEIS), three facts survive every check we could devise. First, the growth rates of these sequences cluster on a small set of exact algebraic numbers 2.618…, 3.414…, 2.414…, 2, and 3, with 2.618… (φ²) the single largest cluster. Second, several of the generated sequences are, term for term, classics of mathematics: the powers of two, the Fibonacci bisections, the Lucas bisection, the Pell family, the Mersenne numbers, and the bare counting numbers, each verified against the full published OEIS record (up to 90 terms) from our 500-term exact sequences. Third, 346 distinct generated sequences appear in no catalogue, although every one satisfies an explicit integer linear recurrence. To test whether these observations arise by chance, we evaluate two random-baseline controls: random alphabets of matched size never form the tiny cores that natural scripts form (0 of 250 simulations), and the English E5 spectrum splits into two equal halves, a pattern random alphabets never produce (0 of 100 simulations). We release the full census, the matrices, and the verification code, and we pose two challenges to the sequence community.

1. THE RULE, IN ONE PARAGRAPH
Every letter has a name. Apply a fixed recursive expansion rule to each letter name, and repeat round after round. This produces an endless string of letters. Count how long the string becomes at each round: that growing list of numbers is the letter’s sequence. The counts obey a fixed recipe fixed by the script’s letter names alone; no tuning, no search. The mathematical engine behind every sequence is the script’s incidence matrix, and the growth rate of the counts is the Perron eigenvalue of that matrix. The matrices for all 36 scripts are open data; everything below was recomputed from them in exact integer arithmetic.

2. WHAT WE MEASURED
This census covers 36 different writing systems, totaling 1,056 individual letters. We chose these scripts based on their documented historical names and to include a wide mix of different writing styles from unconnected parts of the world. We did not cherry-pick this list to force a result. We deliberately kept all the 'failures' in our dataset: 8 scripts that matched nothing in the OEIS at all (seven formed massive, tangled graphs, while Georgian collapsed), along with several scripts that produced completely trivial, flat sequences. If we had filtered the data to keep only the 12 scripts that generated the non-trivial mathematical families, two-thirds of the dataset would have been thrown out. Because we kept them in, you can trust that the patterns we found emerged naturally from the raw data.
The 1,056 letter-sequences collapse into 402 distinct sequences, because letters that share a naming pattern share their sequence (Appendix, Tables A1–A2). For each distinct sequence we computed its exact recurrence order and its growth rate. Two summaries:
• Recurrence orders run from 1 to more than 14. The most common orders are 13 (47 sequences), 5 (41), 4 (29), and 11 (23); 176 sequences need order above 14.
• Growth rates cluster tightly: 78 sequences grow at φ² = 2.618…, 44 at 2+√2 = 3.414…, 27 at 1+√2 = 2.414…, 20 near 3.1416 (English), 19 near 4.21 (Ogham), 19 at exactly 2 (the Mersenne regime), 8 at exactly 3 (Korean), and 30 distinct sequences are flat (rate 1), matched by 176 letters total.
This census is not a sample; it is the whole population of distinct sequences the 36 scripts can produce. Growth at φ² is the most common outcome in the entire dataset.

3. WHAT MATCHED THE OEIS, AND SURVIVED VERIFICATION
While all our sequences were generated to 500 terms, published OEIS records cut off much earlier; we kept only identities that hold term-by-term across the entire available OEIS entry (up to 90 terms) under an exact recurrence check. These are exact structural identities, not coincidental prefix agreements or numerical approximations. Six families pass:
• The powers of two, A000079: generated by four Hebrew letters (bet, tet, mem, nun), and by the same naming pattern in Phoenician, Aramaic, Syriac, Arabic, Japanese-pronounced Latin, Sanskrit and Amharic. (1, 2, 4, 8, 16 … to 2⁸⁹, exact.)
• The Fibonacci bisection, A001906: generated in Ge’ez and Thai (1, 3, 8, 21, 55 …). Its recurrence t(n+2) = 3•t(n+1) − t(n) is the polynomial x²−3x+1 , the same equation behind the φ² growth above. The odd Fibonacci numbers, A001519, appear the same way in both scripts.
• The odd-index Lucas numbers, A002878: two Thai letters (1, 4, 11, 29, 76 …), same polynomial, different seeds.
• The Pell family, A094723 and A048739: generated in Arabic. Their growth rate is the silver ratio 1+√2 , which is exactly why the Arabic core grows at 1+√2.
• The Mersenne numbers 2ⁿ−1, A000225: generated in Japanese-pronounced Latin, Aramaic and Sanskrit.
• The silver-square recurrence, A007070: generated in Burmese (1, 4, 14, 48 ...), growing exactly at 2+√2.

These six families are not arbitrary; four of them are organized by three exact quadratic irrationals,
φ² = 2.618…, 1+√2 = 2.414, and 2+√2 = 3.414…, which recur across unconnected scripts. We call these the "Crown Jewels" of the census. Together, these three constants host 9 catalogued OEIS sequences and 9 uncatalogued cross-script core-letter groups spanning six scripts.

Table A1 lists all fourteen catalogued sequences, including the further matches beyond these six (the bare counting numbers A000027, the all 1s A000012, the shifted counting variant, the odd numbers A005408, the cake numbers A000125, and A000295).

4. WHAT MATCHED NOTHING, THE UNCATALOGUED HALF
346 distinct sequences have no OEIS entry (Table A2 lists the per-script breakdown; every sequence is released with its recurrence in census.csv and uncatalogued_sequences.csv). Each one satisfies an explicit integer linear recurrence of small order, derived from its matrix, and each is released with that recurrence, its matrix, its script and its letters. They concentrate in the large-core scripts: every letter of English E5, Greek, Gothic, Runic, Ogham and Glagolitic is uncatalogued. We make no claim that they are important; we claim only that they are generated, that their recurrences are known, and that no catalogue records them. Whether that gap is worth filling is precisely Challenge I below.

5. TWO CONTROLS THAT MAKE THE ABOVE MEAN SOMETHING
(a) The small-core anomaly. The six verified families come from tiny closed loops of letters: Hebrew and Arabic have dominant cores of 3 letters, Thai of 2, Japanese of 4. Is that usual? We built 250 random 26-letter alphabets with the same name lengths (2–5 letters per name) and computed their cores. Every random alphabet entangled into one giant loop: core sizes ran from 21 to 26, and not one fell below 21 (0 of 250). Natural scripts, in other words, do something random name systems never do: they isolate their growth into loops of two to four letters. This is the quantitative backbone of our name-structure conjecture, and it is reproducible with one script run.
(b) The English split. The English E5 matrix factors as thirteen linear factors and one irreducible polynomial of degree exactly 13, a spectrum split into equal halves. We generated 100 random 26-letter alphabets of matched shape: none produced such a split (0 of 100). Generic random matrices have one large irreducible factor of degree 20 to 26 and almost no linear factors. The English split is a genuine structural anomaly, not a presentation choice.

6. THE CHALLENGES
I. To the uncatalogued 346. Each is released with its recurrence, matrix and attestation. We ask the community for an adjacency audit: is a sequence’s recurrence family already represented in the OEIS? Our own flagship example was, the Hebrew pair dalet and lamed: they generate 1, 4, 12, 34, 94, 256, 690 …, which is 2•F(2n) − 2^(n−1): an order-3 cousin of two catalogued families, whose sibling F(2n+2) − 2ⁿ is A105693. We had called it missing; the record corrected us, and we print the correction. Where a family is genuinely unrepresented and of independent interest, we support inclusion. Where it is catalogued, we ask only that the census record the correspondence. A reasoned rejection will be published with the same care as a match.

II. To the matched six families. Is the hit rate itself remarkable, or do small integer matrices match the OEIS at high rates regardless? We designed a random-matrix control, density-matched, row-shuffled, and degree-preserving, at match windows from 10 to 40 terms, and released the protocol and code. We have not run it to completion. The interpretation rules are fixed in advance: if real scripts match above all controls, naming structure selects catalogued sequences; if they match at control levels, the census rests on the verified identities and the controls alone; if real beats the density control but not the degree-preserving one, the driver is name length and degree structure. Whichever outcome occurs, we pre-commit to publishing it.

7. WHAT WE CLAIM, AND WHAT WE DO NOT
We present an objective measurement: the first complete census of the integer sequences generated by 36 human writing systems, with two verified structural anomalies (small cores, and the English split) and six exact term-for-term matches to named sequences. We do not claim that ancient scribes intentionally encoded mathematics into letter names, nor that these mathematical matches are surprising in number, or that the uncatalogued 346 are profound. The honest open question is the one the census poses and cannot answer: why does the same handful of polynomials, x²−3x+1 above all, organize naming systems that never met?

VERIFICATION AND MATERIALS
Every sequence was computed to 500 terms in exact BigInt arithmetic from the open matrices, and identities in Section 3 were verified against the full published OEIS entries up to 90 terms. The pre-computed census tables (census.csv, uncatalogued_sequences.csv, census_summary.json) and verification scripts ship directly with the release: audit.py (generates the 402-sequence census), verify_wows.py (reproduces the term-exact OEIS identity checks), baseline_oeis_lookup.py (hit-rate control protocol), and e5_split_test_sage.sage (E5 spectral split null).
Matrices: https://doi.org/10.5281/zenodo.23440579.
Main technical paper: https://doi.org/10.5281/zenodo.23449728.
Appendices: https://doi.org/10.5281/zenodo.23695751.

The Golden Ratio Is Hiding in the Alphabet

Bahaa Budargham — Sun, 18 Oct 2026 16:19:06 +0000

To the eye, an alphabet is pure history. Scripts are borrowed, sounds drift, and every culture bends the letters to fit its own tongue. Nothing about it looks like mathematics.
Yet underneath, the names of the letters form a hidden structure. Follow it, and an exact number appears: the Golden Ratio squared. And it appears not once, but in writing traditions that never met.

THE DISCOVERY
We took 36 writing traditions, from Hebrew and Arabic to Thai, Korean, Runic and English, each with its own set of letter names. We applied one strict rule to all of them: follow how each letter’s name refers to other letters, and measure how that network grows. We used no tuning and did not go looking for famous numbers. Every tradition got the same rule.
The results were not random. They gave a small family of exact constants:
φ² = 2.618… the Golden Ratio squared
Hebrew • Phoenician • Ge’ez • Thai • Japanese-pronounced Latin

2 + √2 = 3.414…
Aramaic • Syriac • Burmese

1 + √2 = 2.414…
Arabic

And English? Its letter names land on 3.141593…, a number that agrees with π to five digits. It is not π itself, but it is close enough to make you look twice.

IT IS NOT LUCK
We built 4,482 random networks of the same size and shape. The Golden Ratio squared appeared in only 5.8% of them. The chance that three unrelated writing traditions all land on that exact number by accident is less than 1 in 100.

SEE IT FOR YOURSELF
Three Hebrew letters, Alef (א), Dalet (ד) and Lamed (ל), are tied together by their names. Each one points to the others. Written as a grid, the loop looks like this:
[1 0 1]
[1 1 1]
[1 1 1]
Three letters. One loop. Out comes φ² = 2.618…, the Golden Ratio squared.

Nobody tuned this. These are just letter names, the same ones used for three thousand years.

THE MYSTERY AND THE OPEN CALL
The data is exact, and anyone can check the math. But why this happens is still unknown. The blind tests have carried the work as far as one researcher can.
Break it. Try other historical spellings and pronunciations. Does the pattern survive?
Find the next one. Test an alphabet nobody has tested yet. Which number does it give?
Explain it. Why do human letter names keep choosing the same few exact numbers? We need a theorem.

WHERE IT COULD MATTER
Mathematics and symbolic dynamics. Which exact numbers can human naming systems produce, and why so few? A theorem is waiting to be written.
Combinatorics on words. Every alphabet becomes a sequence that generates itself. What kind of sequences are they?
Linguistics and the history of writing. A numerical fingerprint for each script: a new way to compare traditions, test transliterations and trace how alphabets descend from one another.
AI and language technology. Tokenizers that split text for AI models follow the same kind of substitution rule. Could this fingerprint predict how well a language compresses? Can a model learn the rule from the strings alone?
Information theory. The growth rate is a single number that measures how much hidden structure a naming system carries.
Cognitive science. Why would people naming letters, centuries and continents apart, build the same small loops?
Physics and biology. Do the same loops and constants appear in models of growth, or in how biological codes are named?

These are open questions, not claims. Each one is a paper waiting for the right person.

The framework has now survived five out-of-sample tests: it replicated under an inherited naming tradition, collapsed exactly where the filter predicted (Vietnamese), matched a timestamped prediction (Ogham), exposed a false positive in a lineage’s modern descendant (Glagolitic vs Cyrillic), and produced a target constant on command (√3). We do not claim a law. We claim a machine that has not failed a test yet, and we are inviting you to try to break it.

We are saying something stranger:
the names of the letters themselves follow rules no one has measured until now.

WHAT IS ALREADY ON THE TABLE
Open dataset. The full incidence matrices for all 36 writing traditions, as CSV files, with a verification script that recomputes every growth rate in seconds.
https://doi.org/10.5281/zenodo.23440579

Technical paper. Exact factorizations for every script, the small core loops behind each constant, an exhaustive baseline of 4,482 random networks, a significance test corrected for shared history, a complete classification of the small quadratic constants, five out-of-sample blind tests, open conjectures, and full references.
https://doi.org/10.5281/zenodo.23449728

I am looking for collaborators, co-authors and institutional partners
to take this to the next scale.
Contact: Bahaa Budargham • ORCID 0009-0005-2955-3703
The door is open.

The Budargham Constant λ(E5): Minimal Polynomial, 26x26 Incidence Matrix M, and 1,000-Digit Expansion

Bahaa Budargham — Thu, 15 Oct 2026 14:26:35 +0000

The Budargham Constant ; λE5 (BE5):
λE5 = 3.1415932235776478077659351649002756071087111553047325144046...

This record formally documents the mathematical constant λE5 (the EOA Limiting Ratio under encoding E5). It is defined as the unique strictly dominant real root (Perron root) of the monic, irreducible degree-13 integer polynomial:

G2(x) = x¹³ - 9x¹² + 30x¹¹ - 38x¹⁰ - 26x⁹ + 152x⁸ - 210x⁷ + 116x⁶ + 34x⁵ - 98x⁴ + 74x³ - 45x² + 21x - 4

Key Properties:
• Spectrum of M: λE5 is the spectral radius of the released 26×26 non-negative integer incidence matrix M (matrix_M_E5.csv). Over Q, the characteristic polynomial factors with an equal-degree split:
charpoly(M) = (x - 2) · x³ · (x - 1)⁹ · G2(x).

• Galois Invariant: G2(x) is irreducible with full symmetric Galois group S13 (order 13! = 6,227,020,800).

• Certified Precision: Full 1,000-digit expansion is certified in lambda_E5_1000_digits.txt (verified by checksums.sha256).

• Proximity to π: |λE5 - π| ≈ 5.70 × 10^^-7 (treated as a numerical coincidence).

• Reciprocal Constant: 1/λE5 ≈0.318309886... marks the exact radius of convergence of the generating function.

• Independent Verification: verify_e5.py recomputes the characteristic polynomial factorization and all 1,000 digits directly from M and G2(x).

Staged Disclosure:
The matrix M, polynomial G2(x), and 1,000 digits are fully public. The phonetic letter-name strings and recursive β-operator that generated M are withheld under staged disclosure. Access for collaboration: bdarghamneurolabs@gmail.com.

Access the full matrix, 1,000-digit file, and verification scripts on Zenodo: doi.org/10.5281/zenodo.23395237

Inside a Zero-Entropy Sequence: 12 Visual Diagnostics from EOA Sequence Visualizer v4.1

Bahaa Budargham — Wed, 14 Oct 2026 18:23:52 +0000

When you study a deterministic sequence running into thousands of symbols, summary statistics alone don't tell the full story. You need multiple geometric and topological angles to see what the grammar is actually doing.

In the Engineering of Alphabets (EOA) program, we apply a deterministic recursive operator to phonetic letter encodings. Starting with the spoken name of the letter "a", the system generates a discrete sequence with strictly linear factor complexity and an asymptotic growth ratio near $\pi$ ($\lambda \approx 3.141593$).

To audit its properties without relying on hand-waving, our analysis tool—eoa_sequence_visualizer_v4.1—generates a 12-panel diagnostic suite. Rather than just making generative art, each panel isolates a specific dynamical property: subword graphs, recurrence matrices, topological entropy ladders, and surrogate controls.

Below is the complete 12-panel breakdown extracted from the verified 2,500-symbol prefix.

Panel 1 — Symbolic Turtle Rendering

L-system path tracing where symbols govern rotation and forward translation step-by-step.

Panel 2 — Chaos Game Representation (CGR)

Fractal-space mapping tracking how consecutive subwords distribute across the state space.

Panel 3 — Symbolic Recurrence Matrix

2D recurrence plot exposing exact long-range repetitions, bounded gaps, and diagonal lines.

Panel 4 — Rewrite Engine Waveform

Amplitude signal showing discrete state transitions generated by successive rewrite rounds.

Panel 5 — Empirical Eigenvector Projection

2D projection along the dominant eigenvectors of the letter transition spectrum.

Panel 6 — Subword Transition Graph (Rauzy Graph)

Directed network showing factor connectivity and isolating the small 4-symbol branching core.

Panel 7 — Desubstitution Test

Inverse-morphism scan testing whether recurrent blocks collapse back into a primitive substitution rule.

Panel 8 — Factor Complexity $p(k)$ vs $k$

Counting distinct subwords up to length 30; confirms strictly linear subword growth.

Panel 9 — Abelian Complexity $a(k)$ vs $k$

Subword complexity under Parikh vectors, evaluating permutation symmetry across words.

Panel 10 — Finite-Sample Block-Growth Ladder

Comparing empirical graph spectral radius against observed block growth to test the zero-entropy boundary.

Panel 11 — Prefix-Frequency Discrepancy

Measuring balance and deviation of letter counts against expected asymptotic frequencies.

Panel 12 — Surrogate Controls

Null-model benchmarks testing the sequence against random shuffles and order-1 Markov surrogates.

Open Data & Verification

All raw data, checksums, and technical notes are openly available for independent analysis:

📦 Zenodo Record: doi.org/10.5281/zenodo.23019059
📂 GitHub Repository: bahaa-budargham/eoa-symbolic-sequences
🌐 Research Portal: research.neurolabs.space

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

Bahaa Budargham — Tue, 06 Oct 2026 21:39:41 +0000

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.

Figure 1. The sequence for the letter “a” drawn as a path: each letter tells a virtual pen how to turn and move, so a fixed rule produces this shape.

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.

Figure 2. Distinct blocks p(k) by block length up to 30, shown on a logarithmic vertical axis. Dashed orange is a linear reference; dashed blue is the Sturmian minimum (k+1).

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.

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?
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?
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.
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?
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. click
• If you’re a mathematician or computer scientist: check my numbers. Even “your count is wrong” would help me a lot. click
• If you work with language, speech, or text: tell me where, if anywhere, you’d test something like this.

The data and part of the code are public. The code that generated the sequence is not public, but the code that counted the blocks and computed the growth factor is. The exact letter-by-letter table behind the rule is shared under a short written agreement, because a first formal paper is still in preparation. That is a timing decision, not a permanent lock, and the open questions can be worked from the public data alone.

You can reach me at Bahaa Budargham.
ORCID: 0009-0005-2955-3703. Zenodo • GitHub

Symbolic Dynamics from Letter Names: A Degree-14 Rational Generating Function and a Limit Near π

Bahaa Budargham — Sun, 20 Sep 2026 03:08:58 +0000

I have been working on a deterministic operator called (EOA). It maps the spoken names of letters into integer sequences.

For one English encoding, I generated over 600 terms of one sequence. The final term has 249 digits. I then used gfun to guess a rational generating function. It returned a rational function of degree about 14.

That means the sequence satisfies a linear recurrence with constant coefficients. If the recurrence is exact, the sequence goes on forever and its limiting ratio is algebraic.

The limiting ratio is numerically close to π to five decimal places. It is not exactly π. Because the generating function is rational with integer coefficients, the limit is algebraic, while π is transcendental. The interesting result is the algebraic structure, not the digits.

The generation code is not public. It is available to collaborators. The data and the generating function are public so anyone can check the recurrence.

What is EOA?
EOA stands for Engineering of Alphabets. It is a research program that studies deterministic recursive operators on phonetic letter names.

The process is simple:

Take the spoken name of a letter.
Apply a fixed deterministic operator.
Get an integer sequence.

There is no training data, no randomness, and no statistical optimization.

Under one encoding, English Modified #5, the system produces 20 distinct sequences. These sequences split into two families. The larger family contains 13 sequences. They share a common denominator and satisfy the same linear recurrence.

I focus here on one sequence from that family.

The data
I published over 600 terms of this integer sequence. The final term has 249 digits.

The data is archived on Zenodo:

https://doi.org/10.5281/zenodo.22738062

Access is available upon request. You can request access to the dataset and run your own checks.

The tool: gfun
gfun is a Maple package for guessing generating functions from finite sequences. It takes the first N terms and tries to find a rational function that matches them.

I ran gfun on the 600+ terms. It returned a rational generating function of degree about 14.

Here is the denominator of that rational function:

This is the common denominator for the larger family of 13 sequences. The numerator for this specific sequence is a polynomial of degree 13.

A rational generating function means the sequence satisfies a linear recurrence with constant coefficients. The order of the recurrence is the degree of the denominator, which is 13.

What this means
If the recurrence is exact, then:

The sequence is infinite. You can generate as many terms as you want from the recurrence and the initial conditions.
The limiting ratio of consecutive terms is algebraic. It is the reciprocal of the smallest-modulus root of the denominator polynomial.
The limiting ratio cannot be exactly π. But π is transcendental, so it cannot be the root of a polynomial with integer coefficients.

The numerical agreement with π is therefore a coincidence. It is an interesting one, but it is not a proof of exact equality.

The real result is the algebraic structure: a degree-13 recurrence that generates the sequence.

Verification and collaboration
The generation code is not public. I am seeking collaborators to independently verify and extend the work.

If you are a mathematician or developer, you can:

Request access to the data on Zenodo.
Check whether the recurrence holds for all 600+ terms.
Try to extend the sequence to more terms
Report any errors or improvements.

If you want access to the generation pipeline for verification, contact me. The code can be shared under a collaboration agreement.

The recurrence itself is public. The denominator is above. The data is public. That is enough to check whether the sequence satisfies the recurrence.

Possible applications and domains for further investigation
If the recurrence is exact, it opens several potential directions. None of these are demonstrated yet. They are domains where I believe the structure could be useful, and where I am looking for collaborators.

Symbolic dynamics. The operator produces sequences that satisfy a linear recurrence. This connects to finite-state systems and shift spaces. A natural question is whether the operator defines a sofic shift or a subshift of finite type.
Linear recurrences and generating functions. The degree-13 recurrence is a concrete algebraic object. It could be studied for its own sake: factorisation of the denominator, distribution of roots, and the algebraic nature of the limit.
Combinatorics on words. The mapping from letter names to sequences is a morphism or substitution. The combinatorial properties of this mapping, such as fixed points, recognisability, and factor complexity, are open.
Coding theory and compression. If a long sequence is generated by a short recurrence, it can be compressed. The recurrence coefficients and initial conditions are enough to reconstruct the entire sequence. This is a form of lossless compression for this specific data.
Cryptography and pseudorandom generation. Linear recurrences over finite fields are the basis of LFSRs. If the EOA operator can be adapted to finite fields, it could serve as a deterministic pseudorandom generator. This is speculative and needs careful study.
Machine learning and representation learning. The EOA sequences are deterministic, training-free embeddings. They could be used as structural priors or as fixed features in models that process language or symbols. The rank collapse observed in word vectors built from these sequences suggests a strong inductive bias.
Mathematical linguistics. The operator acts on phonetic encodings. It raises questions about the relationship between the sound structure of language and algebraic structure. Is the recurrence stable across languages and encodings? What does the limit say about the encoding?

If you work in any of these areas, I want to hear from you. The goal is to test the structure, extend it, and find out whether it is useful.

What is next
I am looking for independent checks and collaborators.

If the recurrence is correct, it strengthens the result. If there is an error, it clarifies what the system is actually doing.

Contact me if you want to collaborate on verification, extension, or application.

GitHub repository | Zenodo archive | Research site | Internet Archive