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

O artigo apresenta o framework Code2Math, que utiliza agentes de código para evoluir autonomamente problemas matemáticos existentes em variações mais complexas e solucionáveis, abordando a escassez de desafios de alta qualidade para o treinamento e avaliação de modelos de linguagem.

O essencial

Imagine que você é um professor de matemática muito exigente. Você quer treinar seus alunos (que são, na verdade, supercomputadores chamados "Inteligências Artificiais") para resolver problemas de nível olímpico. O problema é: os livros didáticos estão ficando sem exercícios difíceis o suficiente. Criar novos problemas manualmente é lento, chato e exige gênios humanos.

Aí, os autores deste artigo tiveram uma ideia brilhante: "E se a própria IA pudesse criar os próximos exercícios mais difíceis?"

Eles chamaram esse projeto de Code2Math. Aqui está a explicação simples de como eles fizeram isso, usando analogias do dia a dia:

1. O Grande Desafio: A Escassez de "Desafios"

Até hoje, as IAs ficaram muito boas em matemática, quase como um medalhista olímpico. Mas para elas evoluírem ainda mais, elas precisam de problemas que elas mesmas não consigam resolver facilmente. Criar esses problemas manualmente é como tentar escrever um livro de quebra-cabeças novo todos os dias; é exaustivo.

2. A Solução: Uma Fábrica de Problemas com "Mestres" e "Juízes"

Os pesquisadores criaram um sistema com três agentes (robôs) que trabalham juntos, como uma equipe de produção de TV:

• O Criador (Agente de Evolução): Este é o "chef de cozinha". Ele pega um problema simples (digamos, uma receita de bolo básica) e tenta transformá-lo em algo complexo (um bolo de casamento de 10 andares).
  • O Truque: Ele não apenas muda os números. Ele usa código de computador (Python) como uma "tábua de rascunho". Ele roda simulações, testa milhares de combinações e verifica se a nova receita funciona antes de apresentá-la. Ele tenta esconder a "pista principal" para que o aluno tenha que ter um momento de "Eureka!" para resolver.
• O Fiscal de Qualidade (Agente de Verificação de Solvabilidade): Este é o "inspetor de obras". Ele pega a nova receita do Criador e diz: "Espere, essa parte não faz sentido matemático. Você não pode dividir por zero aqui". Se o problema tiver falhas lógicas, ele joga fora e pede para o Criador tentar de novo.
• O Crítico de Dificuldade (Agente de Verificação de Dificuldade): Este é o "treinador de atletas". Ele compara o problema original com o novo. Ele pergunta: "Isso é realmente mais difícil, ou você só aumentou o tamanho dos números para parecer difícil?" Se for apenas "trabalho braçal" (cálculo chato), ele reprova. Se for um desafio intelectual real, ele aprova.

3. A Magia do "Código"

A parte mais legal é que o Criador não apenas pensa; ele executa.
Imagine que você quer inventar um novo jogo de tabuleiro. Em vez de apenas imaginar, você constrói um protótipo rápido no computador, joga 1.000 vezes e vê se o jogo é justo.
No Code2Math, o agente escreve código para:

• Testar se uma sequência de números tem um padrão escondido.
• Verificar se um problema geométrico é possível de ser construído.
• Garantir que a resposta final exista antes de criar o problema.

Isso transforma a criação de problemas de "adivinhação" em "ciência experimental".

4. O Resultado: IAs Criando Desafios que Elas Mesmas Não Conseguem Resolver

O experimento foi um sucesso surpreendente:

• Qualidade: Os problemas criados eram matematicamente corretos (a maioria passou no teste dos juízes).
• Dificuldade Real: As IAs conseguiram criar problemas que eram mais difíceis do que elas mesmas conseguiam resolver. É como um aluno de ensino médio que, ao tentar criar um problema de física para o professor, acaba criando algo que o próprio professor demora para resolver.
• O Custo: Não foi fácil. Para criar um problema bom, o sistema precisou tentar muitas vezes (muitos "rascunhos" falhos) antes de acertar. Foi um processo de tentativa e erro intensivo.

5. Por que isso importa?

Este trabalho mostra que podemos usar IAs não apenas para resolver problemas, mas para expandir o conhecimento humano.

• Para a Ciência: Podemos gerar milhões de problemas de treinamento para tornar as IAs mais inteligentes.
• Para a Educação: Podemos criar bancos de questões infinitas e personalizadas para desafiar alunos em todo o mundo.
• Para a Matemática: Mostra que a "exploração computacional" (usar o computador para testar ideias) é uma ferramenta poderosa para descobrir novos padrões e desafios, assim como um matemático faria, mas em velocidade e escala muito maiores.

Resumo da Ópera:
O Code2Math é como uma fábrica de quebra-cabeças onde a máquina não apenas monta as peças, mas desenha novas peças, testa se elas encaixam e garante que o quebra-cabeça final seja tão difícil que até a própria máquina tenha que suar a camisa para resolvê-lo. É um passo gigante para o futuro da inteligência artificial e da educação.

Resumo técnico

Resumo Técnico: Code2Math

1. O Problema

Com o avanço dos Grandes Modelos de Linguagem (LLMs) em raciocínio matemático, atingindo níveis comparáveis à Olimpíada Internacional de Matemática (IMO), surgiu um gargalo crítico: a escassez de problemas desafiadores e de alta qualidade para treinamento e avaliação. A curadoria manual de novos problemas é lenta, cara e difícil de escalar. Além disso, muitos benchmarks atuais tornam-se obsoletos rapidamente à medida que os modelos melhoram. O artigo propõe investigar se agentes de código podem autonomamente evoluir problemas matemáticos existentes, transformando-os em variações mais complexas e estruturalmente distintas, utilizando ambientes computacionais executáveis para exploração e validação.

2. Metodologia

O trabalho introduz o Code2Math, um sistema multiagente projetado para a evolução automática de problemas matemáticos. A abordagem baseia-se no paradigma de scaling no tempo de teste (test-time scaling), onde o agente gera múltiplos rascunhos (rollouts) para satisfazer critérios rigorosos de validação.

O sistema é composto por três agentes especializados:

1. Agente de Evolução (Evolution Agent):

   • Função: Analisa um problema "semente" (original) e sua solução para identificar o "gargalo cognitivo" (o insight chave necessário para a solução).
   • Estratégia: Utiliza uma abordagem baseada na Teoria da Mente para antecipar como um solucionador experiente abordaria o problema. O agente deve deliberadamente ocultar insights ou criar novos obstáculos para aumentar a "Carga de Descoberta" (Burden of Discovery), forçando um momento de "Eureka" mais difícil.
   • Ferramenta: O agente escreve e executa código Python (usando bibliotecas como SymPy, NetworkX, itertools, Z3) para explorar espaços de parâmetros, verificar hipóteses, enumerar configurações válidas e validar a solvabilidade antes de formular o novo problema.

2. Agente de Verificação de Solvabilidade (Solvability Verification Agent):

   • Função: Garante que o problema gerado seja matematicamente válido e solúvel.
   • Mecanismo: Opera em duas fases:
     1. Detecção de erros superficiais (inconsistências de domínio, definições ilegais).
     2. Auditoria lógica profunda da solução proposta, utilizando execução de código para verificar cada passo da derivação. Se a cadeia lógica contiver falhas, o problema é rejeitado.

3. Agente de Verificação de Dificuldade (Difficulty Verification Agent):

   • Função: Avalia se o novo problema representa um aumento genuíno de dificuldade em relação ao original.
   • Critério: Distingue entre "Complexidade Artificial" (cálculos tediosos, repetição) e "Profundidade Cognitiva" (novos insights, quebra de heurísticas padrão).
   • Avaliação: Utiliza uma escala de 1 a 5. Problemas que apenas aumentam o volume de cálculo recebem pontuação baixa (1-2). Problemas que exigem novos insights estruturais e "anti-modelagem" (resistência a soluções por padrão) recebem pontuação alta (4-5).

Ambiente e Dados:

• Dados: 100 problemas semente coletados de fontes diversas (IMO, AIME, livros didáticos, competições regionais).
• Ambiente: Execução de código em um sandbox Python controlado (framework Smolagents).
• Processo: O sistema gera múltiplos rollouts (tentativas) até que um problema passe em ambas as verificações (solvabilidade e dificuldade).

3. Contribuições Principais

• Framework Multiagente para Evolução de Problemas: Propõe uma arquitetura que decompõe a tarefa de longo horizonte de adaptação de problemas em agentes especializados, permitindo exploração sistemática e validação rigorosa.
• Exploração Guiada por Código: Demonstra que a execução de código não é apenas para verificação, mas serve como o motor principal para a exploração estrutural, permitindo que os agentes descubram padrões ocultos e validem a solvabilidade de forma determinística.
• Assimetria de Capacidade: Evidência empírica de que os agentes podem sintetizar desafios que superam sua própria capacidade de resolução imediata (ou a de modelos de referência), criando problemas que modelos mais fortes não conseguem resolver facilmente.
• Novo Métrica de Dificuldade: Introduz o conceito de "Carga de Descoberta" (Burden of Discovery) como métrica central, focando na dificuldade de encontrar o insight inicial em vez da complexidade computacional bruta.

4. Resultados Experimentais

Os experimentos foram conduzidos utilizando vários LLMs (DeepSeek-Reasoner, DeepSeek-Chat, Gemini-3-Pro, Kimi-K2, Seed-2.0-Pro) como agentes de evolução e avaliados contra 6 modelos solucionadores diferentes.

• Taxa de Solvabilidade: O sistema gerou problemas com alta taxa de validade. O DeepSeek-Reasoner alcançou uma taxa de concordância de ~96% (94/98) com um juiz externo (GPT-5.2-High) quanto à solvabilidade.
• Aumento de Dificuldade:
  • Os problemas evoluídos resultaram em uma queda significativa nas taxas de acerto (Solve Rates) dos modelos solucionadores em comparação com os problemas originais.
  • Exemplo: O solucionador Gemini-3-Flash-Thinking viu sua taxa de acerto cair de 56% para 35% em problemas evoluídos pelo DeepSeek-Reasoner.
  • O consumo médio de tokens aumentou drasticamente (deslocamento para a direita na distribuição), indicando que os modelos precisaram de cadeias de raciocínio muito mais longas e complexas para resolver os problemas evoluídos.
• Eficiência e Custos:
  • O processo é computacionalmente intensivo. Em média, foram necessários de 1,56 a 6,55 falhas (rejeições) por problema bem-sucedido.
  • A maioria das falhas ocorreu na etapa de verificação de solvabilidade, indicando que garantir a consistência lógica é o principal gargalo, mais do que a verificação de dificuldade.
• Qualidade dos Problemas: Estudos de caso mostram que o sistema consegue transformar problemas de prova de desigualdade simples em caracterizações extremas complexas, ou problemas de contagem em otimizações estruturais profundas, mantendo a coerência matemática.

5. Significado e Conclusão

O artigo Code2Math fornece evidências empíricas de que agentes orientados a código são um mecanismo viável e escalável para a síntese de dados de raciocínio matemático de alta dificuldade.

• Impacto na Pesquisa: O trabalho sugere que o futuro do treinamento de modelos de raciocínio não dependerá apenas de curadoria humana, mas de sistemas autônomos capazes de explorar espaços matemáticos e gerar benchmarks dinâmicos que evoluem junto com a capacidade dos modelos.
• Limitações e Futuro: O processo atual envolve um alto custo computacional e overhead iterativo. Trabalhos futuros devem focar em melhorar a eficiência dos rollouts, fortalecer as garantias de solvabilidade e explorar se essas estratégias exploratórias podem ser generalizadas para além do domínio matemático.

Em suma, o Code2Math demonstra que a combinação de raciocínio estruturado com ambientes executáveis permite a criação automática de um currículo matemático progressivamente mais desafiador, superando as limitações da geração puramente baseada em texto.