Lab record · handoff for new collaborators

Does catalyst data exist?

Six weeks of experiments chasing one appealing idea — that a small amount of the right auxiliary data can make a target task train dramatically faster, the way a catalyst speeds a reaction without being consumed.

157 training runs Qwen3.5-4B throughout 11 synthetic tasks 8–16× H100 Snapshot 2026-08-29

Bottom line as of this snapshot

In this setting, catalysis does not survive its budget control. The best auxiliary data we found speeds up the target task by 2.4× over an under-trained baseline — but adding the same amount of the target task's own data gets you exactly the same curve (AUC 0.719 vs 0.717, n=8/6, p=0.90). Measured per total token consumed, the auxiliary conditions are no better than doing nothing.

中文结论：在当前设定下，"催化剂数据"没有通过预算对照。掺入辅助数据带来的加速，与直接补充等量目标任务数据完全打平；按总 token 口径甚至没有优势。这不是"辅助数据没用"，而是"它的用处等同于多训一会儿"。

That is a real answer to a well-posed question, and the negative result is only meaningful because of the controls built to get it. What remains genuinely open is stated at the end — the falsification is scoped to one target task, one model, one data regime.

The idea we were testing

Stated in the collaborator's own framing, because every later experiment is a response to it.

A catalyst in chemistry does three things: it is used in sub-stoichiometric amounts, it is not consumed by the reaction, and it changes the rate without changing the equilibrium. The hypothesis was that some training data behaves this way — mix a little of it in alongside your target-task data, and the target task converges much faster, with the classic example being math data improving coding ability.

Two consequences shaped the whole project. First, the dependent variable must be speed — tokens of the target task needed to reach a quality bar (time-to-τ) — not final quality. Second, the deliverable is not just a phenomenon but a theory that predicts, before training, which data will accelerate which task.

What we believed, and what killed it

Five successive positions. Each was killed by a control, not by an opinion. This is the fastest way for someone new to avoid re-running dead ends.

Falsified

Cross-task acceleration is carried by specific rollouts inside RL training

The original plan: in multi-task agentic RL, filter which self-generated rollouts of task C enter the gradient (advantage-frozen filtering, F0–F6 conditions) and watch whether task B's learning speed changes.

Killed by: a sampling bug first (all G rollouts in a group shared one vLLM seed — 82% of groups were eight copies of one rollout, invalidating v3–v6). After the fix, all filter conditions land on top of each other. Structurally, GRPO computes advantages within a task's own group, so catalyst data has no path into B's learning signal; on-policy data is already diverse, so the pathology catalysts would fix never arises. Sequential curriculum (train C to mastery, then B) is a pure tax: B ignites ~20 steps later than from scratch.

Falsified

In SFT, mixing in auxiliary traces raises final quality

Dose-response grid over target-token budget × auxiliary type, endpoint pass@1 as the readout. Early numbers looked strong: 30k of target data alone scored 0.583, adding 230k auxiliary traces took it to 0.896.

Killed by: budget-matched controls. Training the same 30k for three epochs reaches 0.778, and 90k of fresh target data reaches 0.806 — the "catalysis" was mostly under-training being fixed. Separately, endpoint scores swing ±0.2 across seeds and orderings invert, so single-seed mixing ablations (the norm in this literature) cannot support their conclusions.

Falsified

The active ingredient is error-recovery trajectories

Traces that hit an error and then recover led every budget-matched comparison: same-task error-recovery data scored 0.861 (tightest band in the whole project) and cross-task error-recovery 0.854, both far above random traces at the same budget (0.764). Same-task failure traces are poison (0.33–0.56).

Killed by: the collaborator's own objection — this is the dominant pattern of the target data itself, so the model is simply learning a broader slice of the same distribution. It is a data-quality finding, not catalysis: the "catalyst" is consumed (the model's score on the auxiliary task rises alongside), and it needs stoichiometric amounts to work.

Falsified

Speed-up is predictable from gradient geometry (rank supplementation)

Switching the dependent variable to time-to-τ produced a striking table — auxiliary data appeared to give 2.4–30× speed-ups while more target data gave only 1.7×. A gradient probe suggested the predictor: auxiliary data adds independent descent directions (rank_gain), while data whose gradients collapse to one direction does not. Predictions were preregistered before training.

Killed by: its own out-of-sample test. Across five far-field domains the criterion went 1-for-5 — logic puzzles were predicted fastest and came last; translation was predicted inert and landed mid-pack. Across all 11 measured data sources, no geometric quantity correlates with speed-up above |r| = 0.35.

Falsified

At least the speed-up itself is real, even if unexplained

The decisive experiment: four conditions × 8 seeds, evaluation set doubled, checkpoint spacing equalized on the target-token axis, decision rule preregistered.

Killed by: the budget control, again, now with enough seeds to be believed. Best auxiliary condition and "just add more of your own data" are indistinguishable (p = 0.90). Two further corrections shrank the original table: expressed per total token consumed the advantage disappears, and the earlier checkpoint schedule had been sampling high-auxiliary conditions more densely on the target-token axis, biasing them toward earlier crossings.

The decisive experiment

Preregistered in reports/PREREG_ROUND3.md before any of these runs started. This is the table to show a skeptic.

Round 3 · B = codegen · 4 conditions × 8 seeds · AUC of the pass@1 curve
Condition	What it is	n	AUC	tt@0.7 (B tok)	per total token
none	30k target tokens, 1 epoch	8	0.613	11,871	1.28×
b90k	90k target tokens — the budget control	6	0.717	9,680	1.57×
mh15	30k target + 15k hard math	7	0.646	7,250	1.40×
pyf60	30k target + 60k error-recovery traces	8	0.719	5,681	0.89×

Mann-Whitney on AUC: pyf60 > none p = 0.016; pyf60 vs b90k p = 0.897; mh15 vs b90k p = 0.317. Reading: auxiliary data beats an under-trained baseline, and does not beat more of your own data. The tt@0.7 column is why the earlier framing looked so good — it counts only target tokens, hiding the extra optimizer steps the auxiliary data buys.

Everything that was run

157 run directories, all results in the public repo. Checkpoints (~1.2 TB) were deliberately not kept.

Experiment phases
Phase	Prefix	Runs	Question	Outcome
RL trace filtering	`v7_`, `hard2_`	12	Do filtered rollouts carry cross-task acceleration?	No effect; curriculum is a tax
SFT dose-response	`sftd_*`	14	Does mixing help, and at what dose?	Yes at endpoint — later explained by budget
SFT curves + controls	`sftc2_*`	31	Content vs budget vs polarity, per-checkpoint	Poison result survives; catalysis does not
Speed / math→coding	`mc_*`	41	Time-to-τ across 9 auxiliary domains	Large apparent speed-ups, later deflated
Decisive high-seed	`r3_*`	31	Does anything beat the budget control?	No (p = 0.90)

Results that did survive every control

Same-task failure traces are poison. Mixing a target task's own failed trajectories into distillation costs roughly half its accuracy (0.33–0.56 vs 0.72 baseline) — the largest and most reproducible content effect we found. Cross-task failures are harmless. The distinction is not "did it err" but "did it recover".
Unrelated data at high dose is mildly harmful, not inert (0.694 vs 0.715 baseline, n=3).
Under-training is the dominant term. Most of what looked like data-mixing magic was a 30k-token budget being too small; the fix is more epochs or more data, whichever is cheaper.
RL and SFT differ structurally. Any "catalysis" story has to explain why on-policy RL offers no site of action — group-relative advantages isolate auxiliary data from the target's learning signal.

Traps that produced false findings

Each of these generated a publishable-looking result before it was caught. Anyone continuing this work will meet them again.

Seed collision in vLLM sampling. One SamplingParams seed shared across a group makes G identical rollouts. It manufactured a convincing "instance-level bimodality" story and invalidated six weeks' worth of RL runs. Fix: per-request seeds.
Endpoint variance of ±0.2. At small data budgets, single-seed endpoint comparisons reverse their own ordering across seeds. Minimum three seeds; prefer whole-curve statistics (AUC) over single crossings.
Loss-normalization confound. Dividing loss by the batch's own gradient-token count makes the target task's effective learning rate depend on how much auxiliary data the condition keeps — exactly the manipulated variable. Fix: a shared constant denominator.
Winner's curse in difficulty screening. Screening instances with k = 8 samples and keeping the 0/8 ones yields a "zero-signal" pool that is roughly one-third false positives; the pool self-ignites within ten steps.
Checkpoint-spacing bias. Saving every N optimizer steps samples high-auxiliary conditions more densely on the target-token axis, biasing time-to-τ downward for precisely the conditions under test.
Axis choice as a confound. "Faster per target token" can simply mean "more total optimizer steps taken". Always report the total-token view alongside.

Where a new collaborator should push

The falsification is scoped. These are the directions where the original idea could still be right.

A target task that is capability-bound, not budget-boundOur target sat at 54% pass@1 with a small budget, so "more data" was always available as an alternative explanation. Pick a target where the model is genuinely stuck — the auxiliary data then has something to do that extra target data cannot.

Scale, where the effect is claimed to liveThe published cross-domain results (math↔code via influence functions, NeurIPS 2025) are at 7–8B with real corpora. A 4B model on synthetic tasks may simply be below the regime where shared reasoning circuits exist to be reinforced.

Mid-training rather than fine-tuningThe most credible version of the idea is "what data makes a model more RL-able later" — a rate question at a stage where representation is still plastic. None of our runs test this.

Push the poison result insteadIt is the one effect that survived every control, it is large, and it contradicts common practice (rejection-sampling pipelines that keep failed traces "for diversity"). It needs a second target task and a mechanism, not more seeds.

If you keep chasing speed, fix the measurement firstTen-plus seeds per condition, AUC as primary, total-token axis reported, checkpoint spacing equalized, and predictions preregistered. Anything less will produce another table like ours.

Picking up the code

Everything — code, donor datasets, all 157 runs' curves and logs, every report and preregistration — is public at huggingface.co/datasets/jiayicheng/transfer-unit-catalyst (17 MB; model checkpoints deliberately excluded).

Orientation · read in this order
File	Why
`reports/SPEED_THEORY.md`	The speed framing, the falsified theory, the surviving measurements
`reports/PREREG_ROUND3.md`	The decisive experiment's design and decision rule, written in advance
`reports/LIT_REVIEW_speed.md`	Where this sits against gradient-geometry and data-mixing literature
`reports/FINAL_REPORT.md`	The endpoint-quality phase, including the poison and budget controls
`tu/analysis/speed.py`	time-to-τ / AUC — the dependent variable
`tu/offline/sft.py`	The mixing experiment: target data + auxiliary data, periodic checkpoints
`tu/offline/eval_ckpts.py`	Hot-swap evaluator — one engine load, ~2.5 min per checkpoint
`tu/tasks/`	11 synthetic, programmatically verified tasks across agentic, reasoning and language forms

Environment notes that will cost you a day otherwise

Stack is pinned to CUDA 12: vllm 0.19.1, torch 2.10+cu128, transformers 5.13, fla-core. Hopper GPUs, driver 535.
fla-core probes a broken TileLang install and refuses gated-DeltaNet backward on Hopper with triton ≥ 3.4 — both worked around in scripts/*.sh (shim plus a monkeypatch to the pure-torch path).
VLLM_ALLOW_INSECURE_SERIALIZATION=1 is required to pass a callable to collective_rpc for weight sync; TORCH_BLAS_PREFER_CUBLASLT=1 is required or every bf16 load crashes.
On a shared NFS home, the NVML symlink workaround must be host-specific — workers running different driver versions will clobber each other's fix.
Paths are absolute: grep -rl chobits-wx and repoint before running anywhere else.