How Can √2 Be Exact If Its Decimal Never Ends?
Last updated on

How Can √2 Be Exact If Its Decimal Never Ends?

By Aditya Karnam (assisted writing by Claude and Codex)

Key Takeaways

  • A geometric length can be exact even when its decimal expansion is infinite — those are two different properties.
  • √2 is completely pinned down by a finite relationship (x² = 2, x > 0), not by how many digits you can write.
  • Formal constructions of the real numbers (Cauchy sequences) define a number as the thing an infinite approximation process converges to — not as a stored infinite string.
  • Most real numbers are far stranger than √2: there are provably more of them than there are finite strings in any fixed language to name them with.
  • The split has a name: extensional representations enumerate an object’s contents, intensional ones specify it by a rule. The intensional version is usually the smaller and more useful object.
  • AI systems face the same choice constantly, and often make it badly — collapsing an exact expression into a float, or a distribution into a single guess, before anything required it.

Draw a square with sides of length 1. Draw its diagonal. By the Pythagorean theorem, that diagonal has length √2 — and √2’s decimal expansion never terminates:

√2 = 1.41421356237309504880...

forever, without repeating.

So here’s the puzzle: if you can never finish writing the number, how does the diagonal manage to stop at a definite point? A drawn line segment looks completely finished. Its decimal description looks permanently unfinished. That discomfort is worth sitting with rather than resolving quickly. Try it below — the segment draws instantly, long before anyone could type out even a fraction of its digits.

1 1 √2

Hypotenuse = √2 — an exact, finite description.

Is the Decimal the Number, or Just One Way to Write It?

The resolution starts with a distinction that’s easy to skip past: a decimal expansion is an encoding, not the number itself. Compare it to something more familiar. 1/3 and 0.333333... name exactly the same object, and nobody feels uneasy that the second notation never ends — the fraction already told us everything, cleanly and finitely. The endlessness belongs to one particular way of writing the number down, not to the number.

√2 works the same way. It is a complete, finite description of a number whose decimal representation happens to be infinite. When you draw the diagonal from (0,0) to (1,1), you don’t need a single digit of 1.41421356… to know exactly where that segment ends. The geometry defines the length directly:

d² = 1² + 1² = 2

That’s the whole answer, and nothing about it is unfinished.

There’s a standard name for the two things being conflated here. Listing an object’s contents — 1.41421356... — is an extensional representation. Specifying it by a rule that picks the object out uniquely — x² = 2, x > 0 — is an intensional one. Both name the same number. Only one of them can be finished. Nearly everything that follows in this essay is a consequence of that single fact: the intensional description can be finite even when the extensional one never terminates, which means “exact” and “expressible in finitely many digits” are two different properties that most of us learned to treat as one.

Where Exactly Is √2, If We Refuse to Accept the Symbol?

Suppose you doubt the symbol rather than accept it — you want to know where √2 actually sits on the number line, not just what defines it. You can trap it between shrinking bounds:

1      < √2 < 2
1.4    < √2 < 1.5
1.41   < √2 < 1.42
1.414  < √2 < 1.415
1.4142 < √2 < 1.4143

Each interval is smaller than the last, and √2 stays inside every one of them. There’s no final step where you land exactly on it — the process of narrowing is what identifies the point.

1 < √2 < 2

Every click shrinks the interval. There's no final click that lands exactly on √2 — the sequence of interval endpoints is what defines the point.

This isn’t just a rhetorical trick. One standard formal construction of the real numbers — Cauchy sequences — builds numbers exactly this way. The sequence 1, 1.4, 1.41, 1.414, 1.4142, ... converges to a single, unique real number. That limit is √2. A real number, in this framing, isn’t an infinitely long string sitting in storage somewhere — it’s the unique target that an endless sequence of better approximations converges toward.

The Discovery That Broke Ancient Mathematics

If you restrict yourself to fractions — ratios of whole numbers — the diagonal of a unit square has no representation at all. There is no pair of integers a, b such that (a/b)² = 2. The proof is short and was devastating when discovered: geometry produces a length that the number system of the time simply could not name.

That’s the real content of the “discovery of irrational numbers”. The diagonal didn’t fail to exist — the representation system (fractions) was too small for it. Mathematics had to expand from the rationals (ℚ) to the reals (ℝ) to catch up with what geometry was already showing.

It’s a pattern worth remembering, because it recurs constantly: a system runs into an object it structurally cannot describe, and the fix is never “the object must be wrong” — it’s “the system needs to get bigger.”

Does a Physical Ruler Ever Actually Measure Infinitely Many Digits?

Not necessarily — and this is where the math and the physics genuinely part ways.

Mathematically, the diagonal is exactly √2, full stop. But build an actual square out of wood or metal, and a measurement gives you something like:

1.41421356 m ± 0.00000001 m

Every real instrument has finite precision. Materials expand and contract, atoms jitter, and at small enough scales quantum effects take over. No experiment has ever produced, or could produce, an infinite decimal expansion of a physical length. Real numbers with infinitely many meaningful digits look like a feature of the mathematical model we use for space — not necessarily something the physical world is required to store. Whether physical space is truly continuous down to arbitrary precision remains an open question in physics, not something a triangle can settle on its own.

Is √2 as Strange as Irrational Numbers Get?

Actually, √2 is one of the easy cases. You can specify it completely in two characters — √2 — and a simple algorithm can grind out as many of its digits as you want, on demand. Numbers like this — √2, π, e — are called computable numbers: infinite decimal expansion, finite generating description. Alan Turing formalized exactly this distinction in the paper that founded computer science — a real number is “computable” if a Turing machine can produce an arbitrarily precise approximation to it, no matter how many digits are requested.

But computable numbers are a tiny, tame corner of the real number line. There are only countably many possible finite computer programs or formulas — you can list them 1, 2, 3… There are uncountably many real numbers, a strictly larger kind of infinity. So for any one fixed formal language — any fixed set of formulas, any fixed programming language — only countably many reals can be named in it, while the reals themselves are uncountable. Almost every real number falls outside what that particular language can express, and the same counting argument applied to programs specifically is exactly why almost every real number is uncomputable. Most of the number line can’t be pinned down by any single fixed system of description — not because no one has looked hard enough, but because there are provably more reals than there are finite strings to name them with.

Against that backdrop, √2’s “problem” — an infinite decimal — starts to look almost trivial. It compresses perfectly into x² = 2, x > 0. Most real numbers don’t compress into anything at all.

Two Ways to Store a Number in a Computer

A standard floating-point number can’t store √2 exactly — it stores a truncated stand-in like 1.4142135623730951 and loses precision the moment it’s written down.

A symbolic system doesn’t have that problem. It can hold sqrt(2) as an exact object and reason directly from the relationship that defines it — (sqrt(2))² = 2 — without ever expanding a single decimal digit. If you later need ten digits of precision, or a thousand, you compute them on demand. The exactness was never at risk; only the moment of approximation moved to when it actually mattered. This isn’t just a thought experiment — it’s an active area of computer science called exact real arithmetic, where numbers are represented as procedures that can produce an approximation to any requested precision. Some systems in this area go further, with algorithms and correctness proofs that bound the resulting error and pin down exactly when an earlier approximation is mathematically forced to be recomputed — rather than redoing everything from scratch by default.

Floating-point decimalSymbolic / exact representation
Stores1.4142135623730951sqrt(2), with x² = 2, x > 0
PrecisionFixed and truncated at write-timeArbitrary, generated on demand
x² = 2?Approximately (≈ 2.0000000000000004)Exactly, by definition
CostCheap, but precision is spent whether needed or notSlightly more overhead, only when a decimal is actually required

This is the extensional/intensional split again, now with an engineering consequence attached: the right representation for an exact quantity is often not “more decimal places” but a change of kind — a constraint instead of a string of digits. A circle isn’t an endless enumeration of points; it’s x² + y² = r². A line isn’t a list of coordinates; it’s y = mx + b. A sequence isn’t 2, 4, 6, 8, ...; it’s a_n = 2n. And √2 isn’t an unfinished decimal — it’s the unique positive number whose square is 2. The definition already finished. The decimal was just never going to.

Does an LLM Have to “Know” All 1.4142135623… to Reason About √2?

No — and there’s a real structural parallel to how language models work, though it turns out to be narrower than it first looks.

An LLM never needs to internally expand √2 into its infinite decimal to reason about it. What it processes is a finite token sequence — sqrt(2) — and its learned representations can support associations and transformations involving properties like irrationality, the Pythagorean theorem, and numerical approximation, without any of those properties ever being enumerated. Ask it about the hypotenuse of a right triangle with legs of 1, and nothing requires it to recall a stored decimal; it can produce √2 directly and only descend to 1.414 if the question calls for a decimal. It would overstate the evidence to say it “activates the Pythagorean relationship” as some discrete object sitting in the weights — nobody has shown that. What interpretability research has shown is more specific, and still striking: probing models in the Llama family turned up linear, geometric representations of space and time and, in related work, of whether a statement is true or false — structured enough that researchers can locate the direction in the activations corresponding to one of these properties and causally flip it. That’s evidence for structured latent representations of some semantic variables — not a general claim that every concept, √2 included, sits inside the model as a tidy symbolic node.

Language Runs on the Same Economy

Whatever is happening in there, it’s plainly not enumeration — and that’s not unique to math. The sentence “John dropped the glass” never states that gravity exists, that the glass accelerates downward, that it might shatter, that John was holding it a moment earlier. You reconstruct all of it from five words. Language runs on the same economy the diagonal does: a small finite cue, unfolded on demand into something far larger than itself.

A formal result sits next to this one. Prediction and compression are mathematically equivalent, and Delétang et al. show large language models act as strong general-purpose compressors even across modalities they were never trained on — Chinchilla 70B squeezes ImageNet patches to 43.4% of their raw size and audio to 16.4%, beating PNG and FLAC at their own job. That equivalence is proven. Whether it reaches all the way down to concepts — whether a model compresses the idea of √2 the way it compresses a pixel array — is a different and much softer question, and the compression result alone doesn’t settle it.

Where the Analogy Breaks

There’s an important limit to the analogy, though. A symbolic math system that holds x = √2 gets guaranteed exact semantics — x² = 2 is true by definition, permanently. An LLM’s internal representation is ultimately finite-precision floating-point tensors shaped by training, not a mathematical guarantee. It can recognize that (√2)^1000 = 2^500, but nothing forces it to; it might just as easily make an arithmetic slip. The model’s “√2” is a learned association that tends to produce the right behavior — not an object with an enforced contract the way x² = 2 is in a symbolic system. This is measurable, not just theoretical: tested on symbolic tasks like arithmetic and modular counting, LLM accuracy declines as the number of symbols involved grows, which is exactly the signature of pattern-matching rather than executing a fixed formal rule.

This cuts both ways for how we build AI systems, and it’s the same problem agentic AI evaluation keeps running into at a larger scale: an agent can produce the right-looking output while the underlying representation has already quietly lost the information that made it reliable. The failure mode here is collapsing an exact or structured representation into a lossy one too early — the model reasons its way to d = √2, and the surrounding code immediately casts it to 1.4142135623730951, so d * d comes back “close to 2” instead of provably equal to 2.

What Does This Mean for How We Should Design AI Systems?

A more careful design keeps the exact expression and its constraints around as long as possible and only generates a decimal, with an explicit precision, at the moment something actually needs one — which is exactly the split that current neuro-symbolic systems are built around: let the model produce the structure, then hand it to something deterministic to execute. Program-aided language models generate a program instead of an answer and let a Python interpreter run it, beating pure chain-of-thought reasoning by 15 absolute points on grade-school math problems even with a much smaller model. Faithful chain-of-thought splits the same way — natural language into a symbolic reasoning chain, then a deterministic solver — with relative accuracy gains from 3.4% on planning tasks up to 21.4% on relational inference. In both cases, the win doesn’t come from a bigger model — it comes from not asking the neural network to be the calculator once the structure is already in hand.

The same principle scales past numbers: an agent that thinks “Alice is probably in Chicago” loses less by keeping the probability and the competing alternatives attached than by collapsing straight to location = Chicago. There’s early evidence that reasoning itself may not need to pass through language tokens at all to preserve options this way — recent work on “continuous thought” feeds a model’s hidden state back into itself instead of decoding every reasoning step into words, letting a single latent step hold multiple possible next moves at once instead of committing early to one word or one path.

Three Levels, Not Two

It’s worth being precise about what that buys you, though, because it’s a different, weaker kind of “not collapsing yet” than the √2 case. There are really three levels here, not two: symbolic exactness (√2, x² = 2), where a claim is true by definition and stays true forever; latent representation, which can be rich and hold multiple branches at once but carries no formal guarantee about what it means; and materialized output (1.414, a word, an action), where one specific choice finally gets made. Continuous-thought reasoning preserves the second kind of richness, not the first kind of exactness. It’s a genuine instance of the same underlying move — defer the commitment — but “exact” and “structured-but-unguaranteed” are different things, and only the first survives contact with a hard case unchanged. In every case here, the fix isn’t storing more information. It’s declining to convert the exact or structured thing into an approximation before something actually asks you to.

Diagram showing a triangle and a constraint feeding a precision-on-demand output, mirrored by a neural graph and a latent structure feeding a decoded output, both converging on the same idea of deferring approximation until needed

Both paths defer the same decision — hold the exact structure as long as possible, and materialize an approximation only at the point something actually demands one.

Further Reading

More essays at Call to Think · About this project