# Distributed resource allocation through utility design - Part I: optimizing the performance certificates via the price of anarchy

Game theory has emerged as a novel approach for the coordination of multiagent systems. A fundamental component of this approach is the design of a local utility function for each agent so that their selfish maximization achieves the global objective. In this paper we propose a novel framework to characterize and optimize the worst case performance (price of anarchy) of any resulting equilibrium as a function of the chosen utilities, thus providing a performance certificate for a large class of algorithms. More specifically, we consider a class of resource allocation problems, where each agent selects a subset of the resources with the goal of maximizing a welfare function. First, we show that any smoothness argument is inconclusive for the design problems considered. Motivated by this, we introduce a new approach providing a tight expression for the price of anarchy (PoA) as a function of the chosen utility functions. Leveraging this result, we show how to design the utilities so as to maximize the PoA through a tractable linear program. In Part II we specialize the results to submodular and supermodular welfare functions, discuss complexity issues and provide two applications.

There are no comments yet.

## Authors

• 15 publications
• 14 publications
• 32 publications
• ### When Smoothness is Not Enough: Toward Exact Quantification and Optimization of the Price-of-Anarchy

Today's multiagent systems have grown too complex to rely on centralized...
04/24/2019 ∙ by Rahul Chandan, et al. ∙ 0

• ### Distributed resource allocation through utility design - Part II: applications to submodular, supermodular and set covering problems

A fundamental component of the game theoretic approach to distributed co...
07/03/2018 ∙ by Dario Paccagnan, et al. ∙ 0

• ### Distributed control and game design: From strategic agents to programmable machines

Large scale systems are forecasted to greatly impact our future lives th...
01/18/2019 ∙ by Dario Paccagnan, et al. ∙ 0

• ### Tractable mechanisms for computing near-optimal utility functions

Large scale multiagent systems must rely on distributed decision making,...
02/08/2021 ∙ by Rahul Chandan, et al. ∙ 0

• ### The Cost of Denied Observation in Multiagent Submodular Optimization

A popular formalism for multiagent control applies tools from game theor...
09/10/2020 ∙ by David Grimsman, et al. ∙ 0

• ### Competitive Information Disclosure with Multiple Receivers

This paper analyzes a model of competition in Bayesian persuasion in whi...
03/05/2021 ∙ by Bolin Ding, et al. ∙ 0

• ### Optimal mechanisms for distributed resource-allocation

As the complexity of real-world systems continues to increase, so does t...
11/18/2019 ∙ by Rahul Chandan, et al. ∙ 0

##### This week in AI

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

## I Introduction

Multiagent systems have enormous potential for solving many of the current societal challenges. Robotic networks can operate in post-disaster environments and reduce the impact of industrial or natural calamities [1, 2]. They have the potential to increase the food production and to reduce the water consumption [3]. Fleets of autonomous cars are forecasted to revolutionize the mobility, to reduce traffic congestion as well as pollutant emissions [4]. On a smaller scale, swarms of medical “microbots” promise groundbreaking results by means of local drug delivery [5] or microsurgery [6].

The main challenge in controlling such systems is to design local decision rules for the individual subsystems to guarantee that the collective behaviour is desirable with respect to a global objective [7]. The spatial distribution, privacy requirements, scale, and quantity of information associated with typical networked systems do not allow for centralized communication and decision making, but require instead the use of distributed protocols. That is, the agents in the system must make decisions independently in response to available information. Such problems are typically posed as optimization problems (finite or infinite dimensional), where the system-level objective is captured by an objective function, while physical laws and informational availability are incorporated as constraints on the decision variables [8, 9]. One common approach for deriving admissible algorithms is to distribute existing centralized optimization schemes by leveraging the structure of the given problem, e.g., distributed gradient ascent, primal-dual and Newton’s method, among others [10, 11].

An alternative approach, termed game design, has established itself as a valuable set of tools to complement these more traditional techniques [12]. Rather than directly specifying a decision-making process, local utility functions are assigned to the the agents, so that their self-interested optimization translates in the achievement of the system-level objective; see Figure 1 for an overview of the approach. The motivation for studying equilibria of such games, as opposed to equilibria of a dynamical process, stems from the existence of readily available distributed learning algorithms that can be utilized to the drive the collective behavior to a Nash equilibrium in a given game [12, 13, 14, 15, 16, 17, 18, 19]. When the agent utility functions are set to be equal to the system-level objective, the resulting algorithms and performance guarantees resemble the centralized optimization methodologies discussed above. The value of the game design approach emerges when the designed agent utility functions are not equal to the system-level objective. In fact, we demonstrate the non-intuitive fact that having agents respond to local utility functions that do not reproduce the system-level objective significantly improves the efficiency guarantees of the resulting collective behavior.

The core of this work centers on characterizing the relationship between the agents’ utility functions and the efficiency of the emergent collective behavior, that is, this work focus on the utility design step depicted in Figure 1. We model the emergent collective behavior as a pure Nash equilibrium of the game defined by the agents’ utility functions, and measure the corresponding efficiency with the notion of price of anarchy [20]. The price of anarchy provides performance guarantees associated with the worst performing Nash equilibrium of the designed game, relative to the optimal performance.

Related Works. There has been extensive research in the field of algorithmic game theory focused on analyzing the price of anarchy, as well as other efficiency measures such as the price of stability [20, 21] and price of stochastic anarchy [22]. However, most of the results are purely analytical and do not properly address the design questions considered in this manuscript. One noteworthy result involves the widely studied smoothness framework, which provides a general approach - in the form of an inequality constraint involving the utility functions - to bound the price of anarchy [23]. Inspired by this line of work, [24, 25, 26, 27] developed mathematical programs aimed at deriving bounds on the price of anarchy by incorporating this constraint. Unfortunately, we show in Section III that the price of anarchy bounds associated with the smoothness framework are relevant only when the agents’ utility functions are budget-balanced, i.e., the sum of the agents’ objective is equal to the system-level objective. While this constraint is well justified for a number of problems modeled through game theory (e.g., cost sharing games [28]), it has little bearing on the design of local utility functions in multiagent systems, as studied here.

Much less is known about tight price of anarchy guarantees outside of the case of budget-balanced objectives, with the exception of some specific problem domains including coverage problems [29] and resource allocation problems with convex costs or concave welfare [30, 31]. We note that all the aforementioned approaches based on the reformulation of the smoothness condition through mathematical programming techniques [24, 25, 26, 27] result in optimization problems whose size is exponential in the number of agents and in the number of strategies available to each agent. Some of these works even require prior knowledge on the structure of the worst case instances, e.g., [25]. On the contrary our approach produces a linear program whose size does not depend on the number of agents’ strategies, and grows only linearly in the number of agents. Just as importantly, our linear program automatically discovers the structure of the worst case instances.

Contributions. This paper generalizes the afore-mentioned application specific results by developing methodologies for game design in a well-studied class of distributed resource allocation problems, where each agent selects a subset of resources with the goal of maximizing a system-level objective function that is separable over the resources. The main contributions of this paper include the following:

1. We show that the smoothness framework typically used to bound the price of anarchy is not suited for the utility design problems considered, as the corresponding efficiency bounds are conservative (Theorem 1).

2. We resolve the problem of computing the exact (i.e., tight) price of anarchy by means of a tractable linear program in its primal and dual form (Theorems 2 and 3). The latter program features only decision variables and , where is the number of agents in the original optimization problem. Such program can be solved efficiently.

3. We solve the problem of designing agent utility functions so as to optimize the resulting price of anarchy. We show that this problem can be posed as a tractable linear program in variables and constraints (Theorem 4).

Part II demonstrates the breadth of the approach by specializing these results to the class of submodular and supermodular resource allocation problems. In this context, we show how our approach subsumes and generalizes existing fragmented results. We conclude Part II by showcasing the applicability of our techniques by means of two applications.

Organization. Section II contains the model, the game theoretic approach, and the corresponding performance metrics. Section III shows the inapplicability of the smoothness framework to the utility design problem considered. Sections IV and V show how to reformulate the problems of characterizing and optimizing the price of anarchy as tractable linear programs.

Notation. For any two positive integers , denote and . We use , and to denote the set of natural numbers, positive and non negative real numbers, respectively. Given a finite set , denotes its cardinality; represents Euler’s number.

## Ii Model and performance metrics

### Ii-a Problem formulation

In this paper we consider a framework for distributed resource allocation. Let be a set of agents, and be a set of resources, with . Each resource is associated with a local welfare function that captures the welfare accrued at each resource as a function of the utilization, i.e., is the welfare generated at resource if there are agents utilizing that resource. Finally, each agent is associated with an admissible choice set . The goal of the system designer is to find an allocation optimizing a system-level objective of the form

 W(a)=∑r∈∪iaiWr(|a|r), (1)

where denotes the number of agents choosing resource in allocation , i.e., the cardinality of the set . We will often use to denote the decision of all the agents but .

###### Example 1 (Vehicle-target assignment / maximum coverage).

Consider the classic vehicle-target assignment problem [32]. In this problem there are a set of targets, each associated to its importance , and a set of agents . Each agent is given a set of possible assignments

, and a common success probability

. The goal is to determine an admissible vehicle-target assignment to maximize the value of acquired targets, as expressed by

 W(a)=∑t∈∪iaivt(1−(1−p)|a|t). (2)

An important case of vehicle-target assignment problem that warrants independent attention is the well-studied maximum coverage problem [33]. In a weighted maximum coverage problem all agents have identical sets . The goal is to select subsets from to maximize the total weight of covered elements. This is obtained setting in (2).

###### Example 2 (Routing through a shared network).

Consider the classic routing problem given in [34]. In this problem a set of users utilizes a common network comprised of a set of edges , where each edge is associated to a cost function . The term captures the quality of service (or latency) on edge if there are users sharing that edge. Each user is associated with a given source and destination, which defines a set of admissible paths. The goal of the system designer is to determine an allocation of users to the network to optimize the total congestion

 W(a)=−∑e∈∪iai|a|e⋅ce(|a|e). (3)

From this point on, we consider resource allocation problems where the welfare functions satisfies for all , and thus for all . The case of for all falls under the framework of cost minimization. While we do not explicitly delve into the framework of cost minimization here, all of the forthcoming results have an analogous result that holds for the cost minimization setting.

### Ii-B Local utility design and the price of anarchy

Within the combinatorial framework studied in this paper, finding a feasible allocation maximizing (1) is known to be an intractable problem. Based on such observation, this work focus on deriving efficient and distributed algorithms for attaining approximate solutions to the maximization of (1). While for specific classes of problems centralized algorithms are available [33], the focus is placed here on distribued algorithms. In this respect, each agent is requested to make independent choices in response to pieces of information only regarding the resources he can select, i.e., .

Rather than directly specifying a decision-making process, we adopt the framework of game theory and utility design. Here, each agent is associated with a utility function of the form that guides their individual behavior. We focus on the following class of local agent objective functions where for any agent and allocation we let

 Ui(a)=∑r∈aifr(|a|r), (4)

and defines the utility each agent receives at resource as a function of the number of agents selecting that resource in the allocation . We refer to as the utility generating functions since each agent utility is fully determined once are specified. We refer to one such game with the tuple .

The core of this work is on analyzing the efficiency of the equilibria associated with the game generated by according to the utility functions (4) and the system-level objective in (1). We focus on the notion of Nash equilibrium, which is guaranteed to exist for any game with utility functions (4), thanks to the fact that is a potential game [35].

###### Definition 1 (Nash equilibrium, [36]).

An allocation is a pure Nash equilibrium if for all alternative allocations and for all agents .

We characterize the efficiency of a Nash equilibrium - which we refer to as simply an equilibrium - using the notion of price of anarchy (). The price of anarchy of an instance is defined as the ratio between the welfare at the worst performing Nash equilibrium, and the maximum attainable welfare [20].111The choice of Nash equilibrium provides us with potentially better performance guarantees compared to what offered by more permissive - but easier to compute - equilibrium notions, e.g., coarse correlated equilibrium [37]. Indeed, since every Nash equilibrium is also a coarse correlated equilibrium, the worst performing coarse correlated equilibrium yields a system-level objective that is no better than that of the worst performing Nash equilibrium. The drawback of this choice stems from the intractability of Nash equilibria, which are hard to compute (-complete, [38]) even for the class of congestion games to which belongs to. Nevertheless, under structural assumptions on the sets similar to those used in combinatorial optimization, computing a Nash equilibrium is a polynomial task (See Proposition 2 in Part II). Finally, the guarantees offered by Nash equilibria are deterministic. Price of anarchy guarantees are particularly impactful when extended from a single game to a family of games ; however, defining a family of games requires defining the utility generating functions for each game instance. Here, we focus on the case where a system designer is unaware of the structure of the specific resource allocation problem. In particular, we assume the system designer is unaware of the exact number of agents, the number of resources, and the agents’ action sets. The only information a priori available to the system designer is the set describing the possible welfare functions utilized, i.e., for all resources. This request stems from the observation that the previous pieces of information may be unreliable, or unavailable to the system designer due to, e.g., communication restrictions or privacy concerns. Given this uncertainty, we consider the case where the system designer commits a priori to a specific utility generating function for each welfare functions , which we express by . The realized resource allocation problem merely employs the utility generating functions . The map constitutes our design choice, and we refer to it as the utility generating mechanism. We denote with the set of games induced by , i.e., any game is of the form

 G=(N,R,A,{Wr}r∈R,{F(Wr)}r∈R), (5)

where is any set of agents, is any set of resources, is any allocation set, and is any tuple of functions satisfying . The price of anarchy of the family of games is defined as the worst case over , i.e.,

 PoA(F,W)=infG∈GF,W(mina∈NE(G)W(a)maxa∈AW(a)). (6)

where denotes the set of equilibria of . While the function also depends on the instance considered, we do not indicate it explicitly, to simplify notation. The quantity characterizes the efficiency of the worst performing equilibrium relative to the corresponding optimal allocation, over all possible instances in . In the non-degenerate cases where , it holds , and the higher the price of anarchy, the better performance certificates we can offer. Observe that when an algorithm is available to compute one such equilibrium, the price of anarchy also represents the approximation ratio of the corresponding algorithm over all the instances in .

###### Example 1 revisited (Vehicle-target assignment).

Consider the vehicle-target assignment problem of Example 1. Define as the set containing only welfare functions of the form

 Wr(j)=vr⋅(1−(1−p)j),∀j∈N. (7)

for all , . Further, consider a utility generating mechanism , known as the marginal contribution, where for any we have with

 fmcr(j)=vr⋅p⋅(1−p)j−1,∀j∈N. (8)

Note that the utility generating mechanism provided in (8) results in a well-defined game for any instance of the vehicle-target assignment problem given Example 1. Furthermore, it is shown in [13] that , meaning that regardless of the underlying vehicle-target assignment problem, all equilibria are guaranteed a performance within of optimal. This paper will develop a framework to design the best possible utility generating mechanism, and accompany that with a performance certificate significantly beyond .

We decompose the utility design problem in two tasks:

• providing a bound (or ideally an exact characterization) of the price of anarchy as a function of and ;

• optimizing this expression over all mechanisms .

In Section IV we address i), while in Section V we turn the attention to ii). Before doing so, we show that the existing smoothness approach is unsuitable for the purpose.

## Iii Smoothness and its limitations

There has been significant research attention geared at analyzing the price of anarchy for various classes of games. One approach that is commonly employed for this purpose is termed smoothness [23]. The framework of smoothness provides a technique to bound the price of anarchy of a given game by devising parameters that satisfy

 ∑i∈NUi(a′i,a−i)≥λW(a′)−μW(a),∀a,a′∈A. (9)

We refer to a game fulfilling (9) as -smooth. If a game is -smooth and for all , [23] proves that the price of anarchy of is lower bounded by

 mina∈NE(G)W(a)maxa∈AW(a)≥λ1+μ. (10)

A similar argument can be used to lower bound the price of anarchy for the family introduced in Section II. In this respect, for any given utility generating mechanism , the best bound on the price of anarchy (6) that can be derived via smoothness is given by the solution to the following program

 RPoA(F,W)=supλ,μ≥0{λ1+μ s.t. (λ,μ) satisfy (???),∀G∈GF,W}. (11)

The term lower bounds , and is often referred to as the robust price of anarchy [23]. Note that the smoothness framework forces us to restrict the attention to mechanisms whose corresponding utilities satisfy

 ∑i∈NUi(a)≤W(a),∀a∈A,∀G∈GF,W, (12)

else no guarantee is provided by [23]. Thus, in the remaining of this section only, we consider utilities satisfying (12).

At first glance it appears that the smoothness framework could be extremely beneficial for characterizing the price of anarchy associated with different utility generating mechanisms. Unfortunately, the following proposition demonstrates a significant weakness associated with this framework.

###### Theorem 1 (Limitations of the smoothness framework).
• Consider the classes of games and differing solely for the choice of the mechanisms. Denote with and the utilities (4) obtained with , and , respectively. Assume that both and satisfy (12). If for all , , , then

 RPoA(F′,W)≤RPoA(F,W). (13)
• The best bound on the price of anarchy that can be obtained using a smoothness argument is provided by a mechanism that is budget balanced, i.e., whose resulting utilities satisfy (12) with equality. The unique mechanism satisfying this constraint for all instances is , with , .

• Consider the weighted maximum coverage problem of Example 1, i.e., let contain only functions of the form for any , , and compare the mechanisms with , where

 fesr(j) =vr⋅1j, ∀j∈N, f⋆r(j) =vr⋅(j−1)!e−1⋅(e−j−1∑i=01i!), ∀j∈N.

For any mechanism , the best bound on the price of anarchy that can be derived with a smoothness argument is

 RPoA(F,W)≤RPoA(Fes,W)=12.

Nevertheless, has better price of anarchy than , as

 PoA(F⋆,W)=1−1e>12=PoA(Fes,W).

The first claim highlights the fact that one can never improve the robust price of anarchy by lowering the agents utility functions from their budget-balanced level, i.e., the case when (12) holds with equality. As a consequence, the utility generating mechanism that gives the best smoothness guarantee must be budget balanced. The third claim demonstrates that such conclusion does not carry over to the true price of anarchy (6), thereby highlighting a significant discrepancy between the robust price of anarchy and the price of anarchy outside the budget-balanced regime. Indeed, the utilities corresponding to satisfy (12) with strict inequality, and yet the mechanism has a significantly better price of anarchy than that of , unlike predicted by the smoothness framework.222While the results of Theorem 1 are stated with respect to Nash equilibria, identical conclusions hold for the broader class of coarse correlated equilibria.

## Iv Characterizing the price of anarchy

In this section we develop a novel framework to characterize the price of anarchy in both budget-balanced and non-budget-balanced regimes. Specifically, we show how to compute the price of anarchy throug a tractable linear program (LP).

In the forthcoming presentation we focus on distributed resource allocation problems where the system-level objective is as in (1) and the local welfare functions are of the form

 Wr(j)=vr⋅w(j),w(j)>0,∀j∈N, (14)

with . The function is fixed, and referred to as welfare basis function. Since associates a positive real number to every integer number , we often denote

as a vector in

. The quantity can be interpreted as the value of the corresponding resource , while scales such value depending on how many agents selected it. In this context, the set contains only functions of the form (14) for all possible values . The vehicle-targets assignment and the weighted maximum coverage problems of Example 1 are of this form. Other problems that can be casted within this framework include - but are not limited - to content distribution in wireless networks [39], information-decoding in noisy channel, combinatorial auctions [40].

Given local welfare functions as in (14), we focus on mechanisms that are linear in their argument, i.e., for which

 F(vr⋅w)=vr⋅F(w),∀vr≥0. (15)

We define , where is hereafter our only design choice. Since associates a real number to every integer number , we often denote as a vector in .

###### Definition 2.

We define as the set of games s.t.

• contains only functions of form (14), is as in (15);

• the number of agents is upper bounded by ;

• the optimum value satisfies ;

We denote the price of anarchy of the class with

 PoA(f,w,n),

as it is completely determined by , and .

### Iv-a The linear program reformulation

We are now ready to state our first main contribution which characterizes the price of anarchy of the set of resource allocations games introduced in Definition 2. While both and are defined over the domain , we artificially set the non-valid extremum points as , for notational convenience, else, e.g., appearing in (17) will not be defined for . Additionally, we define the set

 I\coloneqq{(a,x,b)∈N3≥0 s.t. 1≤a+x+b≤n},

and write instead of . Finally, we associate to each tuple , the decision variable .

###### Theorem 2 (PoA as a linear program).

Let be a welfare basis function, and let .

• If , then for any .

• If instead , , the price of anarchy is

 PoA(f,w,n)=1W⋆, (16)

where is the (finite) value of the following (primal) linear program in the unknowns ,

 (17)

Given , the solution of (17) returns both the price of anarchy, and the corresponding worst case instance encoded in (see the proof in the Appendix). Observe that the number of decision variables is , while only two scalar constraints are present (neglecting the positivity constraint). The previous program can thus already be solved efficiently. Nevertheless, we are interested in the expression of (i.e., in the value ), and therefore consider the dual of (17) in Subsection IV-C. Before doing so, the next subsection provides intuition on the proof of Theorem 2.

### Iv-B Outline of Proof

While Equation (6) corresponds to the definition of price of anarchy, it also describes a (seemingly difficult) optimization problem. The goal of this subsection, is to give an informal introduction on how this optimization problem can be transformed into a finite dimensional LP. The non-interested reader can move forward to the next subsection. We discuss here the case of , as showing that whenever is immediate (see the Appendix). Additionally, we consider only games with exactly agents. This is without loss of generality, as the price of anarchy over the class of games with agents is the same of that over the class of games with  agents.333To see this, note that the price of anarchy of any game with players can be obtained as the price of anarchy of a corresponding game with players where we simply set for the additional players.

Step 1: we observe that the price of anarchy computed over the family of games is the same of the price of anarchy over a reduced family of games, denoted with , where the feasible set of every player only contains two allocations: worst-performing equilibrium and optimal allocation, that is , and definition (6) becomes

 PoA(f,w,n)=infG∈^Gnf,w(W(ane)W(aopt)),s.t.Ui(ane)≥Ui(aopti,ane−i)∀i∈N,

where we have constrained to be an equilibrium. We do not include the additional constraints requiring to be the worst-performing equilibrium and to provide the highest welfare. Taking the infimum over will ensure this.

Step 2: we show that the price of anarchy over the class of games remains unchanged if we introduce the additional constraint . Thus (6) reduces to

 PoA(f,w,n)=infG∈^Gnf,w1W(aopt),s.t.Ui(ane)≥Ui(aopti,ane−i)∀i∈N,W(ane)=1. (18)

Step 3: we relax the previous program as in the following

 infG∈^Gnf,w1W(aopt),s.t.∑i∈N(Ui(ane)−Ui(aopti,ane−i))≥0, W(ane)=1, (19)

where the equilibrium constraints (one per each player) have been substituted by their sum. The main difficulty appearing in (19) is in how to describe an instance and on how to compute the infimum over all such infinite instances. To do so, we note that the objective function and the constraints appearing in (19) can be encoded using only the parameters (see the proof). This trasnforms (19) to the program (17) appearing in Theorem 2.
Step 4: We finally show that the relaxation introduced in Step 3 is tight. Thus, the price of anarchy is the solution of (17).

### Iv-C The dual reformulation

Thanks to strong duality, it suffices to solve the dual program of (17) to compute . For this purpose, let

 IR\coloneqq{(a,x,b)∈I s.t. a⋅x⋅b=0 or a+x+b=n},

and note that contains all the integer points on the planes , , , bounding . While the dual program should feature two scalar decision variables and constraints, the following theorem shows how to reduce the number of constraints to only . The goal is to progress towards an explicit expression for .

###### Theorem 3 (Dual reformulation of PoA).

Let be a welfare basis function, and let .

• If , then for any .

• If instead , , then , where is the (finite) value of the following program

 (20)

The proof of the previous theorem (reported in the Appendix) suggests that a further simplification can be made when is non-increasing for all . In this case the number of constraints reduces to , as detailed next.

###### Corollary 1.

Let be a welfare basis function, and let with .

• If is non-increasing , then , where

 W⋆=minλ∈R≥0,μ∈R μs.t. μw(j)≥w(l)+λ[jf(j)−lf(j+1)] ∀j,l∈[0,n],1≤j+l≤n,μw(j)≥w(l)+λ[(n−l)f(j)−(n−j)f(j+1)] ∀j,l∈[0,n],     j+l>n. (21)
• If additionally , then

 λ⋆=maxl∈[n]w(l)l⋅f(1).

Mimicking the proof of the Corollary 1 (see the Appendix), it is possible to obtain a similar result when is non-decreasing. The result is not included due to space limitations.

###### Remark 1.

If the optimal value is known a priori, as in the second statement of Corollary 1, the price of anarchy can be computed explicitly from (21) as the maximum between real numbers depending on the entries of and . To see this, divide both sides of the constraints in (21) by for . The solution is then found as the maximum of the resulting right hand side, with a corresponding value of

 \medmathW⋆=max⎧⎪ ⎪ ⎪⎨⎪ ⎪ ⎪⎩\medmathmax1≤j+l≤nj,l∈[0,n], j≠0w(l)w(j)+λ⋆[jf(j)w(j)−lf(j+1)w(j)]\medmathmaxj+l>nj,l∈[0,n]w(l)w(j)+λ⋆[(n−l)f(j)w(j)−(n−j)f(j+1)w(j)] (22)

Equation (22) is reminiscent of the result obtained using a very different approach in [41, Theorem 6] (limited to Shapley value) and [29, Theorem 3] (limited to set covering problems). We discuss further connections with these results in Part II.

## V Optimizing the price of anarchy

Given , , and a mechanism , Theorem 3 and Corollary 1 have reduced the computation of the price of anarchy to the solution of a tractable linear program. Nevertheless, determining the mechanism that maximizes , i.e. devising the best mechanism, is also a tractable linear program. The following theorem makes this clear.

###### Theorem 4 (Optimizing PoA is a linear program).

Let be a welfare basis function, . The design problem

 argmaxf∈RnPoA(f,w,n)

is equivalent to the following LP in scalar unknowns

 (23)

The optimal price of anarchy is .

The proof is reported in the Appendix.

###### Remark 2.

The importance of this results stems from its applicability for the game design procedure outlined in the Introduction. As a matter of fact, Theorem 4 allows to compute the optimal mechanism, for any given welfare basis function, and thus to solve the utility design problem. Applications of these results are presented in Part II.

## Vi Conclusions

Motivated by resource allocation problems arising in multiagent and networked systems, we showed how to provide a priori performance guarantees for distributed algorithms based on a game theoretic approach. With this respect, the paper contains two fundamental results. First, we showed that computing the price of anarchy for the considered class of resource allocation problems (and thus the approximation ratio of any algorithm capable of determining a Nash equilibrium) is equivalent to solving a tractable linear program. Second, we showed how to select utility functions so as to maximize such efficiency measure by means of a tractable linear program.

## Appendix A Proof of Theorem 1

###### Proof.

Claim i). Let be a game in , and be the corresponding game in the class of games . Observe that, if every game is smooth with parameters , then every game is also smooth with the same parameters. Indeed, if is -smooth, we have that

 ∑i∈NU′i(a′i,a−i)≥λW(a′)−μW(a),∀a,a′∈A.

Thus, the corresponding game is -smooth, since

 ∑i∈NUi(a′i,a−i)≥∑i∈NU′i(a′i,a−i)≥λW(a′)−μW(a),

for all , where we used the fact that for all , , and (by assumption). This shows that the set of parameters feasible for the program defining is also feasible for the program defining . It follows that

 RPoA(F′,W)≤RPoA(F,W).

Claim ii). If the utility functions do not satisfy (12), then the smoothness framework does not even apply. Hence we must consider mechanisms whose corresponding utilities satisfy (12). In this respect, thanks to the result in (13), it is never advantageous to lower the utilities from their budget balanced level. Thus, the best bound on the price of anarchy achievable using a smoothness argument is attained with a budget balanced mechanism. In this respect, the unique mechanism satisfying (12) with equality is , for all . To see that satisfies the required property note that

 ∑i∈NUi(a)=∑i∈N∑r∈aifesr(|a|r)=∑r∈∪iai|a|rfesr(|a|r)=W(a).

The fact that is the unique such mechanism is because any budget-balanced mechanism must satisfy

 ∑i∈NUi(a)=∑r∈∪iai|a|rfr(|a|r)=∑r∈∪iaiw(|a|r)=W(a),

for all allocations, for all instances. Thus, it suffices to consider instances where only one resource is present and shared by all agents. Since the number of agents is arbitrary, this implies

 |a|rfr(|a|r)=w(|a|r)∀|a|r∈N,

which is satisfied only by .

Claim iii). Thanks to the previous claim, any mechanism for which the smoothness framework applies (i.e., any mechanism whose corresponding utilities satisfies (12)) must satisfy . Thus, we only need to show that . For the mechanism , [29, Theorem 2] shows that (9) holds with and , over all possible instances games where the number of agents is upper bounded by . Since we have not posed any limitations on until now, taking the limit gives , corresponding to To show that there is not better pair we show that the price of anarchy is exactly . To do so, consider the instance proposed in [42, Figure 5] and observe that while . Taking the limit as gives . Since the lower and the upper bound for match, we conclude that . The second inequality is shown upon observing that , thanks to [29]. ∎

## Proof of Theorem 2

###### Proof.

The proof makes the steps 1-4 introduced in Subsection IV-B formal, with particular attention to the steps 3-4. As already clarified in the opening of Subsection IV-B, we consider only games with exactly agents, without loss of generality. Additionally, we focus on the case of . The case of is shown separately in Lemma 1.

Step 1. We intend to show that the price of anarchy computed over is the same of the price of anarchy computed over a reduced set of games. Consider a game and denote with the corresponding worst-performing equilibrium (as measured by ) and with an optimal allocation of . For every such game , we construct a new game , identical to in everything but the allocation sets. The allocation sets of the game are defined as for all , that is, the allocation set of every player in contains only two allocations: an optimal allocation, and the worst-performing equilibrium of . Observe that and have the same price of anarchy, i.e.,

 mina∈NE(G)W(a)maxa∈AW(a)=mina∈NE(^G)W(a)maxa∈^AW(a).

With slight abuse of notation we write to describe the game constructed from as just discussed, and with the class of games . Observe that (by definition) and since for every game , it is possible to construct a game with the same price of anarchy, it follows that can be equivalently computed only using games in , i.e.,

 PoA(f,w,n)=inf^G∈^Gnf,w(mina∈NE(^G)W(a)maxa∈AW(a)).

Step 2. Lemma 2 ensures that for any game , and thus for any game , the equilibrium configuration has strictly positive welfare . Therefore, for every fixed game , one can construct a corresponding game identical to in everything but the value of the resources. Each resource that was associated with a value of in the original game is now associated with a value in the new game . Correspondingly, since that the welfare has the form

 W(a)=∑r∈∪iaivrw(|a|r), (24)

a generic allocation that generated a welfare of as in (24) for the original game , now generates a welfare of for the new game . In particular, the allocation generates a welfare of for the new game . The procedure just introduced simply scales the value of the welfare in all the allocations of by the very same coefficient. Thus remains the worst-performing Nash equilibrium for the new game . Similarly remains an optimal allocation for . Therefore the game must have the same price of anarchy of . In addition, observe that . Hence, using an identical reasoning as the one carried out in Step 1, it follows that the class of games has the same price of anarchy of the subclass where we additionally constraint . Therefore, the price of anarchy can be computed as

 PoA(f,w,n)=inf^G∈^Gnf,w1W(aopt),s.t.Ui(ane)≥Ui(aopti,ane−i)∀i∈N,W(ane)=1.

Step 3. First observe, from the last equation, that , where

 W⋆\coloneqqsup^G∈^Gnf,wW(aopt),s.t.Ui(ane)≥Ui(aopti,ane−i)∀i∈N,W(ane)=1. (25)

We relax the previous program as in the following

 V⋆\coloneqqsup^G∈^Gnf,wW(aopt),s.t.∑i∈N(Ui(ane)−Ui(aopti,ane−i))≥0,W(ane)=1, (26)

where the equilibrium constraints (one per each player) have been substituted by their sum. We now show that appearing in (26) can be computed as

 V⋆=maxθ(a,x,b)∑a,x,bw(b+x)θ(a,x,b)s.t.∑a,x,b[af(a+x)−bf(a+x+1)]θ(a,x,b)≥0,∑a,x,bw(a+x)θ(a