What this is. A way of ranking mathematical constants — π, e, √2, and their cousins — not by how mysterious they seem, but by how expensive they are to pin down. This document is written for the curious reader, not the compiler; you will not need to install anything, and there is no code below. If you have ever wondered whether π is "really" harder than √2, this is a guided tour of one surprisingly sharp way to make that question precise.
Every method for approximating an irrational number is, at heart, a little factory that stamps out fractions. Feed it patience — more terms, more iterations — and it hands you back a better fraction: 3/1, then 22/7, then 333/106, and so on toward π. We call each such factory an engine, and the fraction it produces at any given moment is a prefix of the number's address. The engine itself is a finite program. Each output pins the number down to a smaller cell. The full address is infinite, and the framework asks how infinite: how fast the address must grow as the cell shrinks.
A note on the name. "Rational Certificate Complexity" is historical, and the word certificate is misleading. A certificate is something cheaper to check than to produce. A fraction is not: nothing about 355/113 alone tells you it is near π, and the only way to confirm it is to recompute π far enough to compare. Read RCC as rational addressing complexity. It measures address length, not the size of a proof.
This is the same question Diophantine approximation asks ("how well do fractions approach this number?"), but posed without first assuming the real line exists. A number, here, is whatever an engine addresses. Two engines address the same number when their cells keep overlapping at every resolution.
The framework asks a deceptively simple question. If you demand an answer accurate to within some tolerance ε, two costs come due:
- How many steps must the factory run? (The classical question.)
- How big are the fractions it produces — how many bits to write down the top and bottom? (The question almost everyone forgets to ask.)
That second cost turns out to be the interesting one. It is measurable, it is falsifiable, and — this is the headline — it sees distinctions that the first cost is completely blind to.
The pieces of this story are old and scattered. Numerical analysts have studied
convergence rates for centuries; number theorists study the "height" of rational
approximations; complexity theorists (the Ko–Friedman school) ask whether a real number
can be computed quickly at all. What is unusual here is the synthesis: fix one specific
engine, truncate it, and watch the bit-length of the resulting fraction grow as you
tighten the tolerance. That single, concrete measurement — bit-length versus tolerance —
becomes the number's rational certificate complexity.
This framework is a natural companion to the Numbers as Machines (NAM) essay, which
ranks numbers by the size of their machine's state; RCC instead ranks them by the bit
cost of their certificates. The two hierarchies agree on the headline — algebraic
irrationals like √2 are genuinely cheap, while the classical series for π are not — and
both find their concrete home in the nam interactive lab, where the honest cost of
each digit is put on the screen.
There is an information-theoretic floor underneath all of this. There are at most 2^B addresses of length B bits, so together they can distinguish at most 2^B cells. Resolving typical numbers to within ε therefore takes at least about log₂(1/ε) bits of address. An engine that spends only about that many bits is on the floor.
Be careful, though: this is a statement about all addresses of a given length, not a law
binding each individual number. A particular number can have unusually short addresses at
some scales; 355/113 is one for π. Whether a specific number's best addresses sit on the
floor at every scale is exactly the question of its irrationality exponent. For π, that
question is open (see ../openai/diophantine_rcc.md).
Sort the classical engines by this cost and a clean hierarchy falls out:
| Engine | Steps needed | Bits needed | Verdict |
|---|---|---|---|
| Binomial series for √k | logarithmic | logarithmic | optimal (the best tier) |
| Gregory–Leibniz for π | ~1/ε | ~1/ε | polynomial |
| Nilakantha for π | ~1/√ε | ~1/√ε | polynomial |
| Wallis product for π | ~1/ε | (1/ε)·log(1/ε) | polynomial, but worse |
Two things here are genuinely surprising.
First, the natural engine for √2 lands squarely on the information-theoretic floor. The simplest, most naïve construction for an algebraic irrational is already optimal; you cannot do better, and you did not need to be clever to get there.
Second — and this is the part I find delightful — the Wallis product and the Gregory–Leibniz series need roughly the same number of steps, yet Wallis is meaningfully more expensive in bits. It quietly hauls around a heavier and heavier denominator. Classical convergence analysis, which counts only steps, cannot see this difference at all. The moment you account for the size of the fraction being produced, it snaps into focus. That is the whole pitch for the framework in a single example: it surfaces a real, load-bearing distinction that the standard tools render invisible.
A word of honest caution, because the essay itself is careful about this. It is tempting to conclude "π is harder than √2, full stop." That overstates the case. The framework classifies engines, not constants in some absolute sense; sophisticated algorithms (the arithmetic–geometric mean, Ramanujan-style series) can compute π at the same optimal cost as √2. What the framework genuinely establishes is narrower and sharper: among the natural, series-shaped engines — the ones whose consecutive terms have a clean rational ratio, a decidable property the framework calls hypergeometric — algebraic irrationals reach the optimum while the classical π-series do not. That is weaker than a metaphysical verdict about π, but far stronger than "some series for π is slow."
A framework that produces measurable curves invites a natural companion: a script that actually runs the factories, records what they produce, and checks the hand-derived predictions against real data. The interface here is not buttons and windows; it is a reporting contract — a structured verdict table that the experiment emits.
Think of it as an instrument panel rather than an application. For each engine, the tool reports a single honest row:
- the engine's name,
- whether it is hypergeometric (yes/no),
- the measured step-count class,
- the measured bit-length class,
- the predicted complexity tier, and
- an agreement verdict — does the data match the theory?
The design philosophy is worth stating plainly, because it is unusual: disagreement is the interesting output. Where measured cost diverges from predicted cost, the tool does not paper over it — it flags it as the headline. A discrepancy is treated as informative rather than embarrassing; it points either to hidden structure in the constant or to a gap in the analysis. The experiment is built to be falsifiable, and the report is where that falsifiability lives.
Underneath, a few principles keep the instrument trustworthy:
- Exact arithmetic on the certificate path. No floating point is allowed anywhere near the fractions themselves; approximation is the thing being measured, so it must never sneak into the measurement. Floats appear only at the very end, for fitting curves.
- A single, auditable definition of "bits." Everything routes through one function so the metric cannot quietly drift.
- A tolerance ladder. The tool sweeps ε across a geometric range (a tenth, a hundredth, a thousandth, …) and records the cost at each rung, producing the curve rather than a single anecdote.
- An asymptotic fitter as judge. Given the measured points, it asks which growth law — logarithmic, polynomial, or worse — best explains the data, and that fit is the verdict.
The output is also exported as plain, machine-readable tables (CSV/JSON), so the stratified constants can serve as a benchmark suite for other numerical algorithms down the line.
A few reasons this holds up beyond novelty:
- It makes an abstract argument measurable. The separation between "easy" algebraic numbers and "hard" transcendental ones is usually argued in the abstract. Here it becomes a curve you can plot, fit, and check.
- It rewards a metric everyone overlooks. Bit-length — the actual cost of storing, sending, and computing with a fraction — turns out to be the discriminating variable. The Wallis-versus-Leibniz surprise is the proof of concept.
- It stays honest about its own limits. The framework openly acknowledges that one of its key steps leans on deep number theory (the Prime Number Theorem), and that it classifies engines rather than constants. It trades metaphysical ambition for operational precision — and says so.
- It reframes an old philosophical worry. Rather than resting the whole edifice on the uncountable continuum of "all real numbers," it treats a number, for its own purposes, as an engine together with its cost profile. That is a modest, computational stance, and the project is refreshingly candid that it relocates rather than eliminates the deeper questions.
- The mathematically curious reader who has met π and √2 and wondered, in a way that never quite resolved, whether one is "really" harder than the other. This gives you a precise, defensible answer — along with an honest account of what that answer does and does not settle.
- Students and educators. The gap between "how fast does it converge?" and "how big are the numbers?" is a beautiful teaching moment, and the Wallis product makes it concrete.
- Numerical algorithm builders. Constants sorted by certificate cost form a ready-made benchmark: if your PSLQ, lattice-reduction, or continued-fraction method beats the predicted difficulty, you have found either hidden structure or a genuinely clever method. Either way, that is a result.
- Philosophers of mathematics and computation, who will find the framework's central claim — that a "number" can be treated as an engine plus its cost — a clean, stress-tested case study in what is gained and lost by trading ontology for operation.
The structure of the series is the structure of the cost. That is the whole thesis, and it
is more literal than it sounds: the way a factory is built determines, precisely and
measurably, how expensive its output is to write down. Some constants come with cheap,
optimal factories built right in. Others, under their most natural machinery, do not — and
the bill comes due in bits.
For a single, vivid instance of a factory that lands squarely in the optimal
(logarithmic) tier, see the companion essay The Simplest Increment, which analyzes the
startlingly compact cubic-convergence engine x → x + sin(x) for π. And for the broader
story of where constants like π come from in the first place — the ladder of number
systems that forces each new constant into existence — see The Extension Ladder.
It is a small, sharp idea, and I find it more satisfying the longer I sit with it. Enjoy the tour, and if you come away arguing with one of the verdicts in that table — good. The framework was built to be argued with.