Scaling Formal Reasoning Through Synthetic Data Generation

120 concepts87 papers1 proposal

Deep learning has flourished on the abundance of natural language found on the web, but formal reasoning—the ability to write machine-verifiable proofs in languages like Lean, Coq, or Isabelle—faces a severe "data drought." While billions of tokens of informal mathematics exist in textbooks and papers, the specialized code required for formal verification is orders of magnitude scarcer. As Wang et al. note, formalizing mathematics is labor-intensive, requiring experts who are proficient in both high-level logic and low-level proof assistant syntax.

To overcome this bottleneck, researchers are moving away from human-curated datasets toward systems that can synthesize, mutate, and verify their own training data.

The Autoformalization Bridge

The most direct way to address scarcity is to translate the vast existing corpus of informal mathematics into formal code, a process known as autoformalization. However, this task is itself data-starved; training a translator requires parallel corpora of informal-formal pairs.

To bootstrap this process, researchers have developed iterative pipelines. Ying et al. and the authors of Lean Workbook created a massive dataset of 57,000 problems by using compiler feedback and back-translation to ensure quality. Similarly, Liu et al. introduced the ATLAS framework, which "lifts" concepts from existing libraries and uses logical transformations to synthesize 117,000 new statements. The intuition here is that the strictness of the formal compiler acts as a filter: if a model generates a translation that type-checks, it is likely a valid piece of reasoning, even if the model was not explicitly trained on that specific problem before.

Amplification via Mutation and Evolution

If a small seed of formal data exists, it can be expanded through symbolic manipulation. Rather than asking a model to invent new math from scratch, frameworks like Alchemy amplify existing libraries. The authors of Alchemy systematically replace terms in known theorems with logical equivalents or antecedents, expanding the standard Lean library from 110,000 to over 6 million verified theorems.

A complementary approach is EvolProver, where Tian et al. evolve existing problems across different domains and difficulty levels. By varying the complexity of the premises or the target goal, the system creates a diverse curriculum that prevents models from simply memorizing proof patterns. This diversity is crucial; Jiang and Li found that training on multiple formal languages simultaneously (cross-pollination) significantly improves a model's ability to generalize, as it learns the underlying logical structure rather than language-specific boilerplate.

Perhaps the most powerful solution to data scarcity is eliminating the need for human examples entirely through reinforcement learning (RL). In this paradigm, the "data" is generated by the agent's own exploration of the proof space.

Hubert et al. demonstrated this with AlphaProof, which trained on millions of auto-formalized statements to reach silver-medal status on International Mathematical Olympiad problems. The system uses a "Test-Time RL" strategy, where the model adapts to new problems by searching for verifiable proof paths. Similarly, Dong et al. proposed STP, a self-play framework where the model acts as both a "conjecturer" (creating new problems) and a "prover" (solving them).

This self-improvement loop works because formal logic provides a ground truth that natural language lacks. As Laurent and Platzer argue, by co-training a teacher to generate problems and a solver to crack them, the system creates its own learning gradient. Even unsuccessful proof attempts can be repurposed; Eser Aygün showed that by treating failed attempts as successful proofs of intermediate subgoals (Hindsight Experience Replay), models can learn complex logic even when the final goal remains out of reach.

Neuro-Symbolic Synergy

Finally, researchers are addressing the data bottleneck by delegating different parts of the reasoning process to specialized components. Li et al. and the authors of LIPS use Large Language Models for creative "rewriting" while relying on symbolic solvers for rigorous "scaling." By using symbolic math to generate a "proof sketch" and an LLM to fill in the technical details, as seen in the WZ-LLM framework by Xiong et al., the system reduces the amount of formal training data required to achieve high performance in specialized domains like combinatorics.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 91 papers
  2. Version 1 · 2026-10-04 · 52 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_formal_data_scarcity_0dc4bebb,
  title = {formal data scarcity},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-data-scarcity/rdr_0dc4bebbaeb945eab3c6581303753497},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_formal_data_scarcity_0dc4bebb_v2,
  title = {formal data scarcity},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-data-scarcity/rdr_0dc4bebbaeb945eab3c6581303753497/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake