Summary

• GOEDEL-ARCHITECT is an agentic framework for formal theorem proving in Lean 4 that centers on blueprint generation and refinement — a dependency graph of definitions and lemmas building up to the main theorem.
• Using the open-weight DeepSeek-V4-Flash (284B-A13B) backbone, it achieves 99.2% pass@1 on MiniF2F-test and 75.6% pass@1 on PutnamBench — exceeding prior open pipelines at a fraction of the cost.
• With optional natural-language proof seeding, it closes 100% of MiniF2F-test, reaches 88.8% (597/672) on PutnamBench, and solves 4/6 on IMO 2025, 11/12 on Putnam 2025, and 3/6 on USAMO 2026.
• The pipeline is up to 500× cheaper than comparable open pipelines: **$0.44 per problem** vs. ~$244 for Hilbert (Table 2).
• The key innovation is a global blueprint refinement loop that contrasts with recursive lemma decomposition (used by Hilbert, Seed-Prover), avoiding inefficient loops on dead-end strategies.

---

Introduction and Theoretical Foundation

The paper addresses a critical gap in formal theorem proving: while frontier AI systems (e.g., AlphaProof, IMO gold-medal-level systems) achieve remarkable mathematical performance, they are either closed-weight or prohibitively expensive. The theoretical foundation rests on:

• Formal verification in Lean (Moura & Ullrich, 2021) as a rigorous alternative to informal proof checking.
• Benchmark landscape: MiniF2F-test (244 high-school competition problems), PutnamBench (672 undergraduate-level Putnam problems), and fresh competition sets (IMO 2025, Putnam 2025, USAMO 2026).
• Prior approaches categorized by the LLM's role at inference:
  • Non-agentic provers (Goedel-Prover, DeepSeek-Prover, Kimina-Prover): single-pass proof generation, <15% on PutnamBench.
  • Agentic provers (AxProverBase, Numina-Lean-Agent): single LLM interleaves reasoning with Lean compiler calls.
  • Pipelines (Hilbert, Seed-Prover, Draft-Sketch-Prove): orchestrate multiple LLM components with decomposition/refinement.

The paper argues that existing pipelines use recursive top-down decomposition — which can loop inefficiently on dead-end strategies — and proposes a global dependency-graph blueprint as an alternative.

---

Methodology

2.1 Blueprint Generation

• Receives the formal statement of the target theorem and emits a dependency graph as a single Lean file.
• Each node is a formally stated definition or lemma; edges are declared dependencies (which lemmas a proof may rely on).
• The target theorem is the unique sink; lemma bodies are left unproved.
• The model iterates against the Lean compiler to ensure well-typedness and acyclicity.
• Optional NL guidance: a natural-language proof (from a stronger model or official solution) seeds the initial blueprint structure.

2.2 Theorem Proving

• Each lemma is dispatched to a Lean theorem prover in parallel, seeing only its declared dependencies.
• The prover has access to the Lean compiler and a Mathlib retrieval tool, iterating until closure or budget exhaustion.
• On failure, the prover returns a structured diagnosis (what was attempted, where the gap lies).
• If a counterexample is verified, the prover can register a proof of the negated statement.

2.3 Blueprint Refinement

• The refinement model reads per-lemma traces, marks each as proved/unproved, and emits a revised graph.
• Typical refinements: decomposing hard lemmas into helpers, rewiring dependencies, repairing/dropping false statements.
• Proved lemmas are preserved (signatures intact) so prior compute is not wasted.
• The loop continues until all nodes are solved or iteration budget is exhausted.

---

Empirical Validation / Results

Table 1: Benchmark Comparison

Table 2: Cost Comparison on PutnamBench

Key Findings

• MiniF2F: 242/244 at pass@1 (99.2%). The two remaining problems (IMO 1984 P6, IMO Shortlist 2007 Algebra P6) are closed with NL guidance — the first Lean prover to close all 244 problems.
• PutnamBench: 75.6% at pass@1 (exceeding Hilbert's 70.0% at pass@1840 and AxProverBase's 54.7%). With NL guidance: 88.8% (597/672).
• IMO 2025: Solves 4/6 (P1, P3, P4, P5), matching Seed-Prover 1.5 on all non-geometry problems (P2 is geometry-handled by Seed-Prover with a dedicated engine).
• USAMO 2026: 3/6 (P1, P4, P6) — contamination-free since it postdates all training cutoffs.
• Compute scaling: Solve rate grows roughly log-linearly with refinement iterations (Figure 2): from 200 problems (29.8%) at iteration 0 to 508 (75.6%) at iteration 16.

---

Theoretical and Practical Implications

Theoretical Contributions

• Blueprint-as-graph vs. recursive decomposition: The dependency-graph structure allows global refinement, parallel proof attempts with shared context, and avoids dead-end loops that plague recursive strategies.
• Diagnostic channels: The paper introduces two novel signals for refinement:
  • Negated sub-lemmas: When the prover verifies a counterexample, the disproof (with reflection) is fed into the next revision step — converting dead ends into localized, machine-checked edits.
  • Forfeited proofs: When a node runs out of budget, the prover writes a structured post-mortem (statement-wrong vs. proof-too-hard) that proposes a decomposition plan — turning a failed monolith into a provable sub-graph.

Practical Implications

• Open-weight, open-pipeline accessibility: Both backbone and pipeline are publicly available, democratizing formal theorem proving.
• Cost efficiency: ~$0.44/problem vs. ~$244 for Hilbert — a 555× reduction in compute cost.
• Contamination-free evaluation: USAMO 2026 (post-training-cutoff) validates generalization capability.
• Scaling behavior: The log-linear scaling with refinement iterations suggests predictable performance gains from additional compute — useful for resource planning.

---

Conclusion

GOEDEL-ARCHITECT establishes a new Pareto frontier for formal theorem proving: state-of-the-art performance for open-weight systems at a fraction of the cost of proprietary pipelines. The key insights are:

1. Blueprint-centric approach: A global dependency graph (rather than a recursive tree) allows parallel proof attempts, shared context, and global refinement.
2. Structured failure signals: Both negated sub-lemmas and forfeited proofs provide actionable diagnostics that feed directly into the next refinement iteration.
3. Natural-language guidance is decisive for non-local structure problems (cyclic sums, parity/divisibility chains, tile-counting) — where deriving the lemma graph from the formal statement alone is the bottleneck.

Future Directions

• Extending the blueprint approach to more complex mathematical domains (e.g., geometry, where specialized engines are still needed).
• Reducing the dependency on natural-language guidance for the hardest problems.
• Investigating further compute scaling behavior beyond iteration limits.
• Exploring the potential of the open-weight backbone with additional fine-tuning or RL training.

Bottom line: GOEDEL-ARCHITECT demonstrates that efficient, open-source formal theorem proving can rival closed-weight frontier systems — a significant step toward democratizing rigorous AI-generated mathematics.