betaFeedback

WorksComputer Science

DeepSeek-Prover: Advancing Theorem Proving in LLMs through Large-Scale Synthetic Data

Abstract

Proof assistants like Lean have revolutionized mathematical proof verification, ensuring high accuracy and reliability. Although large language models (LLMs) show promise in mathematical reasoning, their advancement in formal theorem proving is hindered by a lack of training data. To address this issue, we introduce an approach to generate extensive Lean 4 proof data derived from high-school and undergraduate-level mathematical competition problems. This approach involves translating natural language problems into formal statements, filtering out low-quality statements, and generating proofs to create synthetic data. After fine-tuning the DeepSeekMath 7B model on this synthetic dataset, which comprises 8 million formal statements with proofs, our model achieved whole-proof generation accuracies of 46.3% with 64 samples and 52% cumulatively on the Lean 4 miniF2F test, surpassing the baseline GPT-4 at 23.0% with 64 samples and a tree search reinforcement learning method at 41.0%. Additionally, our model successfully proved 5 out of 148 problems in the Lean 4 Formalized International Mathematical Olympiad (FIMO) benchmark, while GPT-4 failed to prove any. These results demonstrate the potential of leveraging large-scale synthetic data to enhance theorem-proving capabilities in LLMs. Both the synthetic dataset and the model will be made available to facilitate further research in this promising field.

Introduction

In modern mathematics, the increasing complexity of proofs presents substantial challenges for peer review. This complexity has led to the acceptance of erroneous proofs, with critical flaws often detected only after considerable time. To address these issues, formal mathematical languages such as Lean [7, 20], Isabelle [21], and Coq [The Coq Development Team] have been developed. These languages enable the creation of computer-verifiable proofs [Avigad, 2023]. However, crafting formal proofs demands significant effort, specialized expertise, and poses challenges even for seasoned mathematicians. Consequently, the significance of automated theorem proving is on the rise [27].

To reduce the effort involved in writing formal mathematical proofs, several approaches [22, 11, 9, 23, 17, 12, 37] have been developed, primarily focusing on search algorithms that explore potential solutions for proposed theorems. However, these methods often struggle with the vast search spaces required for complex theorems, rendering them ineffective for more intricate proofs [19]. Recently, advances in large language models (LLMs) have introduced a novel strategy,

Preprint. Under review. utilizing pre-trained models to guide the search process. Although these new methods [13, 38, 35] represent significant improvements, they still fall short of practical applicability due to the lack of parallel corpus. Unlike conventional programming languages such as Python or Java, formal proof languages are used by relatively few mathematicians, resulting in limited datasets. Recent advances in autoformalization [Wu et al., 2022] allow more aligned data to be synthesized to train LLM-based automated theorem provers. Nevertheless, the resulting dataset remains too small to fully unleash the capabilities of LLMs.

To address this issue, we propose a method for generating extensive Lean 4 proof data from informal mathematical problems. Our approach translates high-school and undergraduate-level mathematical competition problems into formal statements. We then automate proof generation using a large language model (LLM) and verify the correctness of these proofs within the Lean 4 environment. The primary challenge of this method is to ensure both the scale and quality of the synthetic data.

Quality Assurance: We enhance the quality of generated proofs through a multi-step process. First, we filter out simple statements using a quality scoring model and exclude invalid statements via a hypothesis rejection strategy. Our novel iterative framework then improves proof quality by initially generating synthetic statements from informal math problems using an under-trained LLM fine-tuned on limited data. These statements are used to generate corresponding proofs, which are validated for correctness using a Lean 4 verifier. The correct theorem-proof pairs are subsequently used to further train the initial model. Through several iterations, the model trained on large-scale synthetic data becomes significantly more powerful than the originally under-trained LLMs, resulting in higher-quality theorem-proof pairs.

Scale Assurance: To accelerate the proof generation process, our method addresses the challenge of the large search space for proofs. A significant cause of delays is the generation of unprovable statements that continue to be processed until they reach the time limit. To mitigate this, we propose proving negated statements in parallel. Once either the original statement or its negation is proved, the entire proving process is terminated.

We assess the effectiveness of our method on Lean 4 theorem proving using 488 problems from miniF2F [39] and 148 problems from the FIMO benchmarks [18]. We utilize DeepSeekMath 7B [26], a state-of-the-art mathematical model, as our base. The results show that our iteratively trained model performs strongly, achieving 46.3% accuracy in whole-proof generation on the miniF2F-test benchmark with 64 samples, surpassing GPT-4 [1] at 23.0% and a reinforcement learning method at 41.0%. Additionally, our approach solved 4 out of 148 problems in the FIMO benchmark with 100 samples, while GPT-4 solved none, and our approach solved 5 with 4096 samples. Ablation experiments indicate that the model progressively solves more problems in miniF2F with each iteration. In summary, our paper makes the following contributions:

  • We introduce an iterative method to synthesize 8 million formal statements, each accompanied by a formal proof, from informal math problems. Experimental results demonstrate that this method significantly enhances both the scalability and quality of synthetic data.

  • Our model, trained on this synthetic dataset, achieves state-of-the-art performance on benchmarks, with whole-proof generation accuracies of 46.3% using 64 samples and 52% cumulatively on the Lean 4 miniF2F test. This surpasses the baseline GPT-4 at 23.0% with 64 samples and a tree search reinforcement learning method at 41.0%. Additionally, our model successfully proved 5 out of 148 problems in the Lean 4 Formalized International Mathematical Olympiad (FIMO) benchmark, while GPT-4 failed to prove any.

  • We contribute to the mathematical and AI communities by creating and open-sourcing a large dataset of high-quality formal mathematical proofs, thereby fostering further research and development in automated theorem proving.

Background and Related Works

Automated theorem proving has been a significant area of interest in artificial intelligence research since its inception [5]. Initial efforts were directed at simpler logical frameworks, which led to the development of highly efficient first-order theorem provers like E [25] and Vampire [16]. Nonetheless, these tools often fall short in handling complex theorems commonly found in modern proof assistants such as Lean [7], Isabelle [21], and Coq [The Coq Development Team]. The advent of recent deep learning models and model-guided search techniques has reinvigorated the field [4]. This modern approach has not only enhanced the capabilities of ATP systems but also expanded their applicability in solving more intricate mathematical problems.

ATP with Neural Models. With the development of deep learning, several approaches have been proposed to combine neural models with ATP [19]. A series of ATP approaches adopts tree search algorithms guided by neural models [22, 9, 23, 12, 37]. These approaches primarily utilize reinforcement learning techniques to enhance the accuracy of the model [15, 6, 17] (Wu et al. 2021). Since the search space is significantly large, the searching process consumes considerable time and computing resources.

Another series of ATP approaches harnesses the power of large language models. These approaches typically involve language models that are fine-tuned with open-source proof data and interact with verifiers via a state-action transition program [22, 11, 9, 23, 17, 12, 37]. This process iteratively generates proof steps and verifies their correctness with formal verifiers. It then generates the next proof steps based on the proof states returned by the formal verifiers. Although these approaches achieve high performance, they are computationally intensive. To enhance efficiency, recent researches leverage language models to generate complete formal proofs directly [8, 13, 38, 35], thus bypassing the iterative interaction during proof generation.

Autoformalization for Formal Mathematics. Due to the limited availability of formal corpora for training, the performance of current large language models (LLMs) is also constrained. Thus, some approaches propose autoformalization [13] (Wu et al. 2022), which involves converting natural language descriptions into formal statements that can be verified by proof assistants. Several studies have generated synthetic datasets of formal proofs using rule-based transformations of existing theorems [31, 36] (Wu et al. 2020). While effective, these methods are constrained by their reliance on predefined rules and lack flexibility for broader applications. Recent methodologies adopt large language models to translating natural language problems into formal statements [10]. However, these datasets remain smaller than needed and are limited to small mathematical benchmarks, leading to only minor improvements in training outcomes for language models. In this paper, we aim to synthesise formal proofs via autoformalization at a much larger scale to boost the performance of a neural prover.

Approach

In this section, we introduce our approach, which consists of four key processes as depicted in Figure 1. The initial phase concentrates on generating formal mathematical statements from a broad collection of informal math problems, necessitating further proof. Next, the autoformalized statements are filtered through model scoring and hypothesis rejection methods to select high-quality statements. These statements are then proved by a model called DeepSeek-Prover, with their correctness verified by the formal verifier called Lean 42, yielding validated formal statements and proofs. These data serve as synthetic data for fine-tuning the DeepSeek-Prover. After enhancing DeepSeek-Prover, we repeat the entire previously described process. This cycle continues until the improvements in DeepSeek-Prover become marginal. Notably, to enhance proof efficiency, we prove concurrently both the original statements and their negations. This method has the advantage of swiftly discarding the original statement when it is invalid by proving its negation. The details of each phase will be described in the subsequent sections.

Figure 1. An overview of our approach.

Autoformalization

The generation of formal proof data fundamentally relies on the availability of a substantial corpus of formal statements. In practice, however, amassing a large collection of manually crafted formal statements is challenging. Fortunately, the internet is replete with math-related problems expressed natural language. By autoformalizing these informal mathematical problems, we can generate a vast repository of formal statements.

We have observed that problems with explicit conditions and well-defined goals are typically easier to formalize compared to advanced mathematical topics that necessitate intricate definitions and constructions. Consequently, this paper primarily examines high school and undergraduate-level competition problems, with a particular emphasis on algebra and number theory, and to a lesser extent, combinatorics, geometry, and statistics. Despite their apparent simplicity, these problems often involve complex solution techniques, making them excellent candidates for constructing proof data to improve theorem-proving capabilities in Large Language Models (LLMs). To compile our dataset, we employed web scraping and careful data cleaning techniques to extract problems from online resources featuring high school and undergraduate exercises, exams, and competitions, resulting in a dataset of 869,659 high-quality natural language math problems.

Specifically, we initialized the DeepSeek-Prover using the DeepSeekMath-Base 7B model [26]. Initially, the model struggled to convert informal math problems into formal statements. To address this, we fine-tuned the DeepSeek-Prover model using the MMA dataset [14], which comprises formal statements from Lean 4’s mathlib3 that were back-translated into natural language problem descriptions by GPT-4. We then instructed the model to translate these natural language problems into formal statements in Lean 4 using a structured approach.

Prompt:

Mathematical Problem in Natural Language:
{$informal_statement_with_answers}
Translate the problem to Lean 4 (only the core declaration):
“‘lean4

Response:

{$formal_statement}
“‘

Quality Filtering

The quality of the autoformalized statements was found to be suboptimal due to two main issues. Firstly, many formal statements were overly simplistic. To address this, we developed scoring criteria and provided examples from miniF2F-valid as few-shot examples to guide the DeepSeek-Prover model in evaluating the content and quality of these statements using a chain-of-thought approach. Manual review of these scores confirmed that the model’s evaluations closely matched human intuition and expectations. Specifically, the model was instructed (see Appendix § 7.§ 1 for the detailed prompt) to classify the quality of each formal statement into categories: "excellent," "good," "above average," "fair," or "poor." Statements rated as "fair" or "poor" were subsequently excluded.

The second issue pertains to formal statements that, although provable, are based on inconsistent hypotheses leading to vacuous conclusions, rendering the conclusions meaningless in mathematics. For example, consider the following model-generated statement:

example (θ : ℝ) (h₀ : ∀ z : ℂ, z ^ 2 = -1 ∧ z ^ 3 = -1 ∧ z ^ 6 = 1) (h₁ :
  Real.tan θ = 2 * Real.sqrt 3) : θ = 5 * Real.pi / 3

Here, the hypothesis z2=−1∧z3=−1∧z6=1z^2 = -1 \land z^3 = -1 \land z^6 = 1 for all complex numbers is clearly false, making any derived conclusions meaningless. To eliminate such cases from our dataset, we implemented a hypothesis rejection method. This involves using the DeepSeek-Prover model to attempt proving the formal statement with ’False’ as the conclusion. A successful proof indicates an invalid hypothesis, prompting exclusion of the statement. An example is shown below:

example (θ : ℝ) (h₀ : ∀ z : ℂ, z ^ 2 = -1 ∧ z ^ 3 = -1 ∧ z ^ 6 = 1) (h₁ :
  Real.tan θ = 2 * Real.sqrt 3) : False := by
  simpa using h₀ 1

By applying this dual strategy of model scoring and hypothesis rejection, we curated a refined set of 712,073 high-quality formal statements, providing a robust foundation for further proof synthesis.

Statement Proving

After creating a substantial corpus of high-quality formal statements, we employed the model to search for proofs of these statements. Traditionally, language models have been used predominantly in a brute-force manner to prove theorems—repeatedly attempting until a valid proof is found or computational resources are exhausted. This approach is inefficient for our purposes. Typically, language models are applied to human-curated formal statements that are carefully crafted and generally true and provable; however, in our task of proving autoformalized statements, many of the statements produced by the model may be incorrect. Indeed, it is unreasonable to expect the model to validate a false proposition within any reliable proof system. This issue becomes more pronounced during large-scale autoformalization, where we observed that at least 20% of the formal statements generated by our model, even after quality filtering, were incorrect, leading to significant computational waste if addressed with brute force.

To minimize resource wastage on unprovable statements and improve the efficiency of the proof search process, we exploited the logical symmetry between a statement and its negation to accelerate proof synthesis. We implemented dual concurrent proof searches for each synthetic statement—one for the statement Γ⊢P\Gamma\vdash P and another for its negation Γ⊢¬P\Gamma\vdash\neg P. The search terminates as soon as a valid proof is found for either, conclusively demonstrating the unprovability of the other. Each proof search stream attempts up to kk proofs unless a valid proof emerges sooner.

All validated proofs, whether they justify the original theorems or their negations, are then aggregated to further train the DeepSeek-Prover. Thus, this dual approach serves as a form of data augmentation, enriching the dataset with both propositions and their negations—even if the original propositions were not correctly formalized by the model.

Iterative Enhancement

Since the entire pipeline heavily relies on the DeepSeek-Prover, enhancing the model’s performance after each iteration is crucial. To achieve this, we consistently fine-tune the model with newly generated data. The updated model is then utilized for subsequent autoformalization iterations. The key insight from this iterative process is that the model incrementally improves in strength and efficacy after each cycle of refinement and application. This iterative process continues until no further gains are observed. Consequently, the theorem-proof pairs generated by the model become increasingly higher in quality with each iteration. This method ensures that the DeepSeek-Prover consistently enhances its performance, ultimately producing superior theorem-proof pairs through continuous refinement.

Experiments

Experimental Setup

DeepSeek-Prover is built upon DeepSeekMath-Base 7B model [26], a decoder-only transformer [30] pre-trained on a corpus comprising 120 billion math-related tokens. We fine-tuned this model using a global batch size of 512 and a constant learning rate of 1×10−41 \times10^{-4}, incorporating 6,000 warmup steps with synthetic data. DeepSeek-Prover’s performance was evaluated against several baselines:

  • GPT-3.5 and GPT-4 [1], developed by OpenAI, are advanced generative AI models known for their effectiveness in diverse tasks, including code generation. Although not explicitly designed for theorem proving, their extensive scale and parameter count confer significant capabilities. In contrast, DeepSeekMath is a specialized model, explicitly pre-trained for mathematical content. We utilized both GPT-4 (specifically the GPT-4-turbo 0409 version) and DeepSeekMath to generate complete proofs for given theorems using a methodology similar to ours.

  • GPT-f [22], utilizing a GPT-2-inspired architecture [24], implements an iterative best-first search method to progressively generate and validate proof steps within a formal proof setting until a proof is either completed or resources are depleted. This methodology has been further advanced by Proof Artifact Co-Training [9], ReProver [37], Llemma [3], and COPRA [28], which employ either specialized fine-tuned models or versatile general-purpose models such as GPT-3.5 and GPT-4 for the generation of proof steps.

Main Results

This study addresses complex mathematical problems in algebra and number theory. We evaluate the theorem-proving efficacy of our model using the miniF2F [39] and FIMO [18] benchmarks. The metric pass@kk is employed to denote the scenario where at least one valid proof is discovered among the first kk attempts generated by the model.

Results on MiniF2F. The miniF2F benchmark consists of 244 validation and 244 test problems, ranging from basic arithmetic to competition-level problems, e.g., problems from the American Invitational Mathematics Examination (AIME), the American Mathematics Competitions (AMC), and the International Mathematical Olympiad (IMO). We use the version of miniF2F in Lean 4, which was released by the LeanDojo project (https://github.com/yangky11/miniF2F-lean4).

Table 1 compares various state-of-the-art methods on the miniF2F dataset. DeepSeek-Prover outperforms all with cumulative scores of 60.2% on miniF2F-valid and 52.0% on miniF2F-test, significantly higher than other methods, including GPT-4 which scores 25.41% and 22.95%, respectively. Even the best tree search method, Hypertree Proof Search with a 600M model, achieves only up to 58.6% on miniF2F-valid and 41.0% on miniF2F-test. DeepSeek-Prover’s scalability is evident as its performance improves with increased computational resources, rising from 30.03% using a greedy approach to 50.0% at 65536 generation times, demonstrating its effectiveness in handling complex proof scenarios. Examples of proved theorems of MiniF2F can be found in Appendix A.3.1.

MethodModel sizeGeneration timesminiF2F-validminiF2F-test
Tree Search Methods
COPRA (GPT-3.5) [28]-1 × 60-9.0%
COPRA (GPT-4) [28]-1 × 60-26.6%
Proof Artifact Co-Training [9]837M1 × 8 × 51223.9%24.6%
Proof Artifact Co-Training8 × 8 × 51229.3%29.2%
ReProver [37]229M1 × 3751-25.0%
Llemma [3]7B1 × 3200-26.2%
Llemma [3]34B1 × 3200-25.8%
Curriculum Learning [23]837M1 × 8 × 51233.6%29.6%
Curriculum Learning8 × 8 × 51241.2%34.5%
Curriculum Learning64 × 8 × 51247.3%36.6%
Hypertree Proof Search [17]600Mcumulative58.6%-
Hypertree Proof Search64 × 5000-41.0%
Whole-Proof Generation Methods
GPT-4-turbo 0409-6425.4%23.0%
DeepSeekMath-Base [26]7B12825.4%27.5%
DeepSeekMath-Basecumulative60.2%52.0%
DeepSeek-Prover7B1 (greedy)-30.0%
DeepSeek-Prover64-46.3%
DeepSeek-Prover128-46.3%
DeepSeek-Prover8192-48.8%
DeepSeek-Prover65536-50.0%

Table 1. Comparing with state-of-the-arts on the miniF2F dataset.

Results on FIMO. The FIMO benchmark comprises 149 formal problems which are sourced from the IMO shortlist translated into Lean 4. Our method successfully proved 4 theorems with 100 attempts per theorem, whereas GPT-4 failed to prove any. By increasing the number of attempts per theorem to 4,096, we successfully proved an additional theorem. Examples of proved theorems of FIMO can be found in Appendix A.3.2.

Ablation Studies

The Effectiveness of Large-scale Autoformalization

To demonstrate the effectiveness of large-scale autoformalization, we conducted a comparative analysis as shown in Table 2 between our autoformalized dataset and conventional datasets using expert iteration [22]. This iterative method entails generating formal proofs, fine-tune the model based on successful outcomes, and iterating this process until no additional enhancements are observed. The results indicate that models trained with our autoformalized data significantly outperform those trained solely with mathlib data.

Model#TokensminiF2F-validminiF2F-test
--25.4%27.5%
Mathlib0.238B30.3%31.2%
Autoformalized Statements3.108B48.8%42.6%

Table 2. Improvement in pass rates for miniF2F at pass@128 in models trained on formal proofs, including those derived from human-authored theorems in Lean 4’s mathlib and automatically formalized theorems.

The Effectiveness of Formal Statements Scoring

To demonstrate the effectiveness of the model in filtering out low-quality statements, we fine-tuned the DeepSeekMath-Base model using an equal amount of high-score proof data and low-score proof data to verify the quality of the data, as shown in Table 3. The table shows that the model trained on high-score proof data outperformed the model trained on low-score proof data by 4.5%. This enhancement underscores the utility of the model in accurately scoring and effectively filtering out lower-quality statements.

Scored ClassminiF2F-validminiF2F-test
"excellent", "good" and "above average"48.8%42.6%
"fair" and "poor"41.4%38.1%

Table 3. Improvement in pass rates for miniF2F at pass@128 in models trained on differently scored proof data.

The Effectiveness of Iterative Enhancement

Table 4 demonstrates a distinct correlation between the number of iterations in data synthesis and enhanced performance in theorem proving. This evidence underscores the success of our iterative enhancement strategy in augmenting theorem-proving capabilities. Successive iterations not only refine the model’s ability to handle complex proofs but also significantly increase the quality and quantity of the synthetic data produced.

ModelminiF2F-validminiF2F-test
iteration 038.1%34.0%
iteration 145.1%39.3%
iteration 249.2%41.4%
iteration 354.5%45.1%
iteration 459.4%46.3%

Table 4. Improvement in pass rates for miniF2F at pass@128 in models across successive training iterations, facilitated by the incremental integration of synthesized data via autoformalization.

The Effectiveness of Scaling Synthetic Theorem Proving Data

Our investigation into synthetic theorem proving data reveals a clear correlation between dataset size and model efficacy, as illustrated in Table 5. By examining subsets of the eight million generated proof data points, we observed that performance on the miniF2F benchmark improves proportionally to the exponential increase in dataset size. This pattern highlights the pivotal importance of large-scale datasets for boosting model proficiency in automatically formalizing natural language questions. These findings emphasize the significant potential and necessity of systematic data construction for progressing in the field of automated theorem proving.

SizeminiF2F-validminiF2F-test
1,00022.95%24.18%
10,00032.79%31.97%
100,00036.07%37.7%
1,000,00039.34%38.11%
8,066,62142.62%40.16%

Table 5. Improvement in pass rates for miniF2F at pass@128 in models trained with a larger fraction of synthesized data via autoformalization.

Case Studies

This section presents two case studies to demonstrate the application of our methods in autoformalizing theorems. It showcases both successful proofs and the identification of inconsistencies during the Hypothesis Rejection stage.

Autoformalized Theorem with Complete Proof

Example a. Problem: Prove that the determinant of the following matrix is zero.

(1cos⁡(a−b)cos⁡(a)cos⁡(a−b)1cos⁡(b)cos⁡(a)cos⁡(b)1)\begin{pmatrix} 1 & \cos(a-b) & \cos(a) \\ \cos(a-b) & 1 & \cos(b) \\ \cos(a) & \cos(b) & 1 \end{pmatrix}

Autoformalized Theorem in Lean:

example (a b : ℝ) :
  Matrix.det ![![1, Real.cos (a - b), Real.cos a], ![Real.cos (a - b), 1, Real.cos
    b], ![Real.cos a, Real.cos b, 1]] = 0

This approach effectively translates the algebraic expression of the matrix and its determinant into a formal language using Lean. The autoformalization captures the essence of the original mathematical statement by defining a specific 3×33 \times3 matrix dependent on real numbers aa and bb, and asserts that its determinant is zero. The formalization employs the Matrix.det function to compute the determinant, utilizing the ![...] notation for lists of lists in Lean to represent the matrix rows.

Autoformalization of Theorem with Inconsistent Hypotheses

Example b. Problem: Given a real number DD and the condition that for non-zero real numbers aa, bb, cc, the determinant of the matrix

(abc149312)\begin{pmatrix} a & b & c \\ 1 & 4 & 9 \\ 3 & 1 & 2 \end{pmatrix}

equals DD, prove that D2=154D^2 = 154.

Autoformalized Theorem in Lean:

example (D : ℝ) (h₀ : ∀ a b c : ℝ, a ≠ 0 ∧ b ≠ 0 ∧ c ≠ 0 →
  Matrix.det ![![a, b, c], ![1, 4, 9], ![3, 1, 2]] = D) : D ^ 2 = 154

The initial autoformalization incorrectly assumes that the condition D2=154D^2 = 154 universally applies to all non-zero real numbers aa, bb, and cc. This assumption is not supported by the problem statement, which does not claim universal applicability. Instead, the formalization should aim to either identify specific values of aa, bb, and cc that satisfy D2=154D^2 = 154 or demonstrate that no such values exist.

The model successfully identifies this inconsistency and provides a counterexample to demonstrate the absurdity of the hypothesis:

example (D : ℝ) (h₀ : ∀ a b c : ℝ, a ≠ 0 ∧ b ≠ 0 ∧ c ≠ 0 →
  Matrix.det ![![a, b, c], ![1, 4, 9], ![3, 1, 2]] = D) : False := by
  have h₁ := h₀ 1 2 3
  have h₂ := h₀ 1 4 9
  simp [Matrix.det_fin_three] at h₁ h₂
  linarith

A corrected version of the autoformalized theorem can be proposed as follows:

example (a b c : ℝ) (h₀ : a ≠ 0 ∧ b ≠ 0 ∧ c ≠ 0) :
  let D := Matrix.det ![![a, b, c], ![1, 4, 9], ![3, 1, 2]];
  D ^ 2 = 154

These examples illustrate the model’s capability to verify proofs and identify hypothesis inconsistencies effectively. Further details can be found in Appendix § 7.§ 2.

Conclusion

In this paper, we presented a method to generate extensive synthetic proof data from high-school and undergraduate-level mathematical competition problems. By translating natural language problems into formal statements, filtering out low-quality ones, and using iterative proof generation, we created 8 million proof data points and significantly improved the DeepSeekMath 7B model’s performance in ATP when trained on this synthetic data. Our model outperforms GPT-4 and other methods on benchmarks like miniF2F and FIMO. By open-sourcing our dataset and model, we aim to advance research in automated theorem proving and enhance the capabilities of large language models in formal mathematical reasoning. Currently, our work mainly focuses on algebra and number theory at the middle school and undergraduate levels. In future work, we will aim to expand the diversity of mathematical problems addressed, enhancing the general applicability of our methods in ATP.

Broader Impact

The research presented in this paper has the potential to significantly advance automated theorem proving by leveraging large-scale synthetic proof data generated from informal mathematical problems. This remarkable advancement can enhance the capabilities of large language models in formal theorem proving, contributing to more reliable mathematical proof verification and providing valuable educational resources for students and researchers. By directly releasing the code, model, and data, we aim to ensure the responsible use of our work, fostering further innovation and maintaining high standards of data privacy and intellectual property compliance.

Appendix / supplemental material

Prompts

Specifically, we use the following format for scoring for the quality of the formalized statements:

Prompt:

To evaluate whether a formal Lean4 statement will be of interest to the community, consider the following criteria:

1.  Relevance to Current Research:  Does the statement address a problem or concept that is actively being researched in mathematics or related fields? Higher relevance scores indicate greater potential interest.

2.  Complexity and Depth:  Is the statement complex enough to challenge existing theories and methodologies, yet deep enough to provide significant insights or advancements? Complexity and depth showcase Lean4’s capabilities and attract interest.

3.  Interdisciplinary Potential:  Does the statement offer opportunities for interdisciplinary research, connecting mathematics with other fields such as computer science, physics, or biology? Interdisciplinary projects often garner wide interest.

4.  Community Needs and Gaps:  Does the statement fill an identified need or gap within the Lean4 community or the broader mathematical community? Addressing these needs directly correlates with interest.

5.  Innovativeness:  How innovative is the statement? Does it propose new methods, concepts, or applications? Innovation drives interest and engagement.

Customize your evaluation for each problem accordingly, assessing it as ‘excellent‘, ‘good‘, ‘above average‘, ‘fair‘ or ‘poor‘.

You should respond in the following format for each statement:

‘‘‘

Translate the code to natural language:  (Detailed explanation of the informal statement, including any relevant background information, assumptions, and definitions.)
Analysis:  (Provide a brief justification for each score, highlighting why the statement scored as it did across the criteria.)
Assessment:  (Based on the criteria, rate the statement as ‘excellent’, ‘good‘, ‘above average‘, ‘fair‘ or ‘poor‘.)
‘‘‘

Case Studies of Autoformalization

Example a. Problem in Natural Language: For a real number aa and a function ff defined on real numbers, where f(x)=x3−ax−1f(x) = x^3 - ax - 1, if for all xx, f(x)≤0f(x) \le0 implies xx is either less than −1-1 or greater than 11, then aa must equal 3.

Autoformalized Theorems with Complete Proofs:

example (a : ℝ) (f : ℝ → ℝ) (h₀ : ∀ x, f x = x ^ 3 - a * x - 1) :
  (∀ x, f x ≤ 0 → x ∈ Set.Iio (-1) ∪ Set.Ioi 1) → a = 3 := by
  intro h₁
  have h₂ := h₁ 0
  simp [h₀] at h₂
have h₃ := h₁ 1
simp [h₀] at h₃
have h₄ := h₁ (-1)
simp [h₀] at h₄
linarith

Analysis: This is a simple example to illustrate common cases in the autoformalization procedure. The model is required to recognize natural language descriptions in the problem statement and formalize them into proper mathematical operators. In this case, the statement "either less than −1-1 or greater than 11" describes a union of interval (−∞,−1)∪(1,+∞)(-\infty, -1) \cup(1, +\infty), which has been accurately formalized to Set.Iio (-1) ∪ Set.Ioi 1, where Set.Iio (-1) denotes an infinite-open interval ends at −1-1, and Set.Ioi 1 denotes an open-infinite interval begins at 11.

Example b. Problem in Natural Language: Define two functions, FF and ff, where F(k)F(k) is the binomial coefficient of (k+2)(k + 2) choose 22, and f(k)f(k) is the binomial coefficient of (k+1)(k + 1) choose 11. For any natural number nn greater than or equal to 22, there exists a natural number kk such that f(k)f(k) equals (n−1)(n - 1) times nn divided by 22. Furthermore, there exists a natural number mm such that F(m)F(m) equals (n−1)(n - 1) times nn divided by 22, implying mm equals kk.

Autoformalized Theorems with Complete Proofs:

example :
  let F := fun k => Nat.choose (k + 2) 2;
  let f := fun k => Nat.choose (k + 1) 1;
  ∀ n : ℕ, 2 ≤ n → ∃ k : ℕ, f k = (n - 1) * n / 2 → (∃ m : ℕ, F m = (n - 1) * n / 2 → m = k) := by
  simp [Nat.choose, Nat.mul_sub_left_distrib, Nat.sub_sub, Nat.mul_one]
  aesop

Analysis: The formalization for this combinatorial problem involving binomial coefficients is semantically faithful and effective. The use of Nat.choose accurately represents the binomial coefficients, and the logical structure with existential quantifiers (∃\exists) and implications (→\to) aligns well with the problem’s requirements.

Example c. Problem in Natural Language: Given three 3-dimensional vectors aa, bb, and cc, where the dot product of aa and bb equals −3-3, the dot product of aa and cc equals 44, and the dot product of bb and cc equals 66. Prove that the dot product of bb with 7c−2a7c - 2a equals 4848.

Autoformalized Theorems with Complete Proofs:

example (a b c : ℝ × ℝ × ℝ)
(h₀ : a.1 * b.1 + a.2.1 * b.2.1 + a.2.2 * b.2.2 = -3)
(h₁ : a.1 * c.1 + a.2.1 * c.2.1 + a.2.2 * c.2.2 = 4)
(h₂ : b.1 * c.1 + b.2.1 * c.2.1 + b.2.2 * c.2.2 = 6)
: b.1 * (7 * c.1 - 2 * a.1) + b.2.1 * (7 * c.2.1 - 2 * a.2.1) + b.2.2 * (7 * c.2.2 - 2 * a.2.2) = 48 := by
linarith [h₀, h₁, h₂]

Analysis: This formalization result uses Cartesian product R×R×R\mathbb{R} \times\mathbb{R} \times\mathbb{R} to represent a 3-dimensional vector, where the components of a 3-dimensional Cartesian product are denoted by a.1a.1, a.2.1a.2.1, and a.2.2a.2.2 in Lean. The notation of dot products is expanded to the sum of element-wise products by definition.

Example Lean Proofs Generated by Our Model

Results on MiniF2F-Test Dataset

Example a. Problem in Natural Language: Show that for any real number xx and any natural number nn, if x>−1x > -1, then (1+nx)≤(1+x)n(1 + nx) \le(1 + x)^n.

Formal Proof:

theorem induction_1pxpownlt1pnx (x : ℝ) (n : ℕ) (h₀ : -1 < x) (h₁ : 0 < n)
: 1 + ↑n * x ≤ (1 + x) ^ n := by
  induction' h₁ with k h₁ <;> simp_all [Nat.succ_eq_add_one, pow_add, mul_add,
    add_assoc, add_comm, add_left_comm]
nlinarith [mul_self_nonneg (1 + x - 1)]

Example b. Problem in Natural Language: Ms. Blackwell gives an exam to two classes. The mean of the scores of the students in the morning class is 84, and the afternoon class’s mean score is 70. The ratio of the number of students in the morning class to the number of students in the afternoon class is 34\frac{3}{4}. What is the mean of the scores of all the students? Show that it is 76.

Formal Proof:

theorem amc12b_2021_p4 (m a : N) (h₀ : 0 < m ∧ 0 < a)
(h₁ : ↑m / ↑a = (3 : ℝ) / 4)
: (84 * ↑m + 70 * ↑a) / (↑m + ↑a) = (76 : ℝ) := by
have h₂ := h₀.1.ne’
have h₃ := h₀.2.ne’
field_simp at h₂ h₃ ⊢
ring_nf
norm_num
rw [div_eq_inv_mul] at h₁
field_simp at h₁
linarith

Example c. Problem in Natural Language: For how many positive integers mm does there exist at least one positive integer nn such that m⋅n≤m+nm \cdot n \leq m + n? Show that it is infinitely many.

Formal Proof:

theorem amc12a_2002_p6 (n : N) (h₀ : 0 < n)
: ∃ m, m > n ∧ ∃ p, m * p ≤ m + p := by
simp_all only [ge_iff_le, gt_iff_lt, mul_one, mul_add, mul_comm, mul_assoc,
    mul_left_comm]
use n + 1
constructor
exact Nat.lt_succ_self n
use 1
ring_nf
nlinarith

Results on FIMO Dataset

Example a. Problem in Natural Language: Determine all functions ff from the set of positive integers into the set of positive integers such that for all xx and yy there exists a non degenerated triangle with sides of lengths xx, f(y)f(y) and f(y+f(x)−1)f(y + f(x) - 1). The final answer is the identity function f(x)=xf(x) = x.

Formal Proof:

theorem fimo_2009_algebra_p3
(f : N → N)
(h₀ : ∀ x y, ∃ (a b c : N),
    a = x ∧
    b = f y ∧
    c = f (y + f x - 1) ∧
    a + b > c ∧
    a + c > b ∧
    b + c > a) :
∀ x, f x = x := by
have h₁ : f 0 = 0 := by
    specialize h₀ 0 0
    obtain ⟨_, _, _, h₁, h₂, h₃⟩ := h₀
    simp at *
    linarith
intro x
induction x with
| zero => exact h₁
| succ x ih =>
    specialize h₀ (x + 1) 0
obtain ⟨_, _, _, h₁, h₂, h₃⟩ := h₀
simp at *
linarith

Example b. Problem in Natural Language: Prove that for every positive integer nn, there exists a fraction ab\frac{a}{b} where aa and bb are integers satisfying 0<b≤n+10 < b \le\sqrt{n} + 1 and n≤ab≤n+1\sqrt{n} \le\frac{a}{b} \le\sqrt{n + 1}.

Formal Proof:

theorem fimo_2016_algebra_p5_1
    (n : ℕ)
    (h₀ : 0 < n) :
    ∃ a b : ℕ, 0 < b ∧ b ≤ n.sqrt + 1 ∧
      n.sqrt ≤ a / b ∧ a / b ≤ (n + 1).sqrt := by
  use n.sqrt, 1
  constructor <;>
  simp [h₀, Nat.sqrt_le_sqrt] <;>
  norm_num <;>
  linarith [Nat.sqrt_le_sqrt n]

Formal Verification Details

We verify the generated Lean 4 code with the following code as the prefix:

import Mathlib.Algebra.Algebra.Basic
import Mathlib.Algebra.Order.Floor
import Mathlib.Algebra.Associated
import Mathlib.Algebra.BigOperators.Basic
import Mathlib.Algebra.BigOperators.Order
import Mathlib.Algebra.BigOperators.Pi
import Mathlib.Algebra.GeomSum
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Algebra.GroupPower.Basic
import Mathlib.Algebra.GroupPower.Identities
import Mathlib.Algebra.Order.Floor
import Mathlib.Algebra.QuadraticDiscriminant
import Mathlib.Algebra.Ring.Basic
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Analysis.SpecialFunctions.Log.Base
import Mathlib.Combinatorics.SimpleGraph.Basic
import Mathlib.Data.Complex.Basic
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Finset.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Int.Basic
import Mathlib.Data.Int.GCD
import Mathlib.Data.Int.ModEq
import Mathlib.Data.Int.Parity
import Mathlib.Data.List.Intervals
import Mathlib.Data.List.Palindrome
import Mathlib.Data.Multiset.Basic
import Mathlib.Data.Nat.Basic
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Data.Nat.Digits
import Mathlib.Data.Nat.Factorial.Basic
import Mathlib.Data.Nat.ModEq
import Mathlib.Data.Nat.Multiplicity
import Mathlib.Data.Nat.Parity
import Mathlib.Data.Nat.Prime
import Mathlib.Data.PNat.Basic
import Mathlib.Data.PNat.Prime
import Mathlib.Data.Polynomial.Basic
import Mathlib.Data.Polynomial.Eval
import Mathlib.Data.Real.Basic
import Mathlib.Data.Real.Irrational
import Mathlib.Data.Real.NNReal
import Mathlib.Data.Real.Sqrt
import Mathlib.Data.Set.Finite
import Mathlib.Data.Sym.Sym2
import Mathlib.Data.ZMod.Basic
import Mathlib.Dynamics.FixedPoints.Basic
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.LinearAlgebra.AffineSpace.Independent
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.Logic.Equiv.Basic
import Mathlib.Order.Filter.Basic
import Mathlib.Order.LocallyFinite
import Mathlib.Order.WellFounded
import Mathlib.Topology.Basic
import Mathlib.Topology.Instances.NNReal
import Aesop

set_option maxHeartbeats 0
set_option trace.aesop true
set_option trace.aesop.proof true

open Nat Real Rat BigOperators

References

  1. [1]J. Achiam, S. Adler, S. Agarwal, L. Ahmad, I. Akkaya, F. L. Aleman, D. Almeida, J. Altenschmidt, S. Altman, S. Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023.arxiv.org/abs/2303.08774
  2. [3]Z. Azerbayev, H. Schoelkopf, K. Paster, M. D. Santos, S. McAleer, A. Q. Jiang, J. Deng, S. Bi- derman, and S. Welleck. Llemma: An open language model for mathematics. arXiv preprint arXiv:2310.10631, 2023.arxiv.org/abs/2310.10631
  3. [4]K. Bansal, S. Loos, M. Rabe, C. Szegedy, and S. Wilcox. Holist: An environment for machine learning of higher order logic theorem proving. In International Conference on Machine Learning, pages 454–463. PMLR, 2019.
  4. [5]W. Bibel. Automated theorem proving. Springer Science & Business Media, 2013.
  5. [6]M. Crouse, I. Abdelaziz, B. Makni, S. Whitehead, C. Cornelio, P. Kapanipathi, K. Srinivas, V. Thost, M. Witbrock, and A. Fokoue. A deep reinforcement learning approach to first-order logic theorem proving. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 6279–6287, 2021.
  6. [7]L. De Moura, S. Kong, J. Avigad, F. Van Doorn, and J. von Raumer. The lean theorem prover (system description). In Automated Deduction—CADE-25: 25th International Conference on Automated Deduction, Berlin, Germany, August 1-7, 2015, Proceedings 25, pages 378–388. Springer, 2015.
  7. [8]E. First, M. N. Rabe, T. Ringer, and Y. Brun. Baldur: Whole-proof generation and repair with large language models, 2023.arxiv.org/abs/2303.04910
  8. [9]J. M. Han, J. Rute, Y. Wu, E. W. Ayers, and S. Polu. Proof artifact co-training for theorem proving with language models. arXiv preprint arXiv:2102.06203, 2021.arxiv.org/abs/2102.06203
  9. [10]Y. Huang, X. Lin, Z. Liu, Q. Cao, H. Xin, H. Wang, Z. Li, L. Song, and X. Liang. Mustard: Mastering uniform synthesis of theorem and proof data. arXiv preprint arXiv:2402.08957, 2024.arxiv.org/abs/2402.08957
  10. [11]A. Q. Jiang, W. Li, J. M. Han, and Y. Wu. Lisa: Language models of isabelle proofs. In 6th Conference on Artificial Intelligence and Theorem Proving, pages 378–392, 2021.
  11. [12]A. Q. Jiang, W. Li, S. Tworkowski, K. Czechowski, T. Odrzygóźdź, P. Miłoś, Y. Wu, and M. Jamnik. Thor: Wielding hammers to integrate language models and automated theorem provers. Advances in Neural Information Processing Systems, 35:8360–8373, 2022a.arxiv.org/abs/2205.10893
  12. [13]A. Q. Jiang, S. Welleck, J. P. Zhou, W. Li, J. Liu, M. Jamnik, T. Lacroix, Y. Wu, and G. Lample. Draft, sketch, and prove: Guiding formal theorem provers with informal proofs. arXiv preprint arXiv:2210.12283, 2022b.arxiv.org/abs/2210.12283
  13. [14]A. Q. Jiang, W. Li, and M. Jamnik. Multilingual mathematical autoformalization. arXiv preprint arXiv:2311.03755, 2023.arxiv.org/abs/2311.03755
  14. [15]C. Kaliszyk, J. Urban, H. Michalewski, and M. Olsák. Reinforcement learning of theorem proving. Advances in Neural Information Processing Systems, 31, 2018.arxiv.org/abs/1805.07563
  15. [16]L. Kovács and A. Voronkov. First-order theorem proving and vampire. In International Conference on Computer Aided Verification, pages 1–35. Springer, 2013.DOI
  16. [17]G. Lample, T. Lacroix, M.-A. Lachaux, A. Rodriguez, A. Hayat, T. Lavril, G. Ebner, and X. Martinet. Hypertree proof search for neural theorem proving. Advances in neural information processing systems, 35:26337–26349, 2022.arxiv.org/abs/2205.11491
  17. [18]C. Liu, J. Shen, H. Xin, Z. Liu, Y. Yuan, H. Wang, W. Ju, C. Zheng, Y. Yin, L. Li, et al. Fimo: A challenge for formal dataset for automated theorem proving. arXiv preprint arXiv:2309.04295, 2023.
  18. [19]S. Loos, G. Irving, C. Szegedy, and C. Kaliszyk. Deep network guided proof search. arXiv preprint arXiv:1701.06972, 2017.arxiv.org/abs/1701.06972
  19. [20]L. d. Moura and S. Ullrich. The lean 4 theorem prover and programming language. In Automated Deduction–CADE 28: 28th International Conference on Automated Deduction, Virtual Event, July 12–15, 2021, Proceedings 28, pages 625–635. Springer, 2021.
  20. [21]L. C. Paulson. Isabelle a Generic Theorem Prover. Springer Verlag, 1994.
  21. [22]S. Polu and I. Sutskever. Generative language modeling for automated theorem proving. arXiv preprint arXiv:2009.03393, 2020.
  22. [23]S. Polu, J. M. Han, K. Zheng, M. Baksys, I. Babuschkin, and I. Sutskever. Formal mathematics statement curriculum learning. arXiv preprint arXiv:2202.01344, 2022.arxiv.org/abs/2202.01344
  23. [24]A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, I. Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.
  24. [25]S. Schulz. E–a brainiac theorem prover. Ai Communications, 15(2-3):111–126, 2002.DOI
  25. [26]Z. Shao, P. Wang, Q. Zhu, R. Xu, J. Song, M. Zhang, Y. Li, Y. Wu, and D. Guo. Deepseek-math: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024.
  26. [27]M. Shulman. Strange new universes: Proof assistants and synthetic foundations, 2024.
  27. [28]A. Thakur, Y. Wen, and S. Chaudhuri. A language-agent approach to formal theorem-proving. arXiv preprint arXiv:2310.04353, 2023.
  28. [30]A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.
  29. [31]M. Wang and J. Deng. Learning to prove theorems by learning to generate theorems. Advances in Neural Information Processing Systems, 33:18146–18157, 2020.arxiv.org/abs/2002.07019
  30. [35]H. Xin, H. Wang, C. Zheng, L. Li, Z. Liu, Q. Cao, Y. Huang, J. Xiong, H. Shi, E. Xie, et al. Leo-prover: Neural theorem proving with growing libraries. arXiv preprint arXiv:2310.00656, 2023.arxiv.org/abs/2310.00656
  31. [36]J. Xiong, J. Shen, Y. Yuan, H. Wang, Y. Yin, Z. Liu, L. Li, Z. Guo, Q. Cao, Y. Huang, et al. Trigo: Benchmarking formal mathematical proof reduction for generative language models. arXiv preprint arXiv:2310.10180, 2023.arxiv.org/abs/2310.10180
  32. [37]K. Yang, A. Swope, A. Gu, R. Chalamala, P. Song, S. Yu, S. Godil, R. J. Prenger, and A. Anandkumar. Leandojo: Theorem proving with retrieval-augmented language models. Advances in Neural Information Processing Systems, 36, 2024.arxiv.org/abs/2306.15626
  33. [38]X. Zhao, W. Li, and L. Kong. Decomposing the enigma: Subgoal-based demonstration learning for formal theorem proving. arXiv preprint arXiv:2305.16366, 2023.arxiv.org/abs/2305.16366
  34. [39]K. Zheng, J. M. Han, and S. Polu. MiniF2F: a cross-system benchmark for formal olympiad-level mathematics. arXiv preprint arXiv:2109.00110, 2021.arxiv.org/abs/2109.00110

Paper details

vlnc:W_3mzukahv
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents