Infinite Problem Generator: Verifiably Scaling Physics Reasoning Data with Agentic Workflows

Ce papier présente l'Infinite Problem Generator (IPG), un cadre agentique qui surmonte la pénurie de données de raisonnement physique vérifiables en générant des problèmes via des programmes Python exécutables, garantissant ainsi la cohérence mathématique et permettant une génération de curriculum contrôlée grâce à une corrélation linéaire entre la complexité du code et la difficulté du problème.

L'essentiel

Imaginez que vous essayez d'enseigner à un robot (une intelligence artificielle) comment résoudre des problèmes de physique, comme ceux que les étudiants rencontrent à l'université. Le problème, c'est que pour apprendre, le robot a besoin de milliers d'exemples parfaits. Mais trouver ces exemples est difficile : si on demande à un autre robot de les inventer, il risque de se tromper, d'inventer des lois de la physique qui n'existent pas, ou de donner des réponses fausses.

C'est là qu'intervient le Générateur Infini de Problèmes (IPG), présenté dans cet article par des chercheurs de l'Inde. Voici comment cela fonctionne, expliqué simplement avec des images du quotidien.

1. Le Problème : Le "Cuisine" de l'IA

Actuellement, pour entraîner les IA, on leur donne souvent des livres de physique ou on leur demande d'inventer des exercices.

• Le risque : Si on demande à une IA d'écrire un exercice, elle peut faire une "hallucination". C'est comme si un chef cuisinier inventait une recette avec des ingrédients qui n'existent pas (ex: "ajoutez 200g de poussière de lune"). Le résultat semble plausible, mais c'est faux.
• Le besoin : Il faut des exercices où la solution est vérifiable. On ne veut pas juste une réponse, on veut voir les étapes de calcul.

2. La Solution : Le "Cuisinier Robot" avec un Livre de Recettes Numérique

Les chercheurs ont créé un système appelé IPG. Au lieu de laisser l'IA écrire du texte librement, ils lui donnent un cadre très strict.

Imaginez que l'IA n'est pas un écrivain, mais un chef robot qui doit cuisiner.

• La "Recette" (Formule-as-Code) : Au lieu de donner les formules de physique (comme $F=ma$) sous forme de texte, les chercheurs les ont transformées en fonctions informatiques (du code Python). C'est comme si le chef avait des robots qui préparent automatiquement les ingrédients. Si le robot dit "mélangez A et B", le code exécute réellement l'opération.
• Le "Contrôleur de Qualité" : Chaque fois que le chef robot invente un nouvel exercice (par exemple, "un train qui percute un camion"), le système exécute immédiatement le code pour voir si ça marche.
  • Si le code plante ou donne un résultat impossible (comme une vitesse négative ou un camion qui pèse 1000 tonnes), l'exercice est jeté à la poubelle.
  • Si le code tourne parfaitement et donne un résultat logique, l'exercice est validé.

3. Comment ça marche en pratique ? (Le Processus en 3 Étapes)

1. L'Analyse (Le Chef regarde la recette de base) :
   Le système prend un exercice classique écrit par un expert humain (un "grain" de départ). Il analyse les lois physiques utilisées (ex: la gravité, le frottement).

   • Analogie : C'est comme si le chef prenait une recette de "Gâteau au chocolat" et listait les ingrédients de base (farine, œufs, cacao).

2. La Génération Contrainte (Le Chef invente de nouvelles versions) :
   Le système demande à l'IA de créer 10 nouvelles histoires basées sur la même recette, mais avec des décors différents (un train, un ascenseur, un patineur).

   • La règle d'or : L'IA ne peut utiliser que les "ingrédients" (les formules) qui sont dans sa liste officielle. Elle ne peut pas en inventer de nouveaux.
   • Elle doit aussi s'assurer que l'histoire a du sens (pas de train volant sans moteur).

3. La Vérification par le Code (Le Test du Plat) :
   Avant de servir le plat, le système écrit un petit programme informatique qui résout le problème.

   • Si le programme réussit à calculer la réponse sans erreur, le problème est sauvegardé.
   • C'est comme si le chef devait faire goûter le plat à un robot qui vérifie le goût exact. Si le goût est faux, le plat est détruit.

4. La Découverte Surprenante : La "Carte de Complexité"

Les chercheurs ont fait une découverte intéressante. Ils ont remarqué une relation directe entre la difficulté d'un problème et la longueur du code nécessaire pour le résoudre.

• L'analogie : Plus un problème est complexe (nécessite beaucoup d'étapes), plus le "plan de construction" (le code) est long.
• Pourquoi c'est génial ? Cela permet de créer des cours progressifs. Si vous voulez un problème facile, vous demandez un code court. Si vous voulez un problème difficile, vous demandez un code long. C'est comme un mètre à mesurer la difficulté qui ne ment jamais.

5. Le Résultat : Une Bibliothèque Infinie

Grâce à cette méthode, ils ont pris 165 exercices de manuels scolaires classiques et les ont transformés en 1 335 exercices uniques et vérifiés.

• Ils ont créé une base de données appelée ClassicalMechanicsV1.
• Contrairement aux anciennes méthodes où l'IA inventait des choses au hasard, ici, chaque problème est garanti solvable par un ordinateur.

En Résumé

Cet article présente une méthode pour automatiser la création de devoirs de physique parfaits.
Au lieu de laisser l'IA "rêver" des problèmes, on lui donne un laboratoire virtuel où elle doit construire des exercices. Si l'exercice ne tient pas debout mathématiquement (le code échoue), il est rejeté.

C'est comme passer de l'écriture d'une histoire à la main (où on peut faire des fautes) à la construction d'un pont avec des pièces Lego préfabriquées : si le pont ne tient pas, on ne le construit pas. Cela permet d'avoir une quantité illimitée de problèmes de haute qualité pour entraîner les futures intelligences artificielles à raisonner comme des physiciens.

Résumé technique

1. Problématique

L'adaptation des grands modèles de langage (LLM) à des domaines nécessitant un raisonnement complexe, comme la physique, est actuellement limitée par la pénurie de données d'entraînement vérifiables et de haute qualité.

• Limites des approches actuelles : L'augmentation textuelle standard introduit souvent des "hallucinations" mathématiques. Les benchmarks existants (comme JEEBench ou UGPhysics) sont statiques, conçus pour le test et non pour l'entraînement, et manquent de traces de raisonnement exécutables nécessaires au fine-tuning.
• Le défi spécifique : Les problèmes de physique (niveau examen d'entrée indien JEE) exigent une identification de contraintes implicites, la sélection de lois physiques et un raisonnement mathématique précis. Les méthodes de génération synthétique actuelles peinent à maintenir la cohérence logique sur des chaînes de raisonnement longues.

2. Méthodologie : Infinite Problem Generator (IPG)

Les auteurs proposent IPG, un cadre agentique qui génère des problèmes de physique avec une solvabilité garantie via un paradigme "Formule-Code" (Formula-as-Code).

A. Paradigme Formule-Code

Contrairement à la génération de texte probabiliste, IPG traite les équations physiques non pas comme des tokens textuels, mais comme des fonctions Python exécutables.

• Les formules sont encodées dans une bibliothèque d'axiomes validés (ex: kinematics.final_velocity(u, a, t)).
• Cela force la modularité, limite les opérations erronées et permet une vérification numérique en temps réel.

B. Flux de travail en trois phases

Le pipeline suit une approche Générer puis Vérifier :

1. Phase I : Analyse du problème et expansion du contexte

   • À partir d'un "couple graine" (question experte + solution), l'agent extrait les principes physiques sous-jacents.
   • Il mappe ces principes à un dictionnaire de chapitres pour identifier un Contexte Narratif (ex: remplacer une poulie par un rouleau de film) et une Bibliothèque de Formules disponible.
   • Il construit un dictionnaire de variables avec des plages physiques valides (ex: masse > 0).

2. Phase II : Génération de problèmes contraints

   • L'agent génère des variations narratives tout en découplant la variation linguistique du raisonnement numérique.
   • Contrôle de difficulté : Le nombre de formules utilisées est limité (ex: 3 à 5 axiomes) pour forcer le raisonnement multi-étapes.
   • Signature de problème : Chaque problème reçoit une signature unique (ensemble de formules + variable cible) pour éviter les doublons.

3. Phase III : Génération de solution par exécution de code

   • Pour chaque problème généré, l'agent doit produire un script Python qui résout le problème en appelant uniquement les fonctions de la bibliothèque d'axiomes.
   • Vérification : Le code est exécuté dans un environnement isolé (sandbox). Il n'est accepté que s'il est :
     • Syntaxiquement valide.
     • Numériquement soluble (pas de NaN ou infini).
     • Physiquement sain (respect des contraintes de signe et de magnitude).
   • En cas d'échec, une boucle de réessai guidée par les erreurs de trace est déclenchée.

3. Contributions Clés

1. Cadre de vérification agentique (IPG) : Un pipeline qui couple la variation narrative à la vérification par exécution de code, réduisant drastiquement les hallucinations mathématiques.
2. Dataset ClassicalMechanicsV1 : Un corpus de 1 335 problèmes de mécanique classique (niveau licence), dérivés de 165 graines d'experts. Chaque problème inclut un chemin de solution exécutable et une vérification numérique.
3. Blueprint de Complexité (Complexity Blueprint) : La découverte d'une corrélation linéaire forte ($R^2 \approx 0,95$) entre le nombre de formules physiques intégrées et la longueur du code de vérification. Cela permet d'utiliser la complexité du code comme métrie précise et sans proxy pour contrôler la difficulté des problèmes générés.

4. Résultats et Analyse

• Diversité Structurelle : Le corpus couvre 102 formules uniques avec une complexité moyenne de 3,05 formules par problème. Il démontre un fort "mélange de domaines" (Domain Mixing), combinant des concepts de chapitres différents (ex: Friction + Mouvement Rotatoire).
• Qualité et Robustesse :
  • Taux de réussite de la vérification : 99,85 %.
  • Seuls 2 problèmes sur 1 335 ont été rejetés pour instabilité numérique.
  • Le taux d'expansion est d'environ 8x par graine.
• Analyse des échecs :
  • Pour les problèmes simples (2-3 formules), les erreurs sont rares (<1 %).
  • Pour les problèmes complexes (4+ formules), les erreurs se concentrent sur des "incohérences de signature" (l'agent dérive correctement les valeurs intermédiaires mais échoue à les lier à la variable cible), révélant une limite actuelle des LLMs dans le maintien du contexte à long terme.
• Benchmarking : L'évaluation du modèle Qwen3-14B sur ce dataset montre une performance inférieure à celle sur JEEBench, suggérant que les problèmes générés capturent efficacement la complexité du raisonnement "long horizon" et ne sont pas "jouables" par des astuces de sélection de réponses multiples.

5. Signification et Impact

Ce travail comble le fossé entre les benchmarks de test statiques et les besoins en données d'entraînement dynamiques pour le raisonnement scientifique.

• Scalabilité Vérifiable : IPG démontre qu'il est possible de générer des données d'entraînement massives pour la physique tout en garantissant la rigueur mathématique grâce à l'exécution de code.
• Contrôle du Curriculum : La "Blueprint de Complexité" permet de construire des curriculums d'apprentissage adaptatifs en contrôlant simplement la longueur du code ou le nombre de formules, sans annotation humaine coûteuse.
• Reproductibilité : Le pipeline complet, le dataset et les rapports d'évaluation sont publiés pour soutenir la recherche reproductible dans les domaines exigeant un raisonnement intensif.

En résumé, l'article propose une solution élégante au problème de la qualité des données synthétiques en physique, en remplaçant la validation textuelle par une validation exécutable, transformant ainsi la génération de problèmes en un processus déterministe et vérifiable.