Iliad

Agent Foundations

Superintelligence alignment may allow only one critical try, with no trial and error on a system more capable than anything yet observed. Agent foundations seeks research directions that survive extreme optimization and self-modification.

By Daniel C, Satya Benson (Williams College)

1. Prerequisites

  • Comfort with elementary discrete probability (random variables, expectation, conditional probability).
  • Basic formal logic (provability, quantifiers) and basic computability (programs, halting); needed for the Löb and logical-induction strands.
  • Basic information theory (entropy, mutual information); needed for the optimization strand.
  • No prior agent-foundations background is assumed; every term used on the day is introduced on the day or in the readings. An introductory overview of the AI alignment problem (as in the intro-alignment module) is helpful context but not required.
  • Provided refresher notes cover the gaps: a probability theory refresher, a formal logic refresher, a computability theory refresher, and an information theory, causality, and statistical mechanics refresher. Point students at the one matching their weakest area before the day.
What you’ll learn

(What.) By the end of the day, students can explain embedded agency: why an agent built into the world it acts on (made of the same stuff, smaller than its environment, with no clean input/output boundary, able to model and modify itself) breaks the standard dualistic picture. For each of the day's core research directions (called 'strands') they can state the central problem and a plain-language description of a main result: the complete class theorem (consequentialist foundations), Löb's theorem and the tiling obstacle (self-modification), the logical-induction criterion (logical uncertainty), optimization as local entropy reduction (optimization and thermodynamics), and selection theorems (descriptive agent foundations). They can describe at last one strand in mathematical detail. They can explain how each strand is an offshoot of the central threads reflective stability and embedded agency.

(Why.) Aligning a superintelligence is a problem we may have to get right on the first critical try, reasoning about a system more capable than anything we have observed, before it exists. That rules out pure trial and error and demands concepts that stay meaningful under extreme optimization pressure and self-modification. Agent foundations supplies (or tries to supply) those concepts, and this day gives students a map of some main research directions and how they fit together.

(How.) Each student goes deep on one pre-reading track beforehand. A one-hour morning lecture lays out the main threads (reflective stability and embedded agency) and previews every strand. Students then read the shared fundamental readings and, in small groups mixing different tracks, run cross-pollination discussions that connect their topics to embedded agency. The afternoon makes a few results rigorous through exercises.

2. Content

Exercise sheet: Section 3 below, with worked solutions. The lecture deck is built from this module's own slides.tex and linked at the top of the page.

2.1 Fast-track

To get the core in about an hour, or to catch up after missing the day:

  • Read the "Morning lecture" summary below for the unifying spine (reflective stability, embedded agency, the modelling-vs-implementation split).
  • Read Embedded agency up to and including section 3.3, then section 4.1, and Why agent foundations in full.
  • Pick the one strand closest to your background from "The five strands" below and read its first (most conceptual) listed reading.
  • Skim the takeaways at the end of each strand summary.

2.2 Main content

Agent foundations is not one theory but several research strands (research directions), each attacking a different facet of the same problem: how to reason about, and build, stable agents that are embedded in the world they act on. This day is organized around five such strands (consequentialist foundations; Löb's theorem and tiling agents; logical induction; optimization and thermodynamics; descriptive agent foundations). Each student pre-reads one strand in depth before the day; the morning lecture supplies the spine that connects them; the shared fundamental readings and a small-group discussion knit them into a single picture; and an exercise session makes a few of the results rigorous.

Read top to bottom, this section runs: the unifying threads (the morning lecture), then the fundamental readings that give a bird's-eye view, then the five strands each with its readings, then the cross-pollination discussion, the exercises, and a self-check.

2.2.1 Morning lecture

  • Why agent foundations. We may need key safety properties to hold on the first critical try, for an agent far more capable than any we can study directly. Agent foundations looks for the properties capable agents share in general, so we can reason about them in advance.
  • Reflective stability. A safety property only matters if it survives the agent's own self-modification: a capable agent may rewrite its code, build a more capable successor, or revise its world model. A property is reflectively stable if it is invariant under all of these. Working assumption: under enough optimization pressure, a property persists only if there is some reason it must. Reflective stability is the thread running through every strand.
  • Robust concepts ("true names"). Goodhart's law says a proxy that becomes a target stops measuring what we want. So a theory of agency must be built from concepts that do not break under optimization, the "true names" of optimization, goals, world models, and embeddedness.
  • Two pathways of impact (following C. Wyeth). Modelling: build an abstract mathematical model of an idealised capable agent and use it to show why a given alignment proposal would fail. Implementation: develop a theory far enough to build and inspect an actual system, often favouring a modular architecture (a separate, inspectable world model, planner, and goal) so each part can be checked.
  • Dualistic vs embedded agents. The standard picture (an agent with clean I/O, "larger than" and "outside" its environment, holding a full world model in its head) is dualistic. A real agent is embedded: part of the world, made of the same pieces, smaller than its environment, with no crisp boundary, and able to be copied, modified, or to model itself. Embeddedness is what makes self-improvement, multi-agent reasoning about copies, and self-reference unavoidable, and it is what the rest of the day is about.

2.2.2 Fundamental reading

  • Embedded agency: read up to and including section 3.3, then section 4.1. The canonical statement of the embedded-agency problem cluster (the Alexei/Emmy framing the lecture uses).
  • Why agent foundations: read entirely. Why this abstract, theory-first approach is worth pursuing.
  • Reflectively consistent degree of freedom: read entirely. The precise notion behind a property an agent would not self-modify away, which is the day's recurring theme of reflective stability.
  • General purpose search: read entirely. Why a capable mind plausibly contains a retargetable search process.

2.2.3 The five strands (pre-reading tracks)

The five strands are different facets of one problem, embedded agency; each student pre-reads one. Every summary below is self-contained at the conceptual level and ends with that strand's readings (start with the first listed, which is the most conceptual). The morning lecture previews all five; the cross-pollination discussion connects them.

1. Consequentialist foundations. If an agent's preferences are cyclic, an adversary can money-pump it through trades that each look acceptable but leave it strictly worse off. So any agent that reliably avoids such dominated strategies behaves as if it maximizes a utility function. The complete class theorem sharpens this: any decision rule that is not dominated (Pareto-optimal across environments) is Bayes-optimal under some prior with full support. This is representational, not mechanistic: it says a capable, non-self-defeating agent looks like a Bayesian expected-utility maximizer from the outside, without saying it has a utility function inside, and without telling us which utility function (the hard part). Takeaway: coherence gives a reflectively-stable target (a dominated strategy is one a rational agent would self-modify away from), but it under-determines the agent's actual goals. Readings: Coherent decisions imply consistent utilities (Introduction; "Why not circular preferences?"; "Probabilities and expected utilities" through "Conditional probability"; Conclusion); The measuring stick of utility; Complete class: consequentialist foundations.

2. Löb's theorem and tiling agents. A capable agent may build a successor more capable than itself. By Vingean reflection, it cannot verify the successor by simulating it (if it could predict the successor's exact moves, it would be that capable already), so it must reason abstractly about the successor's design. The natural strategy ("trust the successor because it only takes actions it has proved safe") needs the parent to trust the successor's proofs. Löb's theorem blocks this: if a consistent system L can prove "if L proves C then C", then L already proves C. A consistent system cannot vouch for its own proofs in the abstract, only for a strictly weaker system's. So a naive chain of self-improvements uses an ever-weaker proof system (a "telomere" of logical strength that runs out), the finite descent problem. The tiling-agents programme studies whether this obstacle can be overcome. Takeaway: self-trust under self-modification is not free; it runs straight into a logical wall. Readings: Introduction to Löb's theorem (up to and including section 3); Vingean reflection; Walkthrough of the tiling agents paper (start through "Finite Descent Problem", then "What self-modifying agents need").

3. Logical induction. Standard Bayesian reasoning assumes logical omniscience: the agent instantly knows all consequences of its beliefs. A bounded agent cannot (it may know a program's source yet not its output, or the axioms yet not whether a number is prime). Logical induction (Garrabrant et al.) handles this by picturing a market that prices logical sentences in [0,1]; the logical-induction criterion requires only that no efficient (polynomial-time) trader can exploit the market for unbounded profit, a computable weakening of the Dutch-book argument. That single condition yields convergence and coherence in the limit, timely learning of statistical patterns (it prices "the nth digit of pi is 7" near 1/10 without computing it), and self-trust (current credence equals a weighted average of expected future credences). Takeaway: a principled model of how a bounded agent should hold probabilities over facts it has not yet computed. Readings: An intuitive guide to Garrabrant induction; Logical induction (chapters 1 and 3; skim chapter 4).

4. Optimization and thermodynamics. A powerful agent reliably steers the world into a narrow region of outcomes, ones extremely unlikely under any random process. This is local entropy reduction: concentrating probability mass from a broad initial distribution onto a narrow target. Even a pure predictor has an objective reason to attend to optimizers: naming what an optimizer steers toward predicts the outcome cheaply and robustly, where modelling the initial conditions would be expensive and chaos-fragile. Steering is bounded by information: the Touchette-Lloyd inequality says the entropy reduction a sighted agent achieves over a blind baseline is at most the mutual information between its observations and actions (). Algorithmic thermodynamics (Ebtekar and Hutter) replaces ensemble entropy with Kolmogorov complexity, giving laws for individual states and making an embedded agent's knowledge an endogenous physical quantity (algorithmic mutual information between memory and environment), which is exactly its budget for optimization. Takeaway: optimization is physically constrained, and "knowing more" formally means "being able to optimize more." Readings: the self-contained note Optimization and thermodynamics (read entirely; appendix optional) is the primary reading; its underlying sources are The ground of optimization (up to and including "Relationship to Garrabrant and Demski's Embedded Agency"), Generalized heat engine, and Algorithmic thermodynamics and three types of optimization.

5. Descriptive agent foundations. Normative agent foundations asks what an ideal agent should look like; descriptive asks what agents actually arising in the world (bacteria, neural networks, future AI) look like, and aims to read off their goals, world model, and decision structure from the outside. It works bottom-up from properties of the world (modularity, selection pressures, computational limits). Selection theorems aim to prove results of the form "any system selected to achieve goal G in environment E must contain structure approximately isomorphic to X", giving mechanistic rather than merely representational accounts of agency. A key example: the world's modularity (it decomposes into sparsely-interacting subsystems) is what makes both world-modelling (Bayesian networks propagate updates locally) and planning (general-purpose search can pursue decoupled subgoals) tractable. Takeaway: the complementary direction to coherence: not "non-dominated agents can be described as maximizers" but "what pressures make agent-like structure actually arise." Readings: Selection theorems: a program for understanding agents; How we picture Bayesian agents; What selection theorems do we expect/want.

2.2.4 Cross-pollination discussion

On the day, students who pre-read different strands meet in small mixed groups and work to connect their topics into one picture of embedded agency: how a logical inductor's trust in its future self relates to a tiling agent's trust in its successor, how the coherence account of goals relates to the thermodynamic one, how the representational view of agency (coherence) relates to the mechanistic one (selection theorems). The specific discussion prompts used are listed in the teaching guide.

2.2.5 Exercise session

Five exercises (full statements and worked solutions in Section 3), grouped by topic:

Logical uncertainty and self-reference.

  • Exercise 1: Gödel's second incompleteness theorem (difficulty 4/5, importance 4/5). Via a self-referential program: a Gödel sentence is true, a consistent system cannot prove its own consistency, and this is exactly the Löbian obstacle to self-trust. Parts (a) true Gödel sentence, (b) no self-consistency proof, (c) the obstacle.
  • Exercise 2: Löb's theorem (difficulty 3/5, importance 5/5). The three provability properties (necessitation, distribution, the Löb condition), a full proof of the theorem, and an application: FairBot programs cooperate by Löb's theorem. Parts (a-b) properties, (c-d) the proof, (e) FairBot.

Coherence and consequentialism.

  • Exercise 3: The complete class theorem (difficulty 3/5, importance 5/5). The equivalence between non-dominated strategies and Bayesian expected-utility maximization, via a geometric argument over the convex set of attainable reward vectors. Parts (a) admissibility, (b) faces and difference vectors, (c) constructing the rationalizing prior.

Descriptive agent foundations.

  • Exercise 4: The do-divergence theorem (difficulty 2/5, importance 4/5). Formalizes optimization as outcome concentration and proves that how far an agent can steer outcomes (a KL divergence from the unsteered baseline) is bounded by the mutual information between its observations and actions. The single-step backbone of the Touchette-Lloyd picture.
  • Exercise 5: Channel additivity (difficulty 3/5, importance 3/5). Optimal input distributions over independent channels: mutual information decomposes across channels, independence improves throughput, and an optimal policy need not coordinate across a modular environment (connecting modularity to tractable optimization).

2.3 Learn more

The readings for each strand are linked under that strand in the Main content above. Beyond them:

Algorithmic thermodynamics (Ebtekar). Foundations of algorithmic thermodynamics; Modelling the arrows of time with causal multibaker maps; Long-time derivation of the Boltzmann equation from hard-sphere dynamics.

Embedded and universal AI (Wyeth). Limit-computable grains of truth; Embeddedness failures in universal artificial intelligence; Value under ignorance.

Other directions. Introduction to the infra-Bayesianism sequence (non-realizable environments); The learning-theoretic agenda; Optimization at a distance; the hard problem of corrigibility and a critique of the corrigibility basin of attraction; the original tiling agents draft; and background notes on admissibility and the complete class theorem and the Dutch book argument.

Research frontier. The agent structure problem (whether strong optimization provably entails an internal world model), embedded variants of AIXI, and resource-theoretic accounts of instrumental convergence.

3. Exercises

The following are exercises on agent foundations. Each problem is broken into a sequence of lemmas leading to a main theorem. For each subquestion, try to prove the stated lemma before reading on. If you get stuck, you may treat the lemma as given and proceed to the next part.

Before diving into a formal derivation, try to build an intuition for why the statement should be true. Even if you don't complete the proof, having a clear intuitive picture of what's going on is more valuable than a mechanical derivation you don't understand. Don't worry if some of the terminology is unfamiliar — the exercises are designed to be self-contained, and it should be possible to follow the questions from context.

Formal systems and programs. A formal system is a precise set of rules for deriving mathematical statements from axioms. Fix a formal system that is powerful enough to reason about programs (for instance, it can express statements about arithmetic, and any program can be encoded as a mathematical object that can talk about). We write to mean that the statement is provable in , i.e. there exists a finite sequence of steps, each justified by the rules of , that derives .

We say is consistent if it never proves a contradiction. We write for a fixed contradictory statement (such as ), so consistency means . We assume throughout that is consistent.

Programs. By a program we mean a mechanical procedure that follows a fixed list of instructions. A program may halt (finish and produce an output) or run forever (keep executing without ever stopping). Since can reason about programs, it can express the statement "program halts", which we write as .

The bridge between and programs. Formal systems and programs are intimately connected, and the key to these exercises is switching back and forth between the two perspectives:

  • From programs to (concrete outputs become proofs). If a program concretely produces an output (e.g. it halts after some number of steps, or it finds a string with a certain property), then can verify this by tracing through the execution step by step. In particular: if a program actually halts, then can prove that it halts.
  • From to programs (proofs can be found by search). Proofs in are finite strings that can be checked mechanically. So for any statement , we can write a program that searches through all possible strings, checks whether each one is a valid -proof of , and halts if it finds one:

This program halts if and only if is provable in .

Whenever you derive a fact about (e.g. that some statement is or isn't provable), ask what that implies for the corresponding proof-search program, and vice versa.

The provability predicate . We write for the statement, expressed within itself, that " is provable in ." This is a genuine mathematical statement that can reason about, because it is equivalent to the claim that halts, and can talk about programs.

The crucial distinction is between and :

  • means that is provable: there exists a concrete proof of in . This is a fact about that we observe from the outside.
  • means that has proved a statement about itself: namely, that a proof of exists (equivalently, that halts). But this is a claim is making about the program, not a direct certificate for .

Intuition. To see why and are conceptually distinct, consider the two different ways might prove that halts. The first is to actually trace through its execution: if it halts after, say, a million steps, can verify this step by step, and the proof that found along the way is itself a direct -proof of . In this case, and seems to come hand in hand. But there is a second way: might reason abstractly about the program's behaviour without ever simulating it. (This is analogous to how you might argue that a sorting algorithm must eventually finish without tracing through every swap it makes.) Such a proof establishes that halts — and therefore that some proof of exists — but the proof itself is about the program, not about . It need not contain, or even hint at, what the actual proof of looks like. This is the gap that cannot close in general: knowing abstractly that a proof is "out there" is not the same as having the proof in hand.

What "provable in " means (and what it does not). It is important to distinguish between being convinced that something is true and proving it in . When we say " can carry out this argument" or " proves ," we do not mean that a reasonable person reading the argument would find it convincing. We mean something much more specific: that there exists a sequence of formulas, each of which is either an axiom of or follows from earlier formulas by one of 's explicitly listed inference rules, and whose last line is . The formal system is a machine: it has no understanding, no intuition, and no ability to say "well, this obviously follows." Every single step must be justified by a specific rule.

From the outside, we can see that if halts then a proof of exists, so is provable. But can carry out this reasoning internally, always concluding from ? Lob's theorem (Exercise 2) shows that the answer is no: any consistent that derives from for all is in fact inconsistent.

Exercise 3.1 (Godel's second incompleteness theorem). Key fact. If a program actually halts (say, after 17 steps), then can verify this by checking the execution step by step, so . However, if runs forever, cannot necessarily prove . (Informally: it is easy to certify that something stops, because you just exhibit the stopping point; but certifying that something runs forever is much harder, because you cannot check infinitely many steps.)

In fact, no consistent formal system can correctly settle the question "does halt?" for every program . To see why: if could do this, we could write a program that, given any , searches for an -proof of either or . Since is assumed to settle every case, this search would always find a proof and halt, giving us a mechanical procedure that decides whether any program halts. But such a procedure cannot exist (this is the undecidability of the halting problem, a fundamental result in computer science that we take as given here).

A self-referencing program. It is possible to write programs that refer to their own source code. (As a simple example, a program can carry its own source code as a string and then operate on it.) Using this idea, define the following program:

Here means "run program with its own source code as input." So searches for a proof that the program -run-on-itself runs forever.

Now consider feeding its own source code. The program searches for an -proof that runs forever. Define the statement:

In words: says " runs forever." Notice the self-referential structure: halts if and only if it finds an -proof of (i.e. a proof that runs forever).

Part 1(a). Show that is true, assuming is consistent.

Hint: Consider two cases. Either halts or it doesn't. In each case, use the bridge between programs and (if a program halts, can prove it; if proves something, the corresponding proof-search program finds that proof and halts) to derive what follows. One of the two cases leads to a contradiction with the consistency of .

Part 1(b). Show that if can prove its own consistency (i.e. ), then is in fact inconsistent.

Hint: In Part 1(a), you argued from outside that is true, and the argument used only one assumption about : that is consistent. If can prove its own consistency, then every step of your outside argument can be carried out inside as a formal derivation. What would then be able to prove? And what would the corresponding program do?

Part 1(c). Suppose can vouch for all of its own proofs, meaning for every statement . (Read this as: "whenever can prove , then is actually true," and itself asserts this.) Show that is inconsistent, in two steps:

(i) First, show that proves it never proves anything false. That is: for any with , show that . Hint: The statement "if then " is logically equivalent to "if not then not ". Apply this to .

(ii) Apply (i) with , using the fact that ("a contradiction is false") is a tautology. Conclude that , and use Part 1(b) to finish.

Remark (Self-trust, tiling agents, and the Lobian obstacle).

Any sufficiently advanced AI may eventually be able to modify its own code or build a successor system more capable than itself. But this raises a subtle problem. If the successor is genuinely smarter, the original agent cannot predict exactly what it will do — just as the programmers of a chess engine can reason that their program is "trying to win" without knowing its exact moves. So the original agent cannot verify its successor's safety by simulating it move by move. Instead, it must reason abstractly about the successor's design: "whatever my successor does, it will only take actions that it has proved lead to good outcomes."

This reasoning strategy is called tiling: the parent agent builds a child agent , and wants to conclude not merely that will only take actions that has proved to be safe, but that those actions actually are safe. After all, can verify from 's source code that says "only take action if I can prove that leads to good outcomes." But this only tells that acts on what 's proof system certifies — it does not yet tell that what 's proof system certifies is actually true. To close this gap, needs to be able to prove, within its own reasoning, that 's proof system is sound: whenever 's system proves , then is actually true. When both agents use the same formal system , this amounts to for all .

Part 1(c) shows this is impossible: any consistent system that asserts for all is already inconsistent. A consistent system cannot vouch for its own proofs in the abstract — it can only trust a proof once it has witnessed it directly. This is the Lobian obstacle: the barrier created by Lob's theorem to self-trusting formal reasoning.

One might hope to work around this by having the parent use a stronger proof system than the child: a stronger system can trust a weaker one's proofs. But this means each successive agent in a chain of self-improvements must use a strictly weaker proof system than its predecessor, resulting in a "telomere" of logical strength that shortens with each generation. Eventually the chain runs out of trust. The tiling agents research programme studies how (and whether) this obstacle can be overcome, seeking agent architectures that can undergo indefinite self-improvement without their reasoning guarantees degrading at each step.

Solution

Recall searches for an -proof of and halts if it finds one, and

By construction searches for an -proof of , so

Part 1(a). is true (assuming consistent).

Solution. Two cases.

  • halts. By (), , i.e. . But actually halts, so by the bridge . Then proves both and its negation, contradicting consistency.
  • runs forever. Then , i.e. , is true.

Consistency rules out the first case, so runs forever and is true.

Part 1(b). If (i.e. proves its own consistency) then is inconsistent.

Solution. The argument of 1(a) used only the consistency of , and each step is a finite manipulation of programs and proofs that can formalize. Reading it inside : " halts" yields (by construction) and (the bridge), hence ; contrapositively . If , modus ponens gives

But means 's search finds a proof of , so halts; by the bridge . Now proves both and , so is inconsistent.

Part 1(c). If for every , then is inconsistent.

Solution. (i) Fix with . The contrapositive of is , so from we get . With , modus ponens gives .

(ii) Take . Since is a tautology, , so by (i) . Thus proves its own consistency, and Part 1(b) makes inconsistent.

Exercise 3.2 (Lob's theorem). Lob's theorem says: if (i.e. can prove "if is provable then is true"), then (i.e. is already provable in ). In other words, the only statements for which can close the gap between "provably provable" and "provable" are the ones that were already provable to begin with.

The proof uses three properties of the provability predicate . We state them here together with informal explanations of what they say about the proof-search program .

(N)Necessitation.If then .
(K)Distribution..
(4)Lob condition..

Part 2(a). Understanding Necessitation. Necessitation says: if is provable in , then can prove that is provable. Explain why this is true from the perspective of .

Hint: If a proof of exists, then will find it and halt.

Part 2(b). Understanding Distribution. It is helpful to think of a proof of by analogy with a function: given any proof of as input, one can mechanically produce a proof of as output (by writing down the proof of , attaching the proof of , and applying the logical rule that from and one may conclude ).

With this analogy, says that has proved such a "proof-transforming function" exists. Distribution then says: if knows that a function from -proofs to -proofs exists, and knows that a -proof exists, then can conclude that a -proof exists.

Explain why Distribution is true from the perspective of .

Hint: If both and halt, what can you do with their outputs? How can deduce that halts?

We now prove Lob's theorem. The key ingredient is a self-referential sentence constructed using the same idea as in Exercise 1 (a sentence that talks about its own provability). Specifically, there exists a sentence such that

In words: says "if I am provable, then is true." (The existence of such a sentence is guaranteed by the same self-referential construction used to build in Exercise 1; we take it as given here.)

Part 2(c). Show that .

Hint: The Lob sentence says . Apply Necessitation to get this fact inside a , then use Distribution twice (once to "unwrap" the outer implication, once to handle inside). Use the Lob condition to handle the resulting .

Part 2(d). Now assume . Using Part 2(c) and the Lob sentence, derive .

Hint: From Part 2(c), you have . Chain this with the assumption to get . Now compare this with what says about itself.

Remark (The Santa Claus paradox and what Lob adds beyond Godel).

The Lobian sentence is a formal analogue of the Santa Claus sentence (also known as Curry's paradox). Consider the sentence : "If this sentence is true, then Santa Claus exists." Let us try to determine whether is true or false.

Well, is an "if ... then ..." statement, so to check whether it is true, let us assume the "if" part and see whether the "then" part follows. So assume is true. Since says "if is true then Santa Claus exists," and we are assuming is true, it follows that Santa Claus exists. We have therefore shown: if is true, then Santa Claus exists. But that is exactly what says! So is true. And since is true and implies Santa Claus exists, Santa Claus exists. Since nothing about this argument was specific to Santa Claus, the same reasoning "proves" any statement whatsoever.

The reason does not fall prey to this paradox is that cannot form a sentence that refers to its own truth. (A fundamental result called Tarski's theorem shows that no sufficiently powerful formal system can define a truth predicate for itself.) What can do is refer to its own provability: the predicate is a legitimate statement within . The Lobian sentence therefore substitutes "provable" for "true," asserting "if I am provable, then ." The proof of Lob's theorem shows that this substitution is enough to force — but only when is already assumed, not unconditionally.

This mirrors a pattern: replacing "true" with "provable" transforms semantic paradoxes into precise theorems. The liar's paradox ("this sentence is false") becomes Godel's sentence ("this sentence is not provable"), yielding the incompleteness theorems. The Santa Claus paradox ("if this sentence is true, then ") becomes the Lobian sentence ("if this sentence is provable, then "), yielding Lob's theorem.

What Lob adds beyond Godel. Godel's second incompleteness theorem (Exercise 1) says that cannot prove its own consistency. This is already a serious obstacle, but one might hope that consistency is a special case — perhaps can still trust its proofs in less sweeping ways. Lob's theorem crushes this hope completely. It says that for any statement , if can prove "my provability of implies is true" (i.e. ), then was already provable. There are no statements, not for which can assert "well, if I could prove this, it would be true" without already being able to prove them. does not trust its own proofs until it has witnessed them directly.

This is what makes Lob's theorem, rather than Godel's, the fundamental obstacle for tiling agents. Recall the setup from Exercise 1: a parent agent builds a child that only takes actions it can prove to be safe. For to trust , it needs to know that 's proofs track reality — that is, needs for the statements that might act on. Godel tells us cannot prove 's system is consistent. But Lob tells us something far stronger: cannot even trust 's system on a case-by-case basis. For any individual statement , the only way can derive "if my proof system proves , then is really true" is if was already provable — in which case the trust was never needed in the first place.

Part 2(e). In a one-shot Prisoner's Dilemma, two players each choose to either cooperate () or defect (). In this variant, instead of choosing directly, each player submits a program that receives the opponent's source code as input and outputs or . Consider the following agent, FairBot:

algorithm :
Search for an -proof that .
if proof found then return
else return

In words: FairBot cooperates with an opponent if and only if it can find an -proof that the opponent cooperates with FairBot. Note that FairBot is unexploitable: if is sound (i.e. only proves true statements), then FairBot never cooperates with an opponent that defects against it.

The interesting question is what happens when FairBot plays against itself. At first glance, both mutual cooperation and mutual defection seem like stable outcomes.

Consider two copies and (identical programs with different implementations). Let be the statement "" and be the statement "." Prove that , i.e. that the two FairBots mutually cooperate. Use Lob's theorem.

Hint: From FairBot's source code, implies that finds a proof that cooperates, so cooperates, i.e. is true. Similarly implies . Combine these to show , and apply Lob's theorem.

Solution

We use Necessitation (N) , Distribution (K) , and the Lob condition (4) .

Part 2(a). Necessitation. If there is a concrete proof of ; searching all strings, meets it and halts. " halts" is exactly , and a halting run is finite, so by the bridge .

Part 2(b). Distribution. A proof of turns a proof of into one of (concatenate the two proofs and apply modus ponens). So if and both halt, their outputs combine into a proof of , whence halts. This combining is a finite procedure can carry out, so .

The Lob sentence satisfies .

Part 2(c). .

Solution. From :

and chaining the last two, . By (4), . Propositionally, from we obtain and then , so .

Part 2(d). Assuming , derive .

Solution. Chaining (2(c)) with gives . The Lob equivalence gives the converse direction , so . By (N), ; with , modus ponens yields .

Part 2(e). FairBot. With "" and "", show .

Solution. From the source code, returns iff it finds an -proof that its opponent returns against it, i.e. a proof of ; reading this off the code,

For any , whenever is a tautology: indeed (N) gives and (K) then gives . Applying this to and ,

Hence, assuming : we get and , then (from ) and (from ), so . Thus

and Lob's theorem with gives .

Exercise 3.3 (The Complete Class Theorem). The setup: decision-making under uncertainty. Imagine you must choose an action, but you don't know which environment you are in. There are finitely many actions and finitely many possible environments . If you take action and the true environment turns out to be , you receive a reward .

Example. You are deciding whether to carry an umbrella () or not (). The environment is either "rainy" () or "sunny" (). The rewards might be:

Decision rules. A decision rule is a (possibly randomized) strategy: you play action with probability , where and . A pure decision rule puts all its weight on a single action (e.g. "always carry the umbrella"). A mixed rule randomizes (e.g. "carry the umbrella with probability ").

The reward of in environment is the average reward under the randomization:

Risk vectors and the risk set. To compare decision rules across all environments simultaneously, we package the rewards into a single vector. The risk vector of a decision rule is

Each coordinate records how well performs in one environment. In the umbrella example, and .

The risk set is the set of all risk vectors achievable by some decision rule:

Geometrically, is the convex hull of the pure-action risk vectors : the set of all weighted averages of these points.

Admissibility (not being dominated). A decision rule is admissible if there is no other rule that does at least as well as in every environment and strictly better in at least one. If such a exists, we say dominates , and any rational agent should prefer — after all, switching from to never hurts and sometimes helps, regardless of which environment is the true one.

The Pareto frontier is the set of risk vectors of all admissible decision rules. A pure action is Pareto-optimal if .

Bayesian expected utility. A different approach to decision-making is to assign a prior representing your beliefs about how likely each environment is, where and . (For example, means you believe there is a chance of rain.) The expected utility of under is the weighted average reward:

A decision rule is Bayes-optimal under if it achieves the highest expected utility among all decision rules: for all .

The theorem. These two approaches to rational decision-making — admissibility ("never use a dominated strategy") and Bayesian expected utility maximization ("assign beliefs and maximize average reward") — turn out to characterize exactly the same set of decision rules:

Theorem (Complete Class). Every admissible decision rule is Bayes-optimal under some prior with for all . Conversely, every Bayes-optimal rule under such a prior is admissible.

In other words: the decision rules that survive the "no domination" criterion are precisely those that arise from maximizing expected utility under some set of beliefs that doesn't rule out any environment entirely. This is significant because admissibility is an extremely weak rationality requirement — it says only that you shouldn't use a strategy when a strictly better one is available — yet it already forces expected utility maximization.

Part 3(a). Show the following two facts:

(i) Any admissible decision rule places zero weight on dominated pure actions: whenever is not Pareto-optimal. (In other words, the Pareto frontier is contained in the convex hull of the Pareto-optimal pure actions alone.) Hint: If places positive weight on a dominated pure action , replace with the action that dominates it. Does the resulting rule dominate ?

(ii) Every Bayes-optimal rule under a prior with for all is admissible. Hint: If some dominated , compare their expected utilities. What does ensure?

Part 3(b). A face of the Pareto frontier is a maximal convex subset of of the form

for some subset of Pareto-optimal pure actions . Define the difference vectors for , and let . Show that consists precisely of the directions along which one can move within : that is, if , then for some only if .

Part 3(c). Let be a vector perpendicular to the subspace from Part 3(b), normalized so that for all and . You may assume that the entire risk set lies on one side of the hyperplane defined by (i.e. no point in scores strictly higher under than the points on ). Show that:

(i) takes the same value for all with .

(ii) Every rule on the face is Bayes-optimal under .

Conclude the Complete Class Theorem: every admissible rule lies on some face of , and the prior constructed from that face makes it Bayes-optimal.

Solution

Higher reward is better; dominates if coordinatewise with strict inequality in some coordinate. is linear in the mixing weights, , and .

Part 3(a)(i). An admissible puts on every non-Pareto-optimal (dominated) .

Solution. Suppose for a dominated , and let dominate it: with strict inequality in some coordinate . Replace the weight on by , i.e. play with the probability formerly on . This is a valid rule with

and strict in coordinate (since ). So dominates , contradicting admissibility. Hence , i.e. .

Part 3(a)(ii). Every Bayes-optimal rule under a prior with for all is admissible.

Solution. If dominated such a , then with ,

since every term is and the term is . This contradicts Bayes-optimality, so is admissible.

Part 3(b). For a face with and : is exactly the set of directions tangent to .

Solution. Any point of equals , so . Take , say and with . Then

using to eliminate the term. Hence moving within requires . Conversely, from any relative-interior point () every is realized: for small . So the tangent directions of are precisely .

Part 3(c). Let be normalized so and , and assume no point of scores strictly higher under than the points of .

Solution. (i) For we have by 3(b), so . Thus equals a common value for all with .

(ii) Picture as the outward normal of the supporting hyperplane : by assumption the whole risk set lies on the inner side, for all , touching the hyperplane exactly along the face . Fix any (so ) and any other rule . The step from the face point to heads back into the risk set, i.e. against the outward normal, so its dot product with is non-positive:

Since this holds for every , each rule with maximizes expected utility, i.e. is Bayes-optimal under .

Conclusion. If is admissible then lies on some face ; the prior built from has all and, by (ii), makes Bayes-optimal. Conversely, by 3(a)(ii) every Bayes-optimal rule under a strictly positive prior is admissible. The two classes coincide.

Exercise 3.4 (The Do-Divergence Theorem). Motivation: optimization as steering. A useful way to think about what it means for an agent to be optimizing is that it reliably steers the world into a narrow set of outcomes — outcomes that would be extremely unlikely to arise out of any random process . A thermostat keeps a room at 20 ∘ C despite varying weather; a chess player steers toward checkmate despite the opponent's moves. In each case, the actual outcome is concentrated in a small region of possibility space, whereas without the agent's intervention, outcomes would be spread broadly.

This exercise makes that intuition precise in an information-theoretic setting. We will show that an agent's ability to concentrate outcomes ("steer") is bounded by the amount of information the agent extracts from its observations.

Background: KL divergence. Given two probability distributions and over the same set of outcomes, the Kullback–Leibler (KL) divergence from to is

This quantity is always , and equals only when . It measures how "different" is from , with a particular asymmetry: is large when places significant probability on outcomes where assigns very little. In other words, it is large precisely when concentrates on outcomes that would be surprising under . This can be seen as a signature of optimization: the agent's policy makes certain outcomes likely that would be very unlikely under a baseline policy.

Background: mutual information. The mutual information between two random variables and is

This measures how much knowing tells you about (and vice versa). It is zero when and are independent, and large when they are tightly coupled.

Setup. Consider an agent (the "demon") that observes some information about the world and then takes an action based on what it observed. The action and observation together produce an outcome . The joint distribution is

The factor encodes the demon's policy: how it chooses actions as a function of its observations.

Now consider a blind baseline: the demon still acts, but ignores its observations, choosing actions independently of . We write the blind baseline distribution as

The notation means we have "intervened" on the action, replacing the demon's observation-dependent policy with the marginal (the overall frequency of each action, ignoring which observations prompted them). The mechanism by which actions and observations produce outcomes is unchanged — only the demon's strategy has been lobotomized.

The theorem. Prove the Do-Divergence Theorem:

The left side measures how much the sighted demon's outcome distribution differs from the blind baseline's. In the language of steering: it measures how much the demon has concentrated outcomes into regions that would be unlikely without observation-dependent action. The right side is the mutual information between actions and observations — how much the demon's actions depend on what it sees. The theorem says that the degree of steering is bounded by the information the demon uses.

Useful fact:

  • Monotonicity of KL divergence. For any two joint distributions and , marginalizing out can only decrease KL divergence: . (Intuitively: forgetting information can only make two distributions look more similar, never less.)

Hint: Compute by expanding the log ratio using the factorizations above

Remark (Maxwell's demon and the thermodynamics of optimization).

Maxwell's demon is a thought experiment in which a tiny intelligent being controls a door between two halves of a box of gas. By observing each molecule's position and selectively opening the door, the demon can sort all molecules to one side, creating a highly ordered (low-entropy) state from an initially disordered one. In our notation: the outcome is the final configuration of molecules, the observations are the demon's measurements of molecular positions, and the actions are its door openings.

Under the blind baseline (opening the door at random), molecules are roughly equally likely to be on either side, so is spread broadly. If the demon perfectly sorts all molecules to the right, is concentrated on a single configuration, and the KL divergence between these distributions is (i.e. bits). The theorem therefore says that perfectly sorting molecules requires bits: the demon must gather at least bits of information about the molecules to reduce the gas's entropy by bits. This illustrates the idea that any agent that steers a system into a narrow, unlikely region of outcome space (low entropy) must pay for this steering with mutual information.

Solution

Write and the blind baseline .

Claim. .

Solution. Compute the divergence between the full joints. The factors and cancel in the log-ratio:

The summand depends only on ; marginalizing and using ,

Marginalizing the two joints down to sends them to and respectively, so monotonicity of KL under marginalization gives

Exercise 3.5 (Channel Additivity). Consider two independent channels and with a fixed joint channel

That is, output depends only on input , and depends only on ; the two channels do not interact. We are free to choose the input distribution (which may correlate and ), and the joint distribution over everything is then . The goal is to maximize the mutual information , called the information throughput of the channel.

Part 5(a). Show that for any input distribution ,

Hint: Write each mutual information as a KL divergence between the joint and the product of marginals, expand the log ratios using the channel factorization, and collect terms.

Part 5(b). Given any input distribution , define

i.e. the product of the marginals. Show that .

Hint: Under , the inputs are independent. What happens to when , given the channel factorization? Use Part 5(a).

Part 5(c). Use Part 5(b) to conclude that there always exists a throughput-maximizing input distribution under which .

Remark. This result has a natural interpretation in terms of optimization and agency. Think of as the actions of an agent and as the outcomes it cares about. The channel — how actions influence outcomes — is fixed by the environment and outside the agent's control; the agent only gets to choose its policy . The factorization condition on says that the environment is modular: the two groups of outcomes and are each influenced only by their respective actions and . Our theorem says that if the environment is modular in this sense, then the agent can always find an optimal policy that is modular in a corresponding sense — specifically, the two groups of actions need not be coordinated at all and can be chosen independently.

Solution

The channel factorizes as , and .

Part 5(a). .

Solution. Using and the factorization,

The three terms on the right are, respectively,

each written over the full joint (the first depends only on , etc.). Then

Part 5(b). For , .

Solution. keeps the marginals and the channel, so for ( depends only on and ). Under the inputs are independent, so the outputs are too:

hence . Applying 5(a) under each distribution,

the last step using .

Part 5(c). A throughput-maximizing input with always exists.

Solution. The input simplex is compact and continuous, so a maximizer exists. Let . By 5(b), , so is also a maximizer, and under the inputs are independent.