In this paper
AbstractIntroductionThe Lea BackboneApplications Built on LeaCase Study: The Durfee Square Generating FunctionLimitations and ConclusionAcknowledgments and Disclosure of FundingAppendixRelated Work: Human Oversight in Software EngineeringBackbone DetailsApplication Interface ExamplesLeaOverleaf: A Worked ExampleCase Study DetailsFuture WorkReferencesWorksComputer Science
Lea: An Agent Backbone for Mathematician-Controlled Formalization in Lean
Abstract
Agentic systems now formalize research-level mathematics in Lean, but they are built for autonomy: the mathematician states a target and inspects a result. The alternative, a general-purpose coding harness, is domain-neutral and must be assembled into a formalization workspace before any mathematics begins. Mathematicians, however, report wanting to keep high-level control over how an argument is decomposed and established. We present , a Lean-specific agent backbone for mathematician-facing software rather than a single interface. Lea exposes runs, sessions, and typed events through one application-neutral API, and ships with Lean tooling (blueprints, LSP, Loogle, SafeVerify) already wired. We report two applications built on it: , a web client for interactive proof authoring, and , which formalizes theorems annotated directly in an Overleaf document; a session begun in either continues in the other. In a case study, a mathematician outlined a proof of the Durfee square generating function in a few natural-language messages, and Lea produced a complete Lean development from Mathlib alone, following the intended decomposition closely and requiring substantive correction at a single point. Lea and both applications are released as open source so that further mathematician-facing tools can be built on the same backbone.
Introduction
Agentic systems have begun to formalize research-level mathematics in Lean [7]. Two families dominate. Autonomous provers [1, 3, 10, 11, 14, 17, 19] search proof space with domain-specific training and now reach olympiad level. Coding-agent harnesses wrap a general-purpose agent such as Claude Code or Codex with Lean tools, skills, and MCP servers: Numina-Lean-Agent [12] pairs Claude Code with an MCP server exposing the Lean LSP and Mathlib retrieval and solved all twelve Putnam 2025 problems; LeanMarathon [22] coordinates four Codex agents over an evolving proof DAG under CI checks and proved 258 lemmas across seven research-level targets. Both families show that long-horizon formalization is within reach, but in both the unit of interaction is an autonomous run. LeanMarathon confines human involvement to redesigning the harness between runs; Numina-Lean-Agent lets an expert revise a Markdown blueprint between invocations. The mathematician sits at the endpoints of the process.
That is not how mathematicians say they want to work. In a recent mixed-methods study of formalization workflows [6], 81.7% of surveyed students and researchers preferred full or partial human control over formalization, and 66.7% wished to retain high-level strategic control while delegating mechanical work; six of seven participants in the accompanying user study combined several AI tools rather than relying on one. Earlier work found that mathematical correctness and perceived helpfulness diverge when mathematicians interact with language models, motivating systems in which users can inspect and correct model behavior [5]. The autonomy-first systems report the consequences themselves: Numina-Lean-Agent finds its own output overly result-oriented and in need of expert simplification [12], and LeanMarathon reports a run that, with the required Mathlib theory absent, produced an artifact passing every structural check while establishing nothing mathematically [22].
We present Lea, a Lean-specific agent backbone for mathematician-facing software (Figure 1). Relative to the systems above, Lea differs in four ways: the mathematician can intervene while a run is in progress rather than only between runs; the project blueprint persists across runs and is exposed as a dependency graph; Lean tooling (LSP, Loogle, blueprints, and kernel-replay verification with SafeVerify [9]) ships wired rather than assembled per project; and the agent and project state are reachable through one application-neutral API, so several front ends can share a formalization. Our contributions are:

Figure 1. (a) Existing systems are autonomy-first provers or general-purpose harnesses. (b) Lea makes the run itself the surface the mathematician acts on. (c) One application-neutral service boundary carries every client; Lean tooling ships wired, while skills, sub-agent roles, tools, and MCP servers remain user-editable.
An agent backbone (§ 2). One API exposes runs, sessions, and typed events, with no client-specific route. Multi-agent orchestration, persistent blueprints, and the Lean tools that recent harnesses integrated separately for benchmarking [8, 12, 22, 23] are part of the system, and skills, sub-agent roles, tools, and MCP servers are user-editable without touching agent code.
Two applications on that backbone (§ 3). LeaChat is a web client for interactive proof authoring. LeaOverleaf turns annotations in a LaTeX document into blueprint nodes, writes each node’s formalization status back into the document, and fingerprints every formalized statement so that edits to the paper or to the Lean import graph invalidate exactly the affected results. The two share sessions, transcripts, and usage accounting.
A case study (§ 4). From a natural-language outline of the Durfee square generating function, Lea produced a complete Lean proof across three sessions and 38 sub-agent invocations with 28 human messages, one of which required substantive correction.
The Lea Backbone
Lea is a single backend for running and managing formalization agents, exposed through one HTTP API shared by all clients. A run involves three components: the formalization agent decides what to do next, the Lean execution environment carries that action out in the target project, and the persistent run history records what happened and supplies it to later actions. The API exposes runs, sessions, and typed events rather than low-level tool calls, so an application can react to a proof file changing, a Lean check completing, or a sub-agent finishing without implementing agent logic of its own. Application state is derived from recorded Lean results rather than stored separately: whether a blueprint node is complete is read off the latest verification verdict for its proof.
Formalization agent. The agent operates on a project, a workspace that persists across runs and holds a Lean namespace, project instructions, accumulated memory, and a blueprint that decomposes the formalization into dependent lemmas [13]. Each blueprint node records its dependencies and the sessions that contributed to it; a node becomes ready once its dependencies are complete. The agent can delegate bounded tasks to concurrent sub-agents, each with its own scratch directory, turn budget, and allowed tools. Roles are declared in YAML files that specify prompt, tools, budget, and optionally the model, so new roles are added without modifying the agent (Appendix § 9).
Lean execution environment. The environment executes the agent’s actions and checks them with the project’s pinned toolchain and dependencies, including Mathlib, either locally or in a container. A persistent Lean language-server process reuses elaboration state across edits rather than starting Lean afresh for every check, and returns the effects of each action as typed events: file changes, diagnostics, search results, and verification verdicts. It establishes two machine-checked guarantees. A proof is formalized when its file elaborates without sorry, and verified when it additionally passes SafeVerify’s kernel replay, per-declaration type matching, and axiom whitelist [9]. The second matters for AI-generated proofs, which may compile while relying on a non-whitelisted axiom or proving a modified statement.
Persistent run history. Every action and result is emitted as a typed event: messages, proof edits, tool results, Lean verdicts, sub-agent activity, usage, and run completion. This follows the action–observation model of OpenHands [18], but Lea also makes the event stream the contract between backbone and applications, so clients receive an explicit “proof changed” or “check completed” rather than interpreting prover-specific tool output. The history is stored in SQLite with content-addressed proof snapshots, so a restored session shows exactly the proof state the live client saw. Each code step also records whether the mathematician or the agent made the change, so their contributions can be measured directly from the run history.
Applications Built on Lea
The backbone separates the formalization machinery from the way mathematicians interact with it: Lea owns the agent loop, Lean execution, verification, and run history, while each application decides how users start, guide, and review a formalization. LeaChat and LeaOverleaf share projects, sessions, proof history, and verification results through the same API, and a future application supports a new workflow by sending commands to that API and presenting its typed events differently. Interface illustrations of both are provided in Appendix § 10.
LeaChat. LeaChat is a web client for sustained, interactive proof development. It shows the run transcript beside an editable Lean canvas, so the mathematician follows proof changes and verification results as they occur. While the agent is running, the mathematician can edit the current proof in the canvas, approve or deny a tool call, rewrite a blueprint node, or redirect the strategy through chat; each intervention is recorded in the run history and supplied as context to subsequent actions, so it shapes the proof as it develops rather than serving as retrospective feedback. LeaChat also manages skills, tools, MCP servers, and sub-agent roles without touching the harness, preserves each sub-agent’s trajectory for inspection, and can reopen a session created in LeaOverleaf and continue it.
LeaOverleaf. A paper under development already fixes the statements, proposes an order of dependence, and surrounds each claim with prose recording its intent; extracting statements into a separate harness discards this and leaves the author maintaining two developments. LeaOverleaf therefore treats the Overleaf project as the surface from which formalization is directed, dividing labour as the survey evidence recommends [6]: the mathematician chooses the objects and decomposition, the agent produces and checks Lean. Figure 2 illustrates the LeaOverleaf interface.

Figure 2. The LeaOverleaf interface. Left: an Overleaf document whose LaTeX source contains Lea annotations that identify a theorem, dependencies, and audit status. Center: the item detail card, from which the author can rerun the formalization, continue it in LeaChat, or open it in the Lean pane. Right: the Lean pane, which organizes annotated items as a blueprint, displays the statement extracted from the paper and its dependencies, and presents the generated Lean for review and editing. Lean pane also provides additional controls such as navigate to the source in Overleaf, synchronize with the Git repository, and configure the agentic harness.
The author marks a definition or theorem with a non-rendering comment naming the target, its dependencies, and optional guidance. From these annotations LeaOverleaf assembles a blueprint in the sense of §2, with ready, blocked, and complete targets, and supports batch formalization of an eligible subgraph in topological order. Each formalization is a bounded run through the shared backbone: LaTeX sources are mirrored into the project as readable source material, declared dependencies resolve to their recorded Lean artifacts, and an unresolved dependency blocks the run rather than being dropped. When a source proof is supplied, the agent is instructed to preserve the statement’s meaning and the argument’s essential mathematical approach. Without a supplied proof, it may attempt a meaning-preserving proof of a precise statement while disclosing that no source method was available. Runs proceed without per-tool approval, while authors can pause execution and continue through each item’s persisted chat. Individual runs can additionally pause when source issues require author input, if this option is enabled.
Results return as statuses. Formalized means the Lean elaborates without sorry, verified means SafeVerify also passes, and disproved is a successful terminal outcome in which counterexample search machine-checked a refutation, for an author revising a draft among the most informative results a run can produce. Even verified asserts only that the proof establishes the Lean statement, not that the statement expresses what the author intended, the faithfulness gap [21]. LeaOverleaf keeps this gap visible with a final status, audited, that no machine process can set: a mark recorded by the mathematician after review, bound to a hash of the annotation, the Lean artifact, and every project-local file it transitively imports, and removed if any input changes. Live Lea status reports expose the formalizing agent’s assessment of correspondence with the source, the scope of that assessment, and findings such as additional assumptions or departures from the supplied argument. They distinguish Lean-side repairs from unresolved source concerns. These reports are self-assessments, not independent or calibrated faithfulness checks. Review of the resulting statement and dependencies remains necessary. Appendix Figure 4 shows an example report alongside the Lean artifact it describes.
Because a paper changes continually, each artifact is bound to a fingerprint of its statement text, kind, dependencies, and guidance, and changing any of these marks the result stale. Lean-side changes propagate through the import graph: a revised definition rebuilds transitive dependents and reports which results survive (a successful edit confined to a theorem’s proof body, with its declaration unchanged, need not invalidate dependents, although review and verification evidence remain bound to artifact revisions), and broken dependents can be repaired by hand or delegated back to Lea as a topologically ordered batch. Appendix D walks through a small example in which a run ends in disproved and exposes a missing hypothesis in the paper rather than an error in the Lean.
LeaOverleaf is a Chrome extension plus a local companion process. The companion sends formalization and continuation requests to the same adapter used by LeaChat, which invokes the shared prover in-process. Source-bound prompting and live status reporting are supported by the shared backend, while document integration remains in the extension and companion.
Case Study: The Durfee Square Generating Function
A partition of is a non-increasing sequence of positive integers summing to ; counts them. Euler’s generating function is in Mathlib (since Lean 4.26) in a generalized form with a character function restricting part multiplicities, but many partition-theoretic results rest on combinatorial arguments on Ferrers diagrams that Mathlib does not model and that require elaborate Lean proofs [2]. The Durfee square of has side , the largest with ; removing it leaves a right residue with at most parts and a bottom residue with parts at most , of combined size , and conjugation shows the two families equinumerous. Counting over gives
This outline suffices for a human reader; Lean requires the many discrete facts such a diagrammatic argument elides.
The mathematician gave this outline to a LeaChat project over several colloquial chat messages, with no PDF or \LaTeX source. Using GPT-5.5, Lea produced a Lean proof of (1) from Mathlib alone, which supplies Nat.Partition and the generalized Euler theorem but no notion of Ferrers diagrams or Durfee squares. The proof spans three sessions and 38 sub-agent invocations, is organized by a blueprint worked out with the agent, and states the final theorem as
theorem genFun_eq_tsum_qPochhammerInvNat_sq :
Nat.Partition.genFun = ∑’ k : ℕ, PowerSeries.X ^ (k * k) *
qPochhammerInvNat k * qPochhammerInvNat k := by
…
The mathematician sent 28 messages in total, most of them confirmations of a definition or proof approach the agent proposed; every step introducing a new core definition received such confirmation. The mathematician deliberately stated little mathematical content, so that Lea’s ability to make decisions and draw on Mathlib could be assessed. One sub-agent near the end required substantive correction, having proved a trivial restatement of an earlier lemma rather than the target. The resulting development follows the intended outline closely, an advantage over one-shot autonomous generation, though it still needs stylistic clean-up before it would meet Mathlib’s standards (Appendix § 12).
Limitations and Conclusion
Our evidence is the architecture and one case study. Lea is also in use in ongoing research-level formalization projects, which we do not report here because their subject matter would identify the authors; the camera-ready version will describe them. We do not yet offer a controlled comparison with other harnesses such as Numina-Lean-Agent [12] or an evaluation across mathematical domains, and Lea’s output needs refactoring and expert review before it meets Mathlib’s quality and disclosure requirements; nearer-term uses are Lean developments accompanying new papers, machine-checked proofs or refutations of LLM-generated conjectures, and formal components of AI-assisted projects such as TauCeti [15]. Lea does not yet support several mathematicians working concurrently on one project, a natural next step for LeaOverleaf users who already share a document (Appendix § 13). What Lea does provide is formalization-specific infrastructure, with the mathematician in control during the run, that several applications can share without embedding a prover or reimplementing an agent loop, and on which further tools for mathematicians can be built.
Acknowledgments and Disclosure of Funding
This work was funded by the DARPA expMath program (Agreement No. HR0011262E029). Silva was also partially supported by NSF grants OAC-2411221 and DRL-2604563. Jorge was also partially supported by the Brazilian National Council for Scientific and Technological Development (CNPq), grant # 313454/2026-4, and the Getulio Vargas Foundation (FGV). Any opinions, findings, conclusions, or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of DARPA, NSF, or the authors’ affiliated institutions.
Appendix
Related Work: Human Oversight in Software Engineering
Patterns similar to those reported for mathematicians [5, 6] appear in software engineering. A longitudinal study of professional developers finds that AI coding assistants shift work from writing code toward directing, evaluating, and correcting generated code, while flow and cognitive load worsen for some developers over time [16]. A separate study of 448 professional developers finds that developers generally accept AI producing work under human oversight, while willingness to grant greater autonomy decreases for tasks associated with accountability and design [4]. Lea’s design responds to the same findings: the mathematician remains able to inspect and control the agent, and formalization is integrated into the workspace where mathematical writing already happens.
Backbone Details
Blueprints. Blueprints are established practice in Lean formalization: Massot introduced the format [13], LeanArchitect [23] automates blueprint generation, and LeanMarathon [22] uses one to organize autonomous formalization. In Lea the blueprint is additionally shared state across applications, and node completion is never stored as an independent status. It is determined from the latest Lean verification result for the corresponding proof.
Sub-agent roles. Each role is a YAML file specifying the prompt, the allowed tools, the turn budget, and optionally the model. Two shipped examples illustrate the range: the premise-search role can only read the project, while the proof-candidate role can edit a proof and repeatedly check it with Lean. Sub-agent trajectories are preserved in the run history and can be inspected from LeaChat.
Verification. AXLE evaluates SafeVerify on 1,000 production proof-verification requests and demonstrates the practical role of such strict verification for untrusted proof submissions [20].
Storage. SQLite stores the parts of the history required to reconstruct a session: messages, code steps, verification verdicts, and usage. Each code step references a content-addressed proof snapshot, so identical snapshots are deduplicated. When a proof file changes, the exact snapshot sent to the client is stored with the corresponding code step, and when Lean later returns a verdict, Lea attaches it to that same step; the live canvas and a restored session therefore present the same recorded proof state.
Application Interface Examples

Figure 3. The LeaChat interface. Left: projects and their blueprints, the user-editable library of skills, sub-agent roles, tools, and MCP servers, and the roster of sub-agents spawned in the session. Center: the run transcript, where the agent’s reasoning, tool calls, and file writes appear as they happen. Right: the Lean canvas, which shows each edit as it lands, stays editable mid-run, and reports the compile verdict and SafeVerify audit in its status bar. The sidebar composites two scroll positions of one session, since its three sections cannot be on screen together.

Figure 4. LeaOverleaf faithfulness report. Lea Status report (left) and the corresponding Lean code (right) for a CapacityEncoding definition. The report records the agent’s assessment of what in the source was matched, any source issues, and caveats about the formalization. It is a self-assessment, only the mathematician’s review can mark the result audited.
LeaOverleaf: A Worked Example
An author marks a definition and a theorem that uses it:
\begin{definition}\label{def:divides}
% lea: define label=divides_def
We say $d$ divides $n$ if $n = dk$ for some $k$.
\end{definition}
\begin{theorem}\label{thm:divisor-bound}
% lea: formalize label=divisor_le
% lea: uses={divides_def}
If $d$ divides $n$, then $d \le n$.
\end{theorem}
The generated def is stated over the integers; the author edits it to ℕ in the pane (recorded as a human-authored step), re-checks, and audits it. Batch formalization of divisor_le terminates in disproved: every number divides zero. The counterexample identifies a gap in the paper, not the Lean. The author adds ; the fingerprint change marks the earlier attempt stale, the next run formalizes and verifies the corrected statement, and the author audits it. The definition’s audit mark persists, since none of its inputs changed.
Case Study Details
The development was produced with GPT-5.5 against Mathlib for Lean 4.32 and consumed 24.7M tokens across three chat sessions and 38 sub-agent invocations. It comprises four core Lean files organized according to the blueprint, including both internal lemmas and outward-facing APIs intended for future work on Ferrers-diagram arguments. Each of the 28 human messages is recorded in the run history with its position relative to agent actions, as is the single sub-agent trajectory that required correction.

Figure 5. First Messages. The mathematician stated each step of the proof outline in plain language and provided short but thoughtful answers to steering questions offered by Lea itself. Being familiar with the subject matter, reviewing Lea’s reported design choices and verified mathematical content did not take substantial time for the mathematician.
Lea: The Lean theorem I propose to prove is:
{
theorem genFun_eq_durfeeCoeff :
Nat.Partition.genFun = PowerSeries.mk (fun n : ℕ => durfeeCoeff n) := by
}
This would live in the Durfee project namespace, probably in a new or existing generating-
function file importing Lea.Durfee.DurfeeGenFun and Mathlib’s partition generating-
function module.
Does this match what you want - namely the power-series statement whose coefficients are
the Durfee decomposition counts?
────────────────────────────────────────────────────────────────────────────────────────────
You: This is a valid statement, but not what we’re after. We want to use the Durfee
decomposition to deduce a different generating function for partitions, namely $$\
sum_{k=0}^{\infty} X^{k^2} / (X; X)_k^2$$, which arises from counting the
contributions of the Durfee square and symbol to yield all possible partitions.

Figure 6. Significant steering correction. These messages constitute the largest errant deviation from the proof writing seen during the session, and comprise the longest message sent by the mathematician in order to correct it. The target generating function recounted by the mathematician had been stated in exactly the same form in a prior message.
Future Work
GitHub integration supports importing and sharing project state but not live collaborative editing. Future work therefore includes collaborative project access, conflict resolution, and per-author provenance, particularly for LeaOverleaf users who already collaborate on the same document. Because Lea records who made each proof change and whether the change passed verification, the run history also supports future studies of when human intervention occurs and how it affects formalization outcomes.
References
- [1]Tudor Achim, Alex Best, Alberto Bietti, et al. Aristotle: IMO-level automated theorem proving. arXiv preprint arXiv:2510.01346, 2025.arxiv.org/abs/2510.01346
- [2]George E. Andrews and Kimmo Eriksson. Integer Partitions. Cambridge University Press, 2004.
- [3]Jia Chen, Wei Chen, Jing Du, et al. Seed-Prover 1.5: Mastering undergraduate-level theorem proving via learning from experience. arXiv preprint arXiv:2512.17260, 2025.arxiv.org/abs/2512.17260
- [4]Rudrajit Choudhuri, Christian Bird, Carmen Badea, Marco Gerosa, and Anita Sarma. You shall not pass! Where and why developers draw the line on AI autonomy. arXiv preprint arXiv:2607.00533, 2026.arxiv.org/abs/2607.00533
- [5]Katherine M. Collins, Albert Q. Jiang, Simon Frieder, et al. Evaluating language models for mathematics through interactions. Proceedings of the National Academy of Sciences, 121(24): e2318124121, 2024. doi: 10.1073/pnas.2318124121.DOI
- [6]Katherine M. Collins, Simon Frieder, Jonas Bayer, Jacob Loader, Jeck Lime, Peiyang Song, Fabian Zaiser, Lexin Zhou, Shanda Li, Sam Looi, Joshua B. Tenenbaum, Umang Bhatt, Adrian Weller, Jose Hernandez-Orallo, Cameron E. Freer, Valerie Chen, and Ilia Sucholutsky. Characterizing initial human-AI proof formalization workflows. arXiv preprint arXiv:2606.04273, 2026.arxiv.org/abs/2606.04273
- [7]Leonardo de Moura and Sebastian Ullrich. The Lean 4 theorem prover and programming language. In Automated Deduction – CADE 28, volume 12699 of Lecture Notes in Computer Science, pages 625–635. Springer, 2021.DOI
- [8]Cameron Freer. Lean 4 skills: Theorem proving skill and workflow pack for AI coding agents. https://github.com/cameronfreer/lean4-skills, 2025.
- [9]GasStationManager. SafeVerify: Verifying Lean 4 proofs by kernel replay, per-declaration type matching, and an axiom whitelist. https://github.com/GasStationManager/SafeVerify, 2025.
- [10]Thomas Hubert, Rishi Mehta, Laurent Sartran, et al. Olympiad-level formal mathematical reasoning with reinforcement learning. Nature, 2025. doi: 10.1038/s41586-025-09833-y.DOI
- [11]Yong Lin, Shange Tang, Bohan Lyu, Ziran Yang, Jui-Hui Chung, Haoyu Zhao, et al. Goedel-Prover-V2: Scaling formal theorem proving with scaffolded data synthesis and self-correction. arXiv preprint arXiv:2508.03613, 2025.
- [12]Junqi Liu, Zihao Zhou, Zekai Zhu, et al. Numina-Lean-Agent: An open and general agentic reasoning system for formal mathematics. arXiv preprint arXiv:2601.14027, 2026.arxiv.org/abs/2601.14027
- [13]Patrick Massot. leanblueprint: A tool for writing blueprints of Lean 4 projects. https://github.com/PatrickMassot/leanblueprint, 2024.
- [14]Z. Z. Ren, Zhihong Shao, Junxiao Song, et al. DeepSeek-Prover-V2: Advancing formal mathematical reasoning via reinforcement learning for subgoal decomposition. arXiv preprint arXiv:2504.21801, 2025.arxiv.org/abs/2504.21801
- [15]TauCetiProject. Tau Ceti. https://github.com/TauCetiProject/TauCeti, 2026.
- [16]Annie Vella and Kelly Blincoe. The impact of AI coding assistants on software engineering: A longitudinal study. arXiv preprint arXiv:2605.23135, 2026.DOI
- [17]Haiming Wang, Mert Unsal, Xiaoran Lin, Mantas Baksys, Junqi Liu, Marco Dos Santos, et al. Kimina-Prover preview: Towards large formal reasoning models with reinforcement learning. arXiv preprint arXiv:2504.11354, 2025.arxiv.org/abs/2504.11354
- [18]Xingyao Wang, Boxuan Li, Yufan Song, et al. OpenHands: An open platform for AI software developers as generalist agents. In International Conference on Learning Representations (ICLR), 2025.arxiv.org/abs/2407.16741
- [19]Huajian Xin, Z. Z. Ren, Junxiao Song, et al. DeepSeek-Prover-V1.5: Harnessing proof assistant feedback for reinforcement learning and Monte-Carlo tree search. arXiv preprint arXiv:2408.08152, 2024.arxiv.org/abs/2408.08152
- [20]Jimmy Xin, Alex Schneidman, Chris Cummins, Karun Ram, Srihari Ganesh, and Jannis Limperg. AXLE: A cloud infrastructure for Lean 4 theorem proving utilities. arXiv preprint arXiv:2606.26442, 2026.arxiv.org/abs/2606.26442
- [21]Ke Zhang, Patricio Gallardo Candela, Sudhir Murthy, Yi Xie, Zhi Wang, and Maziar Raissi. Beyond compilation: Evaluating faithful natural-language-to-Lean statement formalization. arXiv preprint arXiv:2606.31002, 2026.arxiv.org/abs/2606.31002
- [22]Yuanhe Zhang, Yuekai Sun, Taiji Suzuki, Jason D. Lee, and Fanghui Liu. LeanMarathon: Toward reliable AI co-mathematicians through long-horizon Lean autoformalization. arXiv preprint arXiv:2606.05400, 2026.arxiv.org/abs/2606.05400
- [23]Thomas Zhu, Pietro Monticone, Jeremy Avigad, and Sean Welleck. LeanArchitect: Automating blueprint generation for humans and AI. arXiv preprint arXiv:2601.22554, 2026.arxiv.org/abs/2601.22554