Modern language models are trained in stages: pre-training on web text, then supervised fine-tuning (SFT) on curated demonstrations, then reinforcement learning (RL) against automatic reward checkers. If benchmark test questions leak into any of these stages, scores go up. Recent work shows that the final RL stage also hides the evidence. Once a model has been through RL, standard contamination detectors can no longer tell leaked questions from fresh ones. The fix usually proposed is to release and audit intermediate checkpoints from every stage, which adds storage, transfer and inference cost to every training run.
We propose a cheaper test that needs only the final open weights. The auditor adds one short, deliberately cheap training stage of their own: a brief likelihood fine-tune on a mix of suspected benchmark items and fresh, difficulty-matched control items. The auditor then measures how fast each item's loss falls. The bet borrows a classic memory effect: material learned once is relearned faster than material never seen. RL may flatten the model's output probabilities on leaked items, but if the memorized information is still in the weights, a few gradient steps should bring it back. If the bet holds, a one-to-two GPU-hour probe could recover the item-level contamination signal that RL erased, without asking model developers to archive their training trajectories.
Core Claim
The evidence that RL hides contamination rather than deleting it comes from two papers that look contradictory. On The Fragility of Benchmark Contamination Detection in Reasoning Models shows that one epoch of clean GRPO (group relative policy optimization, an RL method that clips how far each update moves token probabilities) drops LiRA detection by about 14% and loss-based detection by about 16% from a pre-RL LiRA AUROC of 89.1%. Reference-free detectors fall to chance. The paper traces this to the clipping step, and removing clipping restores detectability. The Impact of Post-training on Data Contamination shows the reverse direction. Contamination injected early in pre-training goes dormant after 25B further tokens, yet a later clean SFT stage brings it back, inflating GSM8K and MBPP scores by up to 4% while leaving the uncontaminated counterparts unchanged.
Read together, these results suggest that post-training changes how visible memorization is, not whether it exists. Likelihood training re-exposes it; clipped RL masks it. Our claim is that an auditor can apply the re-exposing operation on purpose, cheaply and after the fact.
The method idea comes from Characterizing Datapoints via Second-Split Forgetting. That paper separates mislabeled from hard examples by watching how each one behaves during a second fine-tuning stage, reaching 0.94 AUC on CIFAR-10. It also notes that running full second-split training is too expensive at foundation-model scale. We keep its core insight, that per-item dynamics under an added training stage reveal hidden properties, but shrink the added stage to a few hundred low-rank adapter steps on a few thousand items. We turn it from forgetting to relearning, and apply it to generative models, which it never tested.
The statistical case comes from When Is Benchmark Contamination Detectable? Information Limits and Power-Calibrated Audits. It bounds audit power by $\alpha\rho\sqrt{m}$, where $\alpha$ is the contaminated fraction, $\rho$ is how separable seen and unseen items are in the model's behavior, and $m$ is the number of audited items. Auditors cannot enlarge a fixed benchmark ($m$) or choose the contamination rate ($\alpha$). The only term they control is $\rho$. The relearning probe is an intervention that raises $\rho$, and its value can be judged directly by how much audit power it buys per GPU-hour.
Research Program
The probe. The auditor takes the released model and a candidate set of benchmark items, such as the AIME problems a lab reports on. The auditor pairs them with control items the model cannot have seen. Controls come from three sources: problems written after the model's release, DyVal-style generated problems (DyVal builds reasoning tasks from random computation graphs with controllable depth), or answer-preserving rewrites.
Both sets are mixed into one training run. The auditor fits a small low-rank adapter (LoRA, a fine-tuning method that trains a thin add-on to the weights instead of the full model) with plain next-token likelihood on question-plus-solution text, for $T$ steps. The per-item loss $\ell_i(t)$ is logged at a handful of steps.
The score. Relearning speed depends on difficulty as well as membership, so we calibrate against a public reference model that was not trained on the benchmark, in the spirit of LiRA. We run the same probe on that model and score each item by its excess relative savings:
$$s_i = \frac{\ell_i(0)-\ell_i(T)}{\ell_i(0)} - \frac{\ell^{\mathrm{ref}}_i(0)-\ell^{\mathrm{ref}}_i(T)}{\ell^{\mathrm{ref}}_i(0)}.$$
Here $\ell_i(t)$ is the audited model's loss on item $i$ after $t$ probe steps, and $\ell^{\mathrm{ref}}_i(t)$ is the reference model's loss under an identical probe. A high $s_i$ means item $i$ comes back faster in the audited model than its difficulty alone predicts.
Items the probe does not train on. A second variant fine-tunes only on generic clean reasoning text and never on the benchmark. It then measures how much benchmark-item loss falls as a side effect. This directly mirrors the resurfacing effect in The Impact of Post-training on Data Contamination. It matters for two reasons. It avoids any objection that the probe teaches the model the answers, and it can score items held out of the probe entirely.
Cost accounting. Every method is charged its full cost in GPU-hours, and checkpoint-based auditing is also charged for storage. The comparison is therefore about detection per unit of compute, which is the overhead question this proposal cares about. It is not only a question of raw AUROC (area under the curve for separating leaked from clean items, where 0.5 is chance).
Stated limitation. The method requires open weights and cannot audit API-only models. It also inherits the hyperparameter sensitivity that the second-split forgetting paper reports for its fine-tuning phase. We therefore fix the probe's settings once, on a development pipeline, and freeze them before any evaluation pipeline is touched.
Baselines
Naive reference (the probe at step zero). The simplest point is the probe with $T=0$. This is exactly the loss detector, with and without reference calibration: zero-step loss alone is the standard loss detector, and zero-step loss calibrated against the reference model is LiRA, the strongest likelihood detector in the fragility study. It is the right floor because our score reduces to it when $T=0$, so any gain comes from the added stage and nothing else. After clean GRPO, the fragility paper reports roughly 89.1% AUROC falling by about 14 points for LiRA and to about 50% for reference-free methods. Beating this floor by a clear margin on the same post-GRPO models is the minimum requirement.
Strongest existing method (Self-Critique). The strongest existing weight-free detector for RL-stage contamination is Self-Critique from Detecting Data Contamination from Reinforcement Learning Post-training for Large Language Models. It asks the model for an answer, then asks for an alternative reasoning path, and compares the token-entropy sequences of the two. Leaked items show "policy collapse", meaning the second attempt stays locked to the first. It is the strongest competitor because it was designed for exactly the RL setting in which likelihood detectors fail.
The paper reports an average AUC of 0.70 on Qwen2.5-7B-Instruct and 0.64 on DeepSeek-Math-7B-Instruct on its RL-MIA benchmark, where likelihood baselines sit at 0.42 to 0.53. We will run the released recipe on the same models and items as our probe, using Top-5 entropy approximation. We give it a prompt-tuning budget equal to our hyperparameter budget, and cap its generation compute at our probe's GPU-hours. Beating it means a mean AUC at least 0.08 higher on RL-MIA at equal or lower compute, with the gap holding on both models.
Benchmark-level reference (ConStat). ConStat, from ConStat: Performance-Based Contamination Detection in Large Language Models, compares a model's score on a benchmark against its score on rephrased or synthetic counterparts, using trusted reference models. It is reported to detect 98.4% of sample-specific contamination and to expose inflation above 10% on leaderboard models. It answers a coarser question, whether a benchmark is inflated at all, so we compare on that question. We aggregate our item scores into a benchmark-level test and compare detection rate at matched false-positive rate and matched item count.
Ablations that isolate the key ingredient. Two ablations test whether the added likelihood stage is what matters. The first swaps it for extra steps of clipped GRPO on the same items, which should not resurface the signal if the mechanism claim is right. The second drops the reference-model calibration term.
Why not just…?
Why not just ask labs to release the SFT checkpoint and run LiRA on it? This is the countermeasure the fragility paper itself recommends, and where it is available it will likely work well, since LiRA reached 89.1% AUROC before RL. The problem is not accuracy but that it needs developer cooperation and adds per-stage checkpoint storage and inference to every run. It also misses contamination injected during RL, which is exactly what RL-MIA simulates. We will report checkpoint-LiRA as an upper reference line. The proposal succeeds if the probe closes most of the gap to it using only final weights.
Why not just use Self-Critique, which needs no weights at all? Self-Critique is the real threat, and it is the right tool for closed models. Its reported 0.64 to 0.70 AUC leaves a lot of room, though, and it has not been tested on contamination that entered during SFT and was then covered by clean RL. That is the fragility paper's Stage I setting, where the memorized signal sits in likelihood rather than in policy collapse. If Self-Critique matches the probe there at equal compute, we will report that the added training stage is unnecessary. We will also test whether the two signals combine, since they measure different traces.
Why not just compare scores on GSMPlus or other rephrased sets? This is ConStat's approach. It detects whether a benchmark is inflated but not which items leaked. Soft Contamination Means Benchmarks Test Shallow Generalization also shows that fine-tuning on paraphrased duplicates lifts both seen and unseen items by about 20% on MuSR. Rephrased controls can therefore be contaminated too, which weakens any score-gap test. We test this directly by including paraphrase-injected items. Among the three control sources, freshly generated controls are the ones least exposed to this problem.
Why not just evaluate on freshly generated DyVal tasks and ignore contamination? Dynamic benchmarks avoid leakage going forward, but they cannot say whether the existing reported numbers were inflated. They also cover only formal reasoning. We use generated items as controls rather than as a replacement for auditing.
Proposed Experiments
Pipelines. We rebuild four contamination pipelines from the file, each with known ground-truth membership.
The first reproduces the fragility paper's Stage I. Qwen2.5-7B-Instruct is contaminated during SFT on AIME, AMC, GPQA Diamond, OlympiadBench and Minerva Math items, then trained with clean GRPO for one, two and four epochs. This lets us plot detection against the amount of RL cloaking.
The second is RL-MIA from the Self-Critique paper. Half of the AIME 2024, AIME 2025, Knights & Knaves and SAT items are injected into RL training on Qwen2.5-7B-Instruct and DeepSeek-Math-7B-Instruct.
The third is the dormant-contamination setting from The Impact of Post-training on Data Contamination. Five copies of GSM8K and MBPP items are injected into the first 2B of 25B extended pre-training tokens on a Qwen2.5 model of at most 4B parameters, followed by clean GRPO.
The fourth is the fragility paper's Stage II. DeepSeek-R1-Distill-Llama-8B receives final-stage chain-of-thought contamination; all ten detectors in that paper averaged 50–58% AUROC here. We treat this as the hardest case and report it even if the probe fails.
Metrics. We report item-level AUROC and true-positive rate at 5% false positives. We also report GPU-hours per audited item, and the empirical separability $\rho$ fitted from score distributions. From $\rho$ we compute the item count needed for 80% audit power under the $\alpha\rho\sqrt{m}$ bound.
Decisive checks.
The first check is mechanistic. If the probe's AUROC on post-GRPO models is well above step-zero LiRA, while the GRPO-probe ablation stays near chance, that supports the claim that likelihood fine-tuning resurfaces what clipping masked.
The second check guards against a confound. On models that were never contaminated, the probe must stay at chance between benchmark and control items. Otherwise it is detecting a distribution shift between benchmark and control text, not membership.
The third check is on cost. Required audit size $m$ for the probe should fall by a large factor relative to LiRA at under two GPU-hours per model. If $\rho$ does not rise enough to shrink $m$ meaningfully, the probe adds overhead without adding power, and we will say so.
References
- On The Fragility of Benchmark Contamination Detection in Reasoning Models
- The Impact of Post-training on Data Contamination
- Characterizing Datapoints via Second-Split Forgetting
- DyVal: Dynamic Evaluation of Large Language Models for Reasoning Tasks
- Detecting Data Contamination from Reinforcement Learning Post-training for Large Language Models
- ConStat: Performance-Based Contamination Detection in Large Language Models
- Soft Contamination Means Benchmarks Test Shallow Generalization