Combinatorial Synthesis: Scaling Code RLVR via Atomic Decomposition and Recombination

Breaking the Logic Barrier: Scaling AI Coding Ability via Atomic Synthesis

Training AI to code is notoriously difficult. Models require highly challenging and unique practice problems to truly improve. Instead of just rewriting old problems, a new research paper proposes breaking coding tasks into tiny, fundamental building blocks. These blocks are mixed in new ways to create entirely original, complex puzzles. This shift from simple imitation to combinatorial construction aims to overcome a critical bottleneck in teaching machines to reason.

The Bottleneck of Imitation

The core problem facing modern AI development in programming is not a lack of data. The issue is a lack of useful data. While the internet provides trillions of lines of code, much of it is repetitive. To teach an AI to reason through complex logic, researchers use Reinforcement Learning with Verifiable Rewards (RLVR). In this setup, the model generates code. The system then checks if it works by running it against deterministic unit tests (automated scripts that confirm if code behaves correctly).

However, the effectiveness of RLVR depends on the difficulty of the exam. If the problems are too easy, the model stops learning. If they are too hard, it cannot find a starting point. Current methods for creating new problems usually rely on "heuristic expansion." This involves taking an existing problem and slightly tweaking the wording or changing a few numbers. The authors argue this approach is fundamentally limited. Because these methods preserve the original logical structure of the "seed" problems, they fail to generate novel logical topologies (the underlying maps of how a problem is solved).

The Prerequisites of Verifiable Reasoning

To understand the proposed solution, one must first grasp the mechanics of RLVR. In standard supervised learning, a model memorizes relationships between questions and answers. In RLVR, the model is instead told to try solving a problem. If the code passes the tests, the model receives a reward. This creates a strong incentive for the model to develop actual reasoning capabilities rather than just pattern matching.

The difficulty lies in the "verifiability" requirement. For a task to be suitable for RLVR, it must have a ground truth that can be checked automatically. This is easy for mathematics or basic algorithms. It becomes harder as tasks move into specialized domains like data science or complex tool usage. Existing synthetic data methods, such as KodCode or Educational Instruct, attempt to fill this gap. However, they often struggle to escape the shadow of their original training data. This results in "premature reward saturation," where the model's progress plateaus because the training material offers no new challenges.

From Seeds to Atoms: The ADR Framework

The researchers propose a departure from imitation through a framework called Atomic Decomposition and Recombination (ADR). Instead of treating a coding problem as a monolithic block of text, ADR treats it as a composition of discrete, logical primitives. The process follows five distinct stages, as outlined in .

To assist in this process, the researchers used DeepSeek-V3.2 for the synthesis of new tasks.

First, the framework performs Element Extraction. It takes a small set of high-quality "seed" tasks. It then breaks them down into a schema of atomic elements. These include the core algorithm idea, the story background, and input/output constraints. To ensure this schema is useful, the authors use "Info-Guided Element Schema Optimization" (ESO). This utilizes information-theoretic signals. It uses entropy ($H$) to ensure the elements are diverse. It also uses Conditional Mutual Information (CMI) to measure how much new logical information an element adds to a problem.

Once the "atoms" are defined, the framework enters Controlled Recombination. Instead of random mixing, the system selects a "core element" and recombines it with others. This ensures the resulting task is semantically coherent. These combinations are then turned into full problems via Template-Based Synthesis. This ensures the output follows a professional, unambiguous format.

The fourth stage, Execution-Grounded Validation, acts as a quality filter. Every synthesized problem is paired with a generated solution and a test case generator. Only if the solution successfully passes the generated tests is the task considered valid. Finally, the framework employs Adversarial Solution Space Refinement (ASSR). In this stage, the system intentionally generates "near-miss" solutions. These are code snippets that look correct but contain subtle bugs. The test generator is then forced to evolve until it can successfully catch these flawed solutions. This significantly increases the rigor of the final dataset.

Expanding the Capability Frontier

The impact of this combinatorial approach is visible in how it changes the training dynamics of Large Language Models. By providing a stream of genuinely new logical challenges, ADR prevents the model from settling into local optima (mathematical "ruts" where a model thinks it has mastered a topic).

The authors demonstrate this through several key findings. First, the ADR-synthesized data shows vastly superior originality and difficulty compared to previous baselines. In a t-SNE visualization of data density, ADR occupies a much broader manifold.

It explores the "long-tail" regions of logical complexity that heuristic methods miss.

Second, the training results are transformative. When training the Qwen2.5-Coder-7B model on the LiveCodeBench (LCB-v5) benchmark, ADR achieved a 25.37% pass rate. This outperformed the best baseline of 22.75%. More importantly, the authors highlight the difference in "capability frontier expansion." While prior methods only yielded a 0.60% improvement in Pass@8 (the probability of finding a correct solution in 8 attempts), ADR delivered a 4.79% improvement .

This means the model is actually learning more complex reasoning rather than just getting lucky.

Finally, the training stability is markedly different. As shown in, while baseline models experience decaying gradients and stagnant learning, the ADR-trained models maintain stable gradient norms.

They also show higher KL divergence (a measure of how much the model's behavior evolves away from its starting point). This indicates that the model is undergoing substantive behavioral evolution rather than just fine-tuning its existing knowledge.

Limits of the Atomic Approach

Despite its success, the ADR framework is not a universal solvent for AI training. The authors note that the current evaluation is limited to specific benchmarks and certain model scales. It remains to be seen how the framework performs when scaled to massive foundation models. It also remains untested in multilingual environments where logical elements might be expressed differently.

Furthermore, the framework is currently optimized for single-turn code generation. This refers to scenarios where a user asks a question and gets one answer. Moving toward "code agent" scenarios will require a significant extension. These agents must engage in multi-turn, autonomous software engineering and interact with complex, evolving environments.