On the Nisan-Ronen conjecture for submodular valuations

We consider incentive compatible mechanisms for a domain that is very close to the domain of scheduling n unrelated machines: the single exception is that the valuation of just one machine is submodular. For the scheduling problem with such cost functions, we give a lower bound of Ω(√(n)) on the approximation ratio of incentive compatible deterministic mechanisms. This is a strong information-theoretic impossibility result on the approximation ratio of mechanisms on relatively simple domains. The lower bound of the current work assumes no restriction on the mechanism side, but an expanded class of valuations, in contrast to previous general results on the Nisan-Ronen conjecture that hold for only special classes of mechanisms such as local, strongly monotone, and anonymous mechanisms. Our approach is based on a novel characterization of appropriately selected smaller instances that allows us to focus on particular type of algorithms (linear mechanisms), from which we extract a locality property that gives the lower bound.

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

05/20/2020

A New Lower Bound for Deterministic Truthful Scheduling

We study the problem of truthfully scheduling m tasks to n selfish unrel...
06/04/2018

Mechanism Design without Money for Common Goods

We initiate the study of mechanism design without money for common goods...
11/29/2020

On the Nisan-Ronen conjecture

The Nisan-Ronen conjecture states that no truthful mechanism for makespa...
05/31/2020

Incentive-Compatible Selection Mechanisms for Forests

Given a directed forest-graph, a probabilistic selection mechanism is a ...
05/10/2018

On the approximation guarantee of obviously strategyproof mechanisms

The concept of obviously strategyproof (OSP) mechanisms has the merit to...
03/29/2018

Exploiting Weak Supermodularity for Coalition-Proof Mechanisms

Under the incentive-compatible Vickrey-Clarke-Groves mechanism, coalitio...
09/30/2019

Impartial Selection with Additive Approximation Guarantees

Impartial selection has recently received much attention within the mult...
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

The design of protocols that provide appropriate incentives to participants, entice them to cooperate, and behave in a way which is socially beneficial has a long and celebrated history. It is the realm of mechanism design which is one of the most researched branches of Game Theory and Microeconomics. It studies the design of algorithms, called

mechanisms, and it has numerous applications to many situations in modern societies, whenever a protocol of conduct of selfish participants is required. The mechanism asks each participant to bid their preferences over the different social outcomes, and implements one of them (e.g. the one which is most socially beneficial). The challenge is that the preferences of the participants are private, and they are either unmotivated to report correctly, or strongly motivated to report them erroneously, if a false report is profitable. A truthful mechanism provides incentives in a way that it is in the best interest of each participant to bid truthfully.

The algorithmic nature of mechanism design and the associated computational issues, were brought to light, in the seminal 20-year-old paper by Nisan and Ronen [31], which essentially established the area of algorithmic mechanism design. They proposed the scheduling problem on unrelated machines, a fundamental, extensively studied from the algorithmic perspective, optimization problem as a representative specimen to study the limitations of truthful mechanisms. The objective is to incentivize machines to execute tasks, so that the maximum completion time of the machines, i.e. the makespan, is minimized.

Nisan and Ronen applied the famous Vickrey-Clarke-Groves (VCG) mechanism [33, 12, 21] which is a general machinery that truthfully computes the outcome that maximizes the social welfare, which for the case of scheduling is the allocation that minimizes the sum of completion times. The VCG is truthful and polynomial-time for scheduling, but with respect to the makespan minimization it has a rather poor approximation ratio, equal to the number of machines . Despite this, they conjectured that the VCG is the mechanism with the best approximation ratio for this problem.

Conjecture 1.

There is no deterministic truthful mechanism with approximation ratio better than for the problem of scheduling unrelated machines.

The bound in the conjecture is information-theoretic, in the sense that it should hold for all mechanisms (algorithms), polynomial-time or not. The Nisan-Ronen conjecture developed into one of the central problems in Algorithmic Game Theory, and despite intensive efforts only very sparse progress has been made towards its resolution. The original Nisan-Ronen paper showed that no truthful deterministic mechanism can achieve an approximation ratio better than . This was improved to  [10], and later to [23], which leaves a huge gap with the known upper bound of . The most general and interesting result, by Ashlagi et al.[3], resolved a restricted version of the conjecture, for the special yet natural class of anonymous mechanisms. However, the original conjecture (for non-anonymous mechanisms) is widely open.

The original conjecture was posed for the case of additive valuations, where the total cost of each machine equals the sum of its individual costs of each task. However, many mechanism design settings consider more general valuations such as submodular, subadditive etc. In these valuations, the cost of a machine that takes a set of tasks is a function of that satisfies some natural properties. For example, for subadditive valuations the cost of a bundle of tasks can be any value bounded above by the sum of the cost of the individual tasks in . This extended domain may affect significantly the incentive compatibility aspect of mechanisms because it allows a machine to also lie about the cost of bundles of tasks.

It is natural to pose the Nisan-Ronen question for these extended valuation classes. Despite the importance of the problem and various attempts, the conjecture has been widely open for all of them. In this work, we consider submodular cost functions, where the marginal contribution of a task to the total cost of a machine is a non-increasing function. The class of submodular valuations contains all additive valuations, it is a proper subject of subadditive valuations, and it is one of the most restrictive natural valuations for the scheduling question. Furthermore it is the most-studied class of valuations for the corresponding maximization problem of combinatorial auctions (see for example [25, 18, 15]).

1.1 Our result

We give the first non-constant lower bound that works for all deterministic truthful mechanisms when the cost functions are submodular.

Theorem 1.

There is no deterministic truthful mechanism with approximation ratio better than for the problem of scheduling unrelated machines with submodular cost functions.

Actually we show a stronger result: Let be the class of scheduling mechanisms which are deterministic and truthful when all machines are additive except for one machine, which is submodular. Then no mechanism in has an approximation ratio better than on the set of instances of scheduling unrelated additive machines.

The lower bound of the current work assumes no restriction on the mechanism side, but an expanded class of valuations. In contrast, the Nisan-Ronen conjecture has been shown to hold for only special classes of mechanisms (local [31], strongly monotone [30], and anonymous [3] mechanisms).

Other valuation classes:

Actually we don’t anticipate any difficulty in translating, in fact carbon-copying, our results to supermodular valuations; we will include the details in the final version of the paper. Interestingly, the class of additive valuations of the original Nisan-Ronen conjecture is exactly the intersection of submodular and supermodular valuations.

In fact, we provide a stronger version of our theorem by considering submodular functions which are also -additive, in the sense that the execution time of a set of tasks is within an arbitrarily small from the sum of the execution times of its tasks (see Section 2 for a precise definition). An important feature of our lower bound construction is that the cost functions of all machines are additive with the single exception of one machine which is submodular for particular disjoint pairs of tasks.

1.2 Overview of the techniques

We provide an overview of our approach for the lower bound. We consider instances in which every task has a fixed large value, practically infinite, for all except for two machines; one of the two machines is always the submodular player (player ). We can assume that these tasks are allocated to one of the two machines, otherwise the approximation ratio is sufficiently high. This restriction of the allocation to only two players per task, have been previously used (e.g. [10, 23]). The main difference with previous approaches is that we use properties of mechanisms that involve at least three players, the submodular player and two other players. Obtaining such multiplayer statements is the bottleneck for a complete characterization of mechanisms in multiplayer domains.

Two-player characterization.

We first focus on the tasks that can be allocated to a particular additive player and fix the values of the remaining tasks. For each additive player, there are only two such tasks, and the situation is very similar to two-player and two-task special case in which the valuation of one player is submodular. A core part of our proof, which is also of independent interest, is a characterization of the allocation functions of all truthful mechanisms for this case.

We provide a complete characterization for the case of two players with submodular valuations which are non-negative and are bounded above by a constant. This is essential in our construction to guarantee that the fixed large value of the other machines does not play any role. Since this is a minimization problem, it is the lower bound (i.e., the restriction that the values are non-negative) that creates complications rather then the upper bound on the domain. We also provide a characterization for additive valuations, the actual scheduling domain.

We note that similar two-player characterizations have been provided by previous work [17, 9], for auctions and scheduling domains, but none of these can be used in our approach. In particular, the characterization of [17] for scheduling relies extensively on the bounded approximation for two players, but we need a characterization without this assumption. The reason is that the approximation ratio of any two players is in general unrelated to the approximation ratio of the whole multi-player instance. In the same work, a characterization for auctions with subadditive valuations is provided, but this is also of no use to the minimization we consider here. Finally, the characterization of [9] cannot be used because it allows negative values.

Indeed, as we show in Section 3, the scheduling domain admits truthful mechanisms not present in the previous characterizations of [17, 9], which we call relaxed affine minimizers. Such mechanisms are essentially affine minimizers for large values, but they can have non-linear boundaries for small values (see Definition 5 and Figure 2).

Gluing two-player mechanisms to multi-player linear mechanisms.

From the characterization of two-payer two-task mechanisms and using the fact that we are interested in mechanisms with small approximation ratio for the whole multi-player instances, we are able to exclude all mechanisms except of those that have affine boundaries (Lemma 3), that is, affine minimizers whose coefficients may depend on the values of the other tasks.

One of the main technical steps is that we use the truthfulness of the submodular player to show that the scaling coefficient of these linear mechanisms do not actually depend on the values of the other tasks (Lemma 4). The rest of the proof, which includes the most complicated technical steps of this work, is to analyze the properties of truthful linear algorithms that facilitate the proof of the lower bound (Lemma 6).

1.3 Related work

The problem of scheduling unrelated machines is a typical multi-dimensional mechanism design problem. In multi-dimensional mechanism design, the valuation of each player for different outcomes is expressed via a vector (one value for every outcome). In the case of unrelated scheduling, this vector expresses the processing times of a machine for each subset of tasks and can be succinctly represented by an

-valued vector, one value for each task.

An interesting special case, which is well-understood, is the single-dimensional mechanism design in which the values of the vector are linear expressions of a single parameter. The principal representative is the problem of scheduling related machines, where the cost of each machine can be expressed via a single parameter, its speed. This was first studied by Archer and Tardos [2] who showed that, in contrast to the unrelated machines version, an algorithm that minimizes the makespan can be truthfully implemented — albeit in exponential time. It was subsequently shown that truthfulness has essentially no impact on the computational complexity of the problem. Specifically, a randomized truthful-in-expectation111This is one of the two main definitions of truthfulness for randomized mechanisms, where truth-telling maximizes the expected utility of each player. PTAS was given in [14] and a deterministic PTAS was given in [11]; a PTAS is the best possible algorithm even for the pure algorithmic problem (unless ).

The main obstacle in resolving the Nisan-Ronen conjecture is the lack of clear algorithmic understanding of truthfulness for many players in multi-dimensional domains. In contrast, we understand better truthfulness for a single player. Saks and Yu [32] gave a nice, complete characterization of deterministic truthful mechanisms for convex domains which was later extended to truthful-in-expectation randomized mechanisms in [1]. This characterization states that the class of allocations of truthful mechanisms is the class of weakly monotone algorithms [5]. This is an elegant characterization, but it has not been proved very useful for mechanisms of many players, because it is difficult to combine monotonicity of each individual player into a single global condition. Its direct applications have provided only constant bounds for makespan minimization [10, 30, 23, 31]. What would be more useful is a characterization similar to the one provided by the seminal work of Roberts [22] for unrestricted domains. It essentially states that the only truthful mechanisms are affine extensions of VCG. Similar characterizations have been provided in [9, 17, 16] for settings with only two players. Extending these characterizations to multiple players for scheduling and combinatorial auctions is notoriously hard, mainly due to lack of externalities in these settings: the valuation of a player for an allocation depends only on the subset of tasks it receives and is indifferent on how the remaining of the tasks are assigned to the other players222For two players, there exist implicit externalities as the tasks one player doesn’t get determine what the other player gets..

Scheduling is related to combinatorial auctions, where multiple items need to be assigned to a set of buyers. This is a broad and successful area, and the setting shares both aforementioned features of multi-dimensionality and lack of externalities, therefore insights and techniques can be transferred from the one problem to the other. However the difference is that the objective for combinatorial auctions is social welfare maximization, and this is known to be achieved by the VCG mechanism, albeit in exponential time. Hence the focus on this rich area is on what can be achieved by computationally efficient mechanisms (see for example [18]). But in the case of the scheduling with the min-max objective, the flavor is more information theoretic, as we know that not even exponential time mechanisms can achieve the optimal makespan.

1.3.1 Further related work

Lavi and Swamy [24] proposed an interesting approach to attack the Nisan-Ronen question, by restricting the input domain, but still keep the multi-dimensional flavour of the setting. They assumed that each entry in the input matrix can take only two possible values “low” and “high”, that are publicly known to the designer. In this case, they showed an elegant deterministic mechanism with an approximation factor of 2. Surprisingly, even for this special case there is a lower bound of . Yu [34] extended the results for a range of values, and Auletta et al.  [4] studied multi-dimensional domains where the private information of the machines is a single bit.

Randomization has been explored and slightly improved the known guarantees. There are two notions of truthfulness for randomized mechanisms. A mechanism is universally truthful

if it is defined as a probability distribution over deterministic truthful mechanisms, while it is

truthful-in-expectation, if in expectation no player can benefit by lying. In [31], a universally truthful mechanism was proposed for the case of two machines, and was later extended to the case of machines by Mu’alem and Schapira [30] with an approximation guarantee of , which was later improved to by [28]. Lu and Yu [29] showed a truthful-in-expectation mechanism with an approximation guarantee of . Mu’alem and Schapira [30], showed a lower bound of , for both notions of randomization. Christodoulou, Koutsoupias and Kovács [8] extended the lower bound for fractional mechanisms, where each task can be fractionally allocated to multiple machines. They also showed a fractional mechanism with a guarantee of . A sequence of papers studied randomized mechanisms for the special case of two machines [27, 29] where a tight answer on the approximation factor is still unresolved. Currently, the best upper bound is due to Chen, Du, and Zuluaga [7].

The truthful implementation of other objectives have been explored by Mu’alem and Schapira [30] for multi-dimensional problems and by Epstein and van Stee [19] for single-dimensional ones, giving a PTAS for a wide range of objective functions. Leucci, Mamageishvili and Penna [26]

showed high lower bounds for other min-max objectives on some combinatorial optimization problems. In the Bayesian setting, Daskalakis and Weinberg

[13] showed a mechanism that is at most a factor of 2 from the optimal truthful mechanism, but not with respect to optimal makespan. Chawla et al. [6] provided bounds of prior-independent mechanisms (where the input comes from a probability unknown to the mechanism). Giannakopoulos and Kyropoulou [20] showed that the VCG mechanism achieves an approximation ratio of under some distributional and symmetry assumptions.

2 Preliminaries

There is a set of machines and a set of tasks that need to be scheduled on the machines. The processing time or cost that each machine takes to process a subset of tasks is described by a set function . In classic unrelated machines scheduling, the cost functions are additive and the objective is to minimize the makespan (min-max objective).

We also consider more general cost functions that are normalized and monotone ( for ). We focus on submodular cost functions, which satisfy the following condition for every

In the classical Nisan-Ronen model, the cost functions are additive. In our lower bound construction, we will assume that all cost functions are additive except for one which is submodular. We also consider valuations which are arbitrarily close to additive, which we call -additive, such that for every subset , Our results hold for valuations that are both submodular and -additive—even for valuations within an multiplicative factor from additive.

Mechanism design setting.

We assume that each machine is controlled by a selfish agent that is reluctant to process the tasks and the cost function is private information known only to her (also called the type of agent ). In the most general version of the problem, the set of possible types of agent consists of all vectors Let also be the space of type profiles.

A mechanism defines for each player a set of available strategies, the player (agent) can choose from. We will consider direct revelation mechanisms, i.e., for all meaning that the players strategies are to simply report their types to the mechanism. A player may report a false cost function , if this serves her interests.

A mechanism consists of two parts:

An allocation algorithm:

The allocation algorithm allocates the jobs to the machines depending on the players’ bids . Let be the set of all possible partitions of tasks to machines. The allocation function partitions the tasks into the machines; we denote by the subset of tasks assigned to machine in the bid profile .

A payment scheme:

The payment scheme determines the payments also depending on the bid values The functions stand for the payments that the mechanism hands to each agent i.e. .

The utility of a player is the payment that he gets minus the actual time that he needs to process the set of tasks assigned to her, . We are interested in truthful mechanisms. A mechanism is truthful, if for every player, reporting his true type is a dominant strategy. Formally,

where denotes the possible types of all players disregarding

We use as an objective to evaluate the performance of a mechanism’s allocation algorithm the makespan, that is the maximum completion time of a machine. The makespan of the allocation algorithm with respect to a given input is

We aim at minimizing the makespan, hence the optimum is

We are interested in the approximation ratio of the mechanism’s allocation algorithm. A mechanism is -approximate, if the allocation algorithm is -approximate, that is, if for all possible inputs

We are looking for truthful mechanisms with low approximation ratio irrespective of the running time to compute and In other words, our lower bounds do not make use of any computational assumptions.

Weak monotonicity.

A useful characterization of truthful mechanisms in terms of the following monotonicity condition, helps us to get rid of the payments and focus on the properties of the allocation algorithm.

Definition 1.

An allocation algorithm is called weakly monotone (WMON) if it satisfies the following property: for every two inputs and , the associated allocations and satisfy

It is well known that the allocation function of every truthful mechanism is WMON [5], and also that this is a sufficient condition for truthfulness in convex domains [32].

A useful tool in our proof relies on the following immediate consequence of WMON, which holds in additive domains as well as in the other domains that we consider. Intuitively, it states that when you fix the values of all players for a subset of tasks (focus on a cut of your domain), then the restriction of the allocation to the rest of the tasks must remain weakly monotone.

Lemma 1.

Let be a WMON allocation. Let us fix an partition of , and consider only valuations of player that are additive across and , i.e., for every , . Then the restriction of the allocation on is weakly monotone for each valuation fixed on the subsets of

Proof.

is weakly monotone, therefore

and additivity across and implies

as the values of subsets of are fixed, and .

The following lemma was essentially shown in [31] and has been a useful tool to show lower bounds for truthful mechanisms for several variants (see for example [10, 30, 3]). Although this holds more generally, we only state it (and use it in Section 4) for additive valuations.

Lemma 2.

Let be a bid vector of additive valuations, and let be the subset assigned to player by the mechanism. For any bid vector such that only the bid of machine has changed and in such a way that for every task in it has decreased (i.e., ) and for every other task it has increased (i.e., ). Then the mechanism does not change the allocation to machine , i.e., .

The main challenge in multi-player settings is that the allocation of the other machines may change and the above condition makes no promise about how this can happen.

3 Characterization for two players

A core element of our lower bound proof is a characterization of truthful mechanisms for two tasks and two players (called -player, and -player). We first provide a characterization for additive valuations , and , so that both and are bounded by an arbitrarily large but fixed value Then we extend it when the player has submodular valuations (Theorem 2), which is the main element that we need in the lower bound in Section 4. We note that both the characterization and the lower bound result hold analogously when the -player has arbitrary monotone, or -additive (or submodular and -additive) valuations.

We postpone the details of the characterization proof to the Appendix, but in this section we introduce the definitions that we will need in order to state the main result and also to introduce some notation which will be used in our lower bound proof in Section 4. We keep in the Appendix intact the whole proof of the characterization.

3.1 Basic Definitions

Let be a truthful mechanism, where is the WMON allocation function, and denotes the payment function. For input the allocation is Since we have only tasks 1 and 2, in we can denote the allocation to one of the players as

For given the allocation for the -player as function of his own bids (or ) is denoted by and symmetrically is an allocation function for the -player. For the allocation regions (resp. ) of are defined to be the interior (wrt. ) of the set of all values such that For the -player we denote the respective regions by

Figure 1: The allocation to the -player depending on his own bid vector
(a) quasi-bundling allocation; (b) quasi-flipping allocation; (c) crossing allocation. The interiors of some regions might be empty, but can be assumed w.l.o.g. We marked the functions of critical values (Definition 7) for receiving task by broken lines.
Additive players

It is known that in the case of two tasks, the regions in a WMON allocation subdivide basically in three possible forms, which are characteristic for the type of the whole allocation-function (see Figure 1). The regions and their boundaries determine the critical values for (as function of ) above which the -player cannot get task 1, and symmetrically for task 2. These critical value functions are determined by the payment functions for the fixed

Definition 2.

For given we call the allocation

  • quasi-bundling, if there are at least two points on the boundary of and

  • quasi-flipping, if there are at least two points on the boundary of and

  • crossing otherwise (see Figure 1).

3.2 Mechanisms for submodular players

We now introduce the types of WMON allocations that can occur when the -player is submodular and the -player is additive and bounded above by the value . We denote these particular domains for two players and two tasks by and refer the reader to the appendix Section A for detailed definitions, and also for extension of our results to other domains. We assume that there always exist high enough values so that the -player receives no task, i.e., that for every 333This assumption is without loss of generality for mechanisms with finite approximation of the makespan, even if some 2D cut mechanism of a WMON mechanism with more tasks and/or players is considered.

1-dimensional mechanisms

In a one-dimensional mechanism at most two possible allocations are ever realized. Due to the assumption on one of these must be the allocation to the -player. If the two occuring allocations (for the -player) are and we call the mechanism bundling mechanism. The other cases when the allocations to the -player are and (or and ) are degenerate task-independent allocations, and can be defined similarly to bundling mechanisms.

Definition 3.

In a bundling mechanism only the allocations and can occur. There is an arbitrary, increasing444Throughout the paper, by ’increasing’ we mean ’non-decreasing’; otherwise we say ’strictly increasing’. function so that if then the -player gets and if then the -player gets

If

has a jump discontinuity in some point

then the critical value may depend on the concrete with the given fixed sum, as long as it is between and

Relaxed affine minimizers
Definition 4.

An allocation is an affine minimizer, if there exist positive constants per player and and constants per allocation (say, here ), so that for every input the allocation minimizes over

Definition 5.

An allocation is a relaxed affine minimizer, if there exist positive constants per player and and constants per allocation (of the -player), furthermore an arbitrary increasing function (if the interval is nonempty) with , so that for every input

  • if the allocation is that of an affine minimizer with the given constants

  • if then if then the allocation for the -player is and if then it is

The boundary conditions in the above definition are such that the affine minimizer part (a) fits with the bundling mechanism part (b) and the resulting mechanism is truthful. See Figure 2, for an example of such a mechanism in the additive domain.

Figure 2: An example of a relaxed affine minimizer, which shows the allocation of the -player. The solid lines show the boundaries of the allocations for values of the -player when . The dashed lines show the allocation boundary when . Sometimes we refer to this part of relaxed affine minimizers as “bundling tail”.
Constant mechanisms

In a constant mechanism the allocation is independent of the bids of at least one of the players. This property can also be interpreted as being an affine minimizer with multiplicative constant Due to the assumption on we only need to consider constant mechanisms that are independent (at least) of the -player.

3.3 The main characterization result

The characterization that we use for the lower bound is captured by the following theorem, whose proof can be found in the Appendix.

Theorem 2.

Every WMON allocation for two tasks and two players with bids and , where both tasks are always allocated, and for every is one of these three types: (1) relaxed affine minimizer, (2) one-dimensional mechanism, or (3) constant mechanism.

In the Appendix we show that the same characterization (and hence our lower bound) holds for WMON allocations for various domains of valuations of the -player and in particular for submodular valuations which are arbitrarily close to additive, which we denote by .

4 Lower Bound

In this section, we give a proof of our main theorem (Theorem 1). First in Section 4.1 we describe the domain of instances that we use, and in Section 4.2 we use the characterization for two machines and two tasks (Theorem 2) to establish that the only interesting mechanisms are linear (see the subsection for a precise definition), then in Section 4.3 we explore the linearity property of mechanisms with bounded approximation ratio to establish some useful locality lemmas that are eventually used in Section 4.4 to complete the proof.

4.1 The construction

To prove the lower bound, we focus on the domain of tasks and players. Player is special and for convenience we use the symbol for its values; sometimes we refer to it as the -player. We use the symbol for the values of the remaining players , and sometimes we refer to them as the -players.

The set of tasks is partitioned in pairs and each pair is associated with player , . We call the two tasks of each pair twin tasks.

Let denote the cost (valuation) of player when it takes the subset of tasks.

  • the cost of the -players is additive: is additive for .

  • the cost of the -players for tasks not in their associated pair is a sufficiently large fixed constant : for distinct , .

  • the cost of the -player for twin tasks is submodular: for every , the restriction of to is submodular.

  • the cost of the -player is additive across pairs: . Therefore is submodular, as the sum of submodular functions.

To simplify the notation we will denote an instance that satisfies the above conditions by

(1)

where

  • and the cost of -th -player for the tasks in its associated pair

  • and the cost of the -player when it takes only one of the twin tasks

  • the cost of the -player when it takes both twin tasks

With the exception of costs an instance is captured by the following matrix indexed by players and tasks, which shows the cost of each when a player gets no other task.

If the valuations of all players were additive, this matrix would be sufficient to determine the cost for all bundles. The instances we consider have more general cost functions and include the submodular valuation of twin tasks for the -player. Since for two tasks, a function is submodular if and only if it is subadditive, values satisfy

It is useful to think of the value as practically infinite, since it is much larger that the other values. On the other hand, to prove our main theorem in its generality, we need this value to be finite and this complicates the characterization of truthful mechanisms.

We focus on instances that satisfy , , , for all . Note the subtlety here: while the domain contains instances with , for the proof of the lower bound, we consider the subclass of additive instances. This should not be surprising in the sense that lower bound proofs usually employ a subclass of instances. Still, it raises the question whether we could carry out the same proof in the additive domain. The answer is negative, because the sets of mechanisms for additive and submodular (subadditive) domains for two tasks are different; for example, task-independent mechanisms are not truthful for submodular domains.

Definition 6 (Restricted instance).

Instances of the form (Equation 1) that satisfy

for all , (2)

will be called restricted instances.

Note that, unlike the other values, the values can be arbitrarily high. This will be useful later (Lemma 3). Note also that the optimum makespan of every restricted instance is at most 1. For these instances, any algorithm with approximation ratio less than , must allocate all the tasks to the -player and every task either to the associated -player or the -player.

4.2 From affine minimizers for twin tasks to linear mechanisms

In this section, we use the characterization of mechanisms (Theorem 2) for each pair of twin tasks in an instance , to derive an essential property of mechanisms for the restricted instances. By the characterization, there are mechanisms of twin tasks, such as the one-dimensional, constant, or bundling tails of relaxed affine minimizers, that may have non-affine boundaries between different allocations. In this section, we show that mechanisms with non-affine boundaries are also excluded, when we additionally require that the mechanisms have small approximation ratio—on whole instances, not just on a pair of twin tasks.

First we define the notion of boundaries that we consider in proof of the lower bound.

Definition 7.

For a given allocation algorithm, considered on restricted instances, we call a critical value or boundary if the -player receives task when and does not receive task when (for example in Figure 1, is shown with dashed lines).

We claim below that a truthful allocation with a reasonable approximation ratio (say, of at most ) for the restricted instances satisfies the following important property:

Definition 8 (Linear mechanisms).

An allocation algorithm for the restricted instances (Equation 2), is called linear if the critical values for task , are truncated affine functions in . In particular when

for some . We call a mechanism linear, if it uses a linear allocation algorithm.

Lemma 3.

A mechanism for the instances (Equation 1) with approximation ratio less than must be linear for the restricted instances.

Proof.

By Lemma 1, the restriction of the mechanism for the twin tasks , is weakly monotone, and therefore by the characterization theorem (Theorem 2), it is either a relaxed affine minimizer, a one-dimensional, or a constant mechanism. We will show that if the approximation ratio is less than , the mechanism cannot be one-dimensional, constant, or even relaxed affine minimizer with a bundling tail. The reason is that algorithms in all these cases are so inefficient that their makespan only for these two tasks is large enough to show a large approximation ratio for the entire instance.

Let’s first argue that it cannot be a one-dimensional or a constant mechanism. We fix all values of the other tasks as in restricted instances. By Lemma B.3.6, there are values for the twin tasks , for which the algorithm has makespan and approximation ratio at least . Since the optimal makespan of the other tasks of a restricted instance is at most , the approximation ratio is at least .

As a result, the restriction to twin tasks , is a relaxed affine minimizer. We now argue that there should be no bundling part of the relaxed affine minimizer when the approximation ratio is less than . Let us fix the values , for all , and the values , for all . We observe that the restriction of the mechanism in the cut (the 2-dimensional partition when we also fix all other values except and ) should definitely contain an area where the -player gets task but not (in particular, when , for some arbitrarily small , and is very large). Otherwise the mechanism has approximation ratio at least .

This shows that in the domain of restricted instances, the mechanisms with approximation ratio less than are affine minimizers in every cut of pairs of twin tasks (even if in general, that is, for they are relaxed affine minimizers). Therefore, the only mechanisms with approximation ratio less than are linear for the restricted instances. ∎

4.3 Linearity

From now on we focus on linear truthful mechanisms for restricted instances. Establishing linearity of the boundaries (Lemma 3) is not directly useful, because the linear coefficient of the boundary may depend on the other values of . The next lemma shows that this is not the case for the scaling factor , although the term may still depend on the other values of . Its proof is based on the interaction of pairs of tasks and . Note that these are not twin tasks but involve at least three players, the -player and the two associated -players. Obtaining such multiplayer statements is the bottleneck for a complete characterization of mechanisms in multiplayer domains, and it is perhaps the most crucial part of the proof.

Lemma 4.

For fixed and , and for fixed , , assume that is a truncated linear function of , i.e., , for some . Then is the same for all that satisfy .

Proof.

To keep the notation simple, we drop all values except for and . Let be the interval of interest. Note first that when we increase , the interval of interest can only expand, because is non-decreasing in .

Within interval , function is positive and therefore equal to . Furthermore, weak monotonicity implies that as a function of , is a piecewise linear function with derivative (slope) in (see for example, Figure 1).

The piecewise linear function is differentiable555It is not hard to see that if is differentiable then so are and ; alternatively, one could use small differences instead of derivatives. everywhere except perhaps of the at most two break points. We have

If , then by varying , the slope cannot stay in . We conclude that in each piece, which shows that is independent of within each piece and therefore independent of everywhere. ∎

The following corollary is an essential tool for establishing the lower bound.

Corollary 1.

The constant parts of the piecewise linear function , as a function of , are independent of , for .

Proof.

We fix all values except for tasks and . By the previous lemma, when we change , the boundary is translated rectilinearly and therefore its break points remain the same. Since the constant parts of are determined by the break points of , they also remain the same. See Figure 3 for an illustration. ∎

Corollary 2.

The piecewise linear function is either non-decreasing in or non-decreasing in .

Proof.

When we fix all other values and consider the cut, it is either quasi-flipping or crossing, in which case is non-decreasing in , or quasi-bundling, in which case 2D geometry shows that it is non-decreasing in (when decreases the diagonal part shifts downwards, and the rectilinear parts remain fixed). See Figure 3 for an illustration.

Figure 3: Consider the dashed lines that show and (these functions may depend on other values but they play no role and we can ingore them). The regular lines show and , for some . Notice that linearity implies that is a shift to the right of ; in particular, the break point stay at the same height. As a consequence, the blue horizontal parts remain at the same height and the blue diagonal part shifts to the right. Therefore .

4.4 The main theorem

We now have most of the ingredients to prove next theorem which directly implies the main lower bound Theorem 1).

Theorem 3.

The approximation ratio of linear truthful algorithms on restricted instances (Equation 2) with machines is at least .

To prove this theorem, we fix some linear truthful algorithm and we focus on a particular set of instances, which we call -inefficient. The set of -inefficient instances depends on the linear algorithm and each instance consists of two types of tasks: either a task is unimportant (i.e., it has very small value for one of the machines), or its value is significantly higher than its value, yet the algorithm allocates the task to the -player.

Definition 9 (-inefficient instances).

Let’s call a task trivial when either or , for some fixed (sufficiently small) . We call a restricted instance -inefficient for a mechanism, if it contains at least one non-trivial task, every non-trivial task satisfies , and the mechanism allocates all non-trivial tasks to the -player.

The heart of the proof is to show that if the set of -inefficient instances is non-empty, there exists an -inefficient instance with exactly one non-trivial task. From this, it immediately follows that the algorithm has approximation ratio at least .

However, it may be that for a given linear truthful algorithm there are no -inefficient instances. But then we can use weak monotonicity to easily derive a lower bound on the approximation ratio as the following lemma shows.

Lemma 5.

If for a given truthful algorithm the set of -inefficient instances is empty, then its approximation ratio is at least .

Proof.

Towards a contradiction, consider an algorithm that has approximation ratio , for some , for which the set of -inefficient instances is empty. We consider the instance with and , for all .

(3)

Note that at least one task is allocated to the -players, because if all tasks are assigned to the -player, the makespan is , the optimum makespan is , and the approximation ratio is strictly greater than .

Now for every task which is allocated to the -player, we lower its value from to some small value in and increase the value of every other task to . By weak monotonicity (Lemma 2), the allocation of the tasks for the -player remains the same. Since at least one task is allocated to the -players, we end up with an -inefficient instance, a contradiction. ∎

The proof of the next lemma (Lemma 6), which provides a very useful property of linear mechanisms, is the most critical part of the proof. It shows that linear weakly monotone algorithms satisfy a locality property, that bears some resemblance to the locality property in [31]. But unlike [31], our proof does not assume this property, but it derives it from weak monotonicity for the special class of instances that we consider.

Lemma 6.

If for a given linear truthful algorithm the set of -inefficient instances is non-empty, then there is an -inefficient instance with exactly one non-trivial task.

Proof.

Fix a linear truthful algorithm and consider an -inefficient instance with the minimum number of non-trivial tasks. If the number of non-trivial tasks is at least two, let us assume without loss of generality that tasks and are non-trivial. We will derive a contradiction by reducing the number of non-trivial tasks.

Consider the boundary function of the first task, , for some positive . The crux of the matter is that we can reduce the value of to or to at most , and guarantee that the -player will keep not getting the second task. This guarantees that the second task is non-trivial and is given to the -player, while the first task becomes trivial.

If as a function of is non-decreasing (i.e., the cut is quasi-flipping or crossing), we set . Since is non-decreasing in (Corollary 2), in the new instance the second task is still allocated to the -player (Figure 4).

Figure 4: When the cut is quasiflipping and neither task is given to the -player in the allocation for , then the second task is still not allocated to the -player in the allocation for .

Otherwise (i.e., the cut is quasi-bundling), by Corollary 1, function is non-decreasing in . In this case, we change the instance as follows (see Figures 5 for an illustration of the first two cases):

  1. if , we set and ,

  2. otherwise, if , we set and , small enough to make task trivial,

  3. and if , we set and , small enough to make task trivial.

In the first two cases, we lower the value to until either becomes (case a), or becomes and then we set (case b). The third case is when is already .

In all cases, the first task becomes a trivial task with the new values. Furthermore, in all cases the new value of is not greater than the original value: . This is clearly true in the first and third case. To see that this is true in the second case, observe that the boundary , which is a non-decreasing function on , moved from a positive value to .

We now argue that the second task is still given to the -player after the change. The argument is based on Corollary 1, which guarantees that the changes can only shift the boundary rectilinearly: in Figure 5, the slanted part moves only horizontally.

For case (a), by Corollary 1, the boundary did not increase and therefore the second task is still given to the -player (left part of Figure 5). For the other two cases, this is not sufficient because changed and therefore changed as well. For case (b), the change shifts the slanted boundary (right part of Figure 5). In its new position, it crosses the boundary of the positive orthant at which is dominated by the point . Therefore, the -player gets neither task, and shows that the -player gets the second task. Case (c) is simpler and similar to the second one; the difference is that the boundary starts at the leftmost position and it does not move at all (in the right part of Figure 5, the solid and dashed lines coincide and they may closer to the beginning of axes).

Figure 5: Left side case (a), when decreases to : the boundary is lower than the boundary . Both tasks are still allocated to the -player. Right side case (b), when the decreases to and changes to . The new remains in the region in which both tasks are allocated to the -player.

The change of values of the first task did not change the allocation of the second task, but it may have changed the allocation of the remaining non-trivial tasks. But we can use weak monotonicity to further change the instance to obtain an -inefficient instance. If some non-trivial tasks changed allocation and were given to the player, we reduce their values to . This will make them trivial tasks and, by weak monotonicity (Lemma 2), preserve the allocation of the first player for the other non-trivial tasks666Strictly speaking, to guarantee that the allocation remains the same for the non-trivial tasks, we need to increase slightly their value. This is possible without violating the constraint , which shows that the resulting instance is also -inefficient.. The resulting instance is -inefficient and has fewer non-trivial tasks, a contradiction. ∎

The proof of the main result of this section follows directly from the last two lemmas.

Proof of Theorem 3.

By the last two lemmas, either a linear truthful algorithm has approximation ratio at least , or there exists an -inefficient instance with one non-trivial task. The approximation ratio of such an instance is trivially at least , and the proof is complete. ∎

References

  • [1] Aaron Archer and Robert Kleinberg. Truthful germs are contagious: A local to global characterization of truthfulness. In ACM Conference on Electronic Commerce (EC), 2008.
  • [2] 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.
  • [3] Itai Ashlagi, Shahar Dobzinski, and Ron Lavi. Optimal lower bounds for anonymous scheduling mechanisms. Mathematics of Operations Research, 37(2):244–258, 2012.
  • [4] Vincenzo Auletta, George Christodoulou, and Paolo Penna. Mechanisms for scheduling with single-bit private values. Theory Comput. Syst., 57(3):523–548, 2015.
  • [5] S. Bikhchandani, S. Chatterji, R. Lavi, A. Mu’alem, N. Nisan, and A. Sen. Weak monotonicity characterizes deterministic dominant strategy implementation. Econometrica, 74(4):1109–1132, 2006.
  • [6] Shuchi Chawla, Jason D. Hartline, David L. Malec, and Balasubramanian Sivan. Prior-independent mechanisms for scheduling. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors,

    Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013

    , pages 51–60. ACM, 2013.
  • [7] Xujin Chen, Donglei Du, and Luis Fernando Zuluaga. Copula-based randomized mechanisms for truthful scheduling on two unrelated machines. Theory Comput. Syst., 57(3):753–781, 2015.
  • [8] George Christodoulou, Elias Koutsoupias, and Annamária Kovács. Mechanism design for fractional scheduling on unrelated machines. ACM Transactions on Algorithms, 6(2), 2010.
  • [9] George Christodoulou, Elias Koutsoupias, and Angelina Vidali. A characterization of 2-player mechanisms for scheduling. In Algorithms - ESA 2008, 16th Annual European Symposium, Karlsruhe, Germany, September 15-17, 2008. Proceedings, pages 297–307, 2008.
  • [10] George Christodoulou, Elias Koutsoupias, and Angelina Vidali. A lower bound for scheduling mechanisms. Algorithmica, 55(4):729–740, 2009.
  • [11] George Christodoulou and Annamária Kovács. A deterministic truthful ptas for scheduling related machines. SIAM J. Comput., 42(4):1572–1595, 2013.
  • [12] Edward H. Clarke. Multipart pricing of public goods. Public Choice, 8, 1971.
  • [13] Constantinos Daskalakis and S. Matthew Weinberg. Bayesian truthful mechanisms for job scheduling from bi-criterion approximation algorithms. In Piotr Indyk, editor, SODA, pages 1934–1952. SIAM, 2015.
  • [14] Peerapong Dhangwatnotai, Shahar Dobzinski, Shaddin Dughmi, and Tim Roughgarden. Truthful approximation schemes for single-parameter agents. SIAM J. on Computing, 40(3):915–933, 2011.
  • [15] Shahar Dobzinski. Breaking the logarithmic barrier for truthful combinatorial auctions with submodular bidders. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, Cambridge, MA, USA, June 18-21, 2016, pages 940–948, 2016.
  • [16] Shahar Dobzinski and Noam Nisan. Multi-unit auctions: Beyond roberts. J. Economic Theory, 156:14–44, 2015.
  • [17] Shahar Dobzinski and Mukund Sundararajan. On characterizations of truthful mechanisms for combinatorial auctions and scheduling. In Proceedings 9th ACM Conference on Electronic Commerce (EC-2008), Chicago, IL, USA, June 8-12, 2008, pages 38–47, 2008.
  • [18] Shahar Dobzinski and Jan Vondrák. Impossibility results for truthful combinatorial auctions with submodular valuations. J. ACM, 63(1):5:1–5:19, 2016.
  • [19] Leah Epstein, Asaf Levin, and Rob van Stee. A unified approach to truthful scheduling on related machines. In Proc. of the Twenty-Fourth Annual ACM-SIAM Symposium on Discrete Algorithm (SODA), pages 1243–1252, 2013.
  • [20] Yiannis Giannakopoulos and Maria Kyropoulou. The VCG mechanism for bayesian scheduling. ACM Trans. Economics and Comput., 5(4):19:1–19:16, 2017.
  • [21] Theodore Groves. Incentives in teams. Econometrica, 41(4):617–631, 1973.