The Minimum Tollbooth Problem in Atomic Network Congestion Games with Unsplittable Flows

TL;DR

This paper studies the problem of placing the minimum number of tolls in atomic congestion games to achieve social optima as Nash equilibria, proving NP-hardness and providing efficient solutions for series-parallel graphs.

Contribution

It introduces the minimum tollbooth problem for atomic games, proves its computational hardness, and offers a polynomial-time algorithm for series-parallel networks.

Findings

The problem is NP-hard and W[2]-hard when parameterized by tolled edges.

A polynomial-time algorithm exists for series-parallel graphs.

Tolls can be optimally placed to align Nash equilibria with social optima in certain network classes.

Abstract

This work analyzes the minimum tollbooth problem in atomic network congestion games with unsplittable flows. The goal is to place tolls on edges, such that there exists a pure Nash equilibrium in the tolled game that is a social optimum in the untolled one. Additionally, we require the number of tolled edges to be the minimum. This problem has been extensively studied in non-atomic games, however, to the best of our knowledge, it as not been considered for atomic games before. By a reduction from the weighted CNF SAT problem, we show both the NP-hardness of the problem and the W[2]-hardness when parameterizing the problem with the number of tolled edges. On the positive side, we present a polynomial time algorithm for networks on series-parallel graphs that turns any given state of the untolled game into a pure Nash equilibrium of the tolled game with the minimum number of tolled edges.

Full text

By a reduction from the weighted CNF SAT problem, we show both the NP-hardness of the problem and the W[2]-hardness when parameterizing the problem with the number of tolled edges. On the positive side, we present a polynomial time algorithm for networks on series-parallel graphs that turns any given state of the untolled game into a pure Nash equilibrium of the tolled game with the minimum number of tolled edges.

1 Introduction

A class of games that are guaranteed to admit at least one pure Nash equilibrium are congestion games, as introduced by Rosenthal rosenthal1973class . However, several well-known results (for example presented by Christodoulou and Koutsoupias christodoulou2005price or Roughgarden and Tardos roughgarden2002bad ) indicate, that playing a Nash equilibrium rarely leads to a state that is socially beneficial. Especially in network congestion games, an approach to push the players towards a social optimum is the levy of tolls on edges of the network. The goal of these tolls is to turn a social optimum of the untolled game into a pure Nash equilibrium of the tolled game. The application of such tolls was shown to be highly beneficial (bilo2016dynamic ; cole2006much ). If we allow the number of players to be infinite, each routing an infinitesimal amount of flow through the network, it is well known that tolls fulfilling the property exist and can be efficiently computed (beckmann1956studies ; cole2003pricing ; fleischer2004tolls ; pigou1932economics ).

Games with a finite number of players are called atomic. The use of tollbooths in atomic games has a comparably short history. One of the main differences to the previous problem is that the strategy change of a single player has a substantial impact on all other players. Additionally, for the non-atomic games, it can be assumed that the resulting pure Nash equilibrium is unique, requiring only light restrictions, see, e.g., Roughgarden and Tardos roughgarden2002bad . As shown by Orda, Rom, and Shimkin, orda1993competitive this is not necessarily the case in atomic games.

Further differentiating the problem leads to the question: Does it suffice that there is at least one Nash equilibrium that corresponds to a social optimum, or must all Nash equilibria correspond to a social optimum? Fotakis, Karakostas, and Kolliopoulos analyzed whether tolls fulfilling the desired properties exist. They conclude in fotakis2010existence that in the latter case the existence cannot be guaranteed even for simple parallel-link networks. On the other hand, for the former case, they can confirm the existence of tolls in games where all players share the same source node and give a polynomial time algorithm calculating the tolls. Other work on this topic is, e.g., Fotakis and Spirakis fotakis2008cost or Caragiannis, Kaklamanis, and Kanellopoulos caragiannis2006taxes . Another line of research allows the players to split up their flow (cominetti2009impact ; swamy2007effectiveness ). We focus on games with unsplittable flows; therefore we do not go into detail with this other branch.

Several papers have focused on special cases of the above problem, restricting, e.g., the height of the tolls (bonifaci2011efficiency ), the set of tollable edges (harks2015computing ), or knowledge about the number of players (colini2018demand ). We consider here the minimum tollbooth problem, first introduced by Hearn and Ramana hearn1998solving . In this problem, we additionally try to minimize the number of tolled edges. Work on this topic is mainly restricted to non-atomic games, with several heuristics as a result (e.g., bai2010heuristic ; bai2009combinatorial ; bai2008evolutionary ; harwood2005genetic ; stefanello2017minimization ). The NP-hardness of the non-atomic case with multiple commodities was shown by Bai, Hearn, and Lawphongpanich in bai2010heuristic and later for the single commodity case by Basu, Lianeas, and Nikolova in basu2015new . On the positive side, Basu, Lianeas, and Nikolova give a polynomial time algorithm, if the network is a series-parallel graph basu2015new .

Contribution:

In this work, we analyze the complexity of the minimum tollbooth problem for atomic network congestion games with unsplittable flows. As mentioned before, it is already known that such tolls may not exist considering the case in which every pure Nash equilibrium of the tolled game must correspond to a social optimum of the original one fotakis2010existence . Therefore, we focus on the problem in which it is only required that there exist a pure Nash equilibrium that corresponds to a social optimum of the untolled game. By a reduction from the weighted CNF SAT problem, we show that the problem is NP-hard. Furthermore, we also prove that the parameterized problem considering the number of tollbooths as the parameter is W[2]-hard, giving evidence that the parameterized problem is not in FPT. An additional spin-off result originates in the nature of the reduction: Finding a social optimum in atomic network congestion games with unsplittable flows is hard, supporting and extending existing results (see, e.g., Chakrabarty, Mehta, and Nagarajan chakrabarty2005fairness or Meyers and Schulzmeyers2008complexity ).

We also show that for a non-trivial graph class, it is possible to efficiently calculate a solution with the smallest possible number of toll booths. Based on the algorithm by Basu, Lianeas, and Nikolova from basu2015new , we construct a polynomial time algorithm on games based on series-parallel graphs that turns any given state of the untolled game into a pure Nash equilibrium of the tolled game with the minimum number of tolled edges.

2 Preliminaries

This section introduces essential general definitions. In an attempt to shorten some statements, we will sometimes use the expression $[d]$ for the set $\{1,...,d\}$ for any natural number $d$ throughout the work.

Definition 1

An atomic network congestion game is a tuple

$\Gamma=(G,N,(c_{e})_{e\in E},(s_{i},t_{i})_{i\in N})$

with $G=(V,E)$ being an undirected graph, $N=\{1,...,n\}$ a set of players, $c_{e}$ non-negative, monotonically increasing cost functions from the set of possible states of the game to the real numbers, and $(s_{i},t_{i})$ source-sink pairs with $s_{i},t_{i}\in V$. The strategies for a player $i$ are the paths from $s_{i}$ to $t_{i}$. The game is called symmetric, if $s_{i}=s_{j}$ and $t_{i}=t_{j}$ for all players $i$ and $j$. It is called single-source (single-sink) if all players share the same source (sink). A state $S=(S_{1},...,S_{n})$ is a vector of strategies of players ($S_{i}$ is a strategy of player $i$). The congestion $n_{e}(S)$ on an edge $e$ is the number of players using that edge in their strategy in state $S$. The cost of a player in state $S$ is $\gamma_{i}(S)=\sum_{e\in S_{i}}c_{e}(n_{e}(S))$, where $S_{i}$ is the strategy of player $i$ in $S$. The social cost of a state is the sum of the costs of all players. A social optimum is a state with minimum social cost. A state $S$ is a pure Nash equilibrium, if for every player $i$ and every state $S^{\prime}$, $\gamma_{i}(S)\leq\gamma_{i}((S^{\prime}_{i},S_{-i}))$. Hereby, the state $(S^{\prime}_{i},S_{-i})$ denotes player $i$ playing his strategy from $S^{\prime}$ and all other players remaining on their strategy of state $S$.

Definition 2

The minimum tollbooth problem (MINTB) on atomic network congestion games is the task of finding tolls for the edges of the network such that a social optimum of the untolled game is a pure Nash equilibrium in the tolled game while tolling only the minimum necessary number of edges. The tolls are depicted by a toll vector $\theta=(t_{e_{1}},...,t_{e_{|E|}})$, with $t_{i}\in\mathbb{R}^{+}_{0}$. An edge $e_{i}$ is called tolled if $t_{e_{i}}>0$, and untolled otherwise.

We say a state $S$ is implemented in an atomic network congestion game $\Gamma^{\theta}$ if $\theta$ is a toll vector such that $\Gamma^{\theta}=(G,N,(c_{e}^{\theta})_{e\in E},(s_{i},t_{i})_{i\in{N}})$ with $c_{e}^{\theta}(S)=c_{e}(S)+t_{e}$ has $S$ as a pure Nash equilibrium. The state is optimally implemented if for this purpose the minimum necessary number of edges is tolled.

3 Atomic MINTB is Hard

This section gives the reduction of the weighted CNF SAT problem to the atomic MINTB problem. We consider formulas in conjunctive normal form (CNF).

Definition 3

A Boolean formula $F$ is in CNF if $F=C_{1}\wedge...\wedge C_{n}$. Hereby, $C_{i}$ is called clause and must have the form $C_{i}=(u_{i,1}\vee...\vee u_{i,k_{i}})$. The $u_{i,j}$ are called literals, with $u_{i,j}\in\{x_{1},...,x_{n}\}\cup\{\overline{x_{1}},...,\overline{x_{n}}\}$. The $x_{i}$ are called variables, with $x_{i}\in\{0,1\}$.

Definition 4

weighted CNF SAT:

[TABLE]

The weight of an assignment is its Hamming weight, i.e., the number of variables with value 1.

It is well known, that weighted CNF SAT is a W[2]-complete problem, see, e.g., chapter 12 of downey2012parameterized or chapter 13 of cygan2015parameterized . This gives evidence that the problem does not lie in the class FPT.

Definition 5

Let $\mathcal{A}$ be a parameterized problem with parameter $k$. We say that $\mathcal{A}$ is fixed-parameter tractable (FPT), if there exists an algorithm solving $\mathcal{A}$ with running time in $\mathcal{O}(p(n)\cdot f(k))$. Here, $p(n)$ is a polynomial that depends on the problem size of $\mathcal{A}$ but not on the parameter $k$, and $f(k)$ is any function that only depends on the parameter $k$.

For more information on parameterized problems, we highly recommend downey2012parameterized by Downey and Fellows or cygan2015parameterized by Cygan et al.

We will reduce weighted CNF SAT to atomic MINTB in such a way, that the minimum number of necessary tollbooths is exactly the minimum weight of a satisfying assignment of the formula. We will construct an atomic network congestion game $\Gamma_{F}$ based on formula $F$, where $F$ is in CNF with $n$ variables $x_{1},...,x_{n}$ and $m$ clauses $C_{1},...,C_{m}$. We will call $\Lambda^{0}_{x_{i}}$ ($\Lambda^{1}_{x_{i}}$) the number of occurrences of variable $x_{i}$ in $F$ in negative (positive) form, $\Lambda_{x_{i}}=\Lambda^{0}_{x_{i}}+\Lambda^{1}_{x_{i}}$ and $\Lambda=\sum_{i=1}^{n}\Lambda_{x_{i}}$. The game will be played by a total of $m+\Lambda+n$ players, each fulfilling a specific role. The $m$ players, called clause players, will each try to find a strategy that can be identified as satisfying a different clause. This will be done by each player choosing the occurrence of a literal in the clause in order to satisfy it. The $\Lambda$ players, or occurrence players, will ensure that while satisfying the clauses, a variable cannot be assigned both value 0 and 1. Lastly, the $n$ players are the variable players, that will state which edges have to be tolled to optimally implement a social optimum. Most players will have both different sources and different sinks.

For the reduction to be correct, the game $\Gamma_{F}$ has to fulfill the following properties:

1. I)

Each clause player chooses a strategy that represents the satisfaction of a different clause. 2. II)

If two clause players choose the same variable as a representative, they both choose either its positive or its negative form, but not a mixture. 3. III)

Optimally implementing a social optimum requires at least $k$ toll stations, where $k$ is the weight of the minimum satisfying assignment of $F$. 4. IV)

From the tolled edges, the minimum satisfying assignment can be reconstructed in polynomial time.

We start by constructing a graph for a game that satisfies property I). Only the clause players play this game.

Let $G_{1}(V_{1},E_{1})$ be the undirected graph with

\begin{array}[]{rcl}V_{1}&=&\{s\}\\ &\cup&\{v_{i},v_{i}^{0},v_{i}^{1}|i\in[n]\}\\ &\cup&\{l^{0}_{x_{i},j,k},r^{0}_{x_{i},j,k},z^{0}_{x_{i},j}|i\in[n],j\in[\Lambda^{0}_{x_{i}}],k\in[\Lambda^{1}_{x_{i}}]\}\\ &\cup&\{l^{1}_{x_{i},j,k},r^{1}_{x_{i},j,k},z^{1}_{x_{i},j}|i\in[n],j\in[\Lambda^{1}_{x_{i}}],k\in[\Lambda^{0}_{x_{i}}]\}\\ &\cup&\{c_{i}|i\in[m]\},\\ E_{1}&=&\{\{s,v_{i}\},\{v_{i},v_{i}^{0}\},\{v_{i},v_{i}^{1}\}|i\in[n]\}\\ &\cup&\{\{v_{i}^{0},l^{0}_{x_{i},j,1}\},\{l^{0}_{x_{i},j,k},r^{0}_{x_{i},j,k}\},\{r^{0}_{x_{i},j,k},l^{0}_{x_{i},j,k+1}\}|i\in[n],j\in[\Lambda^{0}_{x_{i}}],\\ &&\hskip 199.16928ptk\in[\Lambda^{1}_{x_{i}}]\}\\ &\cup&\{\{v_{i}^{1},l^{1}_{x_{i},j,1}\},\{l^{1}_{x_{i},j,k},r^{1}_{x_{i},j,k}\},\{r^{1}_{x_{i},j,k},l^{1}_{x_{i},j,k+1}\}|i\in[n],j\in[\Lambda^{1}_{x_{i}}],\\ &&\hskip 199.16928ptk\in[\Lambda^{0}_{x_{i}}]\}\\ &\cup&\{\{r^{0}_{x_{i},j,\Lambda^{1}_{x_{i}}},z_{x_{i},j}\},\{z_{x_{i},j},c_{k}\}|i\in[n],j\in[\Lambda^{0}_{x_{i}}],\\ &&\hskip 120.92421ptk\mbox{ is the }j\mbox{th smallest index s.t. }\overline{x_{i}}\in C_{k}\}\\ &\cup&\{\{r^{1}_{x_{i},j,\Lambda^{0}_{x_{i}}},z_{x_{i},j}\},\{z_{x_{i},j},c_{k}\}|i\in[n],j\in[\Lambda^{1}_{x_{i}}],\\ &&\hskip 120.92421ptk\mbox{ is the }j\mbox{th smallest index s.t. }x_{i}\in C_{k}\}.\end{array}

The cost functions for the edges are a constant $7$ for each $\{v_{i},v_{i}^{1}\}$ edge, a constant $2$ for each $\{v_{i},v_{i}^{0}\}$ edge and a constant [math] for each $\{s,v_{i}\}$ edge. All other edges have cost [math] for one, and $\infty$ (symbolizing a very large number) for any other number of players. As mentioned before, the game is played by the $m$ clause players. Each clause player $i$ has $s$ as source and $c_{i}$ as sink. Clearly, every node $c_{i}$ is reached by precisely one player, representing the satisfaction of property I). This is forced by every player having a different clause as their sink. Property I) could have been satisfied with a far simpler structure; however, this complex construction is necessary to fulfill the other properties in the upcoming steps. Also, the reason behind the choice of the cost functions will shortly become clear.

Figure 1 displays this construction for the simple satisfiable formula $F=A\wedge(\overline{A}\vee B)$. For simplification, the names of the $l,r$ and $z$ nodes are shortened.

From now on, we call a path from a node $x_{i}^{1}$ to $z_{x_{i}}^{1}$ a 1-Path, and from node $x_{i}^{0}$ to $z_{x_{i}}^{0}$ a 0-path. Similarly, we say a player assigns $1$ ([math]) to variable $x_{i}$ if he chooses the respective 1-Path (0-Path).

A path from a player from $s$ to an (unsatisfied) clause node $c_{j}$ chooses the positive or negative occurrence of a variable in $C_{j}$ in order to satisfy the clause. However, currently, it is possible that two clauses are reached over the same variable, while once in its negative and once in its positive form, i.e., property II) is not satisfied. This is the case in the example of Fig. 1. The red lines indicate the social optimum. The social optimum satisfies clause $\{\overline{A},B\}$ by assigning [math] to $A$ even though 1 was already assigned to $A$. We extend our game to fulfill property II). In addition to the clause players, the game will now be played by the occurrence players as well.

Let $G_{2}(V_{2},E_{2})$ be the undirected graph with

\begin{array}[]{rcl}V_{2}&=&V_{1}\\ &\cup&\{o^{0}_{i,j}|i\in[n],j\in[\Lambda_{x_{i}}^{0}]\}\\ &\cup&\{o^{1}_{i,j}|i\in[n],j\in[\Lambda_{x_{i}}^{1}]\}\\ E_{2}&=&E_{1}\\ &\cup&\{\{o^{0}_{x_{i},j},z^{0}_{x_{i},j}\}|i\in[n],j\in[\Lambda^{0}_{x_{i}}]\}\\ &\cup&\{\{o^{0}_{x_{i},j},l^{1}_{x_{i},1,j}\}|i\in[n],j\in[\Lambda^{0}_{x_{i}}]\}\\ &\cup&\{\{o^{1}_{x_{i},j},z^{1}_{x_{i},j}\}|i\in[n],j\in[\Lambda^{1}_{x_{i}}]\}\\ &\cup&\{\{o^{1}_{x_{i},j},l^{0}_{x_{i},1,j}\}|i\in[n],j\in[\Lambda^{1}_{x_{i}}]\}\\ &\cup&\{\{r^{0}_{x_{i},j,k},l^{0}_{x_{i},j+1,k}\}|i\in[n],j\in[\Lambda^{0}_{x_{i}}],k\in[\Lambda^{1}_{x_{i}}]\}\\ &\cup&\{\{r^{1}_{x_{i},j,k},l^{1}_{x_{i},j+1,k}\}|i\in[n],j\in[\Lambda^{1}_{x_{i}}],k\in[\Lambda^{0}_{x_{i}}]\}\\ &\cup&\{\{r^{0}_{x_{i},\Lambda^{0}_{x_{i}},k},c_{j}\}|i\in[n],k\in[\Lambda^{1}_{x_{i}}],j\mbox{ is the }k\mbox{th smallest index s.t. }x_{i}\in C_{j}\}\\ &\cup&\{\{r^{1}_{x_{i},\Lambda^{1}_{x_{i}},k},c_{j}\}|i\in[n],k\in[\Lambda^{0}_{x_{i}}],j\mbox{ is the }k\mbox{th smallest index s.t. }\overline{x_{i}}\in C_{j}\}.\end{array}

The costs of edges from $E_{1}$ remain unchanged. The new edges $\{r_{x_{i},j,k},c_{l}\}$, $\{o^{1}_{x_{i},j},z^{1}_{x_{i},j}\}$, and $\{o^{0}_{x_{i},j},z^{0}_{x_{i},j}\}$ have cost $6$ for one player and $\infty$ otherwise. All other edges have cost [math] for one player and $\infty$ for any other number of players. The cost of $6$ ensures that a clause player cannot use the edge as a shortcut: Without using the new edge, his maximal cost is $7$, and the minimum cost with the edge is at least $8$. A total of $m+\Lambda$ players play the game on this graph. Each of the $\Lambda$ players represents the occurrence of a variable $x_{i}$ in clause $C_{j}$. If the occurrence is positive, the player has the source $o^{1}_{x_{i},j}$, and $o^{0}_{x_{i},j}$ if the occurrence is negative. In both cases, the sink is $c_{j}$.

The graph in Fig. 2 is the result of creating the construction for the formula $F=A\wedge(\overline{A}\vee B)\wedge(\overline{A}\vee\overline{B}\vee\overline{C})$, while focusing only on the section concerning variable $A$. In an attempt to make the graph clearer, some nodes appear multiple times in the graph; however they all represent one single node. Nodes with this property are displayed as rectangles. If they have the same name, they represent the same single node.

The red path indicates a clause player satisfying $C_{1}$ by assigning 1 to $A$. The green edges encompass three occurrence players, each trying to reach another clause. The intention of this construction is to fix an assignment to a variable. If not hindered, an occurrence player will try to reach a clause by going straight to the $z$ node. However, if there is a player that wants to satisfy the corresponding clause (e.g., by assigning the value 1 to it), the edge $z-C$ cannot be used by the occurrence player as well. Instead, he takes the detour via the zigzag path, blocking all 0-paths of this variable, therefore satisfying property II).

A last problem with the construction is that the desired state reached when all players follow their intended strategies is a pure Nash equilibrium. Since the state is a Nash equilibrium already, no tolls are necessary to implement the social optimum, hence violating property III). A last small change solves this problem. From now on, the variable players join the game.

Let $G_{3}(V_{2},E_{3})$ be the undirected graph with

\begin{array}[]{rcl}E_{3}&=&E_{2}\ \cup\ \{\{v_{i}^{0},v_{i}^{1}\}|i\in[n]\}.\end{array}

The cost function of all edges from $E_{2}$ remain the same. The cost function for a new edge $e=\{v_{i}^{0},v_{i}^{1}\}$ is $c_{e}(x)=2x$, where $x$ is the number of players that use edge $e$. Now all $m+\Lambda+n$ players take part in the game. A variable player $i$ has $v_{i}^{0}$ as source and $v_{i}^{1}$ as sink.

Figure 3 illustrates the new component.

The red edges correspond to a clause player, the blue edge to a variable player. The state on the left is the social optimum. However, it is not a pure Nash equilibrium, because the clause player can find a cheaper path, reducing his cost by 1 but also increasing the social cost by 1, displayed in the center state. The state on the right is a pure Nash equilibrium that coincides with the social optimum of the original graph. It is the result of tolling edge $\{A^{0},A^{1}\}$ with 2.

To optimally implement the social optimum, placing this toll is necessary if and only if a clause player satisfies a clause by assigning 1 to a variable, and at most once per variable. Since assigning 1 to a variable is more expensive than assigning 0, the least number of variables will be assigned value 1, forcing the placement of the toll station. Tolling such an edge corresponds to assigning $1$ to the respective variable in the Boolean formula. Therefore, the minimal satisfying assignment for the original formula can be constructed from the placed toll stations efficiently. Additionally, if the social optimum can be optimally implemented with at most $k$ tollbooths, then there exists a satisfying assignment for the original formula with weight at most $k$. Graph $G_{3}$ therefore finally satisfies all four properties. From these reductions follows Theorem 3.1.

Theorem 3.1

Solving atomic MINTB is NP-hard and W[2]-hard with the number of required toll booths as the parameter.

To know where to place the tollbooths and therefore the minimal satisfying assignment of the original formula, it suffices to know the social optimum. A direct consequence is that finding a social optimum must be hard.

Corollary 1

Finding a social optimum of a game $\Gamma$ is NP-hard. Additionally, finding a social optimum that can be implemented in $\Gamma$ with at most $k$ tollbooths is W[2]-hard, with $k$ being the parameter.

4 Optimally Implementing a State in Polynomial Time

This section presents an algorithm that optimally implements a state $S$ in an atomic network congestion game based on a series-parallel graph in polynomial time. We base the procedure on a similar approach from Basu, Lianeas, and Nikolova, who show the same result in basu2015new for non-atomic games. Starting at the simple base case of parallel-link networks, we inductively decide on the number of tolled edges for larger components, based on the optimality of the smaller ones. We do so by exploiting the recursive structure of series-parallel graphs.

Definition 6

A graph $G$ with source $s$ and sink $t$ is called series-parallel, if

1. i)

it consists of only a single edge. 2. ii)

it is the result of combining two series-parallel graphs in series. 3. iii)

it is the result of combining two series-parallel graphs in parallel.

A combination of graphs $G_{1}$ and $G_{2}$ in series means declaring the source of $G_{1}$ as the new global source, and the sink of $G_{2}$ as the new global sink. Additionally, the sink of $G_{1}$ and the source of $G_{2}$ are identified as one node in the new graph.

Combining $G_{1}$ and $G_{2}$ in parallel means identifying both sources as one node and setting it as the new global source, and respectively identifying both sinks as the new global sink.

A series-parallel parse tree of a series-parallel graph is the representation of the graph as a tree, where every leaf stands for a single edge, and every inner node represents either a combination of its two children in series or parallel. For simplicity, in this paper, the leaves will represent parallel-link networks, i.e., networks consisting of two nodes connected by possibly several edges.

Given an atomic network congestion game on a series-parallel network, let $T$ be the parse tree representation of that network, and $S$ a given state that is to be implemented in that game. For each node of $T$, we will create a list of tuples $(\eta,\lambda)$ with the following meaning. While ensuring that all players follow their strategy in $S$, by tolling at most $\eta$ edges, $\lambda$ is the highest cost we can force on a new player entering the network represented by the regarded node. The values for $\eta$ range from the minimum necessary to guarantee that all player follow their strategy from $S$ to the minimum necessary to toll all paths through the network. Additionally, we will remember a single value $\lambda_{0}$, indicating the lowest cost a new player can have, while ensuring that $S$ is implemented.

Algorithm 1 creates the list for a leaf of the tree, which is a parallel-link network. For simplicity, we denote by $l_{e}=c_{e}(n_{e}(S))$, and by $l_{e}^{+}=c_{e}(n_{e}(S)+1)$.

Lines 2 and 3 of Algorithm 1 ensure, that at least the minimum number of edges necessary to implement the given state $S$ in the parallel-link network is tolled. Line 10 calculates the highest cost enforceable on a new player entering the network. Since the $\eta$ cheapest edges are tolled, the highest cost we could force on a newly entering player is the cost of the $\eta+1$ cheapest edge. Only when all edges are tolled, we can guarantee an arbitrarily high cost, marked by the $\infty$ symbol. Thus, the tuple $(\eta_{\max},\infty)$ forms the last element of the list.

Since the list is ordered with respect to the values of $\eta$, we will address elements from the list by index, so, e.g., $\eta_{1}$ refers to $\eta_{\min}$, and $\lambda_{i}$ is the cost enforceable by $\eta_{i}$ edges. Whenever we refer to the last element of a list, we use $\max$ as the index.

Following an inductive argument, we now show how to correctly form these lists for the inner nodes of the parse tree, assuming that the lists for the children are already correctly formed. To differentiate between the two children of the inner node $r$, we address one of them by $v$, and the other one by $w$. Some values will be labeled with $r,v$ or $w$ accordingly. A tuple for the list of $r$ will originate from two tuples, one for each child node. We add two pointers, $idx_{v}$ and $idx_{w}$, to each new tuple, referencing their origin.

Series composition:

The minimum number of edges that need to be tolled in the parent node $r$ is simply the sum of the minimum necessary number of edges from the children, so $\eta_{1}^{r}=\eta_{1}^{v}+\eta_{1}^{w}$. Similarly, the maximum $\eta_{\max^{r}}^{r}$ can be calculated by $\eta_{\max^{r}}^{r}=\min\{\eta_{1}^{v}+\eta_{\max^{w}}^{w},\eta_{\max^{v}}^{v}+\eta_{1}^{w}\}$. To complete the list, we have to add a tuple for every $\eta_{i}^{r}$ with $1<i<\max^{r}$. The corresponding costs are $\lambda_{i}^{r}=\max\{\lambda_{a}^{v}+\lambda_{b}^{w}\ |\ \eta_{i}^{r}=\eta_{a}^{v}+\eta_{b}^{w}\}$, for all $i\in[\max^{r}]$. Accordingly, we set $\lambda_{0}^{r}=\lambda_{0}^{v}+\lambda_{0}^{w}$.

Parallel composition:

In the parallel composition a player from one component may be able to reduce his cost by joining the other component. Let $c_{\max}$ be the highest cost of a player in both $v$ and $w$, if all players play according to the state $S$. Without loss of generality, let it be a player from $v$ that has this cost $c_{\max}$. To determine the minimum necessary number of tolled edges, it suffices to check how many edges in $w$ have to be tolled to force a joining player to have cost at least $c_{\max}$. That means, $\eta_{1}^{r}=\eta_{1}^{v}+\min\{\eta^{w}_{i}\ |\ \lambda^{w}_{i}\geq c_{\max},i>0\}$, and $\eta_{\max^{r}}^{r}=\eta_{\max^{v}}^{v}+\eta_{\max^{w}}^{w}$. Again, we add a tuple for every $\eta_{i}^{r}$ with $1<i<\max^{r}$. The corresponding costs are $\lambda_{i}^{r}=\max\{\min\{\lambda_{a}^{v},\lambda_{b}^{w}\}\ |\ \eta_{i}^{r}=\eta_{a}^{v}+\eta_{b}^{w}\}$, for all $i\in[\max^{r}]$. We set $\lambda_{0}^{r}=\max\{c_{\max},\min\{\lambda_{0}^{v},\lambda_{0}^{w}\}\}$.

Once the lists for all nodes are created, we can choose the tuple in the root node with the minimum number of edges. We can retrace the creation of the tuple to the leaf nodes of the tree, where we can decide which edges are to be tolled with which value. Algorithm 2 is a recursive algorithm that tolls the edges accordingly. For simplicity, we assume the lists of each node to be globally accessible. The algorithm is initially called with $r$ being the root node of the parse tree and $c_{in}=\lambda_{0}^{r}$, since optimally implementing $S$ requires tolling $\eta_{1}^{r}$ edges.

Lines $1$ to $5$ toll the edges in the parallel-link networks at the leaves of the parse tree. Lines $11$ to $15$ consider the case when $r$ is a series composition. Here the input cost is feasibly divided into two components. By this division, it is both possible and necessary to implement $S$ with the number of edges indicated by the $idx$ pointer. Lines $16$ to $18$ do the same for the parallel composition. This way, it is always possible to toll the rest of the network feasibly while only using $\eta_{1}^{r}$. It ensures, that the state gets properly implemented in all components of the series-parallel graph, and a new player joining the network has cost at least the initial $c_{in}$.

Runtime:

Let $m$ be the number of edges in the original network. The parse tree can be created in $\mathcal{O}(m)$ time, and also has size $\mathcal{O}(m)$. Creating the list at a leaf node is possible in $\mathcal{O}(m)$ time. For an inner node, we have to check at most $\mathcal{O}(m^{2})$ combinations of elements from the children’s lists. Therefore, creating the list for every node is possible in $\mathcal{O}(m^{3})$ time. The computation time on each node in Algorithm 2 is bounded by $\mathcal{O}(m)$. The algorithm visits every node of the parse tree exactly once, leading to a runtime of $\mathcal{O}(m^{2})$. In total, the runtime of the algorithm is $\mathcal{O}(m^{3})$.

Theorem 4.1

Optimally implementing a state $S$ in an atomic network congestion game based on a series-parallel graph with $m$ edges is possible in runtime $\mathcal{O}(m^{3})$.

5 Conclusion

This work analyses the complexity of the minimum tollbooth problem in atomic network congestion games with unsplittable flows.

By a reduction from the weighted CNF SAT problem, we show both the NP-hardness of the problem and, more importantly, the W[2]-hardness of a parameterized version. The parameter in the latter case is the number of necessary tollbooths to turn a social optimum of the untolled game into a pure Nash equilibrium of the tolled one.

A restriction to networks that are series-parallel graphs yields a polynomial time algorithm. The algorithm gives tolls, such that a given state is a pure Nash equilibrium of the tolled game while using the minimum number of toll booths. This algorithm is based on a similar method presented by Basu, Lianeas, and Nikolova in basu2015new , who consider non-atomic games, exploiting the recursive structure of series-parallel graphs.