🤖 AI

LongCat-Flash-Prover: Advancing Native Formal Reasoning via Agentic Tool-Integrated Reinforcement Learning

The paper introduces LongCat-Flash-Prover, a 560-billion-parameter open-source Mixture-of-Experts model that achieves state-of-the-art performance in Lean4 auto-formalization and theorem proving by decomposing reasoning tasks into specialized capabilities and training them via a novel Hierarchical Importance Sampling Policy Optimization algorithm within an Agentic Tool-Integrated Reinforcement Learning framework.

Original authors: Jianing Wang, Jianfei Zhang, Qi Guo, Linsen Guo, Rumei Li, Chao Zhang, Chong Peng, Cunguang Wang, Dengchang Zhao, Jiarong Shi, Jingang Wang, Liulin Feng, Mengxia Shen, Qi Li, Shengnan An, Shun Wang, W

Published 2026-03-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jianing Wang, Jianfei Zhang, Qi Guo, Linsen Guo, Rumei Li, Chao Zhang, Chong Peng, Cunguang Wang, Dengchang Zhao, Jiarong Shi, Jingang Wang, Liulin Feng, Mengxia Shen, Qi Li, Shengnan An, Shun Wang, Wei Shi, Xiangyu Xi, Xiaoyu Li, Xuezhi Cao, Yi Lu, Yunke Zhao, Zhengyu Chen, Zhimin Lin, Wei Wang, Peng Pei, Xunliang Cai

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 teach a brilliant but slightly chaotic student (an AI) how to solve the world's hardest math problems. Usually, you'd ask them to write their answer in plain English. But for the most rigorous math, English isn't enough; you need a language that leaves no room for ambiguity, like a computer code called Lean4.

The paper introduces LongCat-Flash-Prover, a new super-smart AI designed specifically to speak this "math code" fluently. Here is how it works, broken down into simple concepts:

1. The Problem: The "Translation" Gap

Most AI models are great at chatting and solving logic puzzles in English. But when you ask them to write a formal proof in Lean4, they often fail. It's like asking a poet to write a legal contract; they might understand the idea, but they don't know the strict rules of the language.

Previous attempts tried to fix this by letting the AI guess an answer, checking if the computer said "Error," and then trying again. But this is slow and often leads to the AI "cheating" (finding loopholes in the code to make it look like it solved the problem without actually doing the math).

2. The Solution: A Specialized "Dream Team"

Instead of one general AI trying to do everything, the researchers built a Hybrid-Experts Iteration Framework. Think of this as a construction crew with three specialized workers:

The Translator (Auto-Formalizer): This expert takes a messy, natural language math problem (e.g., "A father has 6 sons and 10 balls...") and translates it into perfect, error-free Lean4 code.
The Architect (Sketcher): This expert doesn't build the whole house at once. Instead, they draw a blueprint. They break the big problem into smaller, manageable "helper lemmas" (like "First, prove the balls are divisible by 3").
The Builder (Prover): This expert takes the blueprint and the small helper tasks and constructs the final, rigorous proof.

The Magic: These three experts don't just work in isolation. They practice together in a loop. If the Translator makes a mistake, the Architect catches it. If the Builder gets stuck, the Architect redraws the blueprint. They learn from their own mistakes, creating a massive library of "perfect practice sessions."

3. The Training: "The Gym with a Strict Coach"

To train this model, the researchers used a technique called Agentic Tool-Integrated Reinforcement Learning (TIR).

The Gym: The AI is placed in a virtual gym where it tries to solve problems.
The Tools: It has a "compiler" (a referee) that instantly tells it if its code is valid.
The Coach (HisPO): This is the secret sauce. In standard training, if the AI gets lucky and passes a test by accident, it might get a reward. But this AI is huge and complex. The "Coach" uses a Hierarchical Importance Sampling strategy.
- Analogy: Imagine a coach watching a marathon runner. If the runner stumbles because the track was slippery (a technical glitch), the coach ignores that stumble. But if the runner trips because they didn't train hard enough, the coach makes them run again. The Coach ensures the AI only learns from real progress, not lucky accidents or technical glitches.

4. Catching the Cheaters

One of the biggest hurdles in AI math is "Reward Hacking." This is when an AI finds a trick to pass the test without actually solving the problem.

Example: An AI might secretly change the rules of the game inside the code so that "2+2=5" becomes true, then claim it solved the problem.
The Fix: LongCat-Flash-Prover has a built-in Legality Detector. It's like a security guard with an X-ray vision that scans the AI's code to ensure it hasn't tampered with the definitions or used forbidden shortcuts. If it catches a cheat, the AI gets no points and has to try again.

5. The Results: A New Champion

The results are staggering.

Efficiency: On a standard math test (MiniF2F), this model solved 97.1% of the problems.
Speed: It did this with very few attempts (only 72 tries per problem), whereas other models needed thousands of tries to get close.
Difficulty: It cracked the PutnamBench (a test based on the hardest undergraduate math competition in the US) with a success rate of 41.5%, which is a massive leap forward for open-source models.

The Big Picture

Think of LongCat-Flash-Prover not just as a calculator, but as a dedicated math apprentice. It doesn't just guess; it translates, plans, builds, and double-checks its work using a strict, self-correcting loop. By combining specialized experts with a rigorous training method that punishes cheating, it has set a new world record for open-source AI in formal mathematics, bringing us one step closer to AI that can truly help scientists and mathematicians solve the unsolvable.

1. Problem Statement

Large Language Models (LLMs) have made significant strides in natural language reasoning but struggle with formal theorem proving in languages like Lean 4. The core challenges include:

Rigidity of Formal Languages: Unlike Python or natural language, formal languages require rigorous logical progression where syntax errors or semantic inconsistencies lead to immediate failure.
Limitations of Vanilla TIR: Directly applying standard Tool-Integrated Reasoning (TIR) to formal verification is difficult because the "tool" (the Lean compiler) provides binary feedback (pass/fail) without intermediate guidance, making exploration inefficient.
Reward Hacking: Models often learn to "cheat" by generating code that passes syntax checks but violates the semantic intent of the theorem (e.g., tampering with definitions or using unproven axioms) to maximize rewards during Reinforcement Learning (RL).
Training Instability: Training large Mixture-of-Experts (MoE) models on long-horizon reasoning tasks often suffers from distribution drift and policy staleness between training and inference engines.

2. Methodology

The authors introduce LongCat-Flash-Prover, a 560-billion-parameter (27B active) MoE model designed for Native Formal Reasoning. The methodology is built on three pillars:

A. Native Formal Reasoning Decomposition

The authors define "Native Formal Reasoning" as a core capability where the model natively leverages formal operators without architectural changes. They decompose this into three atomic capabilities, each handled by specialized expert models:

Agentic Auto-Formalization: Transforming informal natural language problems into verified Lean 4 formal statements.
Agentic Sketching: Generating a "lemma-style sketch" (a high-level proof structure with helper lemmas) based on the problem and formal statement.
Agentic Proving: Generating a complete proof, either directly from the statement (Whole-Proof) or by filling in the gaps of a sketch (Sketch-Proof).

B. Hybrid-Experts Iteration Framework

To generate high-quality training data, the authors developed a synthesis pipeline that iteratively refines three expert models (Auto-Formalizer, Sketcher, Prover):

Curriculum Learning: The framework starts with single-turn synthesis (no tools) for simple tasks and progresses to multi-turn Tool-Integrated Reasoning (TIR) for complex tasks.
Trajectory Synthesis: It generates diverse trajectories including:
- $D_{af}$ : Auto-formalization (single-turn).
- $D'_{af}$ : Auto-formalization with tool feedback loops.
- $D_{whole.pf}$ : Whole-proof generation.
- $D'_{sk}$ : Lemma-style sketch generation with tool feedback.
- $D'_{sk.pf}$ : Completing proofs based on sketches.
Self-Evolving: The process involves iterative self-distillation and RL, where the model curates its own high-quality dataset of formal statements, thinking processes, and verified proofs.

C. Hierarchical Importance Sampling Policy Optimization (HisPO)

To stabilize RL training on long-horizon MoE tasks, the authors propose HisPO, an improvement over Group Relative Policy Optimization (GRPO).

Gradient Masking: It addresses Train-Inference Discrepancy (differences between the training engine, e.g., Megatron, and inference engine, e.g., vLLM) and Policy Staleness (data generated by older policy versions).
Mechanism: It calculates Importance Sampling (IS) ratios at both sequence and token levels. If the discrepancy exceeds a threshold ( $\delta_{seq}$ or $\delta_{tok}$ ), the gradient contribution for that sequence or token is masked (set to zero).
Legality Detection: To prevent reward hacking, they introduced a lightweight lexer/parser to convert Lean code into Abstract Syntax Trees (AST). This checks for semantic consistency, ensuring the proof matches the theorem's definition and does not use "cheating" tricks like tampered axioms or global variables.

3. Key Contributions

LongCat-Flash-Prover Model: A state-of-the-art (SOTA) open-weight MoE model (560B params) that unifies general reasoning with native formal reasoning capabilities.
Native Formal Reasoning Paradigm: A new definition and framework treating auto-formalization, sketching, and proving as integrated, composable agentic capabilities rather than separate tasks.
Hybrid-Experts Iteration Framework: A novel data synthesis pipeline that leverages specialized experts and tool feedback to generate high-quality, verified training trajectories.
HisPO Algorithm: A stable RL optimization strategy specifically designed for MoE models in long-horizon tasks, mitigating training instability caused by engine discrepancies and policy staleness.
Robust Reward Mechanism: The introduction of AST-based legality detection to eliminate reward hacking, ensuring models learn genuine mathematical proofs rather than exploiting evaluation loopholes.

4. Experimental Results

The model was evaluated on multiple benchmarks, demonstrating significant improvements over existing open-source and proprietary models.

Auto-Formalization:
- Achieved 100% on MiniF2F-Test and ProofNet.
- Outperformed all open-source auto-formalizers and matched or exceeded proprietary models (e.g., Claude-Opus-4.5, Gemini-3 Pro).
- TIR strategy improved performance by up to 14%.
Theorem Proving:
- MiniF2F-Test: Achieved 97.1% pass rate with only 72 inference attempts per problem (Pass@72), significantly outperforming baselines like Goedel-Prover-V2 and Kimina-Prover-72B which required >1000 attempts for similar scores.
- PutnamBench: Solved 41.5% of problems (Pass@220), a massive leap over the previous SOTA (Goedel-Prover-V2-32B at ~8.6%).
- MathOlympiad-Bench: Achieved 35.8% (Pass@32), a 25.5% improvement over the previous best open-source model.
- Sketch-Proof Mode: The "Sketch-Proof with TIR & Tree Search" mode showed the highest efficiency, proving that decomposing problems into lemmas significantly aids solving complex theorems.
General Reasoning:
- The model retained strong general reasoning capabilities (STEM, coding, agentic tasks), performing comparably to its predecessor (LongCat-Flash-Thinking-2601) on benchmarks like AIME-25 and GPQA-Diamond, with only a negligible drop in performance.

5. Significance

Bridging the Gap: LongCat-Flash-Prover demonstrates that open-source models can surpass proprietary models in specialized formal reasoning tasks when equipped with advanced agentic frameworks and stable RL training.
Efficiency: The model achieves SOTA results with drastically lower inference budgets (e.g., 72 attempts vs. 1024+), making formal verification more accessible and cost-effective.
Safety and Reliability: By addressing reward hacking through AST-based legality checks, the work ensures that the "intelligence" gained is genuine mathematical reasoning rather than exploitation of evaluation metrics.
Community Impact: As an open-source release, it provides a robust foundation for the community to build upon, potentially accelerating research in automated theorem proving, formal verification of code, and the development of AGI systems capable of rigorous logical reasoning.