Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Ao implantar um sistema de resolução de problemas matemáticos em grande escala na área de trabalho do laboratório, a visão geral da macro-arquitetura não ajuda em nada. Aqui, detalhamos as etapas práticas para configurar diretamente o pipeline Lean 4 em um ambiente local e integrá-lo a agentes múltiplos de execução prolongada para automatizar completamente as tarefas de exploração matemática.
Instalar manualmente o Lean 4 no ambiente de desenvolvimento e depender do protocolo de servidor de linguagem do VS Code causa sérios gargalos durante a verificação de IA em grande escala. Se os binários pré-compilados do Mathlib4 não forem armazenados em cache, a CPU local recompilará diretamente centenas de milhares de teoremas, demorando mais de 180 minutos apenas para configurar o ambiente. Para processar solicitações de verificação de código dezenas de vezes por segundo, é necessário mudar para o pipeline Kimina Lean Server baseado em FastAPI.
O procedimento de construção específico para reduzir o tempo de configuração da tarefa de verificação de problemas matemáticos de execução prolongada de 180 minutos para menos de 20 minutos é o seguinte:
leanprover/lean4:v4.15.0 dentro do arquivo.lakefile.lean e especifique o pacote Mathlib4 e o repositório repl que lida com E/S JSON baseada em stdio.`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» {
}
`
`bash
lake update
lake exe cache get
lake build
`
Ao concluir esta tarefa, o cache pré-compilado é recebido imediatamente e um ambiente de execução REPL local completo é preparado em 20 minutos, permitindo a verificação simultânea de até 50 parágrafos de prova por segundo.
Ao tentar provar teoremas complexos com uma única chamada de prompt de modelo de linguagem grande, submetas são perdidas ou um loop infinito é inserido à medida que o contexto se torna mais longo. É necessário aplicar uma arquitetura de gráfico acíclico direcionado hierárquico, separando os papéis em um agente raiz responsável pela divisão de problemas e subagentes que executam táticas secundárias isoladas.
Adotando o formato JSON como especificação de comunicação do agente e isolando o escopo para passar os prompts, é possível reduzir o consumo de tokens da API em mais de 40%. O esquema JSON usado ao chamar um subagente é o seguinte:
`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"]
}
`
A sequência de controle passo a passo para bloquear loops infinitos causados por alucinações de agentes e operar uma estrutura hierárquica estável é a seguinte:
proofState retornada pelo Lean REPL usando o algoritmo SHA-256 e armazene-o na memória. Se o mesmo hash de estado for detectado duplicado 3 vezes ou mais, podar esse ramo de exploração.Em tarefas de exploração de provas que duram horas, enviar todo o histórico de conversas para a API de backend a cada solicitação faz com que o uso de tokens exploda. É necessário construir uma camada de cache baseada em LeanExplore e Vector DB, e controlar a sobrecarga de tokens de entrada refletindo resumidamente os resultados de táticas intermediárias já verificadas no gráfico de memória na forma de teoremas auxiliares.
Registre o identificador de ambiente da sessão REPL no servidor de backend para remover a sintaxe repetitiva import Mathlib no topo dos prompts. Somente isso pode reduzir imediatamente os tokens de entrada de 50% para 70%. O procedimento de implementação do pipeline de controle para evitar a explosão de custos de API devido ao excesso de limites de orçamento é o seguinte:
.leanflow/cache/ e .leanflow/workflow-state/ no diretório do ambiente local.CostMonitor baseado em Python para rastrear cumulativamente os tokens e custos consumidos durante chamadas de API em tempo real.`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)
`
O método em que o agente de IA gera código e revisa manualmente os erros é um gargalo fatal para toda a pesquisa. Os dados de análise JSON, como erros de sintaxe, incompatibilidades de tipo e objetivos não resolvidos gerados pelo compilador Lean REPL, devem ser conectados diretamente à entrada de feedback do agente.
Como funciona o loop de controle de correção automática, que substitui a revisão manual e melhora a velocidade de pesquisa em mais de 2 vezes:
`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 The"].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
`
O código Clean totalmente verificado passa pelas ferramentas de conversão doc-gen4 e paperproof para gerar automaticamente visualizações de gráficos lógicos e contexto LaTeX que podem ser inseridos imediatamente em artigos de pesquisa.
`bash
lake build LeanAutomation:docs
lean-graph extract --input Main.lean --output proof_dependency.json
`