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

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een grootmeester wilt trainen in het oplossen van lastige natuurkundeproblemen, zoals die op het Indiase JEE-examen (een van de moeilijkste toelatingstests ter wereld). Het probleem is: er zijn niet genoeg goede, controleerbare oefeningen om deze AI te leren. Bestaande methoden zijn vaak als een slechte vertaler: ze klinken goed, maar de wiskunde klopt niet, of ze maken dingen op die in de echte wereld onmogelijk zijn.

De auteurs van dit papier hebben een oplossing bedacht: de Infinite Problem Generator (IPG). Laten we uitleggen hoe dit werkt met een paar creatieve vergelijkingen.

1. Het Probleem: De "Goochelaar" vs. De "Rekenmachine"

Normaal gesproken laten we AI's (zoals grote taalmodellen) wiskundige problemen bedenken door ze te laten "gokken" op het volgende woord. Dit is alsof je een goochelaar vraagt om een wiskundig bewijs te maken. Hij kan prachtige zinnen maken, maar als je de getallen invult, klopt het antwoord vaak niet. Het is "hallucineren": het ziet eruit als waarheid, maar is het niet.

2. De Oplossing: "Formules als Code"

De auteurs doen iets heel slim: ze behandelen natuurkundewetten niet als tekst, maar als rekenmachine-functies.

De Vergelijking: Stel je voor dat je een kok bent die een recept bedenkt. In plaats van alleen te zeggen "voeg wat zout toe" (wat vaag is), geef je de kok een exacte, programmeerbare instructie: voeg_zout(5, gram).
In de IPG: Elke natuurkundevormel (zoals $F = m \times a$ ) is een stukje Python-code dat altijd werkt. De AI mag niet zomaar een formule uit zijn hoofd verzinnen; hij moet een bestaande, geteste "rekenmachine-functie" uit de kast halen en gebruiken.

3. Hoe werkt het proces? (De "Agent" Workflow)

De IPG is als een slimme chef-kok met drie helpers die samenwerken:

De Analyseur (De Smaakmaker): Hij neemt een bestaand, goed probleem (een "zaadje") en bedenkt nieuwe verhalen.
- Voorbeeld: Het originele probleem gaat over een vallende appel. De analyseur denkt: "Laten we dit verhaal veranderen naar een rolende bowlingbal, of een vliegende raket, of een draaiende carrousel." De natuurkunde blijft hetzelfde, maar het verhaal wordt anders.
De Generator (De Bouwer): Hij maakt het nieuwe probleem op basis van het verhaal, maar hij moet strikt de "rekenmachine-functies" gebruiken die de analyseur heeft geselecteerd. Hij mag geen nieuwe, onbekende formules uit de lucht plukken.
De Verificator (De Kwaliteitscontroleur): Dit is het belangrijkste deel. Voordat het probleem wordt opgeslagen, draait de AI het echt als een computerprogramma.
- Als de code een fout geeft (bijvoorbeeld: "je deelt door nul" of "de massa is negatief"), wordt het probleem direct weggegooid.
- Alleen als de code perfect draait en een logisch antwoord geeft, wordt het probleem bewaard.

Dit is alsof je elke nieuwe puzzel eerst laat oplossen door een robot voordat je hem aan de mens geeft. Als de robot faalt, is de puzzel onbruikbaar.

4. Het Resultaat: De "Complexiteit Blauwdruk"

De auteurs ontdekten iets fascinerends. Ze zagen dat de lengte van de computercode die nodig is om een probleem op te lossen, perfect overeenkomt met hoe moeilijk het probleem is.

De Metafoor: Stel je voor dat je een huis bouwt. Als je maar één muur moet bouwen, heb je weinig materialen nodig (kort code). Als je een kasteel moet bouwen met torens en trappen, heb je veel meer materialen en een langere bouwinstructie nodig (lange code).
De ontdekking: Ze vonden een rechte lijn: hoe meer natuurkundewetten (formules) er in een probleem zitten, hoe langer de code wordt. Dit betekent dat ze nu precies kunnen controleren hoe moeilijk een probleem is, puur door naar de lengte van de code te kijken. Ze hoeven niet meer te gokken of een mens het moet beoordelen.

5. Waarom is dit belangrijk?

Ze hebben een dataset gemaakt genaamd ClassicalMechanicsV1 met 1.335 unieke problemen.

Geen "Goocheltrucs": Omdat alles door code is gecontroleerd, zijn er geen onmogelijke situaties (zoals een auto die sneller gaat dan het licht).
Leerbaar: De dataset bevat niet alleen de vraag en het antwoord, maar ook de stap-voor-stap "rekenmachine-instructies". Dit is goud waard om AI's te trainen om echt na te denken, in plaats van alleen maar te raden.
Schaalbaar: Ze begonnen met 165 goede voorbeelden en hebben er 1.335 van gemaakt. Het systeem kan oneindig doorgaan met het maken van nieuwe, gevarieerde problemen.

Samenvatting in één zin

De auteurs hebben een "robot-kok" gebouwd die natuurkundeproblemen bakt, waarbij elke stap wordt gecontroleerd door een strikte rekenmachine, zodat ze een eindeloze voorraad van 100% betrouwbare, leerzame en gevarieerde oefeningen kunnen creëren voor AI's die willen leren redeneren.

Each language version is independently generated for its own context, not a direct translation.

Titel: Infinite Problem Generator (IPG): Verifieerbaar Schalen van Natuurkunde-Redeneringsdata met Agentische Workflows

Auteurs: Aditya Sharan, Sriram Hebbale, Dhruv Kumar (BITS Pilani, India)

1. Het Probleem

Het trainen van Large Language Models (LLM's) voor complexe redeneringstaken wordt beperkt door het gebrek aan verifieerbare, hoogwaardige data.

Hallucinaties: Standaard tekstaugmentatie in domeinen zoals natuurkunde introduceert vaak hallucinaties (verzonnen feiten of formules).
Staticiteit: Bestaande benchmarks (zoals JEEBench of UGPhysics) zijn statisch en ontworpen voor evaluatie, niet voor training. Ze missen de noodzakelijke, uitvoerbare redeneringspaden (reasoning traces) om modellen effectief te fine-tunen.
Complexiteit: Natuurkundeproblemen vereisen het identificeren van impliciete constraints, het selecteren van de juiste wetten en het uitvoeren van precieze wiskundige redenering, wat oppervlakkige patroonherkenning doorbreekt.

Er is een urgente behoefte aan een schaalbaar systeem dat synthetische data genereert die zowel logisch consistent als wiskundig correct is.

2. Methodologie: De Infinite Problem Generator (IPG)

De auteurs introduceren IPG, een agentisch framework dat gebruikmaakt van een "Formula-as-Code" paradigma. In plaats van formules als teksttoken te behandelen, worden ze vertaald naar uitvoerbare Python-functies.

Het proces volgt een Generate-then-Verify workflow in drie fasen:

Fase I: Probleemanalyse en Contextuitbreiding

Input: Het systeem start met een "Seed Tuple" bestaande uit een expert-geschreven vraag en oplossing (uit standaardtextboeken).
Extractie: De agent identificeert de onderliggende natuurkundige principes en mapt deze naar een vooraf gedefinieerde "Chapter Dictionary" (hoofdstukken).
Executable Axioms: Formules worden niet als LaTeX-tekst opgeslagen, maar als Python-functies (bijv. kinematics.final_velocity(u, a, t)).
Constraints: Er wordt een "Variable Dictionary" gegenereerd met fysiek realistische bereiken (bijv. massa > 0, wrijvingscoëfficiënt tussen 0 en 1).

Fase II: Gecombineerde Probleemgeneratie

Narratieve Variatie: De agent genereert nieuwe scenario's (bijv. een katrol vervangen door een visrol) terwijl de onderliggende mechanica invariant blijft.
Gecombineerde Selectie: De agent selecteert 3 tot 5 uitvoerbare axioma's per probleem om multi-stap redenering te forceren.
Uniciteit: Elke gegenereerde vraag krijgt een "Problem Signature" (combinatie van gebruikte formules en de onbekende variabele) om duplicaten te detecteren en te verwerpen.

Fase III: Oplossing via Code-executie (Verificatie)

Program-of-Thought (PoT): Voor elke gegenereerde vraag moet de agent een Python-script schrijven dat de oplossing berekent.
Validatie: Het script wordt uitgevoerd in een zandbak-omgeving. Alleen problemen die voldoen aan drie criteria worden geaccepteerd:
1. Syntactische Validiteit: Geen runtime-fouten.
2. Numerieke Oplosbaarheid: Het resultaat is een eindig getal (geen NaN of Inf).
3. Fysieke Sanity: Resultaten voldoen aan basisfysica (bijv. tijd > 0).
Retries: Bij fouten krijgt de agent gestructureerde feedback om de code te corrigeren, wat hallucinaties effectief filtert.

3. Belangrijkste Bijdragen

Agentic Verificatie Framework (IPG): Een pipeline die narratieve variatie koppelt aan code-executie, wat wiskundige hallucinaties in synthetische natuurkundedata drastisch vermindert.
ClassicalMechanicsV1 Dataset: Een trainingsklaar corpus van 1.335 geverifieerde problemen in klassieke mechanica, geëxpandeerd vanuit slechts 165 expert-zaden (ongeveer 8x expansie per zaad).
Complexity Blueprint: Een kwantitatieve inzicht dat een sterke lineaire correlatie ( $R^2 \approx 0.95$ ) toont tussen het aantal gebruikte formules en de lengte van de oplossingscode. Dit stelt onderzoekers in staat om de moeilijkheidsgraad van problemen te controleren via code-lengte, zonder menselijke annotatie.

4. Resultaten en Analyse

Structuur en Diversiteit: Het dataset bevat problemen die variëren van 0 tot 6 formules, met een piek bij 3 formules (57,5% van het corpus). Dit dekt zowel conceptuele basisvragen als complexe, langdurige redeneringsketens.
Domeinmixing: De agent slaagt erin om concepten uit verschillende hoofdstukken te combineren (bijv. Wrijving + Rotatiebeweging), wat resulteert in een groter aantal unieke formules per hoofdstuk dan oorspronkelijk beschikbaar was in de bronnen.
Validatie: Slechts 2 van de 1.335 problemen in de finale set waren numeriek instabiel, wat de robuustheid van de "Generate-then-Verify" aanpak bevestigt.
Foutanalyse:
- Bij lage complexiteit (2-3 formules) is de validiteit >99%.
- Bij hoge complexiteit (4+ formules) verschuiven fouten naar "Signature Mismatches" (de agent leidt tussenwaarden correct af maar koppelt ze verkeerd aan het einddoel), wat een bekende beperking van huidige LLM's in lange contexten blootlegt.
Downstream Evaluatie: Een test met Qwen3-14B toonde aan dat het model op de gegenereerde dataset (34,96% nauwkeurigheid) slechter scoorde dan op JEEBench (47,97%). Dit suggereert dat de gegenereerde problemen de "long-horizon" redeneringseisen van echte examens succesvol nabootsen en niet "te gamen" zijn via meerkeuze-strategieën.

5. Betekenis en Toekomstperspectief

Deze studie is significant omdat het een brug slaat tussen de schaarste aan hoogwaardige trainingsdata en de behoefte aan verifieerbare redenering in wetenschappelijke domeinen.

Proxy-vrije Moeilijkheidsgraad: De "Complexity Blueprint" biedt een nieuwe methode om curriculum-gebaseerde datasets te bouwen waarbij de moeilijkheidsgraad objectief wordt gestuurd via code-structuur.
Reproduceerbaarheid: Door het openbaren van de volledige pipeline, de dataset en de evaluatierapporten, wordt reproduceerbaar onderzoek in reasoning-intensive domeinen mogelijk gemaakt.
Toekomst: De auteurs plannen uitbreiding naar andere domeinen (elektromagnetisme, optica), integratie van multimodale output (diagrammen genereren) en het gebruik van formele constraint-solvers (zoals Z3) voor nog strengere fysieke validatie.

Kortom, IPG demonstreert dat het combineren van agentische workflows met uitvoerbare code een krachtige route is om schaalbare, foutvrije en educatief waardevolle synthetische data te genereren voor complexe redeneringstaken.