Code2Math: Can Your Code Agent Effectively Evolve Math Problems Through Exploration?

Dit paper introduceert een multi-agent framework dat code-gebaseerde agents gebruikt om bestaande wiskundeproblemen autonoom te evolueren naar complexere, oplosbare varianten, waarmee een schaalbare oplossing wordt geboden voor het tekort aan uitdagende trainingsdata voor geavanceerde wiskundige redenering.

De kern

Stel je voor dat wiskundige problemen zoals trucs voor een goochelaar zijn. Om een goochelaar (in dit geval een kunstmatige intelligentie) echt slim te maken, moet je hem niet alleen de oude trucs laten oefenen, maar hem ook nieuwe, nog mysterieuzere trucs leren.

Het probleem is: er zijn maar weinig nieuwe, moeilijke trucs beschikbaar. Mensen moeten die zelf verzinnen, wat veel tijd kost en waarvoor je een genie nodig hebt.

Deze paper, getiteld "Code2Math", introduceert een slimme oplossing: laat de computer zelf de nieuwe trucs verzinnen.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Drie-Hoofdjes-Team (Het Multi-Agent Systeem)

In plaats van één robot die alles probeert te doen, hebben de onderzoekers een klein team van drie digitale experts samengesteld, die samenwerken als een productiebedrijf voor wiskundepuzzels:

• De Uitvinder (Evolution Agent):
  Deze robot kijkt naar een bestaande puzzel (bijvoorbeeld: "Hoeveel appels heb je nodig?"). Hij denkt na: "Wat maakt deze vraag lastig? Hoe kan ik hem lastiger maken zonder dat hij onmogelijk wordt?"
  Hij gebruikt Python-code als zijn schetsblok. Hij tikt snel programmaatjes in om duizenden getallen te testen, patronen te zoeken en te zien wat er gebeurt als hij de regels een beetje verschuift. Hij probeert een nieuwe, mysterieuze puzzel te bouwen die een "Aha-moment" vereist.

• De Kwaliteitscontroleur (Solvability Verification Agent):
  Deze robot is de strenge keurmeester. Hij kijkt naar de nieuwe puzzel en de oplossing die de Uitvinder bedacht. Hij vraagt zich af: "Is dit wel een echte puzzel? Is de oplossing logisch? Of heb ik net een onzinverhaal bedacht?"
  Hij gebruikt ook code om de wiskunde stap voor stap na te rekenen. Als er een foutje in zit, gooit hij de puzzel in de prullenbak.

• De Moeilijkheidsmeter (Difficulty Verification Agent):
  Deze robot is de ervaren trainer. Hij vergelijkt de oude puzzel met de nieuwe. Hij vraagt zich af: "Is dit echt moeilijker, of is het gewoon saai rekenwerk?"
  Hij zoekt naar inzichten. Een goede nieuwe puzzel moet niet alleen meer rekenen vereisen, maar de speler dwingen om op een heel nieuwe manier te denken. Als de nieuwe puzzel alleen maar meer cijfers heeft, is hij een "2" (mislukt). Als hij een echt nieuw inzicht vereist, is hij een "5" (perfect).

2. De "Testtijd" Expeditie

Stel je voor dat je een puzzel oplost, maar je mag niet stoppen tot je het echt snapt.
De onderzoekers laten de robots vele keren proberen (dit noemen ze "rollouts").

• Probeer 1: De Uitvinder maakt een fout. De Kwaliteitscontroleur gooit het weg.
• Probeer 2: De Uitvinder maakt een ander voorstel. De Moeilijkheidsmeter zegt: "Nog te makkelijk."
• Probeer 10: Eindelijk! De robots hebben een puzzel gevonden die logisch klopt én super lastig is.

Dit kost veel rekenkracht (zoals het proberen van honderden sleutels bij een deur), maar het levert een sleutel op die niemand eerder had.

3. Wat hebben ze ontdekt?

De resultaten zijn verrassend:

• De computer kan creatiever zijn dan zijn eigen brein: De robots konden puzzels maken die zelfs de slimste bestaande AI-modellen niet konden oplossen. Het is alsof een leerling een examen maakt dat zelfs de leraar niet kan oplossen.
• Code is de sleutel: Zonder de mogelijkheid om code te draaien (om snel te testen of iets werkt), zouden de robots vastlopen in hun eigen gedachten. De code fungeert als een "proeflab".
• Het is zwaar werk: Het kost veel tijd en rekenkracht om één goede, moeilijke puzzel te maken. Soms moeten ze 6 keer proberen voordat ze er één vinden die goed is. Maar de kwaliteit is er de moeite waard.

Samenvattend

Deze paper laat zien dat we niet langer alleen hoeven te wachten op mensen om nieuwe, moeilijke wiskundepuzzels te bedenken. We kunnen een digitale fabriek opzetten die:

1. Bestaande puzzels neemt.
2. Ze in een code-lab uitprobeert en herschrijft.
3. Ze streng controleert op fouten.
4. Ze teruggeeft als nieuwe, super-moeilijke uitdagingen.

Dit helpt ons om de "slimste" computers van de wereld nog slimmer te maken, door ze te laten oefenen met puzzels die net buiten hun bereik liggen. Het is een stap in de richting van computers die niet alleen antwoorden geven, maar ook de vragen stellen die de wereld vooruit helpen.

Technische samenvatting

Titel: Code2Math: Kan uw Code Agent Wiskundige Problemen Effectief Evolueren door Exploratie?

1. Probleemstelling en Achtergrond

Hoewel grote taalmodellen (LLMs) aanzienlijke vooruitgang hebben geboekt in wiskundig redeneren en nu prestaties op het niveau van de Internationale Wiskunde Olympiade (IMO) bereiken, vormt de schaarste aan uitdagende, hoogwaardige problemen een kritieke bottleneck voor verdere training en evaluatie. Het handmatig creëren van dergelijke problemen vereist diepgaande expertise en is niet schaalbaar.

Bestaande methoden voor het genereren van wiskundige data vertrouwen vaak op eenvoudige perturbaties of menselijke curatie, wat leidt tot oppervlakkige variaties die geen echte cognitieve uitdaging bieden. De auteurs onderzoeken of code-agents (LLMs die code kunnen schrijven en uitvoeren) in staat zijn om bestaande wiskundige problemen autonoom te evolueren naar complexere varianten. Het centrale idee is dat wiskundige ontdekking vaak een exploratief proces is (hypothese-testen, zoeken naar tegenvoorbeelden) dat perfect past bij de capaciteiten van code-agents die toegang hebben tot uitvoerbare omgevingen.

2. Methodologie

De auteurs introduceren een multi-agent framework dat is ontworpen om problemen te evolueren, de oplosbaarheid te valideren en de moeilijkheidsgraad te beoordelen. Het systeem werkt volgens het paradigma van "test-time scaling", waarbij meerdere pogingen (rollouts) worden gedaan om aan strikte criteria te voldoen.

Het framework bestaat uit drie gespecialiseerde agenten:

1. Evolution Agent (Evolutie-Agent):

   • Doel: Analyseert een "seed problem" (oorspronkelijk probleem) en zijn oplossing om de cognitieve bottleneck te identificeren.
   • Aanpak: De agent moet de "Last van Ontdekking" (Burden of Discovery) verhogen. Dit betekent dat de agent moet anticiperen op de redeneerpaden van een ervaren solver en strategisch nieuwe inzichten ("Aha-momenten") moet verbergen of de ingangspunten moet verduisteren.
   • Hulpmiddelen: De agent gebruikt Python-code (met bibliotheken zoals SymPy, NetworkX, Z3, itertools) voor empirische exploratie, het testen van numerieke grenzen, het genereren van tegenvoorbeelden en het valideren van structurele eigenschappen voordat het een nieuw probleem formuleert.

2. Solvability Verification Agent (Oplosbaarheidsverificatie-Agent):

   • Doel: Garandeert dat het gegenereerde probleem wiskundig correct en oplosbaar is.
   • Aanpak: Werkt in twee fasen:
     • Fase 1: Detectie van oppervlakkige fouten (bijv. domeinfouten, tegenstrijdige constraints).
     • Fase 2: Kritische audit van de voorgestelde oplossing. De agent controleert of de logische keten foutloos is. Als de oplossing logische fouten bevat, wordt het probleem verworpen, zelfs als het intrinsiek oplosbaar zou kunnen zijn. Dit dient als proxy voor oplosbaarheid.

3. Difficulty Verification Agent (Moeilijkheidsverificatie-Agent):

   • Doel: Beoordeelt of het nieuwe probleem een echte toename in moeilijkheid vertegenwoordigt ten opzichte van het origineel.
   • Beoordelingscriterium: Het onderscheidt tussen "Artificiële Complexiteit" (meer rekenwerk, grotere getallen) en "Cognitieve Diepte" (nieuwe inzichten, breken van standaard templates).
   • Score: Een 5-puntsschaal wordt gebruikt. Scores 1-2 (faal) duiden op oppervlakkige veranderingen. Scores 3-5 (slagen) vereisen dat het probleem standaard heuristieken onbruikbaar maakt en een diep inzicht vereist.

Data: Het systeem werd getest op 100 seed-problemen uit diverse bronnen (leerboeken, regionale wedstrijden, IMO, AIME).

3. Belangrijkste Bijdragen

• Nieuw Framework: Een multi-agent systeem dat probleemadaptatie decomposeert in gespecialiseerde rollen (evolutie, verificatie, moeilijkheidsbeoordeling), waarbij code-executie centraal staat voor structurele exploratie.
• Empirisch Bewijs: Het paper levert bewijs dat code-gedreven agents in staat zijn om wiskundig valide problemen te synthetiseren die structureel verschillend zijn en aanzienlijk moeilijker dan de originele problemen.
• Capaciteitsasymmetrie: De studie toont aan dat modellen problemen kunnen genereren die moeilijker zijn dan ze zelf kunnen oplossen. Agents kunnen een "Last van Ontdekking" creëren die buiten hun directe redeneercapaciteit valt.
• Open Data: De gegenereerde dataset en de code zijn openbaar beschikbaar.

4. Resultaten

De experimenten werden uitgevoerd met verschillende modellen (DeepSeek-Chat, DeepSeek-Reasoner, Gemini-3-Pro, Kimi-K2, Seed-2.0-Pro) als evolutie-agenten en geëvalueerd door zes verschillende solver-modellen.

• Oplosbaarheid: Het framework behaalde een hoge mate van betrouwbaarheid. De Agreement Rate (AR) tussen de interne verificatie-agent en een externe, state-of-the-art judge (GPT-5.2-High) was zeer hoog (bijv. 96% voor DeepSeek-Reasoner). Dit bevestigt dat de gegenereerde problemen wiskundig sound zijn.
• Toename van Moeilijkheid: Er was een duidelijke daling in de oplosbaarheid (Solve Rate) voor de gegenereerde problemen vergeleken met de originele set.
  • Voorbeeld: De oplosbaarheid van het model Gemini-3-Flash-Thinking daalde van 56% naar 35% op problemen gegenereerd door DeepSeek-Reasoner.
  • Zelfs de sterkste modellen (zoals GPT-5.2-High) lieten een daling zien (van 70% naar 64%), wat aantoont dat de problemen niet alleen "harder" zijn door meer rekenwerk, maar door fundamenteel complexere inzichten.
• Token-gebruik: De gegenereerde problemen vereisten aanzienlijk meer tokens (redeneringslengte) om op te lossen. De verdeling van token-verbruik verschuift naar rechts, wat aangeeft dat modellen gedwongen worden om uitgebreidere zoektochten en hypothese-testen uit te voeren in plaats van standaard patronen te volgen.
• Efficiëntie en Kosten: Het proces is rekenintensief. Gemiddeld zijn er 1,56 tot 6,55 mislukte pogingen nodig per succesvolle evolutie. De meeste fouten ontstaan bij de verificatie van oplosbaarheid, wat aangeeft dat het garanderen van een logisch consistente oplossing de grootste uitdaging blijft.

5. Betekenis en Conclusie

Code2Math demonstreert dat uitvoerbare exploratie een levensvatbare route is voor het autonoom schalen van de moeilijkheidsgraad in gestructureerde redeneringsdomeinen.

• Schalbaarheid: Het biedt een mechanisme om een continue stroom van hoogwaardige, uitdagende trainingsdata te genereren, wat essentieel is voor de volgende generatie wiskundige AI-modellen.
• Kwaliteit van Data: In tegenstelling tot eerdere methoden die vaak leiden tot "tedious" (vervelend) maar niet cognitief uitdagende problemen, forceert dit framework agents om diepere structurele veranderingen door te voeren.
• Toekomstperspectief: Hoewel er nog een afweging bestaat tussen rekenkosten en moeilijkheidsverhoging, suggereert dit werk dat code-agents niet alleen problemen kunnen oplossen, maar ook actief kunnen bijdragen aan de vooruitgang van het wiskundige onderzoeksveld door het synthetiseren van nieuwe, complexe vraagstukken.

Kortom, Code2Math bewijst dat agents, ondersteund door code-executie, in staat zijn om de grenzen van wiskundige redenering te verleggen door zelfstandig nieuwe, moeilijkere problemen te ontwerpen die de huidige staat van de kunst uitdagen.