{'fraction_non_alphanumeric': 0.04739515950900887, 'fraction_numerical': 0.006605450548525869, 'mean_word_length': 3.8626227495908347, 'pattern_counts': {'":': 0, '<': 45, '<?xml version=': 0, '>': 40, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 39, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On the approximation guarantee of obviously strategyproof mechanisms

Catering to the incentives of people with limited rationality is a challenging research direction that requires novel paradigms to design mechanisms and approximation algorithms. Obviously strategyproof (OSP) mechanisms have recently emerged as the concept of interest to this research agenda. However, the majority of the literature in the area has either highlighted the shortcomings of OSP or focused on the"right"definition rather than on the construction of these mechanisms. We here give the first set of tight results on the approximation guarantee of OSP mechanisms for scheduling related machines and a characterization of optimal OSP mechanisms for set system problems. By extending the well-known cycle monotonicity technique, we are able to concentrate on the algorithmic component of OSP mechanisms and provide some novel paradigms for their design.


Introduction
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 i is some private nonnegative value t i which is known only to agent i, and the goal is to pick a path of minimal total cost (shortest path) between two given nodes s and t. 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 1a. To make things even simpler let us restrict to a two-value domain {L, H}, i.e., edges cost either L or H > L. 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 1b. This algorithm is augmented with the following payments: H for edges in the selected path, 0 otherwise. It is not hard to see that, for every edge e, it is not possible that e is selected when she declares that her type is H and it is not selected when she says L. In particular, edge (s, t) is always selected when she says L, while the remaining edges are never selected when they declare H. Then, if e declares her true type, she receives a utility of H − L if the true type is L and e is selected, and 0 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 1c? Consider an edge e 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 L. 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 H + L and the alternative path costs 2L), and thus e receives utility 0. If this edge, instead, cheats and declares H, then it is possible that the corresponding path is selected (if it costs H + L and the alternative path costs 2H) and e receives utility H − L. Thus, it is not obvious for an edge e 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.

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 nonnegative 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 √ n and an essentially tight upper bound of ⌈ √ n⌉. Interestingly, the upper bound is proved with two different OSP mechanisms -one assuming more than ⌈ √ n⌉ 2 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 √ n-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 √ n. The OSP mechanisms use a descending auction (to find the ⌈ √ n⌉ 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 n (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 1a 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 1c 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 e when she has a "high" cost then it must select e 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 e is asked to separate a high cost from a low cost at node u of the tree, we then need the feasible solutions to be "aligned" for the subdomain at u, which roughly means that it should never be the case that there are two bid profiles in this subdomain for which e 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.

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 √ n 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 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 andVohra, 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 andSwamy, 2009] and when some form of verification can be adopted, see [Ventre, 2014, Krysta andVentre, 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 2 as in [Saks and Yu, 2005].

Preliminaries
A mechanism design setting is defined by a set of n selfish agents and a set of allowed outcomes S. Each agent i has a type t i ∈ D i , where D i is called the domain of i. The type t i is usually assumed to be private knowledge of agent i. We will let t i (X) ∈ R denote the cost (opposite of the valuation) of agent i with type t i for the outcome X ∈ S. 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 X ∈ S. To this aim, the mechanism interacts with agents. Specifically, agent i is observed to take actions (e.g., saying yes/no) that may depend on her presumed type b i ∈ D i (e.g., saying yes could "signal" that the presumed type has some properties that b i alone might enjoy). We say that agent i takes actions compatible with (or according to) b i to stress this. We highlight that the presumed type b i can be different from the real type t i .
For a mechanism M, we let M(b) denote the outcome returned by the mechanism when agents take actions according to their presumed types b = (b 1 , . . . , b n ). In our context, this outcome is given by a pair (f, p), where f = f (b) (termed social choice function or, simply, algorithm) maps the actions taken by the agents according to b to a feasible solution in S, and p = p(b) = (p 1 (b), . . . , p n (b)) ∈ R n maps the actions taken by the agents according to b to payments from the mechanism to the agents.
Each selfish agent i is equipped with a utility function u i : D i × S → R. For t i ∈ D i and for an outcome X = (f, p) ∈ S returned by a mechanism M, u i (t i , X) is the utility that agent i has for outcome X when her type is t i . We define utility as a quasi-linear combination of payments and costs, i.e., . . , b n ) and every b i ∈ D i , with t i being the true type of i. 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 i is a single real number t i and t i (X) can be expressed as t i w i (X) for some publicly known function w i . To simplify the notation, we will write t i f i (b) when we want to express the cost of a single-parameter agent i of type t i for the output of social choice function f on input the actions corresponding to a bid vector b.
Obvious Strategyproofness. 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 andGonczarowski, 2017, Mackenzie, 2017], our definition is equivalent to Li's. 1 Let us first formally model how a mechanism works. An extensive-form mechanism M is defined by a directed tree T = (V, E), called the implementation tree, such that: • every leaf ℓ of the tree is labeled with a possible outcome X(ℓ) ∈ S of the mechanism; • every internal vertex u ∈ V is labeled by an agent S(u) ∈ [n]; • every edge e = (u, v) ∈ E is labeled by a subset T (e) ⊆ D = × i D i of type profiles such that: the subsets of profiles that label the edges outgoing from the same vertex u are disjoint, i.e., for every triple of vertices u, v, v ′ such that (u, v) ∈ E and (u, v ′ ) ∈ E, we have that T (u, v) ∩ T (u, v ′ ) = ∅; -the union of the subsets of profiles that label the edges outgoing from a non-root vertex u is equal to the subset of profiles that label the edge going in u, i.e., v : is the parent of u in T ; -the union of the subsets of profiles that label the edges outgoing from the root vertex r is equal to the set of all profiles, i.e., v : (r,v)∈E T (r, v) = D; -for every u, v such that (u, v) ∈ E and for every two Roughly speaking, the tree represents the steps of the execution of the mechanism. As long as the current visited vertex u is not a leaf, the mechanism interacts with the agent S(u). Different edges outgoing from vertex u 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 u. As suggested above, the action that agent i takes may depend on her presumed type b i ∈ D i . That is, different presumed types may correspond to taking different actions, and thus to different edges. The label T (e) on edge e = (u, v) then lists the type profiles that enable the agent S(u) to take those actions that have been assigned to e. In other words, when the agent takes the actions assigned to edge e, then the mechanism (and the other agents) can infer that the type profile must be contained in T (e). 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 u was visited (otherwise, we could have excluded this type profile earlier); third, we have that the action taken by agent S(u) 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 b there is only one leaf ℓ = ℓ(b) such that b belongs to T (φ(ℓ), ℓ). For this reason we say that M(b) = X(ℓ). Moreover, for every type profile b and every node u ∈ V , we say that b is compatible with u if b ∈ T (φ(u), u). Finally, two profiles b, b ′ are said to diverge at vertex u if there are two vertices v, v ′ such that (u, v) ∈ E, (u, v ′ ) ∈ E and b ∈ T (u, v), whereas b ′ ∈ T (u, v ′ ). For every node u in a mechanism M such that there are two profiles b, b ′ that diverge at u, we say that u is a divergent node, and i = S(u) the corresponding divergent agent. For each agent i, we define the current domain at node u, denoted D i (u), such that D i (r) = D i for the root r and D i (u) = ∪ b∈T (φ(u),u) b i . In words, this is the set of types of i that are compatible with the actions that i took during the execution of the mechanism until node u is reached. Indeed, according to the definition above, at each node u in which i diverges, M partitions D i (u) in k subsets, where k is the number of children of u, and where for every child v of u, D i (v) ⊂ D i (u) contains the types of bidder i compatible with the action that she takes when interacting with the mechanism at node u.
We are now ready to define obvious strategyproofness. An extensive-form mechanism M is obviously strategy-proof (OSP) if for every agent i with real type t i , for every vertex u such that i = S(u), for every . Roughly speaking, an obvious strategy-proof mechanism requires that, at each time step agent i 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 u ∈ V and for every two type profiles b, b ′ , it holds that b and b ′ do not diverge at u. 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 i (|D i | − 1) divergent nodes, the upper bound being the case in which at each divergent node u, the agent Machine scheduling. Here, we are given a set of m identical jobs to execute and the n agents control related machines. That is, agent i has a job-independent processing time t i per unit of job (equivalently, an execution speed 1/t i that is independent from the actual jobs). The social choice function f must choose a possible schedule f (b) = (f 1 (b), . . . , f n (b)) of jobs to the machines, where f i (b) denotes the job load assigned to machine i when agents take actions according to b. The cost that agent i faces for the We say that f is α-approximate if it returns a solution whose cost is a factor α away from the optimum. Set systems. In a set system (E, F ) we are given a set E of elements and a family F ⊆ 2 E of feasible subsets of E. Each element i ∈ E is controlled by a selfish agent, that is, the cost for using i is known only to agent i and is equal to some non-negative value t i . The social choice function f must choose a feasible subset in F ; we can use the same notation used above for machine scheduling with the restriction that . Several problems on graphs, such as the path auction discussed above, can be cast in this framework.

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 M and the corresponding implementation tree T . For every i and a, b . Note that such a vertex might not be unique as player i will be asked to separate a from b in different paths from the root to a leaf (but only once for every such path). We call these vertices of T ab-separating for player i.
The algorithmic characterization of OSP we provide herein is based on the following observation.
Observation 1. A mechanism that uses a payment function p and an implementation tree T is an OSP mechanism for the social choice function f if and only if for all i, for all a, b ∈ D i , a = b, for all vertices u i a,b that are ab-separating for i, and (1) Definition 2 (OSP-graph). Let f be a social choice function and T be an implementation tree. For every i, the OSP-graph O T i has a node for each type profile in D, and an edge . Theorem 3. A mechanism with implementation tree T is an OSP mechanism for a social function f on finite domains if and only if, for all i, the graph O T i 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 a and b for a single-parameter agent i as follows:

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.
Proposition 4. For the machine scheduling problem, no OSP mechanism can be better than 2-approximate, even for two jobs and two agents with three-value domains Proof. Assume by contradiction that there is an OSP mechanism M that is better than 2-approximate, and let T be its implementation tree. Since M > 2L and H > 2M , every trivial OSP mechanism must have approximation guarantee at least 2. Hence M must be non trivial. Let i be the first divergent agent of M implemented with T , and let u be the node where this agent diverges (such an agent exists because the mechanism is not trivial).
If i diverges at u on M and H, then consider Since the mechanism is better than 2-approximate, it must satisfy f i (x) = 1 and f i (y) = 0. Then, the cycle 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 D i = {L i , H i } for every i. We will also show how to use a more involved argument to prove a substantially higher (and tight) bound of √ n.

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 s and the destination node t in a given graph G. Consider the case in which G has two parallel paths from the source to the destination; the first is comprised of a set T of t edges, that we will sometimes call top edges, whilst the second is comprised of a set B of b edges, that we will call bottom edges. W.l.o.g., we assume that t ≥ b.
Proposition 5. There is an optimal OSP mechanism for the shortest path problem on parallel paths and two-value domains D = {L, H} n if and only if either (1) Proof. 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 2-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 bottom edge e, instead, we can observe that f e (L, b −e ) = 1 for all b −e and therefore the OSP 2-cycle monotonicity is satisfied again.
Let us now consider the case t > b > 1 and H L ≤ t−1 b−1 . By contradiction, assume that the mechanism is not OSP for some agent e. Consider the case that e is a top edge (the proof is very similar for the case in which e is a bottom edge). Since the mechanism is not OSP for e, and we have two-value domains, Theorem 3 says that the OSP-graph for e has a negative 2-cycle. Let τ and β denote the subset of top and bottom agents that have been queried before e in the implementation tree. Since the OSP-graph for e has a negative 2-cycle, then for some Since ties are broken in favor of the bottom path, this means that We next prove the necessity and show that when either (1) t = b > 1 or (2) t > b > 1 and H L > t−1 b−1 , no optimal mechanism M can be OSP. Since M is optimal, it is not trivial and at some point it must separate L from H for at least one agent. We consider the first divergent agent e, and show a negative 2-cycle in the OSP-graph for this agent e, thus implying that mechanism M is not OSP (Theorem 3). Note that, since e is the first divergent agent, in the implementation tree T , there is a unique LH-separating node u for agent Assume that e is a top edge (the proof is exactly the same for the case in which e is a bottom edge).
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.

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 Theorem 6. Consider a single-parameter setting where |D i | ≤ 3 for each agent i. A mechanism with implementation tree T and social choice function f is OSP iff OSP two-cycle monotonicity holds.
Proof Sketch. One direction follows from Theorem 3. As for the other direction, we prove that OSP two-cycle monotonicity implies OSP CMON.
Fix agent i, and consider a cycle C = (x, x ′ , x ′′ , . . . , x) in the graph O T i . Observe that C can be partitioned in paths (P 1 , . . . , P t ) such that for every j = 1, . . . , t, P j is as one of the following: Since we are focusing on single-parameter settings, the cost of a path of type 2 is C( . We can rewrite this as With similar arguments, we can prove that 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.
Theorem 7. There exists a mechanism with implementation tree T such that O T i is OSP two-cycle monotone for every i, but there is an agent for which the mechanism does not satisfy OSP CMON, whenever there is at least one agent i such that |D i | ≥ 4. The claim holds even for a single-item auction setting and D j = D for every j = i.

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.

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.
Theorem 8. 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., D i = {H, L} for every i. This case turns out to be interesting, since we can here use an explicit, simple payment function P which rewards each agent an amount p, between L and H, for each unit of allocated work, i.e., p i (b) = p · f i (b) for L < p < H. 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.
Theorem 10. A mechanism M = (f, p) with the proportional payments is OSP with direct-revelation implementation for a two-value domain if and only if algorithm f is strongly monotone for the corresponding two-value domain. Proof.
As these two conditions hold for all i and for all From this result we easily obtain an optimal OSP mechanisms for the scheduling problem.
Proposition 11. For the machine scheduling problem, there exists an optimal polynomial-time OSP mechanism for any number of agents with two-value domains D i = {L, H}.
Proof. We show that there is an optimal allocation that is strongly monotone. Let w (ℓ) = (w ℓ 1 , w ℓ 2 , . . . , w ℓ n ) denote some (suitably defined) optimal allocation for the case in which there are ℓ agents with cost L and the remaining n − ℓ with cost H, with these workloads in non-decreasing order (i.e., w Note that w (n) = w (0) is the allocation when all types are the same (all L or all H). For a generic input b with ℓ types being L, we allocate jobs according to w (ℓ) , following a fixed order of the agents among those with the same type: The k-th agent among those of type L gets w (ℓ) k and the j-th agent of type H gets w ℓ is the minimum load assigned to a machine declaring type L, while w (ℓ) ℓ+1 is the maximum load assigned to a machine that declare type H. Let us define w (n) n+1 = 0. Then, if the following key inequalities hold for all ℓ, then the allocation is strongly monotone. Indeed, To conclude the proof, we show how to guarantee (2). First, in the optimal allocation w (n) , the load between machines of the same type differ by at most 1. Then, every other optimal allocation w (ℓ) can be obtained starting from w (n) by repeatedly reallocating one job in the most loaded machine of type H to the least loaded machine of type L. Every step increases the least loaded machine of type L and decreases the most loaded machine of type H, and thus (2) holds at every intermediate step until we obtain w (ℓ) .

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 √ n on the approximation of any OSP mechanism, and a matching upper bound. Lower bound. The 2-inapproximability result in Proposition 4 for three-value domains can be strengthen to √ n-inapproximability by considering a larger number of machines and jobs.
Theorem 12. For the machine scheduling problem, no OSP mechanism can be better than √ n-approximate. This also holds for three-value domains D i = {L, M, H}.
In order to prove this lower bound, we consider m = n = c 2 , for some c > 1, and a three-value domain D i = {L, M, H} such that M ≥ m · L and H ≥ m √ n · M. First observe that, in such domains, every trivial mechanism must have an approximation ratio not lower than √ n. Consider then a non-trivial mechanism M and let T be its implementation tree. Let us rename the agents as follows: Agent 1 is the 1st agent in that diverges in T ; since the mechanism is not trivial agent 1 exists. We now call agent 2, the 2nd agent that diverges in the subtree of T defined by agent 1 taking an action compatible with type H; if no agent diverges in this subtree of T we simply call 2 a random agent different from 1. More generally, agent i is the ith agent that diverges, if any, in the subtree of T that corresponds to the case that the actions taken by agents that previously diverged are compatible with their type being H. As above, if no agent diverges in the subtree of interest, we just let i denote a random agent different from 1, 2, . . . , i − 1. We denote with u i the node in which i diverges in the subtree in which all the other agents have taken actions compatible with H; if i does not diverge (i.e., got her id randomly) we denote with u i a dummy node in which we will say that i does not diverge and i takes an action compatible with every type in D i . We then have the following lemma.
Lemma 13. Any OSP mechanism M which is k-approximate, with k < √ n, must satisfy the following conditions: 1. For every i ≤ n − √ n + 1, if agent i diverges at node u i , it must diverge on M and H.
2. For every i ≤ n − √ n, if agent i at node u i takes an action compatible with her type being H, then M does not assign any job to i, regardless of the actions taken by the other agents.
Proof. Let us first prove part (1). Suppose that there is i ≤ n − √ n + 1 such that at node u i i diverges on L and {M, H}. Consider the type profile x such that x i = M , and x j = H for every j = i. Observe that x is compatible with node u i . The optimal allocation for the type profile x assigns all jobs to machine i, with cost OP T (x) = mM . Since M is k-approximate, then it also assigns all jobs to machine i. Indeed, if a job is assigned to a machine j = i, then the cost of the mechanism would be at least H ≥ √ n · mM > k · OP T (x), that contradicts the approximation bound.
Consider now the profile y such that y i = L, y j = H for every j < i, and y j = L for every j > i. Observe that also y is compatible with node u i . It is not hard to see that OP T (y) ≤ m n−i+1 · L. Since M is k-approximate, then it cannot assign all jobs to machine i. Indeed, in this case the cost of the mechanism contradicts the approximation bound, since it would be mL Hence, we have that if i takes actions compatible with M , then there exists a type profile compatible with u i such that i receives n jobs, whereas, if i takes a different action compatible with a lower type, then there exists a type profile compatible with u i such that i receives less than n jobs. However, this contradicts the OSP CMON property.
Let us now prove part (2). Suppose that there is i ≤ n − √ n and x −i compatible with u i such that if i takes an action compatible with type H, then M assigns at least a job to i. According to part (1), machine i diverges at node u i on H and M .
Consider then the profile y such that y i = M , y j = H for j < i, and y j = L for j > i. It is easy to see that the optimal allocation has cost OP T (y) = m n−i · L. Since M is k-approximate, then it does not assign any job to machine i. Otherwise, the mechanism contradicts the approximation bound since his cost would be at least M ≥ mL ≥ √ n m n−i L > k · OP T (x), where we used that √ n m n−i ≤ √ n m √ n = √ n n √ n = √ n · √ n = n = m. Hence, we have that if i takes actions compatible with H, then there exists a type profile compatible with u i such that i receives one job, whereas, if i takes a different action compatible with a lower type, then there exists a type profile compatible with u i such that i 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 k-approximate mechanism M for some k < √ n. Consider x such that x i = H for every i. Observe that x is compatible with u i for every i. The optimal allocation consists in assigning a job to each machine, and has cost OP T (x) = H.
According to Part (2) of Lemma 13, if machines take actions compatible with x, then the mechanism M does not assign any job to machine i, for every i ≤ n − √ n. Hence, the best outcome that M can return for x consists in assigning √ n jobs to each of the other √ n machines. Therefore, the cost of M is at least √ nH > kOP T (x), which contradicts the approximation ratio of M.
The arguments above can be used to prove that ascending and descending auctions do not help in this setting. Specifically, they cannot return an approximation better than n (see Appendix B. 3). Upper bound. We describe our mechanisms for a generic, not necessarily three-value, domain, as this turns out to be useful in the analysis. In what follows, the usual bold notation x denotes vectors of n entries, while a "hat-bold" notationx denotes vectors of ⌈ √ n⌉ entries only. A mechanism for many jobs (large m). We now introduce mechanism M many whose approximation ratio approaches ⌈ √ n⌉, whenever m ≫ ⌈ √ n⌉. The mechanism consists of a Descending Phase (Algorithm 1) followed by an Ascending Phase (Algorithm 2). Consider the profileẑ such thatẑ i = p andẑ j = min k / ∈A t k for every j ∈ A, j = i 7 Let f ⋆ (ẑ) = (f ⋆ i (ẑ)) i∈A be the optimal assignment of jobs on input type profileẑ Set A = ∅ 10 else set s i = min{d ∈ D i : d > p} Algorithm 2: Ascending Phase (for mechanism M many ).

Proposition 14. Mechanism M many is OSP for any three-value domain
Proof. We prove that M many satisfies the OSP two-cycle monotonicity. The claim then follows from Theorem 6. Specifically, for each machine i, for each node u in which the mechanism makes a query to i, for each pair of type profiles x, y compatible with u such that i diverges at u between x i and y i , we need to prove that if x i > y i , then f i (M many (x)) ≤ f i (M many (y)). Let us first consider a node u corresponding to the descending phase of the mechanism. In this case, x i = p, where p is as at node u. Moreover, in all profiles compatible with u there are at least ⌈ √ n⌉ machines that either have a type lower than p, or they have type p but are queried after i. However, for every x −i satisfying this property, we have that f i (M many (x)) = 0, which implies that these two-cycles are non-negative.
Suppose now that node u corresponds to the ascending phase of the mechanism. In this case, y i = p, where p is as at node u. Observe that for every y −i compatible with node u, f i (M many (y) ) is the number of jobs assigned to machine i by the optimal outcome on input profile (y i ,ẑ) −i ,ẑ −i being such thatẑ j = max k∈A t k for every j ∈ A \ {i}. Observe that for every x compatible with u, it must be the case that x j ≥ y i for every j ∈ A. Hence, we can distinguish two cases: if min j x j = x i , then , where we used thatẑ −k =ẑ −i and the inequalities follow since: (i) in the optimal outcome the fastest machine must receive at least as many jobs as slower machines; (ii) the optimal outcome is monotone, (i.e., given the speeds of other machines, the number of jobs assigned to machine i decreases as its speeds decreases).
Proof Sketch. We show that the mechanism returns an allocation which is m+⌈ √ n⌉−1 m · ⌈ √ n⌉ -approximate. We denote with OP T (x) the makespan of the optimal assignment when machines types are as in the input profile x. We will use the same notation both if the optimal assignment is computed on a set of n machines and if it is computed and on a set of ⌈ √ n⌉ machines, since these two cases can be distinguished through the input profile.
Fix a type profile x. Let OP T (x) be the makespan of the optimal assignment on type profile x. Let A be as at the beginning of the ascending phase. Let w be the last query done in this phase and let i be the last agent queried, i.e., the one that answered yes. Moreover, let t = min j / ∈A t j . It is immediate to see that OP T (x) ≥ OP T (y) where y is such that y j = w for every j ∈ A, and y j = t, otherwise. Moreover, let M(x) be the makespan of the assignment returned by our mechanism on the same input. Then, M(x) is equivalent to OP T (ẑ), whereẑ is such thatẑ i = w andẑ j = t for each remaining machine j. Hence, the theorem follows by proving that OP T (ẑ) (The full proof is given in appendix.) The next corollary follows by simple algebraic manipulations.
A mechanism for few jobs (small m). We now introduce a mechanism M f ew which is OSP and ⌈ √ n⌉approximate whenever m ≤ ⌈ √ n⌉ 2 . Like M many , also M f ew consists of a descending phase followed by an ascending phase. The descending phase is exactly the same (Algorithm 1) with the difference that the ascending phase (Algorithm 3) does not need the information on the type of the machines that are not in A at that point. Let z be the largest integer in [ζ, C] such that z · q ≤ ⌈ √ n⌉ · p 8 Assign z jobs to i and set C = C − z 9 Remove i from A 10 else set t i = min{d ∈ D i : d > p} Algorithm 3: Ascending Phase (for mechanism M f ew ).
We first show that mechanism M f ew is well defined under our assumption on the number of jobs.
Lemma 17. If m ≤ ⌈ √ n⌉ 2 then there exists a z in line 7 of Algorithm 3.
Proof. We next show that it never occurs during the ascending phase that ζ · q > ⌈ √ n⌉ · p. Indeed, for the first machine to reveal the type during the ascending phase, we have that |P 0 | = m ≤ ⌈ √ n⌉ 2 , and, thus ζ ≤ ⌈ √ n⌉. Hence, ζ · q ≤ ⌈ √ n⌉ · p since q ≤ p. If a set Q ⊂ A of machines has previously revealed the type during the ascending phase, and the execution of this phase has not been stopped, then these machines received at least m ′ = |Q|m |A| + min{|Q|, m mod |A|} jobs.
Proof. We prove that M many satisfies the OSP two-cycle monotonicity. The claim then follows from Theorem 6. Specifically, for each machine i, for each node u in which the mechanism makes a query to i, for each pair of type profiles x, y compatible with u such that x i and y i diverge at u, we need to prove that if Let us first consider a node u corresponding to the descending phase of the mechanism. In this case, x i = p, where p is as at node u. Moreover, in all profiles compatible with u there are at least ⌈ √ n⌉ machines that either have a type lower than p, or they have type p but they are queried after i. Hence, for every x −i satisfying this property, we have that f i (M f ew (x)) = 0, that implies the claim.
Suppose now that node u corresponds to the ascending phase of the mechanism. Let C(u), A(u), p(u) and q(u) be the value of C, A, p and q at that node. Observe that for every profile compatible with u, the type of machines not in A(u) is fixed, whereas for every machine in A(u), the type is at least q(u). Moreover, y i = q(u). Hence, f i (M f ew (y)) is the largest integer z ≤ C(u) such that z · y i ≤ ⌈ √ n⌉ · p(u). On the other side, for every x i > y i , f i (M f ew (x)) is at most the largest integer z ′ ≤ C(u) such that z ′ · x i ≤ ⌈ √ n⌉ · p(u). Since x i > y i , then z ′ ≤ z, and the lemma follows.
Proof. Let OPT (x) be the optimal outcome on a type profile x. Let A(M f ew ) be the set of alive machines at the end of the descending phase of mechanism M f ew . We first consider the case that the optimal mechanism assigns jobs to only the ⌈ √ n⌉ machines with lower type. In particular, let B be the set of machines that received a job in the optimal allocation, i.e., B = {i : f i (OPT (x)) > 0}. Note that we can assume that the machines that receive a job are in A(M f ew ), and they are exactly the first |B| machines to be removed from this set during the descending phase of our mechanism. We can also assume that assignment to these |B| machines is monotone non-increasing, that is f i (OPT (x)) ≤ f j (OPT (x)) if j reveals her type before i. Indeed, these properties are satisfied by opportunely breaking ties among optimal outcomes.
Observe that f i (OPT (x)) · x i ≤ |B| · p, otherwise a lower makespan would be achieved by moving a job from every machine in B to the one with type p, where p is as at the end of the descending phase. However, this implies that the mechanism M f ew also assigns at least min {f i (OPT (x)), |P 0 | i } jobs to machine i ∈ B, where |P 0 | i is the number of jobs that mechanism M f ew has not assigned yet when the type of i is revealed. Now, for every i ∈ B, let B i be the set of machines that revealed her type before i. Observe that, since the optimal outcome is monotone with respect to the order of revelation, then it must assign to i at least m− j∈B i fj (OPT (x)) |B|−|Bi| jobs. On the other side, our mechanism assigns to i at most m − j∈Bi f j (M f ew (x)) ≤ m − j∈Bi f j (OPT (x)), where the inequality follows from the observation above. Hence, the approximation ratio is at most |B| − |B i | ≤ |B| ≤ ⌈ √ n⌉. Suppose now that optimal mechanism assigns jobs also to a machine that M f ew remove during the descending phase. Observe that, since by hypothesis, M f ew returns an outcome, then during the execution of the mechanism it always hold that ζ ·q ≤ ⌈ √ n⌉·p. Since OPT (x) assigns at least one job to machines not in A(x) In this case we have that max i f i (OPT (x)) ≥ p. By hypothesis, instead, we have that f i (M f ew (x)) ≤ ⌈ √ n⌉ · p for every machine i ∈ A(x) that receives at least one job. The bound then immediately follows.

Set systems
In this section we characterize when optimal OSP mechanisms exist for set systems. We will formally define the concept of alignment introduced above, with a different and more technical terminology. The main message is that the feasibility of optimal OSP mechanisms depends on structural properties of the feasible solutions and the values in the agents' domains.

Key concepts
Consider a set system problem (E, F , D) where there are |E| elements controlled by the agents, having threevalue domains. Specifically, each e ∈ E is an agent whose domain is D e ⊆ {L e , M e , H e } with L e < M e < H e ; F is the set of feasible solutions P ⊆ E, and D = (D e ) e∈E denotes the domain. We assume that this triple is the input to our mechanism design problem; the implementation tree will query the agents in order to elicit the input instance b from D and return an optimal solution for b whilst guaranteeing OSP. We next define some useful concepts and notation, to state our characterization and mechanism. Consider an arbitrary subdomainD of D, that is, a type domainD = (D e ) e∈E such thatD e ⊆ D e for all e ∈ E. We denote by L(e,D) = min{t ∈D e } and H(e,D) = max{t ∈D e } the lowest and the highest type for e according to the subdomainD. Similarly, for any P ⊆ E, we let L(P,D) and H(P,D) be the lowest and the highest possible cost of P according to subdomainD, i.e., L(P,D) = e∈P L(e, D) and H(P,D) = e∈P H(e,D).
(When clear from the context, we omit the reference toD in these notations.) Finally, we let ≺ denote a total order among the feasible solutions in F ; this order will be used to select the optimal solution to return in case of ties. We now introduce some concepts, along with some properties of theirs, that relate implementation trees of an extensive-form mechanism with the optimality of the solutions. Any implementation tree gradually shrinks D to subdomainsD by querying the agents. The concept of selectable solution for a certain subdomaiñ D captures the intuition that if the implementation tree has already shrunk the domain toD, the solution in question cannot be excluded a priori if we care about optimality (because, for some profile inD, it is either the unique optimum or the optimum preferred according to tie-breaking rule).
Definition 20 (selectable solution). A feasible solution P ∈ F is said selectable for a subdomainD if for every other P ′ ∈ F it holds that L(P \ P ′ ,D) < H(P ′ \ P, D) or L(P \ P ′ ,D) = H(P ′ \ P,D) and P ≺ P ′ .
Observe that there is at least one selectable solution for every subdomainD.
Since the implementation tree may shrink the subdomainD even further, it is useful to relate the optimality for the bigger domain with the optimality for smaller domains. The next lemma shows that an optimal mechanism can "forget" about solutions that are not selectable for the current subdomainD.
Lemma 21. If P is not selectable forD, then it is not selectable for every subdomainD ′ ofD, that is, for everyD ′ such thatD ′ e ⊆D e for every e ∈ E.
Proof. By contradiction, assume that P is selectable forD ′ and not selectable forD. SinceD ′ e ⊆D e for every e ∈ E, we have L(e,D ′ ) ≥ L(e,D) and H(e,D ′ ) ≤ H(e,D). Since P is selectable forD ′ , we have that for every other P ′ ∈ F where the second inequality is either strict, or it holds with equality together with P ≺ P ′ (cf. Definition 20). This means that P is selectable forD, thus a contradiction.
While the above concepts refer only to implementation tree and optimality, the next concept will turn out to be useful to study when there is a way to shrink D (i.e., an implementation tree) that returns an optimal solution but also that is compatible with OSP.
Definition 22 (strongly selectable solution). A selectable solution P is said strongly selectable for a sub-domainD if, for all e ∈ P , it continues to be selectable even for the subdomain (D −e , H(e,D)), wherẽ D −f = (D e ) e =f and, with a slight abuse of notation, H(e,D) denotes {H(e,D)}.
In words, this means that solution P is still potentially optimum when any one of its elements has the largest possible cost H(e,D) in the subdomainD under consideration. That is, should any of the elements of a strongly selectable solution reveal to the mechanism type H(e,D), then optimality implies that we cannot "forget" about this solution.
Example 23 (path auctions, selectable vs strongly selectable solutions). To understand the difference between selectable and strongly selectable solutions, consider path auction on the graph in Figure 1a for D e = {L, H}, with 2L < H, for all e. Both solutions are selectable for this subdomainD: the bottom path because L < 2H and the top path since 2L < H. However, only the bottom path is strongly selectable since the top path cannot be the optimum as soon as one of its edges has cost H. On the contrary, for the graph in Figure 1c, both paths are strongly selectable since, for either path, we can always set the cost of the alternative solution to 2H > H + L.

Necessary condition
Our next two lemmas identify necessary conditions for the implementation tree of an optimal OSP mechanism for set systems. The first roughly says that if there exist a subdomain where elements of strongly selectable solutions can be excluded when they reveal their type to be as low as possible, then there is no implementation tree which yields an optimal OSP mechanism.
Lemma 24. There is no optimal OSP mechanism for a set system problem if there is a subdomainD of D such that the following properties are both satisfied: (i) the set S of strongly selectable solutions forD contains at least one P with f ∈ P such that |D f | > 1; (ii) for every P ∈ S and every f ∈ P such that |D f | > 1, there isP f ∈ S with f ∈P f such thatP f remains selectable even for (D −f , L(f,D)).
Proof. Assume by contradiction that there is a subdomainD for which the conditions above are satisfied and yet there is an optimal OSP mechanism M; let us denote with T its implementation tree. Fix the subdomain to be this particularD. Let S be the set of strongly selectable solutions defined in the statement, which is not empty by hypothesis. Consider the first node u ∈ T in which an agent f ∈ P ∈S P diverges between L(f, D) and H(f,D) in the subtree compatible with the type of every agent e ∈ P ∈S P being inD e and the type of every remaining agent e being H(e,D). We first argue that, since the mechanism M is optimal, such a node u must exist. Consider the following two bid profiles b andb inD defined as Since both P andP f are (strongly) selectable forD, Definition 20 says that the mechanism must return P on input b andP f on inputb. Therefore, P = M(b) = M(b) =P f . Since b andb differ only in the bids of agents e in P ∪P f , there must be some node u ∈ T in which some agent f ∈ P ∪P f diverges between L(f, D) and H(f,D).
Given the existence of u and f as above, we now apply the hypothesis (ii) as follows to show a negative OSP 2-cycle. For the strongly selectable solution P * containing f there is another solution Q * which does not contain f , and Q * is also selectable for (D, L(f,D)). We next define two profiles b (H) and b (L) where f has high and low cost, respectively, and it is selected only for the high cost: It is not hard to see that b (H) and b (L) are compatible with node u, and thus the cycle between b (H) and b (L) exists. Since P * is strongly selectable, and Q * is selectable for (D, L(g,D)), from (3) we have M(b (H) ) = P * and M(b (L) ) = Q * . Therefore, the cycle between b (H) and b (L) is negative.
The second necessary property regards subdomainsD for which there are solutions that are selectable but not strongly selectable. For each such solution P there is an agent w, that we will call the witness of P , such that P is no longer selectable forD hw = (D −w , H(w,D)). A couple of easy properties of witnesses are summarized in the next observation.
Proof. The first observation is easy as if |D w | = 1 then P would be selectable also forD hw . Similarly, if w ∈ P \ P ′ for every P ′ ∈ F , then the conditions of Definition 20 would be satisfied forD hw since they are forD. But then, since P is not selectable forD hw , there is a feasible P ′ such that w ∈ P \ P ′ for which either H(w) + L(P \ (P ′ ∪ {w})) > H(P ′ \ P ) or H(w) + L(P \ (P ′ ∪ {w})) = H(P ′ \ P ) and P ′ ≺ P .
The next lemma intuitively says that, if there exist subdomains where witnesses of solutions that are selectable but not strongly selectable can be excluded (included, respectively) when they reveal their type to be the lowest (highest, respectively) possible, then there is no implementation tree which yields an optimal OSP mechanism. Its proof uses ideas similar to that of Lemma 24.
Lemma 26. There is no optimal OSP mechanism for a set system problem if there is a subdomainD of D such that the following properties are both satisfied: (i) the set S of selectable solutions forD has size |S| ≥ 2, and there is at least one P ∈ S such that P is not strongly selectable; (ii) for every f for which there is at least one selectable solution to which it belongs and at least one selectable to which it does not belong (i.e., f ∈ (P,P ′ )∈S×S P \ P ′ ) both the following are true: there isP f ∈ S such that f ∈P f andP f is selectable forĎ = (D −f , H(f,D)).
Proof. Assume by contradiction that there is a subdomainD for which the conditions above are satisfied and yet there is an optimal OSP mechanism M; let us denote with T its implementation tree. Fix the subdomain to be this particularD. LetS ⊆ S be the subset of solutions that are not strongly selectable, and let W (S) the set of agents f such that f is a witness for some P ∈S. Consider the first node u ∈ T in which f ∈ (P,P ′ )∈S×S P \ P ′ diverges between L(f, D) and H(f,D) in the subtree compatible with the type of every agent e ∈ (P,P ′ )∈S×S P \ P ′ being inD e and the type of every remaining agent e being H(e,D). Observe that since there is at least one solution that is not strongly selectable, then there is at least one witness w, and thus, since from Observation 25 w ∈ (P,P ′ )∈S×S P \ P ′ and |D w | ≥ 2, there is at least one agent that can diverge at node u. We next prove that since the mechanism M is optimal, then such a node must exist. Indeed, let P ∈ S be a solution that is not strongly selectable, let w be its witness, and let P ′ be the solution whose existence is guaranteed by Observation 25. Consider the following two bid profiles b andb inD defined as Since P is selectable then M returns P on input profile b, but since it is not strongly selectable it returns P ′ on input profile P ′ . Therefore P = M(b) = M(b) = P ′ . Since b andb differ only in the bids of agents w ∈ W (S) ⊆ (P,P ′ )∈S×S P \ P ′ , there must be some node u ∈ T in which w diverges between L(w,D) and H(w, D). , where agent f has type L(f,D), an optimal mechanism must selectP f (and thus it does not select f ), since it is selectable even if the type of f is L(f,D). In b (H) , where agent f has type H(f,D) > L(f,D), instead mechanism M selectsP f (and thus f ), since it is selectable even if the type of f is H(f,D). Therefore, the cycle between b (L) and b (H) is negative.

The main result (and the mechanism)
The two necessary conditions suggest that it is possible to design an optimal OSP mechanism when both the following properties are satisfied for every subdomainD containing more than one instance. When all selectable solutions are also strongly selectable then there is an f such that every P ′ with f / ∈ P ′ ceases to be selectable if the type of f is L(f,D) (this is the negation of Lemma 24). Moreover, if there is at least one selectable solution that is not strongly selectable forD, then there is f such that either every P ′ with f / ∈ P ′ ceases to be selectable if the type of f is L(f,D), or every P ′ with f ∈ P ′ ceases to be selectable if the type of f is H(f,D) (this is the negation of Lemma 26). We prove that these properties are indeed sufficient by proving that Algorithm 4 can be augmented with payments to give rise to an optimal OSP mechanism, that we call M opt set . Theorem 27. There is an optimal OSP mechanism for a set system problem with three-value domains if and only if there is no subdomainD such that conditions of Lemma 24 or of Lemma 26 hold.
Proof. The "only if" direction follows from Lemma 24 and Lemma 26.
For the "if" direction, assume that for every subdomain of D the conditions of Lemmas 24 and 26 do not hold. We have discussed above how this leads to the definition of Algorithm 4. The algorithm incrementally removes from F the solutions that are found to be non-selectable for some subdomain (this is the set R in the algorithm). The construction of the subdomains closely exploits the properties coming from the unsatisfied lemmas. Specifically, the algorithm looks for an agent f we can safely ask for OSP-ness to diverge between their current L(f ) and H(f ); if f reveals type L(f ), then she will be securely selected, or if she reveals type H(f ), then she will be never selected. By assumption, such an agent always exists; the algorithm makes the suitable queries. This query will update the current domain of agents, and thus the process can be repeated for the new domains. The algorithm continues until we are left with only one selectable solution, that will be returned.
Observe at each iteration either the set of P = F \ R shrinks, or there is at least one agent whose type domain decreases in size. Hence, we eventually reach a point in which we either have one solution therein (and the algorithm stops) or the type of each agent has been revealed, i.e.,D is such thatD e = {t e } for all e ∈ E. We now show that, also in this case, |R| = |F | − 1. Suppose that this is not the case and that R contains two solutions P and P ′ . Let H(e) = L(e) = t e for each e ∈ E. Observe that L(P \ P ′ ) = H(P \ P ′ ) and L(P ′ \ P ) = H(P ′ \ P ). Since P and P ′ are selectable forD, then and then the two solutions have the exact same cost. Thus, if P ≺ P ′ , then only P is selectable, otherwise, only P ′ is selectable and one of them should have been in R.
Moreover, we will never remove all solutions from F since, as noted above, for any possible subdomain, there is always a selectable solution. We can then conclude that M opt set always returns a feasible solution. Moreover, it is immediate to check that the mechanism returns an optimal solution if for each e, the type t e Input: E, F , D Output: An optimal solution 1 Initialize R with the set of P ∈ F that are not selectable for D, P = F \ R and setD = D 2 while |R| < |F | − 1 do 3 while there is P ∈ P that is not strongly selectable forD do 4 if ∃f ∈ P ∈P P s.t. every P ∈ P, with f / ∈ P , is not selectable for (D −f , L(f,D)) then Add to R and remove from P every P that is not selectable forD Add to R and remove from P every P that is not selectable forD 21 Return the only solution in P Algorithm 4: The implementation tree of the optimal algorithm for mechanism M opt set is compatible with the actions taken by agent e during the execution of M opt set . Indeed, by Lemma 21 we know that the solutions removed for bigger subdomain, because they were not selectable, remain non-selectable for all the smaller domains.
We finally prove that M opt set satisfies the 2-cycle monotonicity, from which, by Theorem 6, it follows that M opt set is OSP. First observe that for every agent e and every node u at which agent e interacts with the mechanism, given that D e (u) is the domain of e compatible with the action previously taken by e, either e is asked to diverge among type H(e, D e (u)) and D e (u) \ {H(e, D e (u))} (at Line 11), or it is asked to diverge among type L(e, D e (u)) and D e (u) \ {L(e, D e (u))} (at Line 5 or at Line 17). In the first case, no 2-cycle is possible, since whenever e takes the action compatible with H(e, D e (u)), then, by hypothesis, every solution to which e belongs ceases to be selectable, and thus this agent is never selected. In the second case, no 2-cycle is possible, since whenever e takes the action compatible with L(e, D e (u)), then, by hypothesis, every solution to which e does not belong ceases to be selectable, and thus this agent is always selected.

Conclusions
We have focused on OSP mechanisms, a compelling and needed notion of incentive compatibility for bounded rationality; Li [2017] proves that OSP is the right and only notion of strategyproofness for agents who lack contingent reasoning skills. It is thus paramount to understand the limitations and the power of these mechanisms.
We have introduced a new technique to look at OSP mechanisms, and shown its power by giving tight results on the approximation and a characterization of these mechanisms for paradigmatic problems in the area. Our contribution highlights how there are two dimensions, algorithms and their implementation, to the design of these mechanisms. The interplay between these dimensions is encapsulated by OSP CMON and plays a central role, as shown by the limitations of fixing the implementation beforehand (as in DA auctions or direct revelation mechanisms).
We leave a number of open problems. A technical one is about the domain size and the difference between 2-cycles and longer ones; to what extent adding an extra type in the domain can deteriorate the approximation ratio of OSP mechanisms? A second, more conceptual question, is about dealing with multiparameter agents. It does not seem immediate to characterize the implementation trees for these kind of agents as there is not a concept of relative ordering of types.

A Postponed proofs about OSP CMON
A.1 Extending CMON to characterize OSP We here prove Theorem 3. To this aim, let us first formally prove Observation 1.
Proof of Observation 1. According to our definition, a mechanism M with implementation tree T is an OSP mechanism for the social choice function f if and only if there exists a payment function p such that M = (f, p) and, for every agent i with real type t i , and for every vertex u such that i = S(u), it holds that are compatible with u, but diverge at u. Since the true type of i can be any value in D i , then the mechanism is OSP if and only if this is true for any pair t i , b i ∈ D i .
Henceforth, we will refer to condition (1) as OSP constraint.
Proof of Theorem 3. We initially show that if O T i has no negative-weight cycles then there exist payments p such that M = (f, p) is OSP with implementation tree T . Fix i and T and consider the graph Augment O T i with a node ω and edges (ω, b) for any b ∈ D each of weight 0. Observe that ω does not belong to any cycle of the augmented O T i since it has outgoing edges only. Therefore we can focus our attention on cycles of O T i . For any b in D, we let SP(ω, b) be the length of the shortest path from ω to b in the augmented OSP-graph. Since O T i is finite and does not have negative-weight cycles then SP(ω, b) is well defined. It suffices, for all b ∈ D, to set P i (b) = SP(ω, b). Indeed, consider any edge (a, b) in O T i . The fact that the shortest path from ω to a followed by the edge (a, b) is a path form ω to b implies, by shortest path definition, that SP(ω, b) ≤ SP(ω, a) + a(f (b, b −i )) − a(f (a, a −i )). We can the conclude that for all Now we assume that the OSP-graph O T i contains a negative-weight cycle. Let the negative-weight cycle be C = a 1 → a 2 → . . . → a k → a k+1 = a 1 . Cycle C corresponds to the following OSP constraints: 2 Suppose that there is a solution for the P 's satisfying each of these k inequalities. This solution must also satisfy the inequality that results when we sum the k inequalities together. If we sum the left-hand sides, each unknown P j is added in once and subtracted out once, so that the sum of the left-hand side is 0. The right-hand side sums to the cycle weight w(C), and thus we obtain 0 ≤ w(C). But since C is a negative-weight cycle, w(C) < 0, and we obtain the contradiction that 0 ≤ w(C) < 0.
2 Note that by the existence of (a j−1 , a j ) and (a j , a j+1 ), , 1 < j ≤ k, we know that a j

A.2 OSP two-cycle monotonicity and OSP CMON
We here give the full proofs of Theorems 6 and 7.
Proof of Theorem 6. One direction follows from Theorem 3. As for the other direction, we prove that OSP two-cycle monotonicity implies OSP CMON. Fix agent i and implementation tree T , and consider a cycle C = (x, x ′ , x ′′ , . . . , x) in the graph O T i . Since C is a cycle, we can assume without loss of generality that x i = L i if a profile exists in the cycle such that the type of i is L i , and x i = M i otherwise. Observe that, since no edge exists among two profiles x and y such that x i = y i , then it must be the case that every cycle C can be partitioned in paths (P 1 , . . . , P t ) such that for every j = 1, . . . , t, P j is as one of the following: if no profile appears in the cycle such that the type of i is L i , then the only way of going from a profile x j−1 with x j−1 i = M i to a profile x j with x j i = M i is through a profile y such that y i = H i , and this is considered in case 1. As for cycles in which there is a profile such that the type of i is L i , then either we have a path of length 2 as considered in case 1, or a path of length 3 as considered in case 2, or a path in which the internal profiles are such that the type of i is alternatively M i and H i . In turn, for this last case we can distinguish two subcases: either the type of i in the last internal profile is the same as in the first internal profile, as considered in case 3, or they are different, as considered instead in case 4.
Since we are focusing on single-parameter settings, the cost of a path of type 1 is C( . This cost can be written as follows where we used that y i > x j−1 i ≥ L i and that f i (y) ≥ f i (x j−1 ) by two-cycle monotonicity.
Consider now paths of type 2. The cost of this path is C( We can rewrite this cost as follows: where we used that z i ≥ M i > L i = x j−1 i and, by two-cycle monotonicity, For paths of type 3, we have that: where Observe that By plugging (6) and (7) into (5), we have that where we used the fact that the y j,h i 's are the same for every h. Since by two-cycle monotonicity, we have Similarly, for paths of type 4, we have that: As above, the last step can be rewritten as follows: Hence, where we used that z j,h i = w j i for every h. The, by two-cycle monotonicity, we have that Finally, the cost of the cycle is the sum of the costs of paths in which this cycle has been partitioned. That is, and consider a social function f aiming to select the agent i with the smallest type. This can be seen as a procurement auction for a single item, or, alternatively, if types are negative, as a classical auction setting for a single item, in which we would like to select the agent with the maximum valuation for the item. Consider the implementation tree T corresponding to the following algorithm: keep a set of candidates, initialized to the set of all agents; for every t ∈ D 1 in decreasing order, first ask agent 1 if her type is t, and then, if b = t, repeat the question to the remaining agents (in some order); if an agent gives a positive answer, then remove this agent from the set of candidates; this process continues until only two candidates are left; when this occurs, then, for every t ∈ D i in increasing order ask the candidates left whether their type is t, by giving precedence to agent 1 if she is still a candidate; if an agent gives a positive answer, then assigns the item to this agent. In other words, we run a descending auction until we are left with only two candidates, and then we run an ascending auction to choose the winner among these two candidates.
It is not hard to see that a mechanism that follows this implementation tree satisfies 2-cycle monotonicity. Indeed, during the descending phase, if the agent gives a positive answer, then she is never assigned the item. Instead, during the ascending phase, if the agent gives a positive answer, then she is always assigned the item. (For a more formal proof of 2-cycle monotonicity, we refer the reader to the proof of Proposition 18, where this property is proved for a generalization of the mechanism above. ) We now consider a cycle of length four in the graph O T 1 involving the profiles x, y, z, w defined as follows: in x we have x 1 = H and x j < H for every j = 1; in w we have w 1 = M and w j = H for every j = 1; in z we have z 1 = L and z j ≥ M for every j = 1; in y we have y 1 = B, there is k = 1 such that y k = L, and y j ≥ L for every j = 1, k.
Observe that when agent 1 is queried about type H, then by answering yes the outcome x can occur, whereas w, z, y can all occur if agent 1 answers no. Hence, in the declaration graph of agent 1 edges (x, w), (w, x), (x, z), (z, x), (x, y) and (y, x) exist. Moreover, if agent 1 is queried about type L, then by answering yes the outcome z can occur, whereas w and y can occur if agent 1 answers no. Hence, in the declaration graph of agent 1 edges (z, w), (w, z), (z, y) and (y, z) exist. It is immediate to check that no other edge exists among these four profiles. Indeed, when agent 1 is queried about B (M ) neither x, z are possible since agent 1 is queried about L and H before being queried about B (M ), nor w since machine k has revealed type L before agent 1 is queried about B (M ).
Observe that the algorithm assigns the item to agent 1 in w and z, while agent 1 does not receive the item in x and y. Hence, edges (x, y), (y, x), (w, z) and (z, w) have weight 0, and weights for other edges are as in Figure 2. B Postponed material about machine scheduling B.1 Characterizing the case of two jobs and two agents The next result then gives a complete characterization of the approximability for two jobs and two agents in the three-value domains.
Theorem 28. For the machine scheduling problem, with two jobs and two agents with three values domains D i = {L, M, H}, there is an optimal OSP mechanism if and only if M ≤ 2L or H ≤ 2M .
Proof. In the sequel, we write x ≈ y if x < y ≤ 2x, and x ≺ y if x < 2x < y. With this notation, we require that L ≈ M or M ≈ H. The optimal schedule is as follows, depending on each possible case: If one agent has high cost and the other does not, schedule both jobs on the agent with lower cost. The OSP mechanism is depicted in Figure 3, where leaf nodes show the allocation and the payment of agent 1: The constants p − and p + satisfy L < p − < M < p + < H and 2p − ≥ L + p + . As for agent 2, we pay p + for each assigned job. • (L ≺ M ≈ H): If one agent has low cost and the other does not, schedule both jobs on the agent with low cost. The OSP mechanism is shown in Figure 4, with payments and allocations being described as in the previous case, except that for agent 2 we pay p − for each assigned job.
1, p + 2, 2p − 0, 0 1, p + • (L ≈ M ≈ H): Here we distinguish two subcases. If 2L ≥ H, then we always schedule one job per machine. Otherwise, for 2L < H, we only need to distinguish if one agent has cost L and the other has cost H (in which case both jobs go to the low cost agent). The mechanism is shown in Figure 5, with payments and allocations for agent 1 being described as in the previous cases. As for agent 2, her payment per unit of work is p + when separating {L, M } from H (left subtree), and p − when separating L from {M, H} (right subtree). In this section, we consider machine scheduling on heterogeneous two-value domains D i = {L i , H i }, where L i ≤ H i for each agent i. In particular, we give an optimal polynomial-time OSP mechanism for this case (thus proving Theorem 8).
Notation. We denote the makespan of a solution (scheduling) x with respect to a profile (machines reported costs) b by M S(x, b) := max i b i · x i , that is, the maximum agent cost (machine completion time). For any subset S of agents, and any profile b, we denote by b S the profile restricted to the agents in S only, and by b −S the profile restricted to the agents not in S. Moreover, L S (H S , respectively) denotes the profile in which all agents in S bid L i (H i , respectively). Analogously, L −S and H −S are the profiles in which all agents not in S bid L i and H i , respectively.
An optimal (greedy) algorithm. We next describe a simple optimal greedy algorithm GR which will lead to an optimal OSP mechanism.
Algorithm GR: Allocate jobs one by one greedily, breaking ties in favor of faster machines or, in case of same speed, in favor of lower index machines.
It is well known that the greedy algorithm returns the optimal scheduling for identical jobs. In addition, this particular tie-breaking rule will ensure that the algorithm returns the "most balanced" allocation. As stated in Fact 29 below, if we move a job from a machine to another one, the makespan relative to these two machines only (the maximum cost between them) will increase.
Fact 29. Algorithm GR satisfies the following condition. For any two machines i and j, such that b i < b j , or b i = b j and i < j, it holds that Proof. For every pair of machines i and j as above , respectively) denotes the number of jobs assigned to machine j (i, respectively) before step t in which the greedy algorithm assigns the last job to i, and b i · (GR i (b) + 1) ≥ b i · (GR τ i (b) + 1) > b j · (GR τ j (b) + 1) = b j · GR j (b), where τ is the time in which the greedy algorithm assigns the last job to j.
Note also that it is impossible that both conditions in (8) are unsatisfied, otherwise we have that b i · (GR i (b) + 1) ≤ b j · GR j (b) < b j · (GR j (b) + 1) < b i · GR i (b), thus a contradiction (recall that b i > 0).
Moreover, if b j · (GR j (b) + 1) ≥ b i · GR i (b), then it is impossible to satisfy both conditions even for the assignment x achieved from GR(b) by moving a job from i to j: indeed, we have that b i · (x i + 1) = b i · GR i (b) ≤ b j · (GR j (b) + 1) = b j · x j , so that the first condition is not satisfied.
Similarly, if b i · (GR i (b) + 1) > b j · GR j (b), then it is impossible to satisfy both the conditions even for the assignment y achieved from GR(b) by moving a job from j to i: indeed, we have that b j · (y j + 1) = b j · GR j (b) < b i · (GR i (b) + 1) = b i · y i , so that the second condition is not satisfied.
The classical monotonicity condition says that, whenever an agent increases her own cost, her load will either decrease or stay the same. The next lemma says that, in our algorithm GR, the load of any every other agent will either increase or stay the same.
Lemma 30. For any profile b, and for any two distinct agents (machines) i and j, it holds that Proof. Let b L = (b −j , L j ) and b H = (b −j , H j ), and y L = GR(b −j , L j ) and y H = GR(b −j , H j ). Using standard argument (see e.g. [Archer and Tardos, 2001]), we first prove that the algorithm is monotone, that is, y L j ≥ y H j . Suppose by contradiction that y L j < y H j . Observe that where the first and the last inequalities are due to the optimality of the algorithm, and the second inequality follows from the fact that b H is obtained from b L by increasing one machine cost. We next distinguish two cases according to which machine determines the makespan M S(y L , b H ). If this is machine j, meaning that M S(y L , b H ) = y L j H j , then (9) . This inequality, combined with (9), implies that all inequalities in (9) hold with '='. We argue that this contradicts the fact that the algorithm breaks ties in a fixed manner, since and thus y L would also be optimal for b H and y H would also be optimal for b L . Since we assumed y H j > y L j , there must be another machine k such that y H k < y L k . On input b H , by the definition of greedy algorithm implies b k · (y H k + 1) ≥ H j · y H j (11) because otherwise the algorithm would have assigned the last job to machine j to machine k instead. Similarly, on input b L , the greedy algorithm must satisfy L j · (y L j + 1) ≥ b k · y L k . Since H j · y H j > L j (y L j + 1) and b k · y L k ≥ b k · (y H k + 1), we have that b k · (y H k + 1) ≤ b k y L k ≤ L j (y L j + 1) < H j · y H j , which contradicts (11). The lemma then follows from our choice for the tie-breaking rule. Suppose indeed that there is a machine i = j that receives less jobs in y H than in y L . Then it must exist also another machine k = j that receives more jobs in y H than in y L . Observe that it must be the case that, starting from y H , moving a job from k to i does not increase the makespan, i.e., b i (y , which contradicts the optimality of y L with respect to b L . Hence, both y H and the assignmentȳ H achieved from y H by moving a job from machine k to machine i are optimal for b H . Since y H has been returned, it must be because it satisfies the tie-breaking condition for each pair of machines. In particular it must hold that with strict inequality if b k > b i , or b k = b i and k > i. Moreover, as showed above, it must be the case that b i · (ȳ H i + 1) ≤ b k ·ȳ H k (with strict inequality if b k < b i or b k = b i and k < i). Since only one of the two tie-breaking conditions may fail, we have that b k · y H k = b k · (ȳ H k + 1) ≥ b i ·ȳ H i = b i · (y H i + 1) (with strict inequality if b k < b i or b k = b i and k < i), that contradicts (12).
Proof. Suppose M is a non-full mechanism for machine scheduling. This means that there exists at least one agent, say i, who will not diverge between H and L when all other agents have played according to H. But then the mechanism must return the same outcome on both the profiles x = (L, b −i ) and y = (H, b −i ) where b j = H, for all j = i. Now if the outcome does not assign all jobs to i then the approximation of M on x is n; on the contrary, if M assigns all jobs to i then the approximation of M on y is n.
Let us now rename the agents as follows: Agent 1 is the 1st agent that diverges in T ; note that agent 1 is well defined for all non-trivial mechanisms. Agent 2 is the 2nd agent that diverges, different from agent 1, in the subtree of T defined by agent 1 taking an action compatible with type H; more generally, agent i is the ith agent that diverges, different from the agents 1, 2, . . . , i − 1, in the subtree of T in which the actions taken by agents that previously diverged are compatible with their type being H. We let u i denote the node of T in which i diverges as from above. Moreover, we let c i = M if, at node u i , i diverges between L and M , and c i = H otherwise.
We have the following results, whose proofs follow the same ideas of the one given in Section 4.2.
Theorem 36. Every non-trivial OSP mechanism for the machine scheduling problem such that c 1 = M has approximation ratio at least n.
Proof. Suppose that there is a k-approximate OSP mechanism M with k < n -M is clearly non-trivial. Consider the type profile x such that x 1 = M , and x j = H for every j = 1. Observe that x is compatible with node u 1 . The optimal allocation for the type profile x assigns all jobs to machine 1, with cost OP T (x) = n·M . Since M is k-approximate, then it also assigns all jobs to machine 1. Indeed, if a job is assigned to a machine j = 1, then the cost of the mechanism would be at least H ≥ n 2 · M > k · OP T (x), that contradicts the approximation bound. Consider now the profile y such that y j = L for every j. Observe that also y is compatible with node u 1 . Clearly, OP T (y) = L. Since M is k-approximate, then it cannot assign all jobs to machine 1. Indeed, in this case the cost of the mechanism would be nL > k · OP T (y), that contradicts the approximation bound.
Hence, we have that if agent 1 takes actions compatible with M , then there exists a type profile compatible with u 1 such that 1 receives n jobs, whereas, if 1 takes a different action compatible with a lower type, then there exists a type profile compatible with u 1 such that 1 receives less than n jobs. However, this contradicts that the mechanism is OSP.
Lemma 37. For every i < n, and every full OSP k-approximate mechanism M, with k < n, if c i = H and i at node u i takes an action compatible with her type being H, then M does not assign any job to i, regardless of the actions taken by the other machines.
Proof. Suppose that there is i < n and x −i compatible with u i such that if i takes an action compatible with type H, then M assigns a job to i. According to the definition of c i , machine i diverges at node u i on H and M .
Consider then the profile y such that y i = M , y j = H for j < i, and y j = L for j > i. It is easy to see that the optimal allocation has cost OP T (y) = n n−i · L. Since M is k-approximate, then it does not assign any job to machine i. Indeed, in this case the cost of the mechanism would be at least M ≥ n 2 L ≥ n · n n−i L > k · OP T (x), that contradicts the approximation bound. Hence, we have that if i takes actions compatible with H, then there exists a type profile compatible with u i such that i receives one job, whereas, if i takes a different action compatible with a lower type, then there exists a type profile compatible with u i such that i receives zero jobs. However, this contradicts that the mechanism is OSP.
Theorem 38. Every full OSP mechanism for the machine scheduling problem such that c i = H for every i < n has approximation ratio at least n.
Proof. Suppose now that there is an OSP k-approximate mechanism M, for some k < n, such that c i = H for every i < n. Consider x such that x i = H for every i. Observe that x is compatible with u i for every i. The optimal allocation consists in assigning each job to a different machine, and has cost OP T (x) = H.