Pourquoi les preuves Lean générées par l'IA nécessitent plus qu'une simple vérification de compilation
Une nouvelle analyse révèle que les preuves formelles en Lean générées par l'IA exigent des étapes de vérification rigoureuses au-delà de la compilation pour garantir qu'elles correspondent bien aux énoncés mathématiques visés.
Traduit automatiquement depuis l'original anglais.
Les récentes affirmations selon lesquelles l'intelligence artificielle a résolu d'importants problèmes mathématiques à l'aide de l'assistant de preuve Lean méritent un examen attentif. Une analyse détaillée du récent dépôt de théorèmes d'OpenAI et de résultats similaires de DeepMind montre que le simple fait que le code compile ne suffit pas à garantir sa justesse. Les ingénieurs et les mathématiciens doivent effectuer des tests de validation spécifiques pour combler le fossé entre les affirmations informelles des articles et le code formel.
Ce qui s'est passé
Le mois dernier, OpenAI a publié une collection de 722 articles mathématiques, dont environ 45 % étaient accompagnés de code Lean. Depuis cette publication, trois articles sans code formel ont été retirés en raison d'erreurs de signe, soulevant des questions sur la fiabilité de l'ensemble du lot. Alors que certains observateurs soutiennent que le système de types strict de Lean garantit la vérité, d'autres soulignent que les modèles d'IA peuvent exploiter des failles ou que la formalisation pourrait ne pas correspondre à l'intention originale. La réalité se situe dans un terrain intermédiaire nuancé où la vérification est possible mais exige un effort délibéré.
Le problème central est que beaucoup de ces dépôts générés par l'IA n'ont pas encore subi de tests systématiques. Par exemple, dans le dépôt d'OpenAI, environ 38 des 290 théorèmes dotés de code Lean n'énoncent même pas, et encore moins ne prouvent, le résultat principal revendiqué dans le PDF correspondant. Dans un cas, un article prétendant résoudre la conjecture de multiplicité de Lech n'avait formalisé qu'un corollaire mineur. Cette divergence souligne que « avoir du code Lean » n'est pas synonyme de « disposer d'une preuve vérifiée du théorème phare ».
Des problèmes similaires apparaissent dans les travaux d'autres organisations. La formalisation de la conjecture de Hodge par DeepMind repose sur plus de 10 000 lignes de code personnalisé, car les bibliothèques standard manquent des définitions nécessaires. L'affirmation d'Axiom concernant la classification des groupes simples finis dépend d'une immense bibliothèque générée par l'IA appelée Tau Ceti, qui contient plus de 250 000 lignes de code. Sans experts humains pour vérifier ces définitions fondamentales, la justesse de l'énoncé lui-même reste incertaine, indépendamment du fait que la preuve compile ou non.
Comment cela fonctionne
Pour faire confiance à une preuve Lean générée par l'IA, il faut répondre à quatre questions critiques. Premièrement, l'énoncé Lean correspond-il à l'énoncé informel de l'article ? Lean distingue nettement l'énoncé d'un théorème de sa preuve. Un énoncé peut être syntaxiquement correct mais mathématiquement faux, comme définir le Dernier Théorème de Fermat sur les entiers naturels incluant zéro, ce qui rend l'énoncé trivialement faux. Vérifier cette correspondance nécessite souvent de lire des milliers de lignes de code de dépendances, surtout lorsque les bibliothèques standard comme Mathlib sont insuffisantes.
Deuxièmement, le code compile-t-il ? Le code généré par l'IA peut être gourmand en ressources ou potentiellement malveillant. La formalisation du Dernier Théorème de Fermat par Anthropic a nécessité 96 cœurs et 500 gigaoctets de RAM pour compiler, tandis que la résolution de Navier-Stokes par OpenAI tient sur un ordinateur portable. Les développeurs doivent toujours exécuter le code généré par l'IA dans un environnement isolé (sandbox) avant de le lancer, afin de prévenir tout dommage potentiel au système. La compilation confirme la validité syntaxique, mais pas la vérité sémantique.
Troisièmement, le code prouve-t-il le théorème tel qu'il est énoncé ? Les fichiers de preuve peuvent importer des millions de lignes de code non fiable qui pourraient redéfinir subtilement des termes ou ajouter des axiomes. Pour vérifier que la preuve dans les fichiers non fiables correspond à l'énoncé dans les fichiers fiables, les développeurs utilisent un outil appelé lake comparator. Cet outil garantit que le théorème prouvé est identique au théorème énoncé et qu'aucun axiome supplémentaire n'a été introduit durant le processus de preuve.
Quatrièmement, le code exploite-t-il un bug dans le noyau de Lean ? Bien que rares, des bugs de solidité logique peuvent exister. Pour atténuer ce risque, on peut utiliser lake comparator --paranoid, qui vérifie la preuve contre plusieurs noyaux indépendants, y compris ceux qui sont formellement vérifiés. Si une preuve passe avec succès sur différents noyaux, il est très peu probable qu'elle repose sur un bug spécifique de l'implémentation.
Détails clés
- Le récent dépôt d'OpenAI comprenait 722 articles, dont 45 % associés à du code Lean.
- Environ 38 des 290 théorèmes liés à Lean ne formalisent pas le résultat principal de l'article.
- La vérification de l'énoncé de théorèmes complexes peut nécessiter l'examen de plus de 10 000 lignes de code de définition personnalisée.
- L'outil
lake comparatorvérifie que le théorème prouvé correspond au théorème énoncé sans axiomes cachés. - L'utilisation de
lake comparator --paranoidvalide les preuves contre plusieurs noyaux indépendants pour écarter les bugs logiciels. - Même si le code Lean est correct, le PDF accompagnant peut toujours contenir des erreurs ou diverger de la preuve formelle.
Pourquoi c'est important
Pour les ingénieurs logiciels et les responsables techniques travaillant avec l'IA, cette analyse souligne l'importance des pipelines de vérification. Il ne suffit pas d'accepter la sortie de l'IA parce qu'elle s'exécute sans erreur. Dans les domaines critiques pour la sécurité, présumer de la justesse sur la seule base de la compilation introduit un risque significatif. La distinction entre un énoncé compilable et une preuve valide est subtile mais cruciale, nécessitant des outils et des processus allant au-delà de la simple exécution.
Cette situation met également en lumière les limites actuelles de la formalisation automatisée. Bien que l'IA puisse générer d'énormes quantités de code, l'alignement sémantique entre le langage humain informel et la logique formelle demeure un goulot d'étranglement. Les équipes adoptant ces technologies doivent investir dans des cadres de test robustes, tels que la comparaison de noyaux et la compilation en environnement isolé, pour s'assurer que leurs assistants IA ne produisent pas seulement des artefacts plausibles mais fondamentalement erronés.
Ce que vous pouvez faire
- Toujours exécuter le code Lean généré par l'IA dans un environnement isolé avant de le compiler, afin de protéger votre environnement local contre tout comportement potentiellement malveillant ou erratique.
- Utiliser
lake comparatorpour vérifier que le théorème prouvé dans les fichiers non fiables correspond exactement à l'énoncé dans les fichiers fiables. - Exécuter
lake comparator --paranoidpour vérifier les preuves contre plusieurs noyaux indépendants, réduisant ainsi le risque de bugs logiciels non détectés. - Inspecter manuellement l'énoncé du théorème principal dans le code Lean pour s'assurer qu'il correspond à l'affirmation informelle de l'article associé.
- Se montrer sceptique face aux affirmations où la base de code Lean est considérablement plus grande que les bibliothèques standard, car cela peut indiquer des définitions personnalisées non vérifiées.
- Reconnaître qu'une preuve Lean correcte ne valide pas automatiquement le PDF accompagnant, qui peut toujours contenir des erreurs logiques ou des divergences.



