Decision Theories: A Semi-Formal Analysis, Part III

10Wei Dai

0crazy88

0Wei Dai

10Vladimir_Nesov

0orthonormal

4CronoDAS

3GDC3

3orthonormal

3Vaniver

4Vladimir_Nesov

5Vaniver

8Vladimir_Nesov

5Vaniver

3[anonymous]

2Vaniver

2[anonymous]

2Vaniver

5Vladimir_Nesov

0Vaniver

2Vladimir_Nesov

0Vaniver

4Vladimir_Nesov

0Vaniver

5Vladimir_Nesov

2Vaniver

2TheOtherDave

0Vaniver

3wedrifid

2jeremysalwen

0Vaniver

2jeremysalwen

1orthonormal

0orthonormal

1orthonormal

0orthonormal

4Vaniver

0orthonormal

4Vaniver

4orthonormal

5Will_Newsome

2orthonormal

0wedrifid

0Vaniver

2orthonormal

0orthonormal

0Vaniver

2orthonormal

1Vaniver

1roystgnr

0orthonormal

2wedrifid

3Vladimir_Nesov

0wedrifid

1Jobst Heitzig

-12MaoShan

New Comment

55 comments, sorted by Click to highlight new comments since: Today at 4:24 AM

This formulation or variant of TDT (I'm not sure if Eliezer's TDT does or not) requires that before a decision problem is handed to it, the world is divided into the agent itself (**X**), other agents (**Y**), and "dumb matter" (**G**). I think this is misguided, since the world doesn't really divide cleanly into these 3 parts. But if this is the approach a decision theory researcher wants to take, they should at least acknowledge the "recognize myself and other agents in the world" problem as a problem, and say something about how this might be done in principle.

If there were a proof of S, then cooperation passes X's sanity test

Considering how much trouble it was to formulate the setups where this actually rigorously follows, I feel that this deserves a footnote, something like this:

Existence of a proof of S is not enough to conclude that X's sanity check succeeds, since provability is not decidable and so the condition for failing the check doesn't imply absence of a proof. One way out is to have a provability oracle perform the sanity check, which makes it impossible for players to be algorithms. Another is to prove some bounds on the length of the shortest proof of S, and write the algorithm in a way that guarantees the sanity check to succeed within these bounds. Yet another way is to never give up, work on the sanity check forever, which makes the agent completely unable to cope with many situations.

He also praised the idea of encouraging spies in certain departments rather than prosecuting them, in order to keep the Soviet Union from worrying that we were planning a first strike.

In general, a caught spy can be a useful resource. If you've identified a spy but the spy doesn't know he's been found out, you get to control what the spy's reports are.

There's a gap in the proof that X and Y cooperate. You may know how to close it, but if it's possible it's not obvious enough so the extra steps should be added to the article. More importantly, if it can't be closed the theorem might not be true.

The gap: We hypothesize that statement S is provable in (system of X). Therefore X will Cooperate. This guarantees that T is true, by definition, but not that Y will prove that T is true. Presumable Y can recreate the proof of S being true, but it cannot conclude that X will cooperate unless it also can prove that X will prove it.

I cannot see how to resolve this without stepping out of a specific formal system, which would make Lob's Theorem unusable.

Am I missing something?

It does work out, but you're right to raise that question; Vladimir Nesov's footnote unpacks those issues.

Unpacking a bit (to more reliably communicate that you don't mean any snark if that's indeed the case) and avoiding the form of a rhetorical question (which is what suggested the snarkiness) could work: "This kind of decision theory assumes the players to have so much knowledge about each other that one wonders whether it should be called "telepathic" instead of "timeless"..."

Telepathic is even worse.

What's worse about it? (I have a defense of the name I'll hold off on sharing until I hear your opnion.)

Timeless because it allows that causality can go backwards in the presence of good simulation. I think.

If you bend what you mean by 'causality,' sure, but I don't think there's value in bending the word that way.

What's worse about it? (I have a defense of the name I'll hold off on sharing until I hear your opnion.)

Telepathic implies some kind of supernatural communication. TDT sortof behaves like that except that there is no actual communication going on. Timeless isn't a very good name, but telepathic has too much wierd baggage, I think. Curious to see your arguments.

If you bend what you mean by 'causality,' sure, but I don't think there's value in bending the word that way.

Well it lets you vastly simplify the causality structures in your predictions, for one.

TDT sortof behaves like that except that there is no actual communication going on.

Huh? How could X possibly run TDT without having Y's source code communicated to it?

Curious to see your arguments.

My model of TDT is that, rather than looking at action-action-outcome triplets, it looks at strategy-strategy-outcome triplets. The rest of game theory remains the same, and so once you have a strategy-strategy-outcome table, you find the Nash equilibrium and you're done. (If constructing that table fails, you revert to the Nash equilibrium from the action-action-outcome table.)

The material difference between this and regular game theory is that we now have access to strategies- i.e., we can read our opponent's mind, i.e. telepathy. (Maybe mind-reading decision theory is a better term, but it doesn't abbreviate to TDT like telepathic decision theory does.)

You can still run TDT in situations with time (like an iterated prisoner's dilemma), but you *can't* run TDT in situations where you don't have your opponent's source code. So calling it "timeless" when it can involve time seems odd, as is not referring to the necessity of source code.

My model of TDT is that, rather than looking at action-action-outcome triplets, it looks at strategy-strategy-outcome triplets.

This characterization/analogy doesn't fit, and doesn't seem to help with making the necessary-knowledge-about-opponent distinction. Knowing that performing action A implies that your opponent performs action B is a *weaker* statement than unconditionally knowing that your opponent performs action B. In standard game theory, you don't know what action your opponent performs, and with TDT you don't know that as well. But not knowing something doesn't (automatically) make it not happen. So if there is indeed a dependence of your opponent's action on your own action, it's useful to know it.

The difference between considering opponent's actions in standard game theory and considering opponent's "strategy" (dependence of opponent's action on your action) is that while the former is usually unknown (to both TDT and standard game theory), the latter can in principle be known, and making use of this additional potential knowledge is what distinguishes TDT. So the actions in game theory and "strategies" in TDT are not analogous.

Knowing that performing action A implies that your opponent performs action B is a weaker statement than unconditionally knowing that your opponent performs action B.

Okay. The first looks like a strategy to me, and the second looks like an action. Right?

In standard game theory, you don't know what action your opponent performs, and with TDT you don't know that as well.

I agree, and that matches my characterization of TDT.

But not knowing something doesn't (automatically) make it not happen. So if there is indeed a dependence of your opponent's action on your own action, it's useful to know it.

I'm not understanding this, though. Are you just saying that knowing about your opponent's strategy gives you useful information?

the latter can in principle be known,

How do you learn it?

So the actions in game theory and "strategies" in TDT are not analogous.

The analogy is that both of them get put into a table, and then you find the Nash equilibria by altering the favored rows and columns and columns of the table, and then you pick the best of the equilibria. (TDT has known bargaining problems, right? That looks like it maps onto disagreeing over which Nash equilibrium to pick.) Would it help if I made a walkthrough of my model with actual tables?

Knowing that performing action A implies that your opponent performs action B is a weaker statement than unconditionally knowing that your opponent performs action B.

Okay. The first looks like a strategy to me, and the second looks like an action. Right?

Y doesn't act according to the rule "Let's see what X does. If it does A, I'm going to do B, etc.", and so it's misleading to call that "a strategy". This is only something like what X infers about Y, but this is not how Y reasons, because Y can't infer what X does, and so it can't respond depending on what X does.

The actual strategy is to figure out an action based on the other player's code, not to figure out an action based on the other player's action. This strategy, which doesn't involve responding to actions, can be characterized as establishing a dependence between players' actions, and this characterization is instrumental to the strategy itself, a part of what makes the characterization correct.

Y doesn't act according to the rule "Let's see what X does. If it does A, I'm going to do B, etc.", and so it's misleading to call that "a strategy". This is only something like what X infers about Y, but this is not how Y reasons, because Y can't infer what X does, and so it can't respond depending on what X does.

So "play whatever I think X will play" does count as a strategy, but "play whatever X plays" does not count as a strategy because Y can't actually implement it. Limiting X and Y to the first sort of strategies was meant to be part of my characterization, but I could have made that clearer.

So "play whatever I think X will play" does count as a strategy, but "play whatever X plays" does not count as a strategy because Y can't actually implement it.

It can't implement "play whatever I think X will play" either, because it doesn't know what X will play.

In one statement, if we are talking about ADT-like PD (the model of TDT in this post appears to be more complicated), Y could be said to choose the action such that provability of Y choosing that action implies X's choosing a good matching action. So Y doesn't act depending on what X does or what Y thinks X does etc., Y acts depending on what X can be inferred to do if we additionally assume that Y is doing a certain thing, and the thing we additionally assume Y to be doing is a specific action, not a strategy of responding to X's source code, or a strategy of responding to X's action. If you describe X's algorithm the same way, you can see that the additional assumption of Y's action is not what X uses in making its decision, for it similarly makes an additional assumption of its own (X's) action and then looks what can be inferred about Y's action (and not Y's "strategy").

Y acts depending on what X can be inferred to do if we additionally assume that Y is doing a certain thing, and the thing we additionally assume Y to be doing is a specific action, not a strategy of responding to X's source code, or a strategy of responding to X's action.

Can you write the "cooperate iff I cooperate iff they cooperate ... " bot this way? I thought the strength of TDT was that it allowed that bot.

Can you write the "cooperate iff I cooperate iff they cooperate ... " bot this way?

This can be unpacked as an algorithm that searches for a proof of the statement "If I cooperate, then my opponent also cooperates; if I defect, then my opponent also defects", and if it finds its proof, it cooperates. Under certain conditions, two players running something like this algorithm will cooperate. As you can see, agent's decision here depends not on the opponent's decision, but on the opponent's decision's *dependence* on your decision (and not dependence on the dependence of your decision on the opponent's decision, etc.).

Okay. I think that fits with my view: so long as it's possible to go from X's strategy and Y's strategy to an outcome, then we can build a table of strategy-strategy-outcome triplets, and do analysis on that. (I built an example over here.) What I'm taking from this subthread is that the word "strategy" needs to have a particular meaning to be accurate, and so I need to be more careful when I use it so that it's clear that I'm conforming to that meaning.

I usually understand "mind-reading" to encompass being aware of the current state of a system. Two systems that simply know one another's strategies can't predict one another's behaviors if their strategies include random coin flips, for example, or depend on information that one system can observe but the other cannot; whereas I would expect telepathic agents to be aware of the results of such observations as well.

If you did have two telepaths playing any game, and one of them decided a mixed strategy was optimal, they wouldn't want to know what action they were playing until it was played- because otherwise they might leak that knowledge to the other player. That is, in a competitive situation I don't think mind-reading would extend to coin-reading, but if your understanding is common then 'mind-reading' is a bad phrase to use. Is there a good word for "has access to its opponent's source code"? Bonus points if it starts with a T.

(Also, my understanding is that TDT will defect against any mixed strategy in the prisoner's dilemma.)

(Also, my understanding is that TDT will defect against any mixed strategy in the prisoner's dilemma.)

Not necessarily. It will play a mixed strategy against an identical mixed strategy if that if what it needs to do to get them to play mixed rather than D. It's the *other guy* being weird and arbitrary in that case, not the TDT.

Well, it certainly will defect against any mixed strategy that is hard coded into the opponent’s source code. On the other hand, if the mixed strategy the opponent plays is dependent on what it predicts the TDT agent will play, then the TDT agent will figure out which outcome has a higher expected utility:

(I defect, Opponent runs "defection predicted" mixed strategy)

(I cooperate, Opponent runs "cooperation detected" mixed strategy)

Of course, this is still simplifying things a bit, since it assumes that the opponent can perfectly predict one's strategy, and it also rules out the possibility of the TDT agent using a mixed strategy himself.

Thus the actual computation is more like

ArgMax(Sum(ExpectedUtility(S,T)*P(T|S)))

where the argmax is over S: all possible mixed strategies for the TDT agent

the sum is over T: all possible mixed strategies for the opponent

and P(T|S) is the probability that opponent will play T, given that we choose to play S. (so this is essentially an estimate of the opponent's predictive power.)

Won't that let the opponent steal utility from you? Consider the case where you're going up against another TDTer which is willing to consider both the strategy "if they cooperate only if I cooperate, then cooperate with 99% probability" and "if they cooperate only if I cooperate, then cooperate." You want your response to the first strategy to be defection and your response to the second strategy to be cooperation, so it's in their interests to play the second strategy.

You're right, if the opponent is a TDT agent. I was assuming that the opponent was simply a prediction=>mixed strategy mapper. (In fact, I always thought that the strategy 51% one-box 49% two box would game the system, assuming that Omega just predicts the outcome which is most likely).

If the opponent is a TDT agent, then it becomes more complex, as in the OP. Just as above, you have to take the argmax over all possible y->x *mappings*, instead of simply taking the argmax over all outputs.

Putting it in that perspective, essentially in this case we are adding all possible mixed strategies to the space of possible outputs. Hmmm... That's somewhat a better way of putting it than everything else I said.

In any case, two TDT agents will both note that the program which only cooperates 100% iff the opponent cooperates 100% dominates all other mixed strategies against such an opponent.

So to answer the original question: *Yes*, it will defect against blind mixed strategies. *No*, it will not necessarily defect against simple (prediction =>mixed strategy) mappers. *N/A* against another TDT agent, as neither will ever play a mixed strategy, so to ask what whether it would cooperate with a mixed strategy TDT agent is counterfactual.

EDIT: Thinking some more, I realize that TDT agents will consider the sort of 99% rigging against each other — and will find that it is better than the cooperate IFF strategy. However, this is where the "sanity check" become important. The TDT agent will realize that although such a pure agent would do better against a TDT opponent, the opponent knows that you are a TDT agent as well, and thus will not fall for the trap.

Out of this I've reached two conclusions:

The sanity check outlined above is

*not*broad enough, as it only sanity checks the*best*agents, whereas even if the best possible agent fails the sanity check, there still could be an*improvement*over the nash equilibrium which passes.Eliezer's previous claim that a TDT agent will never regret being a TDT agent given full information is

*wrong*(hey, I thought it was right too). Either it gives in to a pure 99% rigger or it does not. If it does, then it regrets not being able to 99% rig another TDT agent. If it does not, then it regrets not being a simple hard-coded cooperator against a 99% rigger. This probably could be formalized a bit more, but I'm wondering if Eliezer et. al. have considered this?

EDIT2: I realize I was a bit confused before. Feeling a bit stupid. Eliezer never claimed that a TDT agent won't regret being a TDT agent (which is obviously possible, just consider a clique-bot opponent), but that a TDT agent will never regret being given information.

(In fact, I always thought that the strategy 51% one-box 49% two box would game the system, assuming that Omega just predicts the outcome which is most likely).

Incidentally, my preferred version of Newcomb is that if the Predictor decides that your chance of one-boxing is *p*, it puts (one million times *p*) dollars in the big box. Presumably, you know that the Predictor is both extremely well-calibrated and shockingly accurate (it usually winds up with *p* near 0 or near 1).

The sanity check outlined above is not broad enough, as it only sanity checks the best agents, whereas even if the best possible agent fails the sanity check, there still could be an improvement over the nash equilibrium which passes.

Yup, this is where I'm going in a future post. See the footnote on this post about other variants of TDT; there's a balance between missing workable deals against genuinely stubborn opponents, and failing to get the best possible deal from clever but flexible opponents. (And, if I haven't made a mistake in the reasoning I haven't checked, there *is* a way to use further cleverness to do still better.)

For now, note that TDT wouldn't necessarily prefer to be a hard-coded 99% cooperator in general, since those get "screw you" mutual defections from some (stubborn) agents that mutually cooperate with TDT.

You've made it into a bargaining game with that mixed strategy, and indeed the version of TDT we introduced will defect against an opponent that outputs the mixed strategy (if that opponent would output a pure cooperate if that were the only way to get its adversary to cooperate). But bargaining games are complicated, and I'm saving that for another post.

It's a better analogy to say that TDT is capable of offering deals (and self-enforcing them) even without traditional means of communication and precommitment (as long as it has some means for inferring its opponent's thinking), and so it has a wider range of options than CDT to optimize over.

Well, offering deals isn't enough, right? The self-enforcing part is really important, and that's where the Nash equilibrium idea comes in: it's self-enforced because no party can gain by unilaterally changing their strategy (which is a somewhat different restriction than no party gaining from unilaterally changing their action).

[**EDIT:** I see now what Vaniver was saying, thanks to the diagram in xer reply.] Try writing it out for the Prisoner's Dilemma in such a way that a CDT agent would cooperate with itself in the strategy-strategy game (I mean, such that they would each output a strategy that makes them both cooperate in the original PD), and you'll see the problem. You need to *eliminate logically impossible squares of the matrix*, not just add new rows.

So, let's consider this with three strategies: 1) CooperateBot, 2) DefectBot, 3) CliqueBot.

We now get a table that looks like this (notice the letters are outcomes, not actions):

X has control over which row they get, and Y has control over which column they get. The two Nash equilibria are (2,2) and (3,3). Conveniently, (2,2) and (2,3) have the same result, and so it looks like it'll be easy to figure out that (3,3) is the better Nash equilibrium.

Aha, I see now what you mean. Good insight!

**[EDIT: The following is false.]** A clever CDT would be able to act like TDT if it considered, not the choice of whether to output C or D, but the choice of which mathematical object to output (because it could output a mathematical object that evaluates to C or D in a particular way depending on the code of Y—this gives it the option of genuinely acting like TDT would).

This has the interesting conclusion that even without the benefit of self-modification, a CDT agent with a good model of the world ends up acting more like TDT than traditional game theorists would expect. (Another example of this is here.) The version of CDT in the last post, contrariwise, is equipped with a very narrow model of the world and of its options. **[End falsehood.]**

I think these things are fascinating, but I think it's important to show that you can get TDT behavior without incorporating anthropic reasoning, redefinition of its actions, or anything beyond a basic kind of framework that human beings know how to program.

(By the way, I wouldn't call option 3 CliqueBot, because CliqueBots as I defined them have problems mutually cooperating with anything whose outputs aren't identical to theirs. I think it's better for Option 3 to be the TDT algorithm defined in the post.)

It seems to come up all the time that people aren't aware that CDT with a sufficiently good world model (a sufficiently accurate causal graph) is the same as TDT, even though this has been known for years. If you could address that somewhere in your sequence I think you'd save a lot of people a lot of time—it's the most common objection to standard discourse about decision theory that I've seen.

It seems to come up all the time that people aren't aware that CDT with a sufficiently good world model (a sufficiently accurate causal graph) is the same as TDT

CDT leaves the money on the ground? Not unless the "sufficiently good world model" isn't so much "sufficiently good" as it is an artificial hack that compensates for bad decision making by twisting what causal graphs are supposed to mean.

[This comment is no longer endorsed by its author]

Good insight!

Thanks!

This has the interesting conclusion that even without the benefit of self-modification, a CDT agent with a good model of the world ends up acting more like TDT than traditional game theorists would expect.

This is a pretty common feature of comparisons between decision theories: different outcomes generally require different assumptions.

I think these things are fascinating, but I think it's important to show that you can get TDT behavior without incorporating anthropic reasoning, redefinition of its actions, or anything beyond a basic kind of framework that human beings know how to program.

It's not clear to me what the difference is between the TDT algorithm in your post and the method I've described. You need some method of determining what the outcome pair is from strategy pair, and the inference module can (hopefully) do that. The u_f that you use is the utility of the X outcome corresponding to the best Y outcome in row f, and picking the best of those corresponds to finding the best of the Nash equilibria (in the absence of bargaining problems). The only thing I don't mention is the sanity check, but that should just be another run of the inference module.

By the way, I wouldn't call option 3 CliqueBot, because CliqueBots as I defined them have problems mutually cooperating with anything whose outputs aren't identical to theirs. I think it's better for Option 3 to be the TDT algorithm defined in the post.

Sure, but does it have a short name? ProofBot?

(Notice that Y running the full TDT algorithm corresponds to there being multiple columns in the table: if you were running X against a CooperateBot, you'd just have the first column, and the Nash equilibrium would be (2,1) or (3,1). If you were running it against CliqueBot without a sanity check, there would just be the third column, and it would think (3,3) was the Nash equilibrium, but would be in for a nasty surprise when CliqueBot rejects it because of its baggage.)

It's not clear to me what the difference is between the TDT algorithm in your post and the method I've described.

If you make sure to include a sanity check, then your description should do the same thing as the TDT algorithm in the post (at least on simple games; there may be a difference in bargaining situations.)

Sure, but does it have a short name? ProofBot?

I understand why you might feel it's circular to name that row TDT, but nothing simpler (unless you count ADT/UDT as simpler) does as it does. It's a layer more complicated than Newcomblike agents (which should also be included in your table); in order to get mutual cooperation with self and also defection against CooperateBot, it deduces whether a DefectBot or a MimicBot (C if it deduces Y=C, D otherwise) has a better outcome against Y, runs a sanity check, and if that goes through it does what the preferred strategy does.

After further review, I was wrong that CDT would be capable of making use of this to act like TDT. If CDT treats its output as separate from the rest of the causal graph (in the sense of the previous post), then it would still prefer to output an always-defect rather than a Löbian mathematical object. So it does take a different kind of agent to think of Nash equilibria among strategies.

Also, the combinatorics of enumerating strategies and looking for Nash equilibria are kind of awful: there are 16 different inputs that such a strategy has to deal with (i.e. what the opponent does against CooperateBot, DefectBot, NewcombBot and AntiNewcombBot), so there are 2^16 variant strategies in the same class. The one we call TDT is the Nash equilibrium, but it would take a *long* while to establish that in a naive implementation.

If CDT treats its output as separate from the rest of the causal graph (in the sense of the previous post), then it would still prefer to output an always-defect rather than a Löbian mathematical object.

When its source code is provided to its opponent, how could it be sensible to treat its output as separate from the rest of the causal graph?

Also, the combinatorics of enumerating strategies and looking for Nash equilibria are kind of awful

Sure, but it's just as bad for the algorithm you wrote: you attempt to deduce output Y(code G, code A_i) for all A_i, which is exactly what you need to determine the Nash Equilibrium of this table. (Building the table isn't much extra work, if it even requires more, and is done here more for illustrative than computational purposes.)

After further review, I was wrong that CDT would be capable of making use of this to act like TDT.

I am *really worried* that those two objections were enough to flip your position on this.

Sure, but it's just as bad for the algorithm you wrote: you attempt to deduce output Y(code G, code A_i) for all A_i, which is exactly what you need to determine the Nash Equilibrium of this table.

No, there are four different A_i (CooperateBot, DefectBot, NewcombBot and AntiNewcombBot). 2^16 is the number of distinct agents one could write that see what Y does against the A_i and picks an action based on those responses. Just taking the maximum each time saves you from enumerating 2^16 strategies.

When its source code is provided to its opponent, how could it be sensible to treat its output as separate from the rest of the causal graph?

That is what CDT *is*. "Sensible" doesn't enter into it.

(To expand on this, CDT's way of avoiding harmful self-reference is to treat its decision as a causally separate node and try out different values for it while changing *nothing else on the graph*, including things that are copies of its source code. So it considers it legitimate to figure out the impact of its present decision on any agent who can see the effects of the action, but not on any agent who can predict the decision. Don't complain to me, I didn't make this up.)

Just taking the maximum each time saves you from enumerating 2^16 strategies.

It's not clear to me that's the case. If your bot and my bot both receive the same source code for Y, we both determine the correct number of potential sub-strategies Y can use, and have to evaluate each of them against each of our A_is. I make the maximization over all of Y's substrategies explicit by storing all of the values I obtain, but in order to get the maximum you also have to calculate all possible values. (I suppose you could get a bit of computational savings by exploiting the structure of the problem, but that may not generalize to arbitrary games.)

To expand on this, CDT's way of avoiding harmful self-reference is to treat its decision as a causally separate node and try out different values for it while changing nothing else on the graph, including things that are copies of its source code.

The basic decision here is what to write as the source code, not the action that our bot outputs, and so CDT is fine- if it modifies the source code for X, that can impact the outputs of both X and Y. There's no way to modify the output of X without potentially modifying the output of Y in this game and I don't see a reason for CDT to mistakenly hallucinate one.

Put another way, I don't think I would use "causally separate"- I think I would use "unprecedented." The influence diagram I'm drawing for this has three decision boxes (made by three different agents), all unprecedented, whose outputs are the code for X, Y, and G; all of them point to the calculation node of the inference module, and then all three codes and the inference module point to separate calculation nodes of X's output and Y's output, which then both point to the value node of Game Outcome. (You could have uncertainty nodes pointing to X's output and Y's output separately, but I'm ignoring mixed strategies for now.)

So it considers it legitimate to figure out the impact of its present decision on any agent who can see the effects of the action, but not on any agent who can predict the decision.

To the best of my knowledge, this isn't a feature of CDT: it's a feature of the embedded physics module used by most CDTers. If we altered Newcomb's problem such that Omega filled the boxes after the agent made their choice, then CDTers would one-box- and so if you have a CDTer who believes that perfect prediction is equivalent to information moving backwards in time (and that that's possible), then you have a one-boxing CDTer.

To be a trustworthy tool rather than a potential trap, the source code to Y has to be completely accurate and has to have final decision making authority. Y's programmer has to be able to accurately say "Here is enough information to predict any decision that my irrevokably delegated representative would ever possibly make in this interaction." Saying that this is "without traditional means of communication" is technically accurate but very deceptive. Saying that this is "no actual communication" is outright backwards; if anything it's much *more* communication than is traditionally imagined.

Unlimited communication, even. In the hypothetical "AGIs can inspect each others' source code" case, the AGIs could just as well run that source code and have two separate conversations, one between each original and its counterpart's copy. If the AGIs' senses of ethics were sufficiently situation-dependent, then to generate useful proofs they'd need to be able to inspect copies of each others' current state as well, in which case the two separate conversations might well be identical.

This is all true, but you can come up with situations where exchanging source code is more relevant. For instance, Robin Hanson has frequently argued that agents will diverge from each other as they explore the universe, and that *someone* will start burning the cosmic commons. This is a Prisoner's Dilemma without traditional communication (since signals are limited by lightspeed, it would be too late to stop someone distant from defecting once you see they've started). But the "exchange of source code" kind of coordination is more feasible.

Also, I don't know whether anyone polled traditional game theorists, but I'd bet that some of them would have expected it to be impossible, even with exchange of source codes, to achieve anything better than what CliqueBot does.

"Updateless" does describe the weird attitude of that decision theory to observations. It really does not learn from evidence, and it is a problem, so the weird connotations correspond to actual weirdness of the algorithm. In that sense, "telepathic" also somewhat fits, in that the current models of this style of decision making do require the players to have unreasonable amount of knowledge about each other (although merely reading each other's thoughts *is not enough*), but this seems more like a limitation of current models (i.e. concrete examples of algorithms) than the limitation of the overall decision-making style (it's not yet known to what extent it's so).

even when the agents are unable to explicitly bargain or guarantee their fulfilment of their end by external precommitments

I believe there is a misconception here. The *actual* game you describe is the game between the *programmers*, and the fact that they know in advance that the others' programs *will indeed* be run with the code that their own program has access to *does* make each program submission a *binding commitment to behave in a certain way*.

Game Theory knows since long that if binding commitments are possible, most dilemmas can be solved easily. In other words, I believe this is very nice but is quite far from being the "huge success" you claim it is.

Put differently: The whole thing depends crucially on the fact that X can be *certain* that Y will use the strategy (=code) X thinks it will use. But how on Earth would a real agent ever be able to know such a thing about another agent?

## Or: Formalizing Timeless Decision Theory

Previously:0. Decision Theories: A Less Wrong Primer

1. The Problem with Naive Decision Theory

2. Causal Decision Theory and Substitution

WARNING: The main result of this post, as it's written here, is flawed. I at first thought it was a fatal flaw, but later found a fix. I'm going to try and repair this post, either by including the tricky bits, or by handwaving and pointing you to the actual proofs if you're curious. Carry on!

Summary of Post:Have you ever wanted to know how (and whether) Timeless Decision Theory works? Using the framework from the last two posts, this post shows you explicitly how TDT can be implemented in the context of our tournament, what it does, how it strictly beats CDT on fair problems, and a bit about why this is a Big Deal. But you're seriously going to want to read the previous posts in the sequence before this one.

We've reached the frontier of decision theories, and we're ready at last to write algorithms that achieve mutual cooperation in Prisoner's Dilemma (without risk of being defected on, and without giving up the ability to defect against players who always cooperate)! After two substantial preparatory posts, it feels like it's been a long time, hasn't it?

But look at me, here, talking when there's Science to do...

Once again, we're programming an agent

Xto face another agentYin a gameG, whereXandYhave access to each others' source codes and the source code ofG. (In this post, we'll sweep the "player 1, player 2" bit back into the definition ofGfor simplicity in our code.) We may assume that at least one of thexis a Nash equilibrium, since_{i}XandYcan treat a mixed equilibrium like an extra option and define its expected payoffs as usual.## Not Quite Timeless Decision Theory

Here's our first shot at TDT, based on the idea of substituting different things for the source code of

Xin our prediction ofY...def

X(codeG, codeY):x:_{i}Athat always outputs_{i}xin game_{i}G.Y(codeG, codeA)._{i}U(x, output_{i}Y(codeG, codeA)); call this_{i}u._{i}uhas been deduced for all_{i}x, return the_{i}xfor which_{i}uis largest._{i}To see what this algorithm does, let's try it on Newcomb's Problem as we formalized it last time; we'll let

Adenote the agent that always one-boxes and_{1}Adenote the agent that always two-boxes. If_{2}Phas a valid and sufficiently powerful inference module, the output ofP(codeN, codeA) is 1 and the output of_{1}P(codeN, codeA) is 2. Why?_{2}Aand_{1}Aare very simple bots, so_{2}Pwill be able to deduce their outputs, and we know what it does in that case.And then, if

Xalso has a valid and sufficiently powerful inference module,Xwill deduce those outputs forP. ThusXwill deduce thatu=100 and_{1}u=1, so_{2}Xwill indeed one-box; and ifPhas a sufficiently powerful inference module, it will therefore predict thatXone-boxes, and fill the box, so thatXgets payoff 100!Again, what we're doing here is not counterfactual reasoning, but instead reasoning about what your opponent would do against some

othersimpler agent; therefore we're again evading the problem of spurious counterfactuals. (On a philosophical level, this decision theory finds the most successful constant strategyAand mimics its output.)_{i}Alright, I said there were going to be two problems with this attempt, and indeed I called it Not Quite Timeless Decision Theory. So what goes wrong?

## Problem: NQTDT won't cooperate against itself!

If you face two NQTDT agents against each other in the Prisoner's Dilemma, what happens? First, note that NQTDT will defect against either a CooperateBot (

A) or a DefectBot (_{C}A) in the Prisoner's Dilemma. If_{D}XandYare both NQTDT, thenXdeduces thatYdefects against bothAand_{C}A, therefore_{D}Xcalculatesu=0 and_{C}u=1, so_{D}Xdefects. (And of courseYdoes the same.) Drat!And the second problem?

## Problem: NQTDT might one-box and

notbe rewarded!In Newcomb's Problem, what if

Phas a powerful enough inference module to show thatAone-boxes and_{1}Atwo-boxes, but not one powerful enough to figure out what_{2}Xis doing? (After all,Xis a bit more complicated than theAare.) By the reasoning above,_{i}Xwill one-box, butPwon't fill the box—the worst of all possible outcomes!So NQTDT is broken. What can we do?

## Idea 5: Sanity Check

Well, instead of assuming that our opponent

Ywill behave in the real game as it did against the optimalA, we could try to deduce_{i}Y's actual behavior againstXas a "sanity check" before we make our final decision. That is,def

X(codeG, codeY):x:_{i}Athat always outputs_{i}x._{i}Y(codeG, codeA)._{i}U(x, output_{i}Y(codeG, codeA)); call this_{i}u._{i}uhas been deduced for all_{i}x, take the_{i}xfor which_{i}uis largest, and try to deduce "_{i}U(x, output_{i}Y(codeG, codeX)) ≥u"._{i}thatsucceeds,thenreturnx._{i}Note that the new line checks the behavior of

YagainstXitself, not theA. This "sanity check" ensures that, when_{i}Ximitates the most successful of theA, it achieves at least the payoff that_{i}Adoes. Indeed, if our program does this then it's again un-exploitable in the same sense as CDT, and it still one-boxes on Newcomb's Problem (if and only if it deduces that_{i}Pis sufficiently powerful to deduce this fact), so it's no longer broken in the above sense.But by the same argument as before, it still defects on the Prisoner's Dilemma against itself, so this is still not TDT.

What else could we do better? Well, this agent "mimics" only the very simplest of strategies- the strategies that correspond to one-player games for its opponent. What if we instead let it mimic more complicated (but still basic) strategies, like versions of Newcomb's Predictor?

## Idea 6: Mimic something a bit more clever

This is going to be a bit more complicated than the last one; we first need to define the agents that we'll examine and mimic. Consider each function

ffrom the set {y, . . . ,_{1}y} to the set {_{m}x, . . . ,_{1}x} (there are_{n}nsuch functions), and define^{m}Aas follows:_{f}def

A(code_{f}G, codeY):Y(codeG, codeA)._{f}f(outputY). Else, return the Nash equilibrium.Note that the constant strategies

Aare special cases of the_{i}A, corresponding to the constant functions; note also that Newcomb's Predictor is an example of an_{f}Athat's not simply a constant strategy. Now we'll write a decision theory that looks for the most successful of the_{f}A, applies a sanity check, and mimics it. This results in an instance of..._{f}## Timeless Decision Theory

def

X(codeG, codeY):f:A._{f}Y(codeG, codeA)._{f}U(outputA, output_{f}Y(codeG, codeA)); call this_{f}u._{f}uhas been deduced for all_{f}f, take theffor whichuis largest, and try to deduce "_{f}U(outputA, output_{f}Y(codeG, codeX)) ≥u"._{f}A)._{f}Let's try and parse what this algorithm does. It considers all possible Newcomblike agents (the

A) and tests out how they fare against_{f}Y. Then it takes the best result and does a sanity check: willYactually respond againstXas it does against this particularA? And if that checks out, then_{f}Xgoes ahead and outputs whatAdoes._{f}^{0}We can sketch out some results that this decision theory gets (when equipped with a sufficiently powerful inference module). First, it correctly solves one-player games (since one of the constant strategies

Ais the optimum) and zero-sum two-player games (for the same reasons that CDT does). It one-boxes on Newcomb whenever_{i}Pis a powerful enough predictor (since the best of theAare all one-boxers). And finally, it cooperates with itself on a simple Prisoner's Dilemma!_{f}Why? If

XandYare both running this decision theory, consider the functionfwithf(C)=C andf(D)=D, it's clear thatYcooperates with thisA(by the same logic that makes it one-box on Newcomb's Problem) and that no_{f}Aachieves a better result against_{f}Ythan mutual cooperation. Thus,Xwill run the sanity check for thisA, which is equivalent to trying to deduce that_{f}Ycooperates againstX, whileYattempts to do the same. Here comes the delicate argument from mathematical logic; we'll phrase things in terms of logical provability, but the analogous arguments hold for other (valid and sufficiently powerful) kinds of inference modules:Löb's Theorem states that, within a formal system, proving "if there's a proof of

S, thenSactually holds" leads to a proof ofSitself. In our current context, letSbe the statement "U(outputA, output_{f}Y(codeG, codeX)) ≥u" that appears in_{f}X's sanity test, andTbe the corresponding statement "V(outputA, output_{f}X(codeG, codeY)) ≥u" that appears in_{f}Y's sanity-test. If there were a proof ofS, then cooperation passesX's sanity test^{1}, so that outputX(codeG, codeY))=C. But this directly implies the statementT, so cooperation passesY's sanity test, so that outputY(codeG, codeX))=C, which impliesSitself. Thus, by Löb's Theorem, there must be a proof ofS, and thereforeXandYdo in fact cooperate! (I do realize how confusing this process of logical bootstrapping is—it's helpful to think of it as a useful kind of self-fulfilling prophecy.)This algorithm is a general decision theory rather than something with ad-hoc patches, so it satisfies my criteria for a better decision theory. It also behaves like Timeless Decision Theory is supposed to on the classical problems. Is it therefore justified to call this TDT? Well, let's again think about it on the philosophical level.

Each Newcomblike agent

Arepresents a particular deal that it tries to strike with_{f}Y(if I deduce you're doingthis, then I'll dothat).Xlooks to see which dealsYwill accept, and offersYthe most favorable (toX) of those deals, and ifY"accepts" (passes the sanity check) thenXfulfills its end of the bargain. Since some deals are better than the best Nash equilibrium, this gets better results than CDT in many games, while still being un-exploitable. The novelty (compared to what traditional game theorists already know) is the fact that the communication of the deal and its acceptance all happen via prediction of each other rather than via exchange of messages, which allows for deals to happen even when the agents are unable to explicitly bargain or guarantee their fulfilment of their end by external precommitmentsThat's a pretty good account of what TDT does, no? Also, I realized that I had the right description when I recalled Eliezer's description of when TDT cooperates on the Prisoner's Dilemma: if and only if the opponent would one-box with the TDT agent as Omega. This is

exactlywhat this algorithm ends up doing.It's fair to say that Yudkowsky's invention of Timeless Decision Theory was a triumph. In fact, I'll make a note here...

## TDT: HUGE SUCCESS

Before we move on, we should take a little while to remark on how awesome this is.

Since the Prisoner's Dilemma was first formulated, it's been held up as a dark and dismal portent for the prospects of cooperation among rational people. Douglas Hofstadter felt, on a philosophical level, that there

mustbe a way to see cooperation as the rational choice, and called it superrationality; but his experiments with actual people were discouraging, and he could find no solid theoretical underpinning for that intuition, so game theorists continued to ignore it.The insight of TDT (as well as the other decision theories we might term "reflexive") is that better results can be achieved when you have more information than the original setup allows; in particular, if it's common knowledge that agents have some ability to predict each others' thought process, then mutual cooperation really can arise out of rational self-interest.

Although it's difficult to make the right conditions obtain between individual humans (as in Hofstadter's experiments), it may be possible for a TDT-friendly setup to exist between different organizations, or different countries, if they have means of keeping tabs on each others' strategic planning. This may in fact have saved the world from nuclear destruction...

John von Neumann, the founder of game theory, advocated a pre-emptive nuclear strike on the Soviet Union throughout the 1950s; he was convinced that there was no other possibility of avoiding nuclear destruction ourselves. But here we have a good analogue to our setup; rather than exchanging source code, both governments had spies placed in the other, and so were likely to know what the other was thinking (albeit with some delay). This might have led to unconscious use of TDT thinking and thus spared us from nuclear war, despite the fact that the professional rationalists of the day hadn't conceived of such means to mutual cooperation!

^{2}But this sequence isn't done yet: TDT may surpass CDT, but it's still under-defined when it comes to bargaining, and there's one notable problem in which TDT falls short of common sense...

TO BE CONTINUED (WITH CAKE) IN PART IV

## Notes

0.As with CDT, there are multiple other variants to consider; this one insists on the best possible deal thatYwould accept against anA, or else no deal at all. The downside is that two such agents will fail to reach a deal if they have different "favorite" deals, even if each would be willing to compromise against an_{f}A. We'll say more about this in the context of bargaining games later._{f}Also, it's very important that we have the sanity check here, since otherwise

Ycould defect againstXand haveXcooperate (as long as Y gets Newcomb's Problem right). Without the sanity check, other agents takeX's lunch money, and rightly so!1.Existence of a proof of S is not enough to conclude that X's sanity test succeeds, since provability is not decidable and so the condition for failing the check doesn't imply absence of the proof. One way out is to have a provability oracle perform the sanity check, which makes it impossible for players to be algorithms. Another is to prove some bounds on the length of the shortest proof of S, and write the algorithm in a way that guarantees the sanity check to succeed within these bounds. Yet another way is to never give up, work on the sanity check forever, which makes the agent completely unable to cope with many situations. (Thanks to Vladimir Nesov for this footnote.)2.Thomas Schelling, among others, worked out a plausibly stable logic of mutually assured destruction, but it still invited all sorts of instability when limited conflict was involved. He also praised the idea of encouraging spies in certain departments rather than prosecuting them, in order to keep the Soviet Union from worrying that we were planning a first strike. If you've never read The Strategy of Conflict, I highly recommend it; it is simultaneously one of the most enlightening and most engaging books I've read in recent years.