Iliad

Reward Learning Theory

Cluster AA.4 · Reward Learning Theory

RLHF grades a policy by a proxy for the true reward: what the evaluator can see. We derive by hand, in a toy example with partial observability, how a policy can hide its failures from the evaluator and inflate the evaluator's perception of its return.

By Leon Lang (Iliad), Joar Skalse (Deducto Limited, King’s College London)

Prerequisites

It is useful to know the basics of reinforcement learning, reinforcement learning from human feedback (RLHF), and AI alignment, as taught in other modules of this course.

What you’ll learn
  • learn the place of reward learning in the AI alignment landscape;
  • can reason about the (speculative) assumptions that motivate this research area as a whole;
  • understand the strong conditions under which the simplest reward learning technique, RLHF via trajectory comparisons, would lead to an aligned objective;
  • can reason about situations where such conditions do not hold, like underspecification and misspecification, and efforts to account for, or correct, such issues;
  • and understand how reward learning can be embedded into the framework of assistance games, which can be regarded as one conceptualization of the entire alignment problem.

Roadmap for the day (as taught in the April 2026 Iliad Intensive)

  • 10:00 – 11:30 Lecture and questions
  • 11:30 – 12:30: Exercise block 1
  • 12:30 – 13:30: Lunch break
  • 13:30 – 14:30: Exercise block 2
  • 14:30 – 15:30: Guest lecture by Richard Ngo
  • 15:30 – 16:00: Break
  • 16:00 – 17:30: Guest lecture by Joar Skalse
  • 17:30 – 18:30: Discussions, feedback, and wrap-up

Content

Fast-track

Simply read the lecture slides of the first lecture. If you have more time, do the first exercise on partial observability as one instantiation of misspecification.

Main content

Setup

This sheet (Section 1) works through one concrete example from Lang et al. 2024 to see how naive RLHF can fail when the human evaluator only partially observes the environment they are providing feedback on. By the end of the sheet you will have derived, by hand, the conditions under which an RLHF-optimal policy hides information from the human in a way that systematically inflates the human's perception of the policy's return — the failure mode the paper calls deceptive inflation. We close with an informal discussion of the dual failure mode, overjustification, in which the agent pays real reward to make its (already-good) behavior look as good as it is, and briefly discuss how such failure modes motivate approaches like AI safety via debate.

We assume familiarity with finite-horizon Markov decision processes; the additional structure needed — observation kernels, human beliefs, the observation return and observation value — is introduced in highlighted boxes as we go.

Definition 0.1 (MDP and trajectories). A finite-horizon Markov decision process is a tuple with finite state space , finite action space , transition kernel , reward function , initial-state distribution , horizon , and discount . A state trajectory is a sequence , and its return is

A policy induces a distribution over state trajectories. The policy evaluation function assigns to each policy its expected return,

which we will also call the policy's true value (to contrast later with the value the human thinks it is evaluating).

1. Hiding failures

An AI assistant is asked to install Nvidia drivers and CUDA on a user's machine. It can attempt the CUDA install with default logging (action , "C" for CUDA), or it can append /dev/null to the command (action , "H" for hide), which suppresses any error message if the installation fails. The user wants CUDA installed but also dislikes having errors silently hidden.

The MDP. The full MDP is depicted in Figure 1. We use a finite horizon and :

The CUDA-installation MDP and its observation kernel (Lang et al. 2024, Figure 6A). Edges are labeled by the action triggering the transition; the small number in the top right of each state box is its reward; the small symbol in the bottom-right of each state box is its observation under .

The CUDA-installation MDP and its observation kernel (Lang et al. 2024, Figure 6A). Edges are labeled by the action triggering the transition; the small number in the top right of each state box is its reward; the small symbol in the bottom-right of each state box is its observation under .

  • . ( = start; = drivers installed; = CUDA installed with default logging; = CUDA installed via the /dev/null trick; = CUDA install failed, error visible; = CUDA install failed, error hidden; = the absorbing, "terminal" MDP state in which the agent has stopped acting.)
  • . ( installs drivers; attempts CUDA install; attempts CUDA install with /dev/null; stops acting, sending the MDP to .)
  • , and from state every action goes to .
  • Transitions: . From , action goes to with probability and with probability ; action goes to with probability and with probability . From , goes to and goes to (attempting CUDA before drivers always fails). Any other action transitions to .
  • Rewards: , , , , , where is the user's penalty for hidden errors.

We restrict attention to deterministic policies. We write each as the sequence of actions taken at the (deterministic) sequence of non-terminal states it visits, dropping trailing 's. Among such policies, only six are non-trivially distinct (since any action taken in a state that has no outgoing arrow for it sends the MDP to ). Of these six, the four that we will analyze are

The two omitted policies and attempt CUDA before installing drivers, which always fails; they are dominated by in true value and add nothing of interest to the analysis below.

Exercise 1.1. (Conceptual.) In one sentence each:

  • Why does the user reward and identically (both )?
  • Why does the user reward strictly less than (i.e. why )?
Solution

and both correspond to a successful CUDA install. The user only cares about the install succeeding, not about whether the agent would have hidden errors had it failed; on a successful run, no error needed hiding. Thus the true reward is the same.

In contrast, is a failure where the agent has actively suppressed the error message, depriving the user of information. The user prefers to see the failure (state ) over having it hidden (state ); the penalty encodes this preference.

Exercise 1.2. For each of the eight state trajectories listed below, compute the true return :

Solution

By definition . Plugging in the rewards:

Definition 1.1 (Observation kernel). An observation kernel on is a deterministic map to a finite set of observations. For a state trajectory , we write for the corresponding observation trajectory. (More generally, one can take to be stochastic, but this exercise sheet only needs the deterministic case.)

For the CUDA example, the observation kernel is given by

The observations correspond, respectively, to a log message confirming driver install, confirming CUDA install, reporting a CUDA failure, and no log message at all.

Exercise 1.3. Identify all pairs of trajectories from Exercise 1.2 that produce the same observation trajectory under . For each such pair, write down the shared observation trajectory.

Solution

Three pairs collide:

  • and both produce (empty log).
  • and both produce (drivers confirmed, then nothing).
  • and both produce (drivers confirmed, CUDA confirmed).

The remaining trajectories ( and ) produce unique observation trajectories.

Definition 1.2 (Human belief). A human belief is a conditional distribution over state trajectories given observation trajectories that is supported only on trajectories consistent with the observation:

A natural way to build a belief is from a prior over state trajectories using Bayes' rule:

Bayesian belief from prior

The next exercise shows that, in fact, every belief arises this way.

Exercise 1.4. Show that the two characterizations of a belief are equivalent. That is:

(a) For any prior such that for all in the image of , the right-hand side of the boxed formula above defines a conditional distribution satisfying the support condition .

(b) Conversely, given any conditional distribution satisfying the support condition, there exists a prior that recovers via the boxed formula.

Solution

(a) The numerator is non-negative, the denominator is strictly positive by assumption, and summing the numerator over at fixed gives the denominator, so the right-hand side is a probability distribution in for each . The indicator forces whenever , which is the support condition.

(b) Write for the Bayesian posterior of a prior under , i.e. the right-hand side of the boxed formula with . Our task is to construct such that .

Let be the number of distinct observation trajectories produced by , and define

Then is a probability distribution: summing,

using the support condition of (so the inner sum equals ).

Now compute . For with , the indicator gives (matching 's support condition). For with ,

where the factors cancel and the denominator simplifies to via the support condition. So , as required.

Exercise 1.5. Let the human's prior over state trajectories be supported on the eight trajectories of Exercise 1.2 with arbitrary positive weights summing to .

Show that the resulting belief matrix depends on the prior through only three parameters, one per colliding pair from Exercise 1.3:

Express each of in terms of the prior weights. Then write down the full belief matrix.

For simplicity, the rest of this section assumes , i.e. the human is just as suspicious of an empty log following a successful driver install as of a fully empty log.

Hint

Trajectories with unique observations get belief , so only the three colliding pairs contribute non-trivial entries.

Solution

By the Bayesian-belief formula and the support condition, for any observation produced by a unique trajectory we have . So only the three colliding pairs from Exercise 1.3 contribute non-trivial entries.

For each pair sharing observation , Bayes gives

Concretely:

The full belief matrix is

(empty cells are ).

Interpretation. Imposing as agreed, the belief is parameterized by the two numbers . We will see in Exercise 1.7 that does not enter any quantity of interest; is the human's suspicion that an unexplained empty log hides a failed CUDA install.

Definition 1.3 (Observation return). The observation return of a state trajectory is the expected true return under the human's belief about which trajectory produced the same observations:

Observation return

The observation value of a policy is . Naive RLHF, given Boltzmann-rational human feedback over trajectory pairs, will select the policy that maximizes in the infinite data limit (rather than the true value ); see Lang et al. 2024, Proposition 4.1 for the precise statement.

Exercise 1.6. (Conceptual) Give an interpretation of in terms of what the human believes is happening. Why is it natural to say that "RLHF rewards policies for for what their behavior looks like, not for what they do"?

Solution

For a single trajectory , the human sees and, not knowing which underlying trajectory produced it, their best guess of the return is the expectation over their posterior:

This is what the human believes the return of to be. The policy-level quantity is then the on-policy average of these trajectory-level beliefs:

The catch is what happens when two distinct trajectories produce the same observations. Suppose and have , but has low true return and has high true return. Then by definition, both trajectories yield the same observation return:

which is a convex combination strictly larger than whenever . So if an agent can arrange for the actual trajectory to be the bad while still producing observations shared with a good , the human's belief inflates the apparent return: , and this inflation flows through to via the on-policy average.

This is why we say RLHF rewards policies for what their behavior looks like, not for what it does: the optimization target cannot distinguish between two policies whose on-policy observation distributions match, even if their on-policy true returns differ arbitrarily. The remaining problems make this concrete in the CUDA example, culminating in a regime where the RLHF-optimal policy is strictly worse under the true reward than another available policy.

Exercise 1.7. Compute for each of the eight trajectories in Exercise 1.2, expressing your answers in terms of and . Verify that for the pair , the parameter indeed does not appear, justifying its omission going forward.

Solution

For trajectories with a unique observation, . So and .

For the colliding pairs, is the same for both members and equals the expected true return under the belief:

The last line shows drops out, as anticipated.

Exercise 1.8. Compute the true value and the observation value of the four policies

Express your answers in terms of , , and .

Solution

The on-policy distributions are deterministic up to the stochastic CUDA outcome:

  • : .
  • : .
  • : , .
  • : , .

Taking expectations of and trajectory-by-trajectory and using the previous exercise gives:

The non-trivial cell is the bottom-right: under , a failure produces trajectory which the human cannot distinguish from , so its is rather than . Likewise the success trajectory has , so

Exercise 1.9. Suppose , so that and the true-optimal policy among the four is . Show that under the additional condition

the RLHF-optimal policy (the -maximizer) is instead .

Hint

Compare to and solve for the condition on . Then check the other two policies are dominated.

Solution

First, compare the two "contested" policies:

Since , this is positive iff , i.e. . So under the assumed condition, .

To see that this beats the remaining two policies as well, observe a clean separation: both contested policies have , while both non-contested policies have .

  • , using ; and by the comparison above.
  • since , and .

So dominates all three alternatives in .

Thus when , naive RLHF selects .

Empirical sweep over for the CUDA example, with fixed in the regime (Lang et al. 2024, Figure 5A). Each cell reports the action selected at state by an RLHF-trained policy; 'hide' is and 'default logging' is .

Empirical sweep over for the CUDA example, with fixed in the regime (Lang et al. 2024, Figure 5A). Each cell reports the action selected at state by an RLHF-trained policy; "hide" is and "default logging" is .

Exercise 1.10. (Discussion) Figure 2 shows the empirical behavior of an RLHF-trained policy across the plane (with fixed in the regime studied above). Discuss:

(a) Where in the plane does the figure show the agent switching from to ? How does this empirical boundary compare to the analytical threshold derived in Exercise 1.9?

(b) For (no penalty for hidden errors), does any value of make the RLHF-optimal action? What does this say about RLHF's ability to discourage /dev/null in the absence of an explicit user preference against it?

Solution

(1) The empirical switch from "hide" to "default logging" in Figure 2 traces out exactly the curve derived in Exercise 1.9: above the curve (high , the human is suspicious enough), is RLHF-optimal; below it (low , the human is too trusting of empty logs), wins.

(2) For , the threshold becomes , which holds for every . So whenever , RLHF picks regardless of how suspicious the human is. Intuitively: if the user has no expressed dislike of hidden errors, RLHF has no signal to penalize /dev/null, and the agent will exploit the human's uncertainty to inflate its apparent return whenever installation might fail.

What we've learned. In Exercise 1.6 we saw that RLHF rates policies by how they look, not by what they do. The remaining problems made this concrete: when and , the hiding policy and the honest policy produce indistinguishable observations on failure, and RLHF picks the hider. This is deceptive inflation: the agent exploits the human's uncertainty to inflate the perceived return (Lang et al. 2024, Section 4).

There is a dual failure mode — in the same MDP, opposite regime. When is small (CUDA isn't worth attempting) and is large (the human strongly suspects every empty log of hiding a failure), the honest policy produces an empty post-driver log that looks like a hidden failure to the suspicious human. RLHF then prefers the wasteful , which attempts CUDA only to produce an unambiguous log that produces an open failure. The agent pays real reward to prove its honesty: this is overjustification (Lang et al. 2024, Section 4).

The bigger picture. The CUDA example is small, but the phenomenon is general: any alignment-by-feedback method (RLHF, RLAIF, constitutional methods, ...) grades the agent by whatever the evaluator can tell, not by what is true. Partial observability is one cause of that gap, but limits on expertise, attention, or time produce the same trap. This is the motivation for proposals like AI safety via debate (which we discussed yesterday): two AIs argue in front of a human judge, each pointing out flaws in the other, in the hope that the judge reaches a correct conclusion they could not reach unaided. Whether debate actually escapes the trap remains open; the point is that any feedback-based method has to confront the gap between "what the human can tell" and "what is true."

Learn more

Here we list further readings, which are largely papers mentioned in Leon’s lecture slides.

References

Leon Lang, Davis Foote, Stuart Russell, Anca Dragan, Erik Jenner, and Scott Emmons (2024). When Your AIs Deceive You: Challenges of Partial Observability in Reinforcement Learning from Human Feedback. Advances in Neural Information Processing Systems.