How Proof Assistants Are Transforming Mathematics

Software assistants are now entering mathematics’ most sacred domain.

What was once solitary intellectual work in quiet offices is rapidly becoming a global collaborative undertaking involving leading researchers and computers. Specialist programs inspect mathematical proofs line by line, uncovering mistakes long after people might have given up, and making manageable problems that were previously considered virtually impossible to verify.

How computers are entering mathematics’ sacred territory

Since Archimedes, mathematics has broadly followed the same routine: someone discovers an idea, writes a proof and sends it to peers, who then spend months working through pages of symbols in the hope of not missing a flaw in the reasoning. This process was regarded as the gold standard - slow, laborious, yet without an alternative.

This is precisely where the latest generation of so-called “proof assistants” comes in: software that checks every individual logical step in a proof. Tools in this category include Lean, Coq and Isabelle. They operate like an exceptionally fussy proofreader: no transition, shortcut or “that is obvious” is allowed to pass without scrutiny.

The heart of the revolution: the computer accepts only what can be broken down completely into rigorous logic - without trust or intuition.

Mathematicians must render their proof in a formal language that the program can interpret. The outcome is code in which every step is set out explicitly. It is this very radical approach that prevents familiar human oversights: omitted arguments, unstated assumptions, or minor yet fatal calculation errors.

The Scholze case: when even a superstar prefers verification

A pivotal moment for the field came from Germany. Bonn mathematician Peter Scholze, a Fields Medal recipient, had published a highly complex theorem concerning so-called condensed spaces. His proof ran to hundreds of pages and was so abstract that only a very small group of specialists could read it at all.

Scholze was not entirely certain about it himself. His concern was that a small but decisive gap could be hidden somewhere in the enormous chain of reasoning. Rather than asking further reviewers to undertake years of manual work, he launched an experiment at the end of 2020: the “Liquid Tensor Experiment”.

The proposal was straightforward: anyone able to use Lean should translate parts of his proof into the formal language. Mathematicians and computer scientists around the world joined in, divided the work between them and had Lean check every building block. The result was enormous code comprising around 180,000 lines.

After half a year, the team announced completion: the machine had accepted the full proof. There was no logical gap and no contradiction. For Scholze, this delivered a degree of certainty that even the most meticulous human review could not provide. His discipline also realised that a tradition thousands of years old was beginning to shift.

From lone researcher to global construction site

Projects of this kind are transforming the way mathematicians work. Where a small number of specialists once refined a result, dozens of researchers can now divide a proof into numerous smaller sub-problems. Each person formalises their section, while the software assembles them into one complete structure.

Programs such as Lean also provide a form of live checking: as someone works on a lemma, the system immediately indicates whether the argument stands up. Errors no longer emerge only months later in a review; they appear while the proof is being typed.

• Researchers across the world can work on the same theorem in parallel.
• Software checks every step immediately.
• Contributions can be reused as modular building blocks.
• Early-career researchers can take part in major projects from an early stage.

A pursuit often carried out in isolation is therefore becoming something akin to an open-source project for proofs.

How software makes “impossible” projects achievable

Another high-profile example is the work of mathematician Maryna Viazovska. She solved a longstanding problem on the densest packing of spheres in eight-dimensional and subsequently 24-dimensional space - a higher-dimensional version of the question of how to stack oranges most efficiently. Her solution earned her the Fields Medal in 2022.

There was, however, a difficulty: the proof was so compact and technical that many specialists regarded a full manual check as a nightmare. An international group of experts therefore decided to express the entire proof in Lean. The project took months, and the completed code was published online in 2024.

This now provides a formal confirmation that leaves no room for interpretation: Lean would have halted immediately at any imprecision. Such efforts demonstrate just how strongly mathematics is changing:

Proofs once regarded as “too long” or “too opaque” are suddenly verifiable through automation - not despite their complexity, but because of it.

A key piece of this puzzle is Mathlib, Lean’s large standard library. It now contains more than 1.2 million lines of formalised mathematics: definitions, theorems and proven supporting results. Anyone beginning a new project today can build on this material rather than coding every detail anew from first principles.

From toolkit to infrastructure

This library acts as a long-term multiplier:

• Every project expands the shared body of work.
• New proofs can directly use established building blocks.
• Standard arguments remain consistent and verifiable.
• Errors in the foundations would affect entire areas immediately - and would therefore be detected quickly.

This is creating resilient infrastructure comparable to established software frameworks in IT. The subject here, however, is not web apps but the foundations of pure mathematics.

When the machine corrects prize-winning proofs

Proof assistants are not merely confirmation tools; they can also serve as uncompromising editors. In one case in 2021, a team took an already award-winning theorem and formalised it in Lean. Partway through the process, the system stopped: a central intermediate statement could not be proven as it had been written.

The researchers had to revise the work, make one step more precise and correct their reasoning. Human reviewers had previously missed the error. There was no ill intent involved, merely human limitation. Beyond a certain level of abstraction, nobody can keep every implication in their head.

A computer, by contrast, knows neither fatigue nor routine nor deference to famous names. Either the logic works, or it does not.

New barriers to entry, new support

For a long time, even mathematicians viewed these tools as nerdy toys for computer scientists. The learning curve was steep and the syntax unfamiliar. That is now changing quickly. More user-friendly interfaces and integrated AI modules are providing greater guidance.

Language models translate handwritten sketches or LaTeX formulations into formal Lean code, suggest suitable theorems from Mathlib and complete routine passages semi-automatically. This significantly lowers the barrier to entry for traditional theorists.

The roles are shifting: people provide ideas, strategies and intuition - the machine monitors the logic without mercy.

For the next generation of students, it could become normal to write proofs not only in chalk on a blackboard but also to formalise them simultaneously in Lean or Coq.

What this development means for the future of mathematics

Close collaboration with software is changing the discipline’s self-image. When a computer accepts a proof, the theorem rests on firmer ground than much of what has previously passed through human review. This could alter priorities: instead of devoting countless hours to manually checking details, researchers can invest more energy in fresh ideas and strategies.

At the same time, new questions arise: how much trust should we place in the code of proof assistants themselves? Who checks the programs that check our proofs? This is where a second level of formalisation comes into play: the core logic of these systems can also be verified in other tools to prevent errors in the foundations.

Potential applications beyond pure theory are also compelling. Correctly verified mathematics underpins cryptography, protocol security and the stability of complex algorithms. When a proof assistant confirms a security proof, it may have direct consequences for encryption methods or the reliability of industrial software.

Much is still under construction, but the direction is clear: mathematics is becoming a shared stage for people and machines. Creative flashes of insight will continue to come from researchers of flesh and blood. The painstaking, gap-free checking will increasingly be handled by computers. Together, the two could make possible theorems so extensive and intricate that no human mind could ever fully grasp them alone.