>> Nikhil Devanur Rangarajan: Hello and welcome everyone. It's a
great pleasure to have Matt visit us and it's an even greater pleasure
to have him give a talk, because Matt gives wonderful talks. No
pressure. Matt graduated from MIT last year and has been post-doc at
Princeton since then, and Matt has won many fellowships and awards,
including the MSR Graduate Fellowship and ACM Doctoral Dissertation
Award for the wonderful work he's done on nontruthful mechanism design.
And Matt will tell us what he's been working on recently on
interpolation mechanisms. Over to you, Matt.
>>: Matt Weinberg: Thanks for the introduction. And so this talk is
going to be on two works. The first one is with Nikhil and Jamie
Morgenstern, Vasilis Syrgkanis and the second one is a follow-up with
Mark Braverman and Jieming Mao. The first part of the talk I'm not
going to tell you what interpolation means. I'll just talk about
simple combinatorial auctions.
Okay. So just to make sure everyone knows what I'm talking about, in a
combinatorial auction there's a set of M items for sale to N different
bidders. And the buyers have combinatorial valuations for the items.
So they just have valuation function that takes its input set and
outputs their value. For this talk, I'm always going to assume that
the valuations are sub additive. And the goal of this item is to find
some way to allocate the items that maximizes the welfare which just
sums over every bidder the value for the set they get. And the catch
is that these valuations are private information to the bidders and so
they might lie to whatever algorithm you try to use if they think they
can get a better outcome. The problem has been around for a while.
There's kind of three different approaches that we use to solve them.
The first is due to seminal works of Vickrey, Clarke and Groves. And
what they show is that there's always a truthful mechanism that
allocates the items optimally. So by truthful, I mean that this
mechanism has a property that every bidder prefers to report their true
values to the mechanism no matter what the other buyers choose to do.
And kind of the drawback of this solution is that in basically every
setting that we care about, it requires exponential computation or
communication to actually run the VCG mechanisms. It's basically never
used in practice. Second approach that people have used more recently
is to say, okay, we can't run the optimal mechanism in practice, but
maybe we can design an approximately optimal truthful mechanism. Okay.
And there's been a lot of work on this front. And a lot of the
approximation ratios that we get are actually quite good. The catch is
that these mechanisms are often quite involved and they're not
transparent to the buyers what's going on. And they're also difficult
to implement. And so these are also virtually never used in practice.
And kind of the drawback of these they're not simple in design. So
buyers don't like participating in these mechanisms and sellers don't
like implementing them.
>>:
Are the --
>>: Matt Weinberg:
>>:
I'm sorry.
What's used in practice?
>> Matt Weinberg: That's approach three. So price of anarchy is not
used in practice. But what we often see in practice is people are just
using very simple mechanisms that are not truthful and before this long
line of work the price of anarchy we didn't really have any
understanding of why they should be good in practice or why anyone
should want to use them. So what people have started doing recently is
we're analyzing simple mechanisms. For instance, maybe the simplest
thing you can think of I'll run a second price auction separately for
every item and then bidders you can do whatever you want. It's not
truthful. Okay. And so what the price of anarchy studies is okay the
mechanism is not truthful so I don't want to try and predict how
bidders will behave. Maybe at the very least they'll do something that
constitutes some kind of equilibrium behavior. And then we try and
prove claims that say you know what, as long as they play according to
this equilibrium behavior, things are not so bad. And so the formal
definition of price of anarchy for auction a searches over all
instances. So for all valuation vectors that you want your guarantee
to hold, over all possible equilibria and it find the worst equilibrium
of the worst instance and compares the ratio of the welfare to what you
would get in the optimal solution.
Okay. So actually there's been like a ton of work in the last couple
of years about showing that many simple auction formats have low price
of anarchy and in particular selling every item separately has a low
price of anarchy as well. And recently critique was raised about all
of these results which is that none of the equilibria, which the price
of anarchy bounds are to hold rise naturally. I'll be more formal
about what I mean about that later. In particular some are even known
to be computationally hard to find. So what this means is that just
because we think it makes sense for people to play games at a Nash
equilibrium if it's computationally hard to find maybe a price of
anarchy bound equilibrium is not as appealing for solution concepts
that we know how to find.
Okay. So what I'll say about these is that these mechanisms are not
strategically simple in the sense that buyers cannot look at these
auctions and figure out what they should be doing to play. So here's
just a chart that summarizes what we know so far. So these are the
four categories I want to talk about in this talk. So we care about
the approximation ratio or the price of anarchy. We want all the
mechanisms to run in poly time so we can actually use them. We want
the mechanisms to be strategically simple in the sense buyers should be
able to figure out what they do and we want them to be simple in design
so people are willing to implement them.
Okay. So what we know so far is that we don't have any mechanisms that
kind of check all the boxes. And what I'm going to show you in the
first part of this talk is a new auction format that we call the single
bid auction that has a price of anarchy of log-in and it has poly
communication and runtime. It is strategically simple. And I'll be
formal about what I mean about that later. It's also very simple in
design.
Okay. This is like a fuzzy statement I can't prove it's simple in
design but I'll describe it to you and I think you'll agree with me
that it is pretty simple.
>>:
[indiscernible].
>> Matt Weinberg: I think it's up for debate. So like it's simple in
the sense that I can describe the mechanism to you, right. You know
what it is. But on the other hand like actually running it you know is
NP hard to do. So there's going to be some crazy optimization going
on. And this is still not something that someone is going to want to
implement. Put a question mark there because I don't want to discuss
it. But even so, even if you think it's simple, you still can use it
in practice.
>>: Like only one second, like the auction happens only one short -it's not -- the update result extent ->> Matt Weinberg: So these results -- okay. So what they show is that
the auctions still have low price of anarchy in the repeated game. The
catch is that even what you would naturally say is oh in the repeated
game people are going to play no regret learning. It's even
computationally infeasible to do learning in these auctions. So it's
not -- so you shouldn't even be expect to converge to coordinated
equilibria and it will be to what I say soon so even learning you can't
do.
Okay. So other -- okay. So this is the first part of the talk I'm
going to describe the single bid auction. Okay. So here's what's
going on. In the first phase, each bidder is just going to submit a
single bid. So just one real number. In the second phase, the bidders
are going to be visited one at a time in decreasing order of their
bids. And then when they're visited they can purchase any number of
remaining numbers they want and they have to pay their bid per item.
So have a little animation. So the first phase everyone submits a
number. So Jamie is bidding five. Nikhil is bidding eight and Nikhil
is bidding six. And in second case Nikhil highest bidder he goes
first. Can buy any of the remaining items he wants he chooses apple
pays eight. Nikhil next highest bidder he shows up apple is gone he
can buy any subset of the oranges and bananas and he chooses to buy
both of them pays two for 12 and six per item and Jamie when she gets
there is nothing left pays zero. Is the format clear? Hopefully you
agree with me I think this is pretty simple. Okay. So the main
theorem we show, and again the statements are a little bit informal.
So first we show that the single bid auction has a price of anarchy
log-in whenever buyers are sub additive. The reason this is not formal
because I haven't defined the equilibrium concept yet. And second is
that the single bid auction is learnable. So what I mean by that is
that whatever regret minimization algorithm you want to use, it will
run in poly time. Okay. So what this means is that this single bid
auction has a price of anarchy log -- in, solution concept you should
actually expect to arise in practice. Because in practice when players
play repeated games we expect them to have no regret. This says you
should expect them to be able to minimize regret because whatever
algorithm you expect anyone to use it will run in poly time.
>>:
[indiscernible].
>> Matt Weinberg: N is the number of items, that's right. Okay. And
I just want to -- before I go on -- recall that all previous auctions
either didn't run in poly time to begin with.
They were prohibitively complex in design, even though they did run in
poly time; or the price of anarchy bounds were only known at unnatural
or intractable equilibria, OK? So any questions? I'm going to get
into proving some things next.
>>: [indiscernible] so you need to go over all concepts other than the
price of anarchy that would correspond to a different solution concept
that would be relevant to these other things?
>> Matt Weinberg: So another thing people study is the price of
stability and we do know that good price of -- so price of stability is
looking for the best equilibrium, and we do know in not for
sub-additive buyers but for sub cases we do know how to find at least
one equilibrium efficiently, and we know how to find an equilibrium
that has good welfare. The problem is that these equilibria are
extremely unnatural. It's basically that one person bid very high and
everyone else bid zero, and it looks like this on every item. And it
requires a big, centralized computation to find out what's going on.
So technically there are pure Nash that exist for some of these simple
auction formats that have good price of anarchy that we know how to
find, but they're really unnatural and I don't think you should expect
to see them in practice. That's the extent of what I know of other
approaches.
>>: Just to understand this price of anarchy bound that is, so again
it depends on the auction.
>> Matt Weinberg:
anarchy.
Yes.
So every auction has a different price of
>>:
Which is you look at a set that can be reached with this.
>> Matt Weinberg: Yes. For every auction, for every class of
valuations, you look at what is the worst instance for that instance,
find the worst equilibrium, and then see what is the ratio of what I
would hope to get versus what I get in this bad equilibrium. Does
that -- so it's the find for an auction and for a class of instances
that you want to have a good bound for.
>>:
[indiscernible].
>> Matt Weinberg:
>>:
For whatever notion of equilibrium you want.
And even the approximate equilibrium is hard to compute?
>> Matt Weinberg: Even so, so we don't have formal results saying that
approximate equilibria -- so I think the approximate is, like, really,
really small -- like exponentially small. Epsilon is hard to compute.
I don't even think we know, like, P test doesn't exist or something.
But like a meta argument, I would say, look, if you're using a complex
P task just to find an equilibrium, I don't know that you should expect
bidders to do that in practice either. Okay. So it's kind of two
separate claims going on here. The first is just talking about the
price of anarchy. The second is just talking about how well bidders
can learn this auction. So the price of anarchy. There's been this
recent development of techniques called smoothness that have kind of
become a big hit in price of anarchy recently. We're again going to
use these techniques. I'll explain them starting from scratch. That's
going to be the majority of the first portion of the talk. And it
turns out it's actually pretty straightforward to show that this
mechanism is learnable. Basically what we're going to show is that
when a bidder is trying to do learning they only need to consider a
polynomial number of actions, and when there's a polynomial number of
actions however you decide to learn it's going to run in poly time. So
I'll get started with smoothness. So what smoothness is it's a generic
tool for proving price of anarchy bounds that many equilibrium concepts
at once. And so here's the formal definition. I'll parse through it
in a second. We say that a mechanism is lambda mu smooth if for every
valuation profile that you're hoping for your bound to hold, each
bidder has some safe strategy and the safe strategy should satisfy the
following guarantee. So what this is saying, on the left-hand side
we're summing over every buyer their utility for deviating to their
safe strategy from the existing profile. And then on the right-hand
side, this is just lambda times the optimal welfare and mu times the
optimal revenue. So this right-hand side is just a bound and you say,
look, if everyone has a safe strategy, such that the sum of utility is
deviating from the safe strategy exceeding some bound then something
nice happens.
Okay. And this something nice that happens is Syrgkanis and Tardos
showed whenever a mechanism is lambda mu smooth then M has a price of
anarchy of at most this bound. So this is just mu over lambda at
basically every equilibrium concept that you would care about. Okay.
And I'm not going to prove this because this is older work, but
basically the idea is that how you reason is if you have a strategy
profile that's any of these equilibria concepts every buyer is at least
as happy in this equilibrium as they would be by deviating to their
safe strategy. Okay. And so this means that the sum of everyone's
utility is at least as large as this term on the left and the rest of
the proof is just moving around terms from this inequality. Okay.
>>:
The UI --
>> Matt Weinberg: Where? Okay. Yes. That's right. So this should
be what's on the left-hand side. Okay, so let me give you an example,
first of how you might show that a mechanism is smooth and then kind of
relate this to how you should understand why this implies a price of
anarchy bound. So let's say that there's one item for sale and we're
going to run first price auction. So Syrgkanis and Tardos also showed
that first price auction is one-half one smooth. And therefore by
their previous theorem the first price auction is price of anarchy at
most two at all of these equilibrium concepts. Okay. So let's see how
you would prove this. So for each bidder we have to define their safe
strategy. Their safe strategy is going to be to bid half their value.
Okay. And now for whatever strategy profile we're looking at, let's
let P be the probability that the highest bid you see in the strategy
profile exceeds the highest value over two. Okay. And so what's going
on whenever the highest bid is larger than the highest value over two,
certainly the revenue is at least the highest value over two as well.
So the revenue is at least P times opt over two. And also whenever the
highest bid is less than the highest value over two, now the highest
bidder will win the item when he uses his safe strategy. And when this
happens, he gets -- he only pays half his value, so he gets utility
half of his value. Okay. So this means that just by the highest
bidder, his utility by deviating to the safe strategy is at least 1
minus P times opt over 2. And now when we plug both of these back into
this bound we'll see that you can get lambda equals half and mu equals
1. I think following through this reasoning formally isn't super
important. But the important thing is that you kind of see how you
would reason about this. So every bidder has a safe strategy. And by
reasoning through what happens, we can see that everyone's utility
exceeds this bound. Okay. So how I think of interpreting this is that
in any of these equilibria, the highest value player is at least as
happy with whatever strategy he's using than he would be if he used his
safe strategy and just bid half his value instead. And it turns out
that this fact alone means that the price of anarchy is at most 2 of
these equilibrium concepts. And the way you prove it formally is going
through smoothness but intuitively this is what's going on. Okay. So
any questions? Okay. Okay. Now I want to do a slightly more complex
example. So in the single bid auction I want to only look at very
simple valuation functions and show that the single bid auction has a
low price of anarchy here as well. So I'll define this constraint
homogenous, call it CHV. So evaluation is constrained homogenous if
there exists a set S and value X such that your value for any set is
just X times the number of items in S that you get. So your additive
except your value for every item is either 0 or X. So it's a very
restricted class of valuations.
Okay. And so something we show is that the single bid auction is also
one one-half smooth whenever buyers are constrained homogenous. And
I'm not going to go through a complete proof. But -- I'm sorry. This
is just reminding you of what the single bid auction is in case you
didn't remember from the earlier slides, so this is phase one where
everyone submits a single bid, and phase 2 where the visitors are
visited one at a time and they can buy whatever set of items they want.
And so the proof idea is the safe strategy is going to be basically the
same as in the first price auction. Every bidder's safe strategy is
going to be to bid half of their per-item value over 2. And when they
get visited in the second phase they're going to buy whatever items in
their special set remain.
Okay. And then the rest of the proof I'm going to skip. But it's very
similar to the smoothness proof for first price auctions. You're just
summing a different bound over each item.
Okay. And again how you should interpret this is that in any
equilibrium every bidder is at least as happy with the strategy they're
using as if they deviated to their safe strategy instead. And in this
case their safe strategy is bidding half their per-item value and
taking whatever items are left in phase two. And this fact alone
implies the price of anarchy is at most 2 in the form of way of showing
this is through the smoothness.
Okay. So what do we see so far? So proving that single dimensional
auctions are smooth is not so bad. But directly handling combinatorial
valuations is much harder. And kind of the reason is that we can't
break down per item contribution when we try to prove these bounds
because the valuations are combinatorial and they're weird.
Okay. So what we'd like to do is come up with some kind of lemma that
will let us reduce proving smoothness bounds for complex valuations to
proving smoothness bounds for simpler valuations which you can see is
not so bad.
Okay. And so it turns out that the right notion that we need is the
definition that we'll call a point-wise B approximation. So say that a
class of valuations V, big V, point wise B approximates big V prime if
for every valuation in V prime and subsets S of items there exists a
little V such that this first guarantee is just saying that little V is
close to V prime. Just on this special set X. And the second claim is
just saying that V lower bounds V prime everywhere.
Okay. So this is a really weak notion of approximation. The only
guarantee is that V and V prime are close on S. Everywhere else V
could be like 0. It could be infinitely smaller than V prime we don't
care as long as it's less than V prime.
So what we show is that even this really weak notion of approximation
suffices to get this kind of extension lemma. So the claim is whenever
a class of valuation point wise B approximates another class and you
have a mechanism that's lambda mu smooth whenever valuations are in the
simpler class then M is also lambda mu over B smooth for this more
complex class and the proof it turns out is actually not so hard. It
just uses each of these properties exactly once. But I'm not going to
go through it because it's mostly just chasing around these
inequalities. So now the most interesting thing we show, this is a
little bit more technical, so I'm omitting this as well constrained
homogenous valuations point-wise log M approximates sub additive
valuations. This means for every sub additive function there is for
every sub additive function and for every set S there's a constraint
homogenous valuation such that where I lost the definition, no, it's up
here. Such that it's close to that sub additive function on S and for
everywhere else it's no larger. Okay. And then this alone by our
theorem says that the single bid auction is now 1 minus 1 over E log M
one smooth for sub additive bidders. This is using the fact that it
was smooth for constraint homogenous and this extension lemma. Okay.
So therefore what this means is that the price of anarchy at all these
equilibrium concepts is at most 1 minus 1 over E times log M.
Okay. And again so how you should interpret this stepping back from
the smoothness and how the proof comes is that in any equilibrium of
the single bid auction for sub additive buyers every bidder is at least
as happy with their current strategy as they would be if they use their
safe strategy. And what is their safe strategy? It's to pretend
they're constraint homogenous, bid half of their per-item value and
then take whatever items are left and their constraint homogenous set.
Okay. And then this fact alone guarantees that the price of anarchy is
at most 1 minus 1 over E log N. So I want to point out this guarantee
holds even if the bidders don't know what their safe strategy is.
Okay. So the point is you might look at this and think like, okay, you
know maybe I don't know what CHV valuation I'm supposed to pretend I
am. And that's reasonable. But what an equilibrium guarantees you is
that whatever your safe strategy is, you prefer to do what you're doing
than anything else. You don't need to know what special this anything
else is you prefer to do what you're already doing than to deviate to
it.
>>:
What's the concept you're submitting over here?
>> Matt Weinberg: So any -- where is it? Any of these. So Nash
correlated, course correlated or Bayes Nash. And I haven't identified
them yet because it's not going to be super relevant yet.
So this is the first part of the theorem where we showed that the
single bid auction is 1 minus 1 over E log M smooth for sub additive
bidders. And therefore the price of anarchy at all these equilibrium
concepts is at most 1 minus 1 over E times log M.
>>:
Does this mean anything about the price of anarchy approximated?
>> Matt Weinberg: So when you -- so specifically when you do a
smoothness proof, it also extends to -- so if you have like epsilon
course correlated equilibrium you just lose multiplicative epsilon
here. Multiplicative, it's 1 minus epsilon times this bound. This is
not necessarily true for any price of anarchy bound but specifically
ones that are proved through smoothness. They're also smooth with
respect to approximate concepts.
Okay. So the next thing I have to do is so I told that you the
important part about this auction was that some equilibrium concept at
which this bound holds should arise naturally. And it's going to be
course correlated equilibria. Okay. So let me put these two theorems
on the board that maybe you're already familiar with. So the first one
is just relating learning algorithms to course correlated equilibria.
So what this says if you have any game and that game is played multiple
times so think every round you play the same game, if every player
plays a strategy that guarantees no regret then the aggregate
strategies that randomly sample a round and each player plays their
strategy from that round converges to a course equilibrium. I'm still
actually not going to formally define what a course correlated
equilibrium is. The only thing that's important is that every player
separately minimizing regret converges to a course correlated
equilibrium and the price of anarchy bound holds this equilibrium
concept. And then another theorem is if a player is trying to do no
regret learning and there are K possible actions that they can take, it
is possible for them to do this in time and space poly in the number of
actions. Okay. And by no regret I just mean that this is a standard
definition but every player is happier with the choices they've made
than playing any fixed action every round. Okay. So let me just give
you some examples so we can see why you can't do no regret learning in
some of these other auction formats.
>>:
Question about the significance of the first theorem.
>> Matt Weinberg:
Yes.
>>: So you say that the players can learn equilibria, but in each
round of the learning process itself, they are not necessarily in
equilibrium.
>> Matt Weinberg:
>>:
That's correct.
So that's correct.
So they need to switch eventually to --
>> Matt Weinberg: So it's not quite like that. So what's going on is
that so formally the reason that you care about price of anarchy bounds
course correlated equilibrium even though every day they're not
necessarily playing one is that if you look at the average welfare
across every day that the game is played, this is saying that the
average welfare is necessarily good because the strategies that are
played over time is approximate course correlated equilibrium. So it
is not the case that any single day you can look and say the welfare is
good on this day. But you can guarantee that over time the average
welfare is good.
>>:
So because every day may be just saying.
>>: What is course correlated [indiscernible] empirical distribution
of players, you pick one day at random and everybody plays
[indiscernible] and the welfare corresponds to that.
>> Matt Weinberg:
Yeah.
>>: So it's not the same as course, the course means you can just
pick. Random [indiscernible] the strategy pulled that particular way.
>> Matt Weinberg: Yes, that's right. So does this make sense? So the
important thing is that over time the average welfare is guaranteed to
be good, because of this claim. Okay. So as an example let's say that
we decided to use the simultaneous first price auctions format which is
known to have a price of anarchy of two. So each bidder has
exponentially many possible actions in this mechanism because they can
place a different bid for each of the M possible items. So if they can
place at least two different bids for each item then there's 2 to the M
different strategies. So they can't necessarily in poly time run no
regret learning. So this isn't a proof that you can't do it but at
least you just can't use an off the shelf no regret algorithm and maybe
you shouldn't expect bidders to be able to do this on their own. And
sequential first price auction it's actually even worse. Each bidder
has exponentially many in M number of bidders times numbers of items
possible actions because they now have to consider what are they going
to do for every possible history of bids on the preceding items. And
so maybe this is a little bit more interesting is that if instead you
have truthful auction, then each bidder may have many possible actions.
But they can always guarantee no regret just by telling the truth every
round. Because we know that every round no matter what happens you're
happier telling the truth than doing anything else. So you only have
one possible strategy that you need to consider. This last claim is
important, does that make sense. Even though you may have lots of
actions you only need to consider one of them. Okay. So here's an
observation about the single bid auction is that during phase two, when
the bidder is visited, and there's some set of S items that remain they
have no incentive to select anything except for their favorite set that
they can get. So they can't affect anything that happens to them in
the future. They can't affect any other bidder's behavior so they
might as well at this point just pick their favorite set which will
maximize their value for that set minus what they have to pay to get
it. So what this means is that even though the bidders technically
have exponentially many strategies during phase two, they can always
minimize regret by just picking the best one. So they don't need to
learn what they should do during phase two. Okay. Now during phase
one, they just have to submit a single real number and it turns out
that you only need to consider bids that are powers of two and this is
not an interesting proof. But what this means is that now the only
actions that bidders need to consider are actions that during phase one
submits a bid that's a power of two and during phase two buys their
favorite set of whatever is available to them and these are the only
actions that they need to learn over. And then the punch line is that
there's only polynomial many such actions. So what this means is that
because there's not too many actions however they wind up doing their
no regret learning it will run in poly time. Okay. So this is
wrapping up this portion of the talk. So what we showed is that the
single bid auction has price of anarchy log M at course correlated
equilibria whenever buyers are sub additive, and we showed that it's
learnable and that any standard or algorithm runs in poly time because
bidders only need to consider polynomial many actions. And spiritually
what this means is that it has a low price of anarchy at a solution
concept that is actually likely to arise in practice. And just to
remind you of how this contrasts with previous work is that prior
mechanisms either were not used because they had prohibitive runtime or
prohibitive complex design or they are used but we don't understand
what will actually happen when bidders play them.
>>:
[indiscernible].
>> Matt Weinberg:
You should ask Nikhil.
I don't know.
>>: So similar [indiscernible] have been used, considered draft
options. [indiscernible] that has been used. Hopefully -- pay
attention to this. How does it correlate to this one?
[indiscernible].
>>:
So price of anarchy is the same but you don't get the stability.
>> Matt Weinberg:
So --
>>:
A bit repeated.
>> Matt Weinberg: So the point is that in the draft auctions, how you
act the first time you bid may affect how like there's a lot of
interaction going on between your first bid, your second bid, your
third bid. So it's not necessarily the case that you always want to
pick your favorite set of items that's left, whereas in this one,
because it's so short, you immediately want to just pick your favorite
thing.
So let me say this, maybe this auction -- sounds like it might be used
in practice even if it's not. What might be more likely used in
practice is one that fills in this last column. So maybe -- so I think
what would be nice, price of anarchy of log M is not bad. But it's
also not constant and we know that the price of anarchy could be two
for these auctions that don't have or that we don't know have learnable
equilibrium yet. So this I think following this work is kind of the
main open question is to find the mechanism that is simple in design,
is learnable, runs in poly time but has a better price of anarchy.
>>:
So the option you described, log N is the lower bound?
>> Matt Weinberg: Yes. So that's the second part of the talk is going
to prove that, too. It's log M over log-log M. But log M I think is
probably the right answer.
>>:
What is this auction which gets two?
>> Matt Weinberg: This one? So this is every item you just run a
first price auction separately.
>>:
Why is it not statistically simple?
>> Matt Weinberg: It means we don't know how to find any equilibria of
this auction in poly time.
>>:
It's NP hard proven.
>> Matt Weinberg: Maybe spiritually to think if I told you that you
were going to play in this auction, like what would you do? That's
hard. Whereas ->>:
[indiscernible].
>> Matt Weinberg:
>>:
Sorry?
For many Ms you can't compute Nash --
>> Matt Weinberg:
That's also true.
>>:
You can't learn that's the main --
>> Matt Weinberg: I think that's the big thing you can't even learn.
So there's the point is there's exponentially many different bids that
you can make. So even if you were willing to do some kind of no regret
learning you can't do in poly time. Whereas for this auction okay it's
still not obvious to me like in one step what I should do in a single
bid auction, but at the very least if I run a no regret algorithm I can
do it in poly time I'll do something that guarantees me no regret.
>>:
What's the polynomial there.
>> Matt Weinberg:
>>:
In your auction, you help, there are many, many options.
>> Matt Weinberg:
>>:
Which polynomial there?
Uh-huh.
It's like just [indiscernible] how many strategies there?
>> Matt Weinberg: So it will be -- basically it's just how finely do
you have to disscuretize the bid space. It's not very fine, so it will
really be maybe like on the order of M or something. Like even if you
let them have M different strategies that lets you send exponentially
from like 1 to 2 to the M you can represent a lot of values like this.
So it may be even less.
>>: So try something, you're saying that the auction every item goes
separately a bid for every item. Doesn't matter what -- the theorem
would do that doesn't matter what will be lambda, it will be a factor
of two.
>> Matt Weinberg:
>>:
Correct.
Only problem is we don't know how the lineup is.
>> Matt Weinberg: Correct. In some sense you should maybe not expect
bidders to naturally wind up at 1 magically either. So I would say
another approach is maybe you could look at simultaneous single item
auctions to find a new equilibrium concept and say I think bidders will
do this and if it makes sense then prove price of anarchy bounds will.
But we don't know how to do that yet.
Okay. So the second part of the talk is going to discuss these things
that we call interpolation mechanisms and basically they're going to
address -- I'll say here what they're going to address is that -- so
after this got out a bit. So I think a lot of people were asking
questions oh there are so many natural generalizations of this auction.
Maybe one of these simple modifications will let you significantly
improve the price of anarchy. Okay. And the important thing is you
want to maintain that the auction is learnable. So that's a key
property. And so a lot of natural ideas are like, okay, you know
bidders could learn over two bids instead of just one bid. Made at the
same time. This isn't that much more information. Maybe this helps a
lot. Maybe you can set a different price for each item. So there's no
reason that you have to use the same price for every item. You could
report some information and then somehow I come up with a nonuniform
pricing. Maybe just sub additive is hard but it would be nice if this
auction worked for some modular or budgeted additive or valuation class
that was not quite so general. Another thing maybe we could study the
price of stability instead of the price of anarchy. And also I think
we wanted to understand what are mechanisms like this. What should
that mean. And so what we did in this follow-up work is we defined a
class of mechanisms like this that we call interpolation mechanisms,
and using this we showed that none of these four relaxations above can
improve the approximation ratio. So if we want to be log N we have to
do something new.
>>:
[indiscernible].
>> Matt Weinberg: No combination of them. Yeah. Okay. So let's
define. So an interpolation mechanism we say is a two phase mechanism.
The first phase is just some arbitrary communication protocol. The
output of that protocol is a truthful mechanism. And then phase two is
just bidders play whatever truthful mechanism was selected during phase
one. So think of the single bid auction, phase one is everyone submits
a bid and the output for phase two is a truthful mechanism that visits
bidders one at a time and when they're visited they are faced with an
item pricing that depends on how everyone bid during phase one. Okay.
So does this make sense? So once phase one is fixed and in the books
phase two is a truthful mechanism. That's for the same reason once
they get visited they just want to pick their favorite set. So I think
this is the right way to kind of to generalize this format. Again what
we're interested in is how much time or space does it take to run a no
regret algorithm on an interpolation mechanism. And the point is that
like we said before, bidders will never regret telling the truth during
phase two. So apriori they just need to consider all possible actions
during phase one combined with telling the truth during phase two. So
the important features of an interpolation mechanism will be how much
communication and how many rounds take place during phase one. This is
important because this tells you how many number of actions the bidders
are going to apriori consider. And second is what kind of truthful
mechanism shows up in phase two.
And I'll use this terminology M interpolation mechanism to be if the
phase two mechanisms comes from some class M. So this definition makes
sense.
Okay. And so this is the last definition I think I'm going to give.
We'll say that interpolation mechanism is apriori learnable if the
first phase consists of a single simultaneous broadcast round of
communication and each bidder communicates only log M bids. Okay. So
the reason this is useful is because this implies that every bidder
only has polynomially many actions to consider in the first round. So
they can run any no regret strategy that they want in poly time. And
you see this is sufficient but not necessary condition that a learning
algorithm exists. Okay. So again using the single bid mechanism as an
example in phase one there's log M communication per bidder and there's
one round that's why there's polynomial many actions. In phase two
I'll call this format a single posted price mechanism. Okay. It
picked some prices ahead of time. Visits buyers one at a time and
offers them any remaining items at whatever their price is per item.
Okay. So all right. So another view of single bid mechanisms now that
we're looking at it like this, is that this phase one by itself is
really pretty useless. So each bidder is only submitting log M bids
when -- their valuation is a sub additive function which takes doubly
exponentially many bids to represent. Okay. But somehow this -- so
this is not enough to guarantee any nontrivial approximation. The
second phase by itself is also completely useless because no single
posted price mechanism can possibly guarantee, and it's even worse you
can't get any kind of approximation just using one of these mechanisms
by themselves. But interestingly, combining them in the right way
somehow results in a pretty nontrivial approximation starting from
these two pretty useless components.
Okay. So there's some hope that maybe starting with a more useful
component in phase two will actually let you do better.
Okay. And so the right questions to ask for here are how much phase
one communication does it take in order to get a certain approximation
ratio with an M interpolation mechanism. You can ask this for any
class of truthful mechanisms. What is the best approximation guarantee
that you can get of an apriori learnable and interpolation mechanism.
Let's specialize that to the single posted price mechanisms. So how
much phase one communication is required to guarantee better than a log
M approximation with a single posted price mechanism. How much
communication do you need to beat the single bid auction? And so
actually it turns out that no amount of communication. So no single
posted price interpolation mechanism can beat a little O of log M over
log-log M approximation no matter how much communication happens during
phase one. And this is even when the bidders are just additive. So
the buyers don't have to be very complex for this lower bound to kick
in.
So in particular what this means is that the best approximation
guarantee of an apriori learnable single posted price mechanism is
somewhere between omega of log M over log log N and O of log M. Okay,
so I'm going to give a proof overview of this now. So what we want to
do is we're just going to construct an example where no single posted
price mechanism does well.
And then if we have an example like this, no amount of communication is
going to help you magically find the single posted price mechanism that
doesn't exist. Okay. So here's what the example is going to look
like. There's going to be for each buyer there's different bucket of
items. And the buckets are going to have wildly different number of
items. It will be N to the I for bucket I. Each item is going to be
special for exactly one bidder. And each bidder is going to have a 1
over N fraction of all the items in each bucket is special for them.
And bidders value their special items in each bucket at a factor of N
more than their nonspecial items. So maybe the concrete example is
more useful here. So the red items each different color is a different
bucket. So in the red bucket there's three items. Everyone values
their special item at 27 and their nonspecial items at nine. And the
blue bucket there's nine items. Everyone has three special items that
they each value at nine and they value their nonspecial items at three
and green bucket there's 27 items and they value their nine special
ones at three and nonspecial ones at one.
Okay. So clearly the optimal thing to do is just to give every bidder
their special item and now the question is how well can you do with the
single posted price mechanism. Okay. So the tradeoff here is that if
I want bidder one to get his special item in the blue bucket, I have to
set a price for him of nine or lower. But if I set a price for him of
nine or lower he's also going to steal the special items that I wanted
to go to the later bidders. And if I want him to get his special item
in the green bucket I have to set a price as low as three then he's
going to steal all the previous special items as well. Okay. So this
is kind of the tradeoff is that you can't give the first bidder all of
their special items without him also stealing special items from the
bidders who come after him. Okay. And it turns out that, the way the
math works out, that opt is N to the M plus one. No SPP can do better
than order N to the N. Their N to the N items in the example, so N is
log M over log log M, so that's where the gap comes from.
So what this means is that the single bid auction already reaches a
limit of the single posted price interpolation mechanisms. What about
more general posted price scheme? So I think the natural next step is
we'll consider ->>: [indiscernible] something too. So let's say that the
you gave before that if you do your auction like the first
announced for some reason 10 and second announced four and
you go in the right order and give each one the items that
no?
example that
was
so on. Then
they want,
>> Matt Weinberg: No. So these are the items and these are the
bidders. So if bidder one announces 10, he would show up and he would
buy only red item one. He would not buy any of the blue or any of the
green items. And then he would be gone and he would never come back.
And then two would show up. If he bid four, he would take what's left.
He would take all the remaining red items and he would take his special
blue item, but he would not take any of the green items. And then
three would come up, let's say they bid one. They would just take all
of the remaining items, whatever is left. Does that make sense? So
the point is that so bidder one's bid was too high for him to possibly
get his special items in the lower buckets. Bidder two's bid was too
high for him to get his special item here. It was also too low for him
to pass up on taking 3's special item in the red bucket. So the point
is that just every bidder has a wildly different value for the
different items and one number is just not enough for them to represent
their preferences and what you lose is exactly log N.
>>:
I think --
>> Matt Weinberg: Okay. Okay. So slightly more general scheme that
we want to consider I'll call nonadaptive posted price mechanisms.
Here you order the bidders however you like, maybe at random. And then
for each bidder in each item you set a price. Maybe at random. And
then you visit bidders one at a time. And offer bidder I the
opportunity to buy any set of items paying PIJ for item J.
Okay. So this generalizes it in the sense that now you can have
whatever price you want for each item. They can be different across
bidders. They can be different across items.
Okay. So now it's always the case that there is a nonadaptive posted
price mechanism that results in any allocation you want. And for any
allocation that you want to induce, you can just set the price of item
J equal to zero if you want bidder I to take that item, and infinity if
you don't want them to take that item. So we're not going to get a
strong impossibility result like on the previous slide because there's
always a nonadaptive posted price that results in the optimal
allocation. So the question now is how much phase one communication do
you need to find a good nonadaptive posted price mechanism. Okay. So
just because one exists doesn't mean you can find it easily. Okay.
And so the answer is that any nonadaptive posted price interpolation
mechanism that guarantees little O of log M over log log M
approximation still just on all instances of additive bidders
necessarily has at least M to the 1 minus epsilon first round
communication per bidder and this is for any epsilon. This is not just
for one fixed epsilon. For any epsilon this has to hold. Okay. And
so the proof -- I'm not going to go through the proof. It looks
similar to the previous construction. The idea is that now we need a
family of examples such that no single nonadaptive posted price does
well except on an exponentially small fraction. It turns out that
using a probabilistic construction and ideas from the previous one we
can do this. Okay. So what this means is that the best approximation
guarantee of an apriori learnable nonadaptive posted price
interpolation mechanism is somewhere between omega of log M over log
log N and O of log N. So this means that even for this way more
general class of mechanism single bid auctions have already reached
limits of these. So maybe what about other classes of mechanisms?
>>: Supposedly the additive -- the additive we know things should be
[indiscernible].
>> Matt Weinberg: No, even for additive. The problem is if you have
an additive buyer, it takes basically N log M bits to describe your
valuation. So if I let you use N log M bits, you could tell me your
value. I could allocate the items optimally. There's no problem. It
turns out that in order to do anything better than log M over log log M
you need basically to say your whole valuation. That if you use
anything less, you can't beat log M. But that just one number is
enough to get you log M.
>>:
N log M is basically a separate auction.
>> Matt Weinberg: Yes for additive buyers that's exactly what you
would do. Yeah. Okay. So I'm going to just maybe briefly go through
this. So we considered two more classes of mechanisms that have been
previously studied. I won't read through the definitions but they're
called maximal and range of valuation query. Very strong lower bounds
are known against both of these classes of mechanisms as truthful
mechanisms without interpolation. And what we show is that all of the
existing lower bounds also extend to interpolation mechanism s that
have subexponential first phase communication. That means that these
are also not going to let you do anything interesting with apriori
learnable mechanisms. Okay. So now I'm going to wrap up. So just to
recap, the motivation was we wanted combinatorial auctions that had,
that were either proximally optimal or had a low price of anarchy. We
wanted them simple in design and also strategically simple.
Specifically we mean learnable. So in the first part of the talk we
showed you the single bid auction. And it's the first one that hits
all three of these criteria. But the price of anarchy was still
logarithmic and not constant. And the second part of the talk we
introduced this notion of an interpolation mechanism to try and
properly generalize this format. And the way to think about this this
is kind of like mixing a nontruthful and a truthful mechanism. The
first phase is nontruthful. But really limited. And the second phase
is a truthful mechanism. We proved lower bounds on mechanisms that are
like the single bid auction. We showed that we've already reached the
limits of interpolation with all these classes of mechanisms. The one
that we left open is I'll call adaptive posted price mechanisms. So
these are posted price mechanisms where based on what you see for the
first couple bidders you can update the prices of the remaining
bidders. So these are -- whoops. These are more general than the
non -- that's why they're called nonadaptive. The ones we saw so far,
where the prices were fixed. Where the prices were fixed ahead of
time. Okay. And we know that the techniques that we have right now
cannot possibly prove lower bounds for additive buyers and adaptive
posted price mechanisms. So we need either new techniques for lower
bounds or maybe this is a nice direction for positive design. Okay.
And then just to give you this chart one more time. So the left-hand
side is what we already knew. The green column is what we contributed
with the single bid auction. And then the right-hand column is I think
a nice open direction and interpolation mechanisms are maybe a nice way
to address it. Okay. So that's all I have. Thanks a lot for
listening. [applause].
>>:
Any more questions?
>>: Could you look at you're characterizing the strategy, the learning
[indiscernible] the single bid auction.
>> Matt Weinberg: That's a good question. No. We didn't. Yeah, so I
guess you would first have to for different valuation functions you
could test and see what happens. But we didn't look at that. That's
actually a pretty good question.
>>:
So but for additive buyers the family simultaneous single auction.
>> Matt Weinberg:
>>:
It's optimal.
So for additive buyers.
[indiscernible].
>> Matt Weinberg: It's better than learnable. It's truthful. For
additive buyers, simultaneous auctions you should always bid your value
on every item. There's nothing better you can hope to do.
>>: So for additive buyers VCG and simultaneous and sequential are
all, they're all the same thing and they all collapse to good news. So
the reason we were using additive buyers for lower bounds is basically
to rule out you might say, look, sub additive functions are really
complex. Maybe you can have a good price of anarchy for some modular
buyers or something way simpler. We're saying there's no way that
restriction is going to help you because whatever restriction you come
up with it should at least contain additive buyers. So I'm not
motivating that searching for better mechanisms for additive buyers is
not interesting research direction. But if you have lower bounds for
additive buyers you shouldn't hope to get anything interesting beyond
that.
>>: So Mark is here until Monday. I encourage you to talk to him.
Not related to this, about anything.
>> Matt Weinberg:
[applause]
Thanks.