💬 NLP

OProver: A Unified Framework for Agentic Formal Theorem Proving

OProver is a unified framework for agentic formal theorem proving in Lean 4 that integrates iterative proof revision with compiler feedback and retrieval, achieving state-of-the-art performance across multiple benchmarks through a novel training pipeline combining continued pretraining, supervised fine-tuning on repair trajectories, and reinforcement learning on hard cases.

Original authors: David Ma, Kaijing Ma, Shawn Guo, Yunfeng Shi, Enduo Zhao, Jiajun Shi, Zhaoxiang Zhang, Gavin Cheung, Jiaheng Liu, Zili Wang

Published 2026-05-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: David Ma, Kaijing Ma, Shawn Guo, Yunfeng Shi, Enduo Zhao, Jiajun Shi, Zhaoxiang Zhang, Gavin Cheung, Jiaheng Liu, Zili Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a very difficult math puzzle, but you have to write the solution in a strict, robotic language called Lean 4. If you make even one tiny typo or logical error, the computer (the "compiler") rejects the whole thing and says, "Nope, wrong."

For a long time, AI models trying to solve these puzzles worked like a student taking a test: they would guess an answer, and if it was wrong, they would just guess again from scratch. They didn't really learn why they were wrong, and they didn't use the computer's specific feedback to fix their mistakes.

OProver is a new system that changes the game. Instead of just guessing, it acts like a perfectionist detective who never gives up. Here is how it works, using simple analogies:

1. The "Agentic" Detective (The Prover)

Think of OProver not as a static textbook, but as a detective who has a multi-step investigation process.

The Old Way: The detective writes a theory, the judge (the computer) says "Wrong," and the detective writes a completely new theory from scratch.
The OProver Way: The detective writes a theory. The judge says, "You made a mistake here: you used the wrong type of number." The detective then edits that specific part of the theory, checks it again, and keeps refining it until the judge says, "Correct!"

OProver is trained to do this "edit and refine" dance automatically. It doesn't just guess; it learns to listen to the judge's specific complaints and fix them.

2. The "Library of Solutions" (Retrieval)

Before the detective starts writing, they don't work in a vacuum. They go to a massive library (called the Retrieval Memory).

If the detective is trying to solve a puzzle about triangles, the library instantly pulls out the top 5 best proofs about triangles that other detectives have successfully solved before.
OProver reads these "cheat sheets" to see how other people solved similar problems, using their strategies as a guide. This helps the detective avoid common traps.

3. The "Self-Improving Loop" (The Training)

This is the most magical part. Usually, AI models are trained on a fixed set of data and then left alone. OProver is different; it has a self-improving cycle.

Step 1: OProver tries to solve a bunch of puzzles.
Step 2: When it succeeds, it saves that solution into the library so it can be used as a "cheat sheet" for future problems.
Step 3: When it fails, it saves the entire story of how it failed, what the computer said, and how it eventually fixed it.
Step 4: The system uses these "failure stories" to teach itself how to do better next time.

It's like a student who, after every exam, not only memorizes the right answers but also writes down exactly why they got questions wrong and adds those notes to their study guide. Over time, the student gets smarter, and the study guide gets thicker and more helpful.

4. The Result: A Super-Student

The paper tested this system on five different "math olympiads" (ranging from high school level to very hard university competitions).

The Achievement: OProver (specifically the 32-billion-parameter version) became the top performer among all open-source AI provers. It solved more problems correctly than any other similar system, even beating much larger models.
Why it matters: It proved that giving the AI the ability to listen to feedback, look up past solutions, and iteratively fix its own work is much more powerful than just making it bigger or smarter at guessing.

In Summary

OProver is a math-solving AI that doesn't just "guess and check." It is a collaborative learner that:

Looks up similar solved problems first.
Writes a proof.
Listens to the computer's specific error messages.
Edits its work to fix those errors.
Repeats until it succeeds, then saves the lesson for next time.

By turning the "failure" into a learning opportunity and keeping a running log of what works, OProver has become the best open-source AI at formally proving mathematical theorems today.

Technical Summary: OProver: A Unified Framework for Agentic Formal Theorem Proving

Problem Statement

Recent advancements in formal theorem proving, particularly within the Lean 4 ecosystem, have leveraged large-scale proof generation and verifier-aware training to improve performance on benchmarks like MiniF2F and PutnamBench. However, a critical limitation persists: agentic proving capabilities (retrieval, compiler feedback, and iterative repair) are typically treated as inference-time heuristics applied to a fixed prover, rather than as learned policies integrated into the training process.

This creates a train-inference mismatch. Models trained primarily on finalized, successful proofs encounter compiler feedback and retrieved context only during deployment, in distributions they were never optimized for. Furthermore, existing formal corpora focus on end products (statements and verified proofs), omitting the multi-round interaction histories—failed attempts, retrieved context, and compiler diagnostics—essential for learning how to repair proofs. Consequently, the supervision signal driving proof repair in practice remains largely unexploited in model training.

Methodology

The paper presents OProver, a unified framework that integrates retrieval, compiler feedback, and iterative repair directly into the prover's policy through a co-evolutionary training pipeline.

1. The OProver Framework

OProver treats theorem proving as a bounded, multi-round refinement loop. At each round $t$ , the policy $\pi$ conditions on a compact state $X_t = (s, R_t, p_{t-1}, f_{t-1})$ , where:

$s$ : The target theorem statement.
$R_t$ : Top- $k$ retrieved compiler-verified proofs from a memory $M$ .
$p_{t-1}$ : The previous proof attempt.
$f_{t-1}$ : The raw textual compiler feedback (diagnostics) from the Lean 4 verifier.

The policy generates a revised attempt $p_t$ . If verification fails, the raw feedback is passed back to the policy for the next round. Crucially, the policy conditions only on the most recent attempt and feedback, preserving local correction signals while keeping the state compact.

2. OProofs: A Unified Training Corpus

To support this framework, the authors construct OProofs, a large-scale corpus specifically designed for agentic proving. Unlike prior datasets that preserve only final proofs, OProofs records serialized trajectories including:

Retrieved context.
Failed attempts.
Raw compiler feedback.
Subsequent repairs.

OProofs is built from three sources: public Lean resources, large-scale proof synthesis (autoformalization + verification), and traces from OProver's own agentic proving. It contains 1.77M unique Lean statements and 6.86M compiler-verified proofs, paired with 1.07M agentic trajectories.

3. Co-Evolutionary Training Pipeline

The training process follows an iterative loop (Algorithm 1) where the prover and the corpus co-evolve:

Continued Pretraining (CPT): A base model is trained on a mixture of Lean code, mathematics, and long-context reasoning data to create OProver-Base.
Iterative Post-Training:
- Agentic Rollouts: The current policy performs multi-round proving on a theorem pool, retrieving from the current memory $M_k$ and verifying with the Lean compiler.
- Data Collection: Newly verified proofs are added to the corpus and indexed into the retrieval memory. Failed attempts and successful repairs are decomposed into round-level examples $(s, R_t, p_{t-1}, f_{t-1}) \to p_t$ .
- Supervised Fine-Tuning (SFT): The model is updated using the collected repair examples.
- Reinforcement Learning (RL): Group Sequence Policy Optimization (GSPO) is applied to harder unresolved cases, using a reward signal based on verification success and format correctness.
- Recirculation: The updated corpus and memory feed into the next iteration, allowing the policy to learn from its own improved proofs.

Key Contributions

Unified Framework for Agentic Proving: OProver unifies retrieval, feedback, and iterative repair into a single learned policy, eliminating the train-inference mismatch by training the model to use these signals as part of its core strategy rather than as external heuristics.
OProofs Corpus: The construction of a large-scale corpus (1.77M statements, 6.86M proofs) that explicitly preserves multi-turn interaction histories, including failed attempts and raw compiler feedback, providing supervision previously unavailable in formal datasets.
Co-Evolution Pipeline: A training methodology where the prover generates new data (verified proofs and repair trajectories) that are immediately folded back into the training corpus and retrieval memory, creating a self-improving loop.
State-of-the-Art Performance: OProver achieves top-tier results among open-weight whole-proof provers, demonstrating that agentic refinement strategies can outperform significantly larger models.

Experimental Results

OProver was evaluated on five Lean 4 benchmarks: MiniF2F, MathOlympiadBench, ProofNet, ProverBench, and PutnamBench.

Performance: The OProver-32B model achieved the best Pass@32 scores on three benchmarks (MiniF2F: 93.3%, ProverBench: 58.2%, PutnamBench: 11.3%) and second-best on the other two (MathOlympiad: 22.8%, ProofNet: 33.2%).
Efficiency: OProver-32B (32B parameters) outperformed the 671B DeepSeek-Prover-V2 and the 560B LongCat-Flash-Prover (with TIR) on most benchmarks, despite having significantly fewer parameters. Even the 8B variant outperformed the 32B Goedel-Prover-V2 across all benchmarks.
Test-Time Scaling: Performance consistently improved with increased compute budgets (more samples or refinement rounds), though with diminishing returns. Optimal allocation between refinement depth and sampling width varied by benchmark difficulty.
Ablation Studies: Removing multi-turn compiler feedback caused the most significant performance degradation, confirming iterative refinement as the primary driver of gains. Removing retrieval augmentation also caused consistent, albeit smaller, drops, highlighting the complementary value of retrieval grounding.

Significance and Claims

The paper claims that OProver demonstrates that agentic formal theorem proving can be effectively learned as a unified policy rather than assembled from separate inference-time modules. By training on the full trajectory of proof construction, failure, and repair, the model learns to leverage compiler feedback and retrieved context as intrinsic parts of its reasoning process.

The authors emphasize that the performance gains are not merely a result of model scale but stem from the synergy between retrieval-augmented grounding and compiler-guided iterative refinement. The co-evolution of the OProver policy and the OProofs corpus allows the system to continuously improve its proving capabilities by learning from its own successful and failed attempts, establishing a new paradigm for training formal reasoning systems.