Imagine an ultra-fast assistant handing you, every evening, a stack of essays that are sound in substance but written in five times too many words, with duplicated paragraphs and needless detours. You would be relieved not to have to write them — and overwhelmed at not being able to read them. This is exactly the situation Terence Tao, Fields medalist and professor at UCLA, describes in a message posted on Mathstodon in late June 2026: artificial intelligence has just crossed a critical threshold in the automatic formalization of mathematical proofs. And crossing it creates as many problems as it solves. A project, a ticket queue, and suddenly nothing left
To understand what happened, we first need to grasp what the IEANTN project is — short for Integrated Explicit Analytic Number Theory Network. As described on the official IPAM page, the goal is to build a living network of estimates in analytic number theory — a field where every numerical constant matters, where a single arithmetic error can render dozens of subsequent bounds unreliable. To this end, Tao and his collaborators are formalizing technical papers in Lean, a proof assistant developed by Leonardo de Moura and Sebastian Ullrich, described in the proceedings of CADE 28 as both a programming language and a logical checker: a Lean proof is not a text you read, it is a program the machine checks mechanically. In practice, Tao would break the proofs down into small independent lemmas, post them as open tasks, and wait for volunteers to claim them. The usual result: several weeks of waiting. According to Tao's personal log on the project's GitHub repository, on 18 June 2026, 22 tasks were still unclaimed. On 21 June: 7. By day 153 of the project, 320 tasks had been completed — and the nature of the bottleneck had shifted. What happened in the meantime? Autoformalization tools — that is, as Yuhuai Wu and his colleagues define them in a Google Research paper, "the process of automatically translating from natural-language mathematics to machine-verifiable formal specifications and proofs" — suddenly shifted into a different regime. Almost every task Tao posts is now handled by AI within hours. The ticket queue emptied out. Human digestion stalled
Except here's the paradox. The proofs generated are correct — Lean accepts them, the checker does not balk. But they are verbose to a degree no human would ever choose. Hundreds of lines more than a mathematician would write. Redundant steps. Lemmas pitched at the wrong level of abstraction.
Tao calls this phenomenon "impedance mismatch" — a term borrowed from electronics, where impedance denotes a circuit's resistance to receiving a signal. Here, the signal is the proof. And the circuit's three stages — generation, verification, digestion — no longer run at the same speed. AI has accelerated generation by several orders of magnitude. Formal verification by Lean remains fast. But human digestion — understanding what the proof does, judging whether it is well structured, deciding whether it deserves a place in Mathlib, the large community library of formalized mathematics — that digestion has not sped up one bit. Each verbose proof adds tens of seconds to the project's overall compilation time. Multiply that by hundreds of lemmas, and the cumulative effect becomes a genuine engineering problem.
What AI cannot do alone
Tao has identified a sharp boundary. AI excels at what is called local code golf — compressing an existing proof, eliminating superfluous steps at the scale of a single lemma. But global restructuring escapes it entirely.
Take a concrete example, documented in the project's log: if the same argument appears in several places in a Lean file, a human mathematician will recognize it, abstract it into a reusable lemma, and check whether that lemma belongs in Mathlib rather than in some isolated corner of the project. AI, for its part, can carry out this restructuring once someone has explained it. It does not discover it on its own. It builds small local libraries — around Laplace inversion, for instance — that are locally correct and globally poorly organized.
This is exactly what the LeanMarathon paper, published on arXiv by Yuanhe Zhang and colleagues, points out: "long-horizon autoformalization fails not only on hard lemmas, but at scale" — through statement drift, dependency entanglement, and local repairs that degrade coherence at a distance. Tao's problem has a name in the literature, and it is systemic. See the reversal? Before, the mathematician waited for proofs to be done. Now, they must anticipate how to frame them so that AI produces something integrable. The bottleneck has shifted from execution to architecture. Tao says so himself: he now spends more time planning the scope of tasks than proving them.
A new profession for mathematicians?
This shift has concrete implications for anyone working with these tools — researchers, master's students, contributors to formalization projects. The rising skill is no longer just knowing how to prove: it is knowing how to break down a problem so that AI outputs are reviewable, modular, and compatible with an existing architecture.
It is as much a library-engineering skill as a mathematical one. Mathlib, as described in the mathlib community's founding paper, grew from 15,000 to 140,000 lines of code in two years, driven by 73 contributors. Integrating a proof into this edifice is not just about making it correct — it is about placing it at the right level of abstraction, with the right interfaces, without duplicating what already exists. AI produces puzzle pieces at a staggering speed. But judging whether the shape of the piece matches the overall picture remains, for now, a human job. Tao presented this project's architecture in a talk at ICERM on 15 May 2026, as part of the "Techniques and Tools for the Formalization of Analysis" program. Less than a month later, the nature of the project had changed. That is the pace at which this field is moving right now.
Key takeaways
- AI can now produce formally correct mathematical proofs in hours where human experts once took weeks — but these proofs are often hundreds of lines longer than necessary.
- A mathematical proof "correct" in the sense of a logical checker can still be bad: if it is poorly structured, it slows down the whole project and cannot be integrated into a shared library.
- The real bottleneck is no longer producing the proofs — it is reading them, understanding them, and deciding how to file them. AI speeds up production; human digestion, meanwhile, stays at a constant rate.
- The mathematician's role is evolving: less an executor of proofs, more an architect — someone who breaks down problems so that AI outputs are usable.
Impedance from the inside: what this threshold actually measures
The term "impedance mismatch" is worth pausing on, since it conceals a precise mathematical structure. In an information-processing system, impedance denotes a component's resistance to receiving or transmitting a flow. When two components have incompatible impedances, energy dissipates at the interface — that is a loss, not a gain.
Applied to proofs, the model works as follows. Let's call G the generation rate (lemmas produced per hour), V the formal verification rate (acceptances by Lean, per hour), and D the human digestion rate (proofs understood and integrated per hour). For decades, G was the limiting factor: humans produced slowly, Lean verified quickly, and digestion kept up without strain. The threshold Tao has crossed corresponds to an abrupt shift: G has been multiplied by several orders of magnitude, V has increased slightly (longer proofs take more time to compile), and D has stayed constant. The bottleneck has shifted from G to D.
This kind of shift is well known in queueing theory — a field of operations research that models flows in systems with limited resources. When one speeds up a stage in a chain, the queue moves to the next stage. This is not partial progress: it is a complete change of regime. The good news is that the system produces more. The bad news is that the optimization now required is entirely different from what it was before.
There is also a combinatorial dimension to the problem of global restructuring. Abstracting a repeated argument into a reusable lemma amounts to solving a factorization problem in a dependency graph: finding a subgraph common to several proofs, naming it, and linking every site where it is used to this new node. This problem — finding the "best" common factor in a graph of proofs — is, in its general form, computationally hard. It is no accident that AI, optimized locally, fails to solve it globally: by construction, it has no representation of the entire graph. This is precisely what the LeanMarathon researchers call "dependency entanglement" — and this is where the human architect remains, for now, irreplaceable.