Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Lorsque vous installez un système de résolution de problèmes mathématiques à grande échelle sur le bureau de votre laboratoire, les grandes architectures ne vous aident en rien. Cet article résume les étapes pratiques pour configurer directement un pipeline Lean 4 dans un environnement local et y intégrer des agents multiples à exécution longue afin d'automatiser entièrement les tâches d'exploration mathématique.
Dans un environnement de développement, installer manuellement Lean 4 et dépendre du protocole de serveur de langue de VS Code provoque de sérieux goulots d'étranglement lors de la vérification par IA à grande échelle. Si les binaires précompilés de Mathlib4 ne sont pas mis en cache, le CPU local recompile lui-même des centaines de milliers de théorèmes, ce qui prend plus de 180 minutes rien que pour configurer l'environnement. Pour traiter des dizaines de requêtes de vérification de code par seconde ou plus, il est nécessaire de basculer vers un pipeline Kimina Lean Server basé sur FastAPI.
Voici la procédure de configuration spécifique pour réduire le temps de mise en place de la vérification de problèmes mathématiques à exécution longue de 180 minutes à moins de 20 minutes :
`lean
import Lake
open Lake DSL
package «proof_automation» {
}
equire 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
`
Une fois cette tâche terminée, vous recevez immédiatement le cache précompilé pour préparer un environnement d'exécution REPL local complet en 20 minutes, capable de vérifier simultanément jusqu'à 50 clauses de preuve par seconde.
Si vous tentez de prouver des théorèmes complexes avec un seul appel de prompt à un grand modèle de langage, vous perdrez les sous-objectifs ou entrerez dans une boucle infinie à mesure que le contexte s'allonge. Il convient d'appliquer une architecture de graphe acyclique dirigé hiérarchique qui sépare les rôles entre un agent racine chargé de la division des problèmes et des sous-agents exécutant des tactiques secondaires isolées.
En adoptant le format JSON comme norme de communication des agents et en transmettant les prompts avec une portée isolée, vous pouvez réduire la consommation de jetons API de plus de 40 pour cent. Voici le schéma JSON utilisé lors de l'appel d'un sous-agent :
`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"]
}
`
Voici l'ordre de contrôle étape par étape pour bloquer les boucles infinies dues aux hallucinations des agents et faire fonctionner une structure hiérarchique stable :
Lors de tâches de recherche de preuves durant plusieurs heures, transmettre l'intégralité de l'historique de conversation à l'API backend à chaque requête fait exploser l'utilisation des jetons. Il est nécessaire de construire une couche de mise en cache basée sur LeanExplore et une base de données vectorielle, et de contrôler la surcharge de jetons d'entrée en résumant et en reflétant les résultats intermédiaires de tactiques déjà vérifiés dans le graphe mémoire sous forme de lemmes auxiliaires.
Enregistrez l'identifiant d'environnement de la session REPL sur le serveur backend pour supprimer l'instruction répétitive import Mathlib en haut du prompt. Cela permet à soi seul de réduire immédiatement les jetons d'entrée de 50 à 70 pour cent. Voici la procédure d'implémentation du pipeline de contrôle pour prévenir l'explosion des coûts API due au dépassement de la limite budgétaire :
`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)
`
La méthode où l'agent d'IA génère du code puis examine manuellement les erreurs constitue un goulot d'étranglement critique pour l'ensemble de la recherche. Les données analysées au format JSON (erreurs de syntaxe, incompatibilités de types, objectifs non résolus, etc.) émises par le compilateur REPL de Lean doivent être connectées directement à l'entrée de rétroaction de l'agent.
Voici le mode de fonctionnement de la boucle de contrôle de correction automatique, qui remplace l'examen manuel et double la vitesse de recherche :
`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
`
Le code propre entièrement vérifié passe par les outils de conversion doc-gen4 et paperproof pour être généré automatiquement sous forme de visualisation de graphe logique et de contexte LaTeX immédiatement insérables dans un article de recherche.
`bash
lake build LeanAutomation:docs
lean-graph extract --input Main.lean --output proof_dependency.json
`