evolutionary-data-synthesis

name	evolutionary-data-synthesis
title	EvoSyn: Generalizable Evolutionary Data Synthesis for Verifiable Learning
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.17928
keywords	["synthetic data","evolutionary algorithms","verifiable learning","task-agnostic","data synthesis"]
description	Generate verifiable synthetic training data (problems + solutions + verification artifacts) through evolutionary synthesis that works across math, code, and agent tasks without task-specific rules.

Technique: Evolutionary Data Synthesis — Task-Agnostic Verifiable Data Generation

Creating high-quality synthetic training data requires either expensive human annotation or task-specific generation rules (code templates, math problem schemas). EvoSyn solves this through evolutionary data synthesis: jointly evolve problems, diverse solutions, and verification artifacts that can be checked automatically.

The key insight is that verification enables learning without perfection. By generating problems where correctness can be automatically verified, the model learns from diverse high-quality solutions without human labels. The evolutionary approach generalizes across domains (math, code, agents) without task-specific engineering.

Core Concept

EvoSyn operates on four principles:

• Multi-Component Generation: Simultaneously evolve problems, candidate solutions, and verification checks
• Consistency-Based Evaluation: Solutions must pass both human-annotated and strategy-induced checks
• Iterative Discovery: Refine what counts as "verifiable" across multiple domains
• Task-Agnostic: Single pipeline works for math, coding, agent tasks without customization

The result is stable RL training with automatic verification and effective distillation across diverse problem types.

Architecture Overview

• Problem Generator: Create diverse problems in target domain
• Solution Synthesizer: Generate multiple candidate solutions
• Verification Artifact Composer: Create checkers (math: equations, code: tests, agents: assertions)
• Consistency Evaluator: Cross-check human and strategy-based verification
• Evolutionary Loop: Mutate and recombine successful (problem, solutions, checkers) tuples
• Quality Filter: Keep only high-confidence verified examples

Implementation Steps

The core algorithm evolves problem-solution-verifier tuples jointly. This example shows the synthesis pipeline.

from typing import List, Dict, Tuple
import random

class EvolutionarySynthesis:
    """
    Task-agnostic evolutionary synthesis of verifiable training data.
    """

     ():
        .generator = generator_model
        .executor = executor
        .max_generations = max_generations
        .population = []  

     () -> :
        
        prompt = 
        problem = .generator.generate(prompt, max_tokens=)
         problem

     () -> []:
        
        solutions = []

         variant_idx  (num_variants):
            prompt = 
            solution = .generator.generate(prompt, max_tokens=)
            solutions.append(solution)

         solutions

     () -> :
        
        prompt = 
        artifact_text = .generator.generate(prompt, max_tokens=)

        
        verifier = {
            : extract_test_cases(artifact_text),
            : extract_expected_outputs(artifact_text),
            : extract_edge_cases(artifact_text)
        }

         verifier

     () -> [, ]:
        
        consistency_score = 
        num_passed = 

         solution  solutions:
            :
                
                outputs = .executor.run(solution, verifier[])

                
                all_correct = (
                    out == expected
                     out, expected  (
                        outputs, verifier[]
                    )
                )

                 all_correct:
                    num_passed += 

             Exception  e:
                
                

        consistency_score = num_passed / (solutions)  solutions  
        failure_reason =   consistency_score <   

         consistency_score, failure_reason

     () -> []:
        
        
        ranked = (
            .population,
            key= x: x[],
            reverse=
        )
        survivors = ranked[:(ranked) // ]  

        
        new_population = []
         example  survivors:
            
            mutated_problem = .generator.generate(
                ,
                max_tokens=
            )

            
            new_solutions = .synthesize_solutions(mutated_problem, num_variants=)

            
            new_verifier = .create_verification_artifact(
                mutated_problem, new_solutions
            )

            
            consistency, reason = .evaluate_consistency(
                mutated_problem, new_solutions, new_verifier
            )

             consistency >= :  
                new_population.append({
                    : mutated_problem,
                    : new_solutions,
                    : new_verifier,
                    : consistency
                })

        .population.extend(new_population)
         .population

     () -> []:
        
        
         _  ((, num_examples // )):
            problem = .generate_problem()
            solutions = .synthesize_solutions(problem)
            verifier = .create_verification_artifact(problem, solutions)
            consistency, _ = .evaluate_consistency(problem, solutions, verifier)

             consistency >= :
                .population.append({
                    : problem,
                    : solutions,
                    : verifier,
                    : consistency
                })

        
         generation  (.max_generations):
            .evolve_population(generation)

            
            high_quality = [
                ex  ex  .population
                 ex[] >= consistency_threshold
            ]

             (high_quality) >= num_examples:
                ()
                 high_quality[:num_examples]

            (
                  )

         .population


 ():
    
    optimizer = torch.optim.Adam(model.parameters(), lr=)

     epoch  (num_epochs):
        epoch_loss = 

         example  synthesized_examples:
            problem = example[]
            solutions = example[]
            verifier = example[]

            
             solution  solutions:
                prompt = 
                target = solution

                
                output = model.generate(prompt)
                loss = compute_loss(output, target)

                optimizer.zero_grad()
                loss.backward()
                optimizer.step()

                epoch_loss += loss.item()

        avg_loss = epoch_loss / ((synthesized_examples) * )
        ()

     model