Obvious Strategyproofness, Bounded Rationality and Approximation

Abstract

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.

1 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 design — strategyproof (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?

1.1 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 $\tau _{k}(n) = \frac {\sqrt {k^{2}+4n}-k}{2}$, thus providing a smooth transition function between the known approximation factors of $\sqrt {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 $\frac {n-k-1}{k+1}$ to the approximation ratio of k-OSP mechanisms, whenever $k \leq \left \lceil \frac {n}{2}\right \rceil -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.

1.2 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.

2 OSP with Lookahead

We have a set N of n agents; each agent i has a domain D_i of possible types – encoding some feature of theirs (e.g., their speed). The actual type of agent i is her private knowledge.

An extensive-form mechanism ${\mathscr{M}}$ is a triple $(f, p, \mathcal {T})$, where f is an algorithm (also called social choice function) that takes as input bid profiles and returns a feasible solution, p = (p₁,…,p_n) is the payment function, one for each agent, and $\mathcal {T}$ is an extensive-form game, that we call implementation tree¹. Intuitively, $\mathcal {T}$ represents the steps that the mechanism will take to determine its outcome. More formally, each internal node u of $\mathcal {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 \in \mathcal {T}$. The tree models how ${\mathscr{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 $\mathcal {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}(\textbf {b}), \dots , p_{n}(\textbf {b})$ to denote the outcome of (f,p) for the leaf of $\mathcal {T}$ to which b belongs. We assume that agents have quasi-linear utilities, that is, agent i of type t who signals (i.e., plays the game $\mathcal {T}$ according to) b_i has utility

$$ u_{i}(b_{i}, \textbf{b}_{-i}) = p_{i}(\textbf{b})-t(f(\textbf{b})), $$

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₁(v) = {L} as type H is no longer compatible with the history of v.

Fig. 1

An implementation tree with three players with two-value domains {L,H}; each player separates the domain types upon playing; at each leaf l_i the mechanism computes f(b) and p(b), b being the bid vector at l_i

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₁,…,l₄, otherwise it will correspond to leaves l₅,…,l₈”.

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₁ or in l₂, otherwise I will finish in l₅ or l₆; if player 2 will play R, then my choice will be between the outcomes corresponding to l₃ and l₄ and the one corresponding to l₇ and l₈”. 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, \textbf {b}_{-i}^{\prime })$ 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 example, (L,H,H) and (L,L,H) are compatible with node v on Figure 1 and diverge at that node, whilst (L,L,H) and (L,L,L) are compatible with v but do not diverge at v.

For every agent i and types t,b ∈ D_i, we let $u_{t,b}^{i}$ denote a vertex u in the implementation tree $\mathcal {T}$, such that (t,b_−i) and $(b, \textbf {b}_{-i}^{\prime })$ are compatible with u, but diverge at u for some $\textbf {b}_{-i}, \textbf {b}_{-i}^{\prime } \in D_{-i}(u) = \times _{j \neq i} D_{j}(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 $\mathcal {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_{t,b}^{i}$ as $\L _{k}(u_{t,b}^{i})$, that is, a set of (at most) k agents that move in $\mathcal {T}$ after i. (When k is clear from the context, we simply let Ł(u) be the lookahead of agent S(u) at u.)

Definition 1 (k-OSP)

An extensive-form mechanism ${\mathscr{M}}=(f, \mathcal {T}, p)$ is OSP with k-lookahead (k-OSP, for short) given $\L _{k}(u_{t,b}^{i})$, if for all i, t,b ∈ D_i, t being i’s true type, $u_{t,b}^{i} \in \mathcal {T}$, $\textbf {b}_{K} \in D_{K}(u_{t,b}^{i})$ and ${\textbf {b}}_{T}, {\textbf {b}}_{T}^{\prime } \in D_{T}(u_{t,b}^{i})$, it holds that

$$u_{i}(t, {\textbf{b}}_{K}, {\textbf{b}}_{T}) \geq u_{i}(b, {\textbf{b}}_{K}, {\textbf{b}}_{T}^{\prime}),$$

where $K=\L _{k}(u_{t,b}^{i})$, T = N ∖ (K ∪{i}) and D_A(u) = ×_j∈A⊂ND_j(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 empty – and 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₁,…,l₄ with her utility in l₅,…,l₈; when, instead, k = 1 and Ł₁(r) = {2} then the constraints compare the utility of 1 in the leaves l₁, l₂ with that in l₅, l₆ (this corresponds to the case in which 2 plays L) and the utility of 1 in the leaves l₃, l₄ with that in l₇, l₈ (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.

  Note that whenever Ł_k(u) = Ł_k(v) for S(u) = S(v) 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).

3 The Case of Machine Scheduling

We now study the relationship between lookahead and approximation for the well-studied 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₁(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 f(b) is t_i(f(b)) = t_i ⋅ f_i(b). We focus on algorithms f^∗ minimizing the makespan, i.e.,

$$ f^{*}(\textbf{b}) \in \arg\min_{\textbf{x} } \max_{i=1}^{n} b_{i}(\textbf{x} ); $$

We say that f is α-approximate if it returns a solution with cost at most α times the optimum.

3.1 Lower Bound

Let $\tau _{k}(n) = \frac {\sqrt {k^{2}+4n}-k}{2}$. That is, τ_k is the function of n for which it holds that n = τ_k(n)(τ_k(n) + k). Observe that $\tau _{0}(n) = \sqrt {n}$ and τ_n− 1(n) = 1. Henceforth, for sake of readability, let us denote τ := τ_k(n). Then, we can prove the following theorem.

Theorem 1

For the machine scheduling problem, no k-OSP mechanism can be better than τ-approximate, regardless of the value of the sets Ł_k(⋅). This even holds for homogeneous three-value domains, i.e., D_i = {L,M,H} for each i.

Proof

Consider m = n. Moreover, consider a domain D_i = {L,M,H} for every i, with $M \geq \tau \left \lceil \frac {m}{\lfloor \tau \rfloor }\right \rceil L$ and H ≥ τ ⋅ mM. Intuitively, these values tell us that no τ-approximate mechanism should put a job on a machine with type M if there are at least ⌊τ⌋ machines with type L. Similarly, no τ-approximate mechanism should put a job on a machine with type H if there is at least one machine with type M or smaller.

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.

Lemma 1

τ = c + δ, with $\delta \in \left [0, \frac {k}{\tau + k - 1}\right ]$, where c is the largest integer such that $k \leq \frac {n-c^{2}}{c}$.

Proof

We first show that τ ∈ [c,c + 1). Observe that τ is decreasing in k, since $\frac {\partial \tau }{\partial k} = -\frac {1}{2} \left (1 - \frac {k}{\sqrt {k^{2} + 4n}}\right )$ that is negative for every k ≥ 0. Hence, from $k \leq \frac {n-c^{2}}{c}$, we get that

$$\tau \geq \frac{1}{2} \left( \sqrt{\frac{(n-c^{2})^{2}}{c^{2}} + 4n} - \frac{n-c^{2}}{c}\right) = \frac{\sqrt{(n + c^{2})^{2}} -n + c^{2}}{2c} = c.$$

In a similar way, using that $k > \frac {n-(c+1)^{2}}{c+1}$, we conclude that τ < c + 1.

Next we prove that $\delta = \tau - c \leq \frac {k}{\tau + k - 1}$. That is, we need to prove that $\frac {\sqrt {k^{2} + 4n} - k - 2c}{2} \leq \frac {2k}{\sqrt {k^{2} + 4n} + k - 2}$. By simple algebraic manipulation, we obtain that this is equivalent to proving that $2(n-c) - (c+1)k \leq (c+1)\sqrt {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} - \left( (c+1)(c+1+k) + 2c\right)n + c\left( (c+1)k+c\right) \leq 0.$$

By solving this inequality, we obtain that

$$ c - (c+1)\frac{\lambda}{2} \leq n \leq c + (c+1)\left( c+1+k+\frac{\lambda}{2}\right), $$

(1)

where $\lambda = \sqrt {(c+1+k)^{2}+4c} - (c+1+k) > 0$. The first inequality in (1) is always verified. Indeed, since $0 \leq k \leq \frac {n-c^{2}}{c}$, we have that $c \leq \sqrt {n}$, and thus $c - (c+1)\frac {\lambda }{2} < c \leq \sqrt {n} \leq n.$ As for the second inequality, we note that it always hold since $k > \frac {n-(c+1)^{2}}{c+1}$, and thus

$$ c + (c+1)\left( c+1+k+\frac{\lambda}{2}\right) > c + (c+1)\left( c+1+\frac{n - (c+1)^{2}}{c+1}\right) = c + n > n. $$

This concludes the proof. □

Suppose now that a mechanism ${\mathscr{M}}$ with approximation ratio ρ < τ exists for the setting described above, and let $\mathcal {T}$ be its implementation tree. Observe that in $\mathcal {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 $\mathcal {T}$. We now call agent 2, the first agent different from 1 that diverges in the subtree of $\mathcal {T}$ defined by agent 1 taking an action signalling type H; if no agent diverges in this subtree of $\mathcal {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 $\mathcal {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 ${\mathscr{M}}$ which is ρ-approximate, with ρ < τ, must satisfy the following conditions:

• 1. For every i ≤ n + 1 −⌈τ⌉− k, if agent i diverges at node u_i, it must diverge on M and H.

• 2. For every i ≤ n −⌊τ⌋− k, if agent i diverges at node u_i and takes an action signalling type H, then ${\mathscr{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 OPT(x) = mM. Since ${\mathscr{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 > ρ ⋅ OPT(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 $OPT(\textbf {y} ) = \left \lceil \frac {m}{n-i-k+1}\right \rceil 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 $\left \lceil \frac {m}{n-i-k+1}\right \rceil$ jobs. Let μ be the number of jobs that ${\mathscr{M}}$ assigns to machine i in this case. Since ${\mathscr{M}}$ is ρ-approximate, then μ < m. Indeed, if μ = m, then the cost of the mechanism contradicts the approximation bound, since it would be $m L \geq \tau \left \lceil \frac {m}{n-i-k+1}\right \rceil L > \rho \cdot OPT(\textbf {y} ),$ where we used that

$$ \begin{array}{@{}rcl@{}} \tau \left\lceil\frac{m}{n-i-k+1}\right\rceil & \leq& \tau \left\lceil\frac{n}{\lceil\tau\rceil}\right\rceil \qquad \qquad \qquad \qquad (\text{since }i \leq n+1-\left\lceil\tau\right\rceil-k)\\ & =& \tau \left\lceil\frac{\tau(\tau+k)}{\tau+1-\delta}\right\rceil \qquad \qquad \qquad \qquad \qquad \quad \text{{(by def. of $\delta$)}}\\ & \leq& \tau \frac{\tau(\tau+k)+(\tau-\delta)}{\tau+1-\delta} \\ & =& \tau\left( (\tau + k) - \frac{k - \delta(\tau + k - 1)}{\tau+1-\delta}\right)\\ & \leq& \tau(\tau+k) = m \qquad (\text{since, by Lemma~1, } \delta \leq \frac{k}{\tau + k - 1}). \end{array} $$

Hence, for the mechanism to be k-OSP we need that both the following conditions are satisfied:

$$ \begin{array}{@{}rcl@{}} (i) && p_{i}(\textbf{x} ) - mM \geq p_{i}(\textbf{y} ) - \mu M, \text{and}\\ (ii) && p_{i}(\textbf{y} ) - \mu L \geq p_{i}(\textbf{x} ) - m L, \end{array} $$

where p_i(x) and p_i(y) denote the payment that i receives from the mechanism ${\mathscr{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 ${\mathscr{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 y_j = L for j > i such that j∉Ł(u_i). Observe that $OPT(\textbf {y} )=\left \lceil \frac {m}{n-i-k}\right \rceil \cdot L$. Since ${\mathscr{M}}$ is ρ-approximate, then it does not assign any job to machine i, otherwise its cost would be at least

$$ \begin{array}{@{}rcl@{}} M & \geq& \tau \left\lceil\frac{m}{\lfloor\tau\rfloor}\right\rceil L \qquad \qquad \qquad \qquad \qquad \text{{(by definition of}\ M)}\\ & \geq& \tau \left\lceil\frac{m}{n-i-k}\right\rceil L \qquad \qquad \qquad \qquad (\text{since} \i \leq n-\left\lceil\tau\right\rceil-k)\\ & >& \rho \cdot OPT(\textbf{y} ). \qquad \qquad \qquad \qquad \qquad (\text{since}\ \rho < \tau \ \text{and by def. of}\ OPT(\textbf{y} )) \end{array} $$

Hence, for the mechanism to be k-OSP we need that both the following conditions are satisfied:

$$ \begin{array}{@{}rcl@{}} (i) && p_{i}(\textbf{x} ) - {\mu}H \geq p_{i}(\textbf{y} ) - 0, \text{and}\\ (ii) && p_{i}(\textbf{y} ) - 0 \geq p_{i}(\textbf{x} ) - {\mu}M. \end{array} $$

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 ${\mathscr{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 OPT(x) = H. According to Part (2) of Lemma 2, since ${\mathscr{M}}$ is supposed to be k-OSP, if machines take actions that signal x, then the mechanism ${\mathscr{M}}$ does not assign any job to machine i, for every i ≤ n −⌊τ⌋− k. Hence, the best outcome that ${\mathscr{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 ${\mathscr{M}}$ is at least τH > ρOPT(x), which contradicts the approximation ratio of ${\mathscr{M}}$. Otherwise, there is at least one machine that receives at least ⌈τ⌉ jobs, since $\lfloor \tau \rfloor \left (\lfloor \tau \rfloor +k\right ) < \tau \left (\tau +k\right ) = m$. In this case, the cost of ${\mathscr{M}}$ is at least ⌈τ⌉H > τH = τOPT(x), contradicting again the approximation ratio of ${\mathscr{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²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 $\left \lceil \frac {n}{|S|}\right \rceil$ 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 $\left \lceil \frac {n}{|S|}\right \rceil H \geq 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 < \frac {1}{\tau } H < \frac {1}{\rho } H$, thus contracting the approximation guarantee. □

3.2 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 $\left \{\L _{k}(u)\right \}_{u \in \mathcal {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 ${\mathscr{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 ${\mathscr{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)².

Proposition 1

Mechanism ${\mathscr{M}}_{k}$ is k-OSP if D_i = {L_i, M_i, H_i} for each i.

Proof

We prove that $M_{i}\cdot f_{i}({\mathscr{M}}_{k}(\textbf {x} )) - x_{i} \cdot f_{i}({\mathscr{M}}_{k}(\textbf {x} )) \geq M_{i}\cdot f_{i}({\mathscr{M}}_{k}(\textbf {y} )) - x_{i} \cdot f_{i}({\mathscr{M}}_{k}(\textbf {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}({\mathscr{M}}_{k}(\textbf {x} )) \leq f_{i}({\mathscr{M}}_{k}(\textbf {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 $\left \lceil \tau \right \rceil +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}({{\mathscr{M}}}_{k}(\textbf {x})) = 0 \leq f_{i}({{\mathscr{M}}}_{k}(\textbf {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 $f_{i}({\mathscr{M}}_{k}(\textbf {y} )) = f^{\star }_{i}(y_{i}, \textbf {z}_{\L (u)}, \hat {\textbf {z}}_{-i,\L (u)})$, where $f^{\star }_{i}(y_{i}, \textbf {z}_{\L (u)}, \hat {\textbf {z}}_{-i,\L (u)})$ is the number of jobs assigned to machine i by the optimal outcome when input consists of profile $(y_{i}, \textbf {z}_{\L (u)}, \hat {\textbf {z} }_{-i, \L (u)})$, $\hat {\textbf {z} }_{-i, \L (u)}$ being such that $\hat {z}_{j} = \max \limits _{k \in 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 \limits _{j \in A \setminus \L (u)} x_{j} = x_{i}$, then

$$f_{i}(\mathcal{M}_{k}(\textbf{x} )) = f^{\star}_{i}(x_{i},\textbf{z}_{\L(u)},\hat{\textbf{z} }_{-i,\L(u)}) \leq f^{\star}_{i}(y_{i},\textbf{z}_{\L(u)},\hat{\textbf{z} }_{-i,\L(u)}) = f_{i}(\mathcal{M}_{k}(\textbf{y} ));$$

if instead $\min \limits _{j \in A \setminus \L (u)} x_{j} = x_{k}$, for some k≠i, then

$$ \begin{array}{@{}rcl@{}} f_{i}(\mathcal{M}_{k}(\textbf{x} )) = f^{\star}_{i}(x_{k},\textbf{z}_{\L(u)},\hat{\textbf{z} }_{-k,\L(u)}) & \leq& f^{\star}_{k}(x_{k},\textbf{z}_{\L(u)},\hat{\textbf{z} }_{-k,\L(u)})\\ & \leq& f^{\star}_{i}(y_{i},\textbf{z}_{\L(u)},\hat{\textbf{z} }_{-i,\L(u)}) = f_{i}(\mathcal{M}_{k}(\textbf{y} )), \end{array} $$

where we used that $\hat {\textbf {z} }_{-k,\L (u)} = \hat {\textbf {z} }_{-i,\L (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. □

Proposition 2

Mechanism ${\mathscr{M}}_{k}$, for 1 ≤ k ≤ n − 2, is $\left ({2}\frac {m+2k+\lceil \tau \rceil - 1}{m} \lceil \tau \rceil \right )$-approximate.

Proof

Fix a type profile x. We will denote with OPT(x) the makespan of the assignment returned by the optimal greedy algorithm on input profile x.³ We also denote as OPT_i(x) the number of jobs assigned to machine i in the optimal makespan, so that $OPT(\textbf {x} ) = \max \limits _{i} x_{i} \cdot OPT_{i}(\textbf {x} )$.

The proof proceeds by comparing the makeskan OPT(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 OPT(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 $\alpha \geq {\sum }_{i \in A} {OPT}_{i}(\textbf {x} )$. Moreover, let $t = \min \limits _{j \notin 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 $\frac {\alpha }{|A|} \cdot w = \max \limits _{j \in A} \left (x_{j} \cdot {OPT}_{j}(\textbf {x} )\right )$.⁴ 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 OPT(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(\textbf {a},\textbf {y}) = \frac {\alpha }{|A|} w$, then we have, by our choice of w, that $MS(\textbf {a},\textbf {y}) = \max \limits _{j \in A} \left (x_{j} \cdot OPT_{j}(\textbf {x})\right ) \leq OPT(\textbf {x})$; if $MS(\textbf {a},\textbf {y}) = \left \lceil \frac {m-\alpha }{n-|A|}\right \rceil t$, then, by our choice of α, $MS(\textbf {a},\textbf {y}) \leq \left \lceil \frac {m-{\sum }_{i \in A} OPT_{i}(\textbf {x})}{n-|A|}\right \rceil t \leq OPT(\textbf {x})$, where the last inequality follows since in the optimal assignment there must be at least one machine not in A that receives at least $\left \lceil \frac {m-{\sum }_{i \in A} OPT_{i}(\textbf {x})}{n-|A|}\right \rceil$ jobs, and its type is at least t.

Let ${\mathscr{M}}(\textbf {x} )$ be the makespan of the assignment returned by our mechanism if agents behave according to x. Then, ${\mathscr{M}}(\textbf {x} )$ is equivalent to ${OPT}(\hat {\textbf {z} })$, where $\hat {\textbf {z} }$ is such that $\hat {z}_{j} = x_{j}$ for j ∈ B and $\hat {z}_{j} = t$ for j ∈ A ∖ B. Let $\overline {\beta }$ be the largest multiple of |A ∖ B| such that $\overline {\beta } \leq {\sum }_{i \in B} {OPT}_{i}(\hat {\textbf {z} })$. Moreover, let β be the smallest multiple of |B| such that $\beta \geq \overline {\beta }$. Note that $\beta - \overline {\beta } \leq |B| - 1 = k$. We define the profile $\hat {\textbf {y} }$ as follows: $\hat {y}_{i} = \hat {w}$ for every i ∈ B and $\hat {y}_{i} = t$ otherwise, where $\hat {w}$ is chosen so that $\frac {\beta }{|B|} \cdot \hat {w} = \max \limits _{j \in B} \left (x_{j} \cdot {OPT}_{j}(\hat {\textbf {z} })\right )$. Consider then the assignment $\hat {\textbf {a} }$ that assigns β jobs equally split among agents in B and $m-{\overline {\beta }}$ jobs equally split among agents in A ∖ B.⁵ Observe that $\max \limits _{j \in A \setminus B} (x_{j} \cdot {OPT}_{j}(\hat {\textbf {z} })) = \left \lceil \frac {m-{\sum }_{i \in B} {OPT}_{i}(\textbf {z} )}{|A \setminus B|}\right \rceil \cdot t = \frac {m-\overline {\beta }}{|A \setminus B|} \cdot t = \max \limits _{j \in A \setminus B} (\hat {y}_{j} \cdot \hat {a}_{j})$. Moreover, $\max \limits _{j \in B} (x_{j} \cdot {OPT}_{j}(\hat {\textbf {z} })) = \frac {\beta }{|B|} \cdot \hat {w} = \max \limits _{j \in B} (\hat {y}_{j} \cdot \hat {a}_{j})$. Hence, ${\mathscr{M}}(\textbf {x} ) = {OPT}(\hat {\textbf {z} }) = MS(\hat {\textbf {a} },\hat {\textbf {y} })$.

The theorem then follows, by proving that $\frac {{MS(\hat {\textbf {a} },\hat {\textbf {y} })}}{MS(\textbf {a} ,\textbf {y} )} \leq 2\frac {m+k+\lceil \tau \rceil - 1}{m} \lceil \tau \rceil$. To this aim, let us first to prove some useful lemmata.

Lemma 3

$MS(\hat {\textbf {a} },\hat {\textbf {y} }) = {OPT}(\hat {\textbf {y} })$, i.e., $\hat {\textbf {a} }$ is the optimal assignment for $\hat {\textbf {y} }$ and maximizes the number of jobs assigned to machines in B.

Proof

Observe that $MS(\hat {\textbf {a} },\hat {\textbf {y} }) = \max \limits \left \{\frac {\beta }{k+1} \cdot \hat {w}, \frac {m-{\overline {\beta }}}{\left \lceil \tau \right \rceil - 1} \cdot t\right \}$, and suppose it is not optimal for $\hat {\textbf {y}}$. If $MS(\hat {\textbf {a}},\hat {\textbf {y}}) = \frac {\beta }{k+1} \hat {w}$, then, if $\hat {\textbf {a}}$ is not optimal for $\hat {\textbf {y}}$, 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. $\left (\frac {m-{\overline {\beta }}}{\left \lceil \tau \right \rceil - 1} + {\left \lceil \frac {k+1}{|A\setminus B|}\right \rceil }\right ) \cdot t < \frac {\beta }{k+1} \cdot \hat {w} = \max \limits _{j \in B} \left (x_{j} \cdot OPT_{j}(\hat {\textbf {z}})\right ) = \max \limits _{j \in B} \left (\hat {z}_{j} \cdot OPT_{j}(\hat {\textbf {z}})\right )$. However,

$$ \begin{array}{@{}rcl@{}} \left( \frac{m-\beta}{\left\lceil\tau\right\rceil - 1} + {\left\lceil\frac{k+1}{|A\setminus B|}\right\rceil}\right) \cdot t & =& \left( \left\lceil \frac{m-{\sum}_{i \in B} {OPT}_{i}(\hat{\textbf{z} })}{\left\lceil\tau\right\rceil - 1}\right\rceil + {\left\lceil\frac{k+1}{|A\setminus B|}\right\rceil}\right)\cdot t\\ & =& \max_{j \in A \setminus B} \left( \hat{z}_{j} \cdot \left( {OPT}_{j}(\hat{\textbf{z} })+{\left\lceil\frac{k+1}{|A\setminus B|}\right\rceil}\right)\right), \end{array} $$

that implies $\max \limits _{j \in A \setminus B} \left (\hat {z}_{j} \cdot \left ({OPT}_{j}(\hat {\textbf {z} })+{\left \lceil \frac {k+1}{|A\setminus B|}\right \rceil }\right )\right ) < \max \limits _{j \in B} \left (\hat {z}_{j} \cdot OPT_{j}(\hat {\textbf {z}})\right )$. In words, moving one job from any machine in B to machines in A/B will result in a makespan lower than $OPT(\hat {\textbf {z}})$, that contradicts the optimality of ${OPT}(\hat {\textbf {z} })$.

If instead, $MS(\hat {\textbf {a} },\hat {\textbf {y} }) = \frac {m-{\overline {\beta }}}{\left \lceil \tau \right \rceil - 1} \cdot t$, then, since $\hat {\textbf {a} }$ is not optimal for $\hat {\textbf {y} }$ we have:

$$ \begin{array}{@{}rcl@{}} \left( {\frac{\beta}{k+1}} + 1\right) \hat{w} < \frac{m-{\overline{\beta}}}{\left\lceil\tau\right\rceil - 1} \cdot t & = \left\lceil\frac{m-{\sum}_{i \in B} {OPT}_{i}(\hat{\textbf{z} })}{\left\lceil\tau\right\rceil - 1}\right\rceil \cdot t\\ & = \max_{j \in A \setminus B} \left( \hat{z}_{j} \cdot {OPT}_{j}(\hat{\textbf{z} })\right). \end{array} $$

However, $\left ({\frac {\beta }{k+1}} + 1\right ) \hat {w} = \max \limits _{j \in B} \left (x_{j} \cdot {OPT}_{j}(\hat {\textbf {z} })\right ) + \hat {w}$. If $\hat {w}\geq x_{j^{*}}$, where j^⋆ is the agent in B that maximizes $x_{j} \cdot OPT_{j}(\hat {\textbf {z}})$, then we conclude that

$$\max_{j \in B} \left( \hat{z}_{j} \cdot ({OPT}_{j}(\hat{\textbf{z} })+1)\right) < \max_{j \in A \setminus B} \left( \hat{z}_{j} \cdot {OPT}_{j}(\hat{\textbf{z} })\right),$$

that contradicts either the optimality of $OPT(\hat {\textbf {z}})$ or the tie-breaking rule of the optimal algorithm.

Suppose instead that $\hat {w} < x_{j^{*}}$. Then there must exist $j^{\prime } \in B$ with $x_{j^{\prime }} \leq \hat {w}$ and $x_{j^{\prime }} {OPT}_{j^{\prime }}(\hat {\textbf {z} }) < x_{j^{*}} {OPT}_{j^{*}}(\hat {\textbf {z} })$.

Hence,

$$ x_{j^{\prime}} \left( {OPT}_{j^{\prime}}(\hat{\textbf{z} }) + 1\right) < \max_{j \in B} \left( x_{j} \cdot {OPT}_{j}(\hat{\textbf{z} })\right) + \hat{w} < \max_{j \in A \setminus B} \left( \hat{z}_{j} \cdot {OPT}_{j}(\hat{\textbf{z} })\right), $$

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 ${OPT}(\hat {\textbf {z} })$ 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 $\hat {\textbf {a}}$ is the optimal assignment for $\hat {\textbf {y}}$ that maximizes the number of jobs that are assigned to machines in B. □

Lemma 4

$MS(\hat {\textbf {a} },\hat {\textbf {y} }) \leq \frac {(m+{2}k+\lceil \tau \rceil -1)\hat {\nu }\hat {\theta }}{\hat {\nu }+\hat {\theta }}$, where $\hat {\nu } = \frac {\hat {w}}{k+1}$ and $\hat {\theta } = \frac {t}{\lceil \tau \rceil -1}$.

Proof

Recall that $MS(\hat {\textbf {a} },\hat {\textbf {y} }) = {\min \limits } \left \{\frac {\beta }{k+1} \cdot \hat {w}, \frac {m-\overline {\beta }}{\left \lceil \tau \right \rceil - 1} \cdot t\right \}$. Suppose first that $MS(\hat {\textbf {a} },\hat {\textbf {y} }) = \frac {\beta }{k+1} \cdot \hat {w} = \beta \hat {\nu }$. Since, by Lemma 3, $\hat {\textbf {a} }$ is the optimal assignment for $\hat {\textbf {y} }$, then it must be the case that by moving a job from every machine in B to machines in A ∖ B, the makespan does not decrease. Specifically,

$$\beta\hat{\nu} \leq \left\lceil\frac{m-\overline{\beta}+k+1}{\left\lceil\tau\right\rceil - 1}\right\rceil \cdot t = (m-\overline{\beta}+k+1+\delta) \hat{\theta},$$

where δ is the smallest integer such that m − β + k + 1 + δ is a multiple of $\left \lceil \tau \right \rceil - 1$. If $\beta = \overline {\beta }$, we have that $\beta \leq \frac {(m+k+1+\delta ) \hat {\theta }}{\hat {\nu } + \hat {\theta }}$, and, consequently,

$$ \begin{array}{@{}rcl@{}} MS(\hat{\textbf{a} },\hat{\textbf{y} }) & \leq& \frac{(m+k+1+\delta) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}}\\ & \leq& \frac{(m+k+\lceil\tau\rceil-1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}} \leq \frac{(m+2k+\lceil\tau\rceil-1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}}, \end{array} $$

where the second inequality uses that $\delta \leq \left \lceil \tau \right \rceil -2$. If $\beta > \overline {\beta }$, we have that $\beta \leq \frac {(m+(\beta -\overline {\beta })+k+1+\delta ) \hat {\theta }}{\hat {\nu } + \hat {\theta }} \leq \frac {(m+2k+\delta +1) \hat {\theta }}{\hat {\nu } + \hat {\theta }}$, where we used that $\beta -\overline {\beta }\leq k$. Consequently,

$$ MS(\hat{\textbf{a} },\hat{\textbf{y} }) \leq \frac{(m+2k+\delta+1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}} \leq \frac{(m+2k+\lceil\tau\rceil-1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}}, $$

where the second inequality follows from $\delta \leq \left \lceil \tau \right \rceil - 2$.

Suppose instead $MS(\hat {\textbf {a} },\hat {\textbf {y} }) = \frac {m-\beta }{\left \lceil \tau \right \rceil - 1} \cdot t = (m-\beta ) \hat {\theta }$. Since, by Lemma 3, $\hat {\textbf {a} }$ is the optimal assignment for $\hat {\textbf {y} }$ that maximizes the number of jobs in |B|, then moving one job from A ∖ B to a machine in B results in an higher makespan. Specifically,

$$ \begin{array}{@{}rcl@{}} (m-\overline{\beta}) \hat{\theta} & <& \left( \frac{\beta}{k+1} + 1\right) \cdot \hat{w} = (\beta + k + 1) \hat{\nu}\\ & =& (\overline{\beta} + (\beta-\overline{\beta}) + k + 1) \hat{\nu} \leq (\overline{\beta} + 2k + 1) \hat{\nu}. \end{array} $$

Hence, we have $\overline {\beta } > \frac {m\hat {\theta } - (2k+1)\hat {\nu }}{\hat {\nu }+\hat {\theta }}$, and, consequently,

$$ \begin{array}{@{}rcl@{}} MS(\hat{\textbf{a} },\hat{\textbf{y} }) & <& \left( m - \frac{m\hat{\theta} - (2k+1)\hat{\nu}}{\hat{\nu}+\hat{\theta}}\right) \cdot \hat{\theta} = \frac{(m+2k+1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}}\\ & \leq& \frac{(m+2k+\left\lceil\tau\right\rceil-1) \hat{\theta} \hat{\nu}}{\hat{\nu} + \hat{\theta}}, \end{array} $$

where the second inequality uses that $\left \lceil \tau \right \rceil -1 \geq 1$ since k < n − 1. □

Lemma 5

$MS(\textbf {a} ,\textbf {y} ) \geq \frac {m\nu \theta }{\nu + \theta }$, where $\nu = \frac {w}{\left \lceil \tau \right \rceil + k}$ and $\theta = \frac {t}{n- \left \lceil \tau \right \rceil - k}$.

Proof

Recall that $MS(\textbf {a} ,\textbf {y} ) = \max \limits \left \{\frac {\alpha }{\left \lceil \tau \right \rceil + k} \cdot w, \left \lceil \frac {m-\alpha }{n- \left \lceil \tau \right \rceil - k}\right \rceil \cdot t\right \}$.

If $MS(\textbf {a} ,\textbf {y} ) = \frac {\alpha }{\left \lceil \tau \right \rceil + k} \cdot w = \alpha \nu$, then $\alpha \nu \geq \left \lceil \frac {m-\alpha }{n- \left \lceil \tau \right \rceil - k}\right \rceil \cdot t = \frac {m-\alpha +\lambda }{n- \left \lceil \tau \right \rceil - k} \cdot t = (m-\alpha +\lambda ) \theta$, where λ is the smallest integer such that m − α + λ is a multiple of $n- \left \lceil \tau \right \rceil - k$. Hence, we have $\alpha \geq \frac {(m+\lambda )\theta }{\nu +\theta }$, and, consequently, $MS(\textbf {a} ,\textbf {y} ) \geq \frac {(m+\lambda )\theta \nu }{\nu +\theta } \geq \frac {m\theta \nu }{\nu +\theta }$, since λ ≥ 0.

If $MS(\textbf {a} ,\textbf {y} ) = \left \lceil \frac {m-\alpha }{n- \left \lceil \tau \right \rceil - k}\right \rceil \cdot t = \frac {m-\alpha +\lambda }{n- \left \lceil \tau \right \rceil - k} \cdot t = (m-\alpha +\lambda ) \theta$, then, (m − α + λ)𝜃 ≥ αν. Hence, $\alpha \leq \frac {(m+\lambda )\theta }{\nu +\theta }$, and, consequently,

$$MS(\textbf{a} ,\textbf{y} ) \geq \left( (m+\lambda) - \frac{(m+\lambda)\theta}{\nu+\theta}\right) \theta = \frac{(m+\lambda)\nu\theta}{\nu+\theta} \geq \frac{m\nu\theta}{\nu+\theta}.$$

□

Lemma 6

It holds $\hat {w} \leq {2} w$.

Proof

Throughout this proof, let us denote with γ the number of jobs that the optimal allocation for x assigns 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 $OPT_{i}(\textbf {x} ) = OPT_{i}(\hat {\textbf {z} })$ for every i, and thus $\gamma = \overline {\beta }$. Moreover, by definition of β, $\left \lceil \frac {\gamma }{|B|}\right \rceil = \frac {\beta }{|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 \limits _{j} (x_{j} \cdot {OPT}_{j}(\textbf {x} ))$, then j^∗∈ B and

$$ \begin{aligned} \hat{w} & = \left( \frac{\beta}{|B|}\right)^{-1} \max_{j \in B} (x_{j} \cdot {OPT}_{j}(\hat{\textbf{z} })) = \left( \frac{\beta}{|B|}\right)^{-1} (x_{j^{*}} \cdot {OPT}_{j^{*}}(\hat{\textbf{z} }))\\ & = \left\lceil\frac{\gamma}{|B|}\right\rceil^{-1} \max_{j \in A} (x_{j} \cdot {OPT}_{j}(\textbf{x} )) \leq 2 \cdot \frac{\alpha|B|}{|A|\gamma} \cdot w, \end{aligned} $$

(2)

where the inequality follows since $\left \lceil \frac {\gamma }{|B|}\right \rceil ^{-1} \leq \frac {|B|}{\gamma }$.

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 $\hat {\textbf {z} }$, i.e., $j^{\circ } = \arg \max \limits _{j \in B} (x_{j} \cdot {OPT}_{j}(\hat {\textbf {z} }))$. 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., $OPT_{j^{\dagger }}(\hat {\textbf {z} }) \leq c \cdot OPT_{j^{\dagger }}(\textbf {x} )$. Clearly, such a machine must necessarily exist. Note also that, by our tie-breaking rule about optimal assignments, we have that $OPT_{j^{\dagger }}(\textbf {x} ) \geq 1$.

Observe that

$$ \begin{array}{@{}rcl@{}} x_{j^{\circ}} \cdot OPT_{j^{\circ}}(\hat{\textbf{z}} ) & \leq& x_{j^{\dagger}} \cdot (OPT_{j^{\dagger}}(\hat{\textbf{z}} )+1) \qquad \qquad \qquad \qquad \quad \text{(by optimality)}\\ & \leq& x_{j^{\dagger}} \cdot \left[\left( c \cdot OPT_{j^{\dagger}}(\textbf{x} )+ OPT_{j^{\dagger}}(\textbf{x} ) -1\right) + 1\right] (\text{by def. of}\ j^{\dagger})\\ & \leq& 2 \cdot c \cdot x_{j^{\dagger}} \cdot OPT_{j^{\dagger}}(\textbf{x} )\\ & \leq& 2 \cdot c \cdot x_{j^{*}} \cdot OPT_{j^{*}}(\textbf{x} ). \qquad \qquad \qquad \qquad \quad (\text{by def. of}\ j^{*}) \end{array} $$

Moreover, β ≥ c ⋅ γ, from which we have that $\frac {|B|}{\beta } \leq \frac {|B|}{c \gamma }$. Hence we have that $\hat {w} \leq 2 \cdot \frac {\alpha |B|}{|A|\gamma } \cdot w$.

Then, for both cases, it is sufficient to prove that $\frac {\alpha |B|}{|A|\gamma } \leq 1$, or alternatively, that $\gamma \geq \frac {|B|}{|A|} \alpha$. However this immediately follows from the fact that the machines in B are the fastest ones, and our tie-breaking rule among optimal allocations chooses the allocation that maximizes the number of jobs on these machines.

$$\sum\limits_{i \in B} {OPT}_{i}(\hat{\textbf{z} }) < \frac{k+1}{\lceil\tau\rceil+k} \beta.$$

□

According to Lemma 4, and Lemma 5, we then have that

$$ \begin{aligned} \frac{MS(\hat{\textbf{a} },\hat{\textbf{y} })}{MS(\textbf{a} ,\textbf{y} )} & \leq {\frac{m+2k+\lceil\tau\rceil-1}{m} \cdot \frac{\hat{\nu}\hat{\theta}}{\hat{\nu}+\hat{\theta}} \cdot \frac{\nu+\theta}{\nu\theta}}\\ & = \frac{m+{2}k+\lceil\tau\rceil-1}{m} \cdot \frac{\hat{w}}{w} \cdot \frac{w(n-k-\lceil\tau\rceil)+t(k+\lceil\tau\rceil)}{\hat{w}(\lceil\tau\rceil - 1) + t(k+1)}. \end{aligned} $$

(3)

Observe that

$$ \begin{aligned} \frac{\hat{w}}{w} \cdot \frac{w(n-k-\lceil\tau\rceil)+t(k+\lceil\tau\rceil)}{\hat{w}(\lceil\tau\rceil - 1) + t(k+1)} & = \frac{\hat{w}}{w} \cdot \frac{w(\tau(k+\tau)-(k+\lceil\tau\rceil))+t(k+\lceil\tau\rceil)}{\hat{w}(\lceil\tau\rceil - 1) + t(k+1)}\\ & \leq (k+\lceil\tau\rceil) \cdot \frac{\hat{w}}{w} \cdot \frac{w(\lceil\tau\rceil-1)+t}{\hat{w}(\lceil\tau\rceil - 1) + t(k+1)}. \end{aligned} $$

(4)

Moreover, the function $\frac {w(\lceil \tau \rceil -1)+t}{\hat {w}(\lceil \tau \rceil - 1) + t(k+1)}$ turns out to be non-increasing in t, given that, by Lemma 6, $\hat {w} \leq 2 \cdot w \leq (k+1) \cdot w$, where the last inequality follows since k ≥ 1. Hence, since t ≥ w,

$$ \begin{aligned} \frac{\hat{w}}{w} \cdot \frac{w(\lceil\tau\rceil-1)+t}{\hat{w}(\lceil\tau\rceil - 1) + t(k+1)} & \leq \frac{\hat{w}}{w} \cdot \frac{w(\lceil\tau\rceil-1)+w}{\hat{w}(\lceil\tau\rceil - 1) + w(k+1)}\\ & = \frac{\lceil\tau\rceil \hat{w}}{\hat{w}(\lceil\tau\rceil - 1) + w(k+1)}\\ & \leq \frac{\lceil\tau\rceil \hat{w}}{\hat{w}(\lceil\tau\rceil - 1) + \hat{w}(k+1){/2}}\\ & = \frac{\lceil\tau\rceil}{\lceil\tau\rceil + k{/2} {- 1/2}} {\leq \frac{2\lceil\tau\rceil}{\lceil\tau\rceil + k}}, \end{aligned} $$

(5)

where the last inequality follows since $\lceil \tau \rceil + k/2 - 1/2 \geq \frac {1}{2} \left (\lceil \tau \rceil + k\right )$. By merging (3), (4), and (5), we achieve the desired bound. □

The next corollary follows by simple algebraic manipulations from Proposition 2.

Corollary 1

Mechanism ${\mathscr{M}}_{k}$, for 1 ≤ k ≤ n − 2, is ${2}\left (\left \lceil \tau \right \rceil +1\right )$-approximate for $m > \left \lceil \tau \right \rceil ({2}k+\left \lceil \tau \right \rceil )$.

4 The Case of Facility Location

Let us now consider the facility location problem. Here, the type t_i of each agent consists of her position on the real line. The algorithm f must choose a position $z \in \mathbb {R}$ for the facility. The cost that agent i pays for having the facility in position z is 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.,

$$ f^{*}(\textbf{b}) \in \arg\min_{z \in \mathbb{R}} \mathtt{cost}(z, \b), \quad \mathtt{cost}(z, \b) = \sum\limits_{i=1}^{n} b_{i}(z). $$

As above, we say that the mechanism ${\mathscr{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 $\tau = \tau _{k}(n) = \max \limits \left \{1, \frac {n-k-1}{k+1}\right \}$. Observe that τ₀(n) = n − 1 and τ_n− 1(n) = 1. More specifically, τ = 1 for every $k \geq \frac {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 \in \left \{0, \ldots , \left \lceil \frac {n}{2}\right \rceil -2\right \}$. For every α,β, with α < β, no ρ-approximate mechanism ${\mathscr{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 ${\mathscr{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)(β − α).

If f(b) ≤ α, then the total cost is larger than (n − k − 1)(β − α), and thus the approximation ratio of the mechanism would be $\frac {n-k-1}{k+1} = \tau _{k}(n) > \rho$. □

With the same argument one can prove also the following lemma.

Lemma 8

For every α,β, with α < β, no ρ-approximate mechanism ${\mathscr{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 ${\mathscr{M}}$.

Theorem 2

For every ε > 0, there is no $\left (\tau - \varepsilon \right )$-approximate mechanism for the facility location problem that is k-OSP.

Proof

For $k \geq \left \lceil \frac {n}{2}\right \rceil - 1$, we have τ = 1, and thus the claim is obvious.

Suppose then $k \leq \left \lceil \frac {n}{2}\right \rceil - 2$ and let ${\mathscr{M}}=(f,\mathcal {T}, p)$ be a $\left (\tau - \varepsilon \right )$-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 $\delta \leq \frac {(k+1)\varepsilon }{n-2k-2} \cdot \frac {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 ${\mathscr{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 $\mathcal {T}$ at which it diverges. Note that, by definition of divergent agent, there must be two types $t_{i}, t^{\prime }_{i}$ of agent i such that $t^{\prime }_{i} = t_{i} + \delta$ and i takes an action in ${\mathscr{M}}$ when her type is t_i that is different from the action taken when her type is $t^{\prime }_{i}$. We denote as c and d the smallest t_i and the largest $t^{\prime }_{i}$, respectively, for which this occurs, i.e., c is the smallest type in $D^{\prime }$ such that i diverges on c and c + δ, and d is the largest type in $D^{\prime }$ such that i diverges on d and d − δ.

Note that either $c < \frac {b+a}{2}$ or $d > \frac {b+a}{2}$. Indeed, if $c \geq \frac {b+a}{2}$, then $d \geq c+\delta > \frac {b+a}{2}$. In the rest of the proof we will assume that $c < \frac {a+b}{2}$. The proof for the case that $d > \frac {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 ${\mathscr{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 ${\mathscr{M}}$ is k-OSP, we have that

u_i(x) ≥ u_i(y). Hence, it follows that

$$ p_{i}(\textbf{x} ) \geq p_{i}(\textbf{y} ) - d(c+\delta, f(\textbf{y} )) + d(c+\delta, f(\textbf{x} )). $$

(6)

If the real location of i is $t^{\prime }_{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 ${\mathscr{M}}$ is k-OSP, we have that

u_i(y) ≥ u_i(x). Hence, it follows that

$$ p_{i}(\textbf{x} ) \leq p_{i}(\textbf{y} ) - d(c, f(\textbf{y} )) + d(c, f(\textbf{x} )). $$

(7)

Therefore, in order to satisfy both (6) and (7), we need that

$$ d(c+\delta, f(\textbf{y} )) - d(c, f(\textbf{y} )) \geq d(c+\delta, f(\textbf{x} )) - d(c, f(\textbf{x} )). $$

(8)

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.

Let us first show that f(x) ≥ c. Suppose instead that f(x) < c. Since f(x) < c, then the r.h.s. of (8) is δ. As for the l.h.s., we distinguish two cases. If f(y) ≤ c + δ, then, since f(y) > c according to Lemma 7, we have (c + δ − f(y)) − (f(y) − c) = δ − 2(f(y) − c) < δ. If f(y) > c + δ, we have (f(y) − (c + δ)) − (f(y) − c) = −δ. Hence, in both cases we reach a contradiction.

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

$$ (f(\textbf{y} ) - (c+\delta)) - (f(\textbf{y} ) - c) \geq ((c+\delta) - f(\textbf{x} )) - (f(\textbf{x} ) - c) \Rightarrow -\delta \geq \delta - 2 (f(\textbf{x} ) - c). $$

However, this is impossible since f(x) < c + δ.

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 ${\mathscr{M}}$ on input y is

$$ \begin{array}{@{}rcl@{}} && (k+1)(f(\textbf{y} ) - c) + (n-k-1)\left( b - f(\textbf{y} )\right)\\ && \qquad \qquad \qquad \qquad = (n-k-1)b - (k+1)c - (n-2k-2)f(\textbf{y} )\\ && \qquad \qquad \qquad \qquad = (n-k-1)(b-c) - (n-2k-2)(f(\textbf{y} )-c)\\ & &\qquad \qquad \qquad \qquad \geq (n-k-1)(b-c) - (n-2k-2) \delta\\ && \qquad \qquad \qquad \qquad \geq (n-k-1)(b-c) - (n-2k-2) \frac{(k+1)\varepsilon}{n-2k-2} \cdot \frac{b-a}{2}\\ && \qquad \qquad \qquad \qquad > (n-k-1-(k+1)\varepsilon) (b-c), \end{array} $$

where we used that $b-c > b - \frac {b+a}{2} = \frac {b-a}{2}$. However, this is absurd, since ${\mathscr{M}}$ is (τ − ε)-approximate, where $\tau =\frac {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). □

5 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.