All of the results in this post, and most of the informal observations/interpretations, are due to Sam Eisenstat. I think the Troll Bridge story, as a way to make the decision problem understandable, is due to Tsvi; but I’m not sure.
Pure Logic Version
Troll Bridge is a decision problem which has been floating around for a while, but which has lacked a good introductory post. The original post gives the essential example, but it lacks the “troll bridge” story, which (1) makes it hard to understand, since it is just stated in mathematical abstraction, and (2) makes it difficult to find if you search for “troll bridge”.
The basic idea is that you want to cross a bridge. However, there is a troll who will blow up the bridge with you on it, if (and only if) you cross it “for a dumb reason” — for example, due to unsound logic. You can get to where you want to go by a worse path (through the stream). This path is better than being blown up, though.
We apply a Löbian proof to show not only that you choose not to cross, but furthermore, that your counterfactual reasoning is confident that the bridge would have blown up if you had crossed. This is supposed to be a counterexample to various proposed notions of counterfactual, and for various proposed decision theories.
The pseudocode for the environment (more specifically, the utility gained from the environment) is as follows:
IE, if the agent crosses the bridge and is inconsistent, then U=-10. (□⊥ means “PA proves an inconsistency”.) Otherwise, if the agent crosses the bridge, U=+10. If neither of these (IE, the agent does not cross the bridge), U=0.
The pseudocode for the agent could be as follows:
This is a little more complicated, but the idea is supposed to be that you search for every “action implies utility” pair, and take the action for which you can prove the highest utility (with some tie-breaking procedure). Importantly, this is the kind of proof-based decision theory which eliminates spurious counterfactuals in 5-and-10 type problems. It isn’t that easy to trip up with Löbian proofs. (Historical/terminological note: This decision theory was initially called MUDT, and is still sometimes referred to in that way. However, I now often call it proof-based decision theory, because it isn’t centrally a UDT. “Modal DT” (MDT) would be reasonable, but the modal operator involved is the “provability” operator, so “proof-based DT” seems more direct.)
Now, the proof:
Reasoning within PA (ie, the logic of the agent):
Suppose the agent crosses.
Further suppose that the agent proves that crossing implies U=-10.
Examining the source code of the agent, because we’re assuming the agent crosses, either PA proved that crossing implies U=+10, or it proved that crossing implies U=0.
So, either way, PA is inconsistent—by way of 0=-10 or +10=-10.
So the troll actually blows up the bridge, and really, U=-10.
Therefore (popping out of the second assumption), if the agent proves that crossing implies U=-10, then in fact crossing implies U=-10.
By Löb’s theorem, crossing really implies U=-10.
So (since we’re still under the assumption that the agent crosses), U=-10.
So (popping out of the assumption that the agent crosses), the agent crossing implies U=-10.
Since we proved all of this in PA, the agent proves it, and proves no better utility in addition (unless PA is truly inconsistent). On the other hand, it will prove that not crossing gives it a safe U=0. So it will in fact not cross.
The paradoxical aspect of this example is not that the agent doesn’t cross—it makes sense that a proof-based agent can’t cross a bridge whose safety is dependent on the agent’s own logic being consistent, since proof-based agents can’t know whether their logic is consistent. Rather, the point is that the agent’s “counterfactual” reasoning looks crazy. (However, keep reading for a version of the argument where it does make the agent take the wrong action.) Arguably, the agent should be uncertain of what happens if it crosses the bridge, rather than certain that the bridge would blow up. Furthermore, the agent is reasoning as if it can control whether PA is consistent, which is arguably wrong.
In a comment, Stuart points out that this reasoning seems highly dependent on the code of the agent; the “else” clause could be different, and the argument falls apart. I think the argument keeps its force:
On the one hand, it’s still very concerning if the sensibility of the agent depends greatly on which action it performs in the “else” case.
On the other hand, we can modify the troll’s behavior to match the modified agent. The general rule is that the troll blows up the bridge if the agent would cross for a “dumb reason”—the agent then concludes that the bridge would be blown up if it crossed. I can no longer complain that the agent reasons as if it were controlling the consistency of PA, but I can still complain that the agent thinks an action is bad because that action indicates its own insanity, due to a troublingly circular argument.
Analogy to Smoking Lesion
One interpretation of this thought-experiment is that it shows proof-based decision theory to be essentially a version of EDT, in that it has EDT-like behavior for Smoking Lesion. The analogy to Smoking Lesion is relatively strong:
An agent is at risk of having a significant internal issue. (In Smoking Lesion, it’s a medical issue. In Troll Bridge, it is logical inconsistency.)
The internal issue would bias the agent toward a particular action. (In Smoking Lesion, the agent smokes. In Troll Bridge, an inconsistent agent crosses the bridge.)
The internal issue also causes some imagined practical problem for the agent. (In Smoking Lesion, the lesion makes one more likely to get cancer. In Troll Bridge, the inconsistency would make the troll blow up the bridge.)
There is a chain of reasoning which combines these facts to stop the agent from taking the action. (In smoking lesion, EDT refuses to smoke due to the correlation with cancer. In Troll Bridge, the proof-based agent refuses to cross the bridge because of a Löbian proof that crossing the bridge leads to disaster.)
We intuitively find the conclusion nonsensical. (It seems the EDT agent should smoke; it seems the proof-based agent should not expect the bridge to explode.)
Indeed, the analogy to smoking lesion seems to strengthen the final point—that the counterfactual reasoning is wrong.
I’ve come to think of Troll Bridge as “the real smoking lesion”, since I’m generally not satisfied with how smoking lesion is set up.
But is proof-based decision theory really a version of EDT? I think there’s more to say about the analogy, but a simple explanation is this: both EDT and proof-based decision theory evaluate actions by adding them to the knowledge base and seeing what the world looks like under that additional assumption. Or, to put it differently, proof-based DT reasons about actions as if they’re observations. That’s the fundamental idea of evidential decision theory.
For the purely logical version, I said that we can’t fault the conclusion (because the agent can’t prove that it is safe to cross the bridge) – only the reasoning is being critiqued. However, the probabilistic version better demonstrates the severity of the reasoning error; it illustrates an EDT agent making what seems to be an outright mistake.
It’s reasonable to avoid crossing the bridge if you’re only thinking about provable results. But we might expect an agent who balances risks and rewards would decide to cross, so long as it believes the probability of PA being inconsistent is low. Thus turns out not to be the case.
Here’s the setup.
Suppose that the agent uses a probability distribution which “respects logic” in the sense that it assigns probability zero to anything which is logically refutable. (This assumes logical omniscience. I’ll drop that assumption later.)
The agent is as follows: if P(cross)=0, cross; if P(¬cross)=0, don’t cross; else, take the action with highest expected utility, breaking ties by not crossing. The idea is that we are trying to take the highest-expected-utility action; however, we must handle cases where this isn’t well-defined. Choosing to take an action when the probability of the action is zero guarantees that the agent can never prove its own action; it is a version of the chicken rule. Breaking ties by not crossing is arbitrary, but gives the simplest version of the example, because this choice reduces the number of cases we need to check.
The troll is as follows: if the agent crosses the bridge due to the P(cross)=0 clause, blow up the bridge.
Reasoning in the logic of the agent:
Examining the agent, either crossing had higher expected utility, or P(cross)=0. But we assumed , so it must be the latter. So the bridge gets blown up.
Thus, by Löb’s theorem, we see that .
Therefore, since the agent is certain of things which are provable, the agent assigns expected value −10 to crossing. Since the expected value of the other action will always be higher than this, and since we know the agent doesn’t ever really enter into the P=0 conditions, the agent will choose not to cross.
Notice that this reasoning did not depend much on the values 10, 0, and −10. The utility of the bridge getting blown up could be −0.000001, and the agent still won’t cross. It isn’t weighing the risk; it’s decided that the worst outcome is inevitable. In the case of proof-based agents, I said that the overall decision not to cross was understandable, since proof-based agents are unable to weigh the risks. A probabilistic agent, however, should intuitively be able to say “I don’t know whether the bridge will get blown up, because it involves reasoning about properties of myself which I’m fundamentally uncertain about; but, the odds look decent.” But that’s not what happens: instead, it is sure that crossing is unfavorable, no matter what overall probability it assigns to P(A=cross)=0.
So, in this case we conclude that the Troll Bridge example results in a chicken-rule-based agent taking the wrong action overall. The agent shouldn’t be sure that it would cross “for the right reason” (it should assign some probability to P(A=cross)=0, since it can’t know that its own logic is consistent). However, intuitively, it should be able to assign some probability to this, and balance the risks. If the downside risk is U=-0.000001, and the probability it assigns to its logic being consistent is not similarly small, it should cross—and in doing so, it would get +10.
As mentioned for the proof-based agent, the agent’s code is a bit arbitrary, and it is worth asking how important the details were. In particular, the default in the case of a tie was to not cross. What if the default in case of a tie were to cross?
We then modify the troll’s algorithm to blow up the bridge if and only if P(A=cross)=0 or there is a tie. The proof then goes through in the same way.
Perhaps you think that the problem with the above version is that I assumed logical omniscience. It is unrealistic to suppose that agents have beliefs which perfectly respect logic. (Un)Fortunately, the argument doesn’t really depend on this; it only requires that the agent respects proofs which it can see, and eventually sees the Löbian proof referenced.
The frustrating thing about Troll Bridge is that it seems like the agent could just cross the bridge, and things would be fine. The proof that things wouldn’t be fine relies on the fact that the agent accepts that very proof as sufficient reason; so can’t we just ignore that kind of proof somehow?
One thing you might try is to consider a learning agent, and force random exploration so the agent just crosses the bridge sometimes. If the agent crosses the bridge, it should be able to see that it’s safe, right?
However, we have to ask: what’s the appropriate version of Troll Bridge for the exploring agent? Remember I said that the basic idea of Troll Bridge is that the troll blows up the bridge if the agent crosses “for a dumb reason”—ie, for a reason other than “crossing is a good idea”. Random exploration falls into this category.
Furthermore, random exploration is really closely analogous to the chicken rule. Consider:
(A) The first chicken rule I mentioned: if you prove that you don’t take an action, you immediately take it.
(B) The second chicken rule mentioned: if P(A)=0, then do A.
(C) Epsilon-chicken: if P(A)<epsilon, then do A.
(D) Epsilon-exploration: randomly do A with probability epsilon.
(A) is very similar to (B) if the probability distribution respects proofs in the way I mentioned previously; if the probability distribution has the further property of assigning positive probability to anything not disproven, then they’re exactly the same. (C) is a natural generalization of (B). (B) tells us what to do when the EDT decision rule isn’t well-defined (we can’t condition on probability zero events). (C) generalizes this by treating small-probability events in the same way (we might expect our conditional beliefs to be bad for small-probability events, since we presumably don’t have much experience with them; so we treat it as if it’s the undefined case). (B) ensures there are no zero-probability actions, which means we don’t actually ever have to deal with the EDT decision rule being non-well-defined; similarly, (C) ensures no action is almost surely never taken, which helps ensure that our conditional expectations for all actions are empirically grounded.
(C) and (D) are very similar; (C) just supplies pseudorandomness vie the agent’s own probabilities. Whenever the agent is too confident about what it does, it does something else. This makes the randomization unpredictable too the agent. (D) supplies randomness from an external source instead.
So we have a chain connecting the chicken rule to random exploration.
(Another way of thinking about the similarity: The chicken rule ensures that there are models of the agent’s beliefs in which each action is taken, so that the agent can have sensible logical reasoning about each alternative. Epsilon-exploration ensures that the empirical experiences of the agent include all of the actions, so that the agent can have reasonable empirical estimates of consequences of each action.)
OK. So Troll Bridge for an exploring agent should blow up the bridge on exploration, or if PA is inconsistent. An agent could look like this:
With small probability, explore.
If exploring, flip a coin to cross or not cross.
If P(cross)=0, cross.
If P(¬cross)=0, don’t cross.
Otherwise, take the max-expected-value action, breaking ties randomly.
I’m still assuming that the agent’s probability distribution respects proofs, as before. I’m also assuming this agent is playing the game repeatedly, and learning. I also must assume that the agent has found Now, the agent reasons:
Suppose (cross u=-10) for a particular round.
Further suppose I crossed on that round.
By the first supposition, I knew the payout of crossing to be low; and I must also have known that the payout of not crossing is higher, since I can prove that. Since I can prove what both payouts are, the expected values must equal those, unless PA is inconsistent (in which case P(cross)=0 anyway, since my beliefs respect proofs). So I can only be crossing the bridge for two reasons—either this is an exploration round, or P(cross)=0.
In either case, crossing the bridge yields payout u=-10.
Therefore, cross u=-10 in fact.
So (cross u=-10) (cross u=-10).
Since the agent proves that a proof of crossing being bad implies crossing is actually bad, the agent further must prove that crossing is bad in fact, by Löb.
I did this for the logically omniscient case again, but as before, I claim that you can translate the above proof to work in the case that the agent’s beliefs respect proofs it can find. That’s maybe a bit weird, though, because it involves a Bayesian agent updating on logical proofs; we know this isn’t a particularly good way of handling logical uncertainty.
We can use logical induction instead, using an epsilon-exploring version of LIDT. We consider LIDT on a sequence of troll-bridge problems, and show that it eventually notices the Löbian proof and starts refusing to cross. This is even more frustrating than the previous examples, because LIDT might successfully cross for a long time, apparently learning that crossing is safe, and reliably gets +10 payoff. Then, one day, it finds the Löbian proof and stops crossing the bridge!
That case is a little more complicated to work out than the Bayesian probability case, and I omit the proof here.
On the other hand, consider an agent which uses random exploration but doesn’t do any logical reasoning, like a typical RL agent. Such an agent doesn’t need any chicken rule, since it doesn’t care about proofs of what it’ll do. It still needs to explore, though. So the troll can blow up the bridge whenever the RL agent crosses due to exploration.
This obviously messes with the RL agent’s ability to learn to cross the bridge. The RL agent might never learn to cross, since every time it tries it, it looks bad. So this is sort of similar to Troll Bridge.
However, I think this isn’t really the point of Troll Bridge. The key difference is this: the RL agent can get past the bridge if its prior expectation that crossing is a good idea is high enough. It just starts out crossing, and happily crosses all the time.
Troll Bridge is about the inevitable confidence that crossing the bridge is bad. We would be fine if an agent decided not to cross because it assigned high probability to PA being inconsistent. The RL example seems similar in that it depends on the agent’s prior.
We could try to alter the example to get that kind of inevitability. Maybe we argue it’s still “dumb” to cross only because you start with a high prior probability of it being good. Have the troll punish crossing unless the crossing is justified by an empirical history of crossing being good. Then RL agents do poorly no matter what—no one can get the good outcome in order to build up the history, since getting the good outcome requires the history.
But this still doesn’t seem so interesting. You’re just messing with these agents. It isn’t illustrating the degree of pathological reasoning which the Löbian proof illustrates—of course you don’t put your hand in the fire if you get burned every single time you try it. There’s nothing wrong with the way the RL agent is reacting!
So, Troll Bridge seems to be more exclusively about agents who do reason logically.
All of the examples have depended on a version of the chicken rule. This leaves us with a fascinating catch-22:
We need the chicken rule to avoid spurious proofs. As a reminder: spurious proofs are cases where an agent would reject an action if it could prove that it would not take that action. These actions can then be rejected by an application of Löb’s theorem. The chicken rule avoids this problem by ensuring that agents cannot know their own actions, since if they did then they’d take a different action from the one they know they’ll take (and they know this, conditional on their logic being consistent).
However, Troll Bridge shows that the chicken rule can lead to another kind of problematic Löbian proof.
So, we might take Troll Bridge to show that the chicken rule does not achieve its goal, and therefore reject the chicken rule. However, this conclusion is very severe. We cannot simply drop the chicken rule and open the gates to the (much more common!) spurious proofs. We would need an altogether different way of rejecting the spurious proofs; perhaps a full account of logical counterfactuals.
Furthermore, it is possible to come up with variants of Troll Bridge which counter some such proposals. In particular, Troll Bridge was originally invented to counter proof-length counterfactuals, which essentially generalize chicken rules, and therefore lead to the same Troll Bridge problems).
Another possible conclusion could be that Troll Bridge is simply too hard, and we need to accept that agents will be vulnerable to this kind of reasoning.