Meta and NYU's h1 theorem prover reports 82.5% on Erdős problems at $121, versus 76% at $317 for DeepMind's AlphaProof Nexus

A stripped-down AI system from Meta and NYU says it can prove hard math theorems about as well as the elaborate, hand-built systems, and for less money.

The system is called h1. The paper behind it, "h1: A Taste of the Bitter Lesson in Automated Theorem Proving," was posted to arXiv on October 25, 2026 (arXiv:2610.35962). The authors are Skander Moalla, Ahmad Rammal, Niket Patel, Rémi Munos and Julia Kempe, with affiliations at Meta FAIR, NYU, EPFL and CERMICS-ENPC.

What h1 actually is

h1 is a harness around Lean 4, the formal proof checker. A frontier language model writes proof code, gets the checker's errors back, reflects, and tries again.

There is no decomposition into subgoals. No fixed search strategy. No team of specialized agents. The authors say the design gives the model "an efficient interface to Lean 4" and keeps it working through verifier feedback and self-reflection.

That is a deliberate contrast. Recent systems have wrapped models in human-designed workflows for planning, decomposition and orchestrating specialized provers. The paper asks whether that machinery is necessary.

The numbers

According to the paper, h1 reached state-of-the-art results on PutnamBench, FATE-X and FormalConjectures100-Solved.

• PutnamBench: 670 of 672 problems, using GPT-5.5.
• FATE-X: 90 out of 100, using GPT-5.6 Sol.
• FormalConjectures100-Solved: 78 out of 100, also with GPT-5.6 Sol.
• IMO 2026: all six problems solved with GPT-5.6 Sol, per the paper's reported results.

h1 also settled eight open problems in the FormalConjectures collection. They include variants of Erdős problems 138 and 337. These are questions named for the mathematician Paul Erdős.

The DeepMind comparison

The most direct head-to-head is on five open Erdős problems. With Gemini 3.1 Pro, h1 hit an 82.5% success rate on a single attempt (pass@1), at a mean cost of $121.

Full AlphaProof Nexus, DeepMind's system, scored 76% at $317. A basic version of AlphaProof Nexus scored 75.4% over three attempts at $191.

The authors say that at matched models, h1 matches or outperforms specialized workflows including Goedel-Architect and AlphaProof Nexus. In their words, a single attempt "can often scale to solve open problems." Higher success at lower cost than the full system ($121 versus $317) is the paper's central claim.

The case for the elaborate systems

The prevailing view, as the paper describes it, is that formal proving resists simple scaling. The search space is vast and proofs need structure, so planning and decomposition workflows seemed necessary. That is the premise behind systems like AlphaProof Nexus, and h1 is built to test it.

The authors do not claim the debate is over. Their ablations and matched-model comparisons with Claude Code and AxProverBase found that "simplicity alone is not enough." A loop with a slow, noisy or hard-to-read Lean interface can still be expensive or ineffective. The efficient interface, not the absence of structure, largely determines cost and solve rate.

The paper also does not show that every theorem is best handled by a single loop. It does not say search and decomposition are worthless.

Limits on what the results show

These are the authors' own results in a preprint. The top scores depend on frontier models, GPT-5.5, GPT-5.6 Sol and Gemini 3.1 Pro. Model strength is exactly the variable that muddies comparisons between proving systems.

The Erdős comparison covers five problems. The paper's framing leans on matched models and test-time budgets to address the confound, but readers still have only the authors' numbers for the competing systems. Benchmark scores also reflect performance on specific test sets, and PutnamBench is close to saturated at 670 out of 672.

The work also builds on earlier Meta research, including the HTPS neural theorem prover introduced in 2022. Those earlier efforts focused on smarter search around the model. h1 shifts the focus to letting the model work directly with the verifier.

The "bitter lesson" framing

The title borrows an old machine-learning idea: general methods that scale with computation tend to beat handcrafted techniques over time. The authors apply it to formal proving and note that new workflows often get credit for gains that were confounded with stronger models or more compute.

Their recommendation is concrete. Future work should evaluate frontier models with efficient execution feedback before prescribing workflows, "at the risk of bitter lessons." The paper's contribution is a demanding baseline: additional structure should demonstrate benefits that justify its extra complexity and cost.