A Guide to Setting Up a Local Lean 4 Proof Automation Environment for Mathematical Research

When deploying large-scale mathematical problem-solving systems on a lab desktop, high-level architecture overviews are of no help. Here, we outline the practical steps to directly set up a local Lean 4 pipeline and integrate long-running multi-agents to fully automate mathematical exploration tasks.

Building a Local Lean Proof Verification Environment

Manually installing Lean 4 in a development environment and relying on the VS Code Language Server Protocol causes severe bottlenecks during large-scale AI verification. If Mathlib4 precompiled binaries are not cached, local CPUs will directly recompile hundreds of thousands of theorems, taking over 180 minutes just to set up the environment. To handle code verification requests at a rate of dozens per second or more, you must switch to a FastAPI-based Kimina Lean Server pipeline.

The specific setup procedure to shorten the setup time for long-running mathematical problem verification tasks from 180 minutes to under 20 minutes is as follows:

Pin the toolchain in the lean-toolchain file at the project root directory. Enter the text leanprover/lean4:v4.15.0 inside the file.
Open the lakefile.lean configuration file and specify the Mathlib4 package and the repl repository that handles stdio-based JSON input/output.

`lean
import Lake
open Lake DSL

package «proof_automation» {
}

require mathlib from git
"https://github.com/leanprover-community/mathlib4.git" @ "v4.15.0"

require repl from git
"https://github.com/leanprover-community/repl.git" @ "main"

@[default_target]
lean_lib «ProofAutomation» {
}

Open the terminal and execute the following commands sequentially to download and build the precompiled binary artifacts:

`bash
lake update
lake exe cache get
lake build

Once this task is complete, precompiled caches are received instantly, preparing a fully functional local REPL execution environment in under 20 minutes, capable of simultaneously verifying up to 50 proof clauses per second.

Root and Sub-Agent Role-Division Design

Attempting to prove complex theorems with a single large language model prompt call causes it to lose sub-goals or enter infinite loops as the context grows longer. You must apply a hierarchical Directed Acyclic Graph (DAG) architecture that separates roles into a root agent responsible for problem partitioning and sub-agents executing isolated sub-tactics.

Adopting the JSON format as the agent communication specification and isolating scopes to pass prompts can reduce API token consumption by more than 40 percent. The JSON schema used when calling sub-agents is as follows:

`json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "SubAgentProofTask",
"type": "object",
"properties": {
"task_id": { "type": "string" },
"target_hypothesis": { "type": "string" },
"current_goal_state": { "type": "string" },
"previous_failure_logs": {
"type": "array",
"items": {
"type": "object",
"properties": {
"attempted_tactic": { "type": "string" },
"error_message": { "type": "string" }
}
}
},
"sub_goal_target": { "type": "string" }
},
"required": ["task_id", "target_hypothesis", "current_goal_state", "sub_goal_target"]
}

The step-by-step control sequence to block infinite loops caused by agent hallucinations and operate a stable hierarchical structure is as follows:

When binding input prompts to sub-agents, configure the prompt to remove the entire conversation history and transmit only three core elements: hypotheses, Goal State, and previous failure logs.
Hash the proofState string returned from the Lean REPL using the SHA-256 algorithm and store it in memory. If the same state hash is detected repeatedly 3 or more times, prune that exploration branch.
Set a 5-second timeout for single tactic operations and a 120-second timeout for overall sub-agent exploration, issuing a SIGKILL signal upon exceedance to immediately reorganize the REPL process.

Context Management Strategies for Controlling API Token Costs

In proof exploration tasks lasting several hours, sending the entire conversation history to the backend API with every request causes token usage to skyrocket. You must build a caching layer based on LeanExplore and Vector DB, and control input token overhead by summarizing and reflecting already verified intermediate tactic results into the memory graph in the form of auxiliary lemmas.

Register the environment identifier of the REPL session on the backend server to eliminate repetitive import Mathlib statements at the top of prompts. This alone can instantly reduce input tokens by 50 to 70 percent. The implementation procedure for the control pipeline to prevent API cost explosions caused by budget limit excesses is as follows:

Create .leanflow/cache/ and .leanflow/workflow-state/ paths in the local environment directory.
Write a Python-based CostMonitor module to additively track tokens and costs consumed during API calls in real-time.
Run a script that saves a checkpoint snapshot file and safely halts the process once the threshold amount is reached.

`python
import sys
import json
import logging

class CostMonitor:
def init(self, max_budget_usd: float, token_cost_per_1k: float):
self.max_budget = max_budget_usd
self.cost_per_1k = token_cost_per_1k
self.total_tokens_used = 0
self.current_cost = 0.0

def track_usage(self, prompt_tokens: int, completion_tokens: int):
    tokens_in_call = prompt_tokens + completion_tokens
    self.total_tokens_used += tokens_in_call
    self.current_cost += (tokens_in_call / 1000.0) * self.cost_per_1k
    
    logging.info(f"[TELEMETRY] Used Tokens: {tokens_in_call} | Total Cost: ${self.current_cost:.4f}")
    
    if self.current_cost >= self.max_budget:
        self.trigger_safe_pause()

def trigger_safe_pause(self):
    logging.warning("[WARNING] Target budget threshold reached. Pausing workflow...")
    with open(".leanflow/workflow-state/checkpoint.json", "w") as f:
        json.dump({"status": "PAUSED_BUDGET_EXCEEDED", "tokens": self.total_tokens_used}, f)
    sys.exit(0)

Implementing a Proof Code Error Auto-Correction Loop

The approach where AI agents generate code and humans manually review errors is a fatal bottleneck for overall research. JSON-parsed data such as syntax errors, type mismatches, and unresolved goals output by the Lean REPL compiler must be directly connected as feedback input to the agent.

How the auto-correction control loop—which replaces manual reviews and improves research speed by more than 2x—operates is as follows:

Receive the JSON response returned from the Lean REPL and extract error locations, type error messages, and remaining goals into structured data through the Python parser below:

`python
def parse_lean_repl_output(repl_response_json: str):
data = json.loads(repl_response_json)
parsed_diagnostics = {
"has_error": False,
"errors": [],
"open_sorries": []
}

if "messages" in data:
    for msg in data["messages"]:
        if msg.get("severity") == "error":
            parsed_diagnostics["has_error"] = True
            parsed_diagnostics["errors бассейны" if False else "errors"].append({
                "line": msg["pos"]["line"],
                "column": msg["pos"]["column"],
                "data": msg["data"]
            })
            
if "sorries" in data:
    for sorry in data["sorries"]:
        parsed_diagnostics["open_sorries"].append({
            "goal": sorry["goal"],
            "proof_state": sorry["proofState"],
            "line": sorry["pos"]["line"]
        })
        
return parsed_diagnostics

For the initial 1 to 4 attempts, bind parsed error message data to the sub-agent prompt to locally and precisely modify the tactic parameters at that location.
If verification fails continuously for 5 or more times at the same point, automatically switch to a sketch re-partitioning mode that backtracks and discards that proof strategy, cutting auxiliary lemmas into smaller units.

Fully verified clean code passes through doc-gen4 and paperproof conversion tools, automatically generating logical graph visualizations and LaTeX contexts ready for immediate insertion into research papers.

`bash
lake build LeanAutomation:docs
lean-graph extract --input Main.lean --output proof_dependency.json

A Guide to Setting Up a Local Lean 4 Proof Automation Environment for Mathematical Research

Building a Local Lean Proof Verification Environment

The specific setup procedure to shorten the setup time for long-running mathematical problem verification tasks from 180 minutes to under 20 minutes is as follows:

Pin the toolchain in the lean-toolchain file at the project root directory. Enter the text leanprover/lean4:v4.15.0 inside the file.
Open the lakefile.lean configuration file and specify the Mathlib4 package and the repl repository that handles stdio-based JSON input/output.

`lean
import Lake
open Lake DSL

package «proof_automation» {
}

require mathlib from git
"https://github.com/leanprover-community/mathlib4.git" @ "v4.15.0"

require repl from git
"https://github.com/leanprover-community/repl.git" @ "main"

@[default_target]
lean_lib «ProofAutomation» {
}

Open the terminal and execute the following commands sequentially to download and build the precompiled binary artifacts:

`bash
lake update
lake exe cache get
lake build

Root and Sub-Agent Role-Division Design

The step-by-step control sequence to block infinite loops caused by agent hallucinations and operate a stable hierarchical structure is as follows:

When binding input prompts to sub-agents, configure the prompt to remove the entire conversation history and transmit only three core elements: hypotheses, Goal State, and previous failure logs.
Hash the proofState string returned from the Lean REPL using the SHA-256 algorithm and store it in memory. If the same state hash is detected repeatedly 3 or more times, prune that exploration branch.
Set a 5-second timeout for single tactic operations and a 120-second timeout for overall sub-agent exploration, issuing a SIGKILL signal upon exceedance to immediately reorganize the REPL process.

Context Management Strategies for Controlling API Token Costs

Create .leanflow/cache/ and .leanflow/workflow-state/ paths in the local environment directory.
Write a Python-based CostMonitor module to additively track tokens and costs consumed during API calls in real-time.
Run a script that saves a checkpoint snapshot file and safely halts the process once the threshold amount is reached.

`python
import sys
import json
import logging

def track_usage(self, prompt_tokens: int, completion_tokens: int):
    tokens_in_call = prompt_tokens + completion_tokens
    self.total_tokens_used += tokens_in_call
    self.current_cost += (tokens_in_call / 1000.0) * self.cost_per_1k
    
    logging.info(f"[TELEMETRY] Used Tokens: {tokens_in_call} | Total Cost: ${self.current_cost:.4f}")
    
    if self.current_cost >= self.max_budget:
        self.trigger_safe_pause()

def trigger_safe_pause(self):
    logging.warning("[WARNING] Target budget threshold reached. Pausing workflow...")
    with open(".leanflow/workflow-state/checkpoint.json", "w") as f:
        json.dump({"status": "PAUSED_BUDGET_EXCEEDED", "tokens": self.total_tokens_used}, f)
    sys.exit(0)

Implementing a Proof Code Error Auto-Correction Loop

How the auto-correction control loop—which replaces manual reviews and improves research speed by more than 2x—operates is as follows:

Receive the JSON response returned from the Lean REPL and extract error locations, type error messages, and remaining goals into structured data through the Python parser below:

`python
def parse_lean_repl_output(repl_response_json: str):
data = json.loads(repl_response_json)
parsed_diagnostics = {
"has_error": False,
"errors": [],
"open_sorries": []
}

if "messages" in data:
    for msg in data["messages"]:
        if msg.get("severity") == "error":
            parsed_diagnostics["has_error"] = True
            parsed_diagnostics["errors бассейны" if False else "errors"].append({
                "line": msg["pos"]["line"],
                "column": msg["pos"]["column"],
                "data": msg["data"]
            })
            
if "sorries" in data:
    for sorry in data["sorries"]:
        parsed_diagnostics["open_sorries"].append({
            "goal": sorry["goal"],
            "proof_state": sorry["proofState"],
            "line": sorry["pos"]["line"]
        })
        
return parsed_diagnostics

For the initial 1 to 4 attempts, bind parsed error message data to the sub-agent prompt to locally and precisely modify the tactic parameters at that location.
If verification fails continuously for 5 or more times at the same point, automatically switch to a sketch re-partitioning mode that backtracks and discards that proof strategy, cutting auxiliary lemmas into smaller units.

`bash
lake build LeanAutomation:docs
lean-graph extract --input Main.lean --output proof_dependency.json

A Guide to Setting Up a Local Lean 4 Proof Automation Environment for Mathematical Research

관련 영상

OpenAI Astra Just Advanced Mathematics... 10 Times.

A Guide to Setting Up a Local Lean 4 Proof Automation Environment for Mathematical Research

Building a Local Lean Proof Verification Environment

Root and Sub-Agent Role-Division Design

Context Management Strategies for Controlling API Token Costs

Implementing a Proof Code Error Auto-Correction Loop

커뮤니티의 다른 글

사내 시스템에 llm api 붙일 때 마주하는 현실적인 한계와 대응법

레거시 백엔드에 GPT-6 Astra 붙일 때 예산 승인과 보안 통과를 먼저 끝내는 법이 있습니다

에이전트끼리 대화하다 6천만 원 청구서가 나오는 이유

사내 RAG 벡터 검색에 Okta 권한 필터를 직접 거는 방법

브라우저 에이전트에게 내 구글 계정을 통째로 넘기면 안 되는 이유

Apple Won the AI Race

댓글 (0)

A Guide to Setting Up a Local Lean 4 Proof Automation Environment for Mathematical Research

Building a Local Lean Proof Verification Environment

Root and Sub-Agent Role-Division Design

Context Management Strategies for Controlling API Token Costs

Implementing a Proof Code Error Auto-Correction Loop