 Let us now speak about backward induction and backward induction can be viewed as a way of computing the subgame perfect equilibrium of a game It's a procedure that used Widely or variants of it are used widely in game playing programs be it chess or or other ones and And how does this work? So this is a busy a busy slide And don't be daunted will explain it leisurely Also, the some of you may have not seen algorithms before but we'll explain the algorithm in very plain terms Before we do let's just first Give the intuition and the intuition is very straightforward What we're trying to do is associate a value of the game Not only with leaf nodes with leaf nodes. We know what the value is. It's simply defined by the payoff vector Associated with the leaf node. It's part of the game definition But suppose we want to go to the root of the node or any other internal node and say So what really is the payoff associated here assuming that agents will play a subgame perfect equilibrium? And that's the goal of this procedure called backward induction and the tuition is very straightforward We'll go to the leaves and back up slowly at every step of the of the way Assuming the agents will maximize take an action to maximize their payoff At that node and so that's the intuition now. Let's see how it's done formally The procedure is called backward induction and it takes one argument a node a node in a tree any note could be the root could be a leaf or anything in between and Of course, every node has some players associated with it and just anticipate what will encounter shortly row of H will be the player associated with that node H and When the procedure returned will give us those payoffs as payoffs of To all of the agents associated with that node So how did that work and again? Remember and remembering our intuition We say the following if H is the leaf node Z is a set of leaf nodes If H is a leaf node, then we simply return The payoff vector as defined by the game. That's where the recursion bottoms out Most of the work of course happened in the recursive step when we're not at the leaf node So for that we do the following we will keep a variable called best you till and And best you till will be a vector a vector of payoff associated with the agents each one one with each agents and We will be Updating that that that vector as we as we go along So to start out with will assume the payoff for all terrible. Let's call that minus infinity a Payoff smaller than all possible payoffs in the game And then we do the following We will look at all the actions Available at that node. So kive H is a set of all actions available at that note a would be an example of such an action, so We'll take each action in turn one at a time and do the following We will look at the child you reach by taking action a at that node H That's called Sigma H of a So Sigma H of a simply another node one of the children of node H that you arrive at by taking that particular action a and We'll recursively look at that vector associated with that child and We will Keep it at that at this variable called Util at child So we have two two vectors notice best utile and utile a child Best utile is the best we found so far best for a particular agent and Utile a child is what we found at a child at a particular child will be go over being go will be going over all the children one at a time and If ever the utile at child is better for the agent then the best utile so far Will update the best utile. That's what's going on here So this is what this says it says utile a child is a vector So look at the element of that vector corresponding to the agent we care about the agent and node H If the utile a child is better for that agent Given the best utile what we found so far Then simply update it update best utile to be this utile a child Otherwise leave it unchanged and so in this way, we're cycling through all the children and finding from that agent correspond that to whom node H belong from his point of view which of all the vectors are best and Again the intuition is he will take the action leading to that child and updating that that that vector accordingly and that's why when we're done we returning the best we found so far called best utile that is the back backward induction procedure and Notice that we don't return a strategy. Just return the list of payoffs and And in some sense, it's you can think of it as simply extending the payoff from the nodes to all internal nodes But even though we don't explicitly return the equilibrium strategy the one that will be sub game perfect It's easy to read it off those numbers because at every node The agent will take the action that leads it to the node the child node with the best utility from his point of view So that is the sub game perfect That is a procedure for computing sub game perfect equilibria the backward induction and If we look at the special case of zero sum game It's simplified a little bit because then there are only two players and the payoff for one is Minus the payoff to the other so really we only need to keep track of one number associated with each which with each node and So there's less bookkeeping to be done and furthermore In such zero sum games and all win-lose games are zero sum game for example chess there is a way to speed up the Backward induction procedure by the way in the zero sum game We simply call it the minimax procedure because we alternate between minimizing and maximizing the value one player want to minimize it the other to maximize it and In fact, there's a way to speed up the procedure and We won't go into it here, but the intuition is that as you're visiting a certain Children of a given node You may find out that at that point there's no No need to explore the remaining children of that node as we did in the backward induction procedure because intuitively it won't matter you've already found a value that means that this node that you're examining the parent node will never be visited and It's called the alphabeta alphabeta pruning procedure and optimization of the backward induction or the minimax procedure for zero sum games and You are invited to explore it elsewhere there's one more thing I want to say in connection with backward induction and in fact with sub game perfection and And There's sort of two different things here and they all keyed off the same example the famous example of the centipede game So this well-known example You have two players. They alternate turns We have player one moving and then player two moving and then play one again and pay two and so on so forth but the payoffs are Constructed in a contrived way So that they're gradually increasing and you can imagine it's called the centipede because you can imagine rather than have only Five legs here. You'd have a hundred They saw your rise so that the payoffs here are much smaller than the payoffs here and indeed very much so if you keep going but even though they rise they are contrived in a way that that Leads to only one sub game perfectly cooler be a Playable defect in every place their payable payable go down in every place here So the only outcome sub game perfect outcome is this one where the first player defects immediately Goes down immediately Which is of course similar to the prisoner's dilemma is a little counterintuitive because Had they only had the good sense to keep going They would have gotten gotten something in the ballpark of this or this both of which are much better for both than here But nonetheless when you examined you see that There's only one One once one sub game perfectly cooler beam here And in fact one only one a cooler beam outcome Namely this one and you can see it by doing again the backward induction procedure if the game Progressed and in fact reach this node. What would player one do? Well, they would go down getting a four rather than a three But player two knows this So knowing the player one would go down. He'd rather go down because he'd get a four rather than a three Similarly here player one knowing that player two would go down Elecs to go down here because they would get three rather than two and so on and this is really the backward induction argument so On on the one hand Clearly a clear Account of what will happen this game, but there are two problems. One of them is Sort of simply Experimental and in common sense And the other is a more theoretical On the pragmatic level It's common sense simply tells you this is not going to what's going to happen The players will cooperate for a while until at some point in fact somebody would go down and end the game They know there's so much to gain by going forward. They would if you wish take the chance And this intuition is borne out repeatedly in experiments people do cooperate for a while until in fact eventually they They they defect So that's a problem for theory But there's also a another problem that's theoretical in nature So we know that the only sub game perfect equilibrium is one where agents defect go down at any point in time now imagine that the game starts and Player one goes across does not go down What does player to do? Well on the one hand you could say well The only sub game perfect Equilibrium to go down they should go down Because they'll go through this background deduction argument and it'll tell them that the best thing for them is to go down But that same argument told them player two that player one would have gone down right off the bat but they didn't so Maybe they won't go down again but what will they do and Fundamentally what happens here is you have an event of going across that the Standard theory tells you will happen with zero probability How do you condition on an event that had a zero probability prior prior? There's a This is a big literature on this. It's a very interesting deep-issued game theory We will not delve into it any deeper, but it's interesting to note it