AlphaProof Nexus Is Now Peer Reviewed in Science: 9 Erdős Problems, 44 OEIS Conjectures

AlphaProof Nexus, Google DeepMind's agent that writes and checks mathematical proofs in Lean, has now cleared peer review. According to The Decoder's report on the new study in Science, the system solved 9 of 353 open Erdős problems, two of which had been unsolved for 56 years, and proved 44 conjectures from the OEIS integer sequence database. The headline results are not new: they first appeared in an arXiv preprint on May 21, 2026. What changed on October 12 is the venue, and in the current AI math argument, the venue is the story.

This post covers what the system does, what the numbers do and do not say, and why DeepMind's decision to go through a journal lands differently next to the Association for Human Mathematics' call to stop working with OpenAI.

TL;DR: AlphaProof Nexus at a glance

What is new on October 12: peer review

For five months the AlphaProof Nexus results lived as a preprint. A preprint is a claim; a Science paper is a claim that outside referees have read. The Decoder frames the timing deliberately: the publication "comes as OpenAI faces a boycott for dumping AI proofs on GitHub without peer review," and DeepMind "put its work through peer review."

That is the context readers should keep in mind. Recently, hundreds of AI-generated proofs from OpenAI were released on GitHub rather than submitted to journals, and the Association for Human Mathematics, a group in which Terence Tao is prominent, called for mathematicians to stop collaborating. We covered that dispute in the AHM statement post and the broader expert reactions to OpenAI's math results. The DeepMind paper is, among other things, a counter-example in process: same field, same kind of claim, different route to credibility.

Be careful not to over-read it. Peer review does not change what the system can do; it changes how much weight a reader can reasonably put on the reported numbers. And the Lean artifacts were already public, so the proofs themselves were checkable by anyone from the preprint date.

How AlphaProof Nexus works

Chain of proof steps ending in a green check, illustrating how AlphaProof Nexus verifies each Lean step

The architecture is a loop, and the loop is the interesting part. In the words of the preprint abstract, the team ran "the first large-scale evaluation" of using language models to generate formal proofs in languages like Lean to attack open problems.

Per The Decoder's May write-up of the paper, the system comes in four agent variants of increasing complexity:

1. Agent A runs independent Gemini 3.1 Pro sub-agents in a loop: the model proposes proof steps in Lean, the compiler checks them, and error messages feed the next attempt.
2. Agent B adds queries to AlphaProof, DeepMind's reinforcement-learning system for olympiad-style math, to fill missing proof segments.
3. Agent C adds an evolutionary layer inspired by AlphaEvolve: sub-agents share a population of proof sketches, which rating agents on Gemini 3.0 Flash score for plausibility and novelty and rank with an Elo system.
4. Agent D combines all of it, and it was used for the headline Erdős results.

The setup for each problem is a Lean file where the proof has been replaced by a gap. The agent sees prior attempts with their ratings and a current plan, decomposes the proof into lemmas, calls AlphaProof for sub-goals, and refines failed steps until every goal is closed. Humans step in only at the end, to confirm the final statement matches the problem.

The surprise: the simple agent nearly matched the complex one

A post-hoc analysis found that Agent A, with just an LLM and compiler feedback, could also prove all nine solved Erdős problems, only at higher cost on the hardest instances. The authors attribute this to rapid improvement in the underlying models and "the power of compiler feedback in grounding LLM reasoning," and describe "an ongoing shift from specialized trained systems toward simple agentic loops as LLMs become more capable."

For builders this is the most portable lesson. A cheap verifier in the loop (a compiler, a test suite, a type checker) does a surprising amount of the work that people assume needs a bespoke trained system. It is the same pattern behind modern coding agents; see our guide to loop engineering for coding agents.

What it solved, and what it did not

Two reviewers inspecting a single paper, one holding a green stamp, as a metaphor for peer review of AlphaProof Nexus

The reported results:

• Erdős problems: 9 of 353 open problems resolved autonomously, including two open for 56 years. The solutions were shared online ahead of the paper.
• OEIS: 44 of 492 open conjectures from the Online Encyclopedia of Integer Sequences proved.
• Algebraic geometry: a 15-year-old question about Hilbert functions settled.
• Optimisation: an improved known bound in min-max optimisation, a technique used to train some AI models.
• Deployment: per the abstract, the agent is being deployed in combinatorics, optimisation, graph theory, algebraic geometry and quantum optics research.

And the limits, stated plainly by the authors as relayed by The Decoder: successes cluster where Lean's Mathlib library is mature and problems split into manageable sub-goals; most Erdős problems stayed out of reach, "let alone problems that require extensive new theory"; and the agents inherit the unreliability of the underlying models. A 2.5 percent hit rate lines up almost exactly with the one-to-two percent figure Tao has cited for AI success on Erdős problems generally.

Context matters here. The Erdős problem list is a catalogue of open questions of very uneven difficulty; many are obscure or under-studied rather than famous. Solving nine is a real result, and "AI beats the hardest problems in mathematics" is not what it says.

Formal proof versus natural-language proof

This paper is also a clean illustration of the split that has defined AI math in 2026.

OpenAI's headline results, such as the planar unit-distance Erdős disproof, rely on a model carrying the whole argument in natural language, which humans then have to check. DeepMind's approach trades some raw capability demonstration for reliability: if the Lean file compiles, the logic is sound relative to the formal statement. The Decoder notes OpenAI could add Lean to its own scaffold, and indeed other labs already ship formal certificates, as in the OpenAI Astra ten-proofs post and our look at the collapsing cost of Lean 4 formal proofs.

The authors make a related point worth underlining: "Formal verification can serve as a filter for determining which proofs merit human review." When the volume of AI-generated proofs explodes, as the boycott dispute shows it can, mathematicians' scarce attention is the bottleneck. A formal proof does not remove the need for judgment, but it moves the judgment to one question: did we state the right theorem?

That question is not trivial. The preprint notes the agents were also useful at catching flawed formalisations in the existing literature, which is a reminder that the failure mode shifts from "wrong proof" to "wrong statement."

Failed attempts still had value

Agent loop cycle with a green dot moving through steps, showing the generate and verify loop behind AlphaProof Nexus

One quieter finding: mathematicians who worked with the system reported that even failed attempts deepened their understanding of a problem. Because the sketches are formal, experts could focus on the unsolved sub-goals rather than re-checking an entire argument from scratch. In practice that makes the tool less a solver and more a research collaborator that leaves an auditable trail.

That fits the pattern we saw in other labs' work, from Claude's Riemann zeta lower-bound result to the Star Fleet Erdős effort with GPT-5.6 Codex and Lean 4. The common thread is that the proof assistant, not the model's confidence, is the arbiter.

What this means for what you build or use

• If you build agents: add a hard verifier to the loop. The paper's strongest practical claim is that a simple generate-and-check loop got most of the way to a complicated system.
• If you follow AI math claims: check three things before believing a headline: is there a formal artifact, has anyone outside the lab reviewed it, and what was the denominator (9 of 353, not "9 problems")?
• If you research or teach math: the tooling is being deployed in real research areas now, but access is limited; the public artifacts are the GitHub proofs, not a product.
• If you track the lab race: DeepMind is competing on verifiability and process, OpenAI on raw reasoning scale. Expect each side to adopt parts of the other. For the wider debate, read our piece on AI labs hoarding math solutions and the latest Gemini Cogentic five-math-problems post.

What we could not verify

We read the preprint abstract and two Decoder write-ups, not the full Science text, which we could not access in this run. Numbers above come from the abstract and those reports, and the Gemini variant (3.1 Pro) is from The Decoder, not the abstract. If the journal version changed any figures from the May preprint, we will update this post. We also have not independently run the Lean proofs; the GitHub release is the place to do that.

Related reading

• AHM tells mathematicians to stop working with OpenAI
• OpenAI math results that matter: expert reactions
• Gemini Cogentic and five math problems
• OpenAI planar unit-distance Erdős problem
• Lean 4 formal proof cost collapse
• AI labs hoarding math solutions
• Primary sources: arXiv 2605.22763 · The Decoder on the Science paper

Figures and details are accurate as of October 12, 2026 and may change as the journal version and community review develop.