Letting the Student Vet the Teacher's Hints

Small language models are increasingly trained on material written by larger "teacher" models: worked solutions, step-by-step decompositions, and hints. The weak point is that the teacher's errors are copied along with its skill. A teacher that invents a wrong intermediate step, or proposes a sub-problem that does not actually lead to the answer, passes that mistake to the student as if it were ground truth. Checking final answers does not catch this, because a decomposition can contain a bad step and still end in the right number. We propose a different division of labor. The teacher writes only short Socratic hints, meaning guiding questions and clues that point toward a solution without giving it. The student writes every reasoning trace it is trained on. The student also decides which hints are admitted, by measuring whether each hint actually changes how often it solves the problem.

The mechanism fits in two sentences. For each hard problem, the teacher produces a ladder of hints of increasing specificity: a conceptual question, then a strategic clue, then a sub-problem breakdown. We keep the least revealing hint that measurably raises the student's solve rate, discard hints that do not raise it or that lower it, and then fine-tune the student on its own successful solutions with the hint removed. The claim to test is that this "uplift" signal detects hallucinated teacher content more cheaply and more reliably than asking a judge model. We also test whether the resulting on-policy traces beat curricula built from the teacher's own decompositions at equal teacher cost.

Why this gap is real

The evidence that teacher errors propagate is direct. Learning to Solve Complex Problems via Dataset Decomposition (DECOMPX) has GPT-4o recursively split math and code problems into atomic sub-problems arranged in a dependency graph, and trains Qwen2.5-1.5B on the resulting curriculum. Its own authors note that invalid teacher decompositions are absorbed by the student unchecked. The same pattern appears for flawed evidence-to-answer links in From Evidence to Trajectory and for hallucinated critique rationales in Generative Verifiers. Existing fixes use the teacher more intelligently. DIAG conditions new problems on the student's failures. Socratic-Zero co-evolves a teacher, a problem generator, and a solver around a 50% success target. Learning from Reasoning Failures via Synthetic Data Generation has GPT-4o diagnose failure modes and synthesize remedial examples, and rejects up to 81% of them at filtering. In all three, the content the student learns from is still teacher-authored. None of them tests individual pieces of teacher guidance against the student's behavior.

Two results suggest the student's behavior is a usable detector. First, Automatic Generation of Socratic Subquestions for Teaching Math Word Problems showed that good sub-questions raise solver accuracy substantially on GSM8K, from 29% to 47% for one-shot GPT-3. The same paper found that imperfect sub-questions on complex problems add confusion. Second, Unspoken Hints found that incorrect hints lower Gemini-2-Flash accuracy on GSM-Hard by up to 23 points. Taken together, these say that hint quality leaves a measurable footprint on solve rate. The same paper also supplies a constraint the design must respect: models use hints as shortcuts, reaching the right answer while writing explanations that never acknowledge the hint. A hint that simply leaks the answer will therefore show large uplift. Filtering on uplift alone would reward leakage, which is exactly what Socratic tutoring tries to avoid. This is why we use the hint ladder and prefer the least revealing tier.

Core Claim

Let $x$ be a problem and $h$ a candidate hint. Let $\hat p(x)$ be the student's solve rate over $k$ samples without the hint, and $\hat p(x,h)$ its solve rate with the hint. The uplift is

$$U(x,h) = \hat p(x,h) - \hat p(x).$$

The teacher writes hints at three tiers $t \in \{1,2,3\}$ (conceptual question, strategic clue, sub-problem breakdown), following the progression used in DeepTutor. The admitted hint for $x$ is the lowest-tier hint whose uplift clears a threshold $\tau$, where $\tau$ is set from the binomial standard error of the two rates at the chosen $k$.

Our first hypothesis is that hints containing hallucinated content have near-zero or negative uplift at a rate a judge model does not match. Our second hypothesis is that students trained on their own hint-stripped solutions reach higher accuracy on unhinted test problems than students trained on teacher decompositions, at equal teacher-token budgets. The two hierarchies in the title each have a job. The hint tiers act as an ordering by how much a hint reveals, which controls leakage. A hallucination taxonomy provides the evaluation lens that tells us which kinds of teacher error the uplift signal catches and which it misses.

Research Program

Building the hint ladders. The teacher, using the same GPT-4o-class model as DECOMPX to keep the comparison fair, receives a problem and its reference answer. It writes one hint per tier and is explicitly told not to state the answer. A string-level and numeric check removes any hint that contains the final answer.

Measuring uplift. The student is Qwen2.5-1.5B, chosen to match DECOMPX. It samples $k=16$ solutions with and without each hint. To keep cost down, we compute uplift only for problems whose unhinted solve rate falls below 0.5, since those are the only problems where a hint can add coverage.

Strip-and-train. For admitted hints, we keep the student's correct hinted solutions and remove the hint. We then train on pairs of problem and student solution.

Guarding against shortcut traces. Because of the Unspoken Hints finding, a stripped trace may contain an unexplained jump that only made sense with the hint present. We add a self-sufficiency check. A fresh student instance receives the problem plus the first 80% of the stripped trace and must reach the correct answer with that prefix. We report how many traces fail this check and train with and without it.

Auditing with a hallucination taxonomy. We need to know which teacher errors the uplift filter catches. We use two complementary audits.

The first audit uses injected errors. Following the error-injection method of Fine-grained Hallucination Detection and Editing for Language Models, we take hints that were verified as correct and insert typed errors. We adapt FAVA's entity, relation, contradictory, and invented categories to math. We add calculation-slip and logic-error categories from the perception/calculation/logic split in Benchmarking Multimodal Mathematical Reasoning with Explicit Visual Dependency. With these labels, we compute detection AUROC per error type and per hint tier.

The second audit uses natural errors. Human annotators label about 1,000 naturally generated teacher hints with the same categories. This tells us how often each error type occurs without injection and whether uplift flags it.

We expect one specific blind spot. "Invented" but harmless content, such as a correct but unnecessary sub-question, should survive the filter. The filter should mainly remove errors that point toward a wrong solution path, which are the ones that matter for training.

Baselines

The naive reference point is the base Qwen2.5-1.5B student fine-tuned by standard supervised training on the original problems and reference solutions. On MATH-500, DECOMPX reports this at 47.6% accuracy, and on AIME 2025 at 3.3%.

The strongest existing method on this exact question is DECOMPX itself, which reports 51.6% on MATH-500 and 16.7% on AIME 2025 for Qwen2.5-1.5B. We will rerun it rather than rely only on reported figures. The rerun uses the same seed problems and the same teacher model, and we cap total teacher output tokens to match our hint generation. Our method spends fewer teacher tokens per problem, because hints are short, but many more student sampling tokens. We therefore also report a DECOMPX variant whose extra compute goes to additional teacher decompositions, so that total FLOPs match. Beating DECOMPX means a higher MATH-500 accuracy than the rerun at matched teacher tokens, with the gap exceeding seed-to-seed variation over three seeds. At matched total compute, the result should at least tie.

A second strong competitor is failure-conditioned preference distillation, DIAG. It reports a 53.7% cross-benchmark average on Qwen3-8B-Base, against 51.9% for static generation, on a math battery that includes AMC23, Gaokao2023En, College Math, MinervaMath, and OlympiadBench. We run our method on Qwen3-8B-Base on that same battery so the comparison with DIAG's reported number is direct.

Four ablations isolate the key ingredients.

The first is outcome-only hinted self-training. It keeps every student solution that is correct under any hint, with no uplift comparison. This removes the uplift signal while keeping everything else, and it is the most dangerous competitor.

The second is judge filtering. A GPT-4o judge verifies each hint for correctness and non-leakage. This replaces the student-measured signal with the teacher-side check that most pipelines use.

The third is top-tier-only. It always uses the sub-problem breakdown hint, which tests whether choosing the least revealing tier matters.

The fourth is no-strip. It trains with the hint left in the context, which tests whether removing the hint is what makes the gains carry over to unhinted problems.

Why not just…?

Why not just filter hinted solutions by whether the final answer is correct? This is the real threat. On problems with a checkable numeric answer, most harmful hints may already fail this test. The uplift comparison can still add something in two places. A hint can be wrong while the student reaches the right answer anyway at its unhinted rate, which yields spurious admissions. And a hint can leak the answer, which yields admissions at an overly revealing tier. The outcome-only ablation settles whether either matters. If it matches our method on MATH-500 and AIME 2025 and on the natural-error audit, we will report that uplift adds no value beyond outcome filtering, and the contribution becomes the strip-and-train recipe alone.

Why not just have a stronger judge verify each hint? Teacher-side judging inherits the teacher's blind spots. When Agents go Astray found that only frontier models could act as useful process supervisors and that smaller open models could not supervise themselves. The judge baseline is also costly per hint. The injected-error AUROC comparison, broken down by error type, shows directly whether the judge or uplift catches more of the errors that actually hurt training.

Why not just self-train on the student's own unhinted correct solutions? Self-training without outside signal plateaus. The research file notes that autonomous self-improvement stalls unless it is anchored by external verification or a frozen teacher, as in Evolutionary Contrastive Distillation and Socratic-Zero. Unhinted self-training also cannot produce traces for problems the student never solves. We include it as a baseline and report the fraction of problems whose unhinted solve rate is below 0.5 but which become solvable under an admitted hint. That fraction is the coverage hints are supposed to add.

Why not just use DIAG or Socratic-Zero, which already adapt to the student? Both let the student's success rate decide which teacher content to create, but the content is still teacher-written problems and solutions. Our method keeps the teacher's contribution to short hints and makes the student author every training trace. The matched-battery comparison with DIAG's reported 53.7% tests whether this matters on its home ground.

Decisive Checks

We would consider the idea confirmed if three results hold together. First, uplift detects injected path-altering errors (contradictory steps, calculation slips, logic errors) with higher AUROC than the judge. Second, strip-and-train beats the DECOMPX rerun on MATH-500 and AIME 2025 at matched teacher tokens. Third, the outcome-only ablation is clearly worse on at least one of these benchmarks.

We would consider the idea refuted if either of two things happens. One is that outcome-only filtering matches our method everywhere. The other is that most admitted hints come from the most revealing tier and their traces fail the self-sufficiency check, since that would mean uplift is mostly measuring leakage.

As a secondary check on transfer beyond math, we test GSM-Hard with deliberately wrong hints given at inference time. The concern from Unspoken Hints is that students trained on hint-derived traces could become more dependent on hints. We measure whether their accuracy drop under wrong hints is smaller or larger than the base model's. The file reports a drop of up to 23 points for Gemini-2-Flash, and no reported result was found for a 1.5B student.