Computing pure Nash and strong equilibria in bottleneck congestion games

Bottleneck congestion games properly model the properties of many real-world network routing applications. They are known to possess strong equilibria—a strengthening of Nash equilibrium to resilience against coalitional deviations. In this paper, we study the computational complexity of pure Nash and strong equilibria in these games. We provide a generic centralized algorithm to compute strong equilibria, which has polynomial running time for many interesting classes of games such as, e.g., matroid or single-commodity bottleneck congestion games. In addition, we examine the more demanding goal to reach equilibria in polynomial time using natural improvement dynamics. Using unilateral improvement dynamics in matroid games pure Nash equilibria can be reached efficiently. In contrast, computing even a single coalitional improvement move in matroid and single-commodity games is strongly NP-hard. In addition, we establish a variety of hardness results and lower bounds regarding the duration of unilateral and coalitional improvement dynamics. They continue to hold even for convergence to approximate equilibria.


Introduction
One of the central challenges in algorithmic game theory is to characterize the computational complexity of equilibria. Results in this direction yield important indicators if game-theoretic solution concepts are plausible outcomes of competitive environments in practice. Probably the most prominent stability concept in (non-cooperative) game theory is the Nash equilibrium -a state, from which no player wants to unilaterally deviate -and its' complexity has been under increased scrutiny for quite some time. A drawback of Nash equilibrium is that in general it exists only in mixed strategies. There are, however, practically important classes of games that allow pure Nash equilibria (PNE), most prominently congestion games. In a congestion game [19], there is a set of resources, and the pure strategies of players are subsets of this set. Each resource has a delay function depending on the load, i.e., the number of players that select strategies containing the respective resource. The individual cost for a player in a regular congestion game is given by the sum over the delays of the resources in his strategy.
Congestion games are an elegant model to study the effects of resource usage and congestion with strategic agents. They have been used frequently to model competitive network routing scenarios [20]. For these games the complexity of exact and approximate PNE is now well-understood. A detailed characterization in terms of, e.g., the structure of strategy spaces [1,8] or the delay functions [4,22] has been derived. However, regular congestion games have shortcomings, especially as models for the prominent application of routing in computer networks. The throughput of a stream of packets is usually determined by the delay experienced due to available bandwidth or capacity of links. Here the throughput of a player is closely related to the performance of the most congested (bottleneck) link (see, e.g., [3,5,13,18]). A model that captures this aspect more realistically are bottleneck congestion games, in which the individual cost of a player is the maximum (instead of sum) of the delays in his strategy. Despite being a more realistic model for network routing, they have not received similar attention in the literature. For classes of non-atomic (with infinitesimally small players) and atomic splittable games (finite number of players with arbitrarily splittable demand) existence of PNE and bounds on the price of anarchy were considered in [5,16]. For atomic games with unsplittable demand PNE do always exist [3]. In fact, Harks et al. [11] establish the finite improvement property via a lexicographic potential function. Interestingly, they are able to extend these conditions to hold even if coalitions of players are allowed to change their strategy in a coordinated way. This implies that bottleneck congestion games do admit even (pure) strong equilibria (SE), a solution concept introduced by Aumann [2]. In a SE, no coalition (of any size) can deviate and strictly decrease the individual cost of each member. Every SE is a PNE, but the converse holds only in special cases (e.g., for singleton games [12]). SE represent a very robust and appealing stability concept. In general games, however, they are quite rare, which makes the existence guarantee in bottleneck congestion games even more remarkable. For instance, even in dominant strategy games such as the Prisoner's Dilemma there might be no SE. Not surprisingly, for regular congestion games with linear aggregation the existence of SE is not guaranteed [12,14]. The existence of PNE and SE in bottleneck congestion games raises a variety of important questions regarding their computational complexity. In which cases can PNE and SE be computed efficiently? As the games have the finite improvement property, another important issue is the duration of natural (coalitional) improvement dynamics. More fundamentally, it is not obvious that even a single such coalitional improving move can be found efficiently. These are the main questions that we address in this paper.

Our Results
We examine the computational complexity of PNE and SE in bottleneck congestion games. In Section 2 we focus on computing PNE and SE using (centralized) algorithms. Our first main result is a generic algorithm that computes a SE for any bottleneck congestion game. The algorithm iteratively decreases capacities on the resources and relies on a strategy packing oracle. The oracle decides if a given set of capacities allows to pack a collection of feasible strategies for all players and outputs a feasible packing if one exists. The running time of the algorithm is essentially determined by the running time of this oracle. We show that there are polynomial time oracles for matroids, a-arborescences, and single-commodity networks. Thus, our generic algorithm yields an efficient algorithm to compute SE for the corresponding classes of games. For general games, however, we show that the problem of computing a SE is NP-hard, even in two-commodity networks.
In Section 3 we study the duration and complexity of sequential improvement dynamics that converge to PNE and SE. We first observe that for every matroid bottleneck congestion game the lazy best response dynamics presented in [1] converge in polynomial time to a PNE. In contrast to this positive result for unilateral dynamics, we show that it is NP-hard to decide if a coalitional improving move exists, even for matroid and single-commodity network games, and even if the deviating coalition is fixed a priori. This highlights an interesting contrast for these two classes of games: While there are polynomial time algorithms to compute a SE, it is impossible to decide efficiently if a given state is a SE -the decision problem is co-NP-hard.
For more general games, we observe in Section 3.2 that constructions of [22] regarding the hardness of computing PNE in regular games can be adjusted to yield similar results for bottleneck games. In particular, in (a) symmetric games with arbitrary delay functions and (b) asymmetric games with bounded-jump delay functions computing a PNE is PLS-complete. In addition, we show that in both cases there exist games and starting states, from which every sequence of improvement moves to a PNE is exponentially long. We extend this result to the case when moves of coalitions of size O(n 1− ) are allowed, for any constant > 0. In addition, we observe that all of these hardness results generalize to the computation of αapproximate PNE and SE, for any polynomially bounded factor α. An α-approximate PNE (SE) is a relaxation of a PNE (SE), which is stable only against (coalitional) improving moves that decrease the delay of the (every) moving player by at least a factor of α > 1.
We conclude the paper in Section 4 by outlining some interesting open problems regarding the convergence to approximate equilibria. All proofs missing in this extended abstract are presented in the Appendix.

Preliminaries
Bottleneck congestion games are strategic games G = (N, S, (c i ) i∈N ), where N = {1, . . . , n} is the non-empty and finite set of players, S = × i∈N S i is the non-empty set of states or strategy profiles, and c i : S → N is the individual cost function that specifies the cost value of player i for each state S ∈ S. A game is called finite if S is finite. For the sake of a clean mathematical definition, we define strategies and costs using the general notion of a congestion model.
. . , n} is a non-empty, finite set of players, R = {1, . . . , m} is a non-empty, finite set of resources, and S = × i∈N S i is the set of states or profiles. For each player i ∈ N , the set S i is a non-empty, finite set of pure strategies S i ⊆ R. Given a state S, we define r (S) = |{i ∈ N : r ∈ S i }| as the number of players using r in S. Every resource r ∈ R has a delay function d r : S → N defined as d r (S) = d r ( r (S)). In this paper, all delay functions are non-negative and non-decreasing. A congestion model M is called matroid congestion model if for every i ∈ N there is a matroid M i = (R, I i ) such that S i equals the set of bases of M i . We denote by rk(M) = max i∈N rk(M i ) the rank of the matroid congestion model. (Bottleneck) congestion games corresponding to matroid congestion models will be called matroid (bottleneck) congestion games. Matroids exhibit numerous nice properties, some of which are described in the Appendix. For a comprehensive overview see standard textbooks [15,Chapter 13] and [21,.
Let M be a congestion model. The corresponding bottleneck congestion game is the strategic game G(M) = (N, S, (c i ) i∈N ) in which c i is given by c i (S) = max r∈S i d r r (S) . We drop M whenever it is clear from context. We define the corresponding regular congestion game in the same way, the only difference is that c i (S) = r∈S i d r r (S) . For a coalition C ⊆ N we denote by −C its complement and by S C = × i∈C S i the set of states of players in C. A pair S, (S C , S −C ) ∈ S × S is called an α-improving move of coalition C if c i (S) > αc i (S C , S −C ) for all i ∈ C and α ≥ 1. For α = 1 we call S, (S C , S −C ) improving move (or profitable deviation). A state S is a k-strong equilibrium (k-SE), if there is no improving move (S, ·) for a coalition of size at most k. We say S is a strong equilibrium (SE) if and only if it is a n-SE. Similarly, S is a pure Nash equilibrium (PNE) if and only if it is a 1-SE. We call a state S an α-approximate SE (PNE) if no coalition (single player) has an α-improving move (S, ·). We denote by I(S) the set of all possible α-improving moves (S, S ) to other states S ∈ S. We call a sequence of states (S 0 , S 1 , . . . ) an improvement path if every tuple (S k , S k+1 ) ∈ I(S k ) for all k = 0, 1, 2, . . . . Intuitively, an improvement path is a path in a so-called state graph G(G) derived from G, where every state S ∈ S corresponds to a node in G(G) and there is a directed edge (S, S ) if and only if (S, S ) ∈ I(S).

Computing Strong Equilibria
In this section, we investigate the complexity of computing a SE in bottleneck congestion games. We first present a generic algorithm that computes a SE for an arbitrary bottleneck congestion game. It uses an oracle that solves a strategy packing problem (see Definition 2.1), which we term strategy packing oracle. For games in which the strategy packing oracle can be implemented in polynomial time, we obtain a polynomial algorithm computing a SE. We then examine games for which this is the case. In general, however, we prove that computing a SE is NP-hard, even for two-commodity bottleneck congestion games.

The Dual Greedy
The general approach of our algorithm is to introduce upper bounds u r (capacities) on each resource r. The idea is to iteratively reduce upper bounds of costly resources as long as the residual capacities admit a feasible strategy packing, see Definition 2.1 below. Our algorithm can be interpreted as a dual greedy, or worst out algorithm as studied, e.g., in the field of network optimization, see Schrijver [21]. Definition 2.1 (Strategy packing oracle). Input: Finite set of resources R with upper bounds (u r ) r∈R , and n collections S 1 , . . . , S n ⊆ 2 R given implicitly by a certain combinatorial property. Output: Sets S 1 ∈ S 1 , . . . , S n ∈ S n such that |i ∈ {1, . . . , n} : r ∈ S i | ≤ u r for all r ∈ R, or the information, that no such sets exist.
More specifically, when the algorithm starts, no strategy has been assigned to any player and each resource can be used by n players, thus, u r = n. If r is used by n players, its cost Algorithm 1: Dual Greedy, the strategy packing oracle is denoted by O.
The algorithm now iteratively reduces the maximum resource cost by picking a resource r with maximum delay d r (u r ) and u r > 0. The number of players allowed on r is reduced by one and the strategy packing oracle checks, if there is a feasible strategy profile obeying the capacity constraints. If the strategy packing oracle outputs such a feasible state S, the algorithm reiterates by choosing a (possibly different) resource that has currently maximum delay. If the strategy packing oracle returns ∅ after the capacity of some r ∈ R was reduced to u r − 1, we fix the strategies of those u r many players that used r in the state the strategy packing oracle computed in the previous iteration and decrease the bounds u r of all resources used in the strategies accordingly. This ensures that r is frozen, i.e., there is no residual capacity on r for allocating this resource in future iterations of the algorithm. The algorithm terminates after at most n · m calls of the oracle. For a formal description of the algorithm see Algorithm 1.

Theorem 2.2. Dual Greedy computes a SE.
Proof. Let S denote the output of the algorithm. In addition, we denote by N k , k = 1 . . . , K, the sets of players whose strategies are determined after the strategy packing oracle (denoted We will show by complete induction over k that the players in N 1 ∪· · ·∪N k will not participate in any improving move of any coalition. We start with the case k = 1. Let (u r ) r∈R be the vector of capacities in the algorithm after the strategy packing oracle returned ∅ in line 5 for the first time and u r is updated in line 6.
Suppose there is a coalition C ⊆ N with C ∩ N 1 = ∅ that deviates profitably from S to T = (S C , S −C ). We distinguish two cases.
Case 1: r (T ) ≤ u r for all r ∈ R. Since O(N, R, S, d,ũ) = ∅, whereũ r = u r − 1, if r = r and u r , else, at least |N 1 | players use r in T . Using d r (T ) ≥ d r (S) for all r ∈ R, we obtain a contradiction to the fact that every member of C must strictly improve.
Case 2: There isr ∈ R such that r (T ) > u r . Using that Dual Greedy iteratively reduces the capacity of those resources with maximum delay (line 3), we derive that dr(T ) ≥ d r (S) for all r ∈ R. Using r (T ) > u r , there is at least one player i ∈ C withr ∈ T i , hence, this player does not strictly improve.
For the induction step k → k + 1, suppose the players in N 1 ∪ · · · ∪ N k stick to their strategies and consider the players in N k+1 . As the strategies of the players in N 1 ∪ · · · ∪ N k are fixed, the same arguments as above imply that no subset of N k+1 will participate in a profitable deviation from S.
It is worth noting that the dual greedy algorithm applies to arbitrary strategy spaces. If the strategy packing problem can be solved in polynomial time, this algorithm computes a SE in polynomial time. Hence, the problem of computing a SE is polynomial time reducible to the strategy packing problem. For general bottleneck congestion games the converse is also true.
Theorem 2.3. The strategy packing problem is polynomial time reducible to the problem of computing a SE in a bottleneck congestion game.
Proof. Given an instance of the set packing problem Π we construct a bottleneck congestion game G Π . Let Π be given as set of resources R with upper bounds (u r ) r∈R , and n collections S 1 , . . . , S n ⊆ 2 R . The game G Π consists of the resource R ∪ {r 1 , . . . , r n } and the players 1, . . . , n + 1. The set of strategies of player i ∈ {1, . . . , n} is {S i ∪ {r i } | S i ∈ S i }. Player n + 1 has the strategies R and {r 1 , . . . , r n }. For each resource r ∈ R The delay is 0 it is used by at most u r + 1 and 2 otherwise. For each resource r ∈ {r 1 , . . . , r n } the delay is 0, if used by at most one player and 1, otherwise.
If a strategy profile of the player 1, . . . , n violates an upper bound u r on a resource r ∈ R, player n + 1 has delay of 2 if he plays strategy R. If he plays {r 1 , . . . , r n } he and all other players have delay of 1. Hence, if there is a feasible strategy packing, every SE of the game yields delay 0 for every player. Otherwise, every SE yields delay 1 for every player. Therefore, the state of the players 1, . . . , n in a SE of G Π corresponds to a solution for the strategy packing problem Π, if such a solution exists. On the other hand, if there is no solution for Π, every player in every SE in G Π has delay of 1.
In the next section we will present some interesting cases, in which the strategy packing problem can be solved in polynomial time, or in which computation becomes NP-hard. Proof. For each matroid M i = (R, I i ), we construct a matroid M i = (R , I i ) as follows. For each resource r ∈ R, we introduce u r resources r 1 , . . . , r ur to R . We say that r is the representative of r 1 , . . . , r ur . Then, a set I ⊂ R is independent in M i if the set I that arises from I by replacing resources by their representatives is independent in M i . This construction gives rise to a polynomial independence oracle for M i . Now, we regard the matroid union M = M 1 ∨· · ·∨M n , see Definition A.1 in the Appendix, which again is a matroid. Using the algorithm proposed by Cunningham [6] we can compute a maximum-size set B in I 1 ∨ · · · ∨ I n in time polynomial in n, m, rk(M), and the maximum complexity of the n independence oracles.

Complexity of Strategy Packing
Clearly, if |B| < i∈N rk(M i ), there is no feasible packing of the bases of M 1 , . . . , M n . If, in contrast, |B| = i∈N rk(M i ), we obtain the corresponding strategies (S 1 , . . . , S n ) using the algorithm.
We now consider strategy spaces defined as a-arborescences, which are in general not matroids. Let D = (V, R) be a directed graph with |R| = m. For a distinguished node in a ∈ V , we define an a-arborescence as a directed spanning tree, where a has in-degree zero and every other vertex has in-degree one. Proof. The problem of finding k disjoint a-arborescences in G can be solved in time O(m 2 k 2 ), see Gabow [10, Theorem 3.1]. Introducing u r copies for each edge r ∈ R, the problem of finding admissible strategies in the original problem is equivalent to finding n disjoint aarborescences.
For single-commodity networks efficient computation of a SE is possible using well-known flow algorithms to implement the oracle. When we generalize to two commodities, however, a variety of problems concerning SE become NP-hard by a simple construction. Proof. Assigning a capacity of u r to each edge and using the algorithm of Edmonds and Karp we obtain a maximum flow within O(m 3 ). Clearly, if the value of the flow is smaller than n, no admissible strategies exist and we can return ∅. If the flow is n or larger we can decompose it in at least n unit flows and return n of them.
Theorem 2.7. In two-commodity network bottleneck games it is strongly NP-hard to (1) compute a SE, (2) decide for a given state whether any coalition has an improving move, and (3) decide for a given state and a given coalition if it has an improving move.
Proof. We reduce from the 2 Directed Arc-Disjoint Paths (2DADP) problem, which is strongly NP-hard, see Fortune et al. [9]. The problem is to decide if for a given directed graph D = (V, A) and two node pairs (s 1 , t 1 ), (s 2 , t 2 ) there exist two arc-disjoint (s 1 , t 1 )-and (s 2 , t 2 )-paths. For the reduction, we define a corresponding two-commodity bottleneck game by introducing non-decreasing delay functions on every arc r by d r (x) = 0, if x ≤ 1 and 1, else.
We associate every commodity with a player. Then, 2DADP is a Yes-instance if and only if every SE provides a payoff of zero to every player. For the other problems we simply construct a solution, in which the strategies are not arc-disjoint. The remaining results follow.

Convergence of Improvement Dynamics
In the previous section, we have outlined some prominent classes of games, for which SE can be computed in polynomial time. Furthermore, it is known [11] that sequential improvement dynamics converge to PNE and SE. We now show that the Nash dynamics convergences quickly to a PNE in matroid games. For the convergence to SE one has to consider deviations of coalitions of players. However, deciding if such a deviation exists is NP-hard even in matroid games or single-commodity network games.

Matroid and Single-Commodity Network Games
We first observe that bottleneck congestion games can be transformed into regular congestion games while preserving useful properties regarding the convergence to PNE. This allows to show fast convergence to PNE in matroid bottleneck games.

Convergence to Pure Nash Equilibria
The following lemma establishes a connection between bottleneck and regular congestion games. For a bottleneck congestion game G we denote by G sum the regular congestion game with the same congestion model as G except that we choose d r (S) = m dr(·) , r ∈ R.
Lemma 3.1. Every PNE for G sum is a PNE for G.
Proof. Suppose S is a PNE for G sum but not for G. Thus, there is player i ∈ N and strategy S i ∈ S i , such that max r∈S i d r ( r (S)) > max r∈S i d r ( r (S i , S −i )). We defined := max r∈S i d r ( r (S i , S −i )). This implies max r∈S i d r ( r (S)) ≥d + 1. We obtain a contradiction by observing We analyze the lazy best response dynamics considered for regular matroid congestion games presented in [1] and combine their analysis with Lemma 3.1. This allows to establish the following result.
Theorem 3.2. Let G be a matroid bottleneck congestion game. Then the lazy best response dynamics converges to a PNE in at most n 2 · m · rk(M) steps.
Proof. We consider the lazy best response dynamics in the corresponding game G sum . In addition, we suppose that a player accepts a deviation only if his bottleneck value is strictly reduced. It follows that the duration is still bounded from above by n 2 · m · rk(M) best responses as shown in [1].

Convergence to Strong Equilibria
For matroid bottleneck congestion games we have shown above that it is possible to converge to a PNE in polynomial time by a kind of best-response dynamics with unilateral improving moves. While previous work [11] establishes convergence to SE for every sequence of coalitional improving moves, it may already be hard to find one such move. In fact, we show that an αimproving move can be strongly NP-hard to find, even if strategy spaces have simple matroid structures. This implies that deciding whether a given state is an α-approximate SE is strongly co-NP-hard -even if all delay functions satisfy the β-bounded-jump condition 1 for any β > α. Theorem 3.3. In matroid bottleneck congestion games it is strongly NP-hard to decide for a given state S if there is some coalition C ⊆ N that has an α-improving move, for every polynomial time computable α.
Proof. We reduce from Set Packing. An instance of Set Packing is given by a set of elements E and a set U of sets U ⊆ E, and a number k. The goal is to decide if there are k mutually disjoint sets in U . Given an instance of Set Packing we show how to construct a matroid game G and a state S such that there is an improving move for some coalition of players C if and only if the instance of Set Packing has a solution.
The game will include |N | = 1 + |U | + |E| + U ∈U |U | many players. First, we introduce a master player p 1 , which has two possible strategies. He can either pick a coordination resource r c or the trigger resource r t . For each set U ∈ U , there is a set player p U . Player p U can choose either r t or a set resource r U . For each set U and each element e ∈ U , there is an inclusion player p U,e . Player p U,e can use either the set resource r U or an element resource r e . Finally, for each element e, there is an element player p e that has strategies {r c , r e } and {r c , r a } for some absorbing resource r a .
The state S is given as follows. Player p 1 is on r c , all set players use r t , all inclusion players the corresponding set resources r U , and all element players the strategies {r c , r e }. The coordination resource r c is a bottleneck for the master player and all element players. The delays are d rc (x) = α + 1, if x > |E| and 1, otherwise. The trigger resource has delay d rt (x) = 1, if x ≤ |U | − k + 1, and α + 1, otherwise. For the set resources r U the delay is d r U (x) = 1, if x ≤ 1 and α + 1, otherwise. Finally, for the element resources the delay is d re (x) = 1 if x ≤ 1 and α + 1 otherwise.
Suppose that the underlying Set Packing instance is a Yes-instance, then an α-improving move is as follows. The master player moves to r t , the k set players corresponding to a solution choose their set resources, the respective inclusion players move to the element resources, and all element players move to r a . The delay of r c reduces from α + 1 to 1, and the delay of r t reduces from α + 1 to 1. Thus, the master player, all set players, and all element players improve their bottleneck by a factor of α + 1. The migrating inclusion players do not interfere with each other on the element resources. Thus, they also improve the delay of their bottleneck resource by factor α + 1, and we have constructed an α-improving move for the coalition of all migrating players, all set players, and all element players.
Suppose that the underlying Set Packing instance is a No-instance. For contradiction, assume that there is a coalition C that has an α-improving move. Consider any player p ∈ C. We will show that for any player p = p 1 , i.e., any set, inclusion, or element player, p 1 ∈ C is a prerequisite for achieving any strict improvement. We first note that the master player can never strictly improve without changing his strategy, because all element players will always use r c in their strategy. A move from r c to r t is an improvement if and only if at least k set players drop r t . These players must switch to the corresponding resources. However, for a set player p M such a move is an improvement if and only if all inclusion players on r U drop this resource from their strategy. These inclusion players must switch to the element resources. An inclusion player p U,e improves by such a move if and only if the element player drops the resource and p U,e is the only inclusion player moving to r e . This implies that the moving set players must correspond to sets that are mutually disjoint. Finally, the element players move from r e to r a with delay d ra = 0, and this is an improvement if and only if the master player moves away from r c . This last argument establishes that p ∈ C implies p 1 ∈ C.
However, if the master player p 1 ∈ C, then we again follow the chain of reasoning above and see that the players corresponding to at least k mutually disjoint sets must move and therefore be in C. This is a contradiction to having a No-instance.
Finally, we can add the resource r a to every strategy of the master, set, and inclusion players. In this way, the combinatorial structure of all strategy spaces is the same -a partition matroid M with rk(M ) = 2 and partitions of size 1 and 2 -only the mapping to resources is different for each player.
The previous theorem shows hardness of the problem of finding a suitable coalition and a corresponding improving move. Even if we specify the coalition in advance and search only for strategies corresponding to an improving move, the problem remains strongly NP-hard.
Corollary 3.4. In matroid bottleneck congestion games it is strongly NP-hard to decide for a given state S and a given coalition C ⊆ N if there is an α-improving move for C, for every polynomial time computable α.
Proof. We will show this corollary using the games constructed in the previous proof by fixing the coalition C = N . Consider the construction in the previous proof. The coalition described above that has an improving move for a Yes-instance consists of the master player, all set players, all element players and the inclusion players that correspond to the sets of the solution to Set Packing. However, the inclusion players are only needed to transfer the chain of dependencies to the element players. We can set the strategy space of player p U,e to {r h , r l } × {r U , r e }. Here r h and r l are two resources with delays d r h = α + 1 and d r l = 0. In S we assign the inclusion players to strategies {r h , r U }. Then an improving move for the inclusion players that remain on r U is to exchange r h by r l . Thus, the problem of finding an arbitrary coalition with an improving move becomes trivial. However, we strive to obtain an improving move for C = N , and this must generate improvements for the master player and the set players. Thus, we still must reassign some inclusion players from the resources r U to the element resources r e . Here we need to resolve conflicts as before, because otherwise inclusion players end up with a delay of α + 1 on r e and do not improve. Following the previous reasoning we have an α-improving move if and only if the underlying Set Packing instance is solvable. Finally, by appropriately adding dummy resources, we can again ensure that the combinatorial structure of all strategy spaces is the same.
We can adjust the previous two hardness results on matroid games to hold also for singlecommodity network games. Theorem 3.5. In single-commodity network bottleneck congestion games it is strongly NPhard to decide for a given state S (1) if there is some coalition C ⊆ N that has an α-improving move, and (2) if a given coalition C ⊆ N has an α-improving move, for every polynomial time computable α.
Proof. We transform the construction of Theorem 3.3 into a symmetric network bottleneck congestion game, see Fig. 1 for an example. First, we introduce for each resource r c , r t , r U for all U ∈ U and r e for all e ∈ E an edge with the corresponding delay function as before. Additionally, we identify players and their strategies by routing them through a set of gadgets composed of edges, which have capacities implemented by cost functions that are 1 up to a capacity bound and α + 10 above.
The first gadget is to separate the players into groups. An edge with capacity 1 identifies the master player, an edge with capacity |U | the set players, an edge with capacity U ∈U |U | the inclusion players, and an edge with capacity |E| the element players. The set and inclusion players are then further divided into their particular identities by edges of capacity 1. The element players route all over r c . In addition, the master player has the alternative to route over r c or r t . After the players have passed r c they again split into specific element players using edges of capacity 1. One player is allowed to route directly to the source t. This is meant to be the master player, but it does not hurt our argument if this is not the case.
After the players have routed through the capacitated gadgets, they can be assumed to reach an identification point (indicated by gray nodes in Fig. 1) and obtain an identity. Then they decide on a strategy from the previous game by routing over one of two allowed paths. In particular, we can allow the set players to route either over r t or their r U , the inclusion players over r U or r e , and the element players over r e or directly to the sink t.
We can create the corresponding state S as before by assigning the master player to route over r c directly to the sink, the set players over r t , the inclusion players over r U and the element players over r e . This assignment is such that every player receives one identity (i.e., routes over exactly one gray node) and every identity is taken (i.e., every gray node is reached by exactly one player). This property also holds for every improving move -with the exception of one element player, who might route directly from r c to the sink, but as noted before this does not hurt the argument.
Our network structure allows to reconstruct the reasoning as before. Any improving move must include the master player, which improves if and only if he moves together with players corresponding to a solution to the Set Packing instance. Note that even by switching player identities, we cannot create an improving move when the underlying Set Packing instance is unsolvable. This proves the first part of the theorem.
For the second part, we use the same adjustment as in Corollary 3.4 to ensure that inclusion players can always improve. Directly before the middle fan out (see Figure 1) that results in identification of inclusion players we simply insert a small gadget with 2 parallel edges r l and r h . In this way, all inclusion players must route over one of r l or r h and one of their corresponding r U or r e . This resembles the strategy choices in the matroid game and yields hardness of computing an improving move for the coalition C = N . This proves the theorem.

General Games and Approximation
The results of the previous sections imply hardness of the computation of SE or coalitional deviations, even in network games. Therefore, when considering general games we here restrict ourselves mostly to unilateral improving moves and PNE. Unfortunately, even in this restricted case the hardness results for regular congestion games in Skopalik and Vöcking [22] immediately imply identical results for bottleneck congestion games. The main result of [22] shows that computing an approximate PNE is PLS-hard. The proof is a reduction from Cir-cuitFlip. We can regard the resulting congestion game as a bottleneck congestion game. It is straightforward to adjust all arguments in the proof of [22] to remain valid for bottleneck congestion games. We provide some details on the construction of the class G(n) of games in the Appendix. A standard transformation [8] immediately yields the same result even for symmetric games, in which S i = S j for all i, j ∈ N . Corollary 3.6. Finding an α-approximate PNE in a symmetric bottleneck congestion game with positive and increasing delay functions is PLS-complete, for every polynomial-time computable α > 1.
A second result in [22] reveals that sequences of α-improving moves do not reach an αapproximate PNE quickly -even if all delay functions satisfy the β-bounded-jump condition with a constant β. Again, the proof remains valid if one regards the game as an asymmetric bottleneck congestion game. This yields the following corollary.
Corollary 3.7. For every α > 2, there is a β > 1 such that, for every n ∈ N, there is a bottleneck congestion game G(n) and a state S with the following properties. The description length of G(n) is polynomial in n. The length of every sequence of α-improving moves leading from S to an α-approximate equilibrium is exponential in n. All delay functions of G(n) satisfy the β-bounded-jump condition.
Using the same trick as before to convert an asymmetric game in a symmetric one yields a similar result for symmetric games. However, we must sacrifice the β-bounded-jump condition of the delay functions, for every β polynomial in n.
Despite the fact that (coalitional) improving moves are NP-hard to compute, one might hope that the state graph becomes sufficiently dense such that it allows short improvement paths. Unfortunately, we can show that this is not true, even if we consider all improving moves of coalitions of size up to O(n 1− ), for any constant > 0. Again, the same result holds for symmetric games when sacrificing the bounded-jump condition.
Theorem 3.8. For every α > 2, there is a β > 1 such that, for every n ∈ N and for every k ∈ N, there is a bottleneck congestion game G(n, k) and a state S with the following properties. The description length of G(n, k) is polynomial in n and k. The length of every sequence of α-improving moves of coalitions of size at most k leading from S to an α-approximate k-SE is exponential in n. All delay functions of G(n, k) satisfy the β-bounded-jump condition.
Proof. Our proof adjusts the construction of [22], which we recapitulate in the Appendix. The main idea of our adjustment is to construct a bottleneck congestion game G(n, k) by generating k copies of the game G(n). We then add resources to the strategies. These resources make sure that there is a improvement step for a player in G(n) if and only if there is a improvement step of corresponding k players of the k copies in G(n, k).
To each strategy j ∈ {1, . . . , 9} of player every Main i of every the copy m ∈ {1, . . . , k} we add a resource A j i,k . Additionally, we add this resource to all strategies j = j of all players Main i of every other copy m = m. Each of these resources has delay of δ i−1 if it is allocated by at most one player and δ i+3 otherwise. Analogously, we add resources to the strategies of the auxiliary players. That is, for every player Block j i of every copy m ∈ {1, . . . , k}, we add a resource B j i in his strategy 1. We also add his resource in every strategy 2 of the every player Block j i of every other copies m = m. Similarly, for every player Block j i of every copy m ∈ {1, . . . , k}, we add a resource C j i in his strategy 2, which we also add to every strategy 1 of the every player Block j i of every other copies m = m. Each of these resources has a delay of δ i−1 if it is allocated by at most one player and δ i+3 otherwise. Finally, we have to increase δ slightly.
We obtain the initial strategy profile s of G(n, k) if every player of every copy m of G(n) plays according to the initial strategy profile S of his copy. It it easy to see, that no coalition of less than k player of a copy m has an incentive to change their strategies. At least one of them would have to allocate a A-, B-, or C-resource that is already in use by another player. Thus, it is not an improvement step for these players. We, therefore, can conclude that all k copies of a player always choose the same strategy. On the other hand, if there is an improving move of one player in G(n), there is a coalitional improving move of all k copies of that player in G(n, k). If all players mimic this deviation in their copies, by construction, no two players allocate the same A-, B-, or C-resource. Furthermore, if the improvement step decreases the delay in G(n), it does so for every copy of the player in G(n, k).
Finally, note that as long as k is polynomial in n we obtain a reduction of polynomial size. In particular, for k = n 1/ −1 we obtain a new game with nk players, for which the unilateral moves of G(n) are exactly moves of coalitions of size (nk) 1− and no smaller coalitions have improving moves. This proves the theorem.

Conclusion
We have provided a detailed study of the computational complexity of exact and approximate pure Nash and strong equilibria in bottleneck congestion games. However, some important and fascinating open problems remain. While we have shown that results from [22] essentially translate, we were not able to establish the positive result of [4] about quick convergence to approximate PNE for symmetric games with bounded-jump delays. In addition, there are open problems regarding the duration of unilateral dynamics in symmetric network games and hardness of computing PNE in asymmetric networks. Finally, it would be interesting to see how results on centralized computation of SE extend to the computation of α-approximate SE and k-SE, for 1 < k < n.
These sequences are deterministic apart from the order in which some auxiliary players make their improvement steps. The main player has nine strategies numbered from 1 to 9. Each auxiliary player has two strategies, a first and a second one. A gadget G i is idle if all of its players play their first strategy. Gadget G i+1 activates gadget G i by increasing the delay of (the bottleneck resource in) the first strategy of player Main i . In the following sequence of improvement steps the player Main i successively changes to the strategies 2, . . . , 8. We call this sequence a run of G i . During each run, M ain i activates gadget G i−1 twice by increasing the delay of the (bottleneck resource in the) first strategy of Main i−1 . Gadget G i+1 is blocked (by player Block 8 i ) until player Main i reaches its strategy 9. Then G i+1 continues its run, that is, it decreases the delay of the bottleneck resource in the first strategy of player Main i , waits until gadget G i becomes idle again, and afterwards triggers a second run of G i . The role of the auxiliary players of G i is to control the strategy changes of Main i and Main i+1 .

Strategies of Block
In the initial state s, every gadget G i with 1 ≤ i ≤ n − 1 is idle. Gadget G n is activated. In every improvement path starting from s, gadget G i is activated 2 n−i times, which yields the theorem. Now we go into the details of our construction. The (bottleneck) congestion game G(n) consists of the gadgets G 1 , . . . , G n . Each gadget G i consists of a player Main i and the players Block 1 i , . . . , Block 8 i . The nine strategies of a player Main i are given in Figure 3. The two strategies of a player Block j i are given in Figure 2. δ = 10α 9 is a scaling factor for the delay functions.
The auxiliary players implement a locking mechanism. The first strategy of player Block j i is {t j i , b j i } and its second strategy is {c j i }. The delays of the resources b j i and c j i are relatively small (δ i−1 and 2αδ i−1 , respectively) if allocated by only one player. If they are allocated by two or more players, however, then each of them induce a significantly larger delay of δ i+2 . Theses resources are also part of the strategies of Main i or Main i+1 . Note, that neither Main i nor Main i+1 has an incentive to change to a strategy having a delay of δ i+2 or more. The delay of the resource t j i is chosen such that Block j i has an incentive to change to its second strategy if Main i allocates this resource. If Main i neither allocates this resource nor the resource b j i , it has an incentive to change to its first strategy. Due to scaling factor δ i−1 the delays of the resource t j i do not affect the preferences of Main i . These definitions yield the following properties. If auxiliary player Block j i of gadget G i plays its first strategy then this prevents Main i from choosing strategy j + 2. Player Block j i has an incentive to change to its second strategy only if player Main i chooses its strategy j + 1. By this mechanism, we ensure that Main i chooses the strategies 1 to 8 in the right order. In addition, the first strategy of Block 8 i prevents Main i+1 from going to strategy 4 or 8. This ensures that Main i+1 waits until the run of player Main i is completed. Furthermore, Main i+1 can enter into strategy 3 or 7 only if all auxiliary players of gadget G i use their first strategy. This ensures that a run starts with all auxiliary players being in their first strategy.
This shows that in every sequence of improvement steps from s to a Nash equilibrium in the (bottleneck) congestion game G(n) each gadget i is activated 2 n−i times. One can easily check that every improvement step of a player decreases its delay (of the bottleneck resource) by a factor of at least α and every delay function satisfies the β-bounded-jump condition with β = δ 3 with δ = 10α 9 .