>> Nikhil Devanur: So welcome, everyone. It's my pleasure to introduce
Vasilis Gkatzelis. Vasilis is a postdoc in Berkeley currently, and he'll be
a faculty at Drexel soon, and recently has done some very interesting work in
algorithmic game theory, and in particular how to allocate goods to agents in
a fair manner. So he'll talk about approximating Nash social welfare, which
is one measure of fairness. So over to Vasilis.
>> Vasilis Gkatzelis: Thank you, everyone. So I'm going to talk about how
to approximate the Nash social welfare with indivisible items. So the goal
here will be that we'll have a set of indivisible items that we want to
allocate to a set of participants and, as Nikhil mentioned, the Nash social
welfare is a measure of fairness. We're going to try to maximize fairness
and some notion of efficiency at the same time. And this is joint work with
Richard Cole at NYU.
So let me dive right into the specifics of the model. So we want to
distribute a collection of items among a set of agents, and each agent
assume has additive valuations. So let me define this right away. So
have -- in this case let's say we have these five items and we have an
I. So the fact that agent has additive valuations means that we can
represent his preferences using a vector of just five numbers, one for
item.
Let's
means
would
value
we
we
agent
each
say these are the numbers: 15, 2, 4, 5 and 3. In this case, this
that if we allocate the first item to the agent, his value probably
be 15. If on the other hand we allocated item 2 to the player, his
would be 2.
The part where additive makes more sense is where you have more than one
items. When the player is allocated two items, 2 and 3 let's say, then his
value is the sum of these two, which is where additive comes from. And you
can imagine if he gets 2, 3 and 4, his value is 11; 2, 3, 4 and 5, his value
would be 14. You just sum up the corresponding numbers.
And the important thing that these numbers tell us is that, for example, in
this case, if you had to choose between giving this player this one item or
the bundle of items 2, 3, 4 sand 5, this says the player actually prefers the
first item. So it tells us in a concise way what the preferences of the
player are.
And we're going to assume that this is a case throughout the talk; that the
valuations are additive. So this is, of course, more interesting when you
have more than one agents that are creating for these items, and you're
trying to find a way to distribute. Essentially your distributing value
across the players.
And we're going to be denoting the set of agents by N and the set of items by
M. And the items are indivisible. This means you cannot cut an item in half
or in smaller pieces and give it to more than one players.
And also that for each agent we're going to be using a variable, XIJ, which
is either 0,1 because of the indivisibility, which is an indicator variable
regarding whether agent I will actually get item J or not. Okay. So
formally this could be a matching -- sorry, an assignment of the items.
Since I mentioned.
So we're not going to be talking about matching the items to agents. An
agent can get more than one items. And for each agent I, the valuation of
the player is going to be denoted like this. Okay? So it's just the sum
over all items of XIJ times VIJ, whether the player got the item times his
value for that item.
Make sense? I'm going really slow, but just to make sure.
fundamental setting.
This is a
So the question here is over all -- this is your design space. You can
choose over all these possible ways of allocating the items. The agent, the
question is which one do you want. And we're going to be shooting for
fairness, making sure the allocation of the items is fair and in some sense
also efficient.
And when people talk about efficiency in this setting, the first thing that
comes to mind is what is called the utilitarian social welfare; that is, I'm
going to try to allocate the items in a way that maximizes the sum of the
values of the players. So the aggregate happiness, the aggregate value, the
sum of the values.
Which, if you look at this setting, can you imagine what that would be?
There are more than one ways to do this, maximize social welfare here, but
this is one of them. Right?
So this maximizes social welfare. You can see that the sum of the values
would be maximized in this way. So clearly this is extremely unfair. Right?
So one player gets nothing; the other player gets everything.
So just maximizing this, you contain social welfare alone, can be really
unfair as an outcome. So our goal will be to introduce fairness into this.
And the standard way that people have been approaching fairness is what is
called the egalitarian social welfare. And that is our goal in this case
would be to maximize over all allocations the minimum value across all
players. So, in other words, try to make the least happy person as happy as
possible.
And you might have seen this. This is a well-studied problem, exactly the
setting I've just described, the additive valuations in this objective, and
it's called the Santa Claus problem, is one way in which you might have heard
of it before, and there's a long line of results. But in this general
setting there's still a big gap in terms of the approximability of this
problem.
But given this objective, can you figure out what that would do in this
allocation, that same instance as before. If you try to maximize the
minimum.
>>:
[inaudible].
>> Vasilis Gkatzelis: Exactly. So it's extreme in the other sense. It
gives all the items to the hard-to-satisfy agent, and the other agent gets
just one item. So in some sense this is an extreme notion of fairness that's
trying to satisfy maybe a person who's really hard to satisfy and sacrificing
efficiency.
Our goal here will be to find a balance between the two, and what we're going
to be trying to maximize is the Nash social welfare objective, which is the
geometric mean of the values. Okay? And before I explain why this is a
well-motivated objective, let's see what it would do in that same instance
again. And let's start from the max min allocation that we had before.
So you can verify easily that this is actually not maximizing the geometric
meaning in the following way. If we get seven item -- item 7 and we take it
from agent 1 and give it to agent 2, agent 2 doubles his value, whereas agent
1 doesn't have -- it's still not losing as much. So that would be actually
an improving change. So would this one. So would this one. And, in fact,
this is the product maximizing or geometric mean maximizing allocation.
So, intuitively, in this instance, you can see how it balances. It tries to
distribute value in a balanced way. But let me make it a bit more concrete.
So this objective, the Nash social welfare objective, satisfies some highly
desired properties.
One of them, which I think is really important, especially in this setting
where there's no payments, it's just an allocation, it satisfies
scale-freeness. That means that the outcome does not depend on what scale
the VIJ values are reported in. So if I take for every player I some
parameter, some positive value alpha I, and multiply all the VIJs by the same
value, this will not change the outcome in any way. Right?
And this is very important because usually when there's monetary payments,
you can express the values in the sense that this is -- the value means how
much would you be willing to pay for this item. But once there's no values,
this means nothing really. The scale might not necessarily be -- have any
specific meaning.
So if I multiply all my values by a big constant and that changes the
outcome, this is a bit tricky. There's no real reason why that should
happen.
And it's easy to verify also that if you think about the previous two
objectives, the utilitarian and the egalitarian social welfare, they both
heavily depend on the scale. In the utilitarian, you would want to scale
upwards, in the egalitarian you would want to scale downwards, whereas in the
product it doesn't matter.
And this is the real information. The real information that you're trying to
get from the participants is the relative preferences across items. The
scale doesn't matter. So this is the objective that satisfies this, and that
avoids this interpersonal comparability of individuals' preferences. This
means numbers, the scale of 1 should be comparable to the other in a
particular way.
And the second good thing is that it strikes a balance between fairness and
efficiency. And you can see one way to see it is this; that this is the
generalized mean. And if you take P going to minus infinity, you get max
min. If you take P equals 1, you get the average, the utilitarian social
welfare. And for P equals 0, you actually get the geometric mean. In some
sense it lies between these two extremes. It still tries to balance value,
but it's not going to do it in a really abundant and efficient way.
And another reason why it's -- this is interesting is that the same objective
has been discovered by many different communities. It is the objective
optimized by the Nash bargaining solution. It is the proportional fairness
objective in networking. It's also the competitive equilibrium for equal
incomes objective, or the Fisher market objective.
So in many different communities -- economics, networking, and others -- this
arises naturally. And as I'm going to be mentioning later, maximizing the
product is equivalent to maximizing the sum of the logs. Maybe this sounds
more intuitive. You've seen it somewhere. Okay. So hopefully I've
convinced you that this is an interesting objective to understand and
optimize.
So let me formally define our problem. So let X star be the integral
allocation maximizing the Nash social welfare. Our goal is going to be to
design an algorithm computing an integral allocation X that satisfies this:
The geometric mean of the optimal is at most some raw factor of what we get.
>>: [inaudible] approximation, why -- what makes more sense, the geometric
mean or say the sum of logs?
>> Vasilis Gkatzelis: So you're saying -- I mean, if you get the geometric
mean approximation, a multiplicative one like this, you get an additive false
at the same time for some log. So it's a stronger ->>:
Makes sense to get [inaudible] approximation sum of logs?
>> Vasilis Gkatzelis: So I'm not sure that there would be -- I mean, yeah, I
think in some sense that log transformation is a bit less intuitive, what
happens and what you should be [inaudible] this. And here essentially you
know that, for example, if you get every player half the value they should be
getting, you get a half approximation.
Essentially I think the log kind of messes things up. But I'm not sure what
the right thing would be. I don't know why it would be wrong to aim for log.
But this in some sense is stronger.
>>: So the other thing is like if you want -- if you get zero, will you get
zero on both? Like ->>:
Yeah, log or -- log zero P minus.
>> Vasilis Gkatzelis:
it would be zero.
>>:
Zero.
Okay.
Yeah.
Yeah.
Yeah, but you don't want that either way.
Here
Okay.
>> Vasilis Gkatzelis: But, yeah, at some point we started thinking about the
sum of the logs because it's a modular function. So we're thinking like, oh,
maybe I could do like a greedy-like allocation rule, but it's messy. It
didn't seem like all the greedy-type approaches that we tried didn't seem to
make sense. And that would only give a multiplicative in it. But maybe
it's -- yeah.
So the best known algorithm before our work was growing linearly with a
number of items.
>>:
So what is NR?
>> Vasilis Gkatzelis:
>>:
Gwen?
>> Vasilis Gkatzelis:
>>:
Oh, Nguyen.
And Rothe.
Nguyen.
Oh, okay.
>> Vasilis Gkatzelis:
>>:
Yes.
What is N?
>> Vasilis Gkatzelis:
>>:
Nguyen and Rothe.
That's how it's [inaudible].
I see.
And?
Rothe.
Oh.
>> Vasilis Gkatzelis:
And after our --
>>: What was the context in which they [inaudible]?
[inaudible]?
>> Vasilis Gkatzelis:
Same problem, yes.
They just wanted
>>:
I see.
>> Vasilis Gkatzelis: And the problem was very recently shown to be APX-hard
after our talk at TED Talk.
>>:
[inaudible]?
>> Vasilis Gkatzelis: I'm not sure. He's a student at CMU.
remember the name. It's an archive, the paper.
I'm not sure I
Okay. So our main result is that we propose an algorithm that achieves a
small constant approximation factor, 2.889, which at least to us was a bit
surprising that you actually can do that. And, yeah, the talk is going to be
around how we achieved that approximation, how -- the problems that we had to
face.
So formally we can write this -- the problem that we want solved is exactly
this one. We want to maximize the geometric mean subject to the valuations
which are additive, and we don't want to overallocate any item and the XIJs
are between 0 and 1.
And the first observation is if you take a log of the objective, as I
mentioned before, you get the problem of maximizing the sum of the logs of
the utilities, which is convex, so it's getting better because the previous
one was horrendous. And if you relax the integrality, then what you actually
get is the Eisenberg-Gale problem, which has been well studied and we can
solve this.
So the first reaction is great, let's solve this program and then try to
round it and get a good approximation algorithm. Unfortunately this fails
miserably because the integrality gap of this program is unbounded.
And let me give you an example. It's an easy example to consider, but just
to get a sense of why this happens. This is just an observation. That if
you have these items, M items and N agents, but every agent has a very, very
strong preference, let's imagine this V being arbitrarily high, a really,
really strong preference for the first item, then in a fractional solution
the players can share the top item. And that gives ->>:
[inaudible] only one item that you could --
>> Vasilis Gkatzelis: That too. But I just want -- this is kind of -- the
reason I avoid this instance is because it's kind of the product would be
zero anyway. So, sure, yeah, the integrality gap, that instance is kind of
easy to solve. But you can imagine even if these other items have some small
value, it might be hard to figure out whether you can actually achieve it.
But, yes, even just having one item would also give you the integrality gap.
So, yeah, they can share it and get a high value, share essentially the high
value, but in reality only one of them will get it.
there's no way they can actually get this to work.
So it's clear that
So what this shows is that there's no way to prove, using this as an upper
bound, the fractional objective value as an upper bound, to prove a good
approximation.
>>: So just to be clear, suppose [inaudible] suppose the values are either
like zero, like some values are zero, some are not zero.
>> Vasilis Gkatzelis:
>>:
And I want to check whether the answer is zero or not.
>> Vasilis Gkatzelis:
>>:
Yes.
We achieve a [inaudible], yeah.
[inaudible].
>> Vasilis Gkatzelis:
>>:
Mm-hmm.
Your [inaudible], right?
>> Vasilis Gkatzelis:
>>:
Yes.
Yeah, yeah.
Yeah.
But how [inaudible] but your current program cannot do it?
>> Vasilis Gkatzelis:
No, we're not going to use that program.
Yes.
>>: Yes. But that's [inaudible] that's a matching, right? You're doing
[inaudible] matching, like I just want to say there's a matching, of course,
and [inaudible] zero, nonzero, right?
>> Vasilis Gkatzelis:
>>:
Yeah.
[inaudible].
>>: So can you go back to the [inaudible]?
them, right? That's yes?
>> Vasilis Gkatzelis:
>>:
Yes.
So [inaudible] you can remove
Yes, it's just for [inaudible].
Okay.
>> Vasilis Gkatzelis: So, okay, so what our solution is going to revolve
around and the intuition will come from is the fact that, in fact, this
program we're just looking at has a very natural interpretation as a market
equilibrium. And you don't need to know exactly what I mean by that. I'm
going to explain how this works.
You can imagine if you take this instance that each agent is allocated a
budget of 1, $1 of money that has no value beyond this particular setting.
The goal is to spend all of this money. And there are prices. For each item
there's a price, PJ. I'm not going to at this point tell you yet how we come
up with these prices. These are the duals of the program. But let's say we
have them.
So once I give these prices, and you can imagine the agents arriving one
after the other. Think of agent 1 arriving. What are the preferences? He
has a value of 15 for the first item; zero for everything else. Clearly he
wants to spend his money in the best way possible, which is spending it all
on the first item. Right? So he can spend his $1 on this item, and he buys
a third of that item.
Then the second player arrives and you can verify that the value per price
ratio is the same for these two items for the players. So he's indifferent
between these two. However he spends his money between the two is fine.
I'm going to intentionally tie-break upwards in this case and have him spend
his money optimally again the way he would to get the best he could get using
that -- those prices and buy the second third of that item.
And we continue the same way. If the third player arrives, you can verify
the maximum bang per buck items, the ones that have the best value per price
ratio, are 1, 3, 4 and 5. So, again, I will tie-break upwards and let him
buy the remaining third of that item.
Conveniently, when the last player arrives, he likes all these items equally,
and the sum of these prices are 1, so he can buy them all, and that's
perfect. So that's market clearing.
So the very nice thing about this is that what we require is that every
player is spending his money on his -- to buy his best bundle given the
prices. All the items are fully allocated and all the players are spending
all of their money. Once you have these properties, you know just by even
showing you this, you know that this allocation maximizes a product. Okay.
So the issue -- and let me make another point now. So before I made the
point that the integrality gap of this program is high, now I'm going to less
formally try to convince you that apart from -- so in that sense the program
fails to give us a good upper bound because it gives you high integrality
gap.
But I'm going to argue here that somehow it also doesn't give you a good
fractional solution to round from. So if you look at this one, you know that
since the top player has no other alternative, he really only likes the first
item, he will essentially get it. If you want to maximize, he should be
getting that item. But there's also player 2 and player 3 that in this
fractional solution, all you know about them is that they're getting a third
of that item as well.
But if you look at their preferences, they're very different with -- they're
absolutely different with respect to their preferences other than that first
item. So knowing that they will not be getting that first item, you have no
information about how to distinguish how to round one and how to round the
other. So these two are very different. But in terms of your fractional
allocation, they're the same. So you can imagine if I make this even more
expensive that there will be more and more information lost inside this
fractional location. Okay?
And based on this intuition, what we do, so we started from the
Eisenberg-Gale program, we moved into the market equilibrium interpretation.
What we're going to do now is to tweak the market equilibrium interpretation
to get a different equilibrium that reveals more information and helps us get
a good upper bound. Right? We're not going to use this; we're going to use
a different one.
In order to do that, the main
how much spending can go into
outcome that we aim for. The
one dollar to be spent on any
is the most that can be spent
defining.
trick that we use is we apply a constraint on
any item. And this is the spending-restricted
spending-restricted equilibrium allows at most
item. Right? So one player's worth of budget
on any item in this new equilibrium that I'm
So in this case this fractional solution that we saw before violates this.
There are three players spending one dollar. So there's a total of $3 going
into this item. So this is not allowed in this new constraint that we
introduced. So in order to get an equilibrium that satisfies this additional
constraint, we have to keep -- you can imagine that if I disallowed player 2
or player 3, if they arrived in the same order, I disallowed them to spend
their money on 1, then they wouldn't be able to spend. The prices, all the
other prices, are too little. There will be too much demand for the other
items.
So in order to find this, we actually keep increasing the prices. And we can
discuss how we figure out these new prices later on, but we come up with
these new prices. And you can verify that these prices satisfy the
additional constraint plus most of the ones we had before.
In particular, this is a new market equilibrium in the following sense:
Player 1 arrives, still his preferred item is the first one. Right? So he
spends his money there. That means nobody else can spend on that item
anymore because there's $1 spending going into it.
>>:
But its price is $10 or -- in this picture, so whatever --
>> Vasilis Gkatzelis: Yeah, so the prices can be higher.
this is not fully allocated. So there's a price ->>:
It's a fraction allocation?
So in this case
>> Vasilis Gkatzelis: Yes, it's still a fraction allocation. So you're
buying one-tenth in this case. But the players still prefers one-tenth of
item 1 than anything else.
>>:
But nobody else can know --
>> Vasilis Gkatzelis: Yes. So not -- yes. Yes. So the rest of it will be
unallocated. In the fractional solution. But we only use it as a guide.
We're not going to -- so then the second player arrives. He's equally again
interested in the first and the second item.
>>: So the restriction that nobody spends more than $1 on item 1, it's not
really restricting the optimization problem for the buyer?
>> Vasilis Gkatzelis:
>>:
I'm still -- the players --
[inaudible].
>> Vasilis Gkatzelis:
>>:
Yes.
Exactly.
[inaudible] buying the optimal binder.
>> Vasilis Gkatzelis: The players are the
And we have to allow them to be able to do
constraint. Exactly. And you can verify,
now, that in fact here I can combine their
constraint.
still buying their optimal bundle.
that while satisfying the
and this is what I'm verifying
preferences with the additional
So player 2 arrives. He's indifferent between these two items. And now I
will let him buy this one, which means nobody else can spend on item 2 either
now.
Third player arrives. He is indifferent between these items. I'm going to
choose let's say this way of him spending his money, which means he pays
two-thirds, gets all of this, and one-third, he gets half of this. And the
last player arrives. He's interested in all these items, and there's a way
again to spend his money.
Okay. So to be more precise, the constraint that I want is if the price of
the item is higher than 1, the spending has to be 1 exactly. If the price of
the item is less than 1, then I want it to be fully allocated. So the
spending on it is exactly the price.
And what I verified with this example again in this new outcome is that every
player again buys his favorite bundle of items, spends all of his money, but
instead of the items being fully allocated, I have this new constraint now;
that the spending cannot be more than 1. Which means maybe some of them are
not fully allocated. Okay?
So this will be at the center of our result. We use this fractional
solution, this spending-restricted outcome, in order to come up with an upper
bound and a rounding algorithm. And the intuition -- one thing that I want
to mention compared ->>:
[inaudible].
>> Vasilis Gkatzelis:
>>:
Excuse me?
Like I'm not sure that it [inaudible].
>> Vasilis Gkatzelis: So up until -- like the answer to why they exist is
that we have an algorithm for computing it. But I just -- a few hours ago I
realized there's also a convex program for computing this solution. And
these ->>: [inaudible] put this restriction that I like won't collect more than $1
for each?
>>:
[inaudible] different convex [inaudible].
>> Vasilis Gkatzelis: Yeah. It's a different convex program. But yeah. We
didn't know that. So I'm going to come back to that later on, how to reach
these prices.
But what I wanted to notice here is that remember these players I mentioned
we had no information about, why the previous fractional solution was not a
good guide for the rounding algorithm? You can see here that by applying
this spending constraint I forced these players to spend on less demanded
items. I pushed the demand to lower items.
And now you see that player 2 and player 3 have revealed much more about
their preferences than before. Now I can tell them apart. I can tell that
player 2 wants item 2, player 3 wants item 3 or 4. So as we're going to
show, this help us round and get a good approximation.
Okay. So the main contributions that we get are the following. First that
the spending-restricted outcome, what I just described, is computable in
polynomial time. In order to do this, we actually used some algorithms that
were known -- combinatorial algorithms that were known for computing the
solution of the Eisenberg-Gale program by Devanur, et al. But apparently
there are different ways of doing it now.
And the second one is that the spending-restricted outcome implies a better
upper bound for the optimal solution, and finally that the
spending-restricted outcome reveals useful information for rounding, which is
kind of more of an intuitive point that I just made before.
>>:
What do you mean by the second point?
>> Vasilis Gkatzelis: That it implies a bound where -- which has low -which approximates opt in a better way. Yeah. I mean, we can actually
prove -- we have an upper bound that we can prove a good approximation with,
whereas the previous one there was no hope.
>>:
Like it's not even clear to me what the upper bound is.
>> Vasilis Gkatzelis:
>>:
Yes.
I'm going to describe this.
[inaudible].
>> Vasilis Gkatzelis:
a good bound.
Yeah.
But since we can prove a constant factor, it's
>>: No, no, I don't care what good.
other bound is.
>> Vasilis Gkatzelis:
>>:
Yeah.
I just want clear [inaudible] some
Yeah.
[inaudible] different question.
>> Vasilis Gkatzelis: Yeah. So, okay, so first of all, when it comes to
computing the spending-restricted outcome, the issue is that the spending
constraint that I applied, I said there's the amount of spending that can go
into any item is at most 1. The spending is neither the primal nor the dual
variable. It's a combination of the two.
So, in fact, where we used to have the sum of the XIJs being equal to 1,
everything is fully allocated, we're now replacing it with this. The sum of
the XIJ times PJ is the minimum of 1 and PJ. Right? So XIJ is a primal; PJ
is a dual. So the thing is that this constraint that we introduced, we
didn't know how to write it as one convex program anymore. It was not clear
that we can just introduce this constraint in here anymore.
So in order to achieve this, we use those combinatorial algorithms that I
mentioned before where this constraint just fits in perfectly. And in fact
we get a strong polynomial algorithm out of it, which is still of some value.
>>:
So what is J, and J's [inaudible]?
>> Vasilis Gkatzelis: Yes. So for every item J, you know that the XIJ -- so
this is the amount of spending that some or all agents, XIJ is how much the
agent gets of that item, PJ is how much the price is. So XIJ times PJ is how
much the agents spend on that item. So if you sum over all agents, it's the
total spending on that item. And you want this to be at most to be the
minimum of 1 and the price. Okay.
So that's the first thing. I'm going to come back to this later on if you
want to discuss this. But I guess the more interesting thing --
>>: Go back again.
objective.
>> Vasilis Gkatzelis:
>>:
So it's not clear to me why this is a bound on the
It's not a bound.
It's not a bound.
[inaudible] restating the --
>> Vasilis Gkatzelis: Just restating what we computed. What I'm saying, the
outcome that we're trying to find can be described in this way. It's like
the constraint we're introducing doesn't fit with a known program that we're
using program, the Eisenberg-Gale program, is all I'm saying. So it's not
clear how to compute it ->> Vasilis Gkatzelis: That's not what I'm asking.
be using the objective of any program.
>>:
The upper bound will not
Okay.
>> Vasilis Gkatzelis: Yes. So in order to get the upper bound, we'll be
getting it in an indirect way using this solution. And this is the next
slide. So if you look at this instance, the first -- yeah. So the first
thing I'm going to do -- so this is proof by -- the upper bound is proof by
picture a bit. But if you want, I can just take it and figure everything out
if you're interested.
But the question here is we have this -- right. So I mentioned that the
valuations, the scale of the values doesn't matter. Right? So I can scale
upwards or downwards, however I want. So for convenience, in order to
express our upper bound, I will scale everything so that every player's value
for his -- the item he's being allocated is equal to the price. Right?
Essentially I'm multiplying by the inverse of this MBB, the maximum bang per
buck ratio, your value divided by their price. I'm multiplying by this, and
we get this. So the -- essentially you get 10, which is as much as you
spend.
So you know that after doing this, you're either -- your value for an item is
either the price or less than that. It's the price -- it's one of your
favorite items. It's less than that if it's not one of your favorite items.
So right now, after this multiplication, the scaling of the values, I know
that everybody's value for an item is at most the price of the item. Okay?
And I haven't changed anything. It's still well defined.
And then the second thing we're doing is we're saying here are the highly
priced items, everything that has a price higher than 1, and the low priced
items, the ones I have priced less than 1.
Roughly speaking, just to give you a sense of what we're doing, to get the
upper bound, we're going to argue -- to show -- we're going to prove an upper
bound for the case that H is integral, L is fractional. Right? We're going
to assume these items are divisible. But H, the items in the H, the
important ones, are indivisible. And we're going to prove an upper bound for
that case. Okay?
So partially relaxing the allocation space. And using this, we're showing -and this is the tricky part. This is why I scale the values, so that we can
express the upper bound as a function of the prices. So what we're showing
is that the spending-restricted prices, P bar, the ones I just computed in
the spending-restricted outcome, and the scaled valuations, VI, the ones I
just described having scaled in the way, the product of the values in the
optimal solution is at most the product of the prices in H. So in this case
it's at most 10 times four-thirds. And I'm going to explain why this is the
case.
Roughly speaking, the reason why this is the case is the best thing you can
do is allocate the important items, each one to a distinct agent. And then
the best you can hope to do for the other items is give a value of 1 for
everyone else. Everyone who doesn't get an item from H, the best you can
hope to do is give them a value of 1, in which case you get this product from
the players that get an item in H and 1s from everyone else.
>>:
So if H is NP, then you're saying this [inaudible].
>> Vasilis Gkatzelis:
>>:
Is -- yes.
P is 1.
>> Vasilis Gkatzelis: Because everybody, the best you could ever do is give
everyone 1. Because if you can think of that -- that's the easy case because
then the sum of the prices is N. Right? Actually this is actually a good
point. This probably helps. If H is empty, then the sum of the prices is N,
the total spending. Right? And it's also the social welfare. The total
value you could ever get, the maximum value you could get is that. Right?
And ->>:
What about scaling again?
>> Vasilis Gkatzelis:
So that --
>>:
Forgive me, I did not understand the scaling.
>>:
[inaudible].
>>:
Can you go back?
>> Vasilis Gkatzelis: Yes. So we scale the prices so that your value -essentially by the inverse of your MBB ratio.
>>:
Scale what, prices?
>> Vasilis Gkatzelis: The maximum bang per buck ratio. So you make sure the
value for everyone is equal to the price of the item he's allocated.
>>:
So you'd just like to know --
>>:
So you're scaling the values --
>> Vasilis Gkatzelis:
>>:
[inaudible].
>> Vasilis Gkatzelis:
>>:
So VIJ divided by this ratio, the max --
Over all J of VJ -- V -- sorry --
[inaudible].
>> Vasilis Gkatzelis:
>>:
Right.
Max of [inaudible].
>> Vasilis Gkatzelis:
>>:
So you have -- so VIJ prime is equal to --
VIJ would be ordered by [inaudible].
>> Vasilis Gkatzelis:
>>:
Yes.
[inaudible].
>> Vasilis Gkatzelis:
>>:
Yes, the values.
Of over J prime, VIJ prime over PJ prime.
[inaudible].
>> Vasilis Gkatzelis: All multiplied by the inverse, right? So that means
that all the items that satisfy this, that belong, that actually maximize my
ratio, I'm going to have a value for them equal to the price. For everything
else I'm going to have a value less than the price.
>>:
Okay.
Yes.
>> Vasilis Gkatzelis: The only reason we're doing it, I mean, it sounds like
a tricky thing, but the only reason I'm doing it is to be able to express the
upper bound as a function of the prices. Because we don't know who will get
what. All we know is that's the best you could ever hope for.
And then what I'm saying is that, okay, so for the case that you mentioned,
if the H is empty, the sum of the prices is N. Right? It's the total
spending, how much money everybody's spending. So everyone, the best you
could ever do is give everyone a value of 1.
>>:
At most.
>> Vasilis Gkatzelis: Yes. So just to make it even simpler, to prove that
this is true, I will go back to the values, and I'm going to increase all of
them so that everyone's value for every item is equal to the price. Right?
So if anything, I'm increasing the left-hand side. I'm making it harder for
me to prove it. So I'm increasing everyone's price so that they're
identical. Everyone's value, sorry, so that they're identical. They all
value every item equally. So that's a harder thing to prove.
The thing is, and maybe that's easier to grasp, every player is the same.
Maximizing the product is the same as maximizing the minimum. Okay? So
we -- in this instance I have now constructed. You just want to maximize the
minimum.
And back to the incident I was saying. If H
get -- the best minimum you could get is 1.
is nonempty, the best we could get for these
get the top items, it's, you know, the value
that clear?
is empty, the best
That's why this is
guys is 1, and for
they get from that
you could
easy. If H
the guys who
top item. Is
So essentially it's a mixed thing. We're saying all the items in H we're
going -- the best thing you could ever do, because they already get a value
higher than 1, right ->>:
Why is it a product of those things because they might --
>>: Well, it's a product of the values. The value of the agents that get
something in H. So if an agent gets something from H, his value is equal to
the price. And everyone -- so essentially it's the values are the prices in
H times 1, 1, 1, 1 for everyone who doesn't get an item.
>>:
But I could get markable items, right?
>> Vasilis Gkatzelis:
>>:
But that would make it worse.
Why?
>> Vasilis Gkatzelis: Because these guys are already well off. The guys who
get any -- any agent who gets an item in H already has a value higher than 1.
So since you're trying to do max-min, you shouldn't give them anything else.
So exactly. This is a perfect question. Because the best that you could
do -- so I just argue that here we want to do max-min, right? So anyone who
gets an item in H gets a value 1 -- gets a value higher than 1. So it's
fine. These guys are fine.
And there are -- so there are N minus H people who do not get that. And the
sum of the prices, the last thing to observe, is that the sum of the prices
in L are also N minus H. Do you see that? Because the spending on the items
in H is one for each item. So the spending here, which is equal to the sum
of the prices, is actually N minus H.
So what I just argued is everyone who doesn't get an item in H, there are at
least N minus H such people, and they need to share this total value. So the
best you could ever hope for is give them one H.
>>:
Why is it [inaudible] maximum and the minimum?
>> Vasilis Gkatzelis:
>>:
Yeah.
>> Vasilis Gkatzelis:
>>:
I mean, it's true.
Let me see.
I don't know that I have a good argument
What for?
>> Vasilis Gkatzelis:
>>:
If they're identical?
[inaudible].
>> Vasilis Gkatzelis:
for it. But ->>:
The maximum as the geometric mean?
Why maximum is --
[inaudible] maximum in the [inaudible] because you [inaudible].
>> Vasilis Gkatzelis: Yeah, because the sum is fixed. Yeah. So you have a
set of values. The social welfare is fixed. So you're maximizing the sum -the product of values. You're maximizing the minimum of values that sum up
to the same thing. So the best thing you could do is make them -- you're
maximizing the product of values of a fixed sum. So the best you could do is
balance them so they're equal. That's the argument.
So if you have a fixed sum, essentially you're redistributing the same social
welfare. So I've bounded the social welfare. I'm saying social welfare is
the sum of the values of these prices. And then the question is how do I
distribute it to make the product maximized. So the product is maximized
when they're all equal. Yeah.
So this comes from exactly this argument; that the players who do not get an
item in H are at least N minus H. The sum of the prices here are exactly N
minus H. So the best you could hope for for these people is that they get a
value of 1, even if these items were divisible. Right? That's the best we
could ever hope for.
And that's where we use integrality; that the top items we cannot divide, so
one player gets each. So that's where you get the product for the items in
H. And that's the upper bound. So it's not -- to answer your previous
question, doesn't come from the program directly. It's kind of a partial
relaxation of the -- using the solution.
>>:
And what do you use a program for, like the previous program --
>>:
The program gives PJ back.
>>:
Oh --
>> Vasilis Gkatzelis: Exactly. We get the solution -- actually, we use it
in two ways. First we use it to get the upper bound, and we use it for the
solution, right, for the fractional solution.
>>:
For the rounding?
>> Vasilis Gkatzelis:
For the rounding.
>>: I see. So you took the competitive equilibrium prices and you put it in
the new convex program and then you took the PJ bar.
>> Vasilis Gkatzelis: No, no. So we didn't solve it using a convex program.
We introduced this constraint and defined a new notion of equilibrium, which
we explain how to compute in a totally different way, using a combinatorial
algorithm. I haven't discussed this.
>>:
Oh.
I see.
>> Vasilis Gkatzelis: But once we compute this, we use the prices as a
signal of how to define an upper bound, and then we also use the -- both the
prices and the allocation for the rounding algorithm, which is the next
slide. Okay? So this is the upper bound, this product and the prices.
So roughly speaking, if I could design an algorithm that of course matches
these expensive items to different people each, to distinct people, and then
the other thing rounds in a smooth way so the value is will distributed, then
maybe I could hope to get a good approximation. And this is more or less
what the algorithm does.
So one thing I didn't mention is that you can always make sure that this
spending graph, these edges, they never -- there's never a cycle in this
graph. That's easy by just redistributing it. So essentially you can
redistribute the spending and make sure you're only spending on the -there's no cycle in this thing.
It's not very important, but I'm going to be using the fact that there's a -this is going to be a forest, the solution is going to be a forest. And the
way we do it is -- the way we round is we take every tree in this forest,
choose an arbitrary agent and set it to be the root. And let's say this is
agent A. And in the solution, in this fractional solution, he's spending
money on some -- getting fractions of some of the resources of the items.
And these resources are also being computed for by other agents and so on.
So you have this alternating sequence. And you get a tree like this one.
And we're only going to be rounding using these edges. That layer is only --
an agent is only likely to get an item if there's -- if he's spending
something on that item in the fractional solution. In this fractional
solution.
So of course the first step of the spending-restricted rounding algorithm is
to compute the spending-restricted outcome, which we can discuss later. But
once you have this, you have these graphs. And what is the first easy step
of the rounding? I just told you that I'm only going to round using these
edges. The leafs, right? The item leafs. There's no other option.
So the first thing is allocate the leaf items upwards to their -- to the
agents that are the only ones spending them. So that's easy. We do that.
The second step is to allocate the low priced items. And here we've chosen
by low price, because that's -- that was a convenient number for rounding,
the ones that have priced less than half. So any item that has priced less
than half, we're also going to round it upwards to the parent agent. And
that's where we use a tree. We try to make it consistent rounding, always
upwards.
And in this case you look at all the prices, there's only one this year that
has price less than a half. We take it and round it upwards. Right? And
then after we're done with this step, everything that remains -- essentially
we kind of got rid of the less ->>:
What is A and what is R?
>> Vasilis Gkatzelis: Agent resource. I didn't want to use I because I use
it as an index for the -- but yeah. Agents and resources.
>>:
And the leaf are agents?
>> Vasilis Gkatzelis: Right now, yes. But I did it before, right? Yeah,
I'm sorry. So the resources allocated the leaf items, not the leaf agents.
And then allocate also the low priced items.
>>:
So is it easy to see it's a forest?
>> Vasilis Gkatzelis: Yes. Because you don't care. Essentially it's a
tie-breaking issue, right? You have a set of MBB items. You can just
redistribute and it's fine. So now I've gotten rid of the less important
things. And I'm -- what's remaining is everything has a price less -- at
least half. So everyone who gets an item of the remaining ones actually gets
half, you know, gets a half value, right?
>>:
Can you just show matching?
>> Vasilis Gkatzelis: So that would be fine. So if I could -- if I could do
a half value for everyone, that would be great. What we show is actually we
cannot match everyone, but we can match most of the people that are left.
And in order to do this, what is interesting is in this last step I'm going
to do a matching. I'm matching the remaining agents to items. Each agent
gets one of these items. Because they are the important ones. Nobody should
be getting more than one of those. And you might ask how do you do that, how
do you match. There are many different ways to match.
The interesting thing is actually that last step, you can do it optimally
because you can just say VI of XP is the value of I based on the first couple
of steps, the value he already has, and then you can just change the VIJ to
log of VI XP, the value he already has plus VIJ and do a maximum weight.
Yeah. And add dummy items of value, that much, and run a maximum weight
matching algorithm.
So the thing is, if you have unit demand, the problem is easy. It's maximum
weight matching algorithm. But the problem becomes harder when you want more
than one items. But in this case, at this point, we only want to match
people so we can do it optimally.
And what we prove is essentially that everybody who gets an item in this
space is fine. So if everybody got one, we would definitely get a 2
approximation, because all the really important ones, the ones in H, go to a
different player. Each and everybody else would get a value of half. We
cannot do that. We cannot make sure everybody gets one of these items. What
we're showing that in this matching there exists a matching where even the
ones who do not -- the ones who do not get an item must have received
substantial enough value from the first two steps. So they're fine. And
instead of a 2 approximation -- sorry. And this is the matching. Instead of
2 approximation, that's why we get a bit. Although, although with a tighter
analysis, we now believe we might have a 2 approximation here.
>>:
So this [inaudible].
>>:
Sorry.
>>: So the second step is dependent on your choice of A, but it's almost
saying that doesn't matter?
>> Vasilis Gkatzelis:
>>:
Yes.
Yes.
And the leaf --
[inaudible].
>> Vasilis Gkatzelis: You're right, you're right, you're right. Yeah,
you're right. It doesn't matter. It's arbitrary. So essentially all we
want is to make sure that at the end really you want -- we end up having some
components at the end, and we want to make sure that everyone -- there always
exists someone who receives value. If he doesn't get one of the items, he
must have received value from his children items. So no matter what the
ordering, there exists such a person. Sorry.
>>: No, then, I mean, the mysterious stuff is like the second step, right?
I don't see like if you [inaudible] matched in the third step, like why would
you say that he got a lot of small items? Is there ->> Vasilis Gkatzelis:
end.
>>:
There always exists one within each component at the
Log VI of XP.
>> Vasilis Gkatzelis: No, but you're talking about the proof, right, about
how we can argue there exists someone. Because we always round upwards. And
we're saying essentially it's because of, again, the scaling; that the sum of
the prices is equal to the number of players, right? If all the items -- if
I -- if I got all the items that I was spending on, then the prices of these
items would have been -- so the sum of the prices are of the items that we
were spending on are at least as much as the number of players in that
component, right?
So that's the argument. If for some reason somebody doesn't get anything,
that means that he must have been rounded something before. I mean, it's
not -- it's a delicate argument, but there always exists someone. That's the
core of the -- okay? And that's -- yeah.
So really to summarize, I mean, the idea is that you get this market
equilibrium, we apply this constraint, we compute this different market
equilibrium which reveals more information, we use it in two ways. We use it
in order to get this upper bound by treating the highly priced items as
important and indivisible and then allowing fractional relaxation on the less
important items.
And then the rounding goes along the same lines; that it tries to keep -- it
uses the prices again as a signal of keeping the highly priced items for the
end, for the matching, and trying to be balanced in the way to distribute the
nonimportant items.
>>:
So the right answer should be 2, right?
>> Vasilis Gkatzelis: So we haven't verified everything, but we think with a
tighter analysis the answer is still yes. Yeah. This was a first kind of
rough analysis that gave us this. So let me wrap up with one quick, a quick
discussion on how we compute this. So because I think I actually like this.
It's based on Nikhil's work, and it's kind of how we can actually compute the
market equilibrium in a combinatorial way.
And the nice thing is that if you're given a vector of prices P, then you can
write -- you can have the following network here. You have a sync, here are
all the agents, all the items, and a source -- sorry, a source and a sync.
And then the capacities of the edges from the source to the agents are one
equal to the budget. The capacities of the edges from the items to the sync
are the prices, the current price of the items, and then you have edges here
if the item
And what is
agent I and
for agent I
is one of the favorite items, the maximum bang per buck items.
-- yeah, this is what the second bullet says, that IJ between
J exists if and only if item J is the maximum bang per buck item
at the current prices.
And if you compute a max-flow in this network, and it just so happens that
all these capacities are saturated, you're using all these capacities in
full, what does it mean, that you're fine, everybody's spending all of their
budget on their favorite items and all the items are fully allocated. So
that will be fine. The tricky thing is, of course, how do you find the
prices. And it's very delicate. And once you change the prices, you're
really affecting this structure over here. You can change it dramatically,
right?
So if you change the prices, you change the structure. So how this works is
you start from low prices where essentially not all the left -- these edges
over here are not used to capacity, not everyone is spending [inaudible] and
then you have overdemanded items here. And then you gradually in parallel
increase some of the prices. And the reason why you do it in parallel by the
same multiplicative factor is to maintain these edges here. And you
gradually increase this in a very careful way, and then you have to make sure
this primal dual approach eventually completes in a polynomial number of
steps. And this is what Nikhil, et al., showed in their paper, how to
actually do this in polynomial time. That there's a way of doing this in
polynomial time.
What is great about this combinatorial algorithm is, if you think about it,
the flow is spending. What I just described, this maximum flow, is
essentially pushing spending through from the source to the sync. So all we
need to do for our constraint, although it wasn't easy to introduce it into
the convex program is just ->>:
[inaudible].
>> Vasilis Gkatzelis: Yeah. Instead of having the prices here, just have
the minimum of the price in one. Right? So we just change this to capacity.
So we introduce a new capacity constraint which is at most one. So
essentially the same approach works by just introducing, because they fit
perfectly. These capacity constraints that we have on the spending, the
spending is really the variable here in the flow. And this is how we
computed it. But as I mentioned before, now there's also a convex program to
compute this.
>>:
[inaudible].
>>:
Yeah, yeah, I [inaudible].
>> Vasilis Gkatzelis:
>>:
Yeah, you have to make sure.
It's a delicate process.
Otherwise I don't see like how can just put this thing.
>> Vasilis Gkatzelis: Yeah, I don't know.
team has to make sure that --
Yeah, you have to -- the parallel
>>: You have to do it in parallel and make sure the events that take place,
you know, because if you increase someone that one interested in something
else and ->> Vasilis Gkatzelis:
>>:
This is a gradient design.
This is a DPSP.
>> Nikhil Devanur:
That's it.
[applause]
>> Nikhil Devanur:
Questions?
>>: Again [inaudible] I somehow -- supposing [inaudible] I can just
calculate like a matching, right, is it a matching? Let's say [inaudible].
>> Vasilis Gkatzelis:
Maximum weight matching.
>>: So about this max weight [inaudible] if the value is zero or nonzero,
right, [inaudible] the agents on one side, the items on the other [inaudible]
I don't care of the value.
>> Vasilis Gkatzelis:
>>:
To check if it's zero or not, yeah, you could do.
Yeah, I just want every nonzero pair --
>> Vasilis Gkatzelis: But it does need to be zero, right? That's why I'm
saying. If you have one item, sure, it's going to be zero. That's why my
example has more items. It's not zero. It's low or high, right? If you
have any items.
>> Vasilis Gkatzelis: Yeah, yeah, yeah. But I'm just saying if it
[inaudible] like this matching. But we know the matching portal. So
intuitively you should -- the program should be stronger than that. You just
don't want to just take matching. If there is one, you want to also have
value on solutions, right? But I'm saying the current solution cannot even
detect zero as a nonzero.
>> Vasilis Gkatzelis: But that you can do easily, right?
run this as a first step to verify if zero ->>: Yeah, yeah, but I don't want to do that.
right? The [inaudible] should do it.
>>:
I mean, the [inaudible].
So first you can
The upper bound should do it,
>>:
[inaudible].
>>:
So how [inaudible] zero?
>> Vasilis Gkatzelis: Yeah.
if it detects [inaudible].
>>:
What step did it detect?
I guess, I mean, you can just -- I don't know
It has to, if you want --
>> Vasilis Gkatzelis: Yeah. No, I mean, you can run -- that's what I said.
I mean, we're assuming this is not -- this is not an interesting case.
[multiple people speaking at once]
>>:
What will happen is in that case the outcome of [inaudible] --
>>:
Is also zero.
>>:
-- will also be zero.
>> Vasilis Gkatzelis:
>>:
Yeah, yeah, but [inaudible] whatever the price is, there is something.
>> Vasilis Gkatzelis:
new ->>:
Yeah.
The number -- the prices are not unique for this
Or zero [inaudible] put zero actually.
>> Vasilis Gkatzelis:
By the way, that's actually interesting.
[multiple people speaking at once]
>>:
PJ will go to infinity.
>> Vasilis Gkatzelis:
Yeah.
PJ will go to infinity actually.
And the PJ in the solution --
>>:
[inaudible] whole set basically [inaudible].
>>:
Yeah.
>>:
That's basically the solution.
>> Vasilis Gkatzelis: And the prices -- the prices are not unique that give
you this spending-restricted equilibrium. I don't know if your programs like
give particular prices, but you can multiply all the ones in H, you can
increase them further. You can [inaudible] and still doesn't change
anything.
In some cases, for example, this bidder who only likes that item, you can -so it's not really unique. If you increase the prices -- we're not using the
numbers of the prices, right, we're only using which ones are bigger than 1
and which are not. So otherwise it doesn't really matter.
>>: Why did you [inaudible] two dimensions. Can you formulate the problem
in two? Like I don't know. I don't know what ->>:
Another thing is do you prove it for a particular scaling of values?
>>: We are expressing the upper bound. No, we're not proving it for a
particular. This scaling doesn't matter. We're just -- the thing is we
couldn't express the upper bound as a function of the player's value. We
don't know what goes to whom. So we're expressing it as a function of the
prices instead.
>>:
The scaling doesn't matter for the allocation.
>> Vasilis Gkatzelis: Or the approximation. Or the approximation.
we scaled both up, and it doesn't matter. It simplifies, right?
>>:
Oh, it doesn't [inaudible].
>> Vasilis Gkatzelis:
>>:
Because
It doesn't.
It doesn't affect the approximation.
Okay, okay, okay.
>> Vasilis Gkatzelis: So yeah. The scaling is just a convenient way to
express the upper bound in a succinct way.
>>: And one more question. So in your algorithm, did you show it only for
this K set of budgets are 1 and this upper bounds are 1?
>> Vasilis Gkatzelis: Yes. Budgets are 1. Different budgets, I'm not sure
that it's -- we thought about it, but it's not clear how it [inaudible].
>>:
[inaudible].
>>: [inaudible] the algorithm equal [inaudible] the budgets are equal and
this upper bound on the prices for all the budgets are 1.
>>:
[inaudible].
>> Vasilis Gkatzelis:
This one.
>>:
To finding this SR outcome.
>>:
Okay.
>>:
All the budgets are to be 1 and [inaudible].
>> Vasilis Gkatzelis: I'm not -- I'm not sure about the algorithm. I meant
the rounding. I mean, the capacity. Because the capacity constraint that we
have is essentially a budget worth ->>:
This is a question [inaudible] algorithm itself.
>> Vasilis Gkatzelis:
You mean --
>>: Computing the [inaudible] algorithm [inaudible] upper bound also
being -- budgets may be different, but maybe the upper bounds, you need them
to be all ->> Vasilis Gkatzelis: I don't think we use that. I mean, we didn't look
into that because even if we could compute that, it wasn't useful for the -didn't seem to be useful for the [inaudible]. But I don't think there was
anything particularly specific to equal budgets. And it seemed to be fitting
nicely with what already existed. It wasn't ->> Nikhil Devanur:
Okay.
>> Vasilis Gkatzelis:
[applause]
Thanks.
Thank you.