AutoOverlap in Lean 4 Autoformalization

• AutoOverlap is defined as the fraction of SFT prompts overlapping with GRPO prompts, serving as a tunable hyperparameter in Lean 4 autoformalization.
• Experiments show that zero overlap (α=0) consistently leads to higher compilation and semantic accuracies compared to full overlap (α=1) at no extra compute cost.
• The study recommends using dual-metric evaluation (compile and semantic pass@k) to reveal performance gaps and robustly assess autoformalization quality.

AutoOverlap, as introduced in the context of Lean 4 autoformalization, is the data-overlap fraction between the prompt set used in supervised fine-tuning (SFT) and the prompt set used in Group Relative Policy Optimization (GRPO). In "SFT-GRPO Data Overlap as a Post-Training Hyperparameter for Autoformalization" (Su et al., 15 Apr 2026), it is treated as an explicit post-training hyperparameter for Qwen3-8B with “thinking” disabled, under a controlled ablation in which six training conditions differ solely in training recipe. The central empirical result is that keeping SFT and GRPO data disjoint consistently outperforms full overlap at zero additional compute cost, and that lower overlap is monotonically associated with higher compilation and semantic accuracy on Gaokao-Formal and PutnamBench (Su et al., 15 Apr 2026).

1. Definition and formalization

Let $S_{\rm sft}$ denote the set of prompts used in the SFT stage, and $S_{\rm rl}$ the set of prompts used in the GRPO stage. AutoOverlap, denoted by the data-overlap fraction $\alpha$, is defined as

$$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$

Equivalently, if $|S_{\rm rl}| = N_l$ and $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$, then

$\alpha = \frac{N_{\rm overlap}}{N_l}.$

The study examines three discrete values of $\alpha$: $0\%$ $(\alpha=0)$, $S_{\rm rl}$0 $S_{\rm rl}$1, and $S_{\rm rl}$2 $S_{\rm rl}$3 (Su et al., 15 Apr 2026).

Under this formalization, AutoOverlap is not a property of model architecture or optimizer choice. It is a property of set-membership between post-training stages. This framing makes overlap a controllable experimental variable rather than an incidental feature of dataset construction. The paper identifies this as, to its knowledge, the first controlled investigation of SFT-GRPO data overlap as a post-training hyperparameter (Su et al., 15 Apr 2026).

2. Controlled training conditions

All runs use the same base model, identical SFT and GRPO hyperparameters, and identical total data volumes. The six conditions are constructed so that overlap is the only manipulated variable in the mixed SFT+GRPO settings. For each desired $S_{\rm rl}$4, the GRPO prompt set is cross-deduplicated against the SFT corpus so that exactly $S_{\rm rl}$5 of its prompts appear in $S_{\rm rl}$6 (Su et al., 15 Apr 2026).

Condition	Training recipe
Base model	No post-training
SFT-only	20 000 $S_{\rm rl}$7 pairs
GRPO-only	GRPO on 16 000 prompts
SFT + GRPO-0%	SFT checkpoint, then GRPO on 16 000 non-overlapping prompts
SFT + GRPO-30%	$S_{\rm rl}$8 prompts from SFT pool and 11 200 fresh ones
SFT + GRPO-100%	GRPO prompts fully drawn from the SFT pool

This design isolates a specific question: whether GRPO contributes additional value when it is applied to prompts already seen during SFT. The reported behavior indicates that the answer depends strongly on $S_{\rm rl}$9. When overlap is complete, the GRPO stage becomes effectively redundant relative to SFT; when overlap is zero, GRPO provides the largest gains (Su et al., 15 Apr 2026).

3. Evaluation protocol and metrics

Evaluation is conducted on Gaokao-Formal, comprising 495 problems, and PutnamBench, comprising 672 problems. For each benchmark problem, the system generates $\alpha$0 rollouts and measures two complementary pass@k metrics (Su et al., 15 Apr 2026).

Compile pass@k, denoted $\alpha$1, is the fraction of problems for which at least one of $\alpha$2 rollouts typechecks under Mathlib v4.27.0. Semantic pass@k, denoted $\alpha$3, is the fraction for which at least one rollout both compiles and receives a judge score $\alpha$4. For a dataset $\alpha$5 of size $\alpha$6, with $\alpha$7 per $\alpha$8,

$\alpha$9

and

$$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$0

The compile–semantic gap is defined at $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$1 by

$$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$2

The semantic judge is a frozen LLM, Gemini Flash 3, that returns a continuous score $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$3 for each compilable output $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$4 relative to ground truth $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$5. Non-compiling outputs receive $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$6 (Su et al., 15 Apr 2026).

The metric construction is consequential. It distinguishes syntactic validity from semantic correctness, making it possible to detect models that typecheck frequently but solve the wrong formalization problem.

4. Quantitative findings

At pass@1, the best mixed setting is always the non-overlapping one. Across both benchmarks, performance degrades monotonically as overlap $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$7 increases: $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$8 gives the highest $$\alpha = \frac{|S_{\rm sft} \cap S_{\rm rl}|}{|S_{\rm rl}|} \in [0,1].$$9 and $|S_{\rm rl}| = N_l$0, $|S_{\rm rl}| = N_l$1 is slightly lower, and $|S_{\rm rl}| = N_l$2 collapses back to SFT-only levels (Su et al., 15 Apr 2026).

Condition	Gaokao-Formal $|S_{\rm rl}| = N_l$3	PutnamBench $|S_{\rm rl}| = N_l$4
Base	19.9 / 10.2	11.3 / 3.3
SFT	61.8 / 41.0	28.5 / 14.3
GRPO-only	50.9 / 28.1	36.1 / 11.9
SFT+GRPO-0%	77.6 / 51.4	47.9 / 23.6
SFT+GRPO-30%	76.4 / 48.6	46.4 / 22.9
SFT+GRPO-100%	62.9 / 40.6	29.1 / 14.7

On Gaokao-Formal, SFT+GRPO-0% reaches $|S_{\rm rl}| = N_l$5 and $|S_{\rm rl}| = N_l$6, yielding a semantic gain over SFT of $|S_{\rm rl}| = N_l$7 percentage points. SFT+GRPO-30% is slightly worse at $|S_{\rm rl}| = N_l$8 and $|S_{\rm rl}| = N_l$9. SFT+GRPO-100% reaches $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$0 and $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$1, with both metrics essentially flat versus SFT (Su et al., 15 Apr 2026).

On PutnamBench, SFT+GRPO-0% reaches $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$2 and $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$3, a semantic gain of $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$4 percentage points over SFT. SFT+GRPO-30% reaches $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$5 and $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$6. SFT+GRPO-100% reaches $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$7 and $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$8, again near SFT-only behavior (Su et al., 15 Apr 2026).

The paper’s practical interpretation is direct: non-overlapping GRPO data is essential for RL to provide fresh learning signals, whereas full overlap renders the GRPO stage effectively redundant (Su et al., 15 Apr 2026).

5. Compile–semantic gap and benchmark interpretation

A central contribution of the AutoOverlap study is methodological rather than purely comparative. Dual-metric evaluation reveals compile–semantic gaps exceeding 30 percentage points for the highest compiling models, and this disparity is invisible under compile-only benchmarking (Su et al., 15 Apr 2026).

The reported $N_{\rm overlap} = |S_{\rm sft} \cap S_{\rm rl}|$9 values at pass@1 already show substantial divergence within the six-condition ablation. On Gaokao-Formal, the gap rises from $\alpha = \frac{N_{\rm overlap}}{N_l}.$0 percentage points for the base model to $\alpha = \frac{N_{\rm overlap}}{N_l}.$1 for SFT, $\alpha = \frac{N_{\rm overlap}}{N_l}.$2 for GRPO-only, $\alpha = \frac{N_{\rm overlap}}{N_l}.$3 for SFT+GRPO-0%, $\alpha = \frac{N_{\rm overlap}}{N_l}.$4 for SFT+GRPO-30%, and $\alpha = \frac{N_{\rm overlap}}{N_l}.$5 for SFT+GRPO-100%. On PutnamBench, the corresponding values are $\alpha = \frac{N_{\rm overlap}}{N_l}.$6, $\alpha = \frac{N_{\rm overlap}}{N_l}.$7, $\alpha = \frac{N_{\rm overlap}}{N_l}.$8, $\alpha = \frac{N_{\rm overlap}}{N_l}.$9, $\alpha$0, and $\alpha$1 percentage points (Su et al., 15 Apr 2026).

The same issue appears in external comparisons. For the highest-compiling external baselines, exemplified by Kimina-7B with $\alpha$2, the compile–semantic gap exceeds 35 percentage points (Su et al., 15 Apr 2026). Models with the highest $\alpha$3 often have the largest $\alpha$4, meaning that many outputs are syntactically valid but semantically incorrect.

This result constrains how autoformalization progress should be interpreted. Compile-only metrics can overestimate end-to-end formalization quality because they collapse type correctness and proof-content correctness into a single observable. The paper therefore recommends dual-metric evaluation as standard practice (Su et al., 15 Apr 2026).

6. Practical implications and scope of the term

The immediate recommendation is to treat the SFT↔GRPO overlap $\alpha$5 as a tunable hyperparameter and, whenever corpus volume permits, to allocate disjoint data pools $\alpha$6 in order to maximize both compilation success and semantic fidelity (Su et al., 15 Apr 2026). Because the experiments hold total data volume and post-training hyperparameters fixed, the reported gains occur at zero extra compute cost. In this setting, changing only set overlap is sufficient to alter whether GRPO contributes meaningful additional learning.

A plausible implication is that AutoOverlap functions as a control knob for the novelty of the reinforcement-learning stage relative to the supervised stage. That implication is consistent with the paper’s conclusion that lower overlap provides fresh learning signals, whereas full overlap causes both compile and semantic accuracy to flatline relative to SFT (Su et al., 15 Apr 2026).

The label “AutoOverlap” is not unique to this autoformalization setting. In unrelated work, "AutoOverlap: Enabling Fine-Grained Overlap of Computation and Communication with Chunk-Based Scheduling" denotes a compiler and runtime for intra-kernel overlap on multi-GPU workloads (Qiang et al., 28 Jan 2026). In 3D LiDAR localization, an overlap-based observation model has also been described under the AutoOverlap label in technical summaries (Chen et al., 2021). The term therefore has field-specific meanings. Within Lean 4 autoformalization and SFT→GRPO post-training, however, AutoOverlap specifically denotes the overlap fraction $\alpha$7 between the SFT and GRPO prompt sets (Su et al., 15 Apr 2026).