💬 NLP

Recursive numeral systems are highly regular and easy to process

This paper argues that incorporating regularity and processing complexity through a Minimum Description Length (MDL) framework better explains the structure of recursive numeral systems and naturally accounts for constraints that previous efficiency-based models required to impose ad-hoc.

Original authors: Ponrawee Prasertsom, Andrea Silvi, Jennifer Culbertson, Moa Johansson, Devdatt Dubhashi, Kenny Smith

Published 2026-02-03

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ponrawee Prasertsom, Andrea Silvi, Jennifer Culbertson, Moa Johansson, Devdatt Dubhashi, Kenny Smith

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to design the ultimate instruction manual for counting. You want it to be short enough to fit in your pocket (efficient) but clear enough that anyone can understand exactly what number you mean (informative).

For a long time, linguists thought the secret to why human languages count the way they do was simply a balance between how many words you need (lexicon size) and how long the sentences get (complexity). They thought languages evolved to find the "sweet spot" between these two.

However, this new paper argues that this old view is missing a crucial ingredient: Regularity.

Here is the breakdown of their argument using simple analogies:

1. The "Lego" vs. The "Magic Box"

Think of a human language like English or Mandarin as a set of Lego bricks.

You have a small set of base bricks (1, 2, 3... 10).
You have a few rules for snapping them together (add, multiply).
To make the number 43, you just snap a "4" brick, a "10" brick, and a "3" brick together. It's a predictable pattern.

Now, imagine a "theoretically optimal" system that the old math models suggested was just as good. This system is like a Magic Box.

For the number 18, the box says "10 + 8."
For 19, it says "25 - 7."
For 20, it says "5 × 4."
For 21, it says "3 × 7."

Mathematically, this Magic Box might use fewer total words or shorter average sentences than the Lego system. But it is chaotic. There is no pattern. You can't guess how to say "22" just by knowing "21." You have to memorize every single number as a unique, weird code.

The authors argue that while the Magic Box looks efficient on a spreadsheet, it fails because it lacks regularity. Humans hate the Magic Box because it's hard to learn and hard to process.

2. The New Measurement: "Compressibility"

The researchers used a concept from computer science called Minimum Description Length (MDL). Think of this as a zip file.

A regular system (like Lego) is highly compressible. You can write a tiny rulebook: "To make numbers 10-99, take a digit, multiply by 10, and add another digit." The "zip file" is tiny.
An irregular system (like the Magic Box) cannot be compressed. You have to list every single number individually because there are no patterns to exploit. The "zip file" is huge.

The paper claims that natural languages are "optimal" not just because they are short, but because they are highly compressible. They are easy for our brains to "zip" (store) and "unzip" (process).

3. Testing the Theory

The authors ran a massive simulation:

They took 128 real human languages (like English, Mandarin, French).
They generated 10,000 random, artificial languages (including the "Magic Box" types that previous math models said were "perfect").

The Result:
The human languages were consistently more regular and easier to process than the artificial ones. Even when they forced the artificial languages to use the exact same building blocks (digits and multipliers) as the human languages, the human systems still won. They were better at organizing those blocks into a predictable pattern.

4. The "Weight" Problem

Previous studies assumed that we use small numbers (1, 2, 3) way more often than big numbers (90, 99), so they gave small numbers a lot of "weight" in their calculations. They thought, "If we only care about small numbers, the Magic Box is fine."

The authors tested this by changing the rules to treat all numbers equally (a "uniform prior").

Surprise: Even when every number counts the same, the human languages still looked much more efficient and regular than the artificial ones.
Conclusion: The "Magic Box" systems only looked efficient because the math was ignoring the big, messy numbers. When you look at the whole picture, human languages are the clear winners because of their structure.

The Takeaway

The paper concludes that regularity is a fundamental pressure in language evolution. It's not just about saving space or being informative; it's about creating a system that follows rules so that our brains don't have to memorize a million random codes.

Natural languages aren't just "efficient"; they are predictable. They are like a well-organized library where you can find any book by following a simple system, rather than a chaotic pile of books where you have to memorize the location of every single one. This predictability is what makes them easy to learn, easy to use, and why they are the way they are.

Technical Summary: Regularity and Processing Complexity in Recursive Numeral Systems

Problem Statement

Recent research in linguistics has extensively demonstrated that cross-linguistic variation is constrained by pressures for efficient communication, often framed as a trade-off between simplicity (e.g., lexicon size) and informativeness. However, existing efficiency analyses largely overlook the systematicity (regularity) of forms, a defining characteristic of natural language where form-meaning mappings adhere to rule-like patterns.

This gap is particularly evident in the study of recursive numeral systems (counting systems). Previous work by Denić and Szymanik (2024, D&S) argued that natural systems optimize the trade-off between lexicon size and average morphosyntactic complexity. While their model showed natural systems lying near the theoretical Pareto frontier, the "optimal" systems generated by their model included highly irregular, unnatural systems (e.g., systems with alternating bases). To resolve this, Yang and Regier (2025, Y&R) introduced ad-hoc constraints to artificially restrict the search space to human-like systems. The authors argue that these constraints are unsatisfying because they lack a theoretical explanation; ideally, human-like properties should emerge as byproducts of more fundamental pressures. The core problem is that current metrics fail to capture regularity and processing complexity, which are hypothesized to be the key differentiators between natural and theoretically possible numeral systems.

Methodology

The authors propose a framework based on the Minimum Description Length (MDL) principle to quantify two key properties of recursive numeral systems: irregularity and processing complexity.

1. Formalizing Irregularity

Regularity is measured via compressibility. The authors model a numeral system as a partial deterministic finite automaton (DFA) that generates all valid numerals for a given range (1–99).

Metric: Irregularity $L(G)$ is defined as the number of bits required to encode the DFA.
Calculation: The size of the DFA is determined by the number of states ( $|S|$ ), transitions ( $|Z|$ ), and symbols ( $|\Sigma|$ ). A highly regular system (like Karo Batak) has a small DFA with few states and transitions, resulting in a lower description length.
Algorithm: They use Mihov and Schulz's (2019) algorithm to infer the minimal partial DFA for a given set of numerals.

2. Formalizing Processing Complexity

Processing complexity measures the effort required to parse or generate a numeral given the DFA.

Metric: $L(N|G)$ is the average information (in bits) required to determine the unique parsing path for a set of numbers $N$ through the grammar $G$ .
Calculation: This sums the log-probabilities of transitions taken at each state, plus an extra bit for each accepting state encountered.
Priors: The authors initially test their measures using a power-law prior ( $P(n) \propto n^{-2}$ ), reflecting the communicative need for small numbers. They later test a uniform prior to challenge the assumption that small numbers dominate efficiency calculations.

3. Experimental Design

The study compares three categories of systems:

Natural Systems: 128 recursive numeral systems from natural languages (annotated at the morpheme level).
Baseline Artificial Systems: 10,000 randomly generated systems using Hurford's grammar.
"Optimal" Artificial Systems:
- Systems from D&S (optimized for lexicon size vs. morphosyntactic complexity).
- Systems from Y&R (D&S systems constrained by ad-hoc rules).

The authors also perform a local neighborhood analysis. For each natural system, they generate a set of alternative systems that share the exact same digits ( $D$ ), multipliers ( $M$ ), combinators ( $C$ ), and numeral lengths ( $L_{Num}$ ). This controls for lexicon size and morphosyntactic complexity to isolate the effects of structural arrangement (regularity).

Key Results

1. Natural Systems vs. Random Baselines

Natural systems exhibit significantly higher regularity (lower irregularity scores) and lower processing complexity than the 10,000 randomly generated baseline systems. No sampled random system was simultaneously more regular and less complex than natural systems.

2. Natural Systems vs. "Optimal" Systems (D&S and Y&R)

D&S Systems: While D&S systems lie on the lexicon/complexity frontier, they are often highly irregular and have high processing complexity compared to natural systems.
Y&R Systems: The ad-hoc constraints in Y&R improve regularity but do not fully align with natural systems. Some Y&R systems appear "more efficient" than natural systems under the power-law prior, but this is an artifact of the prior heavily downweighting large numbers. These "super-efficient" systems use extremely small lexicons (digits 1–5) to construct large numbers via deep nesting (e.g., $46 \approx (((2 \times 2 + 1) \times 2 + 1) \times 2 + 1) \times 2$ ).
Uniform Prior: When the power-law prior is replaced with a uniform prior, the "super-efficient" Y&R systems lose their advantage. The deep nesting required for large numbers significantly increases processing complexity, making them less efficient than natural systems.

3. Local Neighborhood Analysis

Even when controlling for the specific set of digits, multipliers, and combinators (thereby holding lexicon size and average morphosyntactic complexity constant), natural systems consistently lie on or near the Pareto frontier of the irregularity vs. processing complexity trade-off. This suggests that the specific structural arrangement of natural systems is not merely a byproduct of optimizing for lexicon size but is driven by pressures for regularity and ease of processing.

Significance and Claims

The paper claims that regularity and processing complexity are fundamental pressures shaping linguistic systems, distinct from and complementary to the simplicity-informativeness trade-off.

Theoretical Contribution: The authors argue that the ad-hoc constraints used in previous work (Y&R) are effectively enforcing regularity. By formalizing regularity via MDL, they demonstrate that these constraints naturally follow from the pressure to minimize description length and processing effort.
Critique of Existing Models: The study challenges the sufficiency of lexicon size and morphosyntactic complexity as the sole metrics for efficiency. It shows that optimizing these metrics alone can yield unnatural, irregular systems that fail to capture the "human-like" nature of numeral systems.
Role of Priors: The paper highlights the sensitivity of efficiency claims to the assumed prior distribution of numbers. It suggests that a uniform prior may be more appropriate for evaluating the efficiency of recursive systems, as their primary function is to express large numbers, which are heavily downweighted by power-law priors.
Broader Implications: The approach suggests that efficiency studies in other domains (e.g., grammatical categories, color terms) must incorporate the systematicity of forms. Treating compositional signals as equally complex as unanalyzable ones may lead to an underestimation of the role of regularity in language evolution.

The authors conclude that natural recursive numeral systems are optimized not just for communication efficiency in terms of information transfer, but for structural efficiency (regularity) and computational tractability (processing complexity).