Achieving Allocatively-Efficient and Strongly Budget-Balanced Mechanisms in the Network Flow Domain for Bounded-Rational Agents

Vickrey-Clarke-Groves (VCG) mechanisms are a framework for finding a solution to a distributed optimization problem in systems of self-interested agents. VCG mechanisms have received wide attention in the AI community because they are efficient and strategy-proof; a special case of the Groves family of mechanisms, VCG mechanisms are the only direct-revelation mechanisms that are allocatively efficient and strategy-proof. Unfortunately, they are only weakly budget-balanced. We consider self-interested agents in a network flow domain, and show that in this domain, it is possible to design a mechanism that is both allocatively-efficient and almost completely budget-balanced. This is done by choosing a mechanism that is not strategy-proof but rather strategyresistant. Instead of using the VCG mechanism, we propose a mechanism in which finding a beneficial manipulation is an NP-complete problem, and the payments from the agents to the mechanism may be minimized as much as desired. 1 Mechanisms for Network Flow Mechanisms face the problem of finding a system-wide solution to an optimization problem based on private information given by self-interested agents. A well-known solution to such problems in the case of quasi-linear preferences is that of Groves mechanisms. A special case of the Groves family of mechanisms are VCG mechanisms, which are budgetbalanced, allocatively-efficient, and strategy-proof. A significant disadvantage of VCG mechanisms is that they are only weakly budget-balanced. We would in principle prefer a strongly budget-balanced mechanism, where the total sum of payments to the mechanism is zero: ∑ i ti(θ) = 0. Impossibility results ([Green and Laffont, 1977] and [Hurwicz, 1975]) show that in a quasi-linear environment, it is impossible to achieve a mechanism that is strategy-proof, allocatively-efficient, and strongly budget-balanced. We address this by slightly relaxing the strategy-proof requirement, replacing it with strategy-resistance. A mechanism is strategy-proof if the dominant strategy of each agent is to reveal its true type to the mechanism. Strategy-resistance only requires that even if an agent is given the reported types of the other agents, it has a computationally intractable problem to solve if it wishes to find a beneficial manipulation (i.e., report a false type to the mechanism to gain higher utility). In this work, we consider the domain of network flows. In that domain, the edges of a network flow belong to several self-interested agents. Each agent reports its edges to the mechanism. The mechanism is then required to choose a flow from the source vertex to the target vertex. Agents gain utility from flow units on their edges. Agents can lie, and declare a subset of the edges they really own. This manipulation may change the flow that the mechanism chooses, and agents may try to take advantage of this. However, we show that it is possible to use the fact that agents have computational limitations and are not unboundedly rational, so as to construct mechanisms with beneficial properties. 1.1 Self-Interested Network Flows We explore the problem of designing a mechanism for bounded-rational agents in a distributed flow problem. We demonstrate that for this domain, we can find a mechanism that is allocatively-efficient, -budget-balanced, and strategyresistant. This means that if we assume the agents are bounded-rational and would not try to manipulate the mechanism if such manipulation is an NP-complete problem, they would all truthfully report their preferences. Once the mechanism gets their true preferences, it chooses the outcome that maximizes total utility of the agents. To achieve this truthfulness, the mechanism requires payments; however, the total sum of these payments can be minimized as much as required. We now present the self-interested layered-graph network flow problem. Consider a flow network on a layered graph. We have a graph G =< V,E >, with source vertex s and target vertex t. The vertices of the graph are partitioned into n + 1 layers, L0 = {s}, L1, ..., Ln = {t}. The edges only run between consecutive layers. We have a capacity function c : E → R which is the maximal flow allowed on the edges. We also have a set I of agents. Each agent controls a subset Ei ⊂ E of the graph’s edges. No two agents control the same edge: ∀i 6=jEi ∩ Ej = φ. The mechanism chooses a valid flow from s to t. A valid flow is a function f : E → R such that ∀(u,v)∈Ef(u, v) ≤ c(u, v), ∀(u,v)∈Ef(u, v) = −f(v, u), and ∀u∈V−{s,t} ∑ v∈V f(u, v) = 0. Each agent values the flow according to the total flow going through its edges. Let f be the valid flow chosen by the mechanism, and Ef the set of edges in f through which there is a positive flow: Ef = {e ∈ E | f(e) > 0}. We denote the set of Ai’s edges used in the flow f by: Ef,i = Ef ∩Ei. The agent’s valuation of the flow is vi(f) = ∑ e∈Ef,i f(e). When the mechanism is given the agents’ true types, θ = E1, E2, ..., EI , we want it to choose the flow that maximizes the total utility of the agents. The mechanism would be allocatively-efficient if it chooses f∗(θ) = argmaxf ∑ i ∑ e∈Ef,i f(e). In a layered graph the flow that maximizes the sum of agents’ utilities is the maximal flow (proof of this is given in the full paper). Thus, if each agent truthfully declares its subset of edges, the mechanism can easily compute f∗(θ) by running a maximal flow algorithm, such as the Edmonds-Karp algorithm. As shown in the full version of this paper, a naive mechanism for the self-interested flow problem, with no payments to the mechanism, is not strategy-proof. An agent may declare a subset of the edges it controls, to change the flow that the mechanism chooses to a flow that the agent values more. 1.2 Self-Interested Network Flow Mechanism We assume quasi-linear utility. Each agent pays the mechanism a payment pi, and its utility is ui(f) = vi(f) − pi. We now show that by using a straightforward payment rule, we make finding a beneficial manipulation NP-hard. The payment rule we use is simple: each agent pays the mechanism a constant of c for each edge it declares it owns. Let E′ i ⊂ Ei be the subset of edges an agent declares it owns. Then pi(E i) = c|E′ i|. We also give a minor correction to make sure the mechanism is individual-rational. The payment pi gives the agent a utility of 0 when the agent’s valuation of the chosen flow is less than the payment to the mechanism. Assume that Ai knows E′ j for all j 6= i. It can easily calculate the utility it would get by truthfully declaring all its edges. How hard is it for i to find a subset of edges it could declare to the mechanism so as to gain a higher utility? We define the problem of finding a useful manipulation in the self-interested network flow domain as follows. FLOW-EDGE-SUBSET: We are given a layered graph flow network, with the capacity function c : E → R, E−i the declared edges of the other agents, and Ei, the set of our edges. We are also given the constant c of the payment, and we know that if we declare that we have k edges, our payment to the mechanism would be pi = ck. We assume the mechanism prefers a maximal flow that maximizes our utility of all the possible maximal flows. We are also given a constant k, the target utility for Ai. We are asked if there is a subset of Ai’s edges E′ i ⊂ Ei, such that the maximal flow chosen by the mechanism, f(E1, ..., Ei−1, E′ i, Ei+1, ..., EI) gives Ai a utility of at least k: ui(f, pi) = vi(f) − pi = ∑ e∈Ef∗,i f(e)− c|E ′ i| ≥ k. A reduction, given in the full version of this paper, indicates that FLOW-EDGE-SUBSET is an NP-complete problem. The reduction given is from a general VERTEXCOVER instance to a FLOW-EDGE-SUBSET problem. Although we do not include the full details of the reduction here, we do give some intuition about how it was constructed. Given the original VERTEX-COVER instance, we build a layer graph, where one of the agents, A1, controls all the edges between two consecutive layers. Each edge A1 owns corresponds to a vertex in the original VERTEXCOVER graph. The network flow graph is constructed so that in order for A1 to maximize its valuation, it must declare a subset of edges that is a vertex cover of G. However, in order to minimize its payment to the mechanism, A1 must choose as few edges as possible. If the payment constant c is small enough, A1’s top priority is to make its chosen vertices a vertex-cover, and only then choosing as few edges as possible. This makes its preferred choice the minimal vertex cover of the original graph. 2 Conclusions and Future Directions We have suggested a mechanism for the distributed network flow problem with self-interested agents. With a proper choice of the payment constant c, finding a beneficial manipulation is an NP-complete problem. Since finding a beneficial manipulation is intractable, we encourage agents to truthfully report their preferences. In this case, the mechanism would choose the result maximizing the sum of agents’ utilities, and we have an allocatively-efficient mechanism. Given some > 0, we can make the mechanism budget-balanced, by choosing a small enough payment constant c < n(|E|+|V |) , where n is the number of agents. This way, all of the agents together pay less than . The mechanism we have described is also individual-rational. Therefore, in the domain of network flows, this achieves an individual-rational, allocatively-efficient, -budget-balanced, and strategy-resistant mechanism. The standard VCG solution in this domain would be only weakly budget-balanced, but strategy-proof. Impossibility results ([Green and Laffont, 1977] and [Hurwicz, 1975]) indicate that no direct-revelation mechanism can achieve strong budget-balance without sacrificing either allocative-efficiency or strategy-proofness. We believe that in many cases, trading strategy-proofness for strategy-resistance is a fair price to pay for achieving strong budget-balance. Our strategy-resistance rested on the worst case assumptions of NP-hardness, which only indicates that a certain problem has some hard instances. A stronger notion of strategy-resistance could also require the manipulation problem to have no approximation methods, that it be in some harder complexity class, or that it be hard to find any (not just the optimal) beneficial manipulation. This work constitutes a first step in establishing the notion of strategy-resistance.