>> Yuval Peres: The next speaker is Janardhan Kulkarni who will tell us about price of anarchy,
the price of independent decision-making via duality.
>> Janardhan Kulkarni: Thanks you all. This is based on my papers with [indiscernible]. There
was a series of papers where this technique was used to bound the price of anarchy. I'm not
going to talk about any specific result here, but I'm going to tell you about the technique which
is the essence of all of the results. Just to motivate, understanding selfish behavior is one of the
main research directions in game theory. A typical example given is think about routing traffic
in large networks. There won't be any centralized entity that can make the decisions on how to
route the traffic, so it's left to the users to decide how to navigate in this network. Typically,
users are self-interested and they choose the route which optimizes their own objective
function or they want to reach other destination is quickly as possible. The question is how the
systems behave like in this selfish setting. I'm an algorithm designer and increasingly this
question is becoming reliant for many of the algorithms we design, not just these kinds of
systems, because the algorithms we design now are being used by other users and hence the
input itself can be very strategic. For example, something like page rank or something ad
allocations, these algorithms are used by users who are self-interested and they can actually
manipulate these algorithms for their own benefit. The question of understanding how these
algorithms behave in selfish settings is of increasing importance in the recent world. One of the
fundamental questions which is focused on algorithm game theory is quantifying the efficiency
lost due to the selfish behavior. If users are behaving in a selfish way, what is the efficiency lost
compared to an optimal algorithm which could have assigned users to a particular strategies
then what would result from such a system, and compare that against the efficiency lost due to
this. In particular, in today's talk I'm going to show how to use convex, linear and convex
programming duality to bound this quantity of efficiency loss. That's the main goal. Just to set
the expectations right, I'm not going to talk about any new result. I'm going to enlist this
technique on something that is already well understood in the literature. In fact, everything
that needs to be known on this problem is already known. Only the technique I'm going to
present is something new and I think it is interesting in its own right. What is the problem I'm
going to talk about? I'm going to look at congestion games which is perhaps the most
important problem studied in algorithm in game theory at least in the literature. The entire
evolution of this literature can be traced to the study of this problem. The problem is
surprisingly interesting, at least the variant of the problem I am going to present. We are given
the network and a set of users, and every user wants to go from some source to some
destination. Here user A wants to go from U to T in a single edge. The user B wants to go from
V to T. This graph is given. These are the users and the users can choose any part they want.
This is usually called the strategy space. If you fix the user B here are two choices of the path to
reach his destination. He can either take the top one or he can take the bottom. Every user has
a set of choices. But depending upon how people choose their paths, they enter some cost. In
this model is called latency and the latency of an edge is basically the number of users using this
edge. In this case if A decided to use the top, the edge E, then the latency of the edge is 2
because both users A and B are using the same edge. They incur the cost of 2 on that particular
edge. What is the player cost? What is the objective every user is trying to optimize? He is
going to optimize the latency he sees along each of these paths. The reason why these latency
functions are interesting is because there is a lot of theory in it, but I am not going to go into
details. The cost incurred by a player if he chooses some path i is just the sum of latencies
along each of these edges. That's the player cost. Select C on this example. Here the latency
seen by player D is 1 on the first edge and 2 on the second edge because both the users are
using the same edge. His cost is 3. On the other end the cost for player A is 2 because he is only
using the first edge. And the latency on that edge is 2. Let me see whether I can use this
interactive thing. That latency is 2. What is the system designer's objective? The system
designer's objective is to minimize the social cost which is the sum of the player costs. That's
the object of the system to the designer. He wants to design systems where every user sees
very little latency. In this case in this example the social cost is 5 because user B sees a latency
of 3 and user A sees a latency of 2. Now to understand selfish behavior we have to make some
assumptions on how the system behaves. Perhaps the most common assumption or widely
studied assumption is that of Nash equilibrium. We believe that when players behave in this
strategy we they all reach a Nash equilibrium. What is the definition of the Nash equilibrium?
It is if no player can decrease his cost by unilateral deviation. Let me make this definition
precise by illustrating on this example. I'm going to claim that this outcome is a Nash
equilibrium because the player, let's focus on player A. Suppose he wants to switch to some
other strategy. I'm going to show that that's only going to increase his cost. Why? Because he
is using this edge going through this and he is incurring a cost of 2. Suppose he switches to
some other path like this. That path is really long because he is going to have a latency of 2
here and 1 here so that's basically like 5 or 6. Now he's entering the latency of 2 but if he
switches to any other path his latency will be much higher. We can also verify that for player B
it is his best strategy given this outcome. This is in fact a Nash equilibrium.
>>: [indiscernible] equally [indiscernible] together [indiscernible]
>> Janardhan Kulkarni: Sure. If you choose another path it will still be a Nash equilibrium. But
this is one particular outcome which is a Nash equilibrium. The way we quantify the efficiency
loss due to selfish behavior is this very nice concept called price of anarchy, which says you take
the maximum of the worst case ratio of cost of Nash equilibrium and compare it against the
optimal strategy for minimizing the social cost. So there is an underlying optimization method
here, but I just want to minimize the social cost. I don't want to worry about it being in the
Nash equilibrium. There is some solution. Let's call it opt. Now since players are behaving in a
strategic way they will reach some Nash equilibrium. I want to look over all possible Nash
equilibrium and bound this ratio. The reason why we care about the worst is if you are a
system designer you can sleep peacefully because I know that every Nash equilibrium is very
close to optimum. We want to understand why what is the price of the anarchy of games. We
already saw that this is a Nash equilibrium and the social cost is 5. Let's see what can be an
optimum solution. I'm not going to give an example of what is an optimum solution, but let's
see some other outcome where player A sticks to his original path but player B now, instead of
using the edge this part which we were seeing earlier, switches to this path. Now the latency
seen by both of the players decreases because in each the player A now sees the latency of 1
here and player B, on the other hand sees the latency of 3. So the social cost is 4, so this is an
outcome that strictly gives you a lesser latency. In fact, for this example, the price is at least
5/4 because we saw an equilibrium outcome where the price is 5. Now it is 4. There are also
generalizations of the Nash equilibrium. For example, mixed Nash equilibrium where your
strategy can be distribution or your strategies are correlated equilibrium, of course correlated
equilibrium and so on. One of the nice things about these generalizations is that pure Nash
equilibrium may not exist for all games. Mixed Nash equilibrium exists but cannot be computed
in polynomial time, but the rest of the things can be computed and you want the course
correlated equilibrium can even be learned to games. So these generalizations of the Nash
equilibrium have very nice properties. One of the fundamental questions I'm interested in is is
there a generic technique to bound the price of anarchy for these various equilibrium notions?
Is there a common technique which we can use? A lot of techniques have been developed in
the literature but is there some unifying techniques for bounding the price of anarchy? And
one such technique is the smoothness framework by T. Roughgarden which basically shows
inequality of the following nature. I'm not going to get into the details of this. Basically, it boils
down to establishing some linear inequalities and then if you can show these game inequalities
are satisfied then the price of anarchy is bounded by lambda [indiscernible] mu. Let's not get
into the details. In my view I think this is some sort of high potential function argument. You
have a game. You have some outcomes and you want to design some nice potential which is
going to bound the price of anarchy. But in this talk I'm going to show something different
which I think is equally powerful and that is based on the idea of duality. This is something that
people in approximation and online algorithms used almost like every other proof of
approximation algorithm used literally these ideas. What is the high-level thing? The high-level
thing is use the big duality theorem. In particular, there is an underlying optimization problem.
I'm going to write a linear or a convex programming relaxation offering. We know from the
duality theory that the corresponding dual linear program or the convex program that any
feasible solution to the dual is a lower bound on this act. One of the classic, the trick in
approximation online literature is to use, to connect the algorithm cost here to some feasible
dual solution. And the week duality [indiscernible] this if I can bound this by some factor alpha
then that's going to be an approximation factor for this. In this is something that we use in
approximation algorithm literature quite often. The take of it for my talk is that the same trick
can be used to bound the price of anarchy. Price of anarchy is still an approximation ratio but
here you are imposing the fact that you want the outcome to be Nash equilibrium. In
particular, I want to look at the Nash equilibrium outcome. Suppose this is some Nash
equilibrium optimum and I want to use this Nash equilibrium condition and produce a dual
certificate and I want to show that by doing this I'm only losing the sum factor of alpha and that
would give me the price of anarchy. It's very similar to what people have used in the
approximation online algorithm. This is the overall goal of the talk. I'm going to show this, how
to do this using one concrete example of the condition games. Is the high-level picture clear to
that's the thing. In this case I construct a linear program but we can write a convex program.
Let's see what it is. Just before I write the convex program but may make some small
observation. Any questions?
>>: Is this for lower bounds for the price of anarchy?
>> Janardhan Kulkarni: Upper bound.
>>: Upper bound? Because you need to look at the worst?
>> Janardhan Kulkarni: Yeah. I mean, I'm not even going to assume what is this Nash
equilibrium. I'm going to just look at some Nash equilibrium and I'm going to produce a dual
certificate which satisfies, I'm going to share a feasible solution using that. I'm not making any
assumption on whether it is the best or worst her anything. It can be any Nash equilibrium as
long as the outcome is in -- in particular it means that if this was the Nash equilibrium the
highest cost I'm going to bound that also.
>>: Is it from the English word any? So you mean every?
>> Janardhan Kulkarni: Okay. For every Nash equilibrium. In particular I am not bounding the
price of stability. I'm in fact bounding the price of anarchy. To help me write the convex
program let's make some small observation which is very simple. I can write the social cost
which is the sum of the player costs and simple latencies, the square of the latency on each
edge. Because if you fix an edge E that is being counted among all of the players, and the
latency is equal to the number of the players, so the social cost is basically the latency squared.
So this is a simple thing. Let's write the convex program. in the convex program are two
variables, xij which basically says the player j takes the path i in the graph. There is a variable ye
which basically measures the latency of this edge. I need this pattern Li which is length of path
i. This is not a variable this is just some constant, but every path i Li is just the length of this
path. The objective, here min is short for minimize. Objective is basically ye squared because
that's my social cost, so this is just my latency squared. And here I need this extra term and for
this talk I will just briefly sketch why I need this extra term. We thought this linear program has
a large integrality gap. Think about only one player and n paths and then we thought this Li
term the cost would be 1 over n squared, which is not really true because the player has to
choose at least one path so his cost is at least one. The way to fix it is if a player j chooses a
path i he has to pay at least Li, the length of the path because he's at least one user using the
path. If this is not clear then we are not going to bother too much. We need it to fix the
integrality gap of this convex program. But the objective is quite simple. This is basically Ye
squared which is what my social cost originally.
>>: Your original formulation, the length of the paths differ from the cost. You have the length
times -- oh this is the length of the total?
>> Janardhan Kulkarni: Yeah. This end even is a lower bound on this.
>>: I just want to make sure I understand. You are allowed to divide between all sorts of
different paths?
>> Janardhan Kulkarni: No. That is splitable. In that case I don't need this. That's a good point.
If I was allowed to split, choose like, fractionally choose the path, then I don't need this dump. I
pull out all of that Ye squared and all that. I won't need it. But here in this, what I'm talking is
you to choose one of the paths integrally.
>>: So this is specific for the specific latency function on the edges?
>> Janardhan Kulkarni: It generalizes and I'm going to show it at the end of the talk. It
generalizes to many, many problems.
>>: Can you just rephrase again why you get the second term [indiscernible] objective?
>> Janardhan Kulkarni: Okay. Let's take one concrete example. There is a path with n edges
and parallel edges and there is only one player who wants to use this graph. If I only put the
first edge, the linear program is going to say take one over n and I am going to take each edge
to extent of 1 over n. My objective is going to be 1 over n squared, but the player incurs at
least a cost of 1.
>>: It would be 1 over the summing.
>> Janardhan Kulkarni: Okay 1 over…
>>: One over n.
>>: N, n transcript.
>> Janardhan Kulkarni: Okay. There were multiple players…
>>: [indiscernible]
>>: One over n, but it should be 1.
>> Janardhan Kulkarni: Right. But since it he is using at least one edge he has to pay a cost of 1,
so that's what this term is fixing. If I took the path i, I'm going to pay at least 1 along each edge
whether there are other players in the system or not, I'm going to pay. And so that's what I'm
saying it is Li.
>>: You are thinking of a related [indiscernible] relaxation and Xij is going to take either zero or
one for each part, but that's in the model where you could take several different paths?
>> Janardhan Kulkarni: I want Xij to be 0 1 but I can't solve that version. I'm going to relax it
with a linear convex program, so there it can take fractional that use.
>>: So in the integer case on the right-hand side is [indiscernible] less than the left hand side,
but then the fractional case it's bigger and so you can [indiscernible]
>> Janardhan Kulkarni: Yes.
>>: So really it shouldn't be Ye's play. It should have been Ye times a number of people who
use it. But if the integer is 10 equal square. That's the [indiscernible] fractional [indiscernible]?
>>: You supply those two?
>> Janardhan Kulkarni: Yes, exactly. Okay. Is it clear? So what are the constraints? The
constraints are fairly obvious. Xij means that player j is using this path i so there are multiple
choices of paths he has. He has to take one of these. So Xij is just one. So [indiscernible] Li has
to be one, so basically says that every player chooses a path. And then what is the second
constraint? The second constraint is going to say that the latency on edge is at least the
number of players using that edge which is basically summation of all of i and summation of all
j, Xij where path i uses this edge e. So this is over all paths which use the edge e. Suppose
there are multiple paths going like this. You fix an edge e. Then that is the summation over all
of that and Xij is the player i is using. Player j is using the edge i is not. So Ye has to be at least
this quantity.
>>: I'm still confused about one. So i is an edge in one and we are summing over edges?
>> Janardhan Kulkarni: No, i is just all possible paths he can take, the player j can take.
>>: [indiscernible]
>> Janardhan Kulkarni: [indiscernible] path, so this graph is given to you. The convex program
is fairly obvious. There are no special tricks except to fix the [indiscernible]. This is a convex
program. This is not a linear program and the people who are not familiar with how to take the
dual of this, I'm not getting into the details. There is a very nice survey by Nikhil Devanur who is
not here. You can see how to write the dual of this linear program. In the way that you can
separate the constraints from the objectivity something similar to the LP duals. Here the dual is
something like this. It gives a variable j, alpha j for every player and it use a variable beta e for
every edge. So that's the objective. It's all obtained using standard taking the LP duals. There
is nothing deep going on here. But let's understand these constraints. This is where I'm going
to, this is very crucial for price of [indiscernible] analysis. What is this constraint trying to tell
me? The constraint is telling if you fix -- the dual is going to give me one variable for every edge
and there is a constraint for every player and every set of possible paths for every pair ji. In
particular, if you fix a player j, so these constraints says that alpha j has to be less than all
possible beta e plus Li. In particular, it has to be less than minimum or all possible edges e.
Maybe the player is going to take this path or maybe the player is going to take this path.
Corresponding to every path that is a constraint and what the dual is telling me, this alpha j,
whatever may be the value of this alpha j, it has to be less minimum of these two quantities.
Let me derive this. This is what this dual is telling me. The alpha j in the dual solution has to a
minimum of all the constraints at hand are responding to the player and this is very similar to
what Nash equilibrium is trying to tell. Nash equilibrium is telling that in the Nash equilibrium
outcome the cost of the player has to be minimum or all the strategies he has. The cost
incurred has to be minimum of these quantities. So this is what dual constraints told me and
this is what Nash equilibrium is telling me and perhaps there is a connection. I mean, this
pattern we cannot miss. So maybe this beta e plus Li, this quantity, I want to interpret as the
cost of player using this strategy i. Essentially, that's what I want to show. In particular, I'm
going to define alpha j as the cost the player incurs in the Nash equilibrium theater and beta e
to be the latency on this edge e. So there is some outcome. This is the Nash equilibrium. I am
not making any assumptions on this Nash equilibrium and player j incurs some cost. Just define
alpha j to be that quantity. In this outcome beta e is the latency on this edge. So what happens
if I define like this? A particular note of the cost alpha, cost of j, the cost incurred by player j is
going to be minimum or all this because of the condition of the Nash equilibrium. And this
immediately gives me some bound on the price of anarchy, just by the definition. Because
what is the dual objective? The dual objective is summation of all player cost minus beta e
squared. But the definition I define alpha j to be the cost of the player in the Nash equilibrium.
So the first term is just cost of the Nash equilibrium and the second term beta e squared, again,
is the cost of the Nash equilibrium because I define beta e to be the latency. This gives me the
dual objective at least three quarters the cost of the Nash equilibrium, three or four, which
means the final objective is at least this and this will give me a bound of four thirds. In fact, if
someone asks me whether the players can choose fractionally, in fact if the players chose
fractionally, this, in fact would give me the bound of four thirds on the prices anarchy which is
tight, intact. Since I used this Li term in the objective, in the primal objective, which means that
the primal was not the lower bound on the opt, you lost some factor there, so if you take that
into account, then you really get the price of anarchy. I'm not going to do that, but it used a
type bound known for this problem. How much more time do I have? I think, I don't know why
it doesn't show the time here. I'm almost done, so I'm left doing only one thing to show that
the constraints are satisfied. Let's just verify for one case. Why is this constraint satisfied? The
alpha -- it's fairly obvious because alpha j is basically has to be less than beta e plus Li and the
way I've defined beta e is just the cost of using this edge and that's what -- I set alpha j to the
cost of the player and the beta e is just the cost of using this edge and that, by definition
satisfies the complaint. If the player switches then I have to argue that the cost of
[indiscernible] increases by at most one and that's where this quantity Li [indiscernible]. Okay?
But this is just by definition these constraints are satisfied. I am now bound to the more gentle
concepts of equilibrium instead of setting the cost, you set in expectation if the distribution is in
cost correlated equilibrium you take expectation of these quantities and the entire proof goes
through. So someone asked me whether this is very specific to this problem. It's not. I could
prove like all of these results and obtain the tight bounds exactly in the same proof technique.
In fact, there were several open problems like coordination mechanisms for temporal routing
and things which were not known how to solve using smoothness framework and we can get
results using this. And these were the first results known. And at least to my understanding I
think the smoothness framework and the duality are equally powerful, although I might be
wrong. And that's one of the questions worth exploring. And one of the things this technique
highlights is that can we use this to bound the price of stability. If you start with some dual
feasible solution and say that I can modify these duals for feasible solution in a way to bound
the Nash equilibrium [indiscernible] Nash equilibrium, then we can also get price of stability
results. Okay? That completes my talk. I will leave you with this picture of the entire
framework. Thank you. [applause]
>>: So [indiscernible] over the break, so we will continue.
>>: I suppose…