>> Yuval Peres: Hello and welcome everyone. It is my pleasure to introduce Saeed Alaei from the
University of Maryland. Saeed has been here before as an intern in 2009, and he is going to tell us today
about Bayesian mechanism design via multi-to single agent reduction.
>> Saeed Alaei: My talk is about Bayesian mechanism design via reduction from multi-agent to single
agent mechanism. So I will start with a quick introduction about what the problem is and then I will
explain two separate approaches for dealing with this problem. The first one is called the competency
via interim allocation rule, and the other one is decomposition via Ex ante Allocation Rule, so here's a
quick introduction. Mechanism design, we face an optimization problem however the input of that
optimization problem comes from selfish agents who may want to misreport and they input in order to
manipulate the outcome in their favor. So we assume that the private information of which agents is
called agent's type, and for example if you have action for setting up one unit of an item then the
private type of each agent would be there value of the item. And the performance of the mechanism is
measured with respect to the actual types and not with respect to the true types. Therefore, in
mechanism design we have to take incentives of the agent’s input account. Roughly speaking
mechanisms can be categorized to mechanisms with money and mechanisms without money.
Mechanisms with money usually either want to maximize welfare or some other objective which is
typically revenue but it could be other objects representing revenue. For example, if you have a Java
scheduling you may want to minimize [inaudible]. For welfare maximization for the case of quasi-linear
utilities which means your utilities are running the outcome minus your payment, the game theory
respect to the problem has been solved like you can get an optimal solution by using VCG, but that
computationally it could be NP hard so there are approximations for this. Another way you can look at
mechanism design is based on prior, whether it is prior free or Bayesian. So Bayesian mechanism design
we assume that we know the distributions from which the agents’ types are drawn, while in prior free
we don't make such an assumption. So in this talk I will focus on the Bayesian settings and assume that
agents’ types are drawn from independent distributions and this is crucial for the rest of my talk. And I
assume further that the objective is something that is linearly separable over the agents; it could be
welfare revenue or any other objective. By linearly separable I mean the objective is the sum of the
objective values that you obtain from each single agent, which is obviously the case for both revenue
and [inaudible]. And assume that the coupling restraints for the agents are polymatroid. I will explain
this later. The main result is that in such environments you can reduce the complexity of the problem
exponentially by doing a multi-agent to single agent reduction and this is without any loss of
performance.
>>: [inaudible] solutions.
>> Saeed Alaei: Yes. I assume that I know what the solution is, but there is some solution and I know
there is some solution.
>>: Just you know, or everybody knows?
>> Saeed Alaei: Everybody knows there's a solution and everyone agrees on the solution so these are
critical assumptions. So what I'm going to explain is the general framework which can be applied to a
variety of settings. For example, it can be applied to non-quasi-linear utilities when you have budget or
risk, or settings, in settings where you don't have money and, for any arbitrary object as long as it is
linearly separable. In most of my talk I will try to focus on the mathematical problems that arise in this
context in the abstract form; I will try not to focus on the game theory aspects that much. So here are
some related works with Bayesian mechanism design. So these are mostly economist’s work. In simple
work where there is, where you have one unit of an item and you have either risk aversion or budget
constraints and most of them assume that the agent types are distributed identically and independently
so these are mostly symmetric cases, and these problems are really hard. If you move from welfare
maximization to something like revenue maximization, the problem suddenly become so hard. As
opposed to the welfare maximization where we see G as optimal, in revenue maximization there is no
like global solution. And for multidimensional types, again, these first two lines are economist’s where
they, so please only handed, these are only about the various special cases where the valuations space
has various specialized structure and a can be reduced to single unit dimensional case. And then there
are some computer scientist’s work, and very recent work that deal with specific variance of like the
revenue maximization problem. For example, in some special settings where you have budget and a
limited number of items that we want to, like we have some independent distribution and we want to
maximize revenue, something like that. And then there is this very recent work which actually uses
techniques which are very similar to the techniques that I am going to describe, but they don't present it
as a reduction. They will use these techniques to solve a specific problem of revenue maximization
where you have independent, like when you have independent agents with item valuations in multiitem auction. So I will start with decomposition via interim allocation rule. This is a joint work with Nu
Fu, Nima Haghpanah, Jason Hartline and Azarakhsh Malekian. So I will show you the first part of my talk
is the recent one and the second part is something which is just my, just me and it is from last year. This
is the first one is the more recent part. So I will start with a quick example which should give you an idea
of what it means by reduction from multi-agent to single agent reduction. Consider any auction for
selling one unit of item to, and pick any action that sells to the highest bidder and consider it a truthful
auction. Suppose these are, have three agents here. So T sub i denotes the type and space of agent i
and these are symmetric agents and each agent has two types. The high type has two dollar, the low
type has one dollar for evaluation for the item and they happen to be equal probability. Now if you look
at any auction which allocates to the highest side, you can actually see that when the agent, one for
example, bids A, he wins it for relative 7/12 and otherwise he wins it with relative 1/12, in expectation
over what the other agents submit. Consider a single agent mechanism which does the exact same
thing, like whenever the agent bids A he wins with this probability and when he bids B he wins with this
other probability and it is well known that in any truthful mechanism once you fix the allocation you can
actually compute the payments corresponding to that allocation which leads to a truthful mechanism.
From the perspective of that agent, that multi-agent mechanism is equivalent to this single agent
mechanism. Actually, this equivalence holds in general and doesn't need to make any assumption about
quasi-linearity of utility, risk neutrality, budget or anything. If you give me a multi-agent mechanism, if
you assume that agent types are distributed independently, I can give you a single agent mechanism
which is equivalent for each agent.
>>: You go back to the [inaudible]?
>> Saeed Alaei: I assume that these ties are broken up uniformly at random.
>>: But the parameters are exactly the same here and after the reduction?
>> Saeed Alaei: I am saying that if this was a multi-agent mechanism, ignore this. Suppose you have an
auction which allocates to the highest agent. Then this is the expected allocation that this agent
observed. Now suppose I give you a single agent mechanism which allocates with these exact
probabilities. Suppose there is no other agent. I just give you a mechanism that if you bid A, it allocates
the item with this probability otherwise with this other probability. And what I am claiming is that from
the perspective of this agent there is nothing different between this and a multi-agent mechanism. In
fact, more generally, if you have a multi-agent mechanism and you have independent bidders, you can
induce a single agent mechanism on each agent as follows. Fix some agent and for all of the other N-1
agents create dummy agents which are drawn from the distributions of those corresponding agents.
Simulate the other agents. Run the multi-agent mechanism on those simulated agents and this actual
agent. And this actual agent will not be able to tell the difference between the simulated mechanism
and the actual mechanism, and here is the point where it is important that the agent types are
distributed independently because if the agent types are correlated, than simulated agents types will
not be correlated with the actual agent, so it is crucial that the agents’ types are independent.
>>: So one more thing. So building this [inaudible] was a benefit you're getting our…
>> Saeed Alaei: I'm not doing, I'm just…
>>: [inaudible] the taking a [inaudible] coming up to…
>> Saeed Alaei: Yes. What I want to do is to go in the other direction. I want to instead of designing a
multi-optimal, multi-agent mechanism, I want to somehow design optimal single agent mechanisms
because single agent mechanisms are easier to design, because instead of considering all possible
combinations of agents’ types, I have to consider only the types of one agent. So the space of
possibilities is exponentially smaller. So that is the idea that I want to get to.
>>: [inaudible].
>> Saeed Alaei: Yeah, this is the other direction; I want to say that anything can be decomposing this
way. In general I claim that any multi-agent mechanism regardless of the setting can be decomposed as
follows. You can decompose it with central allocation mechanism and a bunch of single agent
mechanisms. It works as follows, each single agent mechanism communicates with the corresponding
agent and then this single agent mechanism simultaneously submits some probabilistic demands to the
central allocation mechanism. The central allocation mechanism then allocates resources to the single
agent mechanisms in such a way that in expectation would satisfy these probabilistic demands and then
finally, the single agent mechanisms decide exactly the final outcome corresponding to these agents. So
let me explain this to you with an example. Suppose you are in a setting where you want to sell one car
to, you have three agents; you have one car for sale. Each agent has a multidimensional type and
because each car can be customize in different ways before sale. You can for example, let's say you can
change the color of the car and you can install a sports package, so each agent will have different
valuation for the car based on how you customize the car. Now consider any optimal multi-agent
mechanism in this case. The only constraint is that you can allocate the car to one person. There is no
constraint on how you can customize the car, so this is clearly multidimensional setting and for each
type of, for each agent so this is the, this is the [inaudible] type of space [inaudible] probability of each
type and X is the expected allocation for each type. Take any optimal mechanism and compute the
expected probability of allocation for each type in that optimal mechanism. Now I give you an
equivalent decomposition mechanism that does the same thing. Suppose for each agent I do the
following. I compute a single agent mechanism for this agent subject to these allocation probabilities.
What I mean is that fine, suppose that I have given you this probability like .45 and .1 and I ask you,
what is the optimal mechanism for setting to this agent subject to the probability of allocation not being
more than these red numbers? And suppose we have only the single agent. There is no one else. And I
claim that this optimal single agent mechanism subject to this is exactly the single agent mechanism that
is induced on this agent by the optimal multi-agent mechanism. So basically you can see that as the
following. You have a bunch of optimal single agent mechanism, when the agent to meet their type the
single agent mechanisms submit their probabilistic demand like these single agent mechanisms
[inaudible] .45 to the central allocation mechanism and then the central allocation mechanism ensures
that each single agent mechanism receives the resource with the expected probability in expectation
this much. So to define this formally, so, so far I am considering the single unit of resource that we want
to allocate, but these can be generalized. But I will stick to this simple example. Define T sub N as the
union of the all of the type space. This is a set of the types of all agents and we [inaudible] [inaudible]
assumed that the type spaces are disjoint. Now I define this vector X which is the expected allocation
for each type of each agent and I will call it the interim allocation rule. So in the decomposition I am
claiming, the central allocation mechanism implements this interim allocation rule. In other words, if
each agent submits, I mean if each agent reports a type according to this with these probabilities then
they should receive the item like the resource with those red expected probabilities. And then each
single agent mechanism is optimal subject to the interim allocation rule. So here are a number of
questions that we need to address in order to be able to use this technique to design optimal
mechanisms. First of all, when is an interim allocation rule feasible? So for example, suppose here
instead of .45 I had 1. That would be clearly an infeasible case because what if agent one submits A and
agent two submits C and if this is one then both of the agents have to get the probability of one, so that
is clearly not feasible. And so what the first thing is we have to ensure the physical interim allocation
and so suppose I give you an interim allocation rule that is feasible, how can you actually implement
this? Suppose I have given you these tables and I am asking you to give me an allocation policy that
would implement in expectation, allocate to each type, reduce to red probabilities. How would you do
that? And the third question is how can I compute the optimal interim allocation rule, and finally, the
last question is suppose I give you the interim allocation rule, how can you compute the optimal single
agent mechanism subject to this interim allocation rule. So I will focus on the first three questions and I
will talk about the last question later.
>>: [inaudible] so what you assume [inaudible] assumed [inaudible] optimal mechanism.
>> Saeed Alaei: I assume that I can complete the optimal single mechanism if you give me this red
probabilities, I can compute the optimal single agent mechanism subject to not allocating more than
those probabilities.
>>: So the fourth…
>> Saeed Alaei: That is the fourth question.
>>: So this you assume to have a black box for this?
>> Saeed Alaei: Yes. I assume that I have a black box for that, and I want to answer the first three
questions.
>>: So suppose you [inaudible], let's just take an example, suppose you have a black box but just
optimal [inaudible] mechanism [inaudible] X is something external [inaudible] see is this much you
decided it's more than this probability and so on [inaudible] so is it [inaudible] you can actually
[inaudible] or is it something that you assume?
>> Saeed Alaei: The something that I assume, but for most of the, like for all of the problems that I
know of, you can compute this. Like if you can compute a single agent mechanism for some X, you can
compute it for any X. And it has some nice property which I will explain later, but the expected
[inaudible] is always concave and I will get to that later.
>>: This is optimal single agent [inaudible] optimal for who?
>> Saeed Alaei: So the optimal single agent mechanism is the following. Suppose I have only this one
agent and there is no other agent in the picture, and I am only asking you to construct a mechanism for
me to maximize the revenue from this single agent, and I am putting a constraint on you. The constraint
is the following. If agent, like take this agent, if agent beats C, agent 2, then you are allowed to allocate
the item with probability at most 0.45 and if he beats D you are allowed to allocate with probability at
most .1. What is the maximum revenue you can get in expectation from this agent if that is your
constraint?
>>: [inaudible] so [inaudible] you are asking what is the objective…
>> Saeed Alaei: It could be anything. I am assuming any object that you want to maximize, let's say
revenue. So for the rest of the talk let's say we want to maximize revenue. This could apply to welfare
revenue or any object which can be linearly separated over the agents.
>>: Just to be complete [inaudible] illustrate example of an optimal single agent mechanism in this
setting [inaudible]?
>> Saeed Alaei: Okay. So let's say, I mean I can't compute it off the top of my head, but let's say, I mean
it depends on exactly what you mean. But let's go back. So let's say, let's say that this is a, let's say that
this is the setting that you have and you are constrained with these probabilities. So okay, imagine that
the optimal single agent mechanism here would be something like, you either don't sell to this guy and
always sell to this guy at two dollars. Like you said a price of two dollars and if the guy beats two dollars,
it's not the price. If the guy beats two dollars you will allocate it to the guy and you with this probability
and if he bids one dollar you allocate it with probability zero, if you want to maximize revenue. So the
setting I've explained here originally was for maximizing welfare, but let's say you want to maximize
revenue, and these are your constraints. The optimal mechanism here would be to sell at two dollars
with this probability, which is the maximum you are allowed to, and if he bids one dollar, doesn't sell to
him at all.
>>: Why not sell to the one dollar?
>> Saeed Alaei: Because if you so for one dollar what is the maximum price you can charge? The
maximum price you can charge is one dollar, which means that you also have to charge one dollar for
this higher bound because he would lie to you if you don't, if you want to charge something higher.
>>: [inaudible]?
>>: So this [inaudible] upper bound constraint?
>> Saeed Alaei: Yes, it is an upper bound constraint on what you can do.
>>: What is that Fs there, F1, F2?
>> Saeed Alaei: F1, these are the distributions of these types. Like F1 of A is probability .5 type A;
probability .5 that is type B. And that is the allocation, the expected allocation that he receives, but I
treat the expected allocation as a constraint when I want to compute optimal single agent mechanism.
[multiple speakers] [inaudible].
>> Saeed Alaei: Yeah, yeah.
>>: Is for the [inaudible] or just a random…
>> Saeed Alaei: Yeah, the random coins are in the mechanism…
>>: [inaudible].
>> Saeed Alaei: Yeah. But when you have multi-agents this random mechanism could come from other
agents. So here is formerly the problem back there. From now on I will just ignore all of the mechanism
design aspects, and I will just look at the following problem. Suppose I have given these tables and I
know, for example, that agent one has type A with this probability, and it has to be allocated with, like it
has to get the item with the this probability. And I want to come up with some allocation policy which in
expectation satisfies this red probability. Like whenever agent like two beats C, he has to receive the
item with probability .45. And so and the question is that I want to answer is whether this expectation
probability which I call the interim allocation rule, whether they are feasible and how I can actually
come up with some allocation that implements that, and how we can optimize over X and how we can
compute the optimal single agent mechanism. So to give you an idea of how we can solve this, I will
demonstrate computationally an efficient solution for answering this question. So it is based on an
expert flow argument. So for every possible scenario of the agents that come, I will push one vertex so
each one is like one possible profile of types for the agent. And for each type for each agent I will also
push one vertex on the right-hand side, and I will add a source node and a sync node. Now I will add a
directed edge from the source node to each scenario and then the capacity of each edge is the
probability of that scenario happening. And on the other side I will basically set, direct the edges from
each type node to the sync note in the capacity of each such edge is the probability of that node
happening multiplied by the expected allocation that that type meets. So this is like a demand and this
is like a supply that you have. And you set the middle edges as follows. For each scenario you add
directed edges to the types that appear in that scenario. Like for AC your directed edges to A, C and E.
Now if you have a feasible flow, if the maximum flow from source to sync saturates all of these edges,
then that means that your interim allocation rule is feasible. And if you actually compute a maximum
flow, the amount of flow in the middle edges exactly tell you how to allocate the item. Like, for
example, if you are at scenario A, C, E, look at the flow that goes to A and flow that goes to E and flow
that goes to, sorry C and D. and what it means is that if this scenario happens, you just allocate the items
to one of the A, C or E proportional to that, proportional to the flow of those edges.
>>: Are you assuming that T i’s are disjoint.
>> Saeed Alaei: Yes, I am assuming that T i’s are disjoint. If they are, I mean it doesn't really, that is not
[inaudible] because if they are equal, the same I can like re-label them differently.
>>: [inaudible] makes a difference [inaudible].
>> Saeed Alaei: I mean, I assume that the type I space of each agent are labeled in different ways so if
they are like exactly, they mean the same thing. I will just name them differently. So…
>>: [inaudible] actually a few could give everybody equal edges.
>> Saeed Alaei: Exactly. If these edges are all saturated that would be condition of feasibility. As you
can see this network flow construction is exponential, because you have a node for every possible
scenario, so it is not efficient. But I just wanted to give you an idea of how we can handle this. Okay so,
let capital X denote the set of all possible feasible interim allocation rules. And now suppose for each
agent our R sum i of xi is like x sum i is the part of the interim allocation rule that is restricted to the
types of that agent. So this denotes the expected objective of the optimal single agent mechanism
subject to this interim allocation rule. So first of all, we show that for any single agent problem with the
maximization objective, this R is concave. And this is regardless of whatever object you have or
whatever the constraint on the single agent mechanism is. It is always concave. And therefore, you can
complete the optimal interim allocation rules by just solving this convex program which maximizes the
sum of the single agent objectives subject to physical interim allocation rule. However, this convex
program is of course exponential size because you have the network flow construction is exponential.
So we want to address this problem. We want to check the physical interim allocation rule and be able
to optimize over them in polynomial time. So let's go back to this network flow case. The condition for-so you can imagine these nodes as demand nodes and these other nodes on the left as supply notes. In
order for this network to have a feasible assignment that satisfies all of the demands, the condition that
you need to satisfy is that for any substantive vertices on the right, the total demand should be less than
or equal to the total supply of their neighbors on the left-hand side. That is a necessary [inaudible]
condition. That condition actually discovered by, it was not discovered but it was proved to be sufficient
by Border although Border didn't use this network flow argument. He had a very complicated argument
for proving this, and it can be interpreted as the following. For any substantive types, the total supply of
their neighbors is exactly, so what are the neighbors of these types. The neighbors of those subsets are
exactly the scenarios in which at least one of those types appears. And this is the total demand. So
basically it says that the total demand of that set should be less than recall to the probability that there
is at least one agent whose type is in that subset. And consider exponentially many equalities, but this is
now easier to handle. So now I want to give you polymatroid characterization of this space of interim
allocation rule. Define a normalized interim allocation rule as follows, just multiply the expected
allocation of each type by the probability of that type appearing. And define this function g of S where S
is the subset of types to be equal to the probability that at least there is at least one agent whose type is
in set S. Now the set of all normalized interim allocation rule is a polymatroid defined by these
inequalities. Because it is a polymatroid, you can optimize over it in polynomial time because you can
find, you can construct a separation Oracle and to find a viable inequality by minimizing the G of S minus
the x bar of x for any given x bar. This is a summation of it. We actually show that you can do it very
efficiently in time which is almost linear. Remember that T sub N is the set of all types which is actually
the size of the vector X bar, so this is pretty efficient. So you can…
>>: [inaudible] X is feasible [inaudible].
>> Saeed Alaei: You get the separation overkill and because you have the separation overkill this is
conical space. You can optimize over this space using [inaudible] method in polynomial time. So you
can compute the interim allocation rules in polynomial time. Now the question is, how can we
implement the interim allocation rules. So if I give you an interim allocation rule which is feasible, how
do you allocate the resources to satisfy these expected probabilities? So I will start by defining type sets
that turn out to be very important in our implementation. So let us look at the interpretation of this X
bar of S. So X bar of S when you have one item, simply has the following interpretation. It means the
expected probability that there is a type from, that a type from set S shows up and also gets allocated
to. That is the meaning of X bar of S. It is basically the sum over, okay, this notation means take the
sum over all elements of, like look at the vector X and sum over all elements of X, entries of X that
appear in S. And what is g of S? g of S is the probability that there is at least some type in set X. And
obviously this first one has to be less than or equal to the second one, because if there is an agent from
set S that has appeared and has been allocated to, there must be some agent from set S that has
appeared. And the important thing is that when the two are equal, that means whenever there is at
least one agent from set S, then at least one agent from set S should get allocated to. But if there is
more than one agent in set S then it doesn't say whom to allocate to, but if there is at least one you can
allocate to that. So if somehow, it tells you determines what should be your allocation in the case
where you have a tight subset. And it is easy to show that tight subsets are closed under union and
intersection because the tight subsets are minimizers of a sub modular function so they are closed. And
therefore tight subsets form a hierarchy.
>>: What does tight mean?
>> Saeed Alaei: It means that they are contained in each other or they don't intersect like, I mean, I will
show you in a second. Actually, we can show that when agents are independent they form a hierarchy
which means that there is some ordering in which every tight set is contained in another tight subset.
They can't, you can't have tight subsets that are disjoint. So here is an example. Suppose x4 is your
normalized interim allocation vector. And in this example these are the type subsets. A by itself is a
tight subset and A, C and E is also a tight subset. So because of that proposition regarding the tight
subsets, what I know is the following. That if, and in this scenario, A, C and E, because A by itself is a
tight subset it has to always be allocated, so in this case there is only one choice. I have to allocate to A.
And let's say, let's have another scenario. Let's say the scenario is B, D and E. now E is the only one in
this tight subset that has appeared so I have to allocate to E. There's no other choice. But now let's say
if you have a scenario like B, C and E. In this case you have two guys from one tight subset and B is not
in a tight subset so definitely, for a position I know that I cannot allocate to B but it doesn't tell you
between C and E which one I should allocate to. But now observe that if you have a scenario like this
where we have a full hierarchy of tight subsets, this would completely pin down the allocation, because
if you have something like a full hierarchy of this type, then basically when the agents come in to report
their type, you just sort them in the order defined by these hierarchies and you allocate to the first
agent based on this ordering. So it would be nice if our interim allocation rule, normal interim allocation
rule corresponded to some hierarchy like some full hierarchy like this. And it turns out that the vertices
of that polymatroid, the polymatroid of this, of all feasible interim allocation rules has that property. So
let me define this formally. A partial ranking is a ranking of a subset of the type of space, so basically
suppose S is a subset of types, partial ranking assigns numbers between one and the size of S to these
numbers, so ranking them in some order. Every partial ranking corresponds to a vertex of the
polymatroid and vice versa. Every vertex of a polymatroid corresponds to a partial ranking. And here is
how you get from a partial ranking to vertex of the polymatroid. Basically look at, let's say that this is
our partial ranking. What I will do is the following. I will start with a vector which is all zeros and then I
will start increasing the first element in the ranking, which is A. I increase A until set A by itself becomes
tight. And then the next one, and then is C and I will start increasing C until AC becomes tight, and then I
start increasing D until A C and E becomes tight. And at that point I will stop because B, D and G are not
in the rank, in the partial ranking so their corresponding values will be zero. And this gives me a vertex
of that polymatroid and you can go off in the opposite direction. If I give you a vertex of the
polymatroid, you try do can actually use a greedy algorithm to find a corresponding ranking. And the
nice thing about this ranking is that you can actually deterministically implement the allocation rule
corresponding to ranking, because if you have ranking like this, then it means that whenever the agents
arrive and submit their type, you just sort them based on their type according to this hierarchy and you
allocate to the agent whose type comes first and if, for these other types like B, D and G that the
corresponding interim allocation will zero so you just ignore them, even if there is no type who comes
before them.
>>: [inaudible] because two of them looked to come from the same example, [inaudible] the same time.
>> Saeed Alaei: No, no. If you have a partial ranking, the hierarchies will always be this strict. I am
saying that if you have a vertex, a vertex always defines a strict ordering on some subset of the elements
and it gives deterministic implementation for that vertex. Another important, the nice thing is that if
your normalized interim allocation rule happened to be a vertex of that polymatroid there is a
deterministic implementation for that. And if it is not a vertex, what you can do is it can write it as
convex combination of the vertices of the polymatroid and you can sample a vertex from that convex
combination and then implement it, like use a deterministic allocation corresponding to that vertex.
And actually it turns out that you don't even need to write it as a convex determination. What you can
do is that you can round this X to a vertex in such a way that every coordinate and expectation remains
the same, so I will give a quick--this is previous work. I will give like a quick sketch of how we can do
this. So let's say this is your normalized interim allocation rule, and these are the tight sets that you
have so far. Let's say C and E are both in the same tight subset. What you do is you start increasing C
and at the same time decrease E by the same value until for some Delta this set A and C becomes tight.
And we can also do the opposite thing, like increase E and decrease C until AE becomes tight. You can
always show that at least one of those sets becomes tight before the other entry reaches zero, and this
is always the case. And then you would randomize between one of these two outputs with [inaudible]
proportional to a dev time of Delta prime. And if you do this at random like do the left thing with
[inaudible] Delta prime over the sum of dev time Delta prime and do the right thing otherwise. In
expectation the value of every coordinate remains the same, but you have increased the number of
tight sets by one, so if you keep repeating this thing after a number of iterations you will get to a vertex
in which every coordinate in the partition is the same as the original point and you can actually show
that the number of iterations that you need is at most in the length of this vector.
>>: [inaudible] solution.
>> Saeed Alaei: Yeah, yeah it is exactly the same. Just…
>>: [inaudible] at this case you might have a small support, right?
>> Saeed Alaei: But the thing is if you want to write as a convex combination of the vertices it could be
like you don't want to write it as a convex combination of exponential [inaudible] vertices, right?
>>: This would do that.
>> Saeed Alaei: This would do that, but the thing is it's fine because we just want the sample from that
convex combination so we don't have to go through the trouble of writing it as a complex combination
of a small number of vertices; we can just use this randomize, random approach which just gives me one
vertex. It could be, yeah you are right. The support of this random is random is exponential, but we
don't care about it; we just want to sample from this in polynomial time. So this basically gives me an
implementation for any normalized interim allocation rule. So let's look at some generalization of this.
So now instead of having a single unit of an item, suppose you have a matroid which specifies your
allocation constraint, which means for any subset of agents they can be simultaneously allocated if their
types form an independent set of matroid. It turns out that the condition for feasibility and that this
[inaudible] for feasibility is the following where the RM is the ranked function of the matrix. You
basically replace whatever you had on the right-hand side of your polymatroid concern with the
following. This is the expected rank of the subset of types that have appeared intersection some set S
that comes from your polymatroid constraint. Consider a case where you had one unit of item and that
case the rank function is just a minimum of zero and one, sorry the minimum of one and the
intersection, the size of the intersection of T and S. which means if there is at least one agent whose
type is in set S this whole thing would be one, if you have the rank one uniform metric, and otherwise
this would be zero so this is exactly what we had before. But this is more general, this works for any
matroid environment. And the other things that I explained actually works for this environment. If you
have a vertex the vertex again corresponds to a partial ranking and what you would do to compute the
allocation for a vertex is you would just go through that ranking and specify for the vertex and you look
at the agent types and you try to allocate to them one by one if the set of, if the current set of allocation
remains an and independent set. So you just basically pick a maximum independent set from every
prefix of that ordering. And this can be actually generalized even more. Actually, that matroid itself
could be randomized, so this is the same condition is still holds, and this is useful for example in
environments where we have a stochastic supply. Given an example of this and this can be extended
even to environments with polymatroid constraints.
>>: [inaudible] explain this [inaudible] gm [inaudible]?
>> Saeed Alaei: This is just quantity. This is the expected value of the branch of the matroid where the
expectation is taken over all possible scenarios of the intersection of some set S and the set of types that
have appeared in that scenario. So this is basically telling it the following. Suppose if I fix a set S of
types. What is the maximum that you can allocate to this set? This is the rank of that set. And you can
only allocate to type if that type has shown up, so this should be the intersection of T and S. So in a
sense this is telling you how much you can allocate to this specific subset in expectation over all possible
scenarios. So let me give you an example of a scenario, a problem that can be solved optimally by using
this approach. Suppose you have, you are in a display advertisement. You want to sell contracts for
display advertising. You have n advertisers. Each advertiser has a budget constraint and each advertiser
has evaluation for each type of impression, and they also have a cap on how many impressions of each
type they want, and the advertisers are also partitioned into certain categories and the assertion wants
to ensure that from each category there is a cap of how many advertisers from that category gets
impressions of a certain type. And also, suppose that your exact supply is not known because you are
selling these contracts in advance you don't know how many impressions you're going to get in the
future. So this is something that can be modeled exactly in the framework that I have explained.
Assume that all of these [inaudible] are [inaudible]. And you can solve this problem optimally like you
can compute an auction for maximizing revenue optimally for this setting by using the framework that I
have explained in polynomial time. Like one thing that is worth mentioning is that if for each advertiser I
want to also specific a cap for the total number of impressions that the advertiser would get, then it
would not be, this constraint would not be a single polymatroid. It would be the intersection of two
polymatroids, so that will be, we still don't know how to handle. But for a setting which is like generalize
what you have here, you can still solve it optimally in polynomial time. So the second part of my talk is
the composition via Ex ante Allocation Rule. I will try to go over this quickly and this actually came
before the first one. This is a paper from last year. So the Ex ante Allocation Rule is defined as the
following. Suppose for each agent I will take the expected probability of allocation over all possible
types of that agent. This is for example the sum of the products of these probabilities and this allocation
like .5x1+.5 times this. And you get a single number for each agent. And I call this the Ex ante Allocation
Rule. So it specifies that what is the expected probability that you allocate the item to the agent if you
don't know the type of that agent. Now I want to do some kind of decomposition similar to what I did
with the interim allocation rule and observe that the Ex ante Allocation Rules are much small like if you
could use this, it would be another exponential reduction in the complexity of the problem because the
interim allocation rule specifies a probability for each type, whereas the Ex ante Allocation Rule just
specifies one number for the agent for each like item or resource. So again, we have the following
questions. How can we approximately decompose mechanisms via Ex ante Allocation Rule? And when
is an Ex ante Allocation Rule is feasible and how can we compute the optimal or approximately optimal
one? And how can we compute the optimal single agent mechanism subject to any given Ex ante
Allocation Rule. So first of all observe that if you have an interim allocation rule and we compute the
optimal single agent mechanism and if we then take the corresponding Ex ante Allocation Rule and
compute the optimal single agent mechanism corresponding to that, this is going to be larger in general
than this one because this space is less constrained, because here you are specifying an upper bound on
probability of each type, here you are just specifying an upper bound on overall probability. So this
suggests that by using the Ex ante Allocation Rule you might be able to get the optimal, because this is
like, you would expect to get something which is like, I mean, this could be in general in physical with
this single agent problem that you get from solving this. But there is a condition that it has to satisfy for
sure. So we can see that, for example, if we have a one unit of item the sum of the probabilities Ex ante
Allocation Rule probability should not add up to more than one. This is always. But this is not of course
sufficient condition. Take this example. Suppose there are N agents. Each agent has a high type and a
low type. The high type happens with probability one over N and requires an interim allocation
probability of one and the low type doesn't get anything, any allocation. And in this case you can
consider the Ex ante Allocation Rule for each agent is one over N so it satisfies this semi-feasibility
constraint, but of course it's not feasible because what if two agents with high type appear at the same
time; you cannot allocate to both of them with probability of one. But what you can do, what we can
show is that you can actually get a 1-1 over approximation of any Ex ante Allocation Rule [inaudible].
But by scaling down probabilities we can actually implement this in a physical [inaudible] in this type. So
I will talk about this more in a minute. And I claim that there is some kind of multi-agent agent
decomposition like before which works as follows. Basically there in this decomposition there are a
bunch of single agent mechanisms and each single agent mechanism allocates to subject to some semi
feasible Ex ante Allocation Rule. And then there is a central allocation mechanism which tries to resolve
the conflicts between the single agents because they could over allocate and, but it does it in a way that
will ensure that every allocation is preserved with some probability gamma, which I will define later. So
I will define this more precisely in the next slide, and I claim that gamma equal to 1-1 over E can always
be achieved. So this suggests that you can get a very good approximation like you can get a 1-1 over E
approximation by using Ex ante Allocation Rule. I will make it more formal in the next slide. But another
interesting thing that I will show you actually I will focus in on the second one a little more, is you can
actually do it in an online fashion. And you get one half approximation.
>>: [inaudible]?
>> Saeed Alaei: What's that?
>>: [inaudible] archive [inaudible]?
>> Saeed Alaei: Yeah, that is, yeah, it's not archived; it’s a typo. I will explain how this can be done by a
reduction to this magician’s problem which is something that I defined, and then I will explain in the
next few slides, but suppose that we could do that. Then I claim that an approximate optimal
mechanism can be obtained by using Ex ante Allocation Rule as follows. Let's capitalize on this by Ex
ante Allocation Rule semi-feasible Ex ante Allocation Rule's, so if you have a single item for sale this
would be simply that inequality that would be the sum of the Ex ante Allocation Rules shouldn't be more
than one or if you have K units of item shouldn't be more than K. Now let's say this is the expected
revenue of the optimal mechanism subject to some Ex ante Allocation Rule. Again, we show that this is
always concave for any maximization problem in any setting. And you can get an upper bound on your
optimal mechanism by solving this maximization problem. So this is not something that you can actually
achieve. This is simply an upper bound on what the optimal mechanism can do because this Ex ante
Allocation Rule's are semi-feasible. They may not, you may not be able to implement that feasibly. But I
claim that you can almost get that at least one half factor of the upper bound in expectation by a
reduction to the magician's problem. So this is the interesting part which is called the magician's
problem. So the magician's problem is the following. Suppose you have a magician and there is a
sequence of boxes that are arrive online and are presented to the magician. There is a prize hidden in
one of the boxes and the magician has K wands that he can use to open those boxes. If the magician
uses a wand on box i the box will open but the wand may break with the probability xi which is written
on the box. And we know that the sum of these probabilities add up to no more than K where K is the
number of wands of the magician. Now, and we assume that everything has been arranged by an
adversary so that the order of the boxes the probability is written on the boxes somewhere where the
prize is hidden. And we want to obtain a good solution for this problem, and observe that in order for
magician to be able to guarantee that he gets the prize with the probability of let's say gamma, he has to
ensure that every box in expectation is opened with a probability of at least gamma. Otherwise, the
adversary will just put the prize in the box that has the least [inaudible] probability of being opened.
And I assume that the adversary once that he has arranged everything, he cannot make any changes.
Once the boxes have started arriving, the adversary cannot make any changes anymore. And
furthermore, I assume that the magician has no prior information about anything, not even the number
of boxes. The only thing he knows his K. And I present a solution which is…
>>: What is [inaudible] each box has arrived [inaudible].
>> Saeed Alaei: Yes. When the box arrives you see the number which is written on box. You have to
make a decision about the box whether you want to open it or not. If you just keep that box, you
cannot go back to the box. You have to…
>>: I guess you shouldn't depend on how many ones you left [inaudible] open so far?
>> Saeed Alaei: Your decision is based on the pure past history and length, the number that you-actually I am sure that the decision only depends on your past history; it is not even. It doesn't even
depend on the number which is written on the current box. You can make a decision only based on your
past history.
>>: [inaudible] do know [inaudible].
>> Saeed Alaei: Yes, that is what we know. But he doesn't know how many boxes are going to be there.
He doesn't know N, like even when he sees the last box, he doesn't know if there's going to be another
one are not. Okay so, I present an algorithm which I call a gamma conservative magician which
guarantees that each box is opened with an Ex ante probability of at least gamma, and he tries to
minimize the number of broken wands. And I proved the following theorem. I show that for a gamma
equal to this number or anything less than this, it never needs more than K wands. And observe that
when K is equal to one, this is one half and when event K gets larger, this actually goes towards one
which means that if you have a large K you can actually get something which is pretty close to one. And
here is how we can use it to like solve, like this is just one example of how we can use the magician
problem to solve the auction, the composition using Ex ante Allocation Rule. Suppose you have K units
of one item and you have unit demand buyers and you want to sell them to maximize, in a way that
would maximize your revenue. You solve this convex maximization problem, which is subject to these
Ex ante Allocation Rule's being no more than K and this gives you an upper bound on your revenue. But
this is not of course obtainable. Now what you do is you do the following. You create a gamma
conservative magician with K wands and you set gamma equal to this thing. And for each of the buyers
you do the following. You write this Ex ante Allocation Rule on a box and present the box to the
magician. If the magician opens the box, then he will make the item available to that single agent
problem corresponding to that mechanism, corresponding to that agent, which means that mechanism
may either allocate the item or may not allocate depending on what the type of the agent is. By this Ex
ante Allocation Rule, I know that the mechanism will allocate the item with probability at most this X
half sub i. And if it allocates then I will go back and break the magician's wand. So you can see that the
probability that the magician’s wand gets broken is no more than this Ex ante Allocation Rule, and they
sum up to no more than K.
>>: So if the prize is in that box, the magician still gets the prize even if the wand breaks?
>> Saeed Alaei: Yes, the prize is actually irrelevant; it was just to make the, justify why the magician
wants to open every box with some probability gamma. The important thing is that the magician can
guarantee that each box in expectation is opened with Ex ante Allocation Rule with this gamma. And
because of this guarantee, he can actually get this fraction of every one of these single agent
mechanisms in expectation. So overall, you get this fraction of revenue. And this can be extended to
combinatorial auctions when you have more multiple units, I mean, under certain assumptions. I don't
want to get to the details of that. And the important thing about this is that this can be implemented
actually as an online mechanism. Here observe that the order in which the buyers are served is
irrelevant because I assume that you can serve them in any ordering. As long as you know what buyers
are going to arrive in the future, you can solve this convex problem and then you can basically whenever
they arrive you just do this thing. You write the Ex ante Allocation Rule on a box and present it to the
magician and you decide whether to sell to the corresponding buyer or not. So here is a quick…
>>: In the original problem you make the online thing doesn't matter so much, right?
>> Saeed Alaei: On the original problem there was nothing online, but I'm claiming that you can actually
use it to do online. Actually you can, I will, I wish I had time to talk about this, but you can solve the
online beta matching problem online, it's a classic beta matching, beta B matching problem and with this
technique and get this same approximation factor, but you would replace K with [inaudible] if you have
like single one matching, you would get one half approximation. That is tight actually. So here is a
sketch of how the magician works. So this is the easy part. The actual hard part is the analysis. So the
magician actually computes a sequence of thresholds, theta one up to theta and it completes this
threshold as he sees the boxes. And what that threshold, here is how the thresholds are used. Let's say
Si is a random variable denoting the number of wands broken prior to seeing box i. If Si is less than the
threshold, which means if we haven't broken too many wands, then I will open box i. If it is more than
the threshold, then it does not open the box, and if it is equal to the threshold it has been randomized
and with some probability open the box or at least it is exact probability comes from a dynamic
problem. And here is how the thresholds are computed. For each agent, for each box i I will compute
the theta i such that the probability of having broken less than or equal to theta i wands is at least
gamma, and I will choose the minimum theta i that has this property. Like this is something that you can
compute while using a dynamic program by just, by having the knowledge of the probabilities written on
the boxes one up to i -1 and by using the theta one up to theta -1. You can compute these probabilities
and then you can choose theta i such that this is exactly this. And then once you have that you basically
when you see the box i based on the threshold and the number of wands that have been broken so far,
you decide what to do with box i and it is actually independent on the probability which is written on
box i. That is a nice thing. So the dynamic paradigm is easy to like solve and it is also easy to see why it
works. The hard part is to show that when gamma is between zero and this number, actually it could,
yes, when gamma is at most this number, then this algorithm never uses more than K points, which
means these thresholds are never more than K. because if the threshold is never more than K, it means
that the magician never tries to open a box if he has already broken all of his K wands. And also it can
show that no magician can guarantee a probability of more than this for opening every box. And so you
can see that this is pretty close to that. So it is almost close to optimal. So to conclude, I presented a
general framework for constructing Bayesian mechanisms in a variety of settings as long as you can
solve the single agent problem, which is exponentially simpler to solve compared to the multi-agent
problem. You can get optimal multi-agent problem, and the nice things about this approach is you can
have mixed classes of buyers in your auction. In most of the previous works like you assume that like all
buyers in the option are just similar. They all have budget constraint or they all have additive valuations
or things like that. But suppose you have an option in which you have some agent that has budget
constraints and the other agent has risk parameter and so on. By using this reduction approach, you can
actually mix all of them in one auction as long as you can solve this single agent problem for each one
individually, you can have all of them at the same time. It works for a variety of settings with non-quasilinear utilities, arbitrary objectives and even with online arrival. And notice that in all of my, all of the
things that I explained, I never talked about the payments or the incentive constraints because all of
those go into the single agent problem. So as long as you can solve the single agent problem you are
fine. And some of these techniques as I mentioned, for example, for the online stochastic weighted
matching you can apply this magician problem to obtain a very good bound. So that was the end of my
talk. I would be happy to answer if you have any questions.
[applause].
>>: One thing you cover the relationship between two works. So the first you had to know that it
wasn't it into consideration ratio?
>> Saeed Alaei: Yes. The first one was optimal. The second one, you cannot get optimality but to be
honest the second one is the practical one, because the first one it relies on [inaudible] method so it's
purely theoretical. But the second one is actually pretty practical, because the magician problem just
requires you to solve a dynamic program and furthermore, the single agent parameters just specify the
Ex ante Allocation Rule is just one number for each agent. It doesn't depend on this type of space of the
agent. The type of space of an agent itself could be exponential, in which case you cannot use the first
operation. But still you can get a very good approximation. And it tells you that actually one thing, one
conceptual message of this is that when you extend this to combinational auctions and this condition of
like, what the condition that you get is the following. If you had an environment in which the maximum
demand of each agent compared to the total supply is less than one over K for some K, then you can get
these approximation of the optimal, which means if the demands of the agents are small compared to
the total supply, you can get a very good estimation of the optimal without going through all of the
problems of like solving optimization problems that were polymatroids. You just lose the various small
tiny fraction, but you get something which is practical.
>>: Isn't this this [inaudible] allocation resolution problem [inaudible] one count [inaudible].
>> Saeed Alaei: I'm not sure; I don't know about that.
>>: [inaudible] one thing you can do probability doesn't get you half but gets you…
>> Saeed Alaei: Sorry, you mean the first part or the second part?
>>: This problem. Like it said, it was an online but there's some people that would like to study online
setting because one thing that you could do is just say I going to toss a coin independently for everybody
and let's say see Xi by two, if I see Xi, I toss a point Xi by two.
>> Saeed Alaei: Yeah, you get a one four approximation, but here you get a one half.
>>: So one four but here one half, right? So what you want to do…
>> Saeed Alaei: So let me tell you one thing. If you, so, what I explained is something that is very close
to optimum. But what you can do is actually you can make a decision independently for each agent and
then like drop these boxes at random, and instead of this you would get something which looks like one
minus order of log K divided by the square root of K, or the square root of log K divided by a square root
of K, something like that. But that is, I mean that would be something which is a good in asymptotically
but for a small K it is not very optimal.
>>: I'm saying you could also [inaudible].
>> Saeed Alaei: Well, you can't actually, you can't even do it online. As they arrive, you toss a coin and
with some probability you just keep them or you drop it. But if you do it that way like this is an adaptive
approach which decides based on the previous history, but if, what you are saying is a non-adaptive
approach and you cannot get better than like I said one minus the square root of, divided by the square
root of K.
>>: [inaudible].
>> Saeed Alaei: Okay. Good question. So some of you [inaudible]. So first some of what I explained, it
settles the complexity of class of problems where you have polymatroid concerns, but what if you have
intersection of two polymatroids? Status, greedy importance, class, like if you had for example a bunch
of items and you have a bunch of unit demand buyers. Each one wants at most one of those items, that
is like intersection of two matroids. It is [inaudible] intersection of two polymatroids, so however, those
cases. Can we also compute the optimal mechanism for those in polynomial times, so that is one of the
open questions and yeah, I think that is like an important question that I still have in mind. Thank you.
[applause].