acceptodds
Under review as a conference paper at ICLR 2027

Goedel-Architect: Streamlining Formal Theorem Proving with Blueprint Generation and Refinement

20 views

Abstract

We introduce Goedel-Architect, an agentic framework for formal theorem proving in Lean 4 centered on blueprint generation and refinement. A blueprint is a dependency graph of definitions and lemmas that builds up to the main theorem. First, Goedel-Architect generates a blueprint of formally stated definitions and lemmas, along with declared dependencies. This blueprint is optionally guided by a natural language proof. Then, a tool-equipped Lean prover component closes each open lemma node in parallel using relevant dependencies. Failed lemmas in turn drive refinement of the global blueprint. This strategy contrasts with other mainstream approaches which use recursive lemma decomposition, and can inefficiently loop on dead-end strategies. Using the open-weight DeepSeek-V4-Flash (284B-A13B) as the backbone, Goedel-Architect attains 99.2% pass@1 on MiniF2F-test and 75.6% pass@1 on PutnamBench. With an optional natural-language proof seeding the initial blueprint on the harder problems, we additionally close the remaining two MiniF2F-test problems (reaching 100%), lift PutnamBench to 88.8% (597/672), reach 95.5% (642/672) when Gemini 3.1 Pro supplies the natural-language proofs on the remaining problems, and solve 4/6 on IMO 2025, 11/12 on Putnam 2025, and 3/6 on USAMO 2026. This represents state-of-the-art performance for an open-source pipeline at a price point up to 500x less than comparable open-source pipelines.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Formal Theorem Proving, Lean, AI for Math, Agentic Pipelines

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_fx5ZOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Goedel-Architect is a Lean 4 theorem-proving pipeline that maintains a global blueprint (dependency graph) iteratively refined using proof, disproof, and forfeit feedback. With open-weight DeepSeek-V4-Flash, the 75.6% PutnamBench run costs 0.44 USD/problem (294 USD total). Reported baselines: ~5.8 USD/problem (Goedel-Architect + Gemini at 95.5%) vs 54–68 USD/problem (Aleph).

Critical strengths
  1. Open, cost-efficient pipeline at academic scale. 75.6% PutnamBench with 294 USD total spend (~100× cheaper than Hilbert's 3.9k USD on same metric). Open backbone (DeepSeek-V4-Flash) and fully reproducible budgets/prompts in appendix enable verification.

  2. Blueprint design beats top-down recursion on same backbone. Section 4.1 (Table 3): Hilbert reproduced on DeepSeek-V4-Flash drops to 83.6% vs Goedel-Architect's 99.2% on MiniF2F. Direct evidence that global blueprint + refinement loop outperforms recursive decomposition when backbone is held constant.

Critical weaknesses
  1. Reliance on proprietary models for frontier performance. While the open DeepSeek-V4-Flash pipeline achieves 75.6% on PutnamBench at low cost (0.44 USD/problem), reaching the headline 95.5% solve rate requires seeding with proprietary Gemini 3.1 Pro natural language proofs. This reliance on closed frontier models weakens the claim of a purely open-source solution at the state-of-the-art tier, where the cost advantage over peers like Aleph (54–68 USD) is ~10× rather than the advertised 500×.

  2. Incomplete ablation of blueprint mechanisms. The central claim that global blueprints outperform recursive decomposition lacks systematic causal ablation. Disproof and forfeit mechanisms are evaluated only via anecdotal case studies (Appendix B) rather than quantitative ablations disabling these channels, and the backbone comparison against Hilbert is reported only on the easier MiniF2F-test, leaving the harder PutnamBench row blank in Table 3.

Questions for authors
  1. Could the authors evaluate Hilbert on DeepSeek-V4-Flash on the 200-problem PutnamBench subset to confirm whether the pipeline advantage over recursive decomposition holds on harder problems under matched backbone and compute?

  2. Could the authors provide a quantitative ablation on PutnamBench disabling the disproof and forfeit channels to verify that these specific blueprint refinement mechanisms, rather than simply repeated sampling, drive the gains?

1 comment
AuthorsOpenReview ↗

Response to Reviewer fx5Z

We thank the reviewer for the careful reading and concrete suggestions. We address each point below.

1. Reliance on proprietary models for frontier performance. While the open DeepSeek-V4-Flash pipeline achieves 75.6% on PutnamBench at low cost (0.44 USD/problem), reaching the headline 95.5% solve rate requires seeding with proprietary Gemini 3.1 Pro natural language proofs. This reliance on closed frontier models weakens the claim of a purely open-source solution at the state-of-the-art tier, where the cost advantage over peers like Aleph (54–68 USD) is ~10× rather than the advertised 500×.

We agree that the open-weight and mixed-model results should be distinguished. Our fully open-weight settings achieve 75.6% on PutnamBench in the default run and 88.8% with additional runs and informal-proof guidance. The 95.5% result uses Gemini in both informal and formal stages; we will correct the description accordingly. The reported 500× cost reduction refers to the default setting versus Hilbert, not the 95.5% setting. We will clarify that these cross-system cost comparisons involve different models and budgets and do not establish an advantage under matched compute. It is also worth noting that even with closed-weight models, our system is still publicly accessible, in contrast to AlephProver, which cannot even be accessed via API.

2. Incomplete ablation of blueprint mechanisms. The central claim that global blueprints outperform recursive decomposition lacks systematic causal ablation. Disproof and forfeit mechanisms are evaluated only via anecdotal case studies (Appendix B) rather than quantitative ablations disabling these channels, and the backbone comparison against Hilbert is reported only on the easier MiniF2F-test, leaving the harder PutnamBench row blank in Table 3.

Q2. Could the authors provide a quantitative ablation on PutnamBench disabling the disproof and forfeit channels to verify that these specific blueprint refinement mechanisms, rather than simply repeated sampling, drive the gains?

To isolate each component's contribution to solve rate, we ran ablations that remove global graph revision, formal disproofs and structured failure diagnoses in turn. To stay within an academic budget, we used a pre-registered 48-problem PutnamBench subset, drawn at random from problems the default run solved within 1–8 iterations, with quotas so each feedback type is represented. Every arm, including the full system, was re-run from scratch with DeepSeek-V4-Flash-0423 and six refinement iterations.

ConditionSolvedSolve rate
Graph revision + disproof and forfeit channels43/4889.6%
Graph revision with only proved/unresolved feedback37/4877.1%
Fixed blueprint with repeated sampling24/4850.0%

With the same iteration budget, graph revision using only proved/unresolved feedback achieves a 77.1% solve rate, compared with 50.0% for repeated sampling on a fixed blueprint. Adding disproof and forfeit feedback further increases the solve rate to 89.6%. These results support graph revision's contribution beyond repeated sampling, with informative feedback providing an additional observed gain on this subset.

Q1. Could the authors evaluate Hilbert on DeepSeek-V4-Flash on the 200-problem PutnamBench subset to confirm whether the pipeline advantage over recursive decomposition holds on harder problems under matched backbone and compute?

We have not run the same-backbone Hilbert comparison on PutnamBench. Our existing comparison is limited to MiniF2F, and we acknowledge that it does not automatically establish an advantage over Hilbert on harder problems under matched compute, but we believe it does provide a signal as to the effectiveness of each method.

We thank the reviewer again and are happy to address any further questions.

Reviewer_Y1BWOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

Summary

This paper introduces GOEDEL-ARCHITECT, an open-source agentic framework for formal theorem proving in Lean 4 that replaces traditional top-down recursive goal decomposition with iterative blueprint generation and refinement. Starting from a formal theorem statement and an optional natural-language proof sketch, the system constructs an acyclic dependency graph of definitions and helper lemmas, which are then dispatched in parallel to a tool-equipped Lean prover that only accesses each node's declared parent dependencies. Rather than simply failing on unproved nodes, the prover either formally proves the lemma's negation via a compiler-verified counterexample or outputs a structured diagnostic post-mortem classifying the failure as a wrong statement or an overly difficult proof, allowing a refinement agent to globally repair hypotheses, rewire dependencies, or decompose hard steps while preserving already-proved nodes. With open-weight DeepSeek-V4-Flash backbone, GOEDEL-ARCHITECT achieves 99.2% pass@1 on MiniF2F-test and 75.6% pass@1 on PutnamBench for just $0.44 per problem, while scaling to 100% on MiniF2F-test and up to 95.5% on PutnamBench when guided by natural-language proof sketches, alongside solving 4/6 on IMO 2025, 11/12 on Putnam 2025, and 3/6 on the contamination-free USAMO 2026 benchmark.

Strengths

Critical strengths
  • The design of a global dependency-graph blueprint combines with diagnostic signals from proved/disproved/forfeited lemma nodes enables an effective iterative refinement pipeline.
  • Experimental results demonstrate the effectiveness of GOEDEL-ARCHITECT. Using only open-weight LLMs, the pipeline established a new cost-performance Pareto frontier, outperforming open-source SOTA on PutnamBench while reducing the API cost by 500x. Ablations also show the improvement comes from the iterative refinement of the pipeline rather than the agentic recursive nature.
Critical weaknesses
  • The paper has no mention of safe guards implemented to prevent LLMs to trivialize the problem, such as stating some lemmas as axiom and such.

  • The paper doesn’t mention clearly how the main theorem node is handled. Is the proof for the main theorem be done right at the beginning before all lemmas are proved or at the end?

  • The paper makes no comparison with ToMap [1], another work that also leverages multiple open-source formalizers and provers to formalize and prove lemmas

  • The paper only investigates the Math domain. Because the method is quite generic, it would be interesting to see how it would perform on other domains like Coding, especially given that we also have an open-source prover available for code verification (Goedel-Code-Prover [2]). It would also be interesting to see how GOEDEL-ARCHITECT tackles a frontier math problem rather than working on high-school competition and undergraduate math.

  • There is no further analysis on the blueprint other than the number of iterations for refinement. It would be interesting to see more statistics and real examples, such as the frequency of lemmas nodes that proved/failed/forfeited, actual Lean code for the blueprint, how the blueprint is changed after iterations, etc.

[1] Liu, Tian-Shuo, et al. "Efficient Test-Time Optimization for Multi-Agent Proof Autoformalization." arXiv preprint arXiv:2607.11307 (2026). [2] Li, Zenan, et al. "Goedel-code-prover: Hierarchical proof search for open state-of-the-art code verification." arXiv preprint arXiv:2603.19329 (2026).

Questions for authors

Please address the concerns listed above.

2 comments
AuthorsOpenReview ↗

Response to Reviewer Y1BW (1/2)

We thank the reviewer for the thoughtful feedback and suggestions. We address each point below.

The paper has no mention of safe guards implemented to prevent LLMs to trivialize the problem, such as stating some lemmas as axioms and such.

We will clarify the safeguards explicitly. The target theorem is preserved under its original signature, and success requires verification of the assembled proof. Although intermediate obligations may contain sorry during planning, the final theorem's transitive axiom dependencies must contain only the three axioms propext, Classical.choice, and Quot.sound; sorryAx and other axioms are rejected, so there is no chance of a trivial solution in our performance numbers.

The paper doesn't mention clearly how the main theorem node is handled. Is the proof for the main theorem be done right at the beginning before all lemmas are proved or at the end?

The main theorem is an unproved node in the initial blueprint and is attempted alongside other unresolved lemmas in parallel, using its declared dependencies as assumptions. Its local proof may therefore be found before those dependencies are proved.

The paper makes no comparison with ToMap [1], another work that also leverages multiple open-source formalizers and provers to formalize and prove lemmas.

We will add ToMap to our related work discussion. ToMap optimizes decompositions of a supplied informal proof using LLM rubric feedback before downstream formalization and proving. Goedel-Architect interleaves formal proving with revision of lemma statements and dependencies. A key distinction is revision after proof attempts: ToMap's main algorithm does not return to decomposition revision after downstream proving, whereas Goedel-Architect uses formal disproofs and structured failure diagnoses to repair the blueprint and retry. Our ablation on 48 selected PutnamBench problems demonstrates the contribution of this revision mechanism:

ConditionSolvedSolve rate
Full system43/4889.6%
Revision removed; repeated proving on a fixed blueprint24/4850.0%

Under the same iteration cap, enabling revision yields 19 additional solves, rather than relying solely on repeated proof attempts on unchanged lemmas. This isolates revision's contribution within our system; it is not a direct performance comparison with ToMap.

AuthorsOpenReview ↗

Response to Reviewer Y1BW (2/2)

The paper only investigates the Math domain. Because the method is quite generic, it would be interesting to see how it would perform on other domains like Coding, especially given that we also have an open-source prover available for code verification (Goedel-Code-Prover [2]). It would also be interesting to see how GOEDEL-ARCHITECT tackles a frontier math problem rather than working on high-school competition and undergrad math.

We agree that it is interesting to extend our method to other domains. In a brief effort to do this, we tried code-verification tasks from Verina and CLEVER, alongside research-level Erdős problems. Using DeepSeek-V4.1-Flash without supplied informal proofs, we successfully verified the following:

ProblemCost
Verina 48: insertion sort—sortedness and permutation$0.010
Verina 75: Kadane's maximum-subarray algorithm$0.025
Verina 47: interval merging—coverage and non-overlap$0.085
Verina 62: two-pointer trapping-rainwater algorithm$0.273
Verina 8: gas-station algorithm—correctness and minimal starting index$0.102
CLEVER HumanEval/0: detecting nearby elements$0.014
Erdős 1052: every unitary perfect number is even$0.032
Erdős 198: a Sidon set whose complement contains no infinite arithmetic progression$0.022

We also tested Erdős 457, which remained unsolved after approximately $0.30 in logged model cost. However, we leave broader applications to future work and focus on the mathematics domain, as it offers a large suite of existing methods to which we can compare.

There is no further analysis on the blueprint other than the number of iterations for refinement. It would be interesting to see more statistics and real examples, such as the frequency of lemmas nodes that proved/failed/forfeited, actual Lean code for the blueprint, how the blueprint is changed after iterations, etc.

Following your comment, we audited the default 672-problem run to further characterize blueprint structure and its evolution:

QuestionFinding
How large is an initial blueprint?Median 7 lemmas, including the target theorem; 7 dependency links; dependency depth 3.
What happens after a formal disproof?Among disproved lemmas passed to the reviser, 55% have their statements changed and 29% are removed.
Are the revised lemmas subsequently proved?Of the lemmas restated after a disproof, 57% are proved in the next pass.
What happens when a lemma is judged too difficult?Among such lemmas retained during revision, 65% receive at least two new supporting lemmas.
Are earlier proofs preserved?87% of previously proved nodes are carried into the next pass without another prover attempt.

These statistics describe revision behavior, and our ablations separately measure component contributions to solve rate. We will include a more detailed analysis in the revised draft. We have also developed an interactive visualization displaying each node's actual Lean code and changes to statements, dependencies, and proof status across iterations. To preserve anonymity, we omit the link here and will make it available after the review process.

We thank the reviewer again and are happy to address any further questions.

Reviewer_33H4OpenReview ↗
Rating
3(+1)
Confidence
3(−1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Goedel-Architect, an agentic framework for formal math theorem proving in Lean 4. In the proposed methodology, it generates a blueprint of definitions, lemmas, and dependencies, proves lemmas in parallel and then it revises them using formal disproofs and structured failure diagnoses while reusing proved lemmas. With an open-weight model backbone, the proposed default pipeline solves 99.2% of MiniF2F-test and 75.6% of PutnamBench. Natural language proof guidance and increased refinement budget further improve the PutnamBench performance on pass@1.

Critical strengths
  1. Strong performance and low inference cost. Solving 508/672 PutnamBench within $294 by an open-weight model is significant.
  2. The failure-driven refinement is obviously interesting. It divides formally disproved lemmas from unsuccessful proof attempts and also uses these outcomes to repair statements, split lemmas, and change dependencies.
  3. Comparisons under the same backbone are useful. Comparisons with direct generation and tool-integrated reasoning suggests that the improvements are not solely due to the difference of the backbone.
  4. Providing Concrete implementation details. Prompts, token/retry/iteration budgets, and repair examples are supplied to help explain system behavior.
Critical weaknesses
  1. Novelty to the close studies is not clear. For example, the ProofFlow paper constructs dependency DAGs and formalizes steps as Lean lemmas. “Delta Prover” paper revises decomposition strategies using unsolved subproblems. The LEAP paper has already examined constructing blueprints of proving, AND-OR DAGs, cross-branch lemma sharing, progress preservation, and backtracking. Therefore I assume “global graphs versus recursive decomposition” is not shown from the current manuscript. I recommend that authors clarify specific new updates and explain their necessity in the methodology.
  2. Controlled comparisons with the related methodologies are missing. Although the same-backbone comparison with Hilbert is useful, comparisons with LEAP and Delta Prover under the same model and compute budget are ideal to separate the proposed refinement methodology. As LEAP is contemporaneous, priority and technical differences should be discussed separately.
  3. Ablation experiments are missing. It is ideal for the global graph revision, formal disproofs, structured failure diagnoses, and/or proof reuse. Negations occurring on 292/672 problems may present the usage frequency.
  4. Disproof generation and its integration to the methodology should be separated. The “Learning to Disprove” paper has already studied LLM-generated counter examples with Lean verification. It seems that the core contribution in this paper is to integrate it into graph repair, but this advantage over the ordinary failure feedback is not fully tested.
  5. Performance and costs are ideally compared in multiple conditions. Pipeline-level pass@1 includes many internal attempts and refinements and is not directly comparable with other K. Hilbert uses a different benchmark size in different model prices. The highest scores are also performed with external models, further attempts and budgets. These results are ideally separated from the default setting and compared under common compute budgets.
Questions for authors

See weakness.

7 comments
AuthorsOpenReview ↗

Response to Reviewer 33H4 (1/2)

We thank the reviewer for the detailed and constructive review. We address each point below.

1. Novelty relative to close work is insufficiently clear. ProofFlow constructs dependency DAGs and formalizes steps as Lean lemmas. Delta Prover revises decomposition strategies using unsolved subproblems. LEAP already supports blueprints, AND-OR DAGs, cross-branch lemma sharing, progress preservation, and backtracking. Thus, "global graphs versus recursive decomposition" alone does not establish the distinction. The paper should identify specific new update operations and explain their necessity.

The distinction lies in joint graph construction and graph revision, beyond the DAG representation itself.

Joint graph construction. LEAP plans each supporting lemma independently, conditioned only on the current goal. Goedel-Architect plans the steps jointly as a sequence, so each step can use what earlier steps established. Independent planning tends to push the central difficulty into a single lemma, while joint planning can spread it across steps.

Graph revision. LEAP revisits earlier decompositions through backtracking. An early false lemma that escapes review can induce substantial unsuccessful search beneath it before its introduction is reconsidered. Goedel-Architect directly replaces the problematic statement and repairs its downstream uses in one revision.

To test this empirically, we audited decompositions of 120 randomly sampled PutnamBench problems, generating both a local decomposition (LEAP-style: supporting lemmas for the current goal) and a joint blueprint with the same backbone (DeepSeek-V4-Flash-0423). We judged only decompositions that compiled in Lean within the turn limit (94/120 local, 102/120 joint). An independent judge (Claude Opus 5.5) checked each lemma for correctness and assessed whether any lemma was as hard as the original theorem.

Local decompositionJoint blueprint
Contain incorrect lemmas20/94 (21.3%)28/102 (27.5%)
Retain a lemma as hard as the original theorem69/94 (73.4%)57/102 (55.9%)

Joint blueprints leave a lemma as hard as the original theorem noticeably less often (55.9% vs. 73.4%), which supports better difficulty reduction. Their rate of incorrect lemmas is similar (27.5% vs. 21.3%, not statistically significant). In either setting, roughly a quarter of decompositions contain a false statement, which is why Goedel-Architect pairs joint construction with direct statement revision rather than relying on backtracking.

2. Controlled comparisons with the closest methods are missing. The same-backbone Hilbert comparison is useful, but comparisons with LEAP and Delta Prover under the same model and compute budget are needed to isolate the proposed refinement mechanism. Since LEAP is contemporaneous, priority and technical differences should be discussed separately.

We agree that matched-backbone, matched-budget comparisons with LEAP and Delta Prover would strengthen the evaluation. We lack access to their official implementations and cannot provide faithful controlled comparisons in this revision. We will acknowledge this limitation, clarify the technical differences, and treat LEAP as contemporaneous work.

AuthorsOpenReview ↗

Response to Reviewer 33H4 (2/2)

3. Component effects are not isolated. Ablations are missing for global graph revision, formal disproofs, structured failure diagnoses, and proof reuse. Negations occurring on 292/672 problems show usage frequency, not their contribution to final solve rate or cost.

4. Disproof generation and its integration should be distinguished. Learning to Disprove already studies LLM-generated counterexamples with Lean verification. The potential contribution here is their integration into graph repair, but its advantage over ordinary failure feedback is insufficiently tested.

We address points 3 and 4 together. To isolate each component's contribution to solve rate, we ran ablations that remove global graph revision, formal disproofs and structured failure diagnoses in turn. To stay within an academic budget, we used a pre-registered 48-problem PutnamBench subset, drawn at random from problems the default run solved within 1–8 iterations, with quotas so each feedback type is represented. Every arm, including the full system, was re-run from scratch with DeepSeek-V4-Flash-0423 and six refinement iterations.

ConditionSolvedSolve rate
Global graph revision + formal disproofs + structured failure diagnoses (full system)43/4889.6%
Global graph revision + structured failure diagnoses (without formal disproofs)42/4887.5%
Only global graph revision37/4877.1%
Fixed blueprint, repeated proving24/4850.0%

Allowing revision of the graph increased the solve rate from 50.0% to 89.6% compared with retrying unresolved lemmas on an unchanged blueprint. With only proved/unresolved feedback, revision solved 77.1%; adding structured failure diagnoses raised this to 87.5%. Adding formal disproofs yielded 89.6%, suggesting a limited incremental solve-rate benefit on this subset. These results support graph revision as the main contributor, with diagnoses providing an additional observed gain.

5. Performance and cost comparisons use different conditions. Pipeline-level pass@1 includes many internal attempts and refinements and is not directly comparable with other sampling counts. Hilbert uses a different benchmark size, and cost comparisons involve different model prices and compute estimates. The highest scores additionally use Gemini, extra attempts, model changes, and larger refinement budgets. These results should be separated from the default setting and compared under common compute budgets.

Pipeline-level pass@1 follows the standard convention for agentic provers such as Hilbert, Seed-Prover and Aleph: one end-to-end run counts as one attempt, and its internal proof attempts and refinements are reflected in the reported cost. The paper already reports the default DeepSeek-V4-Flash setting (508/672), the open-weight NL-guided setting with up to four additional runs (597/672), and the mixed-model setting using Gemini (642/672) separately; we will make these distinctions more prominent. The difference from Hilbert's benchmark size reflects the PutnamBench version, not a different benchmark. Dollar cost per problem is the quantity that puts systems built on different models on a common axis. To control for the backbone, we also reimplemented Hilbert with our backbone and observed the same advantage on MiniF2F.

We hope these clarifications and new experiments address the reviewer's concerns. Are there any other questions we can help address?

Reviewer_33H4OpenReview ↗

The additional ablation study seems solid

I read the response and found the ablations of removing global graph revision, formal disproofs and structured failure diagnoses is helpful to capture the methodology effectiveness. Although I still have some remaining concerns on the novelty compared to simultaneous publications (W1) and the comparisons in different pass@K/costs (W2/W5), I am becoming positive on this paper.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary Comment

We thank all three reviewers for careful and constructive reviews. The reviews agree on the strengths: an open-weight pipeline solving 508/672 PutnamBench problems for \$294, failure-driven blueprint refinement, and same-backbone comparisons. The revised manuscript adds three main results addressing the reviewers' concerns.

Ablation studies. On 48 PutnamBench problems, global graph revision raises the solve rate from 50.0% (fixed blueprint) to 89.6% at similar token cost; structured diagnoses add a further 10.4 points, and formal disproofs a further 2.1.

Code verification and frontier mathematics. The same pipeline verified all 6 Verina and CLEVER code-verification tasks and Erdős problems 1052 and 198, for under \$1 in total.

Novelty. Unlike LEAP-style local decomposition, joint blueprints leave a lemma as hard as the theorem less often (55.9% vs. 73.4%), and disproved lemmas are restated in the next revision rather than backtracked; 57% of restated lemmas are then proved.

We have incorporated all of these changes in the revised submission. Detailed answers follow under each review.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.