The number that should arrest your attention is 1.2 million. In three weeks in June 2026, OpenAI's Sol model generated 1.2 million lines of verified Lean 4 proof code — a complete, ground-up formalization of a disproof of Erdős' Unit Distance conjecture, requiring no sorry, no unproven axioms, no borrowed trust. For context: mathlib, the canonical Lean mathematics library, took nine years and hundreds of contributors to reach 2.3 million lines. Sol produced roughly half that — including novel machine-generated arguments in global class field theory, a domain the formalization community considered essentially untouchable as recently as 2025 — in a single sprint.

That is not acceleration. That is a phase transition.

The Erdős Unit Distance conjecture is a classic open problem in discrete geometry: how many unit-distance pairs can a set of n points in the plane achieve? Erdős conjectured in 1946 that the answer grows roughly as n^(1+c/log log n), a nearly linear upper bound. On May 20, 2026, ChatGPT disproved it — leveraging the Golod-Shafarevich theorem, a deep result in algebraic number theory, to construct a counterexample that exceeds the conjectured bound. Within six days, Logical Intelligence had autoformalized the logical chain in Lean 4. Within six weeks, OpenAI researcher Boris Alexeev had produced a complete formalization from first axioms using Sol. The entire arc — discovery, formalization, ground-up machine verification — collapsed into a single pipeline across six weeks.

The State of Formal Mathematics Before This

Lean 4 and its mathematical library mathlib represent the most ambitious human-generated formalization effort in history. As of early 2026, mathlib contained formalized proofs spanning most of undergraduate mathematics and significant portions of graduate-level number theory, algebraic geometry, and combinatorics — 2.3 million lines accumulated by hundreds of contributors over nine years.

Certain domains remained out of reach. Not because they were underexplored, but because the prerequisite infrastructure was simply too vast to construct by human effort on any near-term timeline. Global class field theory — the machinery that classifies abelian extensions of number fields via the idèle class group — was one such domain. Formalizing it would require building hundreds of interconnected definitions and lemmas across algebraic number theory, cohomology, and local-global principles. As of 2025, the formalization community described this as a "fantasy": theoretically possible, practically generations away.

The Erdős Unit Distance problem sat at an intersection of combinatorics and geometry that seemed, on its face, unrelated to such algebraic machinery. Erdős posed it in 1946; it attracted decades of incremental progress on bounds without touching the underlying structural question. The Golod-Shafarevich theorem — a 1960s result about group cohomology and pro-p groups with applications to class field towers — was not on anyone's shortlist of tools for attacking a plane geometry problem. That unexpected connection is what made the ChatGPT disproof genuinely surprising to working mathematicians.

From Disproof to Formalization: The Six-Week Stack

The architecture of what happened matters, because two distinct formalization strategies played out in parallel and their differences are instructive.

Discovery (May 20). ChatGPT identified that the Golod-Shafarevich theorem could be applied to construct a point set exceeding the conjectured unit-distance bound. The full proof of Golod-Shafarevich runs over 100 pages and has no known short proof; it requires genuine engagement with the algebraic structure of class field towers. The mathematical claim verified. Whether the model reasoned through it or pattern-matched across training data is a question the field is actively debating — but the output was correct, and peer-checked.

Autoformalization (May 26). Logical Intelligence — co-founded by Turing Award winner Yann LeCun, with Chief Science Officer and Fields Medallist Mike Freedman — autoformalized the proof in Lean 4 within six days. Their approach was human-in-the-loop: start from existing mathlib infrastructure, bridge gaps with targeted autoformalization, and verify at seam points where the machine-generated code connects to existing library lemmas. This is the correct strategy when the math lies near existing library coverage. The output is auditable at those seams; a domain expert can inspect where bridging occurred and verify the translation is faithful to the informal argument.

Ground-up formalization (June 26). Boris Alexeev used Sol with a different mandate: build from first axioms, without assuming any unproven mathlib infrastructure. The result was 1.2 million lines of Lean 4 in three weeks. A Lean mathlib maintainer who reviewed the output ran it in a sandboxed environment rather than directly — citing genuine concern about malicious Lean executing arbitrary code during elaboration, a risk that is not theoretical when dealing with a machine-generated file of this scale.

Inside 1.2 Million Lines of Machine-Generated Class Field Theory

The structural achievement here is not the geometry. It is the algebra.

Global class field theory is a major organizing theorem of 20th-century mathematics. A complete formalization requires local fields and local class field theory, the theory of adèles and idèles over global fields, L-functions and their analytic properties, the global reciprocity map and its functoriality, and compatibility between local and global invariants. None of this existed in any proof assistant library at production quality. Sol generated arguments for all of it, from axioms, in three weeks.

The proof compiles. No sorry stubs. No axioms beyond the standard foundations. No unsafe imports. By the only criterion Lean's kernel has — does it accept the proof? — the result is correct.

This is where the scale comparison becomes meaningful in a way that goes beyond the impressive statistic. mathlib's 2.3 million lines represent nine years of careful human construction, with proofs written to be readable, maintainable, and integrated with the library's evolving API. Sol's 1.2 million lines are optimized for exactly one property: kernel acceptance. They are not written to be read. They are not organized to be maintained. They are, in the most precise sense, a certificate — a large, opaque artifact that witnesses a true statement and nothing more.

What the Proof Assistant Has Become

The non-obvious disruption here is not to pure mathematics. Mathematicians will continue to debate whether a kernel-verified but humanly incomprehensible proof counts as mathematical understanding. That is a philosophy-of-mathematics argument with a long runway.

The disruption is to the proof assistant community's own epistemic foundation.

Formal verification was built on a specific promise: proofs are checkable by humans at every step. Lean 4's trusted kernel is a few thousand lines of well-audited code — if a proof compiles, it is correct by construction. But "correct" has always bundled two distinct properties: formally valid, and humanly intelligible. A proof you wrote, or that a colleague wrote and you reviewed, was both. Those properties traveled together because human-authored proofs had to be intelligible to be written.

At 1.2 million machine-generated lines, the bundle comes apart. The kernel still guarantees formal validity. Human intelligibility is not degraded — it is gone. No human can read, understand, or reason from 1.2 million lines of machine-generated tactic code on any realistic timeline. What you get is a certificate: you know that the statement is true, but the proof no longer functions as a source of mathematical insight into why it is true.

This matters precisely where formal verification is most valuable. For pure mathematics, certification without comprehension may be acceptable — mathematicians can pursue human proofs that build understanding while the formal certificate provides certainty. But the most ambitious applied project in formal verification is building the foundations that software verification tools depend on. When a formally verified specification underpins a safety-critical system, "why does this property hold?" is not an academic question. A 1.2-million-line machine-generated answer is, in practice, no answer at all.

Lean has, in this context, become a very expensive SAT solver: an oracle that returns true or false with high reliability, but provides no witness you can reason from or act on. The field will need to decide whether that is sufficient — and for what purposes.

What This Means If You Run Lean in Production

If you maintain a Lean-based verification pipeline, the events of the past six weeks have concrete operational implications now.

Sandbox your elaboration environment. Lean 4's #eval, native_decide, and unsafe monad hooks fire during elaboration — before the kernel validates anything. A machine-generated file of this scale is, at check time, an untrusted binary you are executing, not a document you are reading. The mathlib maintainer who first ran Sol's output did so in a sandboxed environment specifically because of this risk. Your CI pipeline should follow suit: network-isolated, filesystem-restricted, with elaboration timeouts set conservatively.

Standard diff and build tooling breaks at this scale. 1.2 million lines of Lean is not diffable by standard tools. Lake's incremental build cache relies on file-level change detection; if a regenerated proof file changes at all — and it will, any time you need to patch it — you rebuild everything downstream. Plan for cold-build times, not incremental ones, and size your CI compute budget accordingly.

Proof maintenance becomes a model dependency. Human-authored proofs have authorial intent recoverable from git history, comments, and the authors themselves. When upstream mathlib API changes break a human-written proof, you patch it. When they break a machine-generated 1.2-million-line proof, selective patching is not possible — you must regenerate, which means Sol (or a successor) must be available, accessible, and produce reproducible output. Sol is a closed model. OpenAI can deprecate it. Build your dependency model accordingly and treat the generative model as a critical infrastructure component, not a one-time tool.

Budget 10x elaboration time in CI. Human tactic proofs are typically written to elaborate quickly, following patterns the elaborator handles efficiently. Machine-generated proofs optimized for kernel acceptance — not readability, not elaboration speed — may use term-mode constructions that are expensive to type-check. Profile elaboration time in a staging environment before committing to any pipeline that includes machine-generated proofs at this scale.

Audit the formalization statement, not just the compilation. A machine-generated proof can correctly verify a Lean statement that subtly mistranslates the informal conjecture. The kernel guarantees internal consistency, not semantic faithfulness to the mathematical claim you intended to capture. For the Erdős conjecture, a domain expert must verify that the Lean statement actually captures what Erdős meant — and that check cannot be delegated to tooling. It is the most important audit, and the one most likely to be skipped.

The Bottleneck Has Moved

The Erdős Unit Distance conjecture stood for 80 years. It fell to an AI in a day. The formalization of that disproof — including novel machine-generated proofs of global class field theory — took six weeks of combined human and model effort, producing 1.2 million lines of verified Lean 4 code. mathlib needed nine years and hundreds of contributors to build 2.3 million.

The bottleneck in formal mathematics is no longer expert human time writing tactic proofs. It is compute, prompt engineering, and epistemic clarity about what we want a proof to do. If the goal is certification — that a statement is true, verifiable by a trusted kernel, with no further obligation to explain itself — AI-generated formalization at scale is here, it works, and it will only accelerate. If the goal is mathematical knowledge — proofs as arguments that illuminate structure and transfer understanding to human minds — the 1.2-million-line opaque certificate does not deliver it.

That distinction will define the next decade of formal verification research and applied proof engineering. It is not a reason to wait. It is a reason to be precise, now, about which goal you are actually building toward.

Sources & Editorial Disclosure

This article was researched and written with AI assistance (Claude by Anthropic) as part of StackRadar's automated editorial pipeline. Content was synthesised from the following public developer community sources: Lobste.rs · ArXiv CS · Dev.to.

All technical claims, version numbers, benchmarks, and project details should be independently verified against official documentation or the original sources listed above. StackRadar analyses and synthesises publicly available information and does not claim original authorship of the underlying events, projects, or research described. Mention of any project, product, or organisation does not constitute an endorsement by StackRadar. This content is provided for informational purposes only — 2026-07-21.