Obvious Strategyproofness, Bounded Rationality and Approximation

Obvious strategyproofness (OSP) has recently emerged as the solution concept of interest to study incentive compatibility in presence of agents with a specific form of bounded rationality, i.e., those who have no contingent reasoning skill whatsoever. We here want to study the relationship between the approximation guarantee of incentive-compatible mechanisms and the degree of rationality of the agents, intuitively measured in terms of the number of contingencies that they can handle in their reasoning. We weaken the definition of OSP to accommodate for cleverer agents and study the trade-off between approximation and agents’ rationality for two paradigmatic problems: machine scheduling and facility location. We prove that, for both problems, “good” approximations are possible if and only if the agents’ rationality allows for a significant number of contingencies to be considered, thus showing that OSP is not too restrictive a notion of bounded rationality from the point of view of approximation.


Introduction
A large body of work in computer science deals with the design of algorithms that return "good" (e.g., optimal) solutions. However, there are settings where the input to the algorithm is not readily available since it is owned by selfish agents. These agents might misguide the designer's algorithm if it is profitable for them to do so. For example, consider the facility location problem where the location of a facility needs to be chosen, with the goal to serve a group of users and the choice depending on these users' private locations. If a user could bring the facility closer to them by misreporting their location, then they may lie and obtain a better solution for themselves (possibly making the solution worse overall). Therefore, the algorithm needs to be designed to avoid providing such incentives, i.e., to be incentive compatible.
The tool typically used to deal with these issues is mechanism designstrategyproof (SP) (a.k.a., truthful) mechanisms guaranteeing that the algorithm and the agents' incentives are compatible.
Strategyproofness is based on the assumption of full rationality: agents are assumed to be able to consider all possible strategies and their combinations when they reason about their incentives. Nevertheless, this assumption is seldom true in reality and it is often the case that people strategize against mechanisms that are known to be truthful [3]. One then needs a different notion to ensure that the algorithm is not misguided even in the presence of agents with bounded rationality. The problem here is twofold: how can we formalize strategyproofness for agents with (some kind of) bounded rationality? If so, can we quantify this bounded rationality and relate that to the performance of the mechanisms?
The first question has been recently addressed by Li [4], who defines the concept of obvious strategyproofness (OSP-ness); this notion has attracted quite a lot of interest in the community [5][6][7][8][9][10][11][12][13][14][15]. According to this notion, the reasoning of each agent when choosing a strategy is simple: the worst possible outcome that she can get when behaving well must be at least as good as the best outcome when misbehaving. Best/Worst are quantified over all the possible decisions taken by the agents after the decision of i. Li [4] proves that this solution concept identifies the algorithms that are incentive compatible for agents that have no contingent reasoning skills, a special model of bounded rationality: rather than requiring a careful case analysis, OSP mechanisms guarantee that honest behavior is the best strategy to follow no matter all the contingencies.
In this work we focus on the second question, using the OSP formalization of bounded rationality. On the one hand, OSP is too restrictive in that people might be able, within their computational limitations, to consider some contingent reasoning, that is, a few cases are considered in the agents' decision making process. On the other hand, OSP mechanisms appear to be quite limited, with respect to SP ones, in terms of their approximation guarantee [7,12]. The question then becomes: Can we quantify the trade-off between the "degree" of bounded rationality of the agents and the approximation guarantee of the mechanisms incentivizing them?

Our Contribution
Lookahead can be defined as the ability to anticipate future events (e.g., the moves of a competitor). This concept is discussed in the literature in the context of (strategies to play) games, and agents with limited computational capabilities. De Groot [16] found that all chess players (of whatever standard) used essentially the same thought process -one based upon a lookahead heuristic. Shannon [17] formally proposed the lookahead method and considered it a practical way for machines to tackle complex problems, whilst, in his classical book on heuristic search, Pearl [18] described lookahead as the technique being used by "almost all game-playing programs".
We propose to consider lookahead as a way to quantify bounded rationality, in relation to OSP. Whilst in OSP the players have no lookahead at all, we here consider the case in which the agents have lookahead k, k going from 0 (OSP) to n − 1 (SP). Intuitively, k measures the number of players upon which each player reasons about in her decision making. We allow the set of k "lookahead" players to be player-and time-specific (that is, different players can reason about different competitors, and this set of players is not fixed but may change at different time steps of the mechanism). So when agent i has to decide upon the strategy to play, she will consider all the possible cases (strategies) for these k agents at that time (à la SP) and a no-contingent reasoning (à la OSP) for the others. (A more technical discussion of our notion is deferred to Section 2.) In absence of other formal definitions of incentive compatibility for different degrees of rationality, we regard our definition of OSP with k-lookahead (k-OSP, for short) as a major conceptual contribution of our work.
We then look at the trade-off between the value of k and the approximation guarantee of k-OSP mechanisms. We focus on two well-studied problems, machine scheduling and facility location. The former considers n agents who control related machines (i.e., machines have a private job-independent speed). The objective is to schedule a set of m (identical) jobs to the machines in order to minimize the makespan (i.e., the latest machine's completion time). Our technical contribution consists in proving a lower bound on the approximation guarantee of τ k (n) = √ k 2 +4n−k 2 , thus providing a smooth transition function between the known approximation factors of √ n for OSP mechanisms [12] and 1 for SP mechanisms [19]. We also show that this bound is tight up to a constant factor, at least for the case in which each machine can report a speed from a domain of three values. (Such a restriction is common to the state of the art of OSP mechanisms [12,14].) Our lower and upper bounds significantly extend and generalize to k-OSP the analysis done in [12] for OSP mechanisms. Specifically, the lower bound needs to identify some basic properties of the function τ k (n) and prove what features the implementation tree of a mechanism (i.e., the protocol between the designer and the agents induced by the mechanism) with good approximation guarantee must have. Our upper bound instead defines a mechanism (algorithm, implementation tree and payment function) which combines a descending auction phase, to identify a certain number of slowest machines, with an ascending auction to find out the k + 1 fastest machines. The analysis of the approximation guarantee of our k-OSP mechanism is significantly more involved than the one used in [12] for k = 0.
The facility location problem considers n agents who are located on the real line, and the goal is to place a facility on the line so to minimize the total distance of the facility to agents. Here, agents have a private location in mind and can misreport it in the attempt to force the facility to be as close as possible to their own location. It is well known that a strategy-proof mechanism exists for this problem [20], even without money, whereas from [7], we know that no OSP mechanisms can perform better than a dictatorial mechanism. Here we show that the arguments therein can be generalized to prove a lower bound of n−k−1 k+1 to the approximation ratio of k-OSP mechanisms, whenever k ≤ n 2 − 2. The main message of our work is that having more rational agents only slightly improves the approximation guarantee of incentive-compatible mechanisms, at least for these two optimization problems. In fact, a constant approximation of the optimum would require agents with very large lookahead. We can conclude that, in the cases in which the agents are not that rational, OSP is not that restrictive a solution concept to study the approximation of mechanisms for agents with bounded rationality.

Related Work
Recent research in algorithmic mechanism design has suggested to focus on "simple" mechanisms to deal with bounded rationality [21][22][23]. OSP provides a formal definition for simple mechanisms, by focusing on imperfect rationality due to no contingent reasoning (see references above for the body of work on this notion).
Other concepts of simple mechanisms have been recently adopted in literature, most prominently posted-price mechanisms have received great attention and have been applied to many different settings [24][25][26][27][28]. In these mechanisms one's own bid is immaterial for the price paid to get some goods of interest -this immediately suggests that trying to play the mechanism is worthless no matter the cognitive abilities of the agents.
A different approach is that of verifiably truthful mechanisms [29], wherein agents can run some algorithm to effectively check that the mechanism is incentive compatible. However, they seem to transfer the question from the mechanism itself to the verification algorithm.
The concept of "guided" implementation [30] shares some of the motivations and philosophy behind OSP. The authors note that the implementation (via normal-form games) of a social choice function is 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. In this context, backwards induction implementation via an extensive game is equivalent to such a guided implementation via a normal-form game.

OSP with Lookahead
We have a set N of n agents; each agent i has a domain D i of possible typesencoding some feature of theirs (e.g., their speed). The actual type of agent i is her private knowledge.
An extensive-form mechanism M is a triple (f, p, T ), where f is an algorithm (also called social choice function) that takes as input bid profiles and returns a feasible solution, p = (p 1 , . . . , p n ) is the payment function, one for each agent, and T is an extensive-form game, that we call implementation tree 1 . Intuitively, T represents the steps that the mechanism will take to determine its outcome. More formally, each internal node u of T is labelled with a player S(u), and the outgoing edges from u are labelled with the subset of types in the domain of S(u) that are compatible with the history leading to u; in particular, the labels of edges going out from u denote a partition of the domain of S(u) compatible with the history. If at node u there are multiple outgoing edges, then S(u) is called a divergent agent at u. We denote by D i (u) the types in the domain of i that are compatible with the history leading to node u ∈ T . The tree models how M interacts with the agents: at node u the agent S(u) is queried and asked to choose an action that corresponds to selecting one of u's outgoing edges. The chosen action signals that the type of S(u) is in the set of types labeling the corresponding edge. The leaves of the tree will then be linked to (a set of) bid profiles; the mechanism will return (f, p) accordingly; in other words, each leaf corresponds to an outcome of the mechanism. (Observe that this means that the domain of f and p is effectively given by the leaves of T .) We use b to denote bid profiles, so that b i stands for the type that i signalled to the mechanism. For simplicity, we use f (b) and p 1 (b), . . . , p n (b) to denote the outcome of (f, p) for the leaf of T to which b belongs. We assume that agents have quasilinear utilities, that is, agent i of type t who signals (i.e., plays the game T according to) b i has utility where, with a slight abuse of notation, t (f (b)) is the cost that player i pays to implement the outcome f (b) when her type is t, and b −i is the declaration vector of (i.e. types signalled by) all agents except i. (In general, we let b A = (b j ) j ∈A for A ⊂ N.) Figure 1 gives an example of an implementation tree where three players have a two-value domain {L, H }. The root partitions the domain of machine 1 into L and H . If we let v denote the left child of the root, then D 1 (v) = {L} as type H is no longer compatible with the history of v.
We now define OSP with k-lookahead. OSP informally implies that whenever an agent is asked to diverge, she is better off acting according to her true type in any possible future scenario: the worst possible outcome after selecting her true type is at least as good as the best possible outcome after misreporting her type, at that particular point in the implementation tree. This models agents with no contingent reasoning, i.e., those unable to think through hypothetical scenarios such as "if player 2 will play L and player 3 will play L, then I prefer L; if they will play L and H respectively, then I prefer L, too; and so on". In OSP, the thinking process of the agents is not finely-grained: "If I play L, then the outcome will correspond to leaves l 1 , . . . , l 4 , otherwise it will correspond to leaves l 5 , . . . , l 8 ". However, it would be possible for the agents to have some limited ability of performing contingent reasoning: they can think through hypothetical scenarios corresponding to the action profiles of some players, but not all of them. Specifically, we would like to model a player able to reason as follows: "If player 2 will play L, I know that by choosing L I will finish either in l 1 or in l 2 , otherwise I will finish in l 5 or l 6 ; if player 2 will play R, then my choice will be between the outcomes corresponding to l 3 and l 4 and the one corresponding to l 7 and l 8 ". That is, we here consider a more finely grained partition of the leaves of the tree, allowing for some steps of contingent reasoning by the divergent agent. Intuitively, our definition will allow the agent to reason about the moves of k agents; informally, OSP with k-lookahead then implies that whenever an agent is asked to diverge, she is better off acting according to her true type for any fixed choice of strategies of the k agents she reasons about (just like truthfulness) and any possible future scenario of the actions of the remaining n−k−1 agents.
For the formal definition, we need to introduce some more notation. We call a bid profile b compatible with u if b is compatible with the history of u for all agents. We furthermore say that (t, b −i ) and (b, b −i ) diverge at u if i = S(u) and t and b are labels of different edges outgoing u (we sometimes will abuse notation and we also say that t and b diverge at u). For every agent i and types t, b ∈ D i , we let u i t,b denote a vertex u in the imple- (u). Note that such a vertex might not be unique as agent i will be asked to separate t from b in different paths from the root (but only once for every such path). We call these vertices of T tb-separating for agent i. For example, the node r in the tree in Fig. 1 is a LH -separating node for agent 1; while v and w are two LH -separating nodes for agent 2. These nodes are crucial, as at any point in which an agent distinguishes two different types we will need to add a (set of) constraints to account for her incentives. We finally denote i's lookahead at u i t,b as Ł k (u i t,b ), that is, a set of (at most) k agents that move in T after i. (When k is clear from the context, we simply let Ł(u) be the lookahead of agent S(u) at u.) In words, a mechanism is OSP with lookahed if each agent is willing to behave truthfully at each node of the tree in which she interacts with the mechanism, provided that she exactly knows the types of agents in K (b K is the same either side of the inequality) but has no information about the agents in T , except that their types are compatible with the history.
We remark that with k = 0 we get the definition of OSP -wherein K is emptyand with k = n − 1 we have truthfulness, T being empty.

Discussion
The set Ł k (u) in the definition above crucially captures our notion of lookahead. We highlight the following features of our definition.
-The size of set Ł k (u) tells us how many players agent S(u) can contingently reason about. This means that the boundaries of k indeed go from 0, which corresponds to OSP, to n − 1, which is equivalent to strategyproofness. In this sense, our definition represents a smooth transition between the two notions, measuring the degree of rationality of the players. For example, consider Figure 1 and focus on player 1; when k = 0 then our notion is exactly OSP and the constraints require to compare the utility of 1 in the leaves l 1 , . . . , l 4 with her utility in l 5 , . . . , l 8 ; when, instead, k = 1 and Ł 1 (r) = {2} then the constraints compare the utility of 1 in the leaves l 1 , l 2 with that in l 5 , l 6 (this corresponds to the case in which 2 plays L) and the utility of 1 in the leaves l 3 , l 4 with that in l 7 , l 8 (this corresponds to the case in which 2 plays H ); finally, for k = 2 we get truthfulness as we need to compare the utility of 1 in l j and l 4+j for j = 1, . . . , 4. We note that intermediate values of k are consistent with the vast literature stating that human reasoning only has limited depth: for example, it is known that in chess most professional players are usually able to think ahead few steps only [16]. We remark that k-OSP differs from k-level reasoning: the latter considers a Nash equilibrium in which an agent plays a best response to what happens in the next k steps; the former considers a(n obviously) dominant strategy. -The set Ł k (u) depends on u; this means that the number and the identities of players on which S(u) can reason about can (in principle) adaptively depend on the actual position in the implementation tree. This in particular allows us to also capture extensive-form games where the choice of the players to query is adaptive and a definition of lookahead where the players on which S(u) can reason about are (a subset of) those who move next: this is for example the case in many multi-player board games in which the player can take actions that change who is the next player to play, e.g., by blocking some opponents or reversing the order of play.
then we model the case in which the lookahead is independent from the actual implementation tree and only depends on S(u)'s prior knowledge of the other agents.
-Differently from the examples of chess and multi-player board games in which a player only looks ahead to opponents that play in the next rounds, our definition of Ł k (u) allows this set to contain also players that will play far away in the future. This clearly makes our definition more general. Moreover, we observe that this definition of Ł k (u) also allows us to overcome a paradox that would arise if one defined the lookahead set only with respect to the implementation tree. For the sake of argument, let us fix k = 1. Consider an adaptive implementation tree, where at node u different actions taken by agent S(u) correspond to different players taking the next move. As a limit case, one can imagine that S(u) has n − 1 different available actions and each of them enables a different opponent to react (e.g., this is the case for those board games where each player can decide who plays next). Hence, assuming that S(u) can look ahead to players moving in the next step means that S(u) has the ability to look ahead to all of them. Hence, in this setting limited look-ahead is not limiting at all the ability of contingent reasoning of S(u) (that is, in this setting every mechanism that is 1-OSP according to this tree-only definition of lookahead is actually SP). This is not surprising, since in this setting we are giving each agent i the chance to "reason about" each opponent regardless of the action that i takes. A more realistic alternative would be to assume that the agent exactly knows the actions of an opponent j only when i takes an action that enables j to be the next to play (e.g., in the board game example described above, the current player i is assumed to know which actions player j will take when i chooses j as the next player, but i has no hint about the actions of j if she chooses k = j as the next player). However, in this case i would have to reason about all the possible action combinations of all the different players that move after her; this might not weaken OSP and indeed means that the agent is not more rational at all. In fact, a careful inspection shows that, in this case, 1-OSP according to this alternative definition of tree-only lookahead has the same constraints of OSP.
It must, however, be highlighted that in non-adaptive trees, i.e., trees where the identity of the next player to move after S(u) is the same irrespectively of S(u)'s action, tree-only lookahead would indeed weaken OSP and effectively capture a more rational agent capable of one step of contingent reasoning. Since this is a special case of our notion, our lower bounds continue to hold. -Our definition requires that an agent with k-lookahead is capable of exactly pinpointing the type of the agents in K. This is in fact the same assumption that is implicitly done in the classical definition of truthfulness. Moreover, this makes our definition of k-OSP mechanism a special case of mechanisms implementable with partition dominant strategy as defined in [9]. Consequently, our definition satisfies a natural generalization of the standard decision theory axioms of monotonicity, continuity and independence, necessary to model the reasoning of agents with a knowledge of the state of nature (e.g., the type profiles) limited only to partitions of the set of these states (e.g., the type profiles that are compatible with the history of the mechanism).
We also observe that this requirement only reinforces our lower bounds below (even if they were so rational to do that, the approximation guarantee would still be a constant only for non-constant values of k). However, we leave open the problem of understanding whether our upper bound is tight even for a weaker notion of rationality where the types of the agents in K are not fully known but only have further restricted domains (e.g., an agent with k-lookahead only knows the next actions, for some > 0, that will be taken by the agents in K).

The Case of Machine Scheduling
We now study the relationship between lookahead and approximation for the wellstudied problem of machine scheduling. Here, we are given a set of m identical jobs to execute and the n agents control related machines.
Agent i's type is 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 algorithm 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 signalling b. The cost that agent i faces for the schedule We focus on algorithms f * minimizing the makespan, i.e., We say that f is α-approximate if it returns a solution with cost at most α times the optimum.

Lower Bound
. That is, τ k is the function of n for which it holds that n = τ k (n)(τ k (n) + k). Observe that τ 0 (n) = √ n and τ n−1 (n) = 1. Henceforth, for sake of readability, let us denote τ := τ k (n). Then, we can prove the following theorem. The proof will work in three steps. First, we prove some algebraic property of τ (cf. Lemma 1). We then characterize implementation tree and algorithm of a k-OSP mechanism with approximation better than τ (cf. Lemma 2). Finally, we identify an instance for which any such mechanism cannot return an approximation better than τ -a contradiction.
Proof We first show that τ ∈ [c, c + 1). Observe that τ is decreasing in k, since that is negative for every k ≥ 0. Hence, from k ≤ n−c 2 c , we get that In a similar way, using that k > n−(c+1) 2 c+1 , we conclude that τ < c + 1. Next we prove that δ = τ − c ≤ k τ +k−1 . That is, we need to prove that √ . By simple algebraic manipulation, we obtain that this is equivalent to proving that 2(n − c) − (c + 1)k ≤ (c + 1) √ k 2 + 4n. Since the r.h.s. is non-negative the claim trivially holds if the l.h.s. is non-positive. If instead the l.h.s. is positive, then we square both sides. By rearranging, our requirement becomes n 2 − ((c + 1)(c + 1 + k) + 2c) n + c ((c + 1)k + c) ≤ 0.
Suppose now that a mechanism M with approximation ratio ρ < τ exists for the setting described above, and let T be its implementation tree. Observe that in T there is at least one divergent agent, otherwise the mechanism has an approximation ratio larger than ρ: indeed, such a mechanism must return the same outcome for the instance where all machines have type H (for which assigning all jobs to the same machine will surely give an approximation ratio worse than ρ), and the instance whereone machine has type L and the remaining have type H (for which every allocation that does not assign all the jobs to the machine of type L has approximation ratio worse than ρ). Let us rename the agents as follows: Agent 1 is the first agent that diverges in T . We now call agent 2, the first agent different from 1 that diverges in the subtree of T defined by agent 1 taking an action signalling type H ; if no agent diverges in this subtree of T we simply call 2 an arbitrary agent different from 1. More generally, we rename all agents as follows: agent i is the first agent different from 1, 2, . . . , i − 1 that diverges, if any, in the subtree of T that corresponds to the case that the actions taken by agents that previously diverged are signalling their type being H . As above, if no agent diverges in the subtree of interest, we just let i denote an arbitrary 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 signalling H ; if i does not diverge (i.e., got her id arbitrarily), then we denote with u i a dummy node. We then have the following lemma.

Lemma 2
Any k-OSP M which is ρ-approximate, with ρ < τ, must satisfy the following conditions:

it must diverge on
M and H .

For every i ≤ n − τ − k, if agent i diverges at node u i and takes an action signalling type H , then M does not assign any job to i whenever the action of agents in Ł(u i ) are all signalling H .
Proof Let us first prove part (1). Suppose that there is i ≤ n + 1 − τ − k such that at node u i i does not diverge on M and H (i.e., any action signalling M is signalling also H ). Then it must diverge on L and M, since u i must have at least two outgoing edges (since i is assumed to diverge at u i ), and the remaining edges can only be labeled with L. Consider the type profile x such that x i = M, and x j = H for every j = i. Observe that, by definition of u i , x j ∈ D j (u i ) for every agent j . The optimal allocation for the type profile x assigns all jobs to machine i, with cost OP T (x) = mM. Since M is ρ-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 ≥ τ · mM > ρ · 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 or j ∈ Ł(u i ), and y j = L for every j > i such that j / ∈ Ł(u i ). (We stress that our lower bound holds no matter the definition of the sets Ł(u i ).) Note that there are n − (i − 1) − k machines j such that y j = L. Observe that, as for x, we have that y j ∈ D j (u i ) for every agent j . It is not hard to see that OP T (y) = m n−i−k+1 L: indeed, the optimal allocation cannot assign any job to machines j such that y j = H otherwise the allocation cost would be at least H > τ ·mL; moreover, if m jobs must be assigned to at most n − (i − 1) − k machines, then there must exist at least one of these machines that receives at least m n−i−k+1 jobs. Let μ be the number of jobs that M assigns to machine i in this case. Since M is ρ-approximate, then μ < m. Indeed, if μ = m, then the cost of the mechanism contradicts the approximation bound, since it would be mL ≥ τ m n−i−k+1 L > ρ · OP T (y), where we used that Hence, for the mechanism to be k-OSP we need that both the following conditions are satisfied: where p i (x) and p i (y) denote the payment that i receives from the mechanism M when agents' actions are signalling x and y, respectively. Indeed, since both x and y are compatible with u then condition (i) ensures that when agent i has type M (x i = M) then she has no incentive to deviate and signal type y i . Similarly, condition (ii) assumes that the type of agent i is y i = L and thus we should have that i has no incentive to deviate and signal type x i . However, conditions (i) and (ii) can be both satisfied only if μ(M − L) ≥ m(M − L) that leads to the contradiction that L ≥ M, since μ < m.
Let us now prove part (2). Suppose that there is i ≤ n − τ − k and x −i , with x j ∈ D j (u i ) for every agent j and x j = H for every j ∈ Ł(u i ), such that if i takes an action signalling type H , then M assigns μ ≥ 1 jobs 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 or j ∈ Ł(u i ), and Since M is ρ-approximate, then it does not assign any job to machine i, otherwise its cost would be at least

y). (since ρ < τ and by def. of OP T (y))
Hence, for the mechanism to be k-OSP we need that both the following conditions are satisfied: However, this leads to the contradiction that H ≤ M.
Roughly speaking, Lemma 2 states that any k-OSP mechanism must have an implementation tree such that the first n − τ − k agents interacting with the mechanism, must be asked if their type is H , and, in the case of affirmative answer, they must not receive any job.
We next observe that such a mechanism cannot have approximation lower than τ , contradicting our hypothesis that M was k-OSP and ρ-approximate.
To this aim, assume first that each agent i ≤ n − τ − k diverges at u i , i.e., they do not get id arbitrarily. We consider the profile x such that x i = H 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 2, since M is supposed to be k-OSP, if machines take actions that signal x, then the mechanism M does not assign any job to machine i, for every i ≤ n − τ − k. Hence, the best outcome that M can return for x consists in fairly assigning the m jobs to the remaining τ + k machines. Observe that, if δ = 0, i.e., τ is an integer, then each machine receives τ job, and thus the cost of M is at least τ H > ρOP T (x), which contradicts the approximation ratio of M. Otherwise, there is at least one machine that receives at least τ jobs, since τ ( τ + k) < τ (τ + k) = m. In this case, the cost of M is at least τ H > τH = τ OP T (x), contradicting again the approximation ratio of M.
Consider now the case that there is 1 < i ≤ n − τ − k that does not diverge at u i (since the mechanism has finite approximation then i > 1). This means that all the machines j ≥ i will not diverge at u i ; let S denote this set of machines. Note that the n − i + 1 ≥ τ + k + 1 machines in S will have the same outcome no matter their types when the machines not in S have type H ; in other words, any profile x where x j = H for j ∈ S is compatible with u i . Consider x such that x j = H for j ∈ S and x j = L otherwise. Since H ≥ τ n 2 L, to guarantee approximation ρ, the mechanism must return a solution for x which keeps the machines not in S empty; then there is a j * ∈ S which is allocated at least n |S| jobs. Consider now y where y j = H for j ∈ S ∪ {j * } and x j = L otherwise. For this type profile, the mechanism must return the same allocation returned when the type profile is x, since it cannot distinguish x from y. Hence, the allocation returned by the mechanism on type profile y must have cost at least n |S| H ≥ H . However, since |S| < n, then there is at least one machine with type L, and thus the optimal allocation would have cost at most mL < 1 τ H < 1 ρ H , thus contracting the approximation guarantee.

Upper Bound
We known that the bound τ is tight for k = n − 1 [19] and for k = 0 [12]. We next show that for every remaining value of k and every possible choice of lookahead sets {Ł k (u)} u∈T , the bound above is tight up to a constant factor for three-values domains, i.e., D i = {L i , M i , H i } for every i.
To this aim, consider the following mechanism M k , that consists of a Descending Phase (Algorithm1) followed by an Ascending Phase (Algorithm 2). The algorithmic output is augmented with a payment, to agent i, of M i for each unit of job load received.
In case of multiple optimal assignments in line 9 of Algorithm 2, we assume that the mechanism returns the one that maximizes the number of jobs assigned to machines in B. This is exactly the solution returned by the optimal greedy algorithm, and thus can be computed in polynomial time.
Roughly speaking, mechanism M k works by discovering in the descending phase the n − τ − k slowest machines and discarding them (i.e., no job will be assigned to these machines).
The ascending phase then serves to select a good assignment to the non-discarded machines. To this aim, the mechanism discovers in the ascending phase the k + 1 fastest machines. The assignment that is returned is then the optimal assignment to the non-discarded machines in the case that the type of the k + 1 fastest machines is as revealed, whereas the type of the remaining non-discarded machines is supposed to be as high as possible, namely equivalent to the type of the last discarded machine (i.e., the fastest among the slow machines) 2 . (M k (y)) for each machine i, for each node u in which the mechanism makes a query to i, for every z Ł(u) such that z j ∈ D j (u) for j ∈ Ł(u), for every x i and y i that diverge at u, for each pair of type profiles x, y such that x j ∈ D j (u), y j ∈ D j (u) for every agent j and x j = y j = z j for every j ∈ Ł(u). This is obvious for x i = M i . Next we prove that f i (M k (x)) ≤ f i (M k (y)) if x i = H i , that immediately implies the desired claim. 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 as described above there are at least τ + k 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 k (x)) = 0 ≤ f i (M k (y)) for every alternative profile y.
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 ) is the number of jobs assigned to machine i by the optimal outcome when input consists of profile (y i , z Ł(u) ,ẑ −i,Ł(u) ),ẑ −i,Ł(u) being such thatẑ j = max k∈A t k for every j ∈ A \ ({i} ∪ Ł(u)).
Observe that for every x as described above, it must be the case that x j ≥ y i for every j ∈ A \ Ł(u). Hence, we distinguish two cases: if min j ∈A\Ł(u) x j = x i , then where we used thatẑ −k,Ł(u) =ẑ −i,Ł(u) and the inequalities follow since: (i) in the optimal outcome the fastest machine must receive at least as many jobs as slower machines; (ii) in the optimal outcome, given the speeds of other machines, the number of jobs assigned to machine i decreases as its speeds decreases.
Proof Fix a type profile x. We will denote with OP T (x) the makespan of the assignment returned by the optimal greedy algorithm on input profile x. 3 We also denote as OP T i (x) the number of jobs assigned to machine i in the optimal makespan, so that The proof proceeds by comparing the makeskan OP T (x) of the optimal allocation for profile x and the makespan of the allocation returned by the mechanism for x. Rather than trying to directly characterize these assignments, our proof considers two simpler instances, each involving only two different types, and two special allocations for these instances that turn out to be related to OP T (x) and the allocation returned by the mechanism. These proxy instances and solutions simplify our analysis.
Specifically, let A and B as at the end of the mechanism when agents behave according to x. Let α be the smallest multiple of |A| such that α ≥ i∈A OP T i (x). Moreover, let t = min j / ∈A t j . We define the profile y as follows: y i = w for every i ∈ A and y i = t otherwise, where w is chosen so that α |A| · w = max j ∈A x j · OP T j (x) . 4 Consider then the assignment a that assigns α jobs equally split among agents in A and m − α jobs equally split among agents not in A. It is immediate to see that OP T (x) ≥ MS(a, y), where MS(a, y) is the makespan of the assignment a with respect to the type profile y: indeed, if MS(a, y) = α |A| w, then we have, by our choice of w, that MS(a, y) where the last inequality follows since in the optimal assignment there must be at least one machine not in A that receives at least n−|A| jobs, and its type is at least t.
Let M(x) be the makespan of the assignment returned by our mechanism if agents behave according to x. Then, M(x) is equivalent to OP T (ẑ), whereẑ is such that z j = x j for j ∈ B andẑ j = t for j ∈ A \ B. Let β be the largest multiple of |A \ B| such that β ≤ i∈B OP T i (ẑ). Moreover, let β be the smallest multiple of |B| such that β ≥ β. Note that β − β ≤ |B| − 1 = k. We define the profileŷ as follows:ŷ i =ŵ for every i ∈ B andŷ i = t otherwise, whereŵ is chosen so that β |B| ·ŵ = max j ∈B x j · OP T j (ẑ) . Consider then the assignmentâ that assigns β jobs equally split among agents in B and m − β jobs equally split among agents in A\B. 5 The theorem then follows, by proving that MS(â,ŷ) MS(a,y) ≤ 2 m+k+ τ −1 m τ . To this aim, let us first to prove some useful lemmata.

Lemma 3 MS(â,ŷ) = OP T (ŷ), i.e.,â is the optimal assignment forŷ and maximizes the number of jobs assigned to machines in B.
Proof Observe that MS(â,ŷ) = max β k+1 ·ŵ, m−β τ −1 · t , and suppose it is not optimal forŷ. If MS(â,ŷ) = β k+1ŵ , then, ifâ is not optimal forŷ, it must be that by moving one job from every machine in B to machines in A \ B we have a smaller makespan, i.e. m−β τ −1 + k+1 . In words, moving one job from any machine in B to machines in A/B will result in a makespan lower than OP T (ẑ), that contradicts the optimality of OP T (ẑ).
If instead, MS(â,ŷ) = m−β τ −1 · t, then, sinceâ is not optimal forŷ we have: that contradicts either the optimality of OP T (ẑ) or the tie-breaking rule of the optimal algorithm. Suppose instead thatŵ < x j * . Then there must exist j ∈ B with x j ≤ŵ and x j OP T j (ẑ) < x j * OP T j * (ẑ). Hence, that again proves that moving a job from A \ B to B will produce an assignment with at least the same makespan and one more job on the fastest machines, by contradicting either the optimality of OP T (ẑ) or the tie-breaking rule of the optimal algorithm. Finally, by our assumption on the tie-breaking rule used by the mechanism for choosing the optimal outcome, and the definition of β, it follows thatâ is the optimal assignment forŷ that maximizes the number of jobs that are assigned to machines in B.
Consider first the simpler case that γ = m, i.e., the optimal allocation for x assigns all the jobs to the machines in B. Clearly, in this case OP T i (x) = OP T i (ẑ) for every i, and thus γ = β. Moreover, by definition of β, γ |B| = β |B| . Finally, if j * is the index of the machine that achieves the makespan in the optimal assignment for type profile x, i.e., j * = arg max j (x j · OP T j (x)), then j * ∈ B and where the inequality follows since γ |B| −1 ≤ |B| γ . Suppose now that γ < m. Note that in this case we can write β = cγ + d, where c ≥ 1 and d ∈ {0, . . . , γ − 1}. Let j * be as defined above, and let us, similarly, define j • as the machine in B achieving the highest load in the optimal allocation for z, i.e., j • = arg max j ∈B (x j · OP T j (ẑ)). Finally, we denote with j † a machine in B that achieves less than c + 1 times the number of jobs that it receives in the optimal allocation for x, i.e., OP T j † (ẑ) ≤ c · OP T j † (x). Clearly, such a machine must necessarily exist. Note also that, by our tie-breaking rule about optimal assignments, we have that OP T j † (x) ≥ 1.
Observe that Moreover, β ≥ c · γ , from which we have that |B| β ≤ |B| cγ . Hence we have that w ≤ 2 · α|B| |A|γ · w. Then, for both cases, it is sufficient to prove that α|B| |A|γ ≤ 1, or alternatively, that γ ≥ |B| |A| α. However this immediately follows from the fact that the machines in B t i (z) = d(t i , z) = |t i − z|. So, t i (z) denotes the distance between t i and the location of the facility. We focus on mechanisms implementing a social choice function f * that optimizes the social cost, i.e., As above, we say that the mechanism M is α-approximate if the solution z returned by the mechanism has a social cost that is at most a factor α away from the cost of the solution returned by f * for any input. Let . Observe that τ 0 (n) = n − 1 and τ n−1 (n) = 1. More specifically, τ = 1 for every k ≥ n 2 − 1 and τ = O(1) if and only if k = (n). We now show that there is no k-OSP mechanism for the facility location problem with an approximation ratio better than τ . The proof extends a similar argument given for OSP mechanisms in [7]. Let us first prove the following lemma.

Lemma 7
Fix k ∈ 0, . . . , n 2 − 2 . For every α, β, with α < β, no ρ-approximate mechanism M for the facility location problem, with ρ < τ k (n), sets f (b) ≤ α, if b j = α for k + 1 agents j and b j = β for every remaining agent, where f is the social choice function used by M.
Proof The optimal facility location for the given setting consists in placing the facility in position β. The total cost in this case is (k + 1)(β − α).
With the same argument one can prove also the following lemma.

Lemma 8
For every α, β, with α < β, no ρ-approximate mechanism M for the facility location problem, with ρ < n − 1, sets f (b) ≥ β, if b j = β for one single agent and b j = α for every remaining agent, where f is the social choice function used by M.
Theorem 2 For every ε > 0, there is no (τ − ε)-approximate mechanism for the facility location problem that is k-OSP.
Proof For k ≥ n 2 − 1, we have τ = 1, and thus the claim is obvious. Suppose then k ≤ n 2 − 2 and let M = (f, T , p) be a (τ − ε)-approximate mechanism for the facility location problem that is k-OSP. Let us consider the domain of every agent to be D = {a, a + δ, . . . , b − δ, b}, where δ ≤ (k+1)ε n−2k−2 · b−a 2 . The proof essentially works by proving that there are instances in which any k-OSP mechanism must place the facility either in x or in x + δ, for some x ∈ D. Setting δ to be a small value, as described above, implies that the choice among x and x + δ essentially does not influence the approximation ratio of the mechanism. Note also that it is w.l.o.g. to consider only this domain, since any k-OSP mechanism returning a ρ-approximation in a larger domain must necessarily have the same properties when applied on a smaller domain.
Then, let i be the first divergent agent of M (such a divergent agent must exist, otherwise the mechanism must return the same solution when all agents are in a, and when they are all in b, which is impossible without violating the approximation guarantee of the mechanism) and let u i be the node of T at which it diverges. Note that, by definition of divergent agent, there must be two types t i , t i of agent i such that t i = t i + δ and i takes an action in M when her type is t i that is different from the action taken when her type is t i . We denote as c and d the smallest t i and the largest t i , respectively, for which this occurs, i.e., c is the smallest type in D such that i diverges on c and c + δ, and d is the largest type in D such that i diverges on d and d − δ.
Note that either c < b+a 2 or d > b+a 2 . Indeed, if c ≥ b+a 2 , then d ≥ c + δ > b+a 2 . In the rest of the proof we will assume that c < a+b 2 . The proof for the case that d > a+b 2 simply requires to replace c with d, c + δ with d − δ, and b with a, and invert the direction of the inequalities in the next claims.
The proof fixes an agent i and uses two profiles x and y, that are defined as follows: x i = c + δ, and x j = c for every j = i; -y i = c, y j = c for j ∈ Ł(u i ), and y k = b for every remaining agent j .
We begin by using k-OSP to relate payments and outcomes of the mechanism M on input x and y. Specifically, we note that if the real location of i is t i = x i = c +δ then u i (x) = p i (x) − d(c + δ, f (x)), and u i (y) = p i (y) − d(c + δ, f (y)).
Since i diverges at u i on c and c + δ, agents in Ł(u i ) play the same actions in x and y, and M is k-OSP, we have that u i (x) ≥ u i (y). Hence, it follows that p i (x) ≥ p i (y) − d(c + δ, f (y)) + d(c + δ, f (x)).
If the real location of i is t i = y i = c, then u i (x) = p i (x) − d(c, f (x)), and u i (y) = p i (y) − d(c, f (y)). As above, since i diverges on c and c + δ, agents in Ł(u i ) play the same actions in x and y, and M is k-OSP, we have that u i (y) ≥ u i (x). Hence, it follows that Therefore, in order to satisfy both (6) and (7), we need that d(c + δ, f (y)) − d(c, f (y)) ≥ d(c + δ, f (x)) − d(c, f (x)).
Using (8) above, we first show that f (x) must be at least c and then that f (y) ≤ c + δ. Finally, we prove how this last fact contradicts the desired approximation ratio.
We now show that f (y) ≤ c + δ. Assume by contradiction that f (y) > c + δ. Since f (x) ≥ c, and f (x) < c + δ by Lemma 8, we can rewrite (8) as
Finally, we prove that, given that f (y) ≤ c + δ, then the mechanism is not (τ − ε)approximate. Indeed, since by Lemma 7 f (y) > c, the total cost of mechanism M on input y is However, this is absurd, since M is (τ −ε)-approximate, where τ = n−k−1 k+1 and the optimal mechanism on input y places the facility in b and has total cost (k + 1)(b − c).

Conclusions
We have studied the relationship between the bounded rationality of the agents and the approximation guarantee of mechanisms incentivizing these agents. We have relaxed the popular notion of OSP [4] to allow for more fine grained notions of rationality. For machine scheduling and facility location, we proved that more rational agents do not help in getting close to the optimum, unless the level of rationality is significant to a point where the meaning of bounded becomes questionable.
On one hand, our findings motivate the focus on OSP for future work on the approximation guarantee of mechanisms for agents with bounded rationality. On the other hand, one might wonder whether similar results hold also for different optimization problems. However, we highlight that no approximation result is known even for OSP mechanisms.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.