Mechanism design has been a very active research area that aims to develop algorithms that align the objectives of the designer (e.g., optimality of the solution) with the incentives of self-interested agents (e.g., maximize their own utility). One of the main obstacles to its application in real settings is the assumption of full rationality. Where theory predicts that people should not strategize, lab experiments in the field show that they do (to their own disadvantage): this is, for example, the case for the renown Vickrey’s second-price auction; proved to be truthful and yet bidders lie when submitting sealed bids. Interestingly, however, lies are less frequent when the very same mechanism is implemented via an ascending auction (Kagel et al., 1987).
A vague explanation of this phenomenon is that, from the point of view of a bidder, the truthfulness (a.k.a. strategyproofness) of an ascending price auction is easier to grasp than the truthfulness of the second-price sealed bid auction (Ausubel, 2004). The key difference here is on how these auctions are implemented:
In the second-price sealed-bid auction (direct-revelation implementation), each bidder submits her own bid once (either her true valuation or a different value). This mechanism is truthful meaning that truth-telling is a dominant strategy: for every report of the other bidders, the utility when truth-telling is not worse than the utility when bidding untruthfully.
In the ascending price auction (extensive-form implementation), each bidder is repeatedly offered some price which she can accept (stay in the auction) or reject (leave the auction). In this auction, momentarily accepting a good price guarantees a non-negative utility, while rejecting a good price or accepting a bad price yield non-positive utility. Here good price refers to the private valuation of the bidder and, intuitively, truth-telling in this auction means accepting prices as long as they are not above the true valuation.
Intuitively speaking, in the second type of auction, it is obvious for a bidder to decide her strategy, because the utility for the worst scenario when truth-telling is at least as good as that of the best scenario when cheating. The recent definition of obviously strategyproof (OSP) mechanisms (Li, 2017) formalizes this argument: ascending auctions are OSP mechanisms, while sealed-bid auctions are not. Interestingly, Li (2017) proves that a mechanism is OSP if and only if truth-telling is dominant even for bidders who lack contingent reasoning skills.
As being OSP is stronger than being strategyproof, it is natural to ask if this has an impact on what can be done by such mechanisms. For instance, the so-called deferred-acceptance (DA) mechanisms (Milgrom and Segal, 2014) are OSP (as they essentially are ascending price auctions), but unfortunately their performance (approximation guarantee) for several optimization problems is quite poor compared to what strategyproof mechanisms can do (Dütting et al., 2017). Whether this is an inherent limitation of OSP mechanisms or just of this technique is not clear.
One of the reasons behind this open question might be the absence of a general technique for designing OSP mechanisms and the lack of an algorithmic understanding of OSP mechanisms. Specifically, it is well known that strategyproofness is equivalent to certain monotonicity conditions of the algorithm used by the mechanism for computing the solution (being it an allocation of goods or a path in a network with self-interested agents). Therefore, one can essentially focus on the algorithmic part and study questions regarding the approximation and the complexity. The same type of questions seem much more challenging for OSP mechanisms, as such characterizations are not known. Recent work in the area (Bade and Gonczarowski, 2017; Pycia and Troyan, 2016; Mackenzie, 2017) aims at simplifying the notion of OSP, by looking at versions of the revelation principle for OSP mechanisms. This, for example, allows to think, without loss of generality, at deterministic (rather than randomized) extensive-form mechanisms where each agent moves sequentially (rather than concurrently). Nevertheless, this line of work does not seem to help much in thinking algorithmically.
An illustrative example (path auctions).
To better exemplify this conundrum, let us consider path auctions introduced by Nisan and Ronen (2001). In this problem, each edge corresponds to a link that is owned by a selfish agent, the cost for using link is some private nonnegative value which is known only to agent , and the goal is to pick a path of minimal total cost (shortest path) between two given nodes and . Since the standard VCG mechanism yields an (exact) strategyproof mechanism for this problem (Nisan and Ronen, 2001), one might consider the following natural question:
Can we compute the shortest path whilst guaranteeing OSP?
For a graph consisting of parallel links, we know from Li (2017) that the answer is yes via a simple descending auction to select the cheaper edge. Already for slightly more general graphs, the answer is unclear. Consider, for example, the graph in Figure 0(a). To make things even simpler let us restrict to a two-value domain , i.e., edges cost either or . In this setting, a simple OSP mechanism can be designed by querying the agents according to the implementation tree (i.e., a querying protocol where different actions are taken according to the answers received) in Figure 0(b). This algorithm is augmented with the following payments: for edges in the selected path, otherwise. It is not hard to see that, for every edge , it is not possible that is selected when she declares that her type is and it is not selected when she says . In particular, edge is always selected when she says , while the remaining edges are never selected when they declare . Then, if declares her true type, she receives a utility of if the true type is and is selected, and otherwise; by inspection, she would receive at most the same utility when cheating. It turns out that this argument is enough to prove that the mechanism is indeed OSP.
Does the same approach work, for example, on the slightly more general graph in Figure 0(c)? Consider an edge that is queried before the type of the remaining edges is known (that is, the first edge to be queried in a sequential mechanism, or an arbitrary edge in a direct revelation mechanism). Suppose that the type of this edge is . If she declares her type truthfully, then the worst that may occur is that the corresponding path is not selected (that occurs when this path costs and the alternative path costs ), and thus receives utility . If this edge, instead, cheats and declares , then it is possible that the corresponding path is selected (if it costs and the alternative path costs ) and receives utility . Thus, it is not obvious for an edge lacking contingent reasoning skills, to understand that revealing the type truthfully is dominant. This raises the following questions: Is there a different payment rule that enables to design an optimal OSP mechanism in the latter case? If not, how good an approximation can we compute?
The goal of this work is build the foundations to reason about OSP algorithmically and answer this kind of questions. In particular, we advance the state of the art by providing an algorithmic characterization of OSP mechanisms. Among others, our results show why deferred acceptance (DA) auctions (Milgrom and Segal, 2014) – essentially the only known technique to design OSP mechanisms – do not fully capture the power of a “generic” OSP mechanism, as the latter may exploit some aspects of the implementation (extensive-form game) in a crucial way.
1.1 Our contribution
To give an algorithmic characterization of OSP mechanisms, we extend the well known cycle-monotonicity (CMON) technique. This approach allows to abstract the truthfulness of an algorithm in terms of non-negative weight cycles on suitably defined graphs. We show that non-negative weight cycles continue to characterize OSP when the graph of interest is carefully defined. Our main conceptual contribution is here a way to accommodate the OSP constraints, which depend on the particular extensive-form implementation of the mechanism, in the machinery of CMON, which is designed to focus on the algorithmic output of mechanism. Interestingly, our technique shows the interplay between algorithms (which outcome/solution to return) and how this is implemented as an extensive-form game (the implementation tree). Roughly speaking, our characterization says which algorithms can be used for any choice of the implementation tree. The ability to choose between different implementation trees is what gives extra power to the designer: for example, the construction of OSP mechanisms based on DA auctions (Milgrom and Segal, 2014) uses always the same fixed tree for all problems and instances. Though this yields a simple algorithmic condition, it can be wasteful in terms of optimality (approximation guarantee) as we show herein. In fact, for our results, we will use CMON two ways to characterize both algorithmic properties (having fixed an implementation tree) and implementation properties (having fixed the approximation guarantee we want to achieve).
Armed with the OSP CMON technique, we are able to give tight bounds on the approximation ratio of OSP mechanisms for scheduling related machines (for identical jobs) and a characterization of optimal OSP mechanisms for set system problems (which include path auctions as a special case). We study mechanisms for two- and three-value domains, as we prove that these are the only cases in which non-negative two-cycles are necessary and sufficient.
We show that the optimum for machine scheduling can be implemented OSP-ly when the agents’ domains have size two. We prove that given a “balanced” optimum (i.e., a greedy allocation of jobs to machines) we can always find an implementation tree for which OSP is guaranteed. The mechanism directly asks the queried agents to reveal their type; given that the domain only contains two values, this is basically a descending/ascending auction. For domains of size three, instead, we give a lower bound of and an essentially tight upper bound of . Interestingly, the upper bound is proved with two different OSP mechanisms – one assuming more than number of jobs and the second under the hypothesis that there are less than that. On the technical level, these results are shown by using our approach of CMON two ways. We prove that any better than -approximate OSP mechanism must have the following structure: for a number of rounds, the mechanism must (i) separate, in its implementation tree, largest and second largest value in the domain; (ii) assign nothing to agents who have maximum value in the domain. The former property restricts the family of implementation trees we can use, whilst the latter restricts the algorithmic output. Our lower bound shows that there is nothing in this intersection. Our matching upper bounds need to find both implementation tree and algorithm satisfying OSP and approximation guarantee.
Main Theorem on Scheduling (informal). The tight approximation guarantee of OSP mechanisms is . The OSP mechanisms use a descending auction (to find the slowest machines) followed by an ascending auction (to find the fastest machine(s)).
While the general idea of the implementation is that of a descending auction followed by an ascending auction independently of the number of jobs, we need to tailor the design of the mechanisms (namely, their ascending phase) according to the number of jobs to achieve OSP and desired approximation simultaneously. This proves two important points. On one hand, the design of OSP mechanisms is challenging yet interesting as one needs to carefully balance algorithms and their implementation. On the other hand, it proves why fixing the implementation, as in DA auctions, might be the wrong choice. We in fact extend and adapt our analysis to prove that any ascending and descending (thus including DA) auction has an approximation of (cf. Appendix B.3).
For set systems, we study under what conditions it is possible to design optimal OSP mechanisms. We begin by considering a restricted version of set systems, shortest path on graphs comprised of two parallel paths, whose edges have two-value domains. We show how the topology (i.e., number of edges of either path) and values in the domains can change the OSP-implementability of optimal algorithms. Specifically, we show that our observation for shortest path on the graph in Figure 0(a) is not an accident as for all the graphs where a path is a direct edge, we can design an optimum OSP mechanism no matter what the alternative path looks like. Similarly, we prove that there are no optimal OSP mechanisms for the graph in Figure 0(c) and all the graphs where the two paths are composed of the same number (larger than one) of edges. As for the graphs where neither path is direct and each has a different number of edges, the existence of an OSP mechanism returning the shortest path depends on the values in the domains. Given the simple setting considered for shortest paths, the mechanisms that we design are not very complex and it actually turns out that any implementation tree would lead to optimal OSP mechanisms, when these are feasible. We then generalize the setting to any set system problem, wherein agents have three-value domains and fully characterize the properties needed to design OSP mechanisms.
Main Theorem on Set Systems (informal). There is an optimal OSP mechanism if and only if the set of feasible solutions are “aligned” for every agent’s subdomain. The optimal OSP mechanism, if any, combines ascending and descending auctions depending on the structure of the feasible solution set.
The intuition behind the characterization is simple. From OSP CMON, we know that if an OSP mechanism selects an agent when she has a “high” cost then it must select when she has a “low” cost (akin to monotonicity for strategyproofness). Therefore, to design an optimal OSP mechanism we need to define an implementation tree which satisfies this property. At each node of the tree, the domain of the agents is restricted to a particular subdomain of the agents’ domain, depending on the particular history. When is asked to separate a high cost from a low cost at node of the tree, we then need the feasible solutions to be “aligned” for the subdomain at , which roughly means that it should never be the case that there are two bid profiles in this subdomain for which belongs to an optimal solution when she has a high cost and is not part of an optimal solution when she has a low cost. The somehow surprising extra aspect is that even if the feasible solutions were not aligned for one subdomain then there would be no way to design an implementation tree to bypass this misalignment, since, roughly speaking, any implementation tree for an optimal algorithm must explore all subdomains to find an optimal solution. The technical definition of alignment has some nuisance to do with the particular ways in which the OSP monotonicity can be broken, but on the positive side, rather immediately suggests how to cleverly interleave ascending and descending phases to design an optimal OSP mechanism.
We remark that our mechanisms are, to the best of our knowledge, the first examples of OSP mechanisms with money that do not follow a clock or a posted price auction format (other mechanisms that do not follow these formats have been proposed only for setting without money, namely matching and voting (Li, 2017; Ashlagi and Gonczarowski, 2015; Bade and Gonczarowski, 2017; Pycia and Troyan, 2016)). One of the main messages of our work is exactly that it is possible to combine ascending and descending phases for the implementation trees of algorithms with good approximation guarantees and obtain OSP mechanisms.
1.2 Related work
The notion of OSP mechanism has been introduced recently by (Li, 2017) and has received a lot of attention in the community. As mentioned above, the class of deferred-acceptance (DA) auctions (Milgrom and Segal, 2014) yields OSP mechanisms since every DA auction can be implemented as a (suitable) ascending price auction. One of the main advantages of DA auctions is that the construction boils down to the problem of defining a suitable scoring function for the bidders (Milgrom and Segal, 2014). Dütting et al. (2017) studied the approximability of DA auctions for several optimization problems, and showed that in some cases DA auctions must have an approximation guarantee significantly worse than the best strategyproof mechanism; (Dütting et al., 2017; Kim, 2015) provide a number of positive results where DA auctions are instead optimal.
Several works have focused on understanding better the notion of OSP mechanism, and to apply it mainly to settings without money, namely matching and voting. In particular Ashlagi and Gonczarowski (2015); Bade and Gonczarowski (2017); Mackenzie (2017) mainly attempt to simplify the notion, whilst Pycia and Troyan (2016); Zhang and Levin (2017) define, among other results, stronger and weaker versions of OSP, respectively. A recent work related to ours is (Ferraioli and Ventre, 2017) where the authors consider OSP mechanisms with and without money for machine scheduling and facility location. Their lower bound for machine scheduling is constant and uses a particular definition of payments, while here we prove a lower bound that follows from the CMON characterization of OSP; their upper bounds instead use monitoring, a model wherein agents pay their reported costs whenever they overbid (instead of their actual cost).
Research in algorithmic mechanism design (Sandholm and Gilpin, 2003; Hartline and Roughgarden, 2009; Chawla et al., 2010) has suggested to focus on “simple” mechanisms to deal with bounded rationality. For example, posted-price mechanisms received huge attention very recently and have been applied to many different settings: from revenue maximization (Babaioff et al., 2014) to makespan minimization (Feldman et al., 2017), for buyers with correlated valuations (Adamczyk et al., 2015), or with complements (Eden et al., 2017b), or for streams of buyers (Correa et al., 2017). In these mechanisms one’s own bid is immaterial for the price paid to get some goods of interest – this should immediately suggest that trying to play the mechanism is worthless no matter the cognitive abilities of the agents. However, posted price mechanisms do not fully capture the concept of simple mechanisms: e.g., ascending price auctions are not posted price mechanisms and still turn out to be “simple”. An orthogonal approach is that of verifiably truthful mechanisms (Brânzei and Procaccia, 2015), wherein agents can run some algorithm to effectively check that the mechanism is incentive compatible. Nevertheless, these verification algorithms can run for long (i.e., time exponential in the input size) and are so far known only for quite limited scenarios. Importantly, moreover, they seem to transfer the question from the mechanism itself to the verification algorithm. Another line of work (Hartline and Roughgarden, 2009; Eden et al., 2017a) focused on extending to more complex settings the well-known result of Bulow and Klemperer (1996), that states that the revenue-maximizing single item auction, i.e., the Myerson auction, performs worse than the “simpler” social welfare maximizing auction, i.e., the Vickrey auction, with one extra bidder. However, simplicity in this research is vaguely stated, since the focus is more on the complexity of designing a mechanism, than on the complexity of understanding it.
Another paper relevant in the context of “simple” mechanisms is (Glazer and Rubinstein, 1996), which shares some of the motivation and philosophy behind OSP. Specifically, the authors notice that the implementation of a social choice function via a normal-form game is simpler/more obvious if there exists a “simple guide” that can always be used to discover the strategy combination which survives successive elimination of dominated strategies. They showed that backwards induction implementation via an extensive game is equivalent to such a “guided” implementation via a normal-form game.
CMON is a widely used technique in mechanism design that dates back to Rochet (1985) – a general treatment is given in (Malakhov and Vohra, 2004; Gui et al., 2004). This method has been used quite extensively to prove truthfulness of mechanisms in the classical setting, cf., e.g., (Bikhchandani et al., 2006; Lavi and Swamy, 2009) and when some form of verification can be adopted, see (Ventre, 2014; Krysta and Ventre, 2015). Particularly relevant for our work is the research which shows that in order to establish truthfulness it is sufficient to study cycles of length as in (Saks and Yu, 2005).
A mechanism design setting is defined by a set of selfish agents and a set of allowed outcomes . Each agent has a type , where is called the domain of . The type is usually assumed to be private knowledge of agent . We will let denote the cost (opposite of the valuation) of agent with type for the outcome . In our applications, we will assume that costs are non-negative; however, our OSP CMON framework and characterizations hold in general no matter the sign (and thus also for valuations).
A mechanism is a process for selecting an outcome . To this aim, the mechanism interacts with agents. Specifically, agent is observed to take actions (e.g., saying yes/no) that may depend on her presumed type (e.g., saying yes could “signal” that the presumed type has some properties that alone might enjoy). We say that agent takes actions compatible with (or according to) to stress this. We highlight that the presumed type can be different from the real type .
For a mechanism , we let denote the outcome returned by the mechanism when agents take actions according to their presumed types . In our context, this outcome is given by a pair , where (termed social choice function or, simply, algorithm) maps the actions taken by the agents according to to a feasible solution in , and maps the actions taken by the agents according to to payments from the mechanism to the agents.
Each selfish agent is equipped with a utility function . For and for an outcome returned by a mechanism , is the utility that agent has for outcome when her type is . We define utility as a quasi-linear combination of payments and costs, i.e.,
A mechanism is strategy-proof if for every , every and every , with being the true type of . That is, in a strategy-proof mechanism the actions taken according to the true type are dominant for each agent.
For our applications, we will be focusing on single-parameter settings, that is, the case in which the private information of each bidder is a single real number and can be expressed as for some publicly known function . To simplify the notation, we will write when we want to express the cost of a single-parameter agent of type for the output of social choice function
on input the actions corresponding to a bid vector.
We now formally define the concept of obviously strategy-proof mechanism.
This concept has been introduced in (Li, 2017).
However, our definition is built on the more accessible ones given by Ashlagi and Gonczarowski (2015) and Ferraioli and Ventre (2017). As shown in (Bade and Gonczarowski, 2017; Mackenzie, 2017), our definition is equivalent to Li’s.111In particular, we highlight that the absence of information sets and chance nodes – i.e., concurrent moves of the agents and randomized choices of the mechanism – is without loss of generality (Bade and Gonczarowski, 2017) . As for the latter, it is worth noting that this is because in Li’s definition, a randomized OSP mechanism turns out to be a probability distribution over deterministic OSP mechanisms; we refer the interested reader to
. As for the latter, it is worth noting that this is because in Li’s definition, a randomized OSP mechanism turns out to be a probability distribution over deterministic OSP mechanisms; we refer the interested reader to(Ferraioli and Ventre, 2018) for a notion of OSP in expectation.
Let us first formally model how a mechanism works. An extensive-form mechanism is defined by a directed tree , called the implementation tree, such that:
every leaf of the tree is labeled with a possible outcome of the mechanism;
every internal vertex is labeled by an agent ;
every edge is labeled by a subset of type profiles such that:
the subsets of profiles that label the edges outgoing from the same vertex are disjoint, i.e., for every triple of vertices such that and , we have that ;
the union of the subsets of profiles that label the edges outgoing from a non-root vertex is equal to the subset of profiles that label the edge going in , i.e., , where is the parent of in ;
the union of the subsets of profiles that label the edges outgoing from the root vertex is equal to the set of all profiles, i.e., ;
for every such that and for every two profiles such that , , if belongs to , then must belong to also.
Roughly speaking, the tree represents the steps of the execution of the mechanism. As long as the current visited vertex is not a leaf, the mechanism interacts with the agent . Different edges outgoing from vertex are used for modeling the different actions that agents can take during this interaction with the mechanism. In particular, each possible action is assigned to an edge outgoing from . As suggested above, the action that agent takes may depend on her presumed type . That is, different presumed types may correspond to taking different actions, and thus to different edges. The label on edge then lists the type profiles that enable the agent to take those actions that have been assigned to . In other words, when the agent takes the actions assigned to edge , then the mechanism (and the other agents) can infer that the type profile must be contained in . The constraints on the edges’ label can be then explained as follows: first we can safely assume that different actions must correspond to different type profiles (indeed, if two different actions are enabled by the same profiles we can consider them as a single action); second, we can safely assume that each action must correspond to at least one type profile that has not been excluded yet by actions taken before node was visited (otherwise, we could have excluded this type profile earlier); third, we have that the action taken by agent can only inform about her types and not about the type of the remaining agents. The execution ends when we reach a leaf of the tree. In this case, the mechanism returns the outcome that labels .
Observe that, according to the definition above, for every profile there is only one leaf such that belongs to . For this reason we say that . Moreover, for every type profile and every node , we say that is compatible with if . Finally, two profiles , are said to diverge at vertex if there are two vertices such that , and , whereas . For every node in a mechanism such that there are two profiles that diverge at , we say that is a divergent node, and the corresponding divergent agent. For each agent , we define the current domain at node , denoted , such that for the root and . In words, this is the set of types of that are compatible with the actions that took during the execution of the mechanism until node is reached. Indeed, according to the definition above, at each node in which diverges, partitions in subsets, where is the number of children of , and where for every child of , contains the types of bidder compatible with the action that she takes when interacting with the mechanism at node .
We are now ready to define obvious strategyproofness. An extensive-form mechanism is obviously strategy-proof (OSP) if for every agent with real type , for every vertex such that , for every (with not necessarily different from ), and for every , with , such that and are compatible with , but diverge at , it holds that . Roughly speaking, an obvious strategy-proof mechanism requires that, at each time step agent is asked to take a decision that depends on her type, the worst utility that she can get if at this time step she behaves according to her true type is at least the best utility achievable by behaving as she had a different type. Hence, if a mechanism is obviously strategy-proof, then it is also strategy-proof. Indeed, the latter requires that truthful behavior is a dominant strategy when agents know the entire type profile, whereas the former requires that it continues to be a dominant strategy even if agents have only a partial knowledge of profiles limited to what they observed in the mechanism up to the time they are called to take their choices.
We say that an extensive-form mechanism is trivial if for every vertex and for every two type profiles , it holds that and do not diverge at . That is, a mechanism is trivial if it never requires that agents take actions that depend on their type. If a mechanism is not trivial, then there is at least one divergent node. On the other hand, every execution of a mechanism (i.e., every path from the root to a leaf in the mechanism implementation tree) may go through at most divergent nodes, the upper bound being the case in which at each divergent node , the agent separates , in and for some .
Machine scheduling. Here, we are given a set of identical jobs to execute and the agents control related machines. That is, agent has a job-independent processing time per unit of job (equivalently, an execution speed that is independent from the actual jobs). The social choice function must choose a possible schedule of jobs to the machines, where denotes the job load assigned to machine when agents take actions according to . The cost that agent faces for the schedule is . We focus on social choice functions minimizing the makespan, i.e., We say that is -approximate if it returns a solution whose cost is a factor away from the optimum.
Set systems. In a set system we are given a set of elements and a family of feasible subsets of . Each element is controlled by a selfish agent, that is, the cost for using is known only to agent and is equal to some non-negative value . The social choice function must choose a feasible subset in ; we can use the same notation used above for machine scheduling with the restriction that to mean that the element controlled by agent is either chosen by , with , or not, with . Our objective is here social cost minimization, that is, Several problems on graphs, such as the path auction discussed above, can be cast in this framework.
3 Cycle-monotonicity for OSP mechanisms
We now show how to generalize the cycle-monotonicity technique to design OSP mechanisms.
Let us fix an extensive-form mechanism and the corresponding implementation tree . For every and , we let be a vertex in such that and and are compatible with , but diverge at , for some . Note that such a vertex might not be unique as player will be asked to separate from in different paths from the root to a leaf (but only once for every such path). We call these vertices of -separating for player .
The algorithmic characterization of OSP we provide herein is based on the following observation.
A mechanism that uses a payment function and an implementation tree is an OSP mechanism for the social choice function if and only if for all , for all , , for all vertices that are -separating for , and ,
Definition 2 (OSP-graph).
Let be a social choice function and be an implementation tree. For every , the OSP-graph has a node for each type profile in , and an edge for every , , and , where is an -separating vertex of . The weight of the edge is .
A mechanism with implementation tree is an OSP mechanism for a social function on finite domains if and only if, for all , the graph does not have negative weight cycles.
The proof of the theorem follow standard arguments used for the classical definition of strategyproofness (a full proof is given in appendix for completeness). We call the cycle monotonicity property of Theorem 3 OSP CMON; when this holds true for cycles of length 2 only then we talk about OSP two-cycle monotonicity. It is useful, for our applications, to recast the OSP two-cycle monotonicity between profiles and for a single-parameter agent as follows:
3.1 Warm-up I: using OSP CMON to bound approximation guarantee
In this section and in the next one, we show some preliminary results about machine scheduling and set systems. These results, despite (or, rather, because of) their simplicity, show how powerful a tool OSP CMON can be, when one wants to answer algorithmic questions, such as approximability, about OSP.
Indeed, we give here a simple lower bound for the machine scheduling problem.
For the machine scheduling problem, no OSP mechanism can be better than -approximate, even for two jobs and two agents with three-value domains , where , with and .
Assume by contradiction that there is an OSP mechanism that is better than -approximate, and let be its implementation tree. Since and , every trivial OSP mechanism must have approximation guarantee at least . Hence must be non trivial. Let be the first divergent agent of implemented with , and let be the node where this agent diverges (such an agent exists because the mechanism is not trivial).
If diverges at on and , then consider and . Since the mechanism is better than -approximate, it must satisfy and . Then, the cycle in has cost , thus a contradiction.
If diverges at on and , then consider and . Since the mechanism is better than -approximate, it must satisfy and . Then, the cycle in has cost , thus a contradiction. ∎
In Appendix B we give a complete characterization of the approximability for two jobs and two agents in the three-value domains, showing that in this specific case the above bound is tight. However, note that for this bound we require the domain to have at least three different values; we will in fact prove in Section 4 that we can design an optimal OSP mechanism for scheduling related machines when for every . We will also show how to use a more involved argument to prove a substantially higher (and tight) bound of .
3.2 Warm-up II: using OSP CMON to characterize OSP mechanisms
While the above example shows how OSP CMON can be used for giving approximation bounds, we now give an example that shows how OSP CMON helps to characterize under which conditions a given mechanism is OSP.
Consider the path auction problem discussed in the introduction; this is a special case of a set system problem where the set of feasible solutions is the set of all the paths between the source node and the destination node in a given graph . Consider the case in which has two parallel paths from the source to the destination; the first is comprised of a set of edges, that we will sometimes call top edges, whilst the second is comprised of a set of edges, that we will call bottom edges. W.l.o.g., we assume that .
There is an optimal OSP mechanism for the shortest path problem on parallel paths and two-value domains if and only if either (1) or (2) and .
Let us start by proving the sufficient condition; the mechanism shall return the bottom path in case of ties. The sufficiency is even stronger in that we will prove it no matter the implementation tree (thus including direct-revelation mechanisms). (Note that it will be enough to prove OSP -cycle monotonicity since, as prove below in Theorem 6, this is sufficient for two-value domains in this setting.)
Consider first the case . For a top edge , we have no matter , thus implying that OSP -cycle monotonicity is satisfied since For a bottom edge , instead, we can observe that for all and therefore the OSP -cycle monotonicity is satisfied again.
Let us now consider the case and . By contradiction, assume that the mechanism is not OSP for some agent . Consider the case that is a top edge (the proof is very similar for the case in which is a bottom edge). Since the mechanism is not OSP for , and we have two-value domains, Theorem 3 says that the OSP-graph for has a negative -cycle. Let and denote the subset of top and bottom agents that have been queried before in the implementation tree. Since the OSP-graph for has a negative -cycle, then for some and there exist and , and such that . Since ties are broken in favor of the bottom path, this means that thus implying , a contradiction.
We next prove the necessity and show that when either (1) or (2) and , no optimal mechanism can be OSP. Since is optimal, it is not trivial and at some point it must separate from for at least one agent. We consider the first divergent agent , and show a negative -cycle in the OSP-graph for this agent , thus implying that mechanism is not OSP (Theorem 3). Note that, since is the first divergent agent, in the implementation tree , there is a unique -separating node for agent ; moreover, for every . Assume that is a top edge (the proof is exactly the same for the case in which is a bottom edge). For the case in which , it is enough to consider comprised of at least one for the top edges and all for all the bottom edges, so that ; is, instead, a bid vector where all the top edges have value and at least two of the bottom edges have bid so that . Therefore, the -cycle between and is negative. When and , consider instead the vectors where , , and , , and , , and , . Since then , while as then . Therefore, the -cycle between and is negative also in this case. ∎
We shall extend this analysis to general set system problems, and we shall characterize exactly when optimal algorithms can be implemented in an OSP way.
3.3 Two-cycles are sufficient for single-parameter domains of size at most three
Two-cycle monotonicity is a property easier to work with than CMON. We will now show that, for single parameter settings, these properties turns out to be equivalent if and only if for each , with . (For the full proofs see Appendix A.2.)
Consider a single-parameter setting where for each agent . A mechanism with implementation tree and social choice function is OSP iff OSP two-cycle monotonicity holds.
One direction follows from Theorem 3. As for the other direction, we prove that OSP two-cycle monotonicity implies OSP CMON.
Fix agent , and consider a cycle in the graph . Observe that can be partitioned in paths such that for every , is as one of the following:
, where ;
, where , but and ;
, where , and , where either and for every or and for every ;
, where , , and, for every , , where and .
Since we are focusing on single-parameter settings, the cost of a path of type 2 is We can rewrite this as
where we used that and, by two-cycle monotonicity, (since ), and either or .
With similar arguments, we can prove that even for the other kinds of path. Hence, ∎
Theorem 6 is tight. Indeed, we next show that if there is at least one agent whose type domain contains at least four values, then OSP two-cycle monotonicity does not imply OSP cycle-monotonicity (and thus OSP-ness). Specifically, we have the following theorem.
There exists a mechanism with implementation tree such that is OSP two-cycle monotone for every , but there is an agent for which the mechanism does not satisfy OSP CMON, whenever there is at least one agent such that . The claim holds even for a single-item auction setting and for every .
4 Scheduling related machines
In this section, we show how the domain structure impacts on the performance guarantee of OSP mechanisms, for the problem of scheduling related machines. Roughly speaking, the problem is easy for two-value domains, while it becomes difficult already for three-value domains and two jobs.
4.1 Two-value domains are easy
OSP-CMON allows us to prove that an OSP optimal mechanism exists whenever each agent’s domain has size two. Specifically, we have the following theorem.
For the machine scheduling problem, there exists an optimal polynomial-time OSP mechanism for any number of agents with two-value domains .
The full proof of this theorem is given in Appendix B.2. Here we instead show a proof of the above theorem for the simpler setting in which domains are homogeneous, i.e., for every . This case turns out to be interesting, since we can here use an explicit, simple payment function which rewards each agent an amount , between and , for each unit of allocated work, i.e., for . We call such a mechanism a mechanism with proportional payments. The main intuition behind these payments is that agents with low cost have positive utility, while those with high cost have a negative utility. In particular, agents with low cost aim to maximize their assigned work, and agents with high cost aim to minimize it. The following definition and theorem formalize this intuition.
An algorithm is strongly monotone for a two-value domain if for all and for all .
A mechanism with the proportional payments is OSP with direct-revelation implementation for a two-value domain if and only if algorithm is strongly monotone for the corresponding two-value domain.
Since , with , and we have . Moreover, since , we have . As these two conditions hold for all and for all , we have shown that OSP holds. ∎
From this result we easily obtain an optimal OSP mechanisms for the scheduling problem.
For the machine scheduling problem, there exists an optimal polynomial-time OSP mechanism for any number of agents with two-value domains .
We show that there is an optimal allocation that is strongly monotone. Let denote some (suitably defined) optimal allocation for the case in which there are agents with cost and the remaining with cost , with these workloads in non-decreasing order (i.e., ). Note that is the allocation when all types are the same (all or all ). For a generic input with types being , we allocate jobs according to , following a fixed order of the agents among those with the same type: The -th agent among those of type gets and the -th agent of type gets . Note that is the minimum load assigned to a machine declaring type , while is the maximum load assigned to a machine that declare type . Let us define . Then, if the following key inequalities hold for all ,
then the allocation is strongly monotone. Indeed, , where is the number of machines of type in ; similarly, , where is the number of machines of type in ; finally, (2) implies .
To conclude the proof, we show how to guarantee (2). First, in the optimal allocation , the load between machines of the same type differ by at most . Then, every other optimal allocation can be obtained starting from by repeatedly reallocating one job in the most loaded machine of type to the least loaded machine of type . Every step increases the least loaded machine of type and decreases the most loaded machine of type , and thus (2) holds at every intermediate step until we obtain . ∎
4.2 Three-value domains are hard
In this section, we show that the problem becomes hard as soon as we have three-value domains. Our contributions are a lower bound of on the approximation of any OSP mechanism, and a matching upper bound.
Lower bound. The -inapproximability result in Proposition 4 for three-value domains can be strengthen to -inapproximability by considering a larger number of machines and jobs.
For the machine scheduling problem, no OSP mechanism can be better than -approximate. This also holds for three-value domains .
In order to prove this lower bound, we consider , for some , and a three-value domain such that and
First observe that, in such domains, every trivial mechanism must have an approximation ratio not lower than . Consider then a non-trivial mechanism and let be its implementation tree. Let us rename the agents as follows: Agent is the st agent in that diverges in ; since the mechanism is not trivial agent exists. We now call agent , the nd agent that diverges in the subtree of defined by agent taking an action compatible with type ; if no agent diverges in this subtree of we simply call a random agent different from . More generally, agent is the th agent that diverges, if any, in the subtree of that corresponds to the case that the actions taken by agents that previously diverged are compatible with their type being . As above, if no agent diverges in the subtree of interest, we just let denote a random agent different from . We denote with the node in which diverges in the subtree in which all the other agents have taken actions compatible with ; if does not diverge (i.e., got her id randomly) we denote with a dummy node in which we will say that does not diverge and takes an action compatible with every type in . We then have the following lemma.
Any OSP mechanism which is -approximate, with , must satisfy the following conditions:
For every , if agent diverges at node , it must diverge on and .
For every , if agent at node takes an action compatible with her type being , then does not assign any job to , regardless of the actions taken by the other agents.
Let us first prove part (1). Suppose that there is such that at node diverges on and . Consider the type profile such that , and for every . Observe that is compatible with node . The optimal allocation for the type profile assigns all jobs to machine , with cost . Since is -approximate, then it also assigns all jobs to machine . Indeed, if a job is assigned to a machine , then the cost of the mechanism would be at least , that contradicts the approximation bound.
Consider now the profile such that , for every , and for every . Observe that also is compatible with node . It is not hard to see that . Since is -approximate, then it cannot assign all jobs to machine . Indeed, in this case the cost of the mechanism contradicts the approximation bound, since it would be where we used that .
Hence, we have that if takes actions compatible with , then there exists a type profile compatible with such that receives jobs, whereas, if takes a different action compatible with a lower type, then there exists a type profile compatible with such that receives less than jobs. However, this contradicts the OSP CMON property.
Let us now prove part (2). Suppose that there is and compatible with such that if takes an action compatible with type , then assigns at least a job to . According to part (1), machine diverges at node on and .
Consider then the profile such that , for , and for . It is easy to see that the optimal allocation has cost . Since is -approximate, then it does not assign any job to machine . Otherwise, the mechanism contradicts the approximation bound since his cost would be at least where we used that .
Hence, we have that if takes actions compatible with , then there exists a type profile compatible with such that receives one job, whereas, if takes a different action compatible with a lower type, then there exists a type profile compatible with such that receives zero jobs. However, this contradicts the OSP CMON property. ∎
We are now ready to prove our lower bound.
Proof of Theorem 12.
Suppose that there is an OSP -approximate mechanism for some . Consider such that for every . Observe that is compatible with for every . The optimal allocation consists in assigning a job to each machine, and has cost