Part XVIII's RLHF chapter fit a reward model because nobody could write down "this answer is worth 7.3 points" for an open-ended response. But a math problem has exactly one right number. Why train a fallible proxy to guess at something you can just check?
What is 17 + 26? (correct answer: 43)
Four sampled responses to one arithmetic problem. Step through them — each one gets checked against the true answer directly, no reward model involved anywhere in the loop.
RLVR's reward is the verifier's own output, nothing learned in between:
- — the reward assigned to sampled response .
- — a program that checks against ground truth: exact-match on a final answer, or a test suite that a piece of code either passes or fails.
- — the indicator function: if the condition holds, otherwise.
- No reward model to fit, no reward model to fool
RLHF's reward model has to be trained on preference data and can be exploited by any response that merely looks convincing to it. A verifier that checks an exact answer or runs a test suite has no such surface to attack.
- The reward is binary and exact
Every sampled response gets exactly or — no in-between score, no calibration to worry about, no drift between the reward model and the policy being trained against it.
- This only works where a verifier exists
RLVR is not a universal replacement for RLHF — open-ended writing has no ground-truth checker. It's the right tool specifically for math, code, and anything else with a checkable answer.
The verifiable reward and the learned reward model's guesses average out to almost the same number across these four responses. But look at which SPECIFIC response each one likes best: the verifier correctly picks a response that got the right answer. The learned reward model — scoring based on what sounds plausible — picks a response that's flatly wrong. That's reward hacking in miniature, and it's exactly the failure mode a verifiable reward can't have.
Four sampled responses to "What is 17 + 26?" (correct answer: ):
- Verify each response exactly
- "" → correct → reward
- "" → wrong → reward
- "" → correct → reward
- "" → wrong → reward
Mean verifiable reward: .
- Compare against the learned reward model's guesses
Guesses for those same four responses, in order:
Sum: . Mean: — close to the verifier's on average.
- But the rankings disagree where it matters
The learned RM's highest guess () belongs to "" — the WRONG answer. The verifier would never make that mistake: it isn't guessing, it's checking.
Pick a response the verifier (not the learned reward model) marks correct.
RLVR replaces a learned proxy for correctness with correctness itself, wherever a verifier can be written. It's not a fix for RLHF's reward model — it's a sidestep, available only on the subset of tasks (math, code, anything checkable) where "correct" isn't a matter of preference at all. The next chapter asks a harder question: once responses are sampled and scored this way, how does the policy actually turn that binary signal into a training update — without training a separate critic network to estimate a baseline?