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

Questo lavoro introduce un framework multi-agente basato su codice che dimostra come gli agenti di intelligenza artificiale possano evolvere autonomamente problemi matematici esistenti in varianti più complesse e risolvibili, affrontando la scarsità di dati di addestramento di alto livello.

L'essenziale

Immagina di voler allenare un atleta per le Olimpiadi. Il problema è che i libri di esercizi esistenti sono finiti e, dopo un certo punto, diventano troppo facili. Per diventare un campione mondiale, l'atleta ha bisogno di problemi sempre più difficili, ma scrivere nuovi problemi matematici di alto livello è un lavoro da geni, richiede anni di studio e non si può fare in massa.

Code2Math è come un "fabbricante di sfide" automatico. È un sistema che usa l'intelligenza artificiale (in particolare modelli linguistici avanzati) non solo per risolvere i problemi, ma per crearne di nuovi, partendo da quelli vecchi e rendendoli molto più complessi.

Ecco come funziona, spiegato con delle metafore:

1. Il Cuore del Sistema: Un Team di Tre Specialisti

Invece di affidarsi a un singolo robot, il sistema usa un "squadra" di tre agenti digitali che lavorano insieme, un po' come una redazione di un giornale o una squadra di ingegneri:

• L'Architetto (Evolution Agent): È il creatore. Prende un problema matematico semplice (chiamato "seme") e dice: "Come posso rendere questo più difficile? Come posso nascondere la soluzione in modo che anche un genio ci metta tempo a trovarla?".
  • La magia: L'Architetto non indovina a caso. Usa il codice informatico come una lavagna digitale. Scrive programmi per simulare migliaia di scenari, testare numeri e vedere se le sue nuove idee funzionano davvero. È come se un architetto costruisse 1000 ponti virtuali per vedere quale regge il peso prima di disegnarne uno nuovo.
• Il Controllore di Qualità (Solvability Verification Agent): Questo è il "poliziotto". Il suo lavoro è assicurarsi che il nuovo problema non sia un errore. Se l'Architetto crea un problema che non ha soluzione o che è contraddittorio, il Controllore lo boccia immediatamente. Usa il codice per verificare che la logica regga, passo dopo passo.
• Il Giudice di Difficoltà (Difficulty Verification Agent): Questo è il "critico d'arte". Deve decidere se il nuovo problema è davvero più difficile o se è solo noioso (ad esempio, calcoli più lunghi ma con la stessa logica). Cerca quel momento "Eureka!" nascosto, quel passaggio intelligente che rende il problema affascinante e difficile. Se il problema è solo "pesante" ma non "intelligente", viene scartato.

2. Il Processo: Esplorazione e Codice

Il punto di forza di questo paper è l'uso del codice.
Immagina che l'Architetto sia un esploratore in una foresta oscura. Invece di camminare a caso, ha una torcia potente (il codice Python).

• Se vuole sapere se un certo numero di condizioni è possibile, scrive un piccolo programma che prova tutte le combinazioni in un secondo.
• Se vuole vedere un pattern nascosto, fa disegnare al computer una serie di numeri per trovare una regola che l'occhio umano non vedrebbe subito.

Questo permette al sistema di fare "esperimenti" matematici su larga scala, qualcosa che un umano farebbe fatica a fare manualmente.

3. Il Risultato: Problemi che ingannano anche le Intelligenze Artificiali

I ricercatori hanno provato questo sistema con diversi modelli di intelligenza artificiale. I risultati sono stati sorprendenti:

• Funziona davvero: Il sistema è riuscito a creare nuovi problemi che erano matematicamente corretti.
• Sono difficili: I nuovi problemi erano così complessi che le stesse intelligenze artificiali (che erano state usate per crearli) faticavano a risolverli! È come se un allenatore creasse un esercizio così difficile che nemmeno lui riesce a farlo, ma serve per spingere l'atleta oltre i suoi limiti.
• Costa fatica: Non è tutto rose e fiori. Per creare un solo problema perfetto, il sistema deve spesso fallire molte volte (a volte 6 o 7 tentativi per averne uno valido). È un processo costoso in termini di energia e tempo, ma ne vale la pena per la qualità.

In Sintesi

Code2Math ci dice che le macchine non devono solo imparare a risolvere i problemi che gli umani hanno scritto. Possono diventare esploratori che usano il codice per viaggiare nel mondo della matematica, trovare nuovi sentieri nascosti e creare sfide che spingono l'intelligenza (sia umana che artificiale) a evolversi.

È come avere un assistente che non ti dà solo le risposte, ma ti costruisce una palestra sempre più alta e complessa, costringendoti a saltare più in alto di quanto avresti mai pensato possibile.

Sommario tecnico

1. Il Problema e il Contesto

Con il rapido avanzamento delle capacità matematiche dei Large Language Models (LLM) verso livelli comparabili a quelli delle Olimpiadi Internazionali di Matematica (IMO), è emersa una criticità significativa: la scarsità di problemi matematici di alta qualità, sfidanti e diversificati necessari per l'addestramento e la valutazione.
La creazione manuale di tali problemi è un collo di bottiglia che richiede un'esperienza profonda e un notevole sforzo umano. Sebbene esistano metodi per generare dati, spesso mancano di complessità strutturale o di validazione rigorosa. Il paper si pone l'obiettivo di investigare se gli agenti di codice (code agents), capaci di ragionamento e di esecuzione di codice, possano autonomamente evolvere problemi matematici esistenti in varianti più complesse, utilizzando l'esecuzione del codice come ambiente scalabile per la sperimentazione matematica.

2. Metodologia: Il Framework Multi-Agente

Gli autori propongono un sistema multi-agente basato sull'esecuzione di codice e sulla scalabilità al momento del test (test-time scaling). Il processo è decomposto in tre fasi gestite da agenti distinti:

A. Agente di Evoluzione (Evolution Agent)

• Input: Un problema "seme" (seed problem) e la sua soluzione.
• Funzione: Analizza il collo di bottiglia cognitivo del problema originale e progetta un nuovo problema più difficile.
• Strategia: Utilizza il concetto di "Onere della Scoperta" (Burden of Discovery). L'agente deve anticipare il ragionamento di un solver esperto e nascondere strategicamente gli insight chiave, creando un momento "Aha!" (illuminazione) difficile da raggiungere.
• Strumenti: L'agente scrive ed esegue codice Python (usando librerie come SymPy, NetworkX, itertools, Z3) per esplorare spazi strutturali, verificare vincoli, generare controesempi e validare ipotesi empiricamente prima di formulare il nuovo problema.

B. Agente di Verifica della Solvibilità (Solvability Verification Agent)

• Funzione: Garantisce che il problema generato sia matematicamente valido e risolvibile.
• Processo:
  1. Controllo Statico: Verifica coerenza logica, domini validi e assenza di contraddizioni (es. divisioni per zero, vincoli incompatibili).
  2. Audit Logico: Esamina i passaggi della soluzione proposta dall'Agente di Evoluzione, utilizzando il codice per verificare calcoli e trasformazioni algebriche.
• Criterio di Rifiuto: Se la soluzione proposta contiene errori logici o il problema è intrinsecamente irrisolvibile, la generazione viene scartata.

C. Agente di Verifica della Difficoltà (Difficulty Verification Agent)

• Funzione: Valuta se il nuovo problema rappresenta un aumento genuino di difficoltà rispetto all'originale.
• Criteri: Distingue tra complessità artificiale (calcoli più lunghi, numeri più grandi) e profondità cognitiva (nuovi insight, rottura di template standard).
• Punteggio: Utilizza una scala da 1 a 5. I punteggi bassi (1-2) indicano fallimenti o aumenti di difficoltà superficiali. I punteggi alti (4-5) richiedono che il problema richieda un insight non banale ("Eureka") e che rompa gli schemi di soluzione standard.

D. Scalabilità al Momento del Test (Test-Time Scaling)

Il sistema sfrutta il paradigma della scalabilità al momento del test generando multiple "rollout" (tentativi) per ogni problema seme. L'agente di evoluzione ripete il processo di esplorazione e generazione fino a quando una variante non supera sia la verifica di solvibilità che quella di difficoltà. Questo approccio compensa l'incertezza iniziale con un'ampia esplorazione computazionale.

3. Contributi Chiave

1. Framework di Evoluzione Autonoma: Introduzione di un sistema multi-agente che combina ragionamento linguistico ed esecuzione di codice per la sintesi automatica di problemi matematici complessi.
2. Validazione Rigorosa: Implementazione di un doppio meccanismo di verifica (solvibilità e difficoltà) che garantisce la qualità matematica dei dati generati, superando i limiti dei metodi puramente basati su prompt.
3. Scoperta di Asimmetrie di Capacità: Dimostrazione che gli agenti possono generare problemi che superano le loro stesse capacità di risoluzione, creando un "Onere della Scoperta" che i modelli stessi non riescono a risolvere immediatamente.
4. Dataset e Risorse: Pubblicazione di un dataset di problemi evoluti e del codice sorgente per la comunità di ricerca.

4. Risultati Sperimentali

Gli esperimenti sono stati condotti su 100 problemi seme provenienti da fonti diverse (IMO, AIME, libri di testo) utilizzando modelli come DeepSeek-Reasoner, Gemini-3-Pro e Kimi-K2.

• Tasso di Solvibilità: Il framework ha dimostrato un'alta affidabilità. Ad esempio, quando DeepSeek-Reasoner agisce come agente di evoluzione, il tasso di accordo con un giudice esterno (GPT-5.2-High) sulla solvibilità è circa del 96% (94/98 casi).
• Aumento della Difficoltà: I problemi evoluti hanno causato un calo significativo nei tassi di risoluzione (Solve Rate) per i modelli solver.
  • Esempio: Per i problemi evoluti da DeepSeek-Reasoner, il tasso di risoluzione di GPT-5.2-High è sceso dal 70% al 64% (-6 punti), mentre per modelli open-source come Qwen3 il calo è stato più marcato in termini assoluti su baseline diverse.
  • Questo conferma che i nuovi problemi non sono semplici parafrasi, ma richiedono nuovi insight strutturali.
• Efficienza e Costi: Il processo è computazionalmente intensivo. In media, sono necessari 1.56 - 6.55 fallimenti (rollout non riusciti) per ottenere un problema valido. La maggior parte dei fallimenti deriva dalla verifica di solvibilità, indicando che garantire la coerenza logica è il collo di bottiglia principale.
• Consumo di Token: I problemi evoluti richiedono un consumo di token significativamente maggiore (spesso con una "coda grassa" di casi che richiedono migliaia di token in più), indicando un maggiore sforzo di ragionamento e un allontanamento dalle soluzioni euristiche rapide.

5. Significato e Implicazioni

Il lavoro di Code2Math dimostra che l'esplorazione guidata dal codice è un meccanismo vitale per la sintesi di dati matematici ad alta difficoltà.

• Superamento dei Limiti Umani: Fornisce una via scalabile per generare dati di addestramento che altrimenti richiederebbero anni di lavoro manuale da parte di esperti.
• Nuovo Paradigma di Valutazione: I problemi generati agiscono come benchmark più discriminanti, esponendo le fragilità nel ragionamento strutturale dei modelli LLM anche quando questi performano bene su dataset standard.
• Futuro della Ricerca: Suggerisce che l'integrazione di ambienti eseguibili nei processi di reasoning degli agenti è fondamentale per l'auto-miglioramento e la scalabilità delle capacità di ragionamento complesso, aprendo la strada a sistemi che possono "scoprire" nuove aree di difficoltà matematica in modo autonomo.

In sintesi, Code2Math non si limita a generare problemi, ma crea un ciclo di feedback in cui gli agenti esplorano, validano e raffinano la complessità matematica, fornendo una prova empirica che l'automazione può espandere i confini della ricerca matematica e dell'addestramento AI.