Convergent Evolution: Why All Large Language Models Understand Numbers the Same Way
An "Overly Perfect" Coincidence
Imagine you are a biologist who discovers three creatures—mammal, cephalopod, insect—with strikingly similar eye structures in completely different corners of the Earth: lens, retina, photoreceptor cells, nearly identical. This is not because they share a common ancestor, but because the physical constraint of light is so strong that any species trying to survive on Earth will eventually evolve a similar visual system.
Biologists call this Convergent Evolution.
Now move this story to the AI world.
A research team from USC and UCSD discovered an equally surprising phenomenon: GPT-2, Llama-3, Llama-4, DeepSeek-V3, Mamba, xLSTM, GloVe, FastText—models with completely different architectures, different training methods, spanning nearly a decade—have independently evolved almost identical representations for understanding numbers.
They all arrange numbers on a "latent space circle" with periods of 2, 5, and 10.
But the story is just beginning. Because the researchers then found a deeper problem: seeing periodic structure does not mean the model truly "understands" numbers.
Two Levels of "Convergence": Looking Alike ≠ Being Alike
The paper distinguishes two types of convergence:
Spectral Convergence: Model number embeddings show Fourier-domain spikes at T=2, 5, 10. This is the "view from afar"—you see periodicity.
Geometric Convergence: Number embeddings form linearly separable classes by n mod T in space. This is the "view up close"—you confirm the periodicity actually corresponds to functional structure.
The key finding: almost all models achieve spectral convergence, but only some achieve geometric convergence.
The most shocking example is LSTM. On identical training data, LSTM's Fourier spikes are even larger than Transformers', but its mod-T probe accuracy stays at random-chance level.
In other words, LSTM's number embeddings look more "periodic," but its actual understanding of numbers is worse than Transformers.
A Mathematical Theorem: Why "Looking Like" ≠ "Being"
Fourier spikes tell you: between-class centers are indeed dispersed (between-class scatter > 0). But they don't tell you: whether the numbers within each class are also spread out (within-class scatter).
If within-class scatter far exceeds between-class scatter, the classes overlap heavily even with dispersed centers, and a linear classifier cannot separate them.
The researchers use Fisher's LDA for a precise mathematical characterization:
> Maximum separability = Φ_T / (N · λ_min(S_W)) · 1/cond(S_W)
where cond(S_W) is the condition number of the within-class scatter matrix. The larger the condition number, the more the periodic signal gets "drowned out."
LSTM's problem is exactly here: its within-class scatter is highly anisotropic (very large condition number), so the periodic signal is completely swallowed by noise. The Transformer's within-class scatter is more uniform, preserving the periodic signal.
The deep implication: any representation-level diagnostic method may mistake statistical artifacts of training data for learned structure. This is an important warning for the entire mechanistic interpretability field.
Three Forces: Data, Architecture, Optimizer
Data: Three Complementary Signals
| Perturbation | Structure Removed | mod-10 Probe κ | |---------|-----------|-------------| | Original | None | 85.4% | | Swap Numbers | Number↔text association | 28.8% | | Unigram replacement | All co-occurrence | ~0% | | Isolate-1 | Number interactions | 45.0% | | Isolate-8 | Limited number interactions | 77.2% | | Context length 2 | Long-range context | 40.3% | | Context length 64 | Long-range context | 72.0% |
Key findings:
1. Text-number co-occurrence is the most important signal. Shuffling number-text associations (Swap Numbers) drops probe performance from 85.4% to 28.8%. 2. Number-number interactions are the second most important. Even when two numbers cannot appear in the same attention window (Isolate-1), Transformers still reach κ=45.0%, far above classic PPMI (27.1%) and word2vec (29.3%). 3. Long-range context provides additional gains. Context growing from 2 to 64 steadily improves probe performance.
No matter the perturbation, Fourier spikes always persist. This confirms spectral and geometric convergence are driven by different mechanisms.
Architecture: LSTM's "Structural Failure"
With identical data and optimizer:
- Transformer: κ = 85.4% (mod-10)
- Gated DeltaNet (linear RNN): κ = 77.8%
- Mamba-2 (linear RNN): κ = 80.1%
- LSTM: κ ≈ 0% (chance level)
Optimizer: Effects Vary by Architecture
Muon outperforms AdamW on Transformers (85.4% vs 72.1%) and Gated DeltaNet (77.8% vs 69.7%), but is slightly worse on Mamba-2 (76.7% vs 80.1%). Optimizer effects are not universal—they interact with architecture.
A Second Path: Convergence in Arithmetic Training
If you train models directly on addition rather than natural language, does convergence still happen? The answer depends on tokenization.
9-digit addition (multi-token): each digit is split into multiple tokens. Each output digit becomes a mod-1000 classification problem (due to carries), forcing models to learn modular arithmetic—converging to the same periodic representation regardless of optimizer.
3-digit addition (single token): each number is one token. No modular arithmetic constraint exists—the sequence "a+b=c" is equally consistent with mod-1000 or mod-1111. Results depend entirely on random seed and optimizer; stable convergence is impossible.
This reveals a deep insight: the tokenizer determines the "environmental pressure" a model faces. Multi-token tokenization implicitly creates modular subproblems through carry propagation; single-token tokenization imposes no such constraint.
Engineering Insights for AI Practitioners
1. Don't be fooled by Fourier spectra. If probing shows beautiful periodic structure, don't rush to conclude the model "learned" something—first check the condition number of within-class scatter.
2. LSTM genuinely fails at number understanding. This is an architectural limitation, not a training issue. If your application involves numerical reasoning, LSTM may be a poor choice.
3. Tokenizers matter more than you think. They determine what number representations a model can learn. Multi-token digit representations actually help models understand number structure.
4. Muon is worth trying. On Transformers, Muon beats AdamW for number representation learning.
5. "Convergent evolution" is a useful mental framework. When different models show similar behavior, don't assume they use the same mechanisms—like eyes, the same result can come from entirely different evolutionary paths.
Closing Thoughts
The most compelling aspect of this paper is its methodology: rather than concluding from observed phenomena, the researchers use carefully controlled experiments (varying one variable at a time) and rigorous mathematical proofs to expose the gap between "looking like" and "being."
This structure attribution approach—attributing model behavior not to individual training samples (as influence functions do) but to structural features of the data distribution—offers a new perspective for mechanistic interpretability.
The deeper lesson: representational similarity may mask fundamental mechanistic differences. When we say two models "learned the same thing," we may need to ask more carefully: did they really learn the same thing, or do they just look like it?
---
Paper: Convergent Evolution: How Different Language Models Learn Similar Number Representations (arXiv: 2604.20817)
Authors: Deqing Fu, Tianyi Zhou, Mikhail Belkin, Vatsal Sharan, Robin Jia (USC & UCSD)
Project page: convergent-evolution.github.io
Model weights: HuggingFace Collection
Blog: Project blog