What OpenAI's Erdős result actually proves — and what "Lean-verified" means

A general-purpose OpenAI reasoning model has disproved a conjecture that Paul Erdős posed in 1946 and that nobody has been able to settle in the eighty years since.¹ That sentence is doing a lot of work, and most of the coverage I've read has skipped the parts that make it interesting. So I want to walk through three things: what the conjecture actually says, what "the model disproved it" means in practice, and why the phrase "Lean-verified" is the load-bearing word in the whole story.

The conjecture, in plain words

Put n points down on a flat piece of paper, wherever you like. Now count the pairs of points that happen to be exactly 1 unit apart. Call that number u(n). The question Erdős asked is: how large can u(n) get, as a function of n?

It's harder than it sounds. If you put your points in a regular grid, lots of pairs are exactly 1 apart, but lots aren't. If you put them in a circle, you get a different count. If you cluster them cleverly using algebraic structure (a lattice tuned to produce unit distances), you can do much better than naive arrangements.

Erdős conjectured that u(n) grows only slightly faster than linearly. Specifically: for any small ε you pick, u(n) eventually stays below n^(1+ε). So a little above n, but nothing like n².

The new result says: no, you can do better than that. There exist point configurations with more unit-distance pairs than Erdős's bound allows. The conjecture is false.¹

This is how a lot of combinatorial geometry works. The headline result is rarely "we found the answer". It's "we narrowed the gap between what's possible and what was thought possible". Eighty years of mathematicians had narrowed that gap from above and below; the new result moves the lower bound past where Erdős said it could go.

What the model actually did

Here's the part that matters for understanding the achievement, and where the research brief I'm working from is genuinely informative.

The proof uses tools from algebraic number theory — roughly, the study of numbers that arise as roots of polynomial equations with integer coefficients, and the structure of the systems those numbers live in. This is a non-obvious angle for a geometry problem. The naive instinct, looking at "how many pairs of points are 1 apart", is to reach for combinatorics (count things), or probability (estimate things), or analytic geometry (compute things with coordinates). Reaching for algebraic number theory means noticing that point configurations with lots of unit distances tend to have hidden algebraic structure, the coordinates satisfy polynomial relations, and exploiting that structure.¹

I find this the most interesting technical detail in the announcement, because it tells you something about what the model was doing. It wasn't pattern-matching its way to a known proof template. It selected a tool from a sub-field of mathematics that isn't where most people would have looked first. Whether that selection was creative reasoning or sophisticated retrieval from training data is a real question, and I'll come back to it, but the choice of weapon is itself informative.

The other key fact: this is a general-purpose reasoning model, not a system built for mathematics. Prior AI math milestones were specialist: DeepMind's AlphaGeometry was trained on synthetic geometry problems; AlphaProof was fine-tuned to write proofs in the Lean proof assistant. Those systems were engineered, end-to-end, for mathematical work. The OpenAI model here is the same architecture that answers your emails and writes your code.¹

That distinction matters because it changes what the result implies. A specialist system proving things tells you the specialist system was well-built. A general-purpose system proving things tells you that general-purpose reasoning, at sufficient scale, contains mathematical reasoning as a capability — not as a feature someone added, but as something that emerged.

"Lean-verified" — the phrase that does the work

Here is where I want to slow down, because most coverage treats "the proof was verified" as a throwaway line, and it isn't.

When a human mathematician proves something, the proof goes through a trust hierarchy. The mathematician's own intuition comes first. Then it's written up informally — equations, prose, "it is easy to see that…", appeals to standard results. Then it goes to peer review, where one or two referees read it and try to find mistakes. If they don't find any, it gets published. That's the system, and it works most of the time. But errors slip through. Important results have been wrong for years before someone noticed.

Lean is different. Lean is what's called a proof assistant: a programming language whose programs are proofs. You write the mathematical argument as typed code. The Lean kernel, a small and heavily-scrutinised piece of software, then checks every single inference step against a fixed set of logical axioms. If even one step doesn't follow from the previous ones by a permitted rule, Lean rejects the proof. There is no hand-waving. There is no "it is easy to see". Every gap has to be filled in.

This means a Lean-verified proof has a categorically stronger trust property than a peer-reviewed one. A human referee might miss a subtle error. Lean cannot, because Lean is not reading the proof — it's executing it.

That's how long Erdős's conjecture stood. And it's the gap that the combination of general-purpose model and Lean verification has now closed.

The Lean kernel doesn't care who wrote the proof.

That sentence is the whole reason this result is different from the long string of AI math claims that have come before. When AlphaProof produced contested results, the dispute was about whether the proof was actually complete, whether gaps had been papered over. When a proof is Lean-verified, that dispute can't happen. Either Lean accepts the code or it doesn't. The model can be a stochastic autocomplete, can be a "true reasoner", can be anything you want it to be metaphysically — and it doesn't matter, because the kernel checked the work.

Where the metaphor breaks

I've been talking about Lean as if it eliminates all doubt. It nearly does, but not quite, and a smart reader should know where the remaining doubt lives.

The Lean encoding itself is human work. Someone — possibly the model, possibly a human collaborator translating the model's argument — wrote the Lean code that the kernel checked. If that encoding contains a subtle mismatch between the informal claim and the formal statement (for example, the Lean statement is slightly weaker than the conjecture it's claiming to disprove), the kernel will happily verify it and the disproof won't actually disprove the thing people think it disproves.² This is a real failure mode in formal verification, and it's the question worth asking about this result: was the Lean statement of the conjecture audited as faithfully matching what Erdős posed?

Lean trusts its own kernel and axioms. The kernel is small and has been examined for decades. The axioms are the standard foundations of mathematics. Both are about as trustworthy as anything in mathematics gets. But "Lean-verified" is "verified relative to the Lean kernel and its axioms", not "verified in some absolute sense that exists outside human-made systems".

These are quibbles, not refutations. Lean verification is the strongest correctness signal we have for AI-generated mathematics, and this result has it. But the trust does not become infinite just because a machine checked it.

Why this matters

If you take only one thing from this: the bar for AI mathematical claims has just been raised, and it has been raised by the verification methodology more than by the result itself.

Before this, a reasonable position was: AI systems can produce mathematical-looking text, but you can't trust it without a careful human checking every step. That position is now harder to hold for any future claim that arrives with a Lean proof attached. The methodology, general-purpose model produces argument, formal proof assistant verifies it, sidesteps the entire "is the model really reasoning" debate, because the kernel is doing the reasoning-check on the model's behalf.

What I'd watch from here: how often this combination shows up. One verified disproof of an 80-year-old conjecture is a milestone. Ten of them, across different sub-fields, in the next eighteen months, is a phase change.

Footnotes and links

Further reading

• Lean proof assistant — official site
• Mathlib — the community library of Lean-verified mathematics
• Terence Tao on formal verification and AI in mathematics

¶