원본 영상을 바탕으로 AI의 도움을 받아 작성했습니다. 원본 영상이 기준입니다.
Log in to leave a comment
아직 작성된 글이 없습니다
Cuando se despliega un sistema de resolución de problemas matemáticos a gran escala en el escritorio de un laboratorio, la descripción general de una gran arquitectura no sirve de nada. A continuación, se detallan los pasos prácticos para configurar directamente el pipeline de Lean 4 en un entorno local y vincular agentes múltiples de ejecución prolongada para automatizar por completo las tareas de exploración matemática.
Instalar manualmente Lean 4 en el entorno de desarrollo y depender del Protocolo de Servidor de Lenguaje de VS Code provoca cuellos de botella graves durante la verificación de IA a gran escala. Si los binarios precompilados de Mathlib4 no se almacenan en caché, la CPU local recompila directamente cientos de miles de teoremas, lo que hace que la configuración del entorno demore más de 180 minutos. Para procesar solicitudes de verificación de código a una velocidad de decenas o más por segundo, es necesario cambiar al pipeline de Kimina Lean Server basado en FastAPI.
El procedimiento de configuración específico para reducir el tiempo de preparación de las tareas de verificación de problemas matemáticos de ejecución prolongada de 180 minutos a menos de 20 minutos es el siguiente:
`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
`
Al completar esta tarea, se recibe inmediatamente la caché precompilada para preparar un entorno de ejecución REPL local completo en 20 minutos, capaz de verificar simultáneamente hasta 50 cláusulas de demostración por segundo.
Intentar demostrar teoremas complejos mediante una única llamada al prompt de un modelo de lenguaje grande provoca la pérdida de subobjetivos o la entrada en bucles infinitos a medida que el contexto se alarga. Es necesario aplicar una arquitectura de gráfico acíclico dirigido y jerárquico que separe los roles en un agente raíz, encargado de la división de problemas, y subagentes que ejecutan tácticas secundarias aisladas.
Adoptar el formato JSON como especificación de comunicación entre agentes y aislar el alcance al transmitir los prompts permite reducir el consumo de tokens de API en más de un 40 por ciento. El esquema JSON utilizado al invocar a un subagente es el siguiente:
`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"]
}
`
El orden de control paso a paso para bloquear bucles infinitos causados por alucinaciones del agente y activar una estructura jerárquica estable es el siguiente:
En tareas de exploración de demostraciones que duran varias horas, enviar todo el historial de conversación a la API del backend en cada solicitud hace que el uso de tokens se disparé. Es necesario construir una capa de caché basada en LeanExplore y Vector DB, y controlar la sobrecarga de tokens de entrada resumiendo y reflejando los resultados de tácticas intermedias ya verificadas en el gráfico de memoria en forma de lemas auxiliares.
Registra el identificador de entorno de la sesión REPL en el servidor backend para eliminar las declaraciones repetitivas de import Mathlib en la parte superior del prompt. Solo con esto, los tokens de entrada se pueden reducir inmediatamente entre un 50 y un 70 por ciento. El procedimiento de implementación del pipeline de control para evitar picos en los costos de API debido a exceder los límites del presupuesto es el siguiente:
`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)
`
El método en el que un agente de IA genera código y luego se revisan manualmente los errores constituye un cuello de botella crítico para toda la investigación. Los datos analizados en JSON de errores de sintaxis, discrepancias de tipos y objetivos no resueltos que emite el compilador Lean REPL deben conectarse directamente como entrada de retroalimentación para el agente.
El funcionamiento del bucle de control de corrección automática, que reemplaza la revisión manual y duplica o más la velocidad de investigación, es el siguiente:
`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
`
El código limpio (Clean) completamente verificado pasa a través de las herramientas de conversión doc-gen4 y paperproof para generarse automáticamente en contextos de LaTeX y visualizaciones de gráficos lógicos que se pueden insertar inmediatamente en un documento de investigación.
`bash
lake build LeanAutomation:docs
lean-graph extract --input Main.lean --output proof_dependency.json
`