Can AI Produce Trustworthy Mathematics? By 2030, Major AI Proofs Will Pass Through Formal Engines

01 — The breakthrough is a chain of specialists.

Ask a general language model to prove an unfamiliar theorem and it faces an almost comic number of choices. Which field contains the right tool? Which paper introduced it? Which version of a lemma matches the hypotheses? Is the attractive intermediate claim even true? A fluent answer can hide one false step because natural language has no compiler.

A formal prover faces the opposite problem. It sees an exact target and an exact local environment, but it may lack the broad mathematical taste needed to choose a useful route. It can spend thousands of attempts applying impeccable tactics to an unpromising idea.

The 2030 system will divide the labour:

The explorer. restates the question, tests examples, proposes constructions and connects distant fields. This will usually be a general foundation model because breadth is the source of mathematical surprise. The librarian. retrieves definitions, theorems and proof patterns from papers and formal libraries. It prevents the explorer from rebuilding a century of mathematics from memory. The translator. converts the claim and its dependencies into a formal language. It turns phrases such as sufficiently large or almost everywhere into explicit quantifiers and conditions. The prover. generates tactics or complete proof terms, branches into subgoals and uses compiler feedback to repair failures. This model will be fine-tuned heavily on formal mathematics. The kernel. checks the completed proof term from declared axioms. It does not estimate whether the argument sounds right. It computes whether the object is a proof.

The chain is already visible in research. The Rethlas–Archon system gives informal exploration to one agent, theorem search to Matlas and Lean formalisation to another agent. Its authors report that the combination resolved an open commutative-algebra problem and produced a machine-checkable Lean project. The important result is the architecture: retrieval found cross-domain tools, the language model assembled an argument and the formal agent exposed and filled gaps. Automated Conjecture Resolution with Formal Verification

This is how AI mathematics escapes the chatbot. It becomes a laboratory in which imagination can be reckless because verification is merciless. A false route costs compute. It does not become a theorem.

02 — General models will supply the leap.

The most interesting mathematical move is often a change of language. A geometry problem becomes number theory. A question about groups becomes an operator-algebra problem. A difficult inequality becomes a statement about probability. A model trained only on Lean tactics can become exceptionally good at finishing the local proof while missing the distant analogy that makes the proof possible.

That is why the front of the pipeline will remain general. OpenAI reported in May 2026 that an internal general-purpose reasoning model overturned the expected growth rate in the planar unit-distance problem. The model replaced the familiar Gaussian-integer construction with more complicated number fields and used class-field towers and Golod–Shafarevich theory. It imported a deep number-theoretic machine into a deceptively elementary geometric question. External mathematicians then checked and contextualised the result. The unit-distance disproof and companion material

In August, OpenAI presented ten more results across sphere packing, coding theory, group theory, operator algebras, circuit complexity, quantum games, lattice problems and Ramsey theory. The company says the arguments came from an internal version of its general model Astra, after which humans and the model prepared manuscripts and the model produced Lean certificates. The exact training corpus, weights and post-training recipe remain proprietary, so these reports cannot tell us which internal lesson created which capability. They can tell us something more useful about system design: one broad model was asked to search across many fields, while formalisation arrived as the certification stage. Ten advances in mathematics and theoretical computer science

Google DeepMind's Aletheia follows the same broad-first logic in natural language. It uses a Gemini Deep Think foundation model in an agent that generates, verifies and revises long mathematical arguments while using tools to navigate the literature. Its published description is a preprint and its base model is closed, so the results require the same scrutiny as any ambitious research claim. The architecture nevertheless points in the right direction: research mathematics needs long-horizon planning and literature navigation before it needs a perfect line of Lean. Towards Autonomous Mathematics Research

The general model will be the mathematician who has read too much, sleeps too little and is delighted by an improbable connection. It will not receive the final word. Its value lies in generating the idea that gives the rest of the system something worth proving.

03 — The proof model will be trained like a mathematician inside a compiler.

Most mathematical models are not born mathematical. They begin as general or code foundation models and acquire their specialism in stages. The early open model Llemma, for example, continued training Code Llama models on Proof-Pile-2, a 55-billion-token mixture of mathematical papers, web mathematics and mathematical code. That stage taught the model the statistical texture of formulas, definitions and proofs. It did not by itself make every output correct. Llemma: An Open Language Model for Mathematics

The next generation moved from reading mathematics to acting inside a proof assistant. DeepSeek-Prover-V2 starts with knowledge inherited from DeepSeek-V3, then builds a cold-start curriculum by asking the large general model to split hard theorems into subgoals. A smaller prover attempts those subgoals in Lean. Successful fragments are assembled into training traces; supervised fine-tuning teaches the initial behaviour; reinforcement learning rewards proofs that the formal environment accepts. The final 671-billion-parameter version reported an 88.9% solve rate on MiniF2F under its evaluation budget and proved 49 of 658 PutnamBench problems. DeepSeek-Prover-V2

Goedel-Prover-V2 makes the recipe easier to see. It creates synthetic tasks in a rising staircase of difficulty, trains on them, lets Lean's feedback drive self-correction and averages model checkpoints to preserve a diversity of proof strategies. Its eight-billion-parameter model reached 84.6% on MiniF2F at pass@32, exceeding DeepSeek-Prover-V2-671B under the same attempt count despite being about eighty times smaller. The 32-billion-parameter version reached 88.1%, and 90.4% after two rounds of verifier-guided correction. Goedel-Prover-V2

The lesson is larger than the leaderboard. Formal proof rewards the right experience more than raw conversational scale. A proof specialist repeatedly sees a state consisting of hypotheses and a goal, proposes an action, executes it and receives an objective result. Syntax error. Unknown theorem. Type mismatch. New subgoals. Proof complete. There is no human preference model deciding that the answer looks rigorous.

By 2030, the strongest research system will keep both kinds of model. The general model will know enough of the world to propose the strange approach. The formal model will know Lean well enough to survive contact with every detail. Specialisation will become a component, not a cage.

04 — Lean turns proof into an executable object.

To understand why this architecture can be trusted, forget AI for a moment and look at the foundation beneath it. Lean is based on a correspondence often summarised as propositions are types and proofs are terms. In simpler words, a theorem is a specification for an object. A proof is the object that satisfies that specification.

A human user rarely writes the final object directly. The user applies tactics: small programs that transform the current proof state. A tactic might introduce a variable, rewrite an expression using a known equality, apply an earlier theorem or divide one goal into several smaller goals. Lean's elaborator turns those commands into a detailed proof term. The kernel then checks the term. If a required case is missing, a type does not match or a conclusion does not follow, the term is rejected.

This creates a perfect training environment. A language model can propose nlinarith, a rewrite or a lemma application. Lean executes the proposal and returns the new state. The model learns which actions reduce the distance to completion. A search procedure keeps several promising branches alive because a locally elegant tactic may lead to a dead end ten moves later. When every branch of every subgoal closes, the reward is unambiguous.

Lean's own validation guide is precise about the guarantee. Acceptance means the theorem statement has been elaborated and the kernel has accepted a proof that follows from the definitions, theorems and axioms in the file and its imports. Authors can print the axioms on which a result depends and re-check compiled proof objects with a separate checker. Lean's guide to validating proofs

The kernel is deliberately small compared with the model that found the argument. This asymmetry is the source of trust. A giant neural network may hallucinate a lemma, choose a bad tactic or misunderstand the literature. None of those failures persuades the kernel. Verification does not need to reproduce the model's intelligence; it needs only to check a completed logical object.

Mathematics has never had this division at scale. A human referee traditionally must discover whether every step is valid while also judging novelty, importance and exposition. Formal AI will separate the jobs. The machine-checkable certificate will settle derivability. The human-readable proof will explain why the result matters. Referees will spend less time hunting invisible algebraic slips and more time deciding whether the new idea changes the map.

05 — AlphaProof shows how the specialist learns.

AlphaProof is the clearest published X-ray of a modern formal prover. Its core proof network is a three-billion-parameter encoder–decoder transformer. Given a Lean tactic state, one output proposes promising tactics; another estimates how difficult the remaining proof is. An AlphaZero-inspired tree search uses both signals to decide which branches deserve more computation. The tree has an AND–OR structure because proving one claim can create several subgoals, all of which must close. Olympiad-level formal mathematical reasoning with reinforcement learning

The network first absorbed about 300 billion tokens of code and mathematical text. It then received supervised fine-tuning on roughly 300,000 state–tactic pairs extracted from human-written Mathlib proofs. That made it a plausible imitator of Lean users. Reinforcement learning made it an experimenter. It proposed tactics, watched Lean accept or reject them, and trained on the resulting proof-search experience.

The data engine was more remarkable than the model. Formal mathematics is tiny beside the ocean of ordinary mathematical writing, so DeepMind trained a Gemini-based autoformaliser and used it to turn about one million natural-language problems into roughly 80 million formal Lean problems. Those statements became starting positions for the prover. AlphaProof learned by trying to prove or disprove them. The main reinforcement-learning phase consumed about 80,000 TPU-days, an industrial research budget turned into a curriculum of logical experience.

For a particularly hard theorem, AlphaProof does not merely think longer with frozen weights. Its test-time reinforcement learning creates related variants of the target, trains on that bespoke neighbourhood and returns to the original problem with a specialised local education. On the 2024 International Mathematical Olympiad, AlphaProof solved three of the five non-geometry problems; combined with AlphaGeometry 2, the system reached a silver-medal score after multi-day computation.

That duration is sometimes described as a weakness because a human Olympiad contestant has four and a half hours per session. Research mathematics runs on a different clock. A machine may spend days exploring a theorem that would occupy a mathematician for months. Inference-time learning turns compute into persistence: the system can construct a private graduate course around one stubborn problem and take it before trying again.

By 2030, that idea will move beyond olympiad questions. A research agent will generate simpler cases, nearby conjectures, weakened hypotheses and finite analogues; solve enough of them to expose the local structure; then attack the original. The proof engine will not merely search harder. It will teach itself the theorem's neighbourhood.

06 — Synthetic mathematics will make formal data abundant.

A specialist prover needs more verified experience than human formalists can type. Synthetic data supplies it because mathematics can generate its own lessons and grade them automatically.

AlphaGeometry demonstrated the idea in a narrow domain. Its language model was trained from scratch on synthetic Euclidean-geometry theorems and proofs, then paired with a symbolic deduction engine. The symbolic side could derive exact geometric consequences but stalled when a problem required an auxiliary construction: add this point, draw that line, introduce the circle no statement mentioned. The neural model proposed those creative constructions; the deduction engine determined what followed. Trained without human demonstrations, the system solved 25 of 30 olympiad geometry problems in its test set. Solving olympiad geometry without human demonstrations

The method is powerful because a generated formal statement does not need to be historically important to be educational. It only needs to exercise a useful combination of concepts and tactics. A curriculum generator can vary constants, exchange hypotheses, compose lemmas, make a theorem easier or harder and retain the examples that force the prover to learn something new. Every completed proof becomes another verified training trace. Every failure identifies the frontier of the current model.

AlphaProof extended this logic across Lean. Its autoformalisation pipeline expanded a comparatively small seed of human-formalised mathematics into tens of millions of formal problems. The Nature paper notes an important subtlety: even when an automatically generated Lean statement is not a faithful translation of the original natural-language problem, it can still be a valid formal exercise for reinforcement learning. That is excellent for training and insufficient for publication.

The distinction will shape the 2030 stack. Synthetic statements teach the prover; faithful statements certify human claims. The training factory can tolerate strange but internally valid exercises. The publication pipeline must demonstrate that its formal theorem says precisely what the paper says.

This is why autoformalisation will become its own serious engineering layer rather than a prompt attached to the front of a prover. It will retrieve definitions, expand tacit conventions, ask the author to resolve ambiguity and generate small tests that compare the formal statement with intended examples. Surveys of the field already treat autoformalisation as a distinct task connecting informal mathematical language to proof assistants. A survey of autoformalisation for proof assistants

Once this bridge improves, mathematical data acquires a flywheel. Better translation creates more formal problems. More formal problems train better provers. Better provers make formalisation cheaper. Cheaper formalisation enlarges the library that retrieval and future models can use. The scarce resource will move from proof attempts to carefully specified meaning.

07 — Retrieval will be mathematical memory, not a footnote.

A model does not need to store every theorem in its weights. It needs to find the right theorem at the right moment. This difference becomes decisive in research, where the useful lemma may be buried in a paper from another field, written with different notation and never included in the model's most salient training examples.

LeanDojo made retrieval part of formal theorem proving by extracting proof states and premises from Lean repositories, then building ReProver, which retrieves useful definitions and theorems before generating tactics. The system showed that retrieval-augmented generation improves proof search while grounding the model in the exact library version it must use. It also provided an open environment in which models can interact with Lean reproducibly. LeanDojo: Theorem Proving with Retrieval-Augmented Language Models

The older Draft, Sketch and Prove method revealed the same division from another angle. A language model first wrote an informal proof, translated it into a formal sketch with gaps and then let existing automated provers fill those gaps. On its benchmark, the pipeline proved 39.3% of problems compared with 20.9% for the baseline. The numbers are now historical; the structure has survived. Broad reasoning supplies a sketch, retrieval supplies the local tools and a formal engine closes the details. Draft, Sketch, and Prove

Rethlas makes retrieval central to discovery rather than merely tactic selection. Its Matlas engine searches theorem-level mathematical material, allowing the agent to locate techniques beyond the immediate language of a conjecture. Archon then uses LeanSearch while converting the resulting informal argument into a formal project. The reported commutative-algebra case matters because the missing move was not a longer chain of generic reasoning. It was access to the right body of mathematics. Rethlas, Matlas and Archon

By 2030, theorem retrieval will resemble scientific instrumentation. The system will search natural-language papers, formal libraries, citation graphs and the local scratch work from its own previous attempts. It will map notation, rank premises, expose dependency chains and record the exact source of every imported claim. A proof model will ask the library dozens of small questions while the explorer asks one large question.

This makes the infrastructure unusually valuable. The decisive asset will not be a single chatbot that appears to know mathematics. It will be the continuously updated graph connecting human literature to machine-checkable definitions and proofs. The model can change every year. The library accumulates.

08 — Proof search will spend compute where certainty is worth it.

Mathematical benchmark scores are easy to misread. pass@32 does not mean a model answers correctly on its first attempt. It means the evaluation gives the system up to 32 generated attempts and counts a problem as solved if at least one passes. Some reported results use hundreds or thousands of attempts. The verifier makes this useful rather than embarrassing: every rejected candidate is cheap, and one accepted proof term is enough.

Goedel-Prover-V2's small-model result shows how training quality can reduce the search burden. DeepSeek-Prover-V2's high MiniF2F result shows what a very large model and a large attempt budget can achieve. AlphaProof goes further by combining a learned policy, a learned value estimate, tree search and problem-specific reinforcement learning. These systems are not answering a quiz. They are allocating computation across a proof tree. Goedel-Prover-V2 DeepSeek-Prover-V2 AlphaProof

The economic shape is attractive for research. Generating thousands of failed proof fragments is far cheaper than assigning thousands of human referees, provided that the final certificate is independently checkable. OpenAI said the model inference used to find its ten August 2026 results would cost about $2,000 at the equivalent Sol API rates, before manuscript preparation and formalisation. That figure comes from the system's developer and excludes model training, expert review and the value of the surrounding infrastructure. Even expanded by orders of magnitude for difficult cases, it describes a new market: deep search can be purchased for selected questions, while verification remains reproducible. OpenAI's ten reported advances

Compute will therefore become a mathematical decision. A university agent may give routine lemmas seconds, a promising conjecture hours and an important open problem weeks. It can stop branches whose value model collapses, generate variants around a bottleneck and return later when the library gains a missing theorem. Search logs will become research artefacts: not a stream of hidden thoughts, but a map of attempted lemmas, compiler failures, retrieved premises and verified intermediate results.

The human comparison should be made honestly. Mathematicians also try many arguments that fail, consult libraries, prove small lemmas and sleep on a problem before returning. Formal agents turn that private process into parallel computation with an incorruptible finish line. They will be most impressive where an enormous forest of plausible routes contains a very small number of valid ones.

09 — The last hard problem is meaning.

A Lean certificate can prove the wrong theorem perfectly. If the English claim says every object and the formal statement encodes some object, the kernel will certify exactly what it received. If a definition omits a boundary case, the proof may be flawless and the paper false in the sense its readers care about. Lean's documentation states the trust boundary clearly: validation is meaningful when the formal theorem corresponds to the intended informal meaning and the imported libraries state what their authors intended. Lean's validation and trust boundary

This semantic gap will not prevent formal proof from becoming the trust layer. It will determine the human role around that layer. Authors and referees will inspect the formal statement, test it on examples and compare every assumption with the prose claim. Tooling will display a two-way map: click a phrase in the paper and see the Lean definition; click a formal hypothesis and see where the paper justifies it. Independent systems will translate the statement separately and flag disagreements.

The strongest workflow will certify four different things:

Derivability. the proof assistant checks that the conclusion follows from the formal assumptions. Fidelity. humans and translation tools check that the formal statement matches the intended claim. Novelty. retrieval and expert review determine whether the result was already known. Meaning. mathematicians explain why the construction works, which idea is reusable and what new questions appear.

Only the first job should be handed completely to the kernel. The other three become more important when generating a candidate proof is cheap. A million valid but uninteresting lemmas do not create a mathematical culture. One proof that reveals a new bridge between fields can.

The Leiden Declaration on AI and Mathematics already asks for transparent disclosure, human responsibility, reproducibility and formal verification where feasible. It reflects a community beginning to design norms before the flow of AI-generated results becomes overwhelming. The International Mathematical Union has endorsed it. Leiden Declaration on Artificial Intelligence and Mathematics

By 2030, a respected AI-assisted paper will arrive with three linked objects: a readable manuscript, a formal certificate and a provenance record describing models, tools and human decisions. That package will be stronger than today's PDF because its claims can be read, recomputed and audited at different levels. Formalisation will not remove judgment from mathematics. It will free judgment from the work a kernel can do better.

10 — Formal libraries will become the compounding asset.

The public image of AI mathematics is a model confronting a famous unsolved problem. The industrial reality will be quieter: thousands of definitions normalised, theorem dependencies cleaned, informal papers translated and reusable lemmas added to shared libraries. Each improvement enlarges the territory future agents can enter safely.

Mathlib, Lean's community library, already contains hundreds of thousands of theorems and definitions contributed by hundreds of people. Its live statistics show the scale changing continually. The library covers substantial parts of algebra, analysis, number theory, topology, probability and computer science, while remaining far smaller than all published mathematics. Current Mathlib statistics

A research agent gains more than facts from such a library. It gains canonical definitions, exact hypotheses, known dependency paths and executable examples of proof technique. Formalisation converts a paper from a document into infrastructure. Once a lemma is in the library, another model can retrieve it, specialise it, compose it with a result from another field and let the kernel check the composition.

This is the flywheel that will make 2030 different from 2026. AI will lower the cost of translating routine mathematics into proof-assistant code. Better formal corpora will train smaller and more capable specialist provers. Those provers will lower the cost again. Journals and research groups will begin to treat formal artefacts as durable scholarly output, comparable to data and software. Universities will fund library engineers because one carefully designed formal API can support hundreds of future proofs.

The advantage will compound internationally as well. Natural-language mathematics is divided by notation, terminology and language. A formal theorem has explicit types and dependencies. A Japanese paper, a Brazilian preprint and a French monograph can meet inside the same library once their statements are formalised. Retrieval will search concepts rather than merely matching phrases.

The winning system will therefore be open at the point of trust even when its explorer is proprietary. A closed model may discover a proof, but a public certificate allows any researcher to run the checker. The model's authority is irrelevant after it has produced a valid object. This is an unusually hopeful bargain: mathematical discovery may use the largest private machines, while mathematical certainty can remain a small public computation.

11 — By 2030, the proof engine will sit beside the referee.

The transition will begin with AI-originated work because those papers create the greatest demand for independent trust. A journal receiving a long proof from an opaque model cannot ask readers to believe the model's confidence or a company's benchmark. It can ask for a certificate. The same workflow will then spread to human proofs in fields where long calculations, enormous case splits or intricate dependency chains already strain conventional review.

A 2030 submission portal will accept the manuscript and a pinned formal environment. Automated checks will rebuild the project, reject sorry, print non-standard axioms, verify dependency licences and display which formal statements correspond to the paper's headline claims. Specialist referees will review the translation and the mathematical contribution. The kernel will review the steps.

This will change what counts as an impressive mathematical AI. Olympiad medals will remain useful engineering tests, but research systems will be judged by a harder sequence: Did the system find a genuinely new statement? Did it retrieve and combine ideas beyond the obvious literature neighbourhood? Did it produce a public proof object? Can another group rebuild it? Did mathematicians learn something from the result?

The forecast's threshold is deliberately concrete. By 31 December 2030, there must be at least 25 peer-reviewed papers across five fields that disclose substantive AI generation or discovery and publish machine-checkable formal certificates. At least three established mathematics journals or publishers must provide an explicit formal-artefact route. Preprints, competition solutions and ordinary papers that use AI only for copy-editing will not count. A certificate hidden behind a private service will not count.

The evidence has already crossed the crucial conceptual line. General models can make surprising cross-field moves. Specialist provers can learn directly from a formal environment. Synthetic curricula can create millions of graded exercises. Retrieval can expose the lemma that changes the route. Lean can reduce the finished argument to an object checked by a small kernel.

Now the pieces will be assembled into scholarly machinery. By 2030, an AI will be allowed to imagine almost anything in mathematics. Publication will depend on whether the proof engine agrees.