Complexity of Public Goods Games on Graphs

07/09/2022
by   Matan Gilboa, et al.
Hebrew University of Jerusalem
0

We study the computational complexity of "public goods games on networks". In this model, each vertex in a graph is an agent that needs to take a binary decision of whether to "produce a good" or not. Each agent's utility depends on the number of its neighbors in the graph that produce the good, as well as on its own action. This dependence can be captured by a "pattern" T: IN→{0,1} that describes an agent's best response to every possible number of neighbors that produce the good. Answering a question of [Papadimitriou and Peng, 2021], we prove that for some simple pattern T the problem of determining whether a non-trivial pure Nash equilibrium exists is NP-complete. We extend our result to a wide class of such T, but also find a new polynomial time algorithm for some specific simple pattern T. We leave open the goal of characterizing the complexity for all patterns.

READ FULL TEXT VIEW PDF

page 1

page 2

page 3

page 4

12/05/2020

A Refined Study of the Complexity of Binary Networked Public Goods Games

We study the complexity of several combinatorial problems in the model o...
02/25/2020

Inducing Equilibria in Networked Public Goods Games through Network Structure Modification

Networked public goods games model scenarios in which self-interested ag...
12/03/2020

On Parameterized Complexity of Binary Networked Public Goods Game

In the Binary Networked Public Goods game, every player needs to decide ...
07/17/2022

Simultaneous Contests with Equal Sharing Allocation of Prizes: Computational Complexity and Price of Anarchy

We study a general scenario of simultaneous contests that allocate prize...
02/25/2020

Hedonic Seat Arrangement Problems

In this paper, we study a variant of hedonic games, called Seat Arrangem...
03/25/2018

Popular Matching in Roommates Setting is NP-hard

An input to the Popular Matching problem, in the roommates setting, cons...
12/17/2018

The complexity of mean payoff games using universal graphs

We study the computational complexity of solving mean payoff games. This...

1 Introduction

We study scenarios where there is a set of agents, each of which must decide whether to make an effort to produce some “good”, where doing so benefits not only himself but also others. This general type of phenomena is captured by the general notion of public goods, and we focus on cases where the public good produced by some agent does not benefit all other agents but rather there is some neighborhood structure between agents specifying which agents benefit from the public goods produced by others. Examples for these types of scenarios abound: anti-pollution efforts that benefit a geographical neighborhood, research efforts that benefit other researchers in related areas, vaccination efforts, security efforts, and many more.

We focus on the following standard modeling of public goods games on networks: We are given an undirected graph, where each node models an agent, and the neighbors of a node are the other agents that benefit from his production of the public good. We focus on the case where each agent has a single boolean decision to make of whether to produce the good or not, and furthermore, as in, e.g., [2, 3, 4, 6, 8], limit ourselves to cases where the effect of an agent’s neighbors is completely characterized by the number of them that produce the good. Furthermore we focus on the cleanest, so called, fully homogenous case where all agents have the same costs and utility functions so all of the heterogeneity between agents is captured by the graph structure.

Formally, there is a cost that each agent pays if they produce their good, and a utility function describing each agent’s utility, where describes whether agent produces the good and is the number of ’s neighbors (excluding ) that produce the good111In this paper, we use the notation to also contain 0, and use to exclude 0.. We focus on the ’strict’ version of the problem [3], where we do not allow knife’s-edge cases where . Therefore, our agent’s best response to exactly of its neighbors producing the good is to produce the good () if and to not produce the good () if . Hence, we can summarize the Best Response Pattern as . We study the following basic problem of finding a non-trivial pure Nash equilibrium in a network.

Equilibrium in a public goods game: For a given best response pattern , given as input an undirected graph , determine whether there exists a pure non-trivial Nash equilibrium of the public goods game on , i.e. an assignment that is not all , such that for every we have that .

Several cases of this problem have been studied in the literature. In [1], the “convex case” where the pattern is monotone (best response is if at least of your neighbors play ) and the ”Best Shot” case (where the best response is only if none of your neighbors play , i.e. and for all , ) were shown to have polynomial time algorithms. The general heterogeneous case where different agents may have different patterns of best responses was shown to be NP-complete in [8] as was, in [3, 6], the fully-homogenous case, if we allow also knife’s-edge cases, i.e. for some utility function where for some we have (which lies outside our concise formalization of patterns, since in these cases, both and are best responses).222An early version [7] of [8] contained an erroneous proof of NP-completeness in the fully-homogenous case for some pattern , but a bug was found by [6] who gave an alternative proof of the NP-completeness of the case that allows . The parameterized complexity for several natural parameters of the graph was studied in [3]. In [2], it is shown that in a public goods game, computing an equilibrium where at least agents produce the good, or at least some specific subset of agents produce it, is NP-Complete. In [4], a version of this problem333A version without the non-triviality assumption on the equilibrium. on directed graphs was studied, and a full characterization of the complexity of this problem was given for every pattern: except for a few explicitly given best response patterns, for any other pattern the directed problem is NP-complete.444One of the few easy cases they identify can be seen to apply also to the undirected case: where the pattern alternates between 0 and 1, i.e. only depends on the parity of , a case that can be solved as a solution of linear equations over . They also suggested an open problem of providing a similar characterization for the more standard undirected case and specifically asked about the complexity of the pattern where the best response is iff exactly one of your neighbors plays . Our main result answers this question, showing that for this specific pattern the problem is NP-complete.

Theorem: For the Best-Response Pattern where each agent prefers to produce the good iff exactly one of its neighbors produces the good, i.e. and for all , the equilibrium decision problem in a public goods game is NP-complete.

When considering the strict version of the game, this is the first pattern for which the equilibrium problem is shown to be NP-complete, and in fact it is even the first proof that the general problem (where the pattern is part of the input) is NP-complete. We then embark on the road to characterizing the complexity for all possible patterns. We extend our proof of NP-completeness to large classes of patterns. We also find a new polynomial time algorithm for a new interesting case:

Theorem: For the pattern where each agent prefers to produce the good iff at most one of its neighbors produces the good, i.e. and for all , , the public goods game always has a pure non-trivial equilibrium, and it can be found in polynomial time.

We were not able to complete our characterization for all patterns and leave this as an open problem. In particular, we were not able to determine the complexity for the following two cases:

Open Problem 1: Determine the computational complexity of the equilibrium decision problem of a public goods game for the pattern where and for all , .

Open Problem 2: Determine the computational complexity of the equilibrium decision problem of a public goods game for the pattern where and for all , .

We suspect that at least the first problem is computationally easy, and in fact that there exists a non-trivial pure Nash equilibrium in any graph.

Category Pattern Reference
PTIME 1,0,0,0,… [1]
1,1,0,0,0,… Theorem 4.1
0,0,…,1,1,1,… [1]
1,0,1,0,1,0,… [4]
NPC 0,1,0,0,0,… Theorem 3.1
0,?,?,…,1,0,0,0,… Theorem 5.1
1,1,?,?,…,0,?,?,…,1,0,0,0,… Theorem 5.2
1,0,..,0,1,1,?,?,…,0,0,0,… Theorem 5.3
Adding 1,0 to non-flat hard patterns Theorem 5.4
Open Problems 1,1,1,0,0,0,…
1,0,1,0,0,0,…
Table 1: A summary of our (and previous) results.

The rest of this paper is organized as follows: After defining our model and notations in section 2, we present our main theorem (hardness of the Single-Neighbor pattern) in Section 3, and provide some intuition about the problem. In Section 4 we construct a polynomial time algorithm for the At-Most-Single-Neighbor pattern. In Section 5 we characterize a number of classes of patterns for which the problem is hard, by reducing from our main theorem, where each sub-section focuses on a specific class of patterns. Our results are summarized in Table 1.

2 Model and Notation

We define a Public Goods Game (PGG) on an undirected graph with nodes , each one representing an agent. The neighborhood of agent i, denoted , is defined as the set of agents adjacent to , excluding , i.e: . An edge between two agents’ nodes models the fact that these agents are directly affected by each other’s decision to produce or not produce the good. The strategy space, which is assumed to be the same for all agents, is , where represents producing the good, and represents the opposite. The strategy of agent is denoted .

Definition 1

If nodes are adjacent, and (i.e. agent produces the good) we say that is a supporting neighbor of .

For convenience, if some node represents agent , we sometimes write or instead of or respectively, to mark ’s strategy. The utility function is assumed to be the same for all agents. Furthermore, we restrict ourselves to utility functions where an agent is never indifferent between producing and not producing the good, and so always has a single best response according to the strategies of the agents in their neighborhood. This characteristic of the utility function allows us to adopt a more convenient way to inspect a PGG model, which we call the best response pattern.

Definition 2

For any PGG, we define its Best Response Pattern (BRP), denoted by

, as an infinite boolean vector in which the

entry represents the best response for each agent given that exactly neighbors of (excluding ) produce the good:

We henceforth identify PGGs by their Best Response Pattern, rather than their utility function and cost. This concludes the definition of a PGG model. We now define a pure Nash equilibrium, which is our main subject of interest.

Definition 3

A strategy profile of a Public Goods Game corresponding to a BRP is a pure Nash equilibrium (PNE) if all agents play the best response to the strategies of the agents in their neighborhood:

In addition, if there exists s.t , then is called a non-trivial pure Nash equilibrium (NTPNE).

Definition 4

For a fixed BRP , the non-trivial pure Nash equilibrium decision problem corresponding to , denoted by NTPNE(), is defined as follows: The input is an undirected graph . The output is ’True’ if there exists an NTPNE in the PGG defined on with respect to , and ’False’ otherwise. The search version of the problem asks for the NTPNE itself.

Let us give names to the following three simplest patterns:

Definition 5

The Best-Shot best-response pattern is defined as follows:

i.e.

Definition 6

The Single-Neighbor best-response pattern is defined as follows:

i.e.

Definition 7

The At-Most-Single-Neighbor best-response pattern is defined as follows:

i.e.

The Best-Shot BRP was coined in [1], where they prove that a pure Nash equilibrium exists in any graph, and show a correspondence between PNEs and Maximal Independent Sets. We study the Single-Neighbor BRP in Section 3, where we prove the decision problem is NP-Complete. We study the At-Most-Single-Neighbor BRP in Section 4, where we prove that a pure Nash equilibrium exists in any graph.

3 Hardness of the Single-Neighbor Pattern

In this section we prove NP-completeness of NTPNE() defined by the Single-Neighbor BRP, and provide basic intuition about its combinatorial structure. This is a linchpin of our hardness results, from which we reduce to many other patterns. We remind the reader that in the Single-Neighbor BRP, an agent prefers to produce the good iff exactly one of their neighbors produces it.

Theorem 3.1

Let be the Single-Neighbor Best Response Pattern. Then NTPNE() is NP-complete.

Before the proof, we provide intuition about the Single-Neighbor problem, by examining a few simple graphs. First, we note that since , a trivial all-zeros PNE exists in any graph. This observation is true for any such pattern555These patterns are denoted flat patterns, and are formally defined in Definition 10., which is the reason we choose to focus on non-trivial PNEs. Now, take for example a simple path with two nodes. The assignment where both nodes are set to is an NTPNE, since neither of them benefit from changing their strategy. But looking at a simple path with 3 nodes, it is easy to verify that there is no NTPNE. Specifically, the all-ones assignment in such a path is not a PNE since the middle node would rather play , as it already has two supporting neighbors. Generalizing this NTPNE analysis to paths of any size, we see that in order for a simple path with nodes to have an NTPNE, it must be that . To see why, let us examine . If is assigned then so is , as otherwise wishes to change strategy; and since is assigned then so is , and so forth. Therefore, in order to get a non-trivial assignment must be assigned , and it must have a supporting neighbor, which must be . This leads to only one possibility for an NTPNE, as shown in Figure 1. A similar analysis shows that a cycle with nodes has an NTPNE iff (see Figure 3).

Figure 1: NTPNE: paths with

Another simple example is the Complete Graph, or Clique. In any Clique of size at least 2, we can construct an NTPNE by choosing any two nodes to be assigned , and assigning to all other nodes (see Figure 3).

Figure 2: NTPNE: cycles with
Figure 3: NTPNE: Clique

So we see there are cases where there exists an NTPNE, and others where there doesn’t, and so the problem is not trivial (and in fact is NP-Hard).


We now begin the proof of Theorem 3.1, first showing that the problem is NP-Hard. To do so, we construct a reduction from ONE-IN-THREE 3SAT, which is a well known NP-complete problem [5]. The input of the ONE-IN-THREE 3SAT problem is a CNF formula where each clause has exactly 3 literals, and the goal is to determine whether there exists a boolean assignment to the variables such that in each clause exactly one literal is assigned with True.

For the reduction, we introduce our Clause Gadget. For each clause in the ONE-IN-THREE 3SAT instance, we construct a 9-nodes Clause Gadget as demonstrated in Figure 5. The nodes represent the literals of the clause, respectively, and are denoted the Literal Nodes. Nodes are denoted the Inner Nodes, and nodes are denoted the Peripheral Nodes. Each Literal Node is adjacent to all other Literal Nodes, and to all Peripheral Nodes. In addition, the Literal Nodes are paired with the Peripheral Nodes respectively, in the sense that they share the same Inner Node as a neighbor, and only that Inner Node (for example, and are paired since they are both adjacent to , and not to ). Notice that the Peripheral Nodes are not adjacent to each other. Additionally, note that in the final graph, only the Literal Nodes will be connected to nodes outside the Clause Gadget. The proof is constructed by a number of Lemmas.

Figure 4: Clause Gadget, with the NTPNE assignment of Lemma 4
Figure 5: Transfer Node (blue edges not shown).
Lemma 1

In any PNE in a graph which includes the Clause Gadget, if one of the nodes of the Clause Gadget is assigned , then one of the Literal Nodes must be assigned .

Proof

Assume by way of contradiction that all Literal Nodes are assigned . Since at least one node in the gadget is assigned , it must either be an Inner Node or a Peripheral Node. Notice that if an Inner Node is assigned , w.l.o.g , then its neighboring Peripheral Node has exactly one supporting neighbor and according to the BRP must also be assigned , seeing that x is connected only to and to the Literal Nodes (which are assigned ). Similarly, if a Peripheral Node is assigned , w.l.o.g , then its neighboring Inner Node must also be assigned , as otherwise would prefer changing strategy. Therefore, there must be a pair of adjacent Inner Node and Peripheral Node that are both assigned . w.l.o.g . Since is assigned , and already has a supporting neighbor, then all other neighbors of (i.e. and ) must be set to . This leaves us only with ; since neither of them have any supporting neighbors, they must be set to . The contradiction comes from nodes , both of which prefer changing their strategy to , having exactly one supporting neighbor.

Lemma 2

In any PNE in a graph which includes the Clause Gadget, if one of the Literal Nodes of the Clause Gadget is assigned , then the other two Literal Nodes must be assigned .

Proof

Assume by way of contradiction that two different Literal Nodes are assigned (w.l.o.g ). Since and are adjacent, they both already have a supporting neighbor, and so all their other neighbors must be set to . Therefore . This leaves us only with node , which must be set to since all its neighbors are set to . The contradiction comes from nodes , both of which prefer changing their strategy to , having exactly one supporting neighbor.

Lemma 3

In any PNE in a graph which includes the Clause Gadget, if one of the Literal Nodes of the Clause Gadget is assigned , then so is its paired Peripheral Node.

Proof

Assume by way of contradiction that a Literal Node is set to while its paired Peripheral Node is set to . w.l.o.g . From Lemma 2, we have that . Therefore, since cannot have only one supporting neighbor and still prefer playing , we must set its remaining neighbor, , to . Since both have a supporting neighbor, all their other neighbors must be set to . Therefore . The contradiction comes from nodes , both of which prefer changing their strategy to , having exactly one supporting neighbor.

Lemma 4

In any PNE in a graph which includes a Clause Gadget, if one of the nodes of the Clause Gadget is assigned , then there is only one possible assignment to the nodes in the gadget. Specifically, one Literal Node and its paired Peripheral Node must be set to , and so do the two Inner Nodes that aren’t connected to them, whereas all other nodes in the gadget must be set to .

Proof

Since there exists a node that is set to inside the gadget, From Lemma 1 one of the Literal Nodes must be set to , w.l.o.g . From Lemma 2 , and from Lemma 3 . Since are supporting neighbors to each other, they cannot have any other neighbor set to , therefore . Since is set to and has only one supporting neighbor (), we must set its remaining neighbor to as well. Symmetrically, we must set to in order to support ’s assignment. It is easy to verify that indeed each node of the Clause Gadget is playing its best response given this assignment.

So far we have seen that the Clause Gadget indeed permits an NTPNE, and enforces the fact that each clause of the CNF formula must have exactly one literal set to . We now wish to enforce the fact that all clauses must have a literal assigned with True. We first construct a connection between the Clause Gadgets such that if some Clause Gadget has a node set to , then all gadgets must have one. The connection is defined as follows. Each pair666It is enough to connect all Clause Gadgets as a chain to one another (by Transfer Nodes), but for ease of proof we connect every pair of gadgets. of Clause Gadgets is connected by one Transfer Node, denoted by . The Transfer Node is adjacent to all Literal Nodes of both of the gadget to which it is connected, and only to those nodes. The connection between the Clause Gadgets is demonstrated in Figure 5.

Lemma 5

In any PNE in a graph which includes 2 Clause Gadgets which are connected by a Transfer Node , must be set to .

Proof

Assume by way of contradiction that . Then it must have a supporting neighbor. Since is only connected to Literal Nodes, one of those Literal Nodes must be set to (w.l.o.g ). From Lemma 3, must also be assigned with , which leads to a contradiction since has 2 supporting neighbors and yet plays .

Lemma 6

In any PNE in a graph which includes at least two Clause Gadgets, which are all connected to each other by Transfer Nodes, if one of the Clause Gadgets has a node set to , then all of the Clause Gadgets have a node set to .

Proof

Denote the gadget that has a node set to by , and let be some other Clause Gadget. Then is connected to via a Transfer Node . Denote the Literal Nodes in by , and the Literal Nodes in by . From Lemma 1 and Lemma 2 we have that one of is set to , while the other two are set to . w.l.o.g assume . From Lemma 5, , and therefore, must have another supporting neighbor other than . Since ’s only neighbors are , and , it follows that one of must be set to one, while the other two must be set to . From Lemma 4 we know the assignments in each Clause Gadget necessary for an NTPNE, and it is easy to verify that this assignment is still a Nash Equilibrium after adding Transfer Nodes between the gadgets.

Now that we have ensured all Clause Gadgets have a node set to (assuming one of them does), we wish to enforce that any two identical literals in the CNF formula are assigned with the same value. To do so, we introduce another connecting node, which we call the Copy Node. Any two777It is enough to connect all literals representing the same variable as a chain to one another (by Copy Nodes), but for ease of proof we connect every pair of them. Literal Nodes (from different Clause Gadgets, or possibly from the same one) which represent the same variable in the original CNF formula, will be connected via a Copy Node denoted by , as shown in Figure 6. Each Copy Node has exactly two neighbors, which are .

Figure 6: Copy Node (blue edges not shown).
Lemma 7

In any PNE in a graph which includes two Literal Nodes in two Clause Gadgets respectively, where are connected by a Copy Node , must be set to .

Proof

Since is connected only to Literal Nodes, the proof of Lemma 5 applies to this claim as well.

Lemma 8

In any PNE in a graph which includes two Literal Nodes in two Clause Gadgets respectively, where are connected by a Copy Node , and must have the same assignment.

Proof

Assume by way of contradiction that (w.l.o.g) . From Lemma 7, must be set to . But since are the only neighbors of , has only one supporting neighbor, and therefore must be set to , in contradiction.

The next property of a ONE-IN-THREE 3SAT assignment we need to enforce, is that a variable and its negation must be set to different values. Since the Copy Nodes already ensure that a variable appearing several times will always get the same value, it is enough to make sure for each variable that one instance of it is indeed different from one instance of its negation. To do so, we introduce another connecting node, called the Negation Node. For each variable , where both and appear in the CNF formula, we choose one instance of and one instance of from different clauses.888We assume a variable and its negation never appear together in the same clause, as the problem without this assumption is easily reducible to the problem with it. Denote the Literal Nodes representing by respectively, and denote the other two Literal Nodes residing with in the same Clause Gadget by . We connect a Negation Node to as well as to , as demonstrated in Figure 7. For convenience, we say that are connected by even though is only adjacent to one of them.

Figure 7: Negation Node (blue edges not shown).
Lemma 9

In any PNE in a graph which includes two Literal Nodes in two different Clause Gadgets respectively, where are connected by a Negation Node , then must be set to .

Proof

Since is connected only to Literal Nodes, the proof of Lemma 5 applies to this claim as well.

Lemma 10

In any PNE in a graph which includes two Literal Nodes in two different Clause Gadgets respectively, where are connected by a Negation Node , and each of has at least one node set to , then must be assigned with different values.

Proof

Denote by the other two Literal Nodes residing with in the same Clause Gadget. Divide into cases. Case 1: If , then must have another supporting neighbor (since itself is set to , from Lemma 9). Thus, either or must be set to , and from Lemma 2 we have that , as needed. Case 2: If , assume by way of contradiction . Since has some node set to , then from Lemmas 1 and 2 we have that either or are set to , and only one of them. Thus, has exactly one supporting neighbor, and therefore must be set to , in contradiction to Lemma 9.

We have shown that our construction enforces all properties of a valid ONE-IN-THREE 3SAT solution. But notice that most of the proofs rely on the assumption that every Clause Gadget has at least one node set to . It is left to prove that there cannot be any NTPNE where all of the Clause Gadgets are all-zero.

Lemma 11

In any NTPNE in the graph constructed throughout the proof of Theorem 3.1, all Clause Gadgets have at least one node set to .

Proof

Since we have an NTPNE, there must be some non-zero node, denoted by . From Lemmas 5, 7, and 9 we have that all Transfer Nodes, Copy Nodes and Negation Nodes must be set to , and therefore must be a part of a Clause Gadget. 999Lemmas 5, 7, and 9 do not assume that the Clause Gadgets have a node set to , and therefore are valid to use here. From Lemma 6 we conclude that all Clause Gadgets must have a node set to .

These Lemmas lead us to the conclusion that indeed any satisfying assignment to the ONE-IN-THREE 3SAT problem matches an NTPNE in the constructed graph, and vice versa, which directly implies that the NTPNE problem is NP-Hard. This result is formulated by the claim in Theorem 3.1, which we can now prove.

Proof

(Theorem 3.1) Clearly the problem is in NP, as given any graph and a binary assignment to the nodes, we can verify that the assignment is an NTPNE in polynomial time. It is left to prove the problem is NP-Hard. Given a ONE-IN-THREE 3SAT instance, we construct a graph as described previously. If there exists a satisfying assignment to the variables of the ONE-IN-THREE 3SAT instance, then we can assign to all Literal Nodes which represent variables that are assigned ’True’, and to the necessary nodes within each gadget according to Lemma 4, and set all other nodes to . Since we saw that the assignment described in Lemma 4 forms an NTPNE, and that all connecting nodes (i.e. Transfer, Copy and Negation Nodes) do not affect this NTPNE given that they are all set to , we will get an NTPNE. In the other direction, if there exists an NTPNE in the constructed graph, From Lemmas 1, 2, 6, 8, 10, 11 we have that this NTPNE corresponds to a satisfying assignment to the ONE-IN-THREE 3SAT instance, where every Literal Node set to will translate to assigning ’True’ to its matching variable, and every Literal Node set to will translate to assigning ’False’ to its matching variable.

The proof itself gives a slightly more general result: The degree of the constructed graph is bounded101010The reader who has read the details of the proof may verify that, in the version where the gadgets are chained as mentioned in footnotes 6 and 7, a Literal Node is attached to 6 nodes within its Clause Gadget, and at most 2 Transfer Nodes, 2 Copy Nodes and 3 Negation Nodes. by 13. Therefore, our proof does not require any information about the entry of the BRP onward, and thus extends to any NTPNE() where agrees with the first 14 entries of the SN-BRP.

Corollary 1

Let be a BRP such that:

  1. T[1]=1

Then NTPNE() is NP-complete.

4 Algorithm for the At-Most-Single-Neighbor Pattern

In this section, we focus on one of the most basic cases of a monotone best response pattern, which is the At-Most-Single-Neighbor BRP. We remind the reader that in the At-Most-Single-Neighbor BRP, an agent prefers to produce the good iff at most one of their neighbors produces it. In addition, we formally define a monotone best response pattern as follows:

Definition 8

A BRP is called monotonically increasing (resp. decreasing) if for all , (resp. ).

The most basic (and well studied) case of a monotonically-decreasing BRP is the Best-Shot BRP. In  [1], it is shown that in any PGG corresponding to the Best-Shot BRP, an NTPNE always exists. Thus, the decision problem in this case is trivially solvable in polynomial time. In this section, we show a similar result for the At-Most-Single-Neighbor BRP: we prove that an NTPNE exists in any PGG corresponding to this BRP, and present a polynomial time algorithm to find one. An important notion in Graph Theory, which will be of use during our proof, is the Maximum Independent Set. Given a Graph , an Independent Set (Henceforth IS) is a subset of nodes such that no two nodes in are adjacent. A Maximal Independent Set is an IS such that for any node outside it holds that is not an IS. A Maximum Independent Set is a Maximal IS, such that for any Maximal IS it holds that . Using this notion, we constructively prove that an NTPNE of the At-Most-Single-Neighbor BRP exists in any graph, by providing a non-polynomial time algorithm to find one. We later alter the algorithm to work in polynomial time.

Input graph
      Output NTPNE for the At-Most-Single-Neighbor PGG on

1:find a maximum IS , and assign all its nodes with 1.
2:for each , if

has exactly one supporting neighbor at the moment of its assignment, then

. Otherwise .
Algorithm 1 At-Most-Single-Neighbor: Non-Polynomial Time Algorithm
Theorem 4.1

Let be the At-Most-Single-Neighbor BRP. Given any graph as an input, Algorithm 1 outputs an NTPNE of the PGG defined on corresponding to , and thus an NTPNE always exists. Therefore, the decision problem NTPNE() is trivially solvable in polynomial time.

Proof

A Maximum IS always exists in any graph, and therefore stage 1 of the algorithm, though not efficient, is well defined. Assume by way of contradiction that the assignment given by the algorithm is not a PNE. Then there must be some node that is not playing the best response to its neighbors assignments. Divide into two cases:

Case 1: If is playing , then at the time of its assignment must have had at least two supporting neighbors, otherwise the algorithm would have assigned it with . Since the algorithm never changes a node’s assignment from 1 to 0, we have that also at the end of the run has at least two supporting neighbors, and therefore is playing its best response, in contradiction.

Case 2: If is playing , then it must be that has at least two supporting neighbors, otherwise is playing its best response. Let be two supporting neighbors of . Divide into two sub-cases:

Sub-Case 2.1: If , then (otherwise we have a contradiction to being an IS), and therefore had received its assignment before did. Any node not in is only assigned with by the algorithm if it has exactly one supporting neighbor at the time of the assignment, and therefore only had as a supporting neighbor at the time of the assignment. Specifically, are not adjacent to any other node in , because all nodes in were already assigned by the time were assigned. Therefore, we have that is also an IS. Since , we have a contradiction to the fact that is a Maximum IS.

Sub-Case 2.2: If , then at least one of must have gotten its assignment after , otherwise the algorithm would have assigned with . w.l.o.g assume got its assignment after , and in particular . Since was assigned , it had exactly one supporting neighbor at the time of the assignment, hence was its only supporting neighbor at the time of the assignment. Since , we have that is not adjacent to any node in , which means that is an IS, in contradiction to being a maximal IS.

Therefore, all nodes play their best response, and so the assignment is an NTPNE.111111Since , any PNE must be an NTPNE.

Theorem 4.1 shows that the decision problem is easy in this case, using the fact that a Maximum IS always exists in any graph. However, finding a Maximum IS is an NP-Hard problem, and so Algorithm 1 does not run in polynomial time. Nevertheless, it does provide a base for our following refined algorithm, which runs in polynomial time and finds an NTPNE in any given graph.

Input graph
      Output NTPNE for the At-Most-Single-Neighbor PGG on

1:find a Maximal IS .
2:perform stage 2 of Algorithm 1 using
3:if the assignment is a PNE then
4:     return
5:else
6:     let be a node which isn’t playing its best response
7:     
8:     for  s.t  do
9:         if  is not adjacent to any node in  then
10:                             
11:go back to stage 2
Algorithm 2 At-Most-Single-Neighbor: Polynomial Time Algorithm
Theorem 4.2

Let be the At-Most-Single-Neighbor BRP. Given any graph as an input, Algorithm 11 runs in polynomial time and outputs an NTPNE of the PGG defined on corresponding to .

Proof

Correctness: We show that if at the beginning of iteration is a Maximal IS, then at the end of it increases by at least 1, and remains a Maximal IS. Therefore, after at most iterations, either the algorithm finds an NTPNE and stops, or increases enough to become a Maximum IS, and therefore by Theorem 4.1 the algorithm outputs an NTPNE.

increases by at least 1 after each iteration: At the beginning of the iteration is a Maximal IS, but not necessarily a Maximum IS. Inspect the different cases of the proof of Theorem 4.1, when assuming that the assignment is not a PNE. Notice that all the cases from the proof of Theorem 4.1 were contradicted by the fact that is a Maximal IS (which is true for the current theorem as well), except for Sub-Case 2.1, which was contradicted by the fact that is a Maximum IS. Therefore, if the assignment given by stage 2 of Algorithm 1 is not a PNE, the conditions of case 2.1 of the proof of Theorem 4.1 must hold. Thus, we are guaranteed that any node not playing its best response must be in , and must have at least two neighbors which satisfy the condition of stage 9 in Algorithm 11. Therefore, in each iteration of the Algorithm 11 gains at least 2 new nodes in the loop of stage 8, and loses exactly one node (which is ), and therefore the size of overall increases by at least 1.

remains a Maximal IS after each iteration: Since is a maximal IS at the beginning of the iteration, any node not in is adjacent to at least one node in . In each iteration we only remove a single node from , hence only and nodes that were adjacent to might (possibly) not be adjacent to any node in . After iterating over all of ’s neighbors and adding whichever possible to , we have that all of ’s neighbors are either in or adjacent to some node in . Regarding itself, we have already shown that at least 2 of its neighbors must be added to . Thus we have that remains a Maximal IS at the end of the iteration. This concludes the correctness of the algorithm.

Run-Time: Stage 1 can be achieved in , greedily. Stages 2,3 and 8-10 all require iterating over all nodes, and for each node iterating over all its neighbors, i.e. . Therefore, each iteration of the algorithm runs in . As explained in the Correctness part of the proof, the number of iterations of the algorithm is bounded by . Hence the overall run time of the algorithm is polynomial w.r.t the input.

5 More Hard Patterns

Theorem 3.1 provides a base to discover more classes of BRPs for which the decision problem is hard, which we present in this section. We focus specifically on non-monotone patterns, with a finite number of ’s, except for in Section 5.4 where we do not assume this. All proofs of this section are postponed to the appendix.

Definition 9

A BRP is called finite if it has a finite number of ’s, i.e.

5.1 Flat Patterns

In this section we generalize the result of the Single-Neighbor BRP to any -Neighbors BRP (where an agent’s best response is iff exactly of their neighbors play 1), and in fact to an even more general case: we show that any BRP that is flat (i.e. starting with ), non-monotone and finite, models an NP-complete decision problem.

Definition 10

A BRP is called flat121212Coined by Papadimitriou and Peng in  [4]. if .

Theorem 5.1

Let be a BRP which satisfies the following conditions:

  1. is flat

  2. is non-monotone

  3. is finite

Then NTPNE() is NP-complete.

The proof can be found in Appendix A.1.

5.2 Sloped Patterns

In this section, we show that the decision problem remains hard when the assumption of flatness is replaced with the assumption that the BRP begins with a finite number of ’s, and at least two. That is, we prove hardness of any non-monotone, finite, sloped BRP.

Definition 11

A BRP is called sloped if .

Theorem 5.2

Let be a BRP which satisfies the following conditions:

  1. is sloped

  2. is non-monotone

  3. is finite

Then NTPNE() is NP-complete under Turing reduction.

The proof can be found in Appendix A.2.

5.3 Sharp Patterns Followed by Two ’s

Among all non-monotone, finite BRPs, we have shown hardness of those which are flat, and those which are sloped. It is left to address the decision problem for non-monotone, finite BRPs which start with .

Definition 12

A BRP is called sharp if and .

In this section, we focus on patterns which start with , followed by any positive, finite number of ’s, and then . We prove that such BRPs present hard decision problems.

Theorem 5.3

Let be a BRP which satisfies the following conditions:

  1. is finite

  2. is sharp

  3. s.t:

Then NTPNE() is NP-complete under Turing reduction.

The proof can be found in Appendix A.3.

5.4 Adding to Non-Flat Patterns

In this section, we show that any non-flat pattern for which the decision problem is hard remains hard when is added to the beginning of it. Notice that adding at the beginning of a non-flat pattern yields another non-flat pattern, and so, by using this result recursively we can add any finite number of to a non-flat hard pattern, and it will remain hard. So far, the only non-flat patterns we have shown to be hard are the ones from Theorems 5.2 and 5.3. Notice that adding to a pattern of the form of 5.2 simply gives a pattern of the form of 5.3, which we have already proved is hard. Thus, until other non-flat patterns are proved hard, the new class of patterns that are shown to be hard in this section is summarized by the form:

If other non-flat patterns are proved hard, this result could be applied to them as well. We begin with a new definition:

Definition 13

Let be two BRPs. We say that is shifted by from if:

We say that is positively-shifted by from if in addition:

Theorem 5.4

Let be a non-flat BRP s.t NTPNE() is NP-complete. Let be a BRP satisfying the following conditions:

  1. is shifted by 2 from .

  2. is sharp

Then NTPNE() is NP-complete.

The proof can be found in Appendix A.4.

Appendix A Proofs of Section 5

a.1 Proof of Theorem 5.1

Proof

Let be a BRP satisfying the conditions of Theorem 5.1. Since is flat, , and since it is non-monotone, some entry of must be . Since is finite, let be the largest entry of s.t , i.e. . If , then is the Single-Neighbor-BRP, which we have already proved to be NP-Hard in Theorem 3.1. Otherwise, we reduce from NTPNE(). Let be a PGG on a graph corresponding to the SN-BRP. Denote . We construct the PGG on the graph , corresponding to the BRP . is built from replicas of , s.t each node in each replica is connected to all replicas of the neighbors it was originally connected to:

We show that there exists an NTPNE in iff there exists an NTPNE in . Let be an NTPNE in . We construct the strategy profile of such that:

i.e. all replicas of each node get the assignment their original node had in . Let be some node corresponding to a node of the original graph . If , then , and since is a PNE must have exactly one supporting neighbor in . By the construction of , must have exactly supporting neighbors, since all replicas of each neighbor share the same assignment. Since , we have that is playing its best response. If , then , and since is a PNE must have either 0 or at least two supporting neighbor in . By the construction of , must have either 0 or at least supporting neighbors, since all replicas of each neighbor share the same assignment. Since is flat, and , we have that is playing its best response. Therefore is a PNE in . Furthermore, is non-trivial because is non-trivial, thus is an NTPNE.

In the other direction, let be an NTPNE in . We arbitrarily choose replica number 1 of the original graph, and construct a strategy profile of as follows:

Notice that, in , all replicas of the same node share exactly the same neighbors. Therefore, their best response must be the same, and so they all must play the same strategy in any equilibrium, and so:

Specifically, there must be some non-zero assignment in (otherwise the entire strategy profile must be all-zeros, in contradiction), and therefore also in , so if is a PNE it is also an NTPNE. In addition, by the construction of , any node connected to some node is connected to all replicas of , which all share the same assignment. Thus, by the construction of , if a node has supporting neighbors according to , then must have supporting neighbors according to . Specifically, the number of supporting neighbors each node in has must be a multiple of . Let be some node in . If , then , and since is a PNE must have exactly supporting neighbors according to (since the best response to any other multiple of is 0 according to ). Therefore, has exactly 1 supporting neighbor according to , which means it is playing the best response according to the SN-BRP. If , then , and since is a PNE must have either 0 or at least supporting neighbors according to (since the only other multiple of is , which yields 1 as the best response according to ). Therefore, has either 0 or at least 2 supporting neighbors according to , which means it is playing the best response according to the SN-BRP.

a.2 Proof of Theorem 5.2

Proof

For convenience, we demonstrate the general form of , where the marked indices will be defined shortly:

Let be the smallest index s.t (there exists one from condition 3). We define the BRP by:

i.e. is positively-shifted by from (see Definition 13). Notice that satisfies the conditions of Theorem 5.1 (otherwise must either be monotone or infinite, in contradiction). Hence, NTPNE() is NP-Complete, and we can construct a Turing-reduction from it. Let be the smallest index satisfying after the first in ( must exist, since is non-monotone). We have that . Let be a PGG on a graph , where the BRP is . Denote . We construct PGGs corresponding to , on the graphs respectively. For each , contains the graph , but in addition, each node except is connected to new ’Antenna’ nodes that are only adjacent to that specific node. is connected only to such Antennas, and additionally to a Force-1-Gadget (FG). Intuitively, in each graph we add supporting neighbors (compared to ) to each node, and specifically force node to be assigned in any PNE.

Figure 8: Force-1-Gadget with

Force-1-Gadget (shown in Figure 8). The Force-1-Gadget of consists of 3 layers. The first layer consists of only a single ’bridge’ node, denoted , which is also the only node in the gadget connected to . The second layer consists of nodes, all of which are connected to . The third layer consists of nodes, such that each node of the previous layer is connected to unique ones of them (i.e. layer 2 nodes don’t share any layer 3 nodes).

Lemma 12

For any , in any PNE of , must be set to . In addition, all nodes of the Force-1-Gadget must be set to .

Proof

We begin by showing the FG nodes must all play . All nodes in layer 3 of the FG must be set to 1, since they have only one neighbor each, and . Assume by way of contradiction that . Then each node in layer 2 must play , having exactly supporting neighbors (the ones from layer 3). This leads to a contradiction in node , which plays and yet has at most one supporting neighbor. Therefore, . Now, each node in layer 2 must also play , having exactly supporting neighbors (the ones from layer 3, and ). So indeed al nodes of the FG must play 1.

Now, assume by way of contradiction that . Then node plays and yet has exactly supporting neighbors, which is a contradiction. If on the other hand, there is no contradiction. So indeed must be set to , and so do all nodes of the FG.

Lemma 13

For any , there exists an NTPNE in s.t iff there exists an NTPNE in .

Proof

Fix , and let be an NTPNE in s.t . We construct the strategy profile of such that

We now show that is an NTPNE in . Clearly, all Antenna nodes play their best response, having exactly one neighbor (since ). All FG nodes also play their best response, according to Lemma 12.

We now show the original nodes also play their best response. Let be some node in . By definition . is adjacent in to all nodes it was adjacent to in , and by definition all its (original) neighbors receive the same assignment in as they did in . In addition, recall that has new neighbors, all of which receive an assignment of 1 (specifically, for one of those neighbors is the bridge node of the FG). Therefore, has more supporting neighbors in according to than it did in according to . Since is shifted by from , and since is an NTPNE, we have that must be playing its best response in , and thus is an NTPNE131313Clearly is non-trivial, for example the Antenna nodes are all assigned 1..

In the other direction, Let be an NTPNE in . We construct the strategy profile of where

Let be some node in . In , the equivalent node had additional neighbors, all of which must be set to in . Therefore, by definition of , has less supporting neighbors in according to than it did in according to . Since is shifted by from , and since is an NTPNE, we have that must be playing its best response in , and thus is a PNE. In addition, from Lemma 12 we have that must play in , and therefore also in , hence is non-trivial, i.e. is an NTPNE.

We now continue with the proof of the theorem. According to Lemma 13, if there doesn’t exist an NTPNE in , then for all there doesn’t exist an NTPNE in . On the other hand, if there does exist an NTPNE in , then there must be some node s.t according to . Therefore, from Lemma 13, we have that has an NTPNE. Therefore, given an oracle which solves NTPNE(), we run on each of the games . If there exists an NTPNE in one of them, there must exist one in , and otherwise there must not exist one in .

a.3 Proof of Theorem 5.3

Proof

We define the BRP by:

i.e. is positively-shifted by 1 from . Notice that satisfies all conditions of Theorem 5.1 (specifically, the conditions of imply that is non-monotone). Hence, NTPNE() is NPC, which allows us to construct a Turing-reduction from it. Let be the largest index s.t , i.e. . For convenience, we demonstrate the general form of :

where is defined in Theorem 5.3 itself. Let be a PGG defined by on a graph . Denote . We construct PGGs corresponding to , on the graphs respectively. For each , contains the graph , and in addition, each node is connected to a unique Node Gadget (NG) composed of nodes, and node is additionally connected to a Force-1-Gadget (FG).

Figure 9: Node-Gadget with
Figure 10: Force-1-Gadget with ,

Node Gadget (shown in Figure 10). For each node , the Node Gadget is defined as follows. We construct a Denoted , from which one of the nodes, denoted , will be referred to as the ’ng-bridge’ (node-gadget-bridge) node. To , we connect ’Antenna’ nodes, all of which have only as a neighbor. We also connect to .

Force-1-Gadget (shown in Figure 10). The Force-1-Gadget of consists of 3 layers. The first layer consists of only a single ’fg-bridge’ (force-gadget-bridge) node, denoted , which is also the only node in the gadget connected to . The second layer consists of nodes, all of which are connected to . The third layer consists of nodes, such that each node of the previous layer is connected to unique ones of them (i.e. layer 2 nodes don’t share any layer 3 nodes).

We begin by proving the following lemmas.

Lemma 14

Fix , and let be a PNE of the PGG . Let be some node in . Then the ng-bridge node must be set to according to . In addition, when there exists an assignment s.t all nodes of the Node-Gadget play their best response.

Proof

Assume by way of contradiction that . Since the ’Antennas’ of the node gadget are only adjacent to , their best response according to is regardless of ’s strategy, hence they all must be set to . Therefore has (at least) supporting neighbors. Examine the remaining nodes of the Clique of the NG (excluding ). Since , they can’t all be set to , because then each of them is not playing its best response. Therefore, at least one node in must be playing , denoted . Hence, all other nodes in must be set to , otherwise would have between to supporting neighbors, thus it would not be playing its best response according to . Altogether, must have either or supporting neighbor, depending on the strategy of . In both cases is not playing its best response according to , in contradiction to being a PNE.

Note that when , we can set all its Antenna nodes to and all of the nodes in the Clique to , and have that all nodes in the NG play their best response (regardless of the strategy of ).

Lemma 15

For any , in any PNE of , must be set to . In addition, there is only one possibility for an assignment of the Force-1-Gadget nodes, and in this assignment .

Proof

We begin by showing the assignment of the FG nodes. Assume by way of contradiction that the fg-bridge node is set to . Let be some node from layer 2 of the FG. If then all its Antenna nodes must be set to according to , and therefore has one supporting neighbor, and prefers playing . If , then all its Antenna nodes must be set to according to , and therefore has supporting neighbors, and prefers playing . Hence, . Now, if is playing , all its Antenna nodes must play , hence has supporting neighbors, which means it isn’t playing its best response. Thus, all nodes in layer 2 of the FG must play , and therefore all Antenna nodes (layer 3 of the FG) must play .

Now, assume by way of contradiction that . Then the fg-bridge node has supporting neighbors (from layer 2), and yet plays , in contradiction to . Therefore, must be set to 1. In this case, has supporting neighbors, which means it is indeed playing its best response, concluding the proof of the lemma.

Lemma 16

Fix . There exists an NTPNE in s.t iff there exists an NTPNE in .

Proof

Let be an NTPNE in s.t according to . We construct the strategy profile of such that all NG-nodes and FG-nodes are assigned according to the PNEs described in the proofs of Lemmas 14 and 15 respectively, and additionally

We now show that is an NTPNE in . We have already shown in Lemmas 14 and 15 that all NG nodes and FG nodes play their best response. It remains to be shown that the original nodes also play their best response. Let be some node in . By definition . is adjacent in to all nodes it was adjacent to in , and by definition all its (original) neighbors receive the same assignment in as they did in . In addition, from Lemma 14 we have that has one additional supporting neighbor, which is the ng-bridge node . From Lemma 15 we have that even if , the additional fg-bridge node is assigned 0, so it does not affect . Therefore, has exactly one additional supporting neighbor in than it does in . Since is shifted by 1 from , and since is a PNE, we have that must be playing its best response in as well, and thus is an NTPNE141414clearly there exists a non-zero assignment in , for example the ng-bridge nodes..

In the other direction, Let be an NTPNE in . We construct the strategy profile of where

Let be some node in . In , the equivalent node had exactly the same neighbors from (all of which play the same in both games), and according to Lemmas 14 and 15, it had exactly one additional supporting neighbor from the node gadget. Therefore, by definition of , has 1 less supporting neighbor in according to than it did in according to