GAR: Generative Adversarial Reinforcement Learning for Formal Theorem Proving
Authors: Ruida WANG
Jiarui Yao
Rui Pan
Shizhe Diao
Tong Zhang
Venue: ICLR 2026 Poster (2026)
Keywords: Lean4
Reinforcement Learning
LLM
Primary area: foundation or frontier models, including LLMs
TL;DR: This paper proposes GAR, a comprehensive RL training famework for Lean4 prover training that enables more efficient and effective RL training by adversarial training of both statement composer and theorem prover.

Abstract: Solving math problems through verifiable languages such as Lean has significantly impacted both the mathematics and computer science communities. Current state-of-the-art models are often trained with expensive online Reinforcement Learning (RL) or expert iteration. However, these approaches rely on fixed problem sets, which causes inefficient training and limits the model to tackle complex problems. To overcome these limitations, we propose **GAR**: *Generative Adversarial Reinforcement learning*, a comprehensive RL training framework that jointly trains the problem composer and solver in an adversarial loop. **GAR** introduces an implicit curriculum learning mechanism, which aligns task difficulty with the prover's evolving capability. It thereby improves the training efficiency and enables stronger performance of proving advanced theorems. Experiments show that with **GAR** training, Goedel-Prover-V2-8B and DeepSeek-Prover-V2-7B achieve an average relative improvement in pass@32 of **4.20%** on MiniF2F-Test benchmark, while DeepSeek-Prover-V2's pass@32 on ProofNet-Test increases from 22.58% to **25.81%**. Beyond formal proving, **GAR** establishes a general RL paradigm for co-evolution of problem generation and solving under verifiable environments. The training code for this paper is open-sourced in [https://github.com/RickySkywalker/GAR-Official](https://github.com/RickySkywalker/GAR-Official)

Published as a conference paper at ICLR 2026
GAR: GENERATIVE ADVERSARIAL REINFORCEMENT LEARNING FOR FORMAL THEOREM PROVING
Ruida Wang'. Jiarui Yao', Rui Pan', Shizhe Diao?, Tong Zhang!
Uniiersstty of Illinois Urbana- -haama-haamp,inn ?NVIDIA (ruidaw, jiarui14, www.preilliiiissss..... shizhe. wiaeeeeeaaaamaammmcmoommm. com torgzhanggetogggzaangg ml. org
ABSTRACT
Solving math problems through verifiable languages such as Lean has signifi- cantly impacted both the mathematics and computer science communities. Cur- rent state-of-the-ar models are often trained with expensive online Reinforcement Learning (RL) or expert iteration. However, these approaches rely on fixed prob- lem sets, which causes inefficient training and limits the model to tackle com- plex problems. To overcome these limitations, we propose GAR: Generative Adversarial Reinforcement learning, comprehensive RL training framework that jointly trains the problem composer and solver in an adversarial loop. GAR introduces an implicit curriculum learning mechanism, which aligns task diffi culty with the prover's evolving capability. It thereby improves the training ef- ficiency and enables stronger performance of proving advanced theorems. Ex- periments show that with GAR training, Goedel-Prover- V2-8B and DeepSeek- Prover-V2-7B achieve average relative improvement in pass @ 32 of 4.20% on MiniF2F-Test benchmark, while DeepSeek-Prover-Ve V2'ss pass@32
on ProofNet- Test increases from 22.58% 25.81%. %. Beyond formal proving, GAR estab- lishes a general RI. paradigm for co-evolution of problem generation and solving under verifiable environments. The training code for this paper open-sourced
INTRODUCTION
The capability to perform formal mathematical reasoning has long been regarded as both hallmark of human intelligence and key objective of machine learning (Newell & Simon 1956). The ability is typically assessed through rigorous mathematical derivations (Yang et al.
2024b). With the emer-
gence of Large Language Models (LLMs), developing accurate and reliable reasoning has become an active area of research. Recent progress in ZERO RL training (Guo et al.
2025) has further ad-
vanced reasoning systems by introducing Long Chain-of-Thougse (Co'T) thinking models that have self-reflection and self-correction capability.
However, the inherent ambiguity of Natural Language (NL) makes it challenging verify inter- mediate reasoning steps. This problem is more severe in advanced mathematics, where the task to prove theorems rather than give a numerical or formulaic answer. The increasing complexity of modern math compounds this difficulty, illustrated by the prolonged verification of Fermat's 's Last Theorem (Wang al.) 2024). To address this issue, researchers have grounded reasoning in formal logical systems, enabling automatic verification through Formal Language (FL.). Based on this idea, some researchers model the reasoning process formally with dependent type languages like Lean (De Moura al. (2015] Moura & Ullrich 2021 and Coq (Coq 1996). Other uses higher- order logic to build language like Isabelle (Paulson 1994) and HOL (Harrison) 2009). All the above languages make every intermediate step of math reasoning verifiable.
Nevertheless, mastering FLs requires considerable expertise, particularly in dependent-type systems like Lean, where proofs often demand complex type matching and the use of functions with limited data (Wang et al. 2023c). Thus, many works have sought to leverage advances in LLMs to solve
FL problems and train specialized FL. provers (Polu et al. 2022 Jiang al. 2022 Xin et al. 2024a

---

Published as a conference paper at ICLR 2026
Statement Fusion
Statement
dege out vie an der the
Fraual Stitement
the pntrr
wan cnd der
NL Staterment Repo
Statement Fuser
Stsleneui
Nu becoree
all ael todked
Fuel the
atl decoie de tee on andltwe
Statenert
PPProf 2- Pooof
NEE
Trod ye Proff
Traiff
Prover
teardeat cnteraaaaan pav tarttaaamt you
formalizer
Pr-Pred
Phoof
Proof Writing
(a) Generation Stage
Minimize pass rate barder theorem
Prover format
Prover correciness reward
Fuser correcnness reward
Fuser format
Theoenn 2
Theeean
Statement Fuser
Prover
GRPO Training
Thaarsr N-2
GRPO Training
N-1
Tard to Beniees
Maximize pass rite by better proofs
(b) Adversarial Reinforeement Learning Stage
GAR Training Framework: Each iteration of GAR consists two stages. (a) Generation Stage: Pairs of NL statements are sampled from the base repository and combined by the state- ment fuser to create more challenging problems that fit the current model's capability. Then, these statements are autoformalized and submitted to the prover to write multiple proofs. Subsequently, the proofs checked by the Lean verifier for reward assignments. (b) Adversarial Reinforcement Learning: The prover is rewarded for producing correct proofss on medium and high- high-diffculty state- ments, while the statement fuser is rewarded for generating harder but solvable problems. This adversarial dynamic drives both models to evolve together.
Figure 1:
Wang et al., 2024 Lin et al. 2025a Dong & Ma 2025b). The verifiability FLs also motivates
large-scale synthesis of new statements, which enables extensive expert iteration (Polu 2022
Xin et al.) 2025) or Reinforcement Learning (RL) (Ren et al. 2025 Wang et al. 2025a Lin et al.
2025b) further enhance perver's performance.
However, most prior approaches RL. or expert iteration rely on fixed theorem statement sets and optimize only the prover. The statement dataset is unchanged during the process. It also leads to wasted computation on trivial or unsolvable tasks. In expert iteration, datasets often require repeated annotation. On the other hand, advanced RL methods suffer from the absence of adaptive difficulty level of statements during rollouts, which restricts concentrated exploration and limits progress on complex theorems. More broadly, only a few works discuss a systematic way align problem difficulty with the prover's growing skill.
Generative Adversarial Reinforcement Learning, comprehensive RL training framework as presented in Figure GAR jointly optimizes the prover and the problem composer, termed as the statement fuser, through adversarial training. This process establishes an implicit curriculum learning that dynamically adjusts statement difficulty to match the prover's development. Each iteration of the GAR framework consists of two stages: the gener- ation and the adversarial RL stage. In the generation stage, the statement fuser synthesizes harder statements from existing solvable ones, and the prover attempts to solve them. In the RL training stage, the fuser is rewarded for producing difficult yet solvable statements, while the prover is
To address this limitation, we propose GAR:
2

---

Published as a conference paper at ICLR 2026
warded for correctly proving medium and high-difficull problems. This adversarial setup ensures that statement complexity evolves alongside the prover's ' capabilities, resulting in more efficient and effective training.
We summarize our contributions as follows: (1) We introduce GAR, a comprehensive RL training framework that establishes implicit currieulum learning, improving the prover's reasoning ability while preventing wasted effort on trivial or unsolvable statements. (2) We present Statement Fusion technique, which enables the creation of novel formal statements beyond direct formalization of NL problems, producing theorem statements better aligned with model capability.
(3) We demonstrate the effectiveness of the GAR through extensive experiments by training two base models using GAR. We achieve an average of 4.20% % relative improvement on MiniF2F-Tess (Zheng et al., 2021 and raise DeepSeek-Prove Prover-8B" pass rass@32 @32 on the more challenging ProofNet-Test (Azerbayev al. 2023 from 22.58% to 25.81 %. It highlights the effectiveness and generality of GAR.
Furthermore, the GAR contributes a general RL paradigm for the co-evolution of problem genera- tion and solving in verifiable environments, which offers new directions for adversarial co-training other reasoning-intensiee domains. To facilitate the advancement of the field, we will open-source the training and inference code of GAR in the near future.
2 METHODOLOGY
In this section, we introduce the GAR framework in detail. The prover's task is to produce Lean4 proofs from NL-FL statement pairs. Our framework trains the prover to improve the task by adapting theorem difficulty to the prover's evolving capabilities through adversarial training of both the prover and the statement fuser. Each iteration of GAR consists of two stages: the Generation stage (Section 2 and the Adversarial Reinforcement Learning stage (Section 2.2 We first de- scribe the behavior of each stage in a single iteration in detail, then present the complete procedure in Section 2.3
2.1
GENERATION STAGE
The generation stage of GAR consists of two processes, namely statement fusion, which produces new statements, and proof writing, which generates and evaluates candidate proofs.
2.1.1
STATEMENT FUSION
This process generates harder statements from existing ones. It aims to mitigate the mismatch be- tween the fixed datasets and the prover's evolving ability. This process first samples two NL state- ments from the base dataset, formally: Sbase = (s) (N.). .s2 (NT.)) ~ Dstats where D stat is a repository consists of 793,243 NL statements collect from Lean- Worn-ook (Wu et al. (024b) and Numina- Math (LI et al. (024). The sampled pair is then passed to the statement fuser trained in the previous iteration of GAR. The fuser is instructed synthesize more challenging statement by combining the key ideas of the two inputs, namely:
(NL) Fuser:-1 (Stase)
where i denotes the current iteration index, (NL) is the generated NI. statement, and Fuser;-1 the fuser from the prior step (initialized base model when i 0).
In particular, we chose thinking models like Qwen3 (Tem 2025) or DeepSeek-RI (Guo et al. 2025) as the base model for the statement fuser because of its outstanding performance. However, direct use of their native Long CoT capability often results in overthinking and degraded quality of the generated statement. To mitigate this, reinitialize the thinking process by passing the default thinking stage and restarting it with a dedicated indicator token named <analysis>. This trick yields more focused and task-specific reasoning. The full prompt for the statement fusion is shown in F Subsequently, the generated NL statement is passed to the autoformalizer, which converts the NL statement into Lean statement s(FI)) The formalized statement is then passed to Lean4 for compilation check. This step filters out statements with grammatical errors.
In the statement fusion stage, they deliberately separate the fusion of NL statements from the formal- ization of FL statements. Two key insights guide this design. First, prior studies (Wang al. 2024
3

---

Published as a conference paper at ICLR 2026
You an expert mathematics educator skilled in problem design. Your task is combine multiple given problems into a SINGLE, more challenging problem by combining their key elements. Follow these steps: Please first do the following steps your analysis process enclosed within <analysis><<annllysis
1. Analyze the points of knowledge that need be used when solving the proof problem and identify overlapping or complementary aspects (c.g., shared topic areas or contrasting difficulty levels).
2. Draft the new problem that integrates at least 2 key components from each original prob- lem and make sure the new problem requires multi-step reasoning (e.g., combining alge- braic manipulation with probabilistic analysis). Also, your combined problem should have no non-trivial extension.
3. Additionally, you should make sure that the new problem is solvable.
After your analysis. you should put the new problem into an MD code block. The new prob- lem should be a SINGLE proof problem. Here are the statements you need to fuse:
Problem 1: <statement_1> Problem <statement_2>
Figure Prompt for the Statement Fuser to generate harder statements from existing ones and restart thinking using new indicator in GAR generation stage
Xin al. 2024b) have shown that NL statements play crucial role in supporting formal reasoning.
Secondly, current 8B-scale general LLMs exhibit only a limited understanding of FL.. This causes them to fail to capture essential relations, which hinders the generation of more robust statements. Consequently, the fuser produces statements that have a high likelihood of failing the compilation check if we directly fuse formal statements, as seen Dong Ma (2025b). Thus, GAR firstly fuses the statement in NL and formalizes it to FL, ensuring the fused statements are adaptively more challenging than the base problems to prover performance evolution.
2.1.2 PROOF WRITING
Utilizing the NL-FL statement pair generated by the fusion process, the prover from the last iteration generates n candidate proofs (with n 16 our implementation), denoted as (ox } specifically:
Ok (s s s(FL)), Ak [1,n]
When 0, is the base prover model like deepSeek-Prover-Ve (Ren et al. 2025) or Goedel-
Prover-Vo V2 (Lin et al. 2025b).
The set of candidate proofs {ou is then passed to the Lean4 verifier to check correctness. Based on the verification results, compute the empirical pass rate of this statement for reward assign- ment as p
Spase where Npass is the number of proofs that pass verification.
2.2 ADVERSARIAL REINFORCEMENT LEARNING
This section outlines the training process of GAR, where the prover and statement fuser are opti- mized competition, deriving adversarial learning and mutual improvement.
2.2.1 STATEMENT FUSER TRAINING
The statement fuser is trained to synthesize problems that are slightly beyond the prover's 's current ca- pability, thereby creating an implicit curriculum. To achieve this, we assign rewards to the generated NL statements that encourage the production of more challenging but solvable problems. We adopt a variant of Group Relative Policy Optimization (GRPO) (Shao et al. 2024) for this optimization. Specifically, for each step i, the fuser generates N statements (with N 1024 in our implementa-
tion). Formally, generated statement set is: { (NL)) N
{.) j=1
and base statement set is represented as:
(base) = ( 8 the following objective.
(NL) 8, }}/r
The statement fuser Fuser;-1 is then updated by maximizing
4

---

Published as a conference paper at ICLR 2026
TGrro
T(P)
(0) =E
{
(bare) Dieani {ol (NL) ois
( No (o)
)=
min (0
(olatat) (stat) clip s(star) 1 + { A A
Aid
3D 3D ( (=ol(TTer)))
N
(1)
LN (base)
To
8) s(stat)
(2)
(NL) (base)
#Buld
(NL) (base)
(NL) (base)
Torat
Sij
8i
(KI(Fol(TO...)
log
(3)
(NL) (base)
(NL) (base)
j.j
iij
[.j
where Te denotes the policy model with parameter 0. It represents the statement fuser here. Oref is the parameter for base statement fuser, Ood is the parameter for the fuser in the previous step, e and are hyper-parameters, and As, is the advantage, computed from the reward set r.
(stal)
(otat) No by:
fris f==1
(stat) mean(r! (stat)) std (stat))
A(sat)
1.
(stat) i.j
(1 (1-Pi.)) - (1- (mm.))-160 Hpss (1
#0}
(FL) and m.j is the statement modification rate, where Pt, is the prover's empirical pass rate on s itj which indicates the portion of proofs that the prover tries modify its statement. The reward is set to if the prover fails to solve the problem, which indicates the statement is too difficult or unsolvable.
We introduce the term - mi,j as a soft statement modification penalty to balance the risk between reward hacking and the need to preserve model capability. Because of Long CoT training, current expert provers often acquire strong self-correction capability. While valuable, this ability can lead the model change formal statements during proof writing. This may lead serious reward hack- ing if unconstrained. Conversely, a strict ban on such modifications would suppress self ceff-correction and reduce proofreading accuracy. Our soft penalty discourages excessive statement change without too much harm to the result.
In summary, the training design for the statement fuser rewards the model to lower the prover's 's pass rate by composing more challenging statements.
2.2.2 PROVER TRAINING
To achieve adverasrial training, the prover is optimized to maxmize the pass rate on generated state- ments. We employ variant of the GRPO algorithm for such training. Specifically, for each theorem statement $i, = (s $i
(NL) (FL)), we update the prover model Prover;-1 by maximizing the fol-
lowing objective function:
T!P [[onsa)) - Foaa (815))
(5)
min
(((r) (pr) Cifi k clip
(((r) iiikk 1 + E 1 Ang.
AT KL (IlTTllTTmmm)
8 g(proof) A.j.k
Twa (or (8(.)
(6)
Tarny (Di.j.k(
where Tw is the prover as policy model, the parameter of prover, and Aej, is the advantage of proof oij,k. computed from the reward set r.,
(proof) (proof)
(reg, =k=1 by:
y (proof) mean( r [.j
(proof))
A (proof) Li.k
(proo()) std(r
Tajik
0.5 mij.k
5

---

Published as a conference paper at ICLR 2026
where mijik is binary indicator of whether statement modification occurred in proof oi, Similar to the training of the statement fuser, modifications are penalized but not strictly prohibited. Furthermore, to ensure the prover is trained on high-qualin data, exclude statements with an empirical pass rate O (unsolvable) or above 0.5 (too easy) following experience in Wang et al. (2025a); Dong & Ma (2025b). It make sure the prover only trained with hard and medium- level problems. This optimization scheme drives the prover to compete with the statement fuser by continually enhancing its genoraeneratinn capability.
2.3
SUMMARY
The GAR is an iterative framework (Wang et al. 2023) that loops the generation stage and the RL stage details above. To provide a clear overview, we present the complete framework in the form of pseudo-code as follows:
Algorithm GAR
Require: Detat, Statement Fuser (base) as Fuser, Prover (base) as Prover, Autoformalizer as AF Fuser
Twi Tuatar Twres Prover; Te, Toaia T0...
2: for i: [] do
Step of GAR
3:
{ 1jml ~ Dstat
(base) N
> Sample base statements
fo (NL) TT( (base) N
4:
1jm1
> Fuse NL statements
{ (FL) ~ AF((S (NL))
5:
11 Si 1=
D Autoformalize statement
{si.j = (NL) (FL)
6:
7:
for j: [1, M] do
8:
for (st.)) Obtain Pt.j Mijj by Lean checking of proofs
> Generate proofs
9:
T Te.ta Optimize(TTcpp (0)
Train NL Fuser
11:
Twold +- Optimize( (J
Train Prover
return 20: Aw
When trained in multiple iterations, the GAR establishes an implicit curriculum by aligning state- ment difficulty with the prover's evolving capability. The statement fuser is trained reduce the pass rate by generating more challenging statements, while the prover is optimized to increase it by producing more valid proofs. Together, their adversarial interaction drives progressive improve- ment.
3 EXPERIMENTS
We conduct comprehensive experiments on the MiniF2F-Test (Zheng et al. 2021) and ProofNet- Test (Azerbayev al. 2023) benchmarks assess the performance of the GAR framework in for- mal proof writing. Specifically, we show in Section 3.3 that the models trained with GAR achieve better empirical results, confirm in Section 3.4 that adversarial training induces an implicit curricu- lum by generating progressively harder statements, and report ablation study results in Section 3.5 Due to space limitations, we have included the efficiency study and case study in Appendix D
3.1 EXPERIMENT SETUP
3.1.1 DATASET AND TASK
We measure the Lean4 reasoning capability of the GAR trained model by MiniP2F-Teas (Zheng
ctt al. (022]) and ProfNet-Test (Azerbayev et al. (003) benchmarks. They are challenging bench-
marks and adopted in nearly all major studies in the field (Xin et al. 2024b Lin et al. 2024
Wang
et al. 2024; Wu et al. 2024a Polu et al. 2022 Dong & Ma 2025a Lin et al. 2025b
Wang et al.
2025c).
The MiniF2F-Tes benchmarks comprise 244 Lean4 statements, spanning from high school com- petition problems to elementary undergraduate--lveè theorem proofs. Specifically, MiniF2F-Test

---

Published as a conference paper at ICLR 2026
Table 1: Main experimental results of GAR trained models compared recent provers models.
Method
Sample budget
MiniF2F-Test
ProofNet-Test
Lean-STaR (Lin et al.
2024)
64 x x 50
46.31% %
Wu al.
2024a
4 32 x 600
50.70%
18.80%
(Xin et
2024b
128
50.00%
18.20%
STP-Lean (Dong Ma 2025b
128
56.15%
19.50%
MA-LoT Waag et al. 2025c
32
61.07%
15.47%
Simina--rovvr-Disttl-- Wang et al.
2025a
32
63.10%
DeepSeek-Prover-Ve V2-7B [Ren et al.
2025
32
70.49%
22.58%
GeodellPrrove--2-88k (Lin
2025a
32
77.87%
Our models
GAR on Prepseek-Prover-22
32
74.18 %
25.81 %
GAR Vo
32
80.33 %
Table 2: Average proof correctness rate for Poodel-Prover--2-333 (base model) and GAR model trained on base model.
Table 3: Statement modification rate for drop- ping statement modification penalty and full GAR trained models.
Step idx
Base Model
GAR model
Step idx
w/o Stat. Penalty
Full GAR
29.16%
29.16%
42.94%
42.94%
I
16.50%
23.71%
48. 48.18%
48.72%
2
11.58%
20.53%
60.42%
30.50%
7.61%
20.08%
71.82%
39.65%
7.69%
21.79%
74.11%
33.63%
comprises problems formalized from the MATH dataset (Hendrycks et al. 2021), high school com- petitions such AMC, AIME, and IMO, as well as self-crafted problems. ProofNet-Tess consists of 186 theorems formalized from standard undergraduate textbooks on advanced topics such as real and complex analysis. linear algebra, abstract algebra, and topology. In our setting, train the L.M with GAR R to generate Lean4 proofs from the NI-FL statement pair. To avoid overloading the model, all the imports and namespaces manually configured.
3.1.2 BASELINES
To evaluate the effectiveness of GAR. compare it against strong open-source baselines, including Lean-STaR (Lin et al. 2024), IntermL--22.--SeepProee (Wu et al. (024a)). Simina-Provee--reeve (Xin al. 2024b), STP-Lean (Dong & Ma 2025a). MA-LoT Wang et al. 2025c). Goedel-Prover- V2 (Lin et al. 2025b), and DeepSeek-
Distill-7B (Wang al. 2025a). DeepSeek-Provee Proveee--ooooo---5----R
Prover- V2 (Ren al. 2025). For baseline models that require Long CoT reasoning (Kimina-Prover Prover,
MA-Lo'T, DeepSeek- Prover-V2 V2, and Goedel-Provee V2), we restrict the reasoning length to 16,384
tokens to conserve computational resources
3.2 IMPLEMENTATION DETAILS
In the generation stage, we construct a repository of 793.243 33 NL statements from Numina-Math (Li ctt al., 2024) and Lean-Workee Workbook (Ying et al. 2024) datasets. For statement fusion, we employ Qwen3-8B TTem 2025) as the base model for the statement fuser because of its skip-thinking capability. We apply Aumina-Auuoformmaiize---7 (Wang et al. proof generation, we use DeepSeek Prover- V2-7B (Ren al. 2025) and Goedel-Prover-VV (Lin) al. 2025b) as base models for provers. We sample 1,024 theorems per step and generate 16 proofs per theorem following (Wang et al. 2025a). We also restrict the sequence length to 16,384 tokens for both models. The GRPO hyperparameters
2025a) as the autoformalizer. For
with learning rate of 2E-6, = 0.01. We perform three itcrations of GAR training on Goedel-Prover- V2 and five itcrations on DeepSeek-Prover-VV V2, which costs around 140 H100 hours for each training. On average, DeepSeek- Prover- V2 costs fewer hours per iteration due to average shorter thinking. In verification, any proof
0.2, and
Becauue of this restriction, reported results for DeepSeek-Provert V2 and Goovel-Prover-VV differ from those in the original papers, where the evaluations used context length of 40,960.

---

Published as a conference paper at ICLR 2026
involving statement modification relying on the "sorry" or "admit" tactic is counted incorrect to ensure fairness.
3.3 RESULTS
Table demonstrates the empirical results of applying GAR to train base prover models. For Goedel Prover- V2, MiniF2F- Test @ass@32 raises to 80.33%, indicating a 3.16% relative gain. For SrepSeek-Prover-Ve the MiniF2F-Test score improves to 74. 18%, corresponding to a 5.23% in- crease. On the challenging ProofNet-Test benchmark, which targets advanced mathematics PereSSeek-Povee--Vee pass@ 32 rate from 22.58% to 25.81 %
topics, GAR enhances
Compared with other baselines, both the base model and the Arained models achieve consistent and substantial gains, highlighting that GAR can contribute to models that already have outstanding performance. Compared to base models, the improvements suggest that the adversarial method pro- posed in GAR enables provers to tackle increasingly difficult problems by establishing an implicit curriculum. Such curriculum can progressively adapt problem difficulty to the model's capability, allowing the prover to explore deeper reasoning strategies and solve more advanced theorems. This behavior becomes more significant as the theorems get harder.
3.4 STATEMENT FUSER STUDY
To show that GAR produces increasingly more difficult statements across iterations and thereby establishes an implicit curriculum learning. we examine the difficulty of problems generated by the statement fuser. In each iteration, we randomly sample 50 generated statements and compute their average proof correctness rate using both the base prover and GAR-trained prover at that iteration. Details of the metric we used are provided in Appendix B.2 The result this experiment is reported in Table
From the results, we can observe that the base model exhibits a consistent performance degradation, with accuracy falling from 29.16% at the first iteration's data 7.69% by the fifth. In contrast, the G-R-traieed model shows only a minor initial decline due to the statement matching but stabilizes at around 21% across later iterations. These findings confirm that GAR progressively generates harder statements, as evidenced by the base model's 's decline. The maintained trained model's performance demonstrates the adversarial training strength of the prover's performance over time.
3.5
ABLATION STUDIES
3.5.1 EFFECT OF STATEMENT MODIFICATION PENALTY
We evaluate the impact of the statement modification penalty by monitoring statement mod- ification rates across by the provers during training rounds. Details of this metric are pro- vided in Appendix B.3 We trained a variant of GAR on Goedeel-rrove--2-88 without the penalty in both the statement fuser and prover, and compared it with the full GAR. Table shows that without the modification penalty, the prover exploits its self-correction ability by simplifying statements. Such behavior worsens as the training pro- mod-
Table 4:
Pass 32 results MiniF2F. Test for Boedee-Prrove--2--8- and its GRPO and GAR trained version.
gresses; by the fourth step, 74% of statements ified at least once, which is a clear signal of reward hack- ing. In contrast, with the penalty enabled, the modifi- cation rate remains below 40% throughout. This study confirms the effectiveness of our statement penalty in pre- venting reward hacking.
Method
MiniF2F-Test
Base model
77.87%
GRPO trained
77.46%
GAR trained
80.33 %
3.5.2 COMPARE TO DIRECT RL TRAINING
This experiment tests whether jointly evolving the prover and statement fuser is more effective than training the prover alone using existing data. We conducted three additional GRPO iterations on
We do not report Gnedel-Prrver-V22 accuracy on ProofNet due to the absence of the reference results in Lin al. 2025b).
8

---

Published as a conference paper at ICLR 2026
Goedel-Prover- V2-8B using the same sampling budget and formalized NL base dataset as GAR. The results are shown in Table [ The GAR-tained model outperforms the variant trained with traditional GRPO. We conclude that such an improvement to GAR progressively raises problem difficulty, enabling the prover to handle more complex statements. In contrast, further RI. training on static dataset degrades performance, as the base model is already heavily RL trained. These findings further support the generality of GAR, demonstrating is ability to enhance model's performance while standard RL longer provides benefits.
4 RELATED WORK
4.1 LLM FOR FORMAL THFOREM PROVING
Recently, applying LLMs to support formal theorem proving has become a prominent research direction. Training approaches can be broadly divided into two categories: model trained solely with Supervised Fine-Tuming (SFT) and those combining SFT with Reinforcement Learning (RL). Early SFT-based provers include Expert Iteration (Polu Sutskever 2020). Re-Prover (Yang al,, 2024c). TaeoremL.ama (Wang et al.) 2024). DeepSeek- Prover- VI (Xin et al. 2024a). InternLM 2.5-StepProver (Wu et al. 2024a). MA-LoT (Wang et al.) 2025c), and Groedel-Provers V1 (Lin et al.) 2025a). These models typically require multiple rounds of large-scale annotation with existing for- mal solvers, which demands a significant amount computational resources and limits exploration. To further advance the prover, researchers began incorporating advanced RL techniques. For in- stance, PrepSeee-Prover-V1
(Xin et al.] 2024b) employs DPO. After the "ZERO" RI. technique that enables Long CoT thinking developed by Guo et al. (2025), provers like Kimina-Prow Provvrr (Wang) et al. 2025a). DeepSeek-Prover-VV (Ren et al.) 2025). and Goedel--rover-V V2 (Lin et al.) (025b) enable models to produce better formal proof after thinking. However, existing RL approaches still rely on a fixed collection of statements, preventing statements from adapting to the prover's evoly- ing skill. In contrast, GAR jointly trains a statement fuser and a prover, ensuring that generated theorems remain suitably challenging as the model improves.
4.2 RL METHODS FOR LLM
RL has been central to the development of reasoning L.MSs (Xiong al. 2025). Early efforts such as DeepSeek-Mait (Sha et al. (2024) and Qwen-2.5-Math YYagg et al. (022a)) applied reward mod- cling with GRPO algorithm to enhance exploration. The release of OpenAl-O1 (OpenAl 2024) and DeepSeek-RI (Guo et al.) (025) demonstrated that verifier-based rewards in RL can enable complex reasoning strategies, including backward search and self-correction. Such techniques have been widely adopted in systems like Qwen3 (Team, 2025) and Kimi-K2 (Team et al., 2025). Neverthe- less, nearly all prior work uses the verification signal only optimize the problem solver, leaving the problem composer untrained. On the other hand, GAR simultaneously improves both statement fuser and the prover, creating an implicit curriculum that adapts task difficulty and allows the model to acquire more complex reasoning skills step-by-ster sts-pp.....
CONCLUSION
This paper presents GAR, a comprehensive training framework for formal theorem proving. GAR aims resolve the inefficient and suboptimal performance caused by traditional expert iteration and online RL in prover training. GAR achieves more efficient training by using statement fusion to formulate statements in the RL process to avoid the prover from annotating problems beyond its capability range. After GAR training, provers can solve more advanced problems through the im- plicit curriculum learning that enables the model explore further. Furthermore, GAR can improve the performance of models that have been through heavy RL training by letting the model explore more difficult statements during the training process. Experiments of applying GAR to DeepSeek- Prover-V2 and Goedel-Prover-V V2 yield an average relative improvement of 4.20% on the MiniF Test dataset and improve the TrapSeek-Proverr V2'ss performance on ProofNet- Test from 22.58% to 25.81 %. Beyond theorem proving, GAR offers general RL paradigm of co-evolution of the prob- lem generation and solving under a verifiable environment. It provides a foundation for adversarial co-training in other iasoninn-intensive domains.

---

Published as a conference paper at ICLR 2026
ETHICS STATEMENT
After carefully reviewing the ethical regulations of the conference, to the best of our knowledge, this work does not present any foreseeable ethical concerns. This research focuses exclusively formal theorem proving using publicly available mathematical datasets, without involving human subjects, private data, or sensitive content. As far are concerned, no negative societal or ethical impacts are anticipated for the contribution of this work. We only use LLMs to polish the writing style and fix grammatical errors in the paper.
REPRODUCIBILITY STATEMENT
We have made efforts ensure that our work is reproducible. The detailed description of the GAR framework, including pseudocode, data source, reward definitions, and training objectives, is pre- sented in Section The experimental setup, including benchmarks, baselines, base model choice, and hyperparameters, is presented in Section 3.1 and Section 3.2 We also plan to further ensure the reproducibility by open-soureing the code in the near future.
REFERENCES
Zhangir Azerbayev, Bartosz Piotrowski, Hailey Schoelkopf, Edward W Ayers, Dragomir Radev, and Jeremy Avigad. Proofnet: Autoformalizing and formally proving undergraduate-level mathemat- ics, arXiv preprint arXiv:2302. 12433, 2023.
Projet Coq. The coq proof assistant-reference manual. INRIA Rocquencourt and ENS Lyon, version, 5, 1996.
Leonardo De Moura, Soonho Kong, Jeremy Avigad, Floris Van Doomn, and Jakob Raumer. The lean theorem prover (system description). In Automated DeduucionnCADE:22 25th International Conference on Automated Deduction, Berlin, Germany, August 1-7, 2015, Proceedings 25, pp- 378-388. Springer, 2015.
Kefan Dong and Tengyu Ma. Beyond limited data: Self-play Ilm theorem provers with iterative conjecturing and proving. arXiv preprint arXiv:2502.002/1 00212, 2025a.
Kefan Dong and Tengyu Ma. Stp: Self-play Ilm theorem provers with iterative conjecturing and proving. arXiv preprint arXiv:2502.00211 2025b.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning, arXiv preprint arXiv:2501.1299 2025.
John Harrison. Hol light: An overview. In International Conference Theorem Proving in Higher
Order Logics, pp. 60-66. Springer, 2009.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874 2021.
Albert Q Jiang, Sean Welleck, Jin Peng Zhou, Wenda Li, Jiacheng Liu, Mateja Jamnik, Timothée Lacroix, Yuhuai Wu, and Guillaume Lample. Draft, sketch, and prove: Guiding formal theorem provers with informal proofs. arXiv preprint arXiv:2210.12283. 2022.
Jia LI. Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, Shengyi Costa Huang, Kashif Rasul, Longhui Yu, Albert Jiang, Ziju Shen, Zihan Qin, Bin Dong. Zhou, Yann Fleureau, Guillaume Lample, and Stanislas Polu. Numinamath. [https: http:///hhgggngag/eee (attps:// ctt. wttp:ttwwww..cmooooo...ttteea cttp:///pppppttttnniaaaaaaaaaaa numina/ 2024.
c0 Boo/AI-MO/AummiaMMathh-aha
aimo http::/pwooaeeesspppaaaaaaaooooa
numina dataset. www.iinnnnininnnnnnnnnnn
Yuxin Li, Minghao Liu, Ruida Wang, Wenzhao Ji, Zhitao He. Rui Pan. Junming Huang, Tong Zhang, and Yi R Fung. Lean4physics: Comprehensive reasoning framework for college-level physics in lean4, arXiv preprint arXiv:25/0 20.2094, 2025.
10

---

Published as a conference paper at ICLR 2026
Haohan Lin, Zhiqing Sun, Yiming Yang, and Sean Welleck. Lean-star: Learning to interleave thinking and proving. arXiv preprint arXiv:2407.10040, 2024.
Yong Lin, Shange Tang, Bohan Lyu, Jiayun Wu, Hongzhou Lin, Kaiyu Yang, Jia Li, Mengzhou Xia, Danqi Chen, Sanjeev Arora, and Chi Jin. Goedel-prover: frontier model for open-source automated theorem proving, 2025a. URL https:://aa.i...o////
07640
Yong Lin, Shange Tang, Bohan Lyu, Ziran Yang, Jui-Hui Chung, Haoyu Zhao, Lai Jiang, Yihan Geng, Jiawei Ge, Jingruo Sun, et al. Goedel-prover-e Scaling formal theorem proving with scaffolded data synthesis and self-correction. arXiv preprint arXiv:2508.0363 03673, 2025b.
Leonardo de Moura and Sebastian Ullrich. The lean 4 theorem prover and programming language. In Automated Deduction-CAND 28: 28th International Conference on Automated Deduction, Virtual Event, July 12-15, 2021, Proceedings 28, pp. 625-635. Springer, 2021.
Allen Newell and Herbert Simon. The logic theory machine-a complex information processing system. IRE Transactions on information theory, 2(3):61-79, 1956.
OpenAL. Learning to reason with llms.
attps://openal cwm index
Learming-to-resson--iiee
September 13 2024. Accessed: 2024-11-24.
Lawrence C Paulson. Isabelle: A generic theorem prover. Springer, 1994.
Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving.
arXiv preprint arXiv:2009.0333 2020.
Stanislas Polu, Jesse Michael Han, Kunhao Zheng, Mantas Baksys, Igor Babuschkin, and Ilya Sutskever. Formal mathematics statement curriculum learning. arXiv preprint arXiv:2202.013444 2022.
77. Ren, Zhihong Shao, Junxiao Song, Huajian Xin, Haocheng Wang, Wanjia Zhao, Liyue Zhang, Zhe Fu, Qihao Zhu, Dejian Yang, et al. Deepseek-prover-tee Advancing formal mathematical rea- soning via reinforcement learning for subgoal decomposition. arXiv preprint arXiv:2504.2180) 2025.
Zhihong Shao, Peiyi Wang. Qihao Zhu, Runxin Xu, Junxiao Song. Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits mathematical reasoning in open language models. arXiv preprint vrXiv2442..03300 2024.
Kimi Team, Yifan Bai, Yiping Bao, Guanduo Chen, Jiahao Chen, Ningxin Chen, Ruijue Chen, Yanru Chen, Yuankun Chen, Yutian Chen, et al. Kimi k2: Open agentic intelligence. arXiv preprint arXiv:2507.20534, 2025.
Qwen Team. Qwen3, April 2025. /tL htt.ggitttt....ooooooooooooeeeee 1o/ www.//////////o....oo....ooooatt qwen3/
Haiming Wang, Mert Unsal, Xiaohan Lin, Mantas Baksys, Junqi Liu, Marco Dos Santos, Flood Sung, Marina Vinyes, Zhenzhe Ying, Zekai Zhu, et al. Kimina-prover preview: Towards large formal reasoning models with reinforcement learning. arXiv preprint arXiv:2504. 1354, 2025a.
Ruida Wang, Wangchunshu Zhou, and Mrinmaya Sachan. Let's synthesize step by step: Iterative dataset synthesis with large language models by extrapolating errors from small models. arXiv preprint arXiv:2310.1367. 2023.
Ruida Wang, Jipeng Zhang. Yizhen Jia, Rui Pan, Shizhe Diao, Renjie Pi, and Tong Zhang. Theorem- Ilama: Transforming anneral-purpose llms into lean4 experts. arXiv preprint 032223340. 2024.
Ruida Wang, Yuxin Li, Yi R Fung, and Tong Zhang. Let's reason formally: Natural-forma hybrid reasoning enhances I1m's math capability. arXiv preprint arXiv:2505.23770: 2025b.
Ruida Wang. Rui Pan, Yuxin Li. Jipeng Zhang, Yizhen Jia, Shizhe Diao, Renjie Pi, Junjie Hu, and Tong Zhang. Ma-lot: collabooolao lean- based long tf-hhuht reasoning enhances formal theorem proving. arXiv preprint arXiv:2503.03205. 2025c.

---

Published as a conference paper at ICLR 2026
Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. Magicoder: Empowering code generation with oss-instruct. arXiv preprint arXiv:2312.02120. 2023.
Zijian Wu, Suozhi Huang, Zhejian Zhou, Huaiyuan Ying, Jiayu Wang, Dahua Lin, and Kai Chen. Intern1m2. S-stepprover: Advancing automated theorem proving via expert iteration on large-scale lean problems. arXiv preprint arXiv:2410. 15700, 2024a.
Zijian Wu, Jiayu Wang, Dahua Lin, and Kai Chen. Lean-github: Compiling github lean repositories for a versatile lean prover. arXiv preprint arXiv:2407. 17222 2024b.
Huajian Xin, Daya Guo, Zhihong Shao, Zhizhou Ren, Qihao Zhu, Bo Liu, Chong Ruan, Wenda Li, and Xiaodan Liang. Deepseek-prover, Advancing theorem proving in Ilms through large-scale synthetic data, arXiv preprint arXiv:2405. /4333, 2024a.
Huajian Xin, ZZ Ren, Junxiao Song, Zhihong Shao, Wanjia Zhao, Haocheng Wang, Bo Liu, Liyue Zhang, Xuan Lu, Qiushi Du, et al. ppepseek-provervee 5: Harnessing proof assistant feedback for reinforcement learning and monte-carlo tree search. arXiv preprint arXiv:2408. 08152, 2024b.
Ran Xin, Chenguang Xi, Jie Yang, Feng Chen, Hang Wu, Xia Xiao, Yifan Sun, Shen Zheng, and Kai Shen. Bfs-prover: Scalable best-first tree search for llm-based automatic theorem proving. arXiv preprint arXhv:2502.03436 2025.
Wei Xiong, Jiarui Yao, Yuhui Xu, Bo Pang, Lei Wang, Doyen Sahoo. Junnan Li, Nan Jiang, Tong Zhang, Caiming Xiong, et al. A minimalist approach to Ilm reasoning: from rejection sampling to reinforce. arXiv preprint arXiv:2504. 1343, 2025.
An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, Keming Lu, Mingfeng Xue, Runji Lin, Tianyu Liu, Xingzhang Ren, and Zhenru Zhang. Qwen2.5-math technical report: Toward mathematical ex- pert model via seff-improvemmnt. arXiv preprint arXiv:2409. 12122, 2024a.
Kaiyu Yang, Gabriel Poesia, Jingxuan He, Wenda Li, Kristin Lauter, Swarat Chaudhuri, and Dawn Song. Formal mathematical reasoning: A new frontier in ai. arXiv preprint arXiv:2412.16075, 2024b.
Kaiyu Yang, Aidan Swope, Alex Gu, Rahul Chalamala, Peiyang Song, Shixing Yu, Saad Godil, Ryan Prenger, and Animashree Anandkumar. Leandojo: Theorem proving with retrieval- augmented language models. Advances in Neural Information Processing Systems, 36, 2024c.
Jiarui Yao, Ruida Wang, and Tong Zhang. Fons-formal answer selection for natural language math reasoning using lean4. arXiv preprint urXiv:2503.03238 2025.
Huaiyuan Ying, Zijian Wu, Yihan Geng. Jiayu Wang. Dahua Lin, and Kai Chen. Lean workbook: A large-scale lean problem set formalized from natural language math problems. arXiv preprint arXiv:2406.0m 03847, 2024.
Hanning Zhang, Ruida Wang. Rui Pan, Wenyuan Wang, Bingxu Meng. and Tong Zhang.
Physprover: Advancing automatic theorem proving for physics. arXiv preprint 251777 2026.
Kunhao Zheng, Jesse Michael Han, and Stanislas Polu. Minif2f: a cross-system benchmark for formal olympiad-level mathematies. arXiv preprint arXiv:2109.001 10, 2021.
12

---

Published as a conference paper at ICLR 2026
A ACKNOWLEDGMENT
This material is based upon work supported partially by NSF under Grant No. 2416897, Grant No. 2505932, and by ORN under Grant No. N000142512318. This research used both Delta (NSF award OAC 2005572) and DeltaAl (NSF award OAC 2320345) advanced computing systems, and computing resources provided by Illinois Computes and NAIRR Pilot NAIRR250157.
B DETAILS OF THE METRICS
For completeness, this section provides the metric definitions that were omitted due to space limita- tions in Section 3
B.1
PASS RATE
Pass @ x is a widely used metric for evaluating formal theorem provers (Polu et al. 2022; Jiang et al,
2022 Wang et al. 2024 Xin et al. 2024a Dong & Ma 2025b Wang al. 2025b Lin et al. 2025b Wu et al. 2024a] Wang et al. [2025a] Li et al. 2025 Yao et al, | et al. 2026]). For each
theorem statement, the model generates e candidate proofs, which are further checked by the Lean4 verifier. If at least one of the x candidates is correct, the theorem is counted as proved theorem. The pass@r x of the LLM the fraction of theorems in the dataset with least one correct proof generated by the prover.
B.2 AVERAGE PROOF CORRECTNESS RATE
This metric measures the relative difficulty of set of statements for given prover, which is used in Section 3.4). Let D a dataset size m. For each theorem t; E D, we sample 16 proofs from the prover and record the number of proofs that pass the verification, which is p;. The average proof correctness rate calculated by
E P
16 mm
A high value indicates the dataset is easier for the given prover.
Note that in this experiment, to demonstrate the significance of GAR better, we train two extra rounds of Goedel--rover-V222 model.
B.3 STATEMENT MODIFICTTION RATE
Since current advanced provers have Long Chain-of-thought (CoT) capability, which enables self- reflection, backtracking, and self correcorrec In the Long CoT process, prover may alter the orig- inal statement into a simplified variant in its reasoning trace and ultimately produce proof for the modified version. To quantify this behavior, we define statement modification rate the portion of theorems in a dataset that have at least one statement modification across generated proofs. This metric helps assess how often the prover attempts to modify the problem and whether such behavior may be too significant to cause severe reward hacking.
C DIRECT COMPARISON WITH RELATED WORKS
This section aims to provide more direct comparison between GAR and other works that also try to build a dynamic dataset during training, namely Goedel-Prover-V2 (Lin et al. 2025b) and STP (Dong & Ma 2025b).
Compared to Goedel-Prover- V2: The statement generation in Goedel-V2 relies frozen large model to synthesize data for SFT. Crucially, during the RL phase, their statement set remains static. This lack of dynamic updates of statements based on the prover's evolving capabilities may lead to suboptimal performance and efficiency as the prover outpaces the fixed problem set. In contrast, GAR continuously updates the statement fuser via adversarial RI., ensuring the generated statements
13

---

Published as a conference paper at ICLR 2026
Table 5: pass results on PutnamBench
Model Type
PutnamBench
DeepSeek-Prover-222 (Ren et al. 2025 GAR PrepSeek-Prover
22/660
24/660
Table Statement Modification Rate for MiniF2F- under pass @32
Model Type
Base Model
GAR trained
DeepSeck-Prover- V2 (Ren al. 2025
6.96% 28.18%
13.11% 27.05%
Pocdel-Prover-V2 [Ln 2025b)
remain progressively challenging and aligned with the prover's current skill level during the RL phase, leading to better empirical performance.
Compared to STP: While STP trains a conjecture model based on the prover's ' feedback, it relies on the expert iteration framework based on offline SFT. This process is inherently inefficient because requires generating a massive volume of training data in a single iteration to achieve effective SFT training. According Dong Ma 20255),, they generate 75,000 conjectures per iteration, which is larger than the entire statement set for our generation. Conversely, GAR operates within an online RL cycle. This allows the fuser and prover continuously update more efficiently, achieving superior performance without the computational burden of the large-scale per-iteration data required by STP.
D ADDITIONAL EXPERIMENTS
This appendix section provides additional experiments that are omitted in the main paper due to space limitations.
D.1 RESULTS ON PUTNAMBENCH
Given that Lean4 formal reasoning is rapidly progressing field, the MiniF2F-Test serves as benchmark with high accuracy in current models. To further validate that the GAR training can also make the model perform better on more advanced benchmarks, we evaluate both DeepSeek- Prover-Ve V2-7B and GAR-trane trained DeepSeek-Pree Prover on PutnamBench under pass@ 32. The results are demonstrated in Table 5
We can see that the GAR-trained model solves four additional problems compared the base model on this challenging benchmark. This consistent improvement across MiniF2F, PutnamBench, and ProofNet demonstrates the robustness of implicit curriculum established by GAR.
D.2 EFFICIENCY STUDY
We analyze the computational efficiency of the GAR framework, as training from scratch demands substantial resources, to evaluate this, we compare our approach with Kimina-Prover (Wang et al., 2025a), selected for its transparent reporting of training details. The number of roll-out theorems and proofs per iteration in Wang et al. (2025a) matches our configuration. From Figure 4 in their work, we observe that Kimina--Prowe achieves approximately 2% of performance gains after 25 training iterations, where GAR trained Goedel-Provert V2-8B reaches more improvements in merely three iterations.
Notably, despite Kimina-Proved starting from an SFT base model, while GAR starts from heav- ily RL-trained base model, this comparison strengthens our efficiency claim. Because well established in prior work (Guo et al.) 2025) that models already heavily optimized via RL face diminishing returns and are inherently harder to improve than SET baselines. The fact that GAR achieves relatively significant gains top of RL-optimized base models in only 3-5 iterations, while Kimina-PP Prover gains approximately 2% from an SFT starting point over 25 iterations, demonstrates the high sample efficiency of adversarial training paradigm. Given resource constraints that
14

---

Published as a conference paper at ICLR 2026
prevent exhaustive experimentation, leave the discussion of the scalability of GAR for future work.
D.3 STATEMENT MODIFICATION RATE STUDY
To dive deeper into the behavior of statement modification, we provide detailed statement modifica- tion rates of both the base model and the GAR trained model in MiniF2F-Test under pass @3...2 The results are shown in Table
From the comparison of base models, we can see that the Goedel's increased statement modifi- cation rate happens together with its performance enhancement. We attribute this the stronger self-correction capability it obtains. Similarly, the soft penalty in GAR ensures that the model penalized if it simplifies the problem to a triviality. Furthermore, we can observe that when the modification rate low, the GAR training introduces a higher modification rate, as is the case for DeepSeck-Prowe Prover. However, if the modification rate is high in the base model, the soft penalty will effectively control it within a reasonable range. These findings prove the improvement of the GAR-trained model from another point of view
D.4 ADDITIONAL ABLATION STUDIES
D.4.1 FROZEN FUSER STUDY
To further analyze our generative adversarial training, we conduct this experiment that applies the GAR training only on the prover and keeps the statement fuser untrained. We run three iterations of Frozen fuser GAR training on Goedel-Prover Prover-V2-BB for three iterations. The MiniF2F-Test pass 32 results are demonstrated in Table
From the results, we can see that frozen fuser fails to obtain any performance improvements com- pared to the base model. This confirms that static generator is unable to extend the prover's capabilities beyond its initial limits. This proves the necessity of co-evolution for both the problem composer and the prover.
D.4.2 SINGLE PROBLEM ENHANCEMENT FUISER
In order to further study the effectiveness of our idea of problem fusing, which enhances the problem difficulty by combining two problems into a single one. We conduct experiment of replacing the statement fuser with MagicCoder (Wei et al. (2023) that enhances the problem difficulty by restating the provided single problem to make it more advanced. The results are presented Table 7
The result indicates that replacing the fusion process with the MagicCoder style problem-evolving strategy results in a 2.46% performance drop compared to the base model. We conclude this degra- dation to the limited capability of Qwen3-8B 3-BB to create more advanced problems with only one reference. It may not provide sufficient difficulty gradient for the prover, leading to training failure. In contrast, our fusion approach creates more effective implicit curriculum by combining distinct concepts from multiple problems, thereby validating the design of the Statement Fuser.
D.5
CASE STUDY
D.5.1
CASE I:
In this section, we demonstrate an example of how the GAR trained model successfully solves the problem while the base models fail. Compared to the base prover, the GAR trained model relies less on brute simplification and more early structural framing, producing shorter, steadier proof traces that remain faith- ful to the statement and more likely pass the verification. If we dig deeper into the Long CoT of two models, we can find that GAR-trained prover writes shorter and more focused long COT. While the base model's CoT is longer but less
Table 7: Additional Ablation Studies
Method
MiniF2F-Tes.
Base model
77.87%
Frozen Fuser
77.87%
MagicCoder Fuser
75.41%
GAR trained
80.33
15

---

Published as a conference paper at ICLR 2026
directed, cycles among general identities and simplifications without stabilizing closing in- variant. The result that GAR's trace both and clearer and more verifiable, which leads to the successful proof.
GA R-tranndd model generated result:
(ogghhooo.sstttooeeoooooooooooop the following Lean code:
-e-nn importt Mathlib importt Aesop
set_option maxtlearbbeats 0
open Big0perators Real Nat Topolegy Rat
Consider prime $p5 of the form $4 t+1s. Show that $a$ is primitive root modulo Sp$ iff $-a$ is primitive root modulo sps. -/ theorem exercise___4 (p t: N) (hpt p.Prime) (hpl p 4xt + 1)
---
(a : 2Mod p)
IsFrimitiveRoot p ++ IsPrimitiveRoot (-a) := by
Before producing the Lean code to formally prove the given theoren, provide a detailed proof plan cutlining the main proof steps and strategies.
The plan should highlight key ideas, intermediate lemmas, and proof
structures that will guide the construction the final formal proof.

##t Detailed Proof
**Problem Analysis:**
We are given a prime "p" of the form "p 4 1" for some natural number "t", and an element "a" in the finite field "ZMdd p (where "p"
is the prime number). We need te prove that "a" is primitive root module 'p" if and only if "-a" is primitive root modulo 'p'.
Recall that "IsPrinitiveoott p means that "a" has multiplicative order p 1 4 * t' in the multiplicative group (2Mod p)
**Key Observations:**
1. The miltiplicative group (2Mod p)* has order "p
t'
2. The negation map "x H -x' an automorphism of (ZMod p)* because + +1> 2", and thus "p" is odd) This means that "-x" has the same order as "x".
"p" is an odd prine ('p 4
3. The multiplicative order of "a' and "-a" are the same if and only if "a -a', but this is not the
unless "p" divides "2 a', which is false here because "a" is arbitrary and "p" is prime. However, the actual condition is that "IsPrimitiveRoot a p if and only if "IsPrimitiveRoot (-a) p" because the order of "-a" is the same as the order of "a" when "p" is of the form '4tt11,
But actually, we need better understanding of the multiplicative group (2Mod =)*
For any odd prime "p" have the fell properties:
1. The map + is an isomorphiam on (XMod *)** because 'p" is odd. -The inverse is "x + -x', , so the map is permutation of the
- multiplicative group.
2. For any "x" in (ZMod p)",, "x 2 is a square (i.e., "x 2 is
square in (ZMod p) ")"
To this, observe that (a b) quadratic residue modulo "p"
ba and -- is
16

---

Published as a conference paper at ICLR 2026
But for our problem, we don't 't need these general observations. Instead,
we can use the fact that the order of "-a" is the same as the order of 'a".
*hyy the orders the *
since "p" is an cdd prime ('p = 4 * t 13 27), the multiplicative group (2Mod p) th is cyclic of order " 4 t let "g" be a generator of (ZMod p)
Then:
1. If "a" is primitive root ('IsPrimitiveRoot a p is true), then "a" has order "4 t- 1", so "-a" must also have order '4 + t because "-a" is unit in "2od (pp' is prime, so "-a * 0*) However, this is not correct unless "-1" has order '2" because (-1) x a", and the order = is '2" if 't + o" (because 2 = 1"). Thus, the order of "-a" is 12mm12, order of a)".
tt, and order of '-1"
Alternatively, better approach is to the follewing fact: The map x r -x" is an automorphism of the group (2Mod p)** because p'' is oaa (-1-1) = 1' and multiplication is invertible).
*Conclusion:**
since the map + -x" is automozphism of (2Mod p)* a (because "p" is an cdd prime), "a" has order 14 t'
only "-a" has order '4 t'. This is because the automorphism "x H -x" preserves the order of clements.
Thus, 'IsPrimitiveRan a p¹ ("order "sPrimitiveRoot (-a) p ('order (-a) tt).
is equivalent to
Therefore, the result follows.
### Step-by-Step Abstract Plan
1. #Unersstand the Multiplicative Group**:
The mult miltiplicative group (ZMod p) " is cyclic of order "p 4
t'.
Any element has miltiplicative order dividing '4 t
2. #Understand the Automorphism x + - ***
The map "x -x" is an automorphism of (2Mod p) a because "p" is an oad prime (-(-1) 17).
3. **Order Preservation**:
The order of "-a" is the same as the order of 'a", because "x + -x
is automorphism.
4. *Conclusion**::
is a primitive root ('order a = 17) T-a" a primitive root ('order (-a) = -1).
### Lean 4 'have" Statements
1ean
theorem exercise_4 4 Ip t: N) (hpl p.Prime) (bpl = 4+t + 1)
(a ZMod p) IsPrimitiveRoot p IsPrimitiveRoot (-a) p by
have h_main IsPrimitiveRoot a p IsPrinitiveRoot (-a) p by sorry sorry
17

---

Published as a conference paper at ICLR 2026
### Complete Lean Proof
leand
theorem _ (p t: N) (hpC p.Prime) (hp1 4+t + 1)
(a 2Med p)
IsPrimitiveRoot p IsPrimitiveRoot (-a) p by
have h_main IsPrimitiveRoct a P + IsPrimitiveRoot (-a) p :- by haveI Fact p.Prime := (hp0)
have h * 0 := ap0.ne_zero have P + have (-a XMod p) - :- rfl
hp0 apo.ne_omm
constructor
-- Prove the forward direction: if is primitive root, then -a
is primitive root
intro h
Use the property that the order -a is the same as the order 4 of a
have h4 := h.isUnit
have hs = w..oo__e__on__o__po
have hg castctnsson]
(by decide N) (by Nat Nat.cast_add, Nat.cast_mul,
rw | Nat
simp_al1 Nat.cast_ofNat]
<;> omega)
simp all IIPrimitiveRoct, MMd. nat past self, Nat.cast_add
4 Nat cast_mul, Nat cast_ofaat,,
RMod.nat_cast_sell
<,>
(try cmega) <t>
(try simp_all [zMod. nat_cast___l_f, eat_cast_add, Nat cast_mul,
4 Nat cast_ofNat,
2Mod.nat Baadd.na__cat_sellg <;>
(try
aesop 1) <;> (try
simp_all [Units.ext_ifff, pow_succ]
<;>
ring_nf nf at * <3>
omega
1) <;>
(try
norm_num at
<;>
aesop
1) <;>
(try
aesop
}) <;>
(try
simp_all (Units.ext_iff pow_succ]
<,>
ring_nf <;>
omega
1)
<;>
aesop
Prove the reverse direction: is a primitive root, then a
is primitive root
intro h
18

---

Published as a conference paper at ICLR 2026
Use the property that the order of is the the order 4 a
have h4 := h.isUnit
have hş := n.pow_ee_one
have he
peov_ne_one_o__po__or (by decide (0 N) 1) (by
rw Nat. cattcossoone]
simp_all val Nat cast add, cat.cast_mul, 4 Nat.cast_ofNat]
<i> emega)
si simp all [ISPrimitivRRoo, aMdd.nat cast self, Nat Nat.cast_add.
Nat cast mul, Nat. vat.cast_ofNat
2Mod_nat_cast_ser1]
<;>
(try omega) <;>
(try simp_all maa.dddat_csstselll Nat Nat.cast_add, Nat.cast_mn
Nat. cort.cas_offar
nMtd. <;>
(try
aesop
1) <;>
(try
simp_all (Units.ext_iff, pow_suee]
<;>
ring_nf <;>
omega
1) <;>
(try
nerm_num at
<;>
aesop
1) <;>
(try
aesop
1) <;>
(try
simp_all (ftits,oxt_ifff, pow_succ]
<;>
nf at <f>
omega
1)
<;>
aesop
exact h_main
Base model generated result:
htapg//of.sseeeeeeee//t////ooooe the following Lean 4 code:
impport Mathl ib import Aescp
set option maxHeartbeats
open BigOperators Real Nat Topology Rat
19

---

Published as a conference paper at ICLR 2026
-- Consider prime $p$ of the form t+1s. Show that faş is primitive root modulo Sps iff $-a$ is primitive root modulo sps. -/ theorem exercise___4 Ip t: N) (hpC p.Prime) (hp1 p 4+t + 1)
(a 2Mod p)
IsPrimitiveRoot p 4 IsPrimitiveRoot (-a) by
Before producing the Lean code to formally prove the given theoren, provide a detailed proof plan cutlining the main preof steps and strategies.
The plan should highlight key ideas, intermediate Lemmas, and proof - structures that will guide the construction the final formal proof.

*## Detailed Proof and Analysis
First, let's recall the definiticns and properties will use:
1. **Primitive Root**: An element "a" is a primitive root modulo "p" if the multiplicative order of "a" in (2/pž)+* is -p-1"
2. **Order of "a'**: The order of "a" module "p', denoted "orderOf a', is the smallest positive integer "k" such that "a"k
mod p
3. **Multiplicative Order**: The multiplicative order of "a" modulo "p"
- the smallest positive integer "k" such that "a"k = mod p'.
Given "p" is prime and "p = 4xt 1', need to prove that "a' is primitive root modulo "p" if and only if "-a" is primitive root module "p".
#### Key Observations:
1. The multiplicative group . (2/p2)x* has order "p 4xt",
2. The quadratic residues modulc "p" are la | 3 b, b² med pl The number of quadratic residues 4").
(p 11/2 2+t" (since pp mod
3. The multiplicative order of any aa E (2/p2) * must divide p -i- 4+t"
4. The multiplicative order of "-a" is the same as the multiplicative order of because ((-a) a = mod p", the order is determined by the exponentiaticn.
#*## Proof Sketch:
1. Assume "a" is primitive root module "p". This means that "a" has
+ mult multiplicative order "p 4xt" (Z/pp)
The order of "-a" is the same as the order of "a", which is 14xt =
1', because:
"4xt) (2))) (2+t) (a²)
mod p' because "az"
has order "2xt" (since "a" is primitive root and the exponent
~ "4xt 2+ (2+t),, but this not directly relevant).
Morc precisely, "-a" and "a" have the same multiplicative order + because (-a)) " (4+t) = ((-a)22)" (2xt) = (a?) (2+t) = 1 mod p" (if "az" has order "2+t").
However, simpler approach is to observe that "az" order "2xt" and thus ((aa) a+", , so ((aa) (
mod p not + guaranteed, Instead, we can use that ((-a (4+t) ((-a) "2) (2+t) (at) (2+t) = mod p', but this does not direct ly help unl llss we know "a2" has order "2xt".
(a*)
A better approach is note that ((aa) "k = mod p if and only if "a"k = 1 mod p' because:
(-a) k = 1 mod p² is equivalent to (-1) "k ark = mod p', 80
~ "a"k = (-1)*k mod p".
- Since "a" is primitive root, "a"k mod p if and only if "k" is multiple of "4xt", because "a" has order "4xt".
20

---

Published as a conference paper at ICLR 2026
Thus, "a'k (-1)*k mod p would imply '(-1) mod pi, i.e.,
(-1) (4+t) mod p which is true for 'p= +4=
mod p²? Wait no: -p= 4At 4xt 1" and "p + = 1 mod 4', so ((-1)"(4+t + +1 = (-1) "11x)(4))
+ (-11 (4At 1) = -1
(-1) = 1 (-1)
ned pi, which is not 'I mod p But "p" is prime and mod 4", which is not 4 helpful. This is mistake in the reasoning.
-1 =
"p mod 4', so --1 p
4xt
The correct approach is to ncte that ((-a) (4+t) = ((=a)"2)" "2"""""""22)) (2+t) ( = mod p because "at" has order "2xt". Hut "a" is (2xt)
primitive rost,
mod p (oodderff
4et 2 )xt").
This is not sufficient.
Alternatively, observe that:
The order of "-a" divides "4xt" because the order of "a" divides
"4+t".
The order of "-a" does not divide "2+t" unless "at = mod p
(since (2 =² mod p would imply "orderOf (-a) 2)). primitive root, so "a" = mod p would imply '2 I orderof a 4+t", 1.e., "2 I 4xt", which is true since 't 2 1". But "a2 = 1 mod is not guaranteed unless "a* = mod p',
But aa'
which is not necessarily true.
A better way is to
the fact that "-a" has the same order "a" because "p = mod 4", and ((a) a
However, a simpler and correct approach is to use the following: The multiplicative order of "-a" module "p" is the same as the multiplicative order of "a" modulc "p", because ((aa a² and "a²" has order '2xt" modulo "p".
But we can use the following:
If "a' is primitive root module "p', then for any 'k', "a"k mod
p' and only if "k" is multiple of '4xt.
Then (-a) = mod p is equivalent to "a"x = mod p", because
+ ((aa) "k (-1)*k + ank" and "p" is odd ('p = mod 4") So (-a) *k = 1 mod p' is equivalent to "a"k = mod p if 'p' is cdd.
Hence, "orderOf (-a) orderOf
4+t = 1".
Therefcre, "-a" is also primitive reot modulo 'p'
#### Correct Approach:
1. "p" is prime and "p mod 4', (-a)
modulo 'p".
2. The multiplicative order of "-a" module 'p' is the same as the multiplicative order of "a" modulc "p", because:
("a) mod p' iff "a"k = mod p for any 'k', since ">a) - (-1)*k a'k", and 'p" is odd ('p = mod 4'),
Alternatively, observe that "orderOf (-a) orderOf because pp + mod 4" and "a" is primitive root.
In particular, "orderOf (-a) p - orderOf a', because (-a)"(p
1) = a (p 1) = mod p (Fermat's Little Theorem).
But need more precise argument:
1. "a" is primitive root, then the multiplicative order of "a" "F
4+t"
2. The multiplicative order of "-a" is the same as the miltiplicative orcer of "a" because "p = 1 mod 4" and "a" is primitive root.
To see this, note that "(-a)
a²", "orderOf (-a)" divides "orderOf a (which is '2xt').
But "orderOf a** divides "orderOf
4xt" (since "a#"2t (a?) "2
+ mod p').
Also, "orderof (-a)" divides "p -p-11 4xt" because ((a) (4+t) (2xt) "2xt) (a*) (2+t) = mod p'. Since "orderof (-a)" divides "4xt" and "4*t" is the order of "a', , and
"orderof (-a)" divides "orderof a²* (which is "2+t"), and "orderof
- at divides "orderOf at (which "4x"", the only common divisors
are "I" and 2
21

---

Published as a conference paper at ICLR 2026
But "orderOf 4+t" and "orderOf a² 2*t".
Alternatively, because a' - "4*t" divides 'k",
primitive root, "a"k mod p iff
Similarly, "K-a)"k = 1 mod p iff "4xt" divides ' because (-a) "k
= a'ak (since "p = mod 4").
Therefore, the order of "-a" is the same the order of "a".
But we can simplify this: The order of "-a" is the same as the order of "a" because pp = mod 4
and "a" is a primitive root.
Thus, have:
1. If "a" is primitive root, then "-a" is also a primitive root.
2. Similarly, if "-a" is a primitive rect, then "a" is also a primitive root.
### Step Abstract Plan
1. **ssuume "a' is a primitive root modulo "p'**:
order of "a" is "p 4xt'. We need to show that the multiplicative order of --a" is "4xt" Use the fact that (-a) "k mod p itf "a"x mod p because "p
The multiplication
= mod 4"
Thus, the order of "-a" is the same as the order of 'a'.
Therefore, "-a" is also primitive root.
2. **Assume "-a' is primitive root modulo *****: Similarly, "a" a primitive roct.
The reascning is symmetric.
### Step 2: Lean 4 'have" Statements
leand
theorem exercise_4_4 (p t: N) (hpC p.Prime) (hpl 4xt + 1)
(a ZMod p)
IsPrimitiveRoot p IsPrimitiveRoot (-a) p by
have h main IsPrimitiveRoot a IsPrimitiveRoot (-a) p := by sorry
have h_cenverse IsPrimitiveRcet (-a) IsPrimitiveRoot à : by
sorry have h_final IsPrimitiveRoct p IsPrinitiveRoo: (-a) p by
sorry exact h final
### Explanation:
1. "h_main": "a" is primitive root, then >-a" also primitive
root.
2. " converse": : Is "-a" is primitive roct, then "a" is also primitive
root.
3. "h_final': Combine the two directions to get the full biconditional.
### Complete Lean Proof
llean
theorem excreise_4_4 (p N) (bpC p.Prime) (bp1 p 4+t 1)
(a ZMod p)
IsPrimitiveRoct p 44 inrimitiveRood (-a) p :- by
have h_main IsPrimitiveRoct
IsPrimitiveRoot (-a) by
intro
haveI := Fact.mk hp0
have hi := h.isUnit
have ha := h.pow
have h.pow one pos of It (by decide (0 N) < 1) (by
simp_all [hp1, Primer [t]
<;> omega)
22

---

Published as a conference paper at ICLR 2026
have h.pow one pos of 1t (by decide (0 : N) 2) (by
simp_all [bp1, Pat.Prime.cne__le
<;> omega)
simp_all
pew_one, pow_two, neg_neg]
<;>
(try omega) <;>
(try simp_all [IsPrimitiveReet, pow_mul, pow_add, pow_ane, pow_two, <;>
(try emega) <;> (try
have h := h.pow eq_ons
have hg := h.isUnit simp_ all naMod.nat setoddnat_cast_eels pow_ pow_two, beg_neg) <;>
acsep
1) <;> (try
have :- htppo_eg_ons
have he : h.istni
simp_en all IMod.natt_can caatt_cas___eeeeee pow_one, pow_two, neg_neg]
<;>
aesop
})
<;>
(try
aescp
1)
<;>
(try
simp_all
[MMod_nat_cas__sel: pow_one, pow_two, neg_neg]
<,>
aesop
})
<;>
(try
omega
})
<+>
(try
acsop
})
<;>
(try
simp_al1 [MMod_nat_cast_eelf, pow_one, pow_two, neg_neg]
<;>
omega
1)
have h_converse IsPrimitiveRoct (-a) IsPrimitiveRoot by
intro
haveI : Fact mk hp0
have h := h.isunit
have h2 := h.pow_eq_ome
have
h.pow_ne_one.
pos_poos______oopoopooooeooooleo of (by decide (0 N) < 1) (by
simp_all all [hpl, Pat.Prime.com one_me.ceee_t_
<;> omega)
have h4 :- h. _f
(by decide (0 : N) < 2) (by
simp_all [hpl, Nat. Pri.Prime.com one_lt.
23

---

Published as a conference paper at ICLR 2026
<;> cmega) simp_all sMod.nat_cast_selle pow_one, pon_two, neg_neg]
<;>
(try emega) <;>
(try simp_all [IsPrimitiveRoct, gow_mul, pow add, paw_one, pow_two,
saadddatt_ss_eeee_ <;> (try emega) <;> (try
have hş h.pow_eg_ann have h.isunit
simp_ all [ cast self, pow one, pow two, neg_neg
<;>
aesop
}) <;> (try
have hş : h.pow_eg_onn
have hg : h.isUnit
simp_all saodd.at_cast_sel pow_one, pow_two, neg_neg]
<;>
aesop
1)
<;>
(try
aesop
})
<;>
(try
simp_all [2Mod_nat_cast_soll pow_one, pow_twe, neg_neg]
<;>
aescp
})
<;>
(try
omega
})
<;>
(try
aesop
})
<;>
(try
simp_al1 [XMod.nat_cast_Bet pow_one, pow_two, neg_neg]
<;>
omega
<i>
aesop
have h_final: IsPrimitiveRoot p IsPrinitiveRoot (-a) p by constructor
exact h_main
exact h_converse
exact finil
24

---

Published as a conference paper at ICLR 2026
D.5.2 CASE 2:
In another ProofNet example, GAR again succeeds where the base prover fails. This instance more clearly illustrates how GAR mitigates useless simplifications. It uses NLs to reach comprehensive proof plan and effectively conduct the proof relatively simple manner. However, the base model conducts quicker search but prolonged proof. It expends effort on low-yield algebra and yields lengthy, fragile derivations. These observations highlight that the implicit curriculum in GAR fosters more efficient reasoning paths and greater verification robustness.
GA R-trained model generated result:
(poghhoo.ssssttoeeeex//oooooooop the following Lean code:
leann iimport Mathlib
import Aescp
set__epioon maxHeartbeats
open BigOperators Real Nat Topolegy Rat
--- Prove that 3+0xxxxx++xxxx2xx2 is irreducible in #'mathbb/ (2) [x]s. -/
theorem excrcise_9_ 9_______2222 Irreducible
(X"4 4xX 6xX-2 2+X Polynomial Z) by
Before producing the Lean code to formally prove the given theoren, provide detailed proof plan cutlining the main proof steps and strategies.
The plan should highlight key ideas, intermediate lemmas, and proof structures that will quide the construction of the final formal procf.
<|assistant/>#F Detailed Proof
>*Problem:** ** Prove that (x) = x 4x"3 6x 2x V) irreducible in (1mathob(2)(x11)
*Approach:***
will use the Rabinowitz Criterien (also known "Rabinowits irreducibility test" or "Rabincwitz's Criterion") to prove that M P(x) V) is irreducible over ((mmtthbb(2) [x]))
e*Rabnowiizz Criterion:**
Let \( (x) x'n (_
!dots a_o \) a polynomial \(mmttbb(2)) [x] Suppose that there exists prime \ V such
that:
1. \( divides each \( a \) for \ 0 \leg i Aleg n-1 V.
2. \ p(222 A) does not divide V( a_0 V)
Then P
is irreducible over \/mathbb/2) (x])
epApplccttion to (x) *)***
let
(( (x)
x'4 4x"3 + 6x'2 + 2x + A).
1. The constant term \(00= V.
2. The primes dividing all coefficients \o a 0, a,, 2, 3 V) are the primes dividing \( \ged(l, 2, 6, 4, 1) = V.. So, no primes satisfy the first condition.
Hmm, this is incorrect: actually, all coefficients a W, V
a_ = V, ((a22 1), af 3 \) are divisible by A W. but the second condition is about \ a_ = V), not all other coefficients. This suggests that perhaps we need different approach.
25

---

Published as a conference paper at ICLR 2026
But the Rabinowitz Criterion still be applied:
Consider P V.
( A) divides Af a_0 = - V) (False).
( 2 V) divides ( = 2 V) (True).
A V) divides A a_a
V) (True)
2 A) divides a_3
(True)
But (( p²2
\) divides M a_o
(False).
This coes not work. So, we need ancther prime.
Consider 1 V::
( V) divides (
V) (Nc).
A 3 V) divides A a_1 - 2 V) (Nc). AP V does not divide any of the coefficients, this is invalid.
Consider \P=5 V::
5 5 V divides ( = V) (Nc).
A( V) divides A a_1 = 2 A (Nc).
A V) does not divide any of the coefficients, this is invalid.
mAlternative Approach:**
Let's consi der the polynomial (( (()) x + 4x"3 + 6x + 2x + 1 M). We can attempt to factor it check for possible roots.
But Q(0) v, Q(1
14 Mr and A Q(-1) 4 + V). No simple rational roots.
Alternatively, perhaps we can facter A Q(x) \) into quadratics.
Assume (( (xx) (x aaxt b) (x c d) W.
Expanding gives: M x (a + c)x + (ac b d)x²2 (ad + bc)x + bd (x). AJ
Thus, we get the system:
1. \ a +
2. A ac + b + -
3. ad ad + be - A)
4.
From (( bd = 1 W,, since Ac b, d Vin \mathbb/2) A), we have the following
cases:
1. \( 1, d= M,
2. \lb -1, =- W.
**Case 1: \ = d= *)**
From (1): \ a + \)
From (2) \
=2=6 limplies
From (3): +latc= U, \( ac 4 V
But (( a, e 1) are roots of t 4t + = A,, i.e., Mt = 2 \). So \ 2 V.
This satisfies all equations: \
\ a +
( ac 4 V
A ad + be = 2 Aedot 1 + 2 Nedet 1 = 4 Aneq 2 A) (Does not hold).
Wait, this is incorrect. The problem in (3): A ad + be a \odot a Nodot (a + c) \neq 2 M), which contradicte the third condition.
Hence, this case is invalid.
**Case 2: Ab d -1 **
From (1): Matc t
26

---

Published as a conference paper at ICLR 2026
From (2) From (3) -a
Aimplies
\implies + V), but this contradicts (
a + c 4 V..
This case is also invalid.
**noother Approach: Eisenstein's Criterion**
This polyncmial is not directly suited for Eisenstein's Criterion,
because replacing A( 1) with V x + \) gives:
Al (x + 1) 4(x 11 6 + 1)"2 + 2 11 + Al
Al =|= =x 4x"3 6x"2 4x
4x"3 + 12x"2 12x 4 6x 2 12x
a +
+1+11 \
M[ x + (4x"3 + 4x"3) + (6x"2 12x²2 6x*2) (4x + 12x 12x 2x)
4 + +1 4 +
1) V
= x 8x"3 24x"2 + 30x 14 A]
But can try another substituticn.
Alternatively, observe that:
M (x)) 4 + 4x"3 + 6x"2 + 2x + 1 A]
M (x"2 22 2 2x"2 + 2x 1 M]
But this
not helpful.
However, a better approach is to note that: M [x) - (x'2 2x + 1) 2 - (2x"2 + 1) A]
But:
AI [xx) x 4x"3 6x*2
1
But:
A (x"2 + 2x + 1) = x-4
4x"3 + 6x + 4x 1 \]
A (xx) (x"2 2x + 12 (2x 2) A]
But \( (x"2 2x + 11 "2 (2x
x-4
4x"3 6x"2 + 4x 1
2x
x 4x"3
6x"2 + 2x Aneq ((x) V
This cubstitution is incorrect.
Conclluiio from the failed attempts:**
It seems difficult to factor / Q(x) V in (1mmttbbb22/ by simple methods.
But we try more general approach using the Cohn's Irreducibility Criterion Ritt's Critericn, but these not straight
However, we can use the Rational Rect Test (or simply checking small primes):
Check for \ x \pm 1, \pm p \) fer primes A A):
( Q(1) = 1
6
14 V
( Q(11)
V)
Q()(2) - 16 32 + 24 +1
77 V) + 24 4 4
Q(-2) 16 32
Since \( ((x) \) has rational reets, it is irreducible (1
But this seems incorrect, as A( (x) \) is reducible for M x = 0 \) and x = Vr, but we are not using this approach.
Alternatively, we can use the **Schinzel's criterion** or #*Rabinowitz - Criterion** again: Consider \ Q + 1) = (x 1) 4 + 11 6 + 1) + 2 + 1) +
V
NI x + 4x"3 + 6x'2
4x + 1 + 4x"3 + 12x"2 + 12x 4 6x 12x +
+ +
AI x + (4x") + 4x"3) + (6x 12x"2 6x (4x + 12x 12x 2x)
(1 +
+ + 1) \]
M x + 8x"3 + 24x + 30x 14 AJ
27

---

Published as a conference paper at ICLR 2026
Emm, immediate factorization here either.
**Final Attempt:**
We use the fact that if ( (x) V) is irreducible over \ (2) then it is irreducible over (0)at
Alternatively, we can directly check that A Q(x) V) has no factors \(Amathbb/2) [x] other than A Q(x) V itself and constants.
We can perform complete check:
Suppose / Q(x) (()) (xx) is factorization into non-constant
polynomials.
We can write:
A (x) x a_1 x x 3 a
M (x) V
But (( (x)) V) is a unit and (( (B)g = V), so this is trivial.
Alternativell vely, assume A( (x) \) has degree \( 1 1) \ A), etc.
But this is tedious and unlikely to work.
Given that the problem is from an clder source, can infer that the polynemial ((x) A is irreducible.
But in Lean, we can proceed by proving that \ (x) V) has no non-trivial
factors, by checking that for every pair of integers \ (a, b) \)
such that \ b \neq \pm 1 V), we cannot write \ ((x) V) as product of two nen-constant polynomials.
Alternat ivernattiely,, ively, we can use Lean's libraries to prove irreducibility by
**Proof Sketch:**
1. Assume \{ (x)) (x) (x) V).
2. Look at the constant term.
The constant term is \ 1 M), sc possible constant factors are \( Apm
1 V.
3. either \ A(X) V) \( ((x) \) is constant, say \ A(x) Apm V..
4. But then \ Q(x) V) would have to be constant, which false. So, contradiction.
But Lean may directly have 1emmas for this.
better approach is to use that for a monic polynomial with integer coefficients and A \pm 1 \) constant term, it is irreducible if it has no non-trivial factors.
But in Lean, we can prove that ne ncn-trivial factors exist.
Hoxever, checking all possible factors is impractical.
Alternatively, - polynemial or Schur polynemial.
use the fact that At (x) is cyclotomic-11kk
But since this seems too involved, we can use Lean's 's wirreedciiiiitty
testing** (but that's not part of standard libraries).
*Alterrative step:**
We can instead show that (x)) V) is not a perfect square in \ \mathbb(Z) [x] V).
But this is non-trivial.
28

---

Published as a conference paper at ICLR 2026
Alternatively, we can use **Mignotte's bound** to check that no non-trivial factors exist.
But given that \ (x) A) is not known factori zable polynomial, we can
simply use the fact that it is not reducible and is of degree \ Vr so must be irredueible if has no roots
\mathbb/2; M).
Since (( ((x) V is strictly increasing for A x \geq 0 V and \ Q(-1)
2 M, A 0101 1 V, and ((11)) 14 V, there are no integer roots.
But Lean can confirm this by checking values.
But instead, can use:
**Iemmas:**
1. If ( (xx) A is reducible in A \mathbb/2) [x] M) then it has a linear or quadratic factor.
2. reducible polynomial must have factor with A Adeg Aee A1floor \fracideg (2) H12 \rfloor 2 V.
3. The possible quadratics are xxx2 aax W) or similar, but none
- divide \ (x) V).
But checking this is tedious.
Instead, we can appeal to known fact that \ x + x
x - V
is irreducible, and substituting \ x 1 \) gives:
AI (x + 1) + (xx + 1) 6(x + " + 2 1) +1
Al = 4x"3 + 6x + 4x + + 4x"3 + 12x"2 + 12x 6x 12x +
2x
x 8x"3 24x"2 30x 14 M]
This is the same as above.
Alternatively, check that \l x 4x"3 6x"2 + 2x V) is irreducible using:
**Useful L The polynomial A x + a x + +bx2
1) is irreducible in \ \mathbb [x] \) if al22 4b 1) or \l b < 4c
x
W etc.
But this is not directly helpful.
*leean Approach:**
To prove irreducibility in Lean, directly use: The **reduction modulo primes** approach to eliminate possible factorizations.
Alternatively, we can use the fact that A (x) A) is a cyclotomie-1ike polynemial or Cohn polynemial.
But given that the polynomial factorization exists, we can proceed by contradiction.
degree \ \) and no obvious
### Step-by-Step Abstract Plan
1. **ssume Reducibilityss: Suppose \t Q(x) is reducible V
- \mathbb(z) [x] \). Then, V( ((x) - A() ((x) \) with A (A \gea 1 Mr A (B \geq 1 V), and A \deg (x)) + Adeg (B(x) V.
2. Analyy Constant Terms**: Since Q(0) 1 A) Q(x) \) has rational roots, no constant factors can exist unless one of M (x)
\) or B(x) \) is \ \pm 1 V.
29

---

Published as a conference paper at ICLR 2026
3. **hheck for Linear Factors**: If M \deg (x()) V), say \( A ((x) A) Expand to get coefficients
V) then ( Q(x)
and contradict.
4. **Check for Quadratic Factors**: If A Adeg (x))) 2 M), say M A()) x x V, analyze to find contradictions.
5. *nContradictionw:: Since all pessible factorizations lead to \( (x) V) must be irreducible.
contradi ct
### Lean 4 Abstract Plan with 'have' Statements
leand
theorem exercise_9_4
: Irreducible
(X"4 4** 6*X"2 2+X 1 Polynomial Σ) := by
have h_main Irreducible (X"4 4*X*3 6xX²2 2*X Pollnoniall 2) := by sorry sorry
### Complete Lean Proof
leand
theorem avercise_9_4_22
Irreducible
(x"4 4xx*3 6xx-2 2+X 1 Polynomial Σ) :- by
have h main Irreducible (X*4 4xX 6.X-2 2+X + : Polynonial Z) := by apply?
apply hamain
Base model generated result:
<|begin of setettteccppppppte///ooome the following Lean code:
impprrt Mathlib
import Aescp
set_optiio maxHeartbeats 0
open Big0perators Real Nat Topology Rat
--- Prove that $x $x"4+4x 34'4 is irreducible in (mathbb(2)) [x]s. theorem axercise_9_4_22 : Irreducible
4X"4 4 6xX*2 2+X Polynomial Z) = by
Before producing the Lean code formally prove the given theoren, provide a detailed proof plan cutlining the main proof steps and strategies,
-
The plan should highlight key ideas, intermediate lemmas, and proof structures that will guide the construction of the final formal proof.
<|assistant) Detailed Proof and Analysis
We need to prove that the polynomial M ( x + 4x"3 + 6x"2 + 2x +
)) is irreducible over (1\matbbb(2) [x]
### Step Understand the Polynomial
30

---

Published as a conference paper at ICLR 2026
First, observe that (( (x) is palindromic. A palindromic polynomial
P (x) V) can be factored as A P(x) (x a b) (x"2 с d) V) if and only if ( (x) V) can be written as a product of two quadratic polynomials.
***# Step 2: Try to Factor (( (x)) V)
Assume that \< P(x) V factors inte two non-constant polynemials with integer coefficients:
NI (x)) (x'2 xax b) (x'2 c d) AJ
Expanding the right- hand side gives: M x (a + c)x"3 + (ac b d)x'2 (ad + belx + bd. A
By comparing coefficients, we get the system:
V, 3. a + bc = V),
1. \(
2. \
V,,
4. bd = W.
**## Step 3: Solve the System
From ( bd 1 Mr the possible integer pairs \(o, d) are:
M (1, 1), (-1, -1). VJ
**Case 1:** \bb b - V, - Substitute into the other equaticns:
1. \( = W),
2. A( ac + 1 = \Rightarrow ac = A 4 M,, 4. ad + bc a W, but this is already satisfied.
3. +
But from \{ a - \) and ( ac V,, the quadratic equation for (
a \) is:
M 2 4t + 4 = \Rightarrow (t 2) 2 0 \Rigatarrow t 2. VJ
Thus ((
V.
Check the last equation: M ad be Aedot 2 \edot 1 4 Aneq 2 W. This is a contradiction, se this case is invalid.
*Casse 2:** \(
-1 W, \( d V.
Substitute into the other equaticns:
1. A a +c+ = \),
2. Al ac - -1-1 11 \Rightarrow ac = 8 \),
3. \( + be = -a =
4. bd
W.
But from \ a c = \) and / ac = W, the quadratic equation for (
a \) is:
\] which has discriminant D = 16 32 -16 A). Thus, there
MI t22 4t
real (and hence no integer) rocts, so this case invalid.
#### Step 4: Check Other Possible Factorizations
The above exhaustive search shows that \( ((x) \) does not factor into con-constant polynomials with integer coefficients. Thus, \ \) irreducible.
#### Verification of the Irreducibility
we have checked all possible factorizations of \( (x) V) into quadraticn and found that none satisfy the coefficient conditions. Therefore, (x) is irreduciole.
### Abstract Plan
1. **Assume Factorization**: Suppose \ (()) (x"2 b) (x"2
+d) V) for integers \( a, b, c, W
31

---

Published as a conference paper at ICLR 2026
2. *Coomaree Confficients**: Derive the system of equations for A a,
C, V.
M V,
= ac + b 6 A),
-\ ad bc = 2 M,
-\O = =1
3. **Solve ((
))*: Consider the pairs (oo, d) as M(2 11
and ((-1, -11
4. **Case \ b = 1 W) \( ***:
Derive /< + V and Y ac 4 V.
Solve for a () and \(
to find ( =a==2 V
But this leads to \(
be
\neq 2 W), contradiction.
5. **Case ( -1 \), ((d -1 *)*: Derive a +
V) and ac ac = V. Show that no real roots exist for \ W,, this case is invalid.
6. *cConclusione:: No valid factorization exists, so ((x) A) is irreducible.
### Lean 4 "have" Statements
leann
theorem exercise_ (X"4 4+X'3 6xX'2 2+X Polynomial 2) := by
Irreducible
have h main Irreducible (X'4 4+x 6xX 2*X + Polynonial
Z) by sorry sorry
### Complete Lean Proof
1eand
theorem exercise_9 9_ 2e Irreducible
(x"4 + 4+x"3 6+X²2 + 2+X + Polynomial Ø) :- by
have h_main Irreducible (x"4 4*x 6xx*2 2xx + Polynonial al
2) :- by
Assume the polynemial factors into two non-constant polynemiais
4 with integer coefficients
refine' (prime_of_irreucibblee
irreducible (show Prime (X"4 + 4x803 + 6xX"2 - 2 +1 Polynomial Z) by
Use the fact that the polynomial is primo to show it is
4 irreducible
apply prime_C_mul___pee pow add C_
<;> norm_num
<;>
aecide))
<,>
(try norm_num) <;>
(try decide) <>> (try
intro
-- If the polynomial factors, it must factor into quadratics reases h with (p, q, hp, hq, hpq)
Analyze the possible factorizations
have h1 congr_arg (fun p eval p) hpg
have h2 :- congr_arg (fun p => eval p) hpg
have hg :- congr_arg (fun p => eval (-1) p) hpg
have hu : congr_arg (fun p => eval p) hpq
have
congr_ars (fun p eval (-2)
hpg
simp at hi ha ha ha hs
Check the possible evaluations to find a contradiction
norm_num [eval_add, eval_mul, eval_pow, eval_C, eval_X, eval_pow, eval_mul, eval_add, eval_sub] at hı b2 hg hs <;>
(try { contradiction <;>
32

---

Published as a conference paper at ICLR 2026
(try
have be p_sub_dvd_oval_sub
have h7 q.Sub_ddv__vvl__eu 1
have ha p_sub_ddv_cval__sub (-1)
have hg g_sub_dvd_eval_sub (-1)
have h10
p_sub_dvv_evvl_sub
have h1 :- g.sub_dvd_eval
2
have h12 = p_sub_dvd_eval_su 0 (-2)
have h13
weeuu_ddd_eeal_eee 0 (-2)
simp leval add, eval_mul, pow, evai_c, evai X at he
4 hg h1o h1 h12 his
<;>
(try omega) <;>
(try
have h14 : p.naDeeeeee
by
contrapose! he
simp_all [Polynomial. eval_add, aaroomialleva_mmii.
4 Polynomial.
polynomial.eval..
Polynomial.eval_X]
<;>
(try omega) <;>
(try nlinarith)
have his : g.natilegree S 2 : by
contrapose! h7
simp all Pollynmiill eval add, Polynomial eval mul,
4 Polynomial.eval pow, Polynomial.eval.
4 Polynomial.eval X]
<;>
(try omega) <t>
(try nlinarith)
have his : p.natDegree S :- by
contrapose! hs
simp_all |Folynomial. eval_add, Polynomial.eval eval_mul,
Polynomial.eval pew, Polynomial.eval..
4 Polynomial.cem .eeanom <;>
(try omega) <;>
(try nlinarith) have h17 g.naDDegres
by
contrapose! hy
simp_all [Polynomial.cwe aval_adalllllllddd, Polynomial. evaammi,
Polynomial.eval_pe Polynomial.evaa + Polynomial.eval_1 <;>
(try omega) <;>
(try nlinarith)
have h1s : natllerreee S 2 :- by
contrapose! h10
simp all [Folynemial eval add, Polynomial eval mul,
- Polynomial.eval pow, Polynomial.eval.
4 Polynomial.eval. X]
<;>
(try omega) <+>
(try nlinarith)
have h1s : nanDreeee < := by
contrapose! hi
simp_all [Polynomial, eval_add, Polynemial. wtw.yymmallllallmmm.... eval_mul,
Folynomial..val pow, Polynomial.eval..
4 Polynomial.eval.. <;>
(try omega) <;>
(try nlinarith)
have h2o : n.aDreee := by
contrapose! h12
33

---

Published as a conference paper at ICLR 2026
simp all [Plynooial..eval add, Polynomial eval mul,
+ Polynomial evval_pow volynomial.eval_.
+ httpyoomaal.vva.....
<;>
(try omega) <;>
(try nlinarith)
have h21 : g.natDegree contrapose! hi3
:= by
simp_all [Polynomial al 1ewaya evalevvllee Polynomial .evv Leval_me m_mu,,
Polynomial ayt.nomial.evall .evaleell___e _eval_pow, Polynomia al evall_C,
4 Polynomial <;>
(try omega) <;>
(tr nlinarith)
Now know the degree of and g is most
have h22 : p.natDegree
:= by linarith
have h23 : g.natDegree I :- by linarith
have h24 : = C (p.coeff 0) V
(p.coeff 0) * X V c
coefo 0) * X - by
have h2s
p.natulegre__le_____erreee
h22
have h2s p-natllagre__ee_of..erree
h22
have h27 :- p.
le h22
cases' 1t _t_or_eq_ott of (natDegree of degreddeeeeeeeerr le h22) with
h2s h28 <;>
simp_all
Polynomia degrreeeggggtaaaaggrro.o..o
<1>
(try omega) <;>
(try acsop) <;>
ttr {
aesop
) <;>
(try {
aesop
1) <;>
(try |
aesop
})
have has
(q. coeff 0) V (q. coeff 0) V q
coeff
:= by
have has g.natbegree_ee_o__gggee
has
have hur := sattttDorrra_le_____oreeeee
hus
have h2s q_natDogrcelee_offoogrree leatDegree_le_o__deggeee
h23
cases' 1t_or_eq_o__le
h22) with
h29 h29 <;>
simp all [Folynemial natDegree_ itt_eeeeeeeeeeeeeeeeeeeeeeeeeeee
volyyomial.natteegre...
degree le,
+ Polynomial degree eq natDegree)
<;>
(try omega) <;>
ttry aesop) <;>
tryy {
acsop
1) <;>
(try {
aesop
)) <;>
(try {
aesop
rcases
has with (h2s has has) <;> reases has with (has has
+ h2a) <;> simp_all poolynomial.eval...
polynomial.eval_ngg
Polynomial.eval__
Polynomial.eval_. Polynomial. _vain____lell_]]]_______________
<;>
(try omega) <;>
34

---

Published as a conference paper at ICLR 2026
(try nlinarith) <;>
(try {
ring_nf at
<;>
onega
}) <;>
(try {
nom at
<,>
aesop
}
}}
}}
})
<;>
aesop
exact h_main
35


Reviews:
[{"review_id": "MFxzY5BZ14", "reviewer": "Reviewer_Kc9L", "summary": "The paper introduces GAR (Generative Adversarial Reinforcement Learning) for formal theorem proving in Lean. Unlike traditional expert iteration or RL for theorem proving with a fixed statement set, GAR dynamically generate new statements at the right difficulty level for the prover, forming an implicit curriculum. The method consists of a composer that generates new statements by fusing existing statements and a prover. Both components are trained with RL. The composer is incentivized to generate statements that are challenging but provable for the current prover. Experiments on MiniF2F and ProofNet shows improvements to the prover's capability.", "questions": "N/A", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "* The paper addresses a critical bottleneck in current neural theorem provers, i.e., the reliance on a fixed and limited set of theorem statement. Having the model conjecturing and proving new statement is a promising direction. The design space here is quite big, and GAR represents one reasonable method in this space.\n* Experiments show good improvements on MiniF2F and ProofNet.", "weaknesses": "* GAR is not the first attempt to augment the set of formal statements. For example, the scaffolded data synthesis in Goedel-Prover-V2 tries to generate simpler variants of hard problems and harder variants of simple problems. STP also generates new statements based on existing statements. The fuser in this paper is different from those methods, but it would be great if the authors can make the comparison more explicit. \n* MiniF2F is already saturated. SOTA methods are close to 100%. Experiments on PutnamBench would make this paper much stronger.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "WZAChrpKKe", "reviewer": "Reviewer_oK7C", "summary": "The paper proposes a variant of self-play theorem proving (conjecturer-prover adversarial training) where the conjecturer fuses two statements to create a statement with higher difficulty \"Composability\" is a frequently observed problem in LLMs, and the method directly tackles this issue. With small budgets of additional training, the method improves the initial already highly optimized models by a significant margin.", "questions": "- Can you expand on the issue of <analysis> ?\n- Why the statement modification loss and not simply freezing the statement (and punishing any modifications as fully incorrect)? Doesn't this give an optimal policy that is not intended? Why doesn't that happen in practice?\n\nNits:\neq 7: r_{ijk} needs a correctness term instead of 1?\nAlg. 1: typo in line 7", "limitations": "", "rating": 8, "confidence": 5, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "The method is sensible, the numbers are very good, the paper is very clearly written.\nThe scope is limited because there are many ways of generating synthetic statements and there was no comparison to other synthetic data methods (STP, Magicoder), but it appears that the authors have found a particularly effective method for this.", "weaknesses": "No comparisons to other synthetic data generation methods.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "MZJaBFaWIv", "reviewer": "Reviewer_TB6c", "summary": "This work introduces a novel RL framework (GAR) that trains not only a solver, but also a fuser designed to generate new problems suitable for the solver's current training stage. To be specific, in the context of automated theorem proving, the prover (solver) is trained to solve problems. Concurrently, the fuser attempts to generate problems that are provable in Lean (by the current provers) but possess a relatively low pass rate, thus making them \"difficult but approachable.\" The fuser is also trained during the RL process, creating an adversarial environment. The experimental results demonstrate the effectiveness of this method.", "questions": "Regarding Table 1, could you please explain why your reported results for previous works (Kimina, Deepseek, Goedel) are all significantly lower than those in their original papers? Did you encounter any issues with your experimental setup, such as a different Lean version, that might account for this mismatch?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "The overall quality and clarity of this work are good. Its motivation and methodology are described in detail. The proposed method also demonstrates significance, as it is potentially applicable to domains beyond automated theorem proving.", "weaknesses": "Regarding novelty, the idea of generating problems with appropriate difficulty levels has been explored by prior works, such as STP and Goedel-Prover-V2. STP, in particular, also trained a model to generate new problems in an adversarial way. The main difference appears to be that this work uses RL, whereas STP used expert iteration (SFT). This overlap weakens the originality and significance of the current paper.\n\nAdditionally, some experimental results in Table 1 are questionable. It appears that the reported results for prior works are all much lower than those originally published in their respective papers.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "rdrSaHrC2p", "reviewer": "Reviewer_BPXJ", "summary": "This paper presents Generative Adversarial Reinforcement learning, a framework for adversarial co-training of theorem provers and problem generators in the Lean environment.\nGAR jointly optimizes a statement fuser that composes new mathematical statements and a prover that attempts to prove them, forming a self-improving loop. In each iteration, the fuser generates new, harder statements by combining two natural-language problems from a large dataset from Numina-Math and Lean-Workbook, which are then automatically formalized into Lean. The prover produces proofs for these statements, and Lean verification provides reward signals to both models.\n\nThrough this interaction, the fuser learns to propose “hard but solvable” problems while the prover learns to solve increasingly challenging ones. The framework yields consistent improvements over strong RL-trained baselines on MiniF2F and ProofNet, and demonstrates that jointly evolving generators and solvers can outperform direct reinforcement learning on static datasets.", "questions": "The reported statement-modification rate under full GAR (around 30–50%) seems unreasonably high. Since this behavior reflects an instruction-following failure rather than a Lean reasoning limitation, and your prover prompt is identical to the official prompts of DeepSeek-Prover-V2 and Goedel-Prover-V2, there is no prompt-shift factor that could explain it.\n   \nPlease therefore report:\n   - the modification rates of DeepSeek-Prover-V2 and Goedel-Prover-V2 under their original prompts (no GAR); and\n   - the corresponding rate of the GAR-trained prover under the same prompts.\n\nSuch a comparison is important, because a statement-modification rate this high, combined with a relatively small sample size (pass@32), yet still achieving strong benchmark performance, is highly questionable.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "* Novel formulation: The paper introduces a clear and well-motivated adversarial training paradigm for formal theorem proving, aligning problem difficulty with prover capability.\n* Empirical gains: GAR achieves measurable and consistent improvements on competitive baselines, even when those baselines are already heavily RL-trained.\n* Clarity and reproducibility: The training procedure, algorithmic structure, and implementation details are well described, with clear experimental setups and evaluation metrics.\n* Significance: The proposed paradigm is general and could influence future work on co-evolving reasoning models in other verifiable domains.", "weaknesses": "1. Lack of a frozen-fuser control:\n   The paper always updates both the fuser and the prover in each GAR iteration. A variant that keeps the fuser fixed (for example, using the initial fuser) while training only the prover is missing. This is necessary to determine whether the gains derive from adversarial co-adaptation or simply from exposure to more generated data.\n\n2. Absence of an SFT-only baseline:\n   All experiments start from provers that have already undergone heavy RL fine-tuning. It remains unclear whether GAR would still provide improvement if applied directly to a purely SFT-trained prover. This limits understanding of GAR’s generality and its effectiveness from weaker starting points.\n\n3. No comparison with single-input statement generation:\n   The current fuser fuses two NL statements into one new problem. There is no experiment showing what happens if the model generates or rewrites new statements from a single input problem (similar to iterative conjecturing). This ablation would clarify whether the two-input fusion design is critical to the observed gains.\n\n4. Ambiguity in the Statement Fuser study:\n   The difficulty analysis (Table 2) evaluates only problems produced by the evolving fuser—the same distribution used to train the GAR prover. The observed decline in base-prover accuracy might reflect distributional or stylistic shift rather than genuine difficulty increase. A control using random samples from Dstat would help validate the claimed implicit curriculum effect.\n\n5. Limited exploration of the statement-modification penalty:\n   The ablation in Table 3 removes penalties from both the fuser and the prover simultaneously, but does not include one-sided removals or a hard-ban condition. The paper would benefit from a more granular investigation of these choices.\n\n6. Unfair efficiency comparison:\n   The efficiency discussion (Appendix B.1) compares GAR, built upon already RL-trained long-CoT provers, with Kimina-Prover, which is trained from SFT. Because the starting points differ significantly, the efficiency claim is not directly justified.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)