# No truthful mechanism can be better than n approximate for two natural problems

This work gives the first natural non-utilitarian problems for which the trivial n approximation via VCG mechanisms is the best possible. That is, no truthful mechanism can be better than n approximate, where n is the number of agents. The problems are the min-max variant of shortest path and (directed) minimum spanning tree mechanism design problems. In these procurement auctions, agents own the edges of a network, and the corresponding edge costs are private. Instead of the total weight of the subnetwork, in the min-max variant we aim to minimize the maximum agent cost.

## Authors

• 7 publications
• 4 publications
• 10 publications
• ### Approximating some network problems with scenarios

In this paper the shortest path and the minimum spanning tree problems i...
06/23/2018 ∙ by Adam Kasperski, et al. ∙ 0

• ### Approximating APSP without Scaling: Equivalence of Approximate Min-Plus and Exact Min-Max

Zwick's (1+ε)-approximation algorithm for the All Pairs Shortest Path (A...
07/25/2019 ∙ by Karl Bringmann, et al. ∙ 0

• ### Sorting Can Exponentially Speed Up Pure Dynamic Programming

Many discrete minimization problems, including various versions of the s...
12/23/2020 ∙ by Stasys Jukna, et al. ∙ 0

• ### Directed Shortest Paths via Approximate Cost Balancing

We present an O(nm) algorithm for all-pairs shortest paths computations ...
07/15/2020 ∙ by James B. Orlin, et al. ∙ 0

• ### On Romeo and Juliet Problems: Minimizing Distance-to-Sight

We introduce a variant of the watchman route problem, which we call the ...
06/03/2019 ∙ by Hee-Kap Ahn, et al. ∙ 0

• ### Monochromatic Triangles, Intermediate Matrix Products, and Convolutions

The most studied linear algebraic operation, matrix multiplication, has ...
09/30/2020 ∙ by Andrea Lincoln, et al. ∙ 0

• ### Approximation Algorithms for Replenishment Problems with Fixed Turnover Times

We introduce and study a class of optimization problems we coin replenis...
12/14/2017 ∙ by Thomas Bosman, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

One of the central issues in algorithmic mechanism design concerns the interplay between optimization and incentives. Roughly speaking, one would like to compute a solution which optimizes a function that depends on some private information held by the agents. In general, agents may find it convenient to misreport this information, and therefore optimization becomes a critical issue. To overcome this problem, one should design a truthful mechanism, that is, a combination of an algorithm and a suitable payment rule such that truth-telling is a dominant strategy for all agents.111Throughout this work we assume the standard quasi-linear utilities, meaning that each agent’s utility is equal to the difference between the payment received and the private cost associated to the chosen outcome.

In their seminal paper, Nisan and Ronen [21] considered how well truthful mechanisms can solve a given optimization problem. They view a mechanism as an abstraction of a “distributed protocol” which involves various self-interested parties (agents), a typical scenario in Internet applications. The protocol is required to optimize some function, but also needs to provide suitable incentives to the agents to make sure that they cannot profit from manipulating the protocol. Consider the following simple problem:

#### Shortest path (auction)[21].

In a communication network, we would like to establish a path between two distinguished nodes having minimal total length (sum of the costs of the links forming this path). Each link of the network is controlled by an entity (agent) who has a private cost for having her link used to connect the two nodes. Without any compensation (payment), agents have an incentive to misreport their own cost (i.e., report a very high cost so that their link is not selected).

Problems like the one above admit a truthful mechanism through the standard VCG construction. This may not always be the case. Indeed, Nisan and Ronen [21] identified two types of optimization problems:

• Utilitarian (min-sum) problems. These are the problems where the goal is to minimize the sum of all agents’ costs.

• Non-utilitarian (min-max) problems. Here the goal is to minimize the maximum cost incurred by the agents, as opposed to the sum.

They showed that, while all utilitarian problems admit an exact mechanism using the standard VCG construction, there are simple and natural non-utilitarian (min-max) problems for which no truthful mechanism can guarantee the optimum. Specifically, they considered the following min-max problem:

#### Unrelated machines scheduling[21].

We have a set of jobs to be scheduled on unrelated machines (agents). Each machine has a type which specifies the processing time (cost) for each of the jobs on this machine. These costs are private (known to machine only), and an allocation of the jobs to machines determines the completion time of that machine (sum of processing times of allocated jobs). The goal is to return an allocation minimizing the makespan, that is, minimizing the maximum cost among all machines.

They showed that even for just two machines, no truthful mechanism can be better than -approximate222Here -approximation means that the mechanism returns an allocation whose makespan is at most times the optimal makespan for the given input (reported costs)., while a trivial -approximation can be obtained via the VCG mechanism,333Their MinWork mechanism is the VCG mechanism minimizing the sum of all agents costs. This implies that every job is allocated to the fastest machine for that job, which turns out to be an -approximation of the optimal makespan. and thus the case of two machines is tight. They conjecture that the trivial upper bound is the correct answer for this problem:

Conjecture (Nisan-Ronen): No truthful mechanism for unrelated machines scheduling can have an approximation ratio that is smaller than .

This quite natural and well studied optimization problem suggests that incentives do have a negative impact on the performance guarantee: Despite being NP-hard, one can compute arbitrarily good approximate solutions in polynomial time. In contrast, no truthful mechanism can be better than -approximate, even for two machines and even if running in exponential time. Unfortunately, the exact efficiency loss is still unclear, as the conjecture above is still open even for three machines, with a large gap between the upper and the lower bound (see related work below):

1. There is a trivial -approximation using the VCG mechanism, while the best known lower bound is only a small constant.

2. The conjecture holds if one makes additional assumptions on the class of mechanisms.

Though the latter result supports the conjecture above (showing that natural mechanisms cannot improve VCG for this problems), the following basic question remains open:

How much is lost because of truthfulness?

Interestingly, similar state of the art holds for analogous non-utilitarian (min-max) problems.

### 1.1 Our contribution

We show that the following very simple and natural problems do not admit any truthful mechanism whose approximation is better than , where is the number of agents:

#### Min-max path.

We are given a weighted graph and two distinguished nodes and , and we would like to find the path connecting them which minimizes the maximum cost over the agents. Here the cost of an agent is equal to the sum of the weights of her selected edges, i.e., her share of the path’s weight. This agent cost is the same as in the shortest path (auction) problem [21] when the agents have several edges.

#### Min-max directed MST.

We are given a directed weighted graph and one distinguished node , and we would like to find the directed spanning tree rooted in which minimizes the maximum cost over the agents, where the cost of an agent is the same as in the previous problem.

We prove the following two negative results about the approximability that truthful mechanisms can achieve for the problems above:

###### Theorem 1.

No truthful mechanism for the min-max path problem can be better than -approximate.

###### Theorem 2.

No truthful mechanism for the min-max directed MST problem can be better than -approximate.

To the best of our knowledge, these are the first examples for which there is a strong separation between truthful approximations and non-truthful ones. Note that these results hold without any additional assumption on the mechanism (including its running time). This gives an unconditional lower bound based solely on truthfulness. A trivial -approximation can be obtained by simply running the VCG mechanism: A shortest path (respectively minimum spanning tree) is an -approximation of the min-max path (respectively, min-max directed MST). Thus is a tight bound for truthful mechanisms in both problems.

The merit of this result is the simplicity of the problem and of the proof. Specifically, in both problems, the agents’ costs for a solution are the same as in the shortest-path problem with agents owning several edges (sum of the costs of chosen edges). In the auction terminology, we are in a simple case of no externalities, meaning that agents care only about the items that they get (which of their edges are chosen). Many of the interesting problems are of this sort, and the main difficulty here is that one cannot invoke Roberts Theorem saying that truthfulness implies that the mechanism must be an affine maximizer (in the VCG family).

As we discuss in the next section, all prior inapproximability results for other non-utilitarian min-max problems either (1) are significantly weaker as only a small constant factor on the inapproximability is known or (2) they only apply to certain classes of mechanisms as they are based on additional assumptions. As we discuss in Section 4, our problems can be thought of as a generalization of the unrelated machines scheduling problem.

### 1.2 Related work

Arguably, the most general mechanism design technique is VCG and its simple generalization known as affine maximizers (“weighted VCG”). Roughly speaking, these mechanisms maximize the weighted social welfare (sum of agents valuations) over a fixed subset of the possible solutions. Equivalently, for problems involving private costs, these mechanisms minimize the weighted social cost (sum of agents costs). These constructions are general in the sense that they require no assumption on the agents’ domain, that is, they can be applied to unrestricted domains.444This is the case where, for a finite set of alternatives or outcomes, each agent has a valuation which can be any function . A famous result by Roberts [22] says that affine maximizers are the only truthful mechanism on unrestricted domains.

For most of the interesting problems, truthful mechanisms other than VCG may still be possible because the problem deals inherently with a restricted domain. A classical example is the no externalities condition in combinatorial auctions which says that the agents valuations depend uniquely on the items they get, and not on who gets the other items. For multi-unit auctions there are truthful non-VCG mechanisms that outperform any VCG mechanism for the same problem [10]. In a one-dimensional or single-parameter setting, valuations are linear in the number of items allocated (the private parameter being the valuation for a single unit). These problems are usually easier and truthfulness is less stringent than in the multi-dimensional case (see e.g. Myerson [20] and Archer and Tardos [1]). Truthfulness can be characterized by a so called monotonicity condition (see e.g., Rochet [23], Bikhchandani et al. [4], Saks and Yu [24]). Intuitively, this is a property of the algorithm (allocation rule) and it prescribes how the allocation of an agent should change if only this agent changes her reported type. In that sense, this condition is local as it focuses on one agent at a time. Lavi et al. [15] presented an alternative proof of Roberts’ theorem using monotonicity (and an extra condition called “player decisiveness”).

All known lower bounds for the unrelated machines scheduling (and others) are based on the above mentioned monotonicity condition. The difficulty in the unrelated machine scheduling problem is that its domain is neither one-dimensional nor unrestricted. The problem becomes interesting already for machines, and the gap between the best upper bound and the best lower bound gets wider as grows. Nisan and Ronen [21] proved that -approximation can be obtained via the VCG mechanism, and that for no mechanism can be better than -approximate. This has triggered a fairly large number of papers that focused on this problem and some variants [8, 13, 2, 19, 6]. Christodoulou et al. [8] showed a lower bound of for machines. Koutsoupias and Vidali [13] proved a lower bound of for arbitrarily many machines (i.e., for ). These are the best known lower bounds for this problem, and stronger lower bounds have been obtained only by making additional assumptions on the mechanism. Specifically, a lower bound of has been obtained under the following various assumptions: Nisan and Ronen [21] considered mechanisms whose payments are additive in the jobs; Mu’alem and Schapira [19] considered strong monotonicity, a stronger condition than the one characterizing truthfulness; Ashlagi et al. [2] focused on anonymous mechanisms, i.e., mechanisms whose allocation does not depend on the names of the agents.

Christodoulou et al. [6] studied the fractional version of the unrelated machines problem. They proved that still there is a lower bound of for this seemingly simpler problem, and obtained a slightly better upper bound of compared to the original problem. Similarly to the original problem, if one makes the additional assumption on the mechanism, namely that the algorithm is task independent555This condition requires that the allocation of a task depends only on the processing times of this task on the machines, and not on the other tasks’ processing times., then a matching lower bound of holds.

Another problem which exhibits a similar structure to the unrelated machines is the inter-domain routing problem by Mu’alem and Shapira [19]. Here, we have a graph whose nodes are the agents, and the solutions are the trees directed towards a destination node; each solution determines the amount of traffic that each of node receives from its neighbors; each node has a per-unit cost for each of the neighbors, and the goal is to minimize the maximum cost among the nodes. Again, we have a multi-dimensional non-utilitarian (min-max) problem for which the best lower bound is a small constant and the best upper bound is using the VCG mechanism [19]. Gamzu [11] proved a lower bound of , which is the best known lower bound for this problem and it also applies to randomized mechanisms.

The only significant improvements on the upper bounds have been obtained for single-parameter or two-values domains. Archer and Tardos [1] showed that, unlike in the unrelated machines, the related machines case admits an exact (exponential time) truthful mechanism, and a constant approximation can be obtained by a randomized polynomial-time truthful mechanism. Christodoulou and Kovács [9] even obtained a polynomial-time deterministic truthful approximation scheme, that is, for any there is a truthful polynomial-time mechanism which computes a -approximate solution. Mu’alem and Shapira [19] observed that the single-parameter version of their inter-domain routing problem also admits an exact truthful mechanism (as opposed to the multi-dimensional version). Lavi and Swamy [16] gave a truthful -approximation mechanism for the unrelated machines restricted to two-values domains, i.e., when the cost of executing a job on a machine can be only “low” or “high”. Their proof uses (in a non-trivial way) the cycle monotonicity condition by Rochet [23]. Yu [26] extended the result to two-range values where the costs belong to two ranges which are “sufficiently far apart”.

Several papers considered the power of randomization for this problem, essentially showing that the situation is not much different. In particular, Mu’alem and Shapira [19] proved a lower bound of , meaning that it is still impossible to achieve exact solutions (note that this is the same lower bound for the fractional version). Lu and Yu [18, 17] gave a randomized mechanism with approximation and , depending on whether we consider universally truthful or truthful in expectation mechanisms. Intuitively, the former is a stronger requirement which says that truth-telling is a dominant strategy, even if agents would know the random bits, while the latter needs agents to care about their expected utility. For a separation result in a subclass of the two-values domains in unrelated machines see Auletta et al. [3]. Like for deterministic mechanisms, the known upper bounds for randomized mechanisms are optimal if one restricts to task-independent mechanisms ( is a lower bound [18]).

Kovács and Vidali [14] studied mechanisms that satisfy strong monotonicity for the unrelated machines scheduling domain. They provide characterizations of mechanisms satisfying also some additional requirements for the case of two jobs. Christodoulou et al. [7] characterized the class of truthful mechanisms for two machines. In both cases, the resulting class is a wider class than VCG/affine minimizers, which suggests that trying to extend Roberts’ theorem to the scheduling domain in order to prove a lower bound might be hopeless. Indeed, only for the case of two jobs and two machines truthful mechanisms coincide with VCG mechanisms/affine minimizers [7].

Chawla et al. [5] and Giannakopoulos and Kyropoulou [12] considered a Bayesian

setting where the agents types are drawn according to a certain probability distribution.

## 2 The two problems and truthfulness

Both problems we consider share the following features:

• We are given a weighted (directed or undirected) graph .

• The edges are partitioned among agents , where each agent owns a subset of edges, and each edge belongs to exactly one agent.

• The cost (weight) of edge is denoted by

 ti(e)

where is the type of agent owning this edge. The type of agent is private knowledge, and each agent can report a possibly different type.

• We have a set of feasible solutions, where each feasible solution consists of a subset of edges. Any feasible solution costs agent the sum of the weights (costs) of her edges included in the solution,

 ti(x)=∑e∈x∩Eiti(e) .
• The goal is to find a feasible solution minimizing the maximum agent cost where , that is, .

We call problems with the above structure graph problems, regardless of the last item (the optimization criteria). The main differences between the two problems we consider are: (i) whether the graph is undirected or not, and (ii) the structure of the set of feasible solutions (i.e., whether a solution corresponds to a path or a tree in ).

###### Definition 3 (min-max path and min-max directed MST).

In the min-max path problem, the graph is undirected, and the set of feasible solutions consists of all paths connecting two given nodes. In the min-max directed minimum spanning tree (MST), the graph is directed, and the feasible solutions consist of all directed trees (i.e., arborescences) connecting a given vertex (the root) to all other nodes (there is a directed path from the root to every other node).

We conclude with the formal definition of a truthful mechanism.

###### Definition 4 (truthful mechanism).

A mechanism is truthful

if truth-telling is a dominant strategy (utility maximizing) for all agents. That is, for any vector

of costs reported by the agents, for any , and for any true cost of agent ,

 Pi(t)−ti(x)≥Pi(~t)−ti(~x),

where , , and .

### 2.1 Implications of truthfulness

In this section, we state the main basic properties that any truthful mechanism must satisfy for our problems.

###### Definition 5 (monotone algorithm).

Algorithm is monotone if, for any , for any , and for any ,

 ti(x)+t′i(x′)≤ti(x′)+t′i(x) (1)

where and .

The following is a well-known result (see e.g., [4, 19]).

###### Proposition 6.

If a mechanism is truthful then is monotone.

From the above property, one can easily derive the following condition that must be satisfied by any truthful mechanism.

###### Lemma 7.

Let be a truthful mechanism for a graph problem. Let be a vector of reported types and let be an agent. For the mechanism selects a subset of the edges owned by . Now consider types in which these edges are less costly, while all non-selected edges of are more costly:

 t′i(e)< ti(e) for e∈Ai(t), (2) t′i(e)> ti(e) for e∉Ai(t). (3)

Then the mechanism must select the same subset of edges of , provided all other agents’ types are unchanged, i.e.,

 Ai(t)=Ai(t′i,t−i). (4)
###### Proof.

Consider the symmetric difference between the edges owned by selected in the two solutions, where and . We shall prove that both and must be empty. If is non-empty, then (2) implies

 ti(S)>t′i(S) . (5)

Similarly, if is non-empty, then (3) implies

 t′i(S′)>ti(S′) . (6)

We thus have if at least one of and is non-empty. This contradicts the monotonicity condition (1), and thus cannot be truthful (creftypecap 6). ∎

### 2.2 Min-max path (Proof of Theorem 1)

We construct a graph chain as follows (see Figure 1). Consider the concatenation of blocks , where each block consists of parallel edges connecting to , one for each agent. We denote by the cost of the edge of agent in block . We shall specify the number of blocks and the costs later in the proof.

We now transform chain into another graph expandedchain in the following way (see Figure 2). In every block , each edge of agent is replaced by a path of edges. Edge belongs to agent and the costs are as follows. Edge owned by has the original cost of , and all the other edges in this path have a tiny cost . We name the resulting graph expandedchain.

###### Lemma 8.

Let be a truthful mechanism, and let and be defined as in Lemma 7. Then, on expandedchain, the algorithm must return the same solution on these two types, i.e.,

 A(t)=A(t′i,t−i).
###### Proof.

We show that and must select the same path in each block of expandedchain. Fix a block and notice that each of the paths contains exactly one edge from agent . By Lemma 7, must also be selected in , which forces the same path in this block to be selected as well (and no other paths are selected because the solution must be a simple path). ∎

#### Proof of Theorem 1.

Suppose all costs are equal to in the chain graph (before the transformation) and consider the corresponding graph expandedchain.

Notice that the algorithm must select exactly one simple path between and . Let denote the number of these paths in expandedchain that contain an edge of cost owned by agent . Without loss of generality, assume

 0≤ℓn≤ℓn−1≤⋯≤ℓ2≤ℓ1

by simply renaming the agents. Then, since all blocks contain one selected path,

 ℓ1≥ℓ/n.

Now iteratively repeat the following transformation on the costs for agents :

• Set the cost of all edges of agent selected in the solution to , and increase by the cost of edges of not in the solution.

By Lemma 8, the solution cannot change and therefore, for the final types , the cost of agent is still at least , thus implying

 cost(A(t∗),t∗)≥ℓ1.

However, the optimum for this instance would be to distribute these paths among the agents, as each of the other paths contributes at most to the cost of the solution:

 opt(t∗)≤⌈ℓ1n⌉(1+ϵ)+2ϵℓ≤(ℓ1n+1)(1+ϵ)+2ϵℓ ,

where the term accounts for the fact that a solution always selects, in each of the blocks, at most one edge of initial cost per agent, and the new cost is at most . By taking this implies

 opt(t∗)≤ℓ1n+ℓ12nℓ+1+12ℓ+1≤ℓ1n+4 .

We thus have

 cost(A(t∗),t∗)opt(t∗)≥n⋅ℓ1ℓ1+4n=n−4n2ℓ1+4n>n−4n2ℓ1≥n−4n3ℓ .

Taking arbitrarily large gives a lower bound of , for any . ∎

## 3 Min-max directed MST (Proof of Theorem 2)

The min-max directed MST problem is similar to the min-max path problem with few differences: (i) We have a weighted directed graph ; (ii) A solution is a directed spanning tree (arborescence) rooted at some distinguished node .

In the proof we start from the same chain of blocks as in the proof of Theorem 1, where edges are now directed from to , but the transformation is slightly different (see Figure 3 for the intuition).

Specifically, the left block consists of parallel edges directed from left to right, each of them belonging to a different agent. The -th parallel edge in each block is then replaced by a path of rightward edges plus leftward edges as follows:

1. The first rightward edge belongs to agent and its cost is the same as the cost in the left graph (parallel edges).

2. The remaining rightward edges belong to agent . This order is the same across all blocks (this will be crucial in the following). All these edges have cost .

3. Each of the previous edges is paired with an edge directed in the opposite direction, also of cost .

The whole construction consists of again a chain of blocks, where block consists of the parallel paths connecting with . The leftmost node in the first block, i.e., , is the root.

###### Definition 9.

For any block and any agent , we define as the unique path of rightward edges, as defined in Items 1-2 above, in which the first edge is owned by agent . We say that the mechanism selects agent in block if is selected.

Note that, in general, it is possible to select more than one agent per block. However, due to the presence of the leftward edges, there exists always a feasible solution that selects only one agent per block.

#### Proof of Theorem 2.

We are now in a position to apply a similar type of analysis as we did in the proof of Theorem 1. Initially all costs are equal to in the directed chain graph (before the transformation). Since the algorithm must select a full path in each block, there must be an agent which has been selected in at least blocks.

Without loss of generality (as this can be guaranteed by simply renaming the agents), we assume . Notice that traverses the edges owned by agents in left-to-right order.

Now we iteratively repeat the following transformation on the costs of agent , where agents are considered in decreasing order from to :

• For the current agent , reduce the cost of all edges of taken in the solution to , and increase the cost of non-selected edges by .

Intuitively, this particular order will ensure that, after each transformation, the mechanism must still select agent in each of the blocks where it was initially selected.

###### Claim 10.

For any block where has been initially selected, the following holds. After the -th step of the above transformation, (that is, at the beginning if or after modifying the edge costs of the edges owned by agent , if ), the mechanism must still select all edges in that belong to agents .

###### Proof.

The proof is by induction on , where the base case is trivial since initially the mechanism has selected all edges in . As for the inductive step, suppose that after the -th step the edge of agent is still selected (inductive hypothesis). The -th step consists of lowering the costs of all edges of agent which are currently selected, while increasing the cost of the edges owned by agent not currently selected. By Lemma 7, the edge of agent in must be selected also after the transformation. Since the feasible solution must be a directed spanning tree, this forces all previous edges in to be selected, i.e., those from agents . That is, the claim holds for . ∎

The above claim shows that, after the last iteration, we still have agent with a cost at least . However, in the modified costs , the optimum is at most

 opt(t∗)≤⌈ℓi∗n⌉(1+ϵ)+4ϵnℓ≤(ℓi∗n+1)(1+ϵ)+4ϵnℓ. (7)

This is so because, in every block where the mechanism initially selected some agent , has cost at most , due to the single edge of whose initial cost was . Moreover, each agent has at most edges of initial cost , and after the transformation this cost is at most . Then, the first inequality in (7) can be obtained by considering the solution in which the blocks selecting are redistributed evenly among all agents.

By taking , (7) implies

 opt(t∗)≤ℓi∗n+ℓi∗4ℓn2+1+14ℓn+1≤ℓi∗n+4 .

The remainder of the proof is identical to that of Theorem 1. ∎

## 4 Conclusion and open questions

It is worth noticing that our problems can be thought of as a generalization of the unrelated machines scheduling. Indeed, by considering the chain graph (see Fig. 1), one can think of each as the cost to process job on machine from the scheduling problem. Any solution for the min-max path problem corresponds to a job scheduling with the same makespan. For the min-max directed MST problem, a similar argument applies since every (directed) tree on this graph is also a path.

An important point in our proofs is the role of the combinatorial structure, in particular how we expand chain into expandedchain. In a nutshell, it allows to control how the solution changes when a single player cost changes (cf Lemma 8 and creftypecap 10 for the two reductions, respectively). In several proofs of lower bound results for unrelated machines scheduling, this is done by assuming extra properties of the mechanism. The lower bound by Mu’alem and Schapira [19] is based on strong monotonicity, which implies that the algorithm is somehow breaking ties among the solutions in a fixed manner.

The following two natural questions are still open:

#### Question 1:

Is it possible to extend our lower bounds to randomized mechanisms?

#### Question 2:

Is it possible to extend the lower bound for min-max directed MST to the undirected case?

We do not know the answer to either question. The main reason is that certain key properties of our reduction seem difficult to obtain. Regarding the first question, randomized mechanisms for min-max path could be studied by looking at the fractional version of the problem, i.e., the one in which we send a unit of flow from the source to the destination (this flow can be divided arbitrarily). Now the monotonicity condition on our reduction does not guarantee anymore that the solution does not change under certain conditions (Lemma 8). Regarding the second question, the monotonicity condition of the min-max directed MST problem is ensured by the direction of the edges and again it is lost in the undirected case (creftypecap 10).

Furthermore, we observe that our reductions use few values and, in fact, they would fall in the class of two-range values studied by Yu [26] for unrelated machines scheduling. Since Yu [26] shows that constant-approximation is indeed possible in this restriction, we obtain a separation between the scheduling problem and our two min-max problems for such restricted domains.

Finally, we remark that the min-max path problem can be approximated efficiently in a non-truthful manner (thus complexity is not an issue). In particular, there exists a polynomial-time approximation scheme666This means that, for every , there exists a polynomial-time -approximation algorithm. for any constant number of agents. This follows easily from a result by Tsaggouris et al. [25] on the multi-objective version of the shortest-path problem (see Appendix A) and it is the same result that holds for scheduling a constant number of unrelated machines. Whether the same holds for the min-max MST is an interesting open question.

## References

• [1] Aaron Archer and Éva Tardos. Truthful mechanisms for one-parameter agents. In Proc. of the 42nd IEEE Symposium on Foundations of Computer Science (FOCS), pages 482–491, 2001.
• [2] Itai Ashlagi, Shahar Dobzinski, and Ron Lavi. Optimal lower bounds for anonymous scheduling mechanisms. Math. Oper. Res., 37(2):244–258, 2012.
• [3] Vincenzo Auletta, George Christodoulou, and Paolo Penna. Mechanisms for scheduling with single-bit private values. Theory of Computing Systems, 57(3):523–548, 2015.
• [4] Sushil Bikhchandani, Shurojit Chatterji, Ron Lavi, Ahuva Mu’alem, Noam Nisan, and Arunava Sen. Weak monotonicity characterizes deterministic dominant-strategy implementation. Econometrica, pages 1109–1132, 2006.
• [5] Shuchi Chawla, Jason D Hartline, David Malec, and Balasubramanian Sivan. Prior-independent mechanisms for scheduling. In Proc. of the 45th annual ACM Symposium on Theory of Computing (STOC), pages 51–60, 2013.
• [6] George Christodoulou, Elias Koutsoupias, and Annamária Kovács. Mechanism design for fractional scheduling on unrelated machines. ACM Trans. Algorithms, 6(2):38:1–38:18, 2010.
• [7] George Christodoulou, Elias Koutsoupias, and Angelina Vidali. A characterization of 2-player mechanisms for scheduling. In Proc. of the 16th Annual European Symposium on Algorithms (ESA), volume 5193 of Lecture Notes in Computer Science, pages 297–307, 2008.
• [8] George Christodoulou, Elias Koutsoupias, and Angelina Vidali. A lower bound for scheduling mechanisms. Algorithmica, 55(4):729–740, 2009.
• [9] George Christodoulou and Annamária Kovács. A deterministic truthful PTAS for scheduling related machines. SIAM Journal on Computing, 42(4):1572–1595, 2013.
• [10] Shahar Dobzinski and Noam Nisan. Multi-unit auctions: Beyond Roberts. Journal of Economic Theory, 156:14–44, 2015.
• [11] Iftah Gamzu. Improved lower bounds for non-utilitarian truthfulness. Theoretical Computer Science, 412(7):626 – 632, 2011.
• [12] Yiannis Giannakopoulos and Maria Kyropoulou. The VCG Mechanism for Bayesian Scheduling. In Proc. of the 11th International Conference on Web and Internet Economics (WINE), pages 343–356, Berlin, Heidelberg, 2015. Springer Berlin Heidelberg.
• [13] Elias Koutsoupias and Angelina Vidali. A lower bound of 1+ for truthful scheduling mechanisms. Algorithmica, 66(1):211–223, 2013.
• [14] Annamária Kovács and Angelina Vidali. A characterization of n-player strongly monotone scheduling mechanisms. In

Proc. of the 24th International Joint Conference on Artificial Intelligence (IJCAI)

, pages 568–574. AAAI Press, 2015.
• [15] Ron Lavi, Ahuva Mu’alem, and Noam Nisan. Two simplified proofs for Roberts’ theorem. Social Choice and Welfare, 32(3):407, 2008.
• [16] Ron Lavi and Chaitanya Swamy. Truthful mechanism design for multidimensional scheduling via cycle monotonicity. Games and Economic Behavior, 1(67):99–124, 2009.
• [17] Pinyan Lu and Changyuan Yu. An improved randomized truthful mechanism for scheduling unrelated machines. In Proc. of the 25th Annual Symposium on Theoretical Aspects of Computer Science (STACS), volume 1 of LIPIcs, pages 527–538. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, Germany, 2008.
• [18] Pinyan Lu and Changyuan Yu. Randomized truthful mechanisms for scheduling unrelated machines. In Proc. of the 4th International Workshop on Internet and Network Economics (WINE), volume 5385 of Lecture Notes in Computer Science, pages 402–413, 2008.
• [19] Ahuva Mu’alem and Michael Schapira. Setting lower bounds on truthfulness. In Proc. of the 18th Annual ACM Symposium on Discrete Algorithms (SODA), pages 1143–1152, 2007.
• [20] Roger B. Myerson. Optimal auction design. Mathematics of Operations Research, 6:58–73, 1981.
• [21] Noam Nisan and Amir Ronen. Algorithmic mechanism design. Games and Economic Behavior, 35(1-2):166–196, 2001.
• [22] Kevin Roberts. Aggregation and revelation of preferences. The Characterization of Implementable Choice Rules, pages 321–348, 1979.
• [23] Jean-Charles Rochet. A necessary and sufficient condition for rationalizability in a quasi-linear context. Journal of Mathematical Economics, 16(2):191–200, 1987.
• [24] Michael Saks and Lan Yu. Weak monotonicity suffices for truthfulness on convex domains. In Proc. of the 6th ACM Conference on Electronic Commerce (EC), pages 286–293. ACM, 2005.
• [25] George Tsaggouris and Christos Zaroliagis. Multiobjective optimization: Improved fptas for shortest paths and non-linear objectives with applications. Theory of Computing Systems, 45(1):162–186, Jun 2009.
• [26] Changyuan Yu. Truthful mechanisms for two-range-values variant of unrelated scheduling. Theoretical Computer Science, 410(21-23):2196–2206, 2009.

## Appendix A Complexity considerations

In this section, we show that the optimization (non-strategic) version of the min-max path problem can be approximated arbitrarily well in polynomial time, for any constant number of agents.

###### Theorem 11.

For any constant number of agents, there exists a polynomial-time approximation scheme (PTAS) for the min-max path problem.

We employ a result by Tsaggouris et al. [25] on the multi-objective version of the shortest path problem. In this version, each edge has associated an -dimensional vector . Each solution has an -dimensional cost vector with being the cost computed with respect to the component of weights ,

 ci(x)=∑e∈xwi(s) .

One can see that our min-max path is a special case of this multi-objective optimization problem: For an edge owned by , consider the vector

 w(e)=(0,…,0,wi(e),0,…,0) with wi(e)=ti(e) (8)

which then implies

 ci(x)=ti(x) .

The set of Pareto solutions consists of all solutions that are not dominated: For every , there is no other solution such that for all , and one of these inequalities being strict.

###### Definition 12 ((1+ϵ)-Pareto set).

The set of -Pareto solutions is a set of solutions such that, for every , there is some in such that for all .

Let be the Pareto solutions and be the -Pareto set. Let and denote the number of nodes and edges in the graph, and be the number of agents as above. Another key parameter is the ratio between the maximum and minimum cost of an edge, i.e.,

 Rw=maxemaxk,lwk(e)/wl(e) .
###### Theorem 13 ([25]).

can be computed in time .

Note that, in the above encoding of our problem (8), is actually unbounded, which makes the above theorem of no use. We shall therefore make a minor modifications of the weights, by setting the minimum weight to some suitably small to be specified below:

 w′i(e)=max(δ,wi(e)) for all i and e . (9)

(In particular, all s of are replaced by which is the minimum weight in the modified vectors.) In order to specify , we make the following observations. Let denote the length of the shortest path (sum of edge costs) for the original edge costs . Let also denote the optimum for the min-max cost for edge costs . Then

 SP(t)n≤OPT(t)≤SP(t). (10)

(See Remark 1 below for a proof.) If then this solution is also the optimum and we are done. Otherwise, we set and remove all edges whose cost , for being the agent owning edge , is larger than . Let be the instance obtained from after this transformation. Now observe the following:

• Any solution that uses some discarded edge would cost at least , so it will not be better than the shortest path.

• Any solution which does not use any discarded edge, has a cost which is close in both edge weightings:

 cost(x,t′)≤cost(x,t)+n⋅δ≤cost(x,t)+ϵOPT(t) ,

where the first inequality is due to the fact that any simple path has at most edges, and we have increased each edge cost by at most ; the second inequality follows from (10) and by our choice of .

In particular, the set of Pareto solutions for the modified weights contains a -approximate solution for the original weights . Since , we can apply Theorem 13 and compute the -Pareto set in polynomial time. Then this set contains a polynomial number fo solutions. The solution in minimizing our cost function is a -approximation for the weights , and thus a -approximation for the original weights . That is, it is a -approximation for the input . Since we can choose arbitrarily small, this yields a PTAS.

## Appendix B Trivial n-approximation via VCG

It is well known that every min-max problem admits a trivial -approximate truthful VCG mechanism (see e.g. Nisan and Ronen [21]). For convenience of the reader, we repeat here this simple folklore argument. Let be the min-max optimum for costs , and being the social cost optimum (sum of agents costs) also with respect to . By writing both these quantities according to the agents shares, we have

 OPT(t)=max(OPT1(t),…,OPTn(t))

where for being the solution minimizing the min-max cost, and

 SC(t)=SC1(t)+⋯+SCn(t)

where for being the solution minimizing the social cost. The solution minimizing the social cost (output by the VCG mechanism) has cost

 cost(x,t)=maxiti(x)=maxiSCi(t) ≤∑iSCi(t) ≤∑iOPTi(t)≤n⋅maxiOPTi(t)

which then implies that is an -approximate solution.

###### Remark 1.

The optimum social cost and the min-max optimum are related according to following two inequalities:

 SC(t)n≤OPT(t)≤SC(t) . (11)

The first one has been proved above. As for the second inequality, simply observe that , where the first inequality is due to the fact that is the optimum for the min-max. For the min-max path problem, is simply the length of the shortest path with respect to edge costs .