Truthful Mechanisms for Delivery with Mobile Agents

TL;DR

This paper introduces truthful mechanisms for selecting and routing mobile agents to deliver multiple items efficiently, ensuring agents reveal private energy costs and achieve near-optimal total energy consumption.

Contribution

It presents three novel truthful mechanisms that guarantee voluntary participation and approximate the optimal energy use in delivery tasks with private agent costs.

Findings

Mechanisms are truthful and ensure voluntary participation.

Approximate the optimal energy consumption within a constant factor.

Payments can be bounded in terms of the optimum for certain single-package cases.

Abstract

We study the game-theoretic task of selecting mobile agents to deliver multiple items on a network. An instance is given by $m$ messages (physical objects) which have to be transported between specified source-target pairs in a weighted undirected graph, and $k$ mobile heterogeneous agents, each being able to transport one message at a time. Following a recent model by [B\"artschi et al. 2016], each agent $i$ consumes energy proportional to the distance it travels in the graph, where the different rates of energy consumption are given by weight factors $w_i$. We are interested in optimizing or approximating the total energy consumption over all selected agents. Unlike previous research, we assume the weights to be private values known only to the respective agents. We present three different mechanisms which select, route and pay the agents in a truthful way that guarantees voluntary participation of the agents, while approximating the optimum energy consumption by a constant factor. To this end we analyze a previous structural result and an approximation algorithm given by [B\"artschi et al. 2017]. Finally, we show that for some instances in the case of a single package, the sum of the payments can be bounded in terms of the optimum.

Equations

$$P_i(w^{\prime })=Q_i(w_{-i}^{\prime })-\left({\sum }_{j\ne i}{w}_j^{\prime }\cdot d_j(A(w^{\prime }))\right).$$

$$Q_i(w_{-i}^{\prime }):=\text{textsc}cost(A(\perp ,w_{-i}^{\prime }),w_{-i}^{\prime })$$

$$Q_i(w_{-i}^{\prime })-\left(\sum _{j\ne i}{w}_j^{\prime }\cdot d_j(A(w^{\prime }))\right)-w_i\cdot d_i(A(w^{\prime }))=Q_i(w_{-i}^{\prime })-\text{textsc}cost(A(w^{\prime }),(w_i,w_{-i}^{\prime }))$$

$$=\text{textsc}cost(A(\perp ,w_{-i}^{\prime }),w_{-i}^{\prime })-\text{textsc}cost(A(w^{\prime }),(w_i,w_{-i}^{\prime })).$$

$$x_0:=A_{pos}(w^{\prime }),\text{ and }\forall i=1,\dots ,k:x_{-i}:=A_{pos}(\perp ,w_{-i}^{\prime }).$$

$$A^{\ast }(w^{\prime }):=\underset{x\in R_{A^{\ast }}}{\mathrm{argmin}}\{\text{textsc}cost(x,w^{\prime })\}.$$

$$\text{textsc}cost(A^{\ast }(w^{\prime }),w^{\prime })$$

$$Q_i(w_{-i}^{\prime })-\left(\sum _{j\ne i}{w}_j^{\prime }\cdot d_j(A^{\ast }(w^{\prime }))\right)-w_i\cdot d_i(A^{\ast }(w^{\prime }))=Q_i(w_{-i}^{\prime })-\text{textsc}cost(A^{\ast }(w^{\prime }),(w_i,w_{-i}^{\prime }))$$

$$=\text{textsc}cost(A_{pos}(\perp ,w_{-i}^{\prime }),w_{-i}^{\prime })-\text{textsc}cost(A^{\ast }(w^{\prime }),(w_i^{\prime },w_{-i}^{\prime }))\stackrel{\text{eqref}new}{\ge }0.\text{qed}$$

$$d_i(x)=$$

$$A^m(w^{\prime }):=\underset{x\in R_{A^m}}{\mathrm{argmin}}\{\text{textsc}cost(x,w^{\prime })\}.$$

$$A^k(w^{\prime }):=\underset{x\in R_{A^k}}{\mathrm{argmin}}\{\text{textsc}cost(x,w^{\prime })\}.$$

$$\text{textsc}cost(S^{\prime },w^{\prime })=\sum _{i=1}^k{w}_i^{\prime }\cdot d_i(S^{\prime })$$

$$OPT=\text{textsc}cost(A_{opt}(w^{\prime }),w^{\prime }),$$

$$LOPT=\text{textsc}cost(A_{lon}(w^{\prime }),w^{\prime }),$$

$$P_i(w^{\prime })$$

$$OP{T}_{-i}\le OPT+w_i{d}_i.$$

Full text

Unlike previous research, we assume the weights to be private values known only to the respective agents. We present three different mechanisms which select, route and pay the agents in a truthful way that guarantees voluntary participation of the agents, while approximating the optimum energy consumption by a constant factor. To this end, we analyze a previous structural result and an approximation algorithm given in [6]. Finally, we show that for some instances in the case of a single package, the sum of the payments can be bounded in terms of the optimum.

1 Introduction

We study the delivery of physical objects (henceforth called packages) by mobile agents. Regardless of whether large volumes are transported by motor lorries or cargo airplanes, or whether autonomous drones deliver your groceries, the fuel or battery consumption of the transporting agent is a major cost factor. The main concern for algorithm-design thus focuses on an energy-efficient operation of these agents. The primary energy expense is defined by the movements of the agents; in this paper we consider the energy consumption to be proportional to the distance traveled by an agent. We assume the agents to be heterogeneous in the sense of the agents having different rates of energy consumption.

Recent progress in minimizing the total energy consumption in delivery problems has been made assuming that the agents belong to the same entity which wants to deliver the packages [6]. It has been shown that there is a polynomial-time constant-factor approximation algorithm with the ratio depending on the energy consumption rates.

In the following, however, we assume the agents to be independent selfish agents which make a bid to transport packages. Think for instance of a cargo company that hires subcontractors (like independent lorry drivers or individual couriers) to outsource the delivery of packages to these agents. In this scenario, the rate of energy consumption is a private value known only to the respective agent. Our goal is hence to design a mechanism for the cargo company to select agents, plan the agents’ routes and reimburse them in a way such that:

the energy spent overall is as close to the optimum as possible, 2. 2.

each agent announces its true rate of energy consumption in its bid, and 3. 3.

each agent is reimbursed at least the cost of energy it needs to deliver all of its packages.

Our model.

We are given a connected, undirected graph $G=(V,E)$ on $n:=|V|$ nodes with the length of each edge, together with $m$ packages, each of which is given by a specified source-target node pair $(s_{j},t_{j})$. Furthermore there are $k>1$ mobile agents initially located at distinct nodes of the graph. Each agent $i$ starts at position $p_{i}$ and can carry at most one package at a time. An agent can pick up a package at some node $u$ and drop the package again at some other node $v$. In that sense it is also possible to hand over a package $j$ between agents if agent $a$ drops it at a node where another agent $b$ later picks up the same package, in which case we say that the agents collaborate on package $j$. A scenario in which each package $j$ is delivered from its source $s_{j}$ to its target $t_{j}$ is called a feasible solution of the delivery problem. Such a feasible solution $x$ specifies the travel distance $d_{i}(x)$ that each agent $i$ has to travel in this solution.

Each agent consumes energy proportional to the distance it travels in the graph, and we are interested in optimizing the total energy consumption for the team of agents. Specifically, we consider heterogeneous agents with different rates of energy consumption (weights $w_{i}$), and therefore the energy spent by agent $i$ in solution $x$ is $w_{i}\cdot d_{i}(x)$, while the total energy of a solution is (see e.g., Figures 1,2): $\textsc{cost}(x,w):=\sum_{i=1}^{k}w_{i}\cdot d_{i}(x)$, where $w=(w_{1},\ldots,w_{k})$. We denote by Opt a solution with minimum cost among all solutions, $\textsc{Opt}\in\operatorname*{arg\,min}_{x}\textsc{cost}(x,w)$. It is natural to consider the scenario in which every agent is selfish and therefore cares only about its own cost (energy) and not about the optimum social cost (total energy).

Mechanism design.

We consider the scenario in which agents can cheat or speculate about their costs: each $w_{i}$ is private piece of information known to agent $i$ who can report a possibly different $w_{i}^{\prime}$. For instance, an agent may find it convenient to report a very high cost, in order to induce the underlying algorithm to assign a shorter travel distance to it (which may not be globally optimal). To deal with such situations, we introduce suitable compensations for the agents to incentivize them to truthfully report their costs. This combination of an algorithm and a payment rule is called a mechanism, and we are interested in the following:

• •

Optimality. The mechanism runs some (nearly) optimal algorithm such that, if agents do not misreport, the computed solution has an optimal (or nearly optimal) social cost $\textsc{cost}(x,w)$ with respect to the true weights $w$.

• •

Truthfulness. For every agent, truth-telling is a dominant strategy, i.e., in no circumstance it is beneficial for an agent to misreport its cost. Thus, independently of the other agents, its utility (payment minus incurred cost) is maximized when reporting the true cost.

• •

Frugality. The total payment to the agents should be nearly optimal, that is, comparable to the total energy cost. Since agents should be payed at least their own cost when truthfully reporting (voluntary participation), the mechanism must pay at least $\textsc{cost}(x,w)$.

Intuitively speaking, we are paying the agents to make sure that they reveal their true costs, and, in this way, we can find a (nearly) optimal solution (w.r.t. the sum of weighted travel distances). At the same time, we want to minimize our total payments, i.e., we would like not to spend much more than the actual cost (weighted travel distance) of the solution.

Our results.

After some preliminaries on mechanism design and on energy-efficient delivery in Section 2, we first investigate in Section 3.1 the constant-factor $\left(4\cdot\max\smash{\tfrac{w_{i}}{w_{j}}}\right)$-approximation algorithm presented in [6]. We reason why this algorithm cannot be turned into a mechanism that is both truthful and guarantees voluntary participation. However, using the algorithm as a black box for a new algorithm $A^{*}$ and applying Clarke’s pivot rule for the payments to the agents, we give a truthful mechanism based on $A^{*}$ which guarantees voluntary participation and incurs a total energy of at most $\left(4\cdot\max\smash{\tfrac{w_{i}}{w_{j}}}\right)$ times the energy cost of an optimal delivery.

In Section 3.2, we consider instances where either the number of packages $m$ is constant or the number of agents $k$ is constant. For both cases we provide constant-factor approximation algorithms with approximation factors that are independent of the agents’ weights. Both of these approximation algorithms satisfy sufficient conditions to be turned into truthful mechanisms with voluntary participation. The running time of the former algorithm can be improved to yield a $\mathit{FPT}$-approximation mechanism, parametrized by the number of packages; the latter runs in exponential time with $k$ as the base of the exponential term.

Finally, in Section 4, we discuss the frugality of mechanisms for the case of a single package. In particular, we consider two truthful mechanisms, namely, the optimal one (which possibly uses several agents), and the one which always uses a single agent only. Although the latter results in a higher energy cost, it might need a smaller sum of payments. However, under some assumptions on the input, the payments of both mechanisms are only a small multiplicative factor larger than the minimum necessary (the cost of the optimum).

Related work.

Energy-efficient delivery has not been studied until recently. Most previous results are based on a model where the agents have uniform rates of energy-consumption but limited battery [8]. This restricts the possible movements of the agents – one gets the decision problem of whether the given packages can be delivered without exceeding the available battery levels. This turns out to be $\mathrm{NP}$-hard even for a single package [9, 4] and even if energy can be exchanged between the agents [11]. The model of unbounded battery but heterogeneous weights has been introduced recently [6] (for the full version see [5]). Besides the mentioned approximation algorithm, it was shown that a restricted solution in which each package is delivered by a single agent approximates an optimum delivery (in which agents can handover a package to another agent) by a factor of at most $2$. This result has been named the Benefit of Collaboration. Furthermore, the problem is $\mathrm{NP}$-hard to approximate to within a small constant, even for a single agent.

Approximating the maximum travel distance of $k$ agents has been studied for other tasks such as visiting a set of given arcs [17], or visiting all nodes of a tree [16]. Furthermore Demaine et al. [12] studied fixed-parameter tractability for minimizing both the sum of as well as the maximum travel distance of agents for several tasks such as pattern formation, parametrized by the number of agents $k$. These models consider only unweighted agents.

The problem of performing some collaborative task using selfish agents is well studied in algorithmic game theory and, in particular, in algorithmic mechanism design [21] where the system pays the agents in order to make sure that they report their costs truthfully. The existence of computationally feasible truthful mechanisms is one of the central questions, as truthfulness is often obtained by running an exact algorithm [22]. In addition, even for simple problems, like shortest path, the mechanism may have to pay a lot to the agents [14, 3]. Network flow problems have been studied for the case when selfish agents own edges of the network and the mechanism pays them in order to deliver packages [1, 19]. A setting where the transported packages are selfish entities which choose from fixed-route transportation providers was recently studied in [15]. In a sense, this is the reverse setting of our problem.

2 Preliminaries

Mechanisms.

A mechanism is a pair $(A,P)$ where $A$ is an algorithm and $P$ a payment scheme which, for a given vector $w^{\prime}=(w_{1}^{\prime},\ldots,w_{k}^{\prime})$ of costs reported by the agents, computes a solution $A(w^{\prime})$ and a payment $P_{i}(w^{\prime})$ for each agent $i$.

Definition 1** (Truthful mechanism).**

A mechanism $(A,P)$ is truthful if truth-telling is a dominant strategy (utility maximizing) for all agents. That is, for any vector $w^{\prime}=(w_{1}^{\prime},\ldots,w_{k}^{\prime})$ of costs reported by the agents, for any $i$, and for any true cost $w_{i}$ of agent $i$, $P_{i}(w^{\prime})-w_{i}\cdot d_{i}(A(w^{\prime}))\leq P_{i}(w_{i},w^{\prime}_{-i})-w_{i}\cdot d_{i}(A(w_{i},w^{\prime}_{-i}))$, where $d_{i}(x)$ is the travel distance of agent $i$ in solution $x$, and where $w^{\prime}_{-i}:=(w_{1}^{\prime},\ldots,w^{\prime}_{i-1},w^{\prime}_{i+1},\ldots,w_{k}^{\prime})$ and $(w_{i},w^{\prime}_{-i}):=(w_{1}^{\prime},\ldots,w^{\prime}_{i-1},w_{i},w^{\prime}_{i+1},\ldots,w_{k}^{\prime})$.

Truthfulness can be achieved through a construction known as VCG mechanisms [27, 10, 18], which requires that the underlying algorithm satisfies certain ‘optimality’ conditions:

Definition 2** (VCG-based mechanism).**

A VCG-based mechanism is a pair $(A,P)$ of the following form: For any vector $w^{\prime}=(w_{1}^{\prime},\ldots,w_{k}^{\prime})$ of costs reported by the agents, and for each agent $i$, there is a function $Q_{i}()$ independent of $w_{i}^{\prime}$ such that $i$ is payed an amount of

[TABLE]

Intuitively speaking, these mechanisms turn out to be truthful, whenever the underlying algorithm minimizes the social cost with respect to a fixed subset of solutions (in particular, an optimal algorithm always yields a truthful mechanism):

Theorem 1** (Proposition 3.1 in [22]).**

A VCG-based mechanism $(A,P)$ is truthful if algorithm $A$ minimizes the social cost over a fixed subset $R_{A}$ of solutions. That is, there exists $R_{A}$ such that, for every $w^{\prime}$, $A(w^{\prime})\in\operatorname*{arg\,min}_{x\in R_{A}}\{\textsc{cost}(x,w^{\prime})\}$.

The above result is a simple rewriting of the one in [22] which is originally stated for a more general setting, in which agent $i$ valuates a solution $x$ by an amount $v_{i}(x)$, and $v_{i}()$ is the private information. Our setting is the special case in which these valuations are all of the form $v_{i}(x)=-w_{i}\cdot d_{i}(x)$ and $w_{i}$ is the private information (this setting is also called one-parameter [2]).

Definition 3** (Voluntary participation).**

A mechanism $(A,P)$ satisfies the voluntary participation condition if truth-telling agents have always a nonnegative utility. That is, for every $w^{\prime}=(w_{1}^{\prime},\ldots,w_{k}^{\prime})$, and for every agent $i$, $P_{i}(w^{\prime})-w_{i}^{\prime}\cdot d_{i}(A(w^{\prime}))\geq 0$.

We assume there are at least two agents (otherwise the problem is trivial and there is no point in doing mechanism design; also one can easily show that voluntary participation and truthfulness cannot be achieved in this case). Voluntary participation can be obtained by the standard Clarke pivot rule, setting in the payments (1) the functions $Q_{i}()$ as follows:

[TABLE]

where $(\bot,w^{\prime}_{-i})$ is the instance in which agent $i$ is not present. Note that, if algorithm $A$ runs in polynomial time, then the payments can also be computed in polynomial time: we only need to recompute $k$ solutions using $A$ and their costs. The next is a well-known result:

Fact 1**.**

The VCG-based mechanism $(A,P)$ with the payments in (2) satisfies voluntary participation if the algorithm satisfies the following condition: For any vector $w^{\prime}$ and for any agent $i$, $\textsc{cost}(A(\bot,w^{\prime}_{-i}),w^{\prime})\geq\textsc{cost}(A(w^{\prime}),w^{\prime})$.

Proof.

Observe that the utility of agent $i$ is

[TABLE]

When $i$ is truth-telling we have $w_{i}^{\prime}=w_{i}$, and $w^{\prime}=(w_{i},w_{-i}^{\prime})$. Also, $\textsc{cost}(A(\bot,w_{-i}^{\prime}),w_{-i}^{\prime})=\textsc{cost}(A(\bot,w_{-i}^{\prime}),w^{\prime})$ because $i$ is not present in solution $A(\bot,w_{-i}^{\prime})$. Hence the utility of $i$ is $\textsc{cost}(A(\bot,w^{\prime}_{-i}),w^{\prime})-\textsc{cost}(A(w^{\prime}),w^{\prime})$, which is non-negative by assumption. ∎

Definition 4** (Approximation mechanism).**

A mechanism $(A,P)$ is a $c-$approximation mechanism, if for every input vector of bids $w^{\prime}$ its algorithm $A$ computes a solution $A(w^{\prime})$ which is a $c-$approximation of a best solution $\textsc{Opt}(w^{\prime})$, i.e., $\textsc{cost}(A(w^{\prime}),w^{\prime})\leq c\cdot\textsc{cost}(\textsc{Opt}(w^{\prime}),w^{\prime})$.

Collaboration of agents.

To describe a solution for an instance of the delivery problem, we can (among other characteristics) elaborate on the following properties of the solution: How do agents work together on each package (collaboration), how are agents assigned to packages (coordination) and which route does each agent take (planning). Most of the mechanisms in this paper are based on the characterizations of the benefit of collaboration:

Definition 5** (Benefit of collaboration).**

Define $R_{\mathrm{noC}}$ as the set of solutions $x$ in which there is no collaboration of the agents, meaning that each package is delivered by a single agent only. Define $R^{\star}_{\mathrm{noC}}\subset R_{\mathrm{noC}}$ as the subset of solutions $x\in R_{\mathrm{noC}}$ in which (i) every package is transported directly from source to target without intermediate dropoffs, and (ii) every agent returns to its respective starting location. The ratios $\textsc{BoC}:=\smash{\min\limits_{x\in R_{\mathrm{noC}}}\tfrac{\textsc{cost}(x,w)}{\textsc{cost}(\textsc{Opt},w)}}$ and $\textsc{BoC}^{*}:=\smash{\min\limits_{x\in R^{\star}_{\mathrm{noC}}}\tfrac{\textsc{cost}(x,w)}{\textsc{cost}(\textsc{Opt},w)}}$ are called benefit of collaboration.

Theorem 2** (Theorems 5, 6 & 7 in [6]).**

For the the benefit of collaboration we have $\textsc{BoC}\leq 1/\ln 2$ for a single package ($m=1$, for a tight lower bound example see Fig. 1), and $\textsc{BoC}\leq\textsc{BoC}^{*}\leq 2$ in general ($m\geq 1$, see for example Fig. 2).

3 Truthful Approximation Mechanisms

In this section, we present two polynomial-time truthful mechanisms. Note that energy-efficient delivery is $\mathrm{NP}$-hard to approximate to within any constant approximation ratio less than 367/366 [6, Theorem 9]. Hence, even in the best case, our goal can only be to guarantee a constant-factor approximation of the optimum in a truthful way.

In the first part we present a polynomial-time truthful approximation mechanism with a constant-factor approximation guarantee depending on the weights of the agents. In the second part we turn to absolute constant-factor approximation, for which we require the number of packages $m$ to be constant in order to get a polynomial-time mechanism. Similar techniques yield a mechanism running in exponential time for a constant number of agents $k$.

Main algorithmic issue.

The two truthful polynomial-time approximation mechanisms we obtain are based on the following scheme (and the third approximation mechanism follows the same scheme but takes exponential time):

Precompute a feasible subset $R$ of solutions independently of the input weights $w^{\prime}$. This set may depend on the name/index and on the position of the agents. 2. 2.

Among all precomputed solutions in $R$, return the best solution with respect to the input weights $w^{\prime}$, that is, a solution $x^{*}\in\operatorname*{arg\,min}_{x\in R}\{\textsc{cost}(x,w^{\prime})\}$.

Truthfulness then follows directly by Theorem 1. Note that, since we want polynomial running time, the first step selects a polynomial number of solutions (thus the second step is also polynomial). The main crux here is to make sure that, for all possible input weights $w^{\prime}$, the set $R$ contains at least one good approximation (a solution $x\in R$ whose cost for $w^{\prime}$ is at most a constant factor above the optimum for $w^{\prime}$).

3.1 A polynomial-time approximation mechanism

We start with the general setting of arbitrarily many packages $m$ and arbitrarily many agents $k$. Our construction of a truthful approximation mechanism $(A^{*},P)$ for this setting relies on Theorem 1. To this end, we define a fixed subset of solutions $R_{A^{*}}$ and a polynomial-time algorithm $A^{*}$, such that for every vector of reported weights $w^{\prime}$, the algorithm $A^{*}$ computes a solution $S$ of optimum cost among all solutions in $R_{A^{*}}$, $S\in\operatorname*{arg\,min}_{x\in R_{A^{*}}}\textsc{cost}(x,w^{\prime})$.

In a next step, we show that whenever the agents report truthfully ($w^{\prime}=w$), the computed solution $x\in R_{A^{*}}$ has an energy cost that approximates the overall optimum energy cost by a constant factor of at most $4\cdot\tfrac{w_{\max}}{w_{\min}}$, where $w_{\max}:=\max_{i}{w_{i}}$ and $w_{\min}:=\min_{i}{w_{i}}$.

A first approach.

We first analyze an existing approximation algorithm $A_{pos}$ presented in [6], which computes a solution depending only on the position of the agents, but not on their reported costs. Roughly speaking, $A_{pos}$ connects the agent positions and the package sources and targets by a minimum spanning forest, subject to the following: In each tree, there is (i) an edge between the corresponding source/target nodes $s_{j},t_{j}$ and (ii) exactly one agent position $p_{i}$. All edge lengths correspond to the distances in the original instance. Agent $i$ then traverses its tree in a DFS-like fashion, crossing each edge twice and thus delivering all packages in the tree. For an example of such a solution, see Figure 3 (left).

Theorem 3** (Theorem 13 in [6]).**

For any number of packages $m$ and agents $k$, there exists a polynomial-time algorithm $A_{pos}$ which computes a $\left(\smash{4\cdot\frac{w_{\max}}{w_{\min}}}\right)$-approximation. The computed solution does not depend on the input weights $w$, only on the position of the agents.

However, there is no mechanism $(A_{pos},P)$ which is both truthful and guarantees voluntary participation: Assume for the sake of contradiction there is such a mechanism. To guarantee voluntary participation we need the payments to satisfy $P_{i}(w^{\prime})-w_{i}\cdot d_{i}(A_{pos}(w^{\prime}))\geq 0$ for each agent $i$. Consider any agent $i$ which is used in the solution, i.e., $\smash{d_{i}(A_{pos}(w_{i},w_{-i}^{\prime}))>0}$. Note that $A_{pos}$ selected $i$ independent of its weight $w_{i}$, hence $d_{i}$ remains the same for all reported weights $w_{i}^{\prime}$, i.e., we have $d_{i}:=d_{i}(A_{pos}(w_{i},w_{-i}^{\prime}))=d_{i}(A_{pos}(w_{i}^{\prime},w_{-i}^{\prime}))$. Let $P_{i}(w_{i},w_{-i}^{\prime})$ denote the payment to agent $i$ when she reports her true weight $w_{i}$. Now consider a situation where agent $i$ reports a different value $w_{i}^{\prime}>P_{i}(w_{i},w_{-i}^{\prime})/d_{i}$ instead: For voluntary participation of agent $i$, the payment $P_{i}(w^{\prime})$ needs to satisfy $P_{i}(w^{\prime})-w_{i}^{\prime}\cdot d_{i}\geq 0\Leftrightarrow P_{i}(w^{\prime})\geq w_{i}^{\prime}\cdot d_{i}$, but $w_{i}^{\prime}\cdot d_{i}>P_{i}(w_{i},w_{-i}^{\prime})$, contradicting the truthfulness of the mechanism (in other words: reporting an arbitrary high weight results in an arbitrary high payment).

Refining the approach.

In order to obtain a truthful mechanism with voluntary participation we consider the algorithm $A^{*}$ obtained from $A_{pos}$ and a repeated application of algorithm $A_{pos}$ on all subsets of $(k-1)$ agents (for feasibility recall that $G$ is connected and that $k>1$).

Theorem 4**.**

There exists a polynomial-time truthful VCG mechanism $(A^{*},P)$ satisfying voluntary participation with approximation ratio of at most the approximation ratio of $A_{pos}$.

Proof.

We use VCG payments (1) with (2) as $Q_{i}(w^{\prime}_{-i}):=\textsc{cost}(A_{pos}(\bot,w^{\prime}_{-i}),w^{\prime}_{-i})=\textsc{cost}(x_{-i},w^{\prime}_{-i})$. Since in Step 3 every solution is computed independently of the input weights, algorithm $A^{*}$ satisfies the conditions of Theorem 1, which implies truthfulness. We show voluntary participation along the lines of Fact 1: First note that by Step 4 in $A^{*}$:

[TABLE]

since the solution $x_{-i}=A_{pos}(\bot,w^{\prime}_{-i})$ is a feasible solution that $A^{*}$ considers on input $w^{\prime}$. By the same argument, the approximation ratio of $A^{*}$ is at most the approximation ratio of $A_{pos}(w)$. For voluntary participation, note that for $w_{i}^{\prime}=w_{i}$, $i$’s utility is

[TABLE]

For an illustration of the computed set $R_{A^{*}}$, see Figure 3: The mechanism $(A^{*},P)$ will pick solution $x_{-2}$ and award payments $P_{1}=46-(10-4)=40,\ P_{2}=0,P_{3}=160-(10-6)=156$.

3.2 Absolute constant-factor approximation mechanisms

We now turn to developing truthful mechanisms where the approximation guarantee will be an absolute constant, therefore independent of the weights (cf. Theorems 3 and 4). To this end, we provide a polynomial-time truthful approximation mechanism if the number of packages $m$ is constant. We also show that by slightly deviating from the 2-step scheme given in the beginning of this section, the running time of the algorithm can be improved to $f(m)\cdot(kn)^{\mathcal{O}(1)}$, where $f$ depends only on $m$. Hence we get a truthful fixed parameter tractable (FPT) approximation mechanism, parametrized by the number of packages. To the best of our knowledge, the underlying algorithm is also the first absolute constant-factor approximation for the delivery problem. For the case of only constantly many agents $k$, we provide an exponential-time algorithm, where $k$ is the base of the exponential term.

No collaboration.

In the following, we consider only solutions $x\in R^{\star}_{\mathrm{noC}}$ where agents do not collaborate and follow the two properties given in Theorem 2. We are therefore left with the tasks of coordinating which agent gets assigned to which packages and planning in which order she delivers the assigned packages. In other words, in every such solution $x\in R^{\star}_{\mathrm{noC}}$, each agent $i$ is assigned a (possibly empty) block of packages $M_{i}(x)=\{i_{1},i_{2},\ldots,i_{|M_{i}(x)|}\}$. These package blocks are disjoint and form a partition of all $m$ packages $\{1,\ldots,m\}$. Furthermore, agent $i$ delivers each of its packages directly after picking it up at its source. These packages are processed in some order $\pi_{x}(i_{1}),\pi_{x}(i_{2}),\ldots,\pi_{x}(i_{|M_{i}(x)|})$, where $\pi_{x}$ is a permutation of $\{1,\ldots,m\}$. Finally, $i$ returns to its starting location $p_{i}$. Therefore, denoting the distance between $u$ and $v$ in $G$ by $\operatorname*{dist}(u,v)$, the travel distance $d_{i}(x)$ of agent $i$ can be written as

[TABLE]

Remark 1**.**

In the $\operatorname*{dist}(u,v)$ terms in (4) we are not interested in the actual route agent $i$ takes, as long as it uses a shortest path between $u$ and $v$.

Sets and lists.

To clarify the use of package blocks and package orders, we use the standard notion of sets and lists regarding partitions (see e.g., [7]): If we look at a partition of $\left\{1,\ldots,m\right\}$ into non-empty disjoint blocks, we can take into account the order of the elements within blocks, the order of the blocks, or both. We get four cases: sets of sets, sets of lists, lists of sets and lists of lists ([23, 24, 25, 26]). However, in the delivery setting we can also have agents which are not used at all and therefore not assigned to any packages – a complete description (coordination + planning) of a solution $x\in R^{\star}_{\mathrm{noC}}$ is therefore given by a list of exactly $k$ (possibly empty) lists, $M=(M_{1},\ldots,M_{k})$, where list $M_{i}$ represents the sequence of the packages that agent $i$ has to deliver in the order specified by $M_{i}$. Hence, we immediately get a bijection from all lists of exactly $k$ possibly empty lists to $R^{\star}_{\mathrm{noC}}$ (modulo the equivalence between shortest paths – see Remark 1).

Fact 2**.**

For every such list of lists $M$, there is a solution $x_{M}\in R^{\star}_{\mathrm{noC}}$ in which each agent $i$ delivers the packages in $M_{i}$ in the order specified by this list and in which the cost is minimized. Given $M$, such a solution can be computed in time $\mathit{poly}(n,m,k).$

Constant number of packages $m$

We now look at the case of a constant number $m$ of packages. By Theorem 2, the solution $S:=\operatorname*{arg\,min}_{x\in R^{\star}_{\mathrm{noC}}}{\textsc{cost}(x,w)}$ is a $2-$approximation of the optimum. First, we present an algorithm $A^{m}$ which basically enumerates over all lists of exactly $k$ (possibly empty) lists and adds the corresponding solution to a set $R_{A^{m}}$ (where we get $R_{A^{m}}=R^{\star}_{\mathrm{noC}}$), as described in the first step of our scheme. Then, given an input vector of weights $w^{\prime}$, $A^{m}$ chooses the best solution $A^{m}(w^{\prime})\in\arg\min_{x\in R^{\star}_{\mathrm{noC}}}\left\{\textsc{cost}(x,w^{\prime}\right\}$.

Theorem 5**.**

Algorithm $A^{m}$ finds a best solution $S\in$ $\smash{\operatorname*{arg\,min}\limits_{x\in R^{\star}_{\mathrm{noC}}}{\textsc{cost}(x,w)}}$ and can be implemented to run in time $\mathcal{O}\left(m!(k+m)^{m}\cdot\mathit{poly}(n,m,k)\right)$.

Proof.

Step 1 of $A^{m}$ produces $\mathcal{O}(m!\cdot{m+k-1\choose k-1})$ many solutions and can be implemented in time $\mathcal{O}\left(m!(k+m)^{m}\cdot\mathit{poly}(m,k)\right)$ as follows: Since we look at a list of lists we have a total order on the packages. Hence we first enumerate in an outer loop over all $m!$ permutations, which can be done in time $\mathcal{O}(m!)$. Each such permutation also needs to be subdivided into exactly $k$ possibly empty lists. There are ${m+k-1\choose k-1}\leq(k+m)^{m}$ many ways to do this (by placing $k-1$ delimiters at $m+k-1$ potential positions in time $\mathcal{O}\left(\mathit{poly}(m,k)\right)$). Step 2 of $A^{m}$ consists of computing the cost of each solution $x\in R^{\star}_{\mathrm{noC}}$ in time $\mathcal{O}\left(\mathit{poly}(n,m,k)\right)$. ∎

Theorem 6**.**

For a constant number of packages $m$, there exists a polynomial-time truthful VCG mechanism $(A^{m},P)$, satisfying voluntary participation, with approximation ratio $\leq 2$.

Proof.

Theorem 5 says that the algorithm satisfies the conditions in Theorem 1, and thus truthfulness holds. Theorem 5 also implies the running time. The approximation is due to Theorem 2 and the definition of the benefit of collaboration $\textsc{BoC}^{*}$. We next argue that the algorithm satisfies the condition in Fact 1, $\textsc{cost}(A^{m}(w^{\prime}),w^{\prime})\leq\textsc{cost}(A^{m}(\bot,w^{\prime}_{-i}),w^{\prime})$. Indeed, every solution $A^{m}(\bot,w^{\prime}_{-i})$ is also considered by the algorithm when all agents are present (input $w^{\prime}$), since this solution corresponds to some list of $k$ lists $M$ in which agent $i$ is not given any package (i.e. $M_{i}=\emptyset$). Thus the solution $A^{m}(\bot,w^{\prime}_{-i})$ is contained in $R^{\star}_{\mathrm{noC}}$. ∎

We now show that the running time of the mechanism $(A^{m},P)$ can be improved. The main idea is to enumerate in $A^{m}$ over all sets of lists instead of list of lists – i.e. during the enumeration we do not fix yet which agent gets which list of packages. Rather for each set of lists, we aim to directly compute an optimal assignment between the agents and the lists, thus deciding for every fixed set of lists in a parallel way the assigned list for every agent (instead of enumerating over all possible assignments as well).

Theorem 7**.**

The running time of the truthful VCG mechanism $(A^{m},P)$ can be improved to show fixed parameter tractablility, parametrized by the number of packages, namely a running time of $\mathcal{O}(f(m)\cdot\mathit{poly}(n,k))$, where $f(m)\in\smash{\mathcal{O}\left(e^{2\sqrt{m}-m}m^{m}\cdot\mathit{poly}(m)\right)}$.

Proof.

Consider first the running time of the improved algorithm $A^{m}$, which iterates over all sets of non-empty lists of the packages $1,\ldots,m$. The number of sets of lists is known to be $\mathcal{O}(e^{2\sqrt{m}-m}m^{m}/\mathit{poly}(m))$ [24]. To this end we enumerate over all sets of lists while spending only an additional $\mathcal{O}(\mathit{poly}(m))$-factor (over the number of sets of lists) on the running time. This can be done by enumerating over all sets of sets (by considering packages one-by-one and deciding whether to put them in a previously created subset or whether to start a new subset), followed by enumerating over all permutations of the packages inside each subset.

For each of the sets of at most $k$ lists, we compute the best assignment of the $k$ agents to the lists (say $l\leq k$ many) with a weighted bipartite matching as follows: On one side of the bipartite graph, we have $k$ vertices, one for each agent. On the other side, we have one vertex per list. We take the complete bipartite graph between the two sides. This graph has at most $k\cdot l\leq k\cdot m$ edges. We compute the cost of an (agent, list)-edge as the energy cost of delivering all packages in the bundle in that order with that agent. This requires $\mathcal{O}(\mathit{poly}(n,m))$ time per edge and $\mathcal{O}(\mathit{poly}(n,k,m))$ time in total. A maximum matching of minimum cost in this graph gives the best assignment of agents to bundles and can be found in polynomial time, e.g., by using the Hungarian method [20] or the successive shortest path algorithm [13].

It remains to show that truthfulness and voluntary participation also hold for the improved version of algorithm $A^{m}$. Truthfulness follows immediately from the fact that $A^{m}$ still considers all solutions $x\in R^{\star}_{\mathrm{noC}}$, albeit always several of them in a parallel fashion. To be able to apply Clarke’s pivot rule to define the payments via $Q_{i}(w_{-i}^{\prime})$ we make sure to also consider all solutions on all $k$ different subsets of $k-1$ agents, see Step 3 of the improved algorithm $A^{m}$. ∎

Constant number of agents $k$

Next, we look at settings with a constant number of agents $k$ but an arbitrary number of packages $m$. In this case, even for $k=1$ and independent of whether or not we restrict the packages to be transported from source to target without intermediate drop-offs, it is $\mathrm{NP}$-hard to approximate $\min_{x}\textsc{cost}(x,w^{\prime})$ to within any constant approximation ratio less than $367/366$ [6, Theorem 9]. There, the bottleneck lies in finding the optimal permutation $\pi_{\textsc{Opt}}$ to minimize the travel distances, see Equation (4). For $k>1$, we first have to partition the packages into (possibly empty) subsets $M_{1},\dots,M_{k}$. Contrary to $A^{*}$ and $A^{m}$, we will need exponential time $\mathcal{O}(k^{m})$ to enumerate all partitions. Next, for every fixed partition of the packages into subsets $M_{i}$, we look for a package order $\pi_{x}(i_{1}),\pi_{x}(i_{2}),\ldots,\pi_{x}(i_{|M_{i}|})$ given by a permutation $\pi_{x}$ of $\left\{1,2,\ldots,m\right\}$ such that we get an approximation guarantee on $d_{i}(x)$.

Stacker-Crane problem.

The latter can be modeled as the Stacker-Crane problem, which asks for the following: Given a weighted graph $G_{\mathit{SCP}}$ with a set of directed arcs and a set of undirected edges, find the minimum tour that uses each arc at least once. Since we restrict ourselves to the two additional conditions (i) direct delivery of each package, (ii) return of each agent $i$ in the end, we can model the transport of package $j$ along a shortest path by a directed edge from $s_{j}$ to $t_{j}$: Hence we choose the graph $G_{\mathit{SCP}}$ to consist of node $p_{i}$ and all nodes $s_{j},t_{j},\ j=i_{1},\ldots,i_{|M_{i}|}$, together with directed arcs $(s_{j},t_{j})$ of weight $\operatorname*{dist}_{G}(s_{j},t_{j})$ (corresponding to the length of a shortest path between $s_{j}$ and $t_{j}$ in $G$) and undirected edges $\smash{\left\{t_{j1},s_{j2}\right\},\left\{p_{i},s_{j}\right\},\left\{p_{i},t_{j}\right\}}$ of weights corresponding to the original distances $\operatorname*{dist}_{G}(t_{j1},s_{j2})$ between $t_{j1},s_{j2}$ (respectively $\operatorname*{dist}_{G}(p_{i},s_{j})$, $\operatorname*{dist}_{G}(p_{i},t_{j})$). For the Stacker-Crane problem, a polynomial-time $1.8$-approximation due to Frederickson et al. is known [16]. It remains to iterate over all assignments of the packages to the $k$ agents as in the presented Algorithm $A^{k}$.

Theorem 8**.**

Algorithm $A^{k}$ runs in time $\mathcal{O}\left(\mathit{poly}(n,m,k)\cdot k^{m}\right)$ and finds an approximate solution $S$ of $\textsc{cost}(S,w^{\prime})\leq 1.8\cdot\smash{\min_{x\in R^{\star}_{\mathrm{noC}}}}\textsc{cost}(x,w^{\prime})$.

Proof.

Algorithm $A^{k}$ first enumerates over all lists of exactly $k$ possibly empty sets of the packages. This can be implemented to run in time $\mathcal{O}(k^{m})$ by choosing for each of the $m$ packages the subset of packages $M_{i}$ it belongs to. We know that for each list of exactly $k$ possibly empty lists there is a corresponding solution $x\in R^{\star}_{\mathrm{noC}}$ and vice versa (Fact 2). In particular there exists a list $M=(M_{1},\ldots,M_{k})$ of lists $M_{1},\ldots,M_{k}$ for each optimal solution $\textsc{Opt}(R^{\star}_{\mathrm{noC}})\in\arg\min_{x\in R^{\star}_{\mathrm{noC}}}\left\{\textsc{cost}(x,w^{\prime})\right\}$. Algorithm $A^{k}$ at some point considers the list of exactly $k$ possibly empty sets $M_{1},\ldots,M_{k}$ (where there is no prescribed order of the elements in each of the $M_{i},\ i=1,\ldots,k$). Applying the Stacker-Crane approximation algorithm, $A^{k}$ approximates each of the travelling distances $d_{i}(\textsc{Opt}(R^{\star}_{\mathrm{noC}}))$ of the agents by a factor of at most $1.8$. Hence $A^{k}$ also considers a solution $S^{\prime}\in R^{\star}_{\mathrm{noC}}$ of cost

[TABLE]

Since this solution $S^{\prime}$ is contained in the built set $R_{A^{k}}$, we know that $S:=A^{k}(w^{\prime})$ has $\textsc{cost}(S,w^{\prime})\leq\textsc{cost}(S^{\prime},w^{\prime})\leq 1.8\cdot\min_{x\in R^{\star}_{\mathrm{noC}}}{\textsc{cost}(x,w^{\prime})}$. ∎

Theorem 9**.**

For a constant number of agents $k$, there exists an exponential-time truthful VCG mechanism $(A^{k},P)$, satisfying voluntary participation, with approximation ratio $\leq 3.6$.

Proof.

The approximation follows from Theorem 2 and Theorem 8. The latter theorem also implies the running time of the mechanism. Truthfulness and voluntary participation can be proved essentially in the same way as for Theorem 6. Indeed, the set of solutions $R_{A^{k}}$ is computed independently of the input weights $w^{\prime}$, and thus the last step defining $A^{k}$ satisfy the condition of Theorem 1 (implying truthfulness). As for voluntary participation, we observe that when $A^{k}$ is run on input $(\bot,w^{\prime}_{-i})$, the computed solution corresponds to some list of $k-1$ sets (agent $i$ is not present), and the same solution is considered on input $w^{\prime}$ as a list of $k$ sets, where one set is empty. This implies that the algorithm satisfies $\textsc{cost}(A^{k}(w^{\prime}),w^{\prime})\leq\textsc{cost}(A^{k}(\bot,w^{\prime}_{-i}),w^{\prime})$, i.e., Fact 1 and thus voluntary participation. ∎

3.3 Comparison of the algorithms

We conclude our results on truthful approximation mechanisms with a comparison of the three given algorithms $A^{*}$ (general setting, polynomial time), $A^{m}$ (FPT, parametrized by the number of packages $m$) and $A^{k}$ (exponential time for a constant number of agents $k$), given in Figure 4. Each of the three algorithms chooses an optimal solution from a respective set $R_{A^{*}},R_{A^{m}},R_{A^{k}}$. To ensure voluntary participation, in each set we include solutions where individual agents are not present – in this way, we can set the payments according to Clarke’s pivot rule (2). All three algorithms make use of Theorem 2 which bounds the Benefit of Collaboration $\textsc{BoC}^{*}$ by 2 (this can be seen directly in the definition of the algorithms $A^{m},A^{k}$, for algorithm $A^{*}$ this follows from the black box algorithm $A_{pos}$ [6, Theorem 13]). In fact, the first version of the algorithm $A^{m}$ computes a set $R_{A^{m}}$ which consists of all the solutions in $R^{\star}_{\mathrm{noC}}$ – the improved version of $A^{m}$ discards solutions of high cost early on (while still considering solutions where individual agents are not present), in order to limit the set $R_{A^{m}}$ to a small ($\mathit{FPT}$-) size, parametrized by the number of packages. Finally, we can compare the approximation guarantees. For algorithm $A^{*}$ the approximation ratio of $4\cdot\tfrac{w_{\max}}{w_{min}}$ follows from the (same) approximation ratio of $A_{pos}$. Both $A^{m}$ and $A^{k}$ have a factor of $\textsc{BoC}^{*}\leq 2$, with an additional factor of $1.8$ for $A^{k}$ since we need to approximate the planning of each agent’s tour (which we model with stacker-crane).

4 Single Package and Frugality

For the case of a single package, we define two truthful VCG mechanisms. The optimal mechanism which minimizes the social cost using any number of agents, and the lonely mechanism which computes the solution of minimal cost under the constraint of using only one single agent. In both mechanisms, we use the VCG payments (1) with Clarke pivot rule (2) in order to satisfy voluntary participation.

Theorem 10** (Theorem 2 in [6]).**

For $m=1$, the optimal solution using a single agent, as well as the optimal solution using any number of agents, can be computed in polynomial time.

Fact 3**.**

Both the exact and the lonely mechanisms are truthful since the algorithms are optimal with respect to a fixed subset of solutions, i.e., they satisfy the condition of Theorem 1. Moreover, the mechanisms run in polynomial time by Theorem 10.

In the following, we bound the total payments of these mechanisms compared with the cost of the optimal solution (for the given input). In other words, assuming the reported weights are the true weights ($w^{\prime}=w$), we would like the mechanism to not pay much more than the optimum for these weights $w=w^{\prime}$. This property is usually termed frugality [14, 3].

We first observe that, if we care more about the total payment made to the agents than about the optimality of the final solution, then in some instances it may pay off to run the lonely mechanism instead of the optimal mechanism. However, in other instances, the converse happens, meaning that neither mechanism is always better than the other.

In order to compare the optimal mechanism with the lonely mechanism, it is useful to define the following shorthands:

[TABLE]

where $A_{opt}$ is the optimal algorithm, and $A_{lon}$ is the lonely algorithm, that is, the one computing the optimal solution using a single agent. Then the VCG payments (1) with the Clarke pivot rule in (2) can be rewritten as follows in the two cases:

[TABLE]

Below, we usually omit the agents’ weights $w^{\prime}=w$ whenever they are clear from the context.

Fact 4**.**

The lonely mechanism pays the selected agent $i$ an amount $LOPT_{-i}$, and the other agents get no payment. This is because $LOPT=w_{i}^{\prime}\cdot d_{i}(A_{lon}(w^{\prime}))$ when $i$ is selected, and for all non-selected agent $j\neq i$, $LOPT=LOPT_{-j}$ and $d_{j}(A_{lon(w^{\prime})})=0$.

Theorem 11**.**

For a single package, there are instances where the optimal mechanism pays a total amount of money larger than what the lonely mechanism does. Moreover, there are instances in which the opposite happens, that is, the lonely mechanism pays more.

Proof.

First we prove that there are instances, in which the optimal mechanism pays more. The example in Figure 5 (left) shows an instance and its optimal solution. The optimum for the instance in which agent $1$ is not present has cost $OPT_{-1}=40$ (let agent $3$ do the whole work). More generally, one can check that $OPT_{-1}=OPT_{-2}=40$ and $OPT_{-3}=45$, and obviously $OPT=9+12+16=37$. Using these values for the payments (5), we get $P_{1}=40-(37-9)=12$, $P_{2}=40-(37-12)=15,\ P_{3}=45-(37-16)=24$, for a total amount of $51$ payed by this mechanism to the agents. The lonely mechanism will instead select agent $3$ and pay only this agent (see Fact 4) an amount $LOPT_{-3}=6\cdot(2+2+4)=48$, which is the lonely optimum for the instance where agent $3$ is not present.

On the other hand, the example in Figure 5 (right) shows an instance in which the lonely mechanism pays more. The optimal solution has cost is $OPT=18+10+10=38$ and we get $OPT_{-1}=40$, $OPT_{-2}=46$ and $OPT_{-3}=38$, resulting in the payments $P_{1}=40-(38-18)=20,\ P_{2}=46-(38-10)=18,\ P_{3}=38-(38-10)=10$ for a total amount of $48$. The lonely mechanism will instead select agent $2$ and pay $LOPT_{-2}=50$. ∎

We remark that the payments given by (1) and (2) guarantee voluntary participation, and therefore the mechanism must pay a total amount of at least the optimum. We show that both mechanisms pay only a small constant factor over the optimum, except when a single agent can do the work for a much cheaper price than the others (as shown in Example 1):

Definition 6** (monopoly-free).**

We say that an instance with a single package is monopoly-free if there is an optimal solution which uses at least two agents.

Example 1**.**

Both the exact and the lonely mechanism perform equally bad if, for instance, there is only one very cheap agent and another very expensive one. Consider two agents of weights $w_{1}=\epsilon$ small, and $w_{2}=L$ large, both agents sitting on the starting position $s_{1}$ of the package. In this case the two mechanisms output the same solution and payment: Agent $1$ does the whole work and gets an amount of money given by the best alternative solution. We have $P_{1}=$ $w_{2}\operatorname*{dist}(s_{1},t_{1})=L\operatorname*{dist}(s_{1},t_{1})$, while the optimum is $w_{1}\operatorname*{dist}(s_{1},t_{1})=\epsilon\operatorname*{dist}(s_{1},t_{1})$.

Theorem 12**.**

In any single package monopoly-free instance, the optimal mechanism pays a total amount of money which is at most twice the optimum.

Proof.

The optimal solution selects a certain number $\ell\geq 2$ of agents and assigns to each of them some path. By renaming the agents, we can therefore assume that the optimum cost is of the form $OPT=w_{1}d_{1}+w_{2}d_{2}+\cdots+w_{\ell}d_{\ell}$, where no agent appears twice and the weights must satisfy $w_{i}\geq w_{i+1}$ and $w_{i}\leq 2w_{i+1}$, for otherwise agent $i$ can replace agent $i+1$ or vice versa. We shall prove below that

[TABLE]

Using VCG payments (1), we obtain from (7) that every agent is payed at most twice her cost, $P_{i}\leq OPT+w_{i}d_{i}-(OPT-w_{i}d_{i})=2w_{i}d_{i}$, which then implies the theorem. To complete the proof, we show (7) by distinguishing two cases. For $i<\ell$, we can replace agent $i$ with agent $i+1$ who then has to travel an additional distance of at most $2d_{i}$ to reach $i$ and come back to its position. This gives an upper bound: $OPT_{-i}\leq OPT-w_{i}d_{i}+w_{i+1}2d_{i}\leq OPT+w_{i}d_{i}$, where the last inequality is due to $w_{i+1}\leq w_{i}$. For $i=\ell$, we replace agent $i$ by agent $\ell-1$ who travels an extra amount $d_{\ell}$, and obtain this upper bound: $OPT_{-\ell}\leq OPT-w_{\ell}d_{\ell}+w_{\ell-1}d_{\ell}\leq OPT+w_{\ell}d_{\ell}$, where the last inequality is due to $w_{\ell-1}\leq 2w_{\ell}$. ∎

Theorem 13**.**

In any single package monopoly-free instance, the lonely mechanism pays at most $2BoC$ times the optimum, where $BoC=1/\ln 2\approx 1.44$ (by Theorem 2).

Proof.

Let $i$ be the selected agent. A crude upper bound on the sum of the payments can be obtained via Fact 4, where the second inequality requires the instance to be monopoly-free: $P_{i}=LOPT_{-i}\leq\textsc{BoC}\cdot OPT_{-i}\stackrel{{\scriptstyle\eqref{eq:OPT-i}}}{{\leq}}\textsc{BoC}\cdot(OPT+w_{i}d_{i})\leq\textsc{BoC}\cdot 2\cdot OPT$. ∎

5 Conclusion and open questions

This work initiates the study of truthful mechanisms for delivery in a natural setting where mobile agents are selfish and can speculate about their own energy consumption rate. We considered mechanisms which are truthful, run in polynomial-time, have a worst-case approximation guarantee and, possibly, do not pay the agents abnormal amounts (frugality). We provide such polynomial-time truthful approximation mechanisms for two cases: (1) when the consumption rate of different agents are similar, i.e., the ratio $\max\frac{w_{i}}{w_{j}}$ is bounded (see Theorem 4) and (2) when the number of packages $m$ is small (see Theorem 7). For a single package, we also gave bounds on the frugality of two natural truthful mechanisms which return the optimum or an approximation of the optimum.

The main open question is whether there exists a polynomial-time constant-factor approximation independent of the weights. This remains an intriguing open question even for a constant number of agents $k$, for which we presented an exponential-time truthful approximation mechanism.

Acknowledgments.

We would like to thank Jérémie Chalopin, Shantanu Das, Yann Disser, Jan Hackfeld, and Peter Widmayer for some insightful discussions. We are very grateful for the feedback provided by the anonymous reviewers. This work was partially supported by the SNF (Project 200021L_156620, Algorithm Design for Microrobots with Energy Constraints).