---
title: 'Numina-Lean-Agent: Automated Formal Reasoning'
url: https://www.emergentmind.com/topics/numina-lean-agent
type: topic
---

# Numina-Lean-Agent: Automated Formal Reasoning

Numina-Lean-Agent is an open and general agentic reasoning system designed for formal mathematics, notable for its integration of a general-purpose large language model (LLM) with a lightweight Model Context Protocol (MCP) tool orchestration framework. Diverging from monolithic, task-specific neural provers, Numina-Lean-Agent positions a model-agnostic coding agent (Claude Code) at the core of its architecture, enabling autonomous interaction with the Lean proof assistant and facilitating formalization workflows ranging from theorem proving to library extension. Numina-Lean-Agent achieved a perfect score on Putnam 2025 formalization tasks and has demonstrated collaborative capability on advanced mathematical formalizations, such as the Brascamp–Lieb theorem [2601.14027].

## 1. System Paradigm and Motivations

Numina-Lean-Agent adopts the general coding agent paradigm, positioning an off-the-shelf code-generation LLM as the principal formal mathematics reasoner. Unlike classical neural provers trained end-to-end for fixed tactic languages, this approach enables the agent to directly generate and inspect Lean code, eschewing single-step tactic prediction schemes. There is no requirement for model-specific finetuning; improvements in agent capability accrue directly from swapping in stronger base models. The system leverages a compact orchestration layer (Numina-Lean-MCP), which provides transparent access to specialized tools, including Lean interaction, retrieval indices, informal verifiers, and auxiliary reasoning partners. The principal motivations for this paradigm are:

- **Flexibility:** General coding agents manage a diverse set of formal reasoning tasks, including definition scripting, proof construction, code refactoring, and extending formal libraries.
- **Model-agnostic enhancement:** Direct replacement of the underlying LLM (e.g., switching from Claude Code to Claude Opus 4.5) yields immediate gains without additional retraining.
- **MCP-based orchestration:** A concise collection of tool APIs exposed through a unified protocol supports seamless extension, enabling the agent to autonomously invoke Lean, semantic search, informal checking, and collaborative tools without dedicated pipeline design [2601.14027].

## 2. Architecture and Components

At the high level, Numina-Lean-Agent consists of Claude Code as the inference engine, mediated by the Numina-Lean-MCP server, which orchestrates a set of external tools:

| Agentic Reasoner  | MCP Orchestrator      | Tool Suite (Examples)                           |
|-------------------|----------------------|-------------------------------------------------|
| Claude Code       | Numina-Lean-MCP      | Lean-LSP-MCP, LeanDex, Informal Prover, Discussion Partner |

The MCP orchestrator is responsible for tool selection at each interaction step, optimizing over available tools $t \in T$ given query $q$ and Lean proof state $s$:

$$ t^* = \arg\max_{t\in T} \text{LM\_score}(\text{prompt}_t(q, s)) $$

Pseudocode:

```python
def select_tool(q, s):
    for t in available_tools:
        score[t] = LLM.logprob(format_invoke(t, q, s))
    return argmax(score)
```
Upon selection, the orchestrator invokes the corresponding handler (e.g., a JSON-RPC call to Lean-LSP-MCP or a semantic search to LeanDex) and returns results to the LLM agent.

### Core MCP Tools

- **Lean-LSP-MCP:** Exposes Lean functionality via Language Server Protocol, including project outline inspection, goal querying, code checking via `lean_run_code`, and simultaneous tactic attempts through `lean_multi_attempt`. This supports a rapid trial→feedback loop for agent-driven proof refinement.
- **LeanDex:** Serves as a universal semantic theorem-search index over mathlib and related packages. It enables natural-language or symbolic retrieval of relevant declarations, ensuring only valid theorems are cited.
- **Informal Prover:** Implements an iterative generator+verifier architecture inspired by Gemini IMO agents, permitting proof sketching with up to $N=20$ refinement rounds.
- **Discussion Partner:** Allows the agent to initiate lateral conversations with other LLMs (e.g., Gemini) when encountering proof bottlenecks or gaps in strategy, subsequently incorporating new ideas into ongoing formalization [2601.14027].

## 3. Lean Interaction Workflow

The principal interaction loop involves the agent issuing Lean syntax steps, which are checked and diagnosed by the Lean toolchain, facilitating iterative refinement:

1. Agent proposes a Lean proof step.
2. MCP invokes `lean_run_code` or `lean_multi_attempt`.
3. Lean compiles the snippet, returning new goals or diagnostics upon failure.
4. Agent processes diagnostics with `lean_diagnostic` and updates its proof-state, selecting the next tool or action.

**Example:** Inductive proof for the sum of squares:
```lean
/- The sum of the first n squares -/
theorem sum_of_squares (n : ℕ) :
  ∑ i in Finset.range (n+1), (i : ℚ)^2
  = n*(n+1)*(2*n+1)/6 := by
  induction n with
  | zero   => simp
  | succ n ih =>
      rw [Finset.sum_range_succ, ih]
      field_simp
      ring
```
If the tactic `ring` fails (e.g., due to denominators), the agent handles corrective actions, such as inserting `field_simp`, informed by Lean diagnostics.

## 4. Benchmark Performance and Model Ablation

On the Putnam 2025 suite (A1–A6, B1–B6), Numina-Lean-Agent using Claude Opus 4.5 solved all 12 problems, equaling the performance of the best closed-source system (AXIOMProver). Comparative results:

| System           | Problems Solved (Putnam 2025) |
|------------------|:----------------------------:|
| ARISTOTLE        | 10/12                        |
| SEED-PROVER 1.5  | 11/12                        |
| AXIOMProver      | 12/12                        |
| Numina-Lean-Agent| 12/12                        |

Notably, Numina-Lean-Agent generated proofs significantly shorter than AXIOMProver on several problems and, despite sequential execution (i.e., no parallelism), was often faster. Model ablation studies indicate that using an earlier, smaller Claude Code model yielded 9/12 problems solved but with increased runtimes, substantiating that base-model quality translates directly to empirical performance. No model-specific finetuning was performed at any stage [2601.14027].

## 5. Collaborative Case Study: Brascamp–Lieb Theorem Formalization

Numina-Lean-Agent supported the 8,000-line Lean formalization of the Effective Brascamp–Lieb inequalities (Bénard & He 2025). The process consisted of several key steps:

### Blueprint Generation

For complex theorems, the agent begins by constructing a proof "blueprint"—a DAG whose nodes correspond to formal definitions, intermediate lemmas, and dependencies. Nodes are annotated with `uses {…}` sets, specifying the prerequisite structure and suggesting a valid proving order. Failures in typeclass search or type mismatches automatically trigger blueprint refinements, such as splitting lemmas or adjusting assumptions.

### Human–AI Collaboration

Human mathematicians may edit the blueprint, provide high-level proofs, or correct type coercions (e.g., Real → NNReal). The agent revisits the plan→formalize→refine loop with each update. In demonstrated cases, the agent autonomously detected and corrected false intermediate statements, evidencing self-correcting capabilities in extended formalization processes.

**Excerpt (simplified):**
```lean
theorem upperBound
  {J : Type*} [Fintype J]
  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
  (D : locRegDatum E (λ j => F j)) … :
   M_max.toContinuousLinearMap ‖_‖_+^… := by
  -- blueprint: handle empty case, nondegenerate case, glue inequalities, etc.
  …
```

## 6. Implementation and Reproducibility

Numina-Lean-Agent is accessible at https://github.com/project-numina/numina-lean-agent and includes:

- A Python MCP server (FastAPI) managing tool registration, schema specification, and handler execution.
- The `lean-lsp-mcp` adapter (Dressler 2025) for Lean v4.26.0.
- A LeanDex theorem index (based on LeanExplore) covering mathlib and FLT.
- Gemini-based informal-prover functionality.
- CLI and notebook interfaces for benchmark execution and interactive use.

Reproducibility involves standard open-source installation and configuration steps. Adding new MCP tools is protocol-driven (subclass a handler and register it in `mcp/tools.py`), reflecting the modularity of the architecture [2601.14027].

## 7. Limitations and Prospects

Numina-Lean-Agent exhibits several constraints:

- **Readability:** Generated proofs, while functional, may lack high-level structuring and remain overly tactic-driven compared to hand-written mathematical code.
- **Type-level brittleness:** Certain type conversions (e.g., Real to NNReal) may challenge the agent, necessitating occasional human intervention or pre-processing.
- **Scalability:** Very large formalization efforts can trigger context limitations, though the subagent mechanism partially mitigates this in practice.

Planned enhancements target high-level proof planning (to induce idiomatic Lean constructs such as `@[simp]` lemmas), improved type inference guidance, deeper neural subgoal decomposition for scalability, and more user-friendly interfaces for blueprint-guided workflows and MCP decision inspection. The open, protocol-driven design supports future integration of specialized tools and evolving LLM architectures [2601.14027].

In conclusion, Numina-Lean-Agent exemplifies a generalizable, model-agnostic approach to formal mathematical reasoning, leveraging lightweight orchestration and general code agents to solve benchmark tasks and enable collaborative, large-scale formalization. Its architecture supports extensibility and adaptability for advanced research in automated formal mathematics.

Source: https://www.emergentmind.com/topics/numina-lean-agent