Abstract 1 Introduction 2 Pursuit-Evasion in Foliage Graphs 3 Throttling Numbers in Graph Products 4 Open Questions and Future Work References

Replacing Cops with Zombies

Fengyi Liu ORCID Department of Computer Science, University of Manitoba, Winnipeg, Canada Avery Miller111corresponding author ORCID Department of Computer Science, University of Manitoba, Winnipeg, Canada
Abstract

In the Cops and Robbers game, two players take turns to move their pieces in a given graph, and the goal of the Cop player is to have any of their pieces capture the piece controlled by the Robber player. In the Zombies and Survivors variant, the Zombie player is trying to catch the piece controlled by the Survivor player, but the pursuers are more restricted: the zombie pieces must always move, and must do so toward the survivor along a shortest path. Essentially, the zombies move in a ’brainless’ way, which severely limits the design of algorithmic strategies. In a practical setting where the pursuers are robots or drones, the zombie strategies can be carried out by simpler/cheaper devices. This motivates the question: when can cops be replaced by zombies? In contrast to previous work that highlights graph classes where cops are significantly more useful when trying to catch the evader, we examine some situations where the simpler restricted movements imposed on zombies can be sufficient.

Keywords and phrases:
Pursuit-Evasion Games, Grid Graphs, Cop Number, Zombie Number, Throttling Number
Funding:
Avery Miller: Supported by the Natural Sciences and Engineering Research Council of Canada (NSERC), Discovery Grant RGPIN-2024-06411.
Copyright and License:
[Uncaptioned image] © Fengyi Liu and Avery Miller; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing Graph theory
; Theory of computation Design and analysis of algorithms
Related Version:
Related Thesis: http://hdl.handle.net/1993/38062
Editor:
John Iacono

1 Introduction

Pursuit-Evasion games are combinatorial problems in graphs that can model searching and exploration. In these games, one player controls a set of pursuers while the other player controls an evader. For potential real-world applications, one can imagine a rescue team trying to save a lost target (e.g., a human or animal) even if the target is moving in an unpredictable or unhelpful way. Other applications could involve capturing an intruder in a physical environment or stopping a software-based virus in a network.

Cops and Robbers is a classic Pursuit-Evasion game that was first introduced by Quilliot [17] and by Nowakowski and Winkler [15]. The game is played by two players on a graph G. The Cop player controls a set of cop pieces, and the Robber player controls a single robber piece. The game consists of discrete rounds, each of which consists of a Cop turn followed by a Robber turn. In the initial round, the Cop player places the cop piece(s) at any vertices of G, and then the robber player places the robber piece at any vertex of G. From this point on, both players see the locations of all pieces. In each subsequent round, the Cop player first takes its turn by making a decision for each of the cop pieces, i.e., each piece can either stay at its current position or move to an adjacent vertex; then, the Robber player takes its turn by choosing whether the robber piece will stay at its current position or move to an adjacent vertex. The Cop player wins if there is ever a time when at least one cop piece is at the same vertex as the robber piece, otherwise, the game goes on indefinitely and the Robber player wins. A variant called Zombies and Survivors was introduced by Fitzpatrick et al. [9]. In this version of the game, “cops” are replaced by “zombies”, and the “robber” is replaced by a “survivor”. The rules are similar except that, during the Zombie player’s turn, each zombie piece must move, and it must move along a shortest path toward the survivor. If there are multiple shortest paths toward the survivor, then the zombie can freely choose to move along any one of them. The Zombie player wins if there is ever a time when at least one zombie piece is at the same vertex as the survivor piece, otherwise, the game goes on indefinitely and the Survivor player wins. Besides providing an alternative approach to law enforcement, this variant is interesting since each pursuer follows a greedy rule, which allows for simple implementations that can be used by robots or drones with limited computational power or memory.

1.1 Definitions

Pursuit-Evasion games are played on a simple, undirected graph G with vertex set V(G) and edge set E(G). The minimum number of cops for which there is a winning strategy for the Cop player in Cops and Robbers in a graph G is called the cop number c(G) of G, and the minimum number of zombies for which there is a winning strategy for the Zombie player in Zombies and Survivors in a graph G is called the zombie number z(G). A graph with cop number k is called a k-cop-win graph. A 1-cop-win graph is also called a cop-win graph, and a graph that is not 1-cop-win is called a robber-win graph. A zombie-win graph, survivor-win graph and k-zombie-win graph are defined similarly.

Besides studying the number of pursuers, we also consider how quickly the pursuers can capture the evader. The capture time is a measure of the length of the game, that is, the number of rounds that elapse until capture, assuming that both players move optimally. When we say that the players move optimally, we mean that during each of the pursuer’s turns, given the current positions of all pieces, the pursuer moves its piece(s) to minimize the number of rounds required to capture the evader in the worst case considering all possible evader strategies. Similarly, during each of the evader’s turns, given the current positions of all piece(s), the evader moves its piece(s) to maximize the number of rounds for pursuers to capture the evader in the best case considering all possible pursuer strategies. We use the definition of capture time for Cops and Robbers from [3]: for any pc(G), the cop capture time, denoted by captc(G,p), is the minimum number of rounds needed for p cops to capture the robber on G over all possible games in which both players play optimally. We use the analogous definition of capture time for Zombies and Survivors [11]: for any pz(G), the zombie capture time, denoted by captz(G,p), is the minimum number of rounds needed for p zombies to capture the survivor on G over all possible games in which both players play optimally. For any graph G, captc(G,p)captz(G,p), since p cops can follow any p-zombie-strategy.

The throttling number is a measure that combines the number of pursuers and the capture time. Breen et al. [6] introduced the cop-throttling number, denoted by thc(G), as the minimum value of (p+captc(G,p)) taken over all p{c(G),,|V(G)|}. We define the zombie-throttling number thz(G) of a graph G analogously: the zombie-throttling number, denoted by thz(G), is the minimum value of (p+captz(G,p)) taken over all p{z(G),,|V(G)|}. For any graph G, we have thc(G)thz(G), since p+captc(G,p)p+captz(G,p) for any fixed p.

1.2 Our Results

In Section 2, we study a graph class that exhibits a structure where having cops as pursuers seems to be more useful than having zombies. In particular, if a graph has a central vertex c whose removal would shatter the graph into small pieces, then a good strategy for the Cop player would be to have one cop stay at vertex c to guard it, and then have a small number of cops go chase and capture the robber in its component. In Zombies and Survivors, the Zombie player cannot implement this strategy since every zombie piece must move in every round, and so different strategies, and perhaps more zombies, are needed. We study a particularly simple such class of graphs, which we call foliage graphs, each of which consist of a collection of at least two cycles which meet at a single common intersection vertex. This graph class is a generalization of a set of graphs studied by Bartier et al. [1]. The cop number of any such graph is at most 2, using the strategy described above. We provide a characterization of foliage graphs that allows us to distinguish whether the zombie number is 1, 2, or neither. In other words, our characterization determines for which foliage graphs the zombie number is equal to the cop number.

In Section 3, we compare the cop-throttling number and zombie-throttling number of the Cartesian grid and the strong grid. In particular, we give matching upper and lower asymptotic bounds on the throttling number of such graphs, which are the same regardless of whether the pursuers are cops or zombies. More specifically, we prove that for any integers ab1, and G{PaPb,PaPb},

thz(G)=thc(G)={Θ((ab)1/3)=Θ(|G|1/3) if ab(ab)13,Θ(a1/2)=Θ(|G|12logaba) if a(ab)13>b.

Due to space limitations, in some cases we omit or only sketch the proof details. Many of the omitted details can be found in [12].

1.3 Related Work

Fitzpatrick et al. [9] formally introduced Zombies and Survivors. Since the allowed zombies’ moves are a subset of the allowed cops’ moves, it follows that z(G)c(G), which allows us to relate upper and lower bounds from one problem to the other. Offner and Ojakian [16] proved that the ratio z(G)/c(G) can be made arbitrarily large by showing that, for any mk1, there is a graph with zombie number m and cop number k. One direction of research is to determine the zombie number or bounds on the zombie number for specific graph classes, such as outerplanar graphs [1, 4, 9], hypercubes [8], and graph products [1, 5, 8, 9, 11, 13, 14, 16, 18]. Regarding capture time, Clarke and Nowakowski [7] showed that for a cop-win graph with n vertices, the cop-win strategy in terms of cop-win ordering naturally leads to a capture time of at most n. Bonato et al. [3] improved the capture time bound to n3 for graphs with n5 vertices, and Gavenčiak [10] improved the bound to n4 when n7. Bonato et al. [3] showed that the capture time of 2-dismantlable graphs (graphs that have at least two corners after recursively removing two corners) is bounded above by n/2. For the Cops and Robbers game, determining the capture time with k cops for some fixed constant k is in P [2]. Determining the minimum number of cops to capture the robber within k rounds for some fixed constant k is NP-complete [3]. Further, Keramatipour and Bahrak [11] proved that determining the minimum number of zombies to capture the survivor within k rounds for an arbitrary given k is NP-hard for Zombies and Survivors. Also, they provided a bound on the capture time of the Cartesian product of G and H with zG+zH zombies, and showed captz(GH,zG+zH)rad(G)+rad(H)+captz(G,zG)+captz(H,zH) [11]. Regarding throttling numbers, Breen et al. [6] proved that for the grid G=PaPb, the cop-throttling number satisfies thc(G)O(ab). Breen et al. [6, Observation 2.1] showed that for every graph G, the cop-throttling number satisfies thc(G)γ(G)+1 where γ(G) denotes the domination number of G. The same upper bound applies to zombie-throttling number thz(G), since by initially placing γ(G) zombies on the vertices of a minimum dominating set, the survivor’s starting vertex is either in the dominating set or adjacent to a vertex in the dominating set, so the survivor will be captured by a zombie in the first round. Breen et al. [6, Example 2.2] then showed that the cop-throttling can be arbitrarily smaller than the domination number, and the same example also applies to the zombie-throttling number.

2 Pursuit-Evasion in Foliage Graphs

We start by studying the winning strategy for zombies in a single cycle. It is known that the zombie number of a cycle of length at least 4 is 2, since the survivor can escape one zombie by keeping a distance of 2 away from the zombie. So, we fully characterize the winning positions of two zombies on a single cycle. At a high level, it is necessary and sufficient that the initial distance between the two zombies satisfies the condition that the shortest paths from the two zombies towards any potential starting vertex of the survivor are in different directions (i.e., one is clockwise and the other is counter-clockwise), since otherwise the two zombies will chase the survivor around the cycle in the same direction forever.

Lemma 1.

Consider any cycle C such that |C|4. Two zombies have a winning strategy in C if and only if the distance between the initial positions of the two zombies is in {|C|22,,|C|2}. Equivalently, two zombies have a winning strategy in C if and only if one of the two paths between the initial positions of the two zombies has length in {|C|22,,|C|2+2}.

Next, we set out to characterize the 1-zombie-win and 2-zombie-win foliage graphs. Recall that foliage graphs are formed by a collection of cycles sharing a common center vertex c. First, notice that when all cycles are of the length 3, then the center vertex c is a dominating vertex. If there is a cycle of length at least 4, then the zombie number is at least 2, since the survivor can stay in the largest cycle and evade a single zombie indefinitely. These two observations also hold for the Cops and Robbers game, which allows us to characterize the 1-zombie-win and 1-cop-win foliage graphs.

Observation 2.

For any foliage graph F whose collection of cycles is {C0,C1,,Cn} such that n0, z(F)=c(F)=1 if and only if |Ci|=3 for each i{0,1,2,,n}.

For Cops and Robbers, we see that c(F)2 for any foliage graph F: one cop stays at the center vertex c while the other cop chases the robber around its cycle. The situation is more complex for Zombies and Survivors, as we now demonstrate by fully characterizing the 2-zombie-win foliage graphs.

At a high level, our sufficient condition for two zombies to win in a foliage graph ignores all the 3-cycles, the 4-cycles, and the largest cycle, and states that all the remaining cycles have roughly the same size.

Lemma 3.

Consider any foliage graph F whose collection of cycles is {L,C1,,Cn} such that n1 and |L||Ci||Cj|3 for i,j{1,2,,n} such that ij, and let S={i{1,2,3,,n}|Ci|5}. If S= or iS{|Ci|22,,|Ci|2+2}, then the zombie number of F satisfies z(F)2.

Proof Sketch.

Let S=i=1n{|Ci|22,,|Ci|2+2}, and, let d=min(S) be the smallest integer in S. Then, we have i{1,2,3,,n},d{|Ci|22,,|Ci|2+2}. Since d was defined as the minimum integer that belongs to each set {|Ci|22,,|Ci|2+2}, and, since |C1| is the length of the largest cycle besides L, no set {|Ci|22,,|Ci|2+2} has all elements strictly larger than |C1|22, so d=|C1|22. Let x=(|L|2|C1|2)/2. We now show that there is a 2-zombie-win strategy. With respect to the center vertex c, initially place the zombies Z1 and Z2 in L (the largest cycle) such that d(Z1,c)=x and d(Z2,c)=d+x, respectively, and in opposite directions. These zombie positions are chosen with a winning distance between them (as characterized by Lemma 1), so that they can catch the survivor if it starts and stays in L. If the survivor starts in a cycle other than L (or starts in L then leaves), the additional distance d from Z2 to c will make sure that, when both zombies leave L and enter a different cycle, they are guaranteed to form a winning position in the new cycle that contains the survivor.

The next result shows that the converse of Lemma 3 is also true, which completes the characterization of 2-zombie-win foliage graphs.

Lemma 4.

Consider any foliage graph F whose collection of cycles is {L,C1,,Cn} such that n1 and |L||Ci||Cj|3 for i,j{1,2,,n} such that ij, and let S={i{1,2,3,,n}|Ci|5}. If S and iS{|Ci|22,,|Ci|2+2}=, then the zombie number of F satisfies z(F)>2.

Proof Sketch.

Consider two cases, depending on the difference d between the initial distance from Z1 to center c and the initial distance from Z2 to center c. Without loss of generality, we assume that Z1 starts closer to c than Z2 does. Since we assume that S and iS{|Ci|22,,|Ci|2+2}=, there must exist an iS such that d{|Ci|22,,|Ci|2+2}. In the first case, we assume that d<|Ci|22, which means that the survivor can lure the two zombies into either Ci or L (whose length is at least as large as |Ci|) and when the two zombies chase the survivor so that both are in that cycle, they will be too close together to form a winning position (as characterized by Lemma 1). In the second case, we assume that d>|Ci|2+2. In this case, the survivor allows Z1 to chase it around the cycle Ci at least once before Z2 reaches c, and in doing so, decreases the distance between Z1 and Z2 by at least |Ci|. We prove that this new distance is less than |L|22, which means that the zombie can enter cycle L and the zombies will be too close together to form a winning position (as characterized by Lemma 1).

For foliage graphs with zombie number greater than 2, we obtain an upper bound by partitioning the collection of cycles according to their lengths such that all cycles of the same length are in the same part (and share a winning strategy in the sense of Lemma 3). The zombie number can be bounded above by the 1+(number of parts in the partition) as follows: place one zombie at the center vertex c, and, for each part of the partition, choose one cycle and place one zombie in a vertex diametrically opposite to c in this cycle. The survivor’s starting position is in some part p of the partition, and by applying a 2-zombie-win strategy for the zombie at c and the other zombie in p, the survivor will be captured. Bartier et al. [1] constructed a foliage graph Gk, which consists of k copies of cycles of length 2m+23 for each m{1,k}, and they proved that the zombie number of such a graph satisfies z(Gk)k, e.g., that planar graphs have unbounded zombie number. Using our technique described earlier in this paragraph, the zombie number of Gk is bounded above by k+1.

3 Throttling Numbers in Graph Products

The Cartesian product of graphs G and H, denoted by GH, is a graph whose vertex set is the Cartesian product V(G)×V(H)={(u,v)uV(G),vV(H)} and whose edge set consists of all pairs {(u,v),(u,v)} where u,uV(G),v,vV(H) that satisfy exactly one of the following: (i) u=u and {v,v}E(H), or, (ii) v=v and {u,u}E(G). The strong product of graphs G and H, denoted by GH, is a graph such that the vertex set V is the Cartesian product V(G)×V(H), and the edge set E consists of all pairs {(u,v),(u,v)} where u,uV(G),v,vV(H) that satisfy exactly one of the following: (i) u=u and {v,v}E(H), or, (ii) v=v and {u,u}E(G), or, (iii) {u,u}E(G) and {v,v}E(H).

3.1 Zombie-Throttling Number of the Cartesian Grid

First, we establish matching upper and lower bounds on the zombie-throttling number of a×b Cartesian grids. Without loss of generality, we assume that ab. Let PaPb be the a×b grid with vertex set V={(x,y)x{0,1,2,,a1},y{0,1,2,,b1}}, then the size of PaPb is |V|=ab. For convenience, assume that the grid PaPb is drawn in the first quadrant of the Euclidean plane, where the first element of each vertex corresponds to its x-coordinate, and the second element of each vertex corresponds to its y-coordinate.

For the upper bound, the idea is to divide the entire grid into smaller subgrids and place the zombies at the corners of the subgrids. Let da,db be two positive integers such that daa1 and dbb1, whose specific values will be set later during the analysis. Roughly speaking, the values da and db represent the width and height of the subgrids, respectively (except for some subgrids at the rightmost and topmost border of the grid, due to the width or height of the entire grid not being divisible by da or db, respectively). The number of subgrids that fit horizontally in the grid is defined as sa=(a1)/da, and the number of subgrids that fit vertically in the grid is defined as sb=(b1)/db. The initial placement of the zombies is at the corner of these subgrids, and to ensure that the placement of zombies remains within the boundaries of the grid, the maximum value of the zombie’s initial coordinate is at most a1 in the x-coordinate and at most b1 in the y-coordinate. More specifically, for each i{0,,sa} and j{0,,sb}, place one zombie, denoted Zi,j, at vertex (min{ida,a1},min{jdb,b1}). Note that, if a1 is not an integer multiple of da, the initial distance between zombies Zsa1,j and Zsa,j is less than da, and, if b1 is not a multiple of db, the initial distance between zombies Zi,sb1 and Zi,sb is less than db. Then, place four additional zombies: one at each corner of the grid. Figure 1 illustrates an example of the initial placement of zombies for P12P10 with da=db=(119)1/3=5. This completes the description of the initial placement of zombies, leading to the following upper bound on the number of zombies.

(a) Initial placement of zombies (black dot: one zombie, gray dot: two zombies).
(b) Corresponding subgrids.
Figure 1: P12P10 with da=db=(ab)1/3=5.
Lemma 5.

For any integers a,b1, the number of zombies placed in PaPb is at most 5(a1)(b1)dadb+8.

Next, the survivor selects its starting vertex. For i{0,,sa1} and j{0,,sb1}, denote by subgrid SGi,j the subgrid with four corner vertices (ida,jdb), (min{a1,(i+1)da},jdb), (ida,min{b1,(j+1)db}), and (min{a1,(i+1)da},min{b1,(j+1)db}). These corners are initially occupied by Zi,j, Zi+1,j, Zi,j+1, and Zi+1,j+1, respectively, with the bottom-left corner of SGi,j occupied by Zi,j. The survivor’s starting position lies within a subgrid SGα,β for some α{0,,sa1} and β{0,,sb1}. We refer to this subgrid as the survivor’s home subgrid (and if the survivor is on the boundary of multiple subgrids, the home subgrid is defined as the one that minimizes both α and β.)

Let d=max{da,db}. To describe the zombie strategy when the survivor’s home subgrid is SGα,β, we define four pairs of nearby zombies, called the confining zombies that surround the survivor in four directions: below, above, to the left, and to the right. More specifically, the four pairs are defined as follows:

  • ZH1{Zα,jbelow,Zα+1,jbelow}, where jbelow is the largest index such that the y-coordinate of the two zombies is initially at least d below the survivor’s initially, or jbelow=0 if no such index exists.

  • ZH2{Zα,jabove,Zα+1,jabove}, where jabove is the smallest index such that the y-coordinate of the two zombies is initially at least d above the survivor’s initially, or jabove=sb1 if no such index exists.

  • ZV1{Zileft,β,Zileft,β+1}, where ileft is the largest index such that the x-coordinate of the two zombies is initially at least d to the left of the survivor’s, or ileft=0 if no such index exists.

  • ZV2{Ziright,β,Ziright,β+1}, where iright is the smallest index such that the x-coordinate of the two zombies is initially at least d to the right of the survivor’s, or iright=sa1 if no such index exists.

No individual zombie needs to be used in more than one of the above pairs, even if SGi,j lies at a corner of PaPb, because we placed an additional zombie at each corner of the grid during the initial setup.

We say that a zombie Z catches the survivor’s x-shadow if Z and the survivor have the same x-coordinate. Catching the survivor’s y-shadow is defined analogously. For each H{H1,H2}, we say that the pair of zombies in ZH have caught the survivor’s x-shadow if at least one zombie in ZH has done so. Similarly, for each V{V1,V2}, the pair of zombies in ZV has caught the survivor’s y-shadow if at least one zombie in ZV has done so.

The Zombie Algorithm.

In each round after the initial placement of the zombies and survivor, the zombie strategy proceeds as follows. Each zombie in ZH1ZH2 moves horizontally to catch the survivor’s x-shadow, but if it already has the same x-coordinate as the survivor, it instead moves toward the survivor vertically. Similarly, each zombie in ZV1ZV2 moves vertically to catch the survivor’s y-shadow, but if it already has the same y-coordinate as the survivor, then it moves toward the survivor horizontally. All other zombies move arbitrarily along any shortest path towards the survivor. This concludes the description of the strategy.

Immediately after the survivor’s move in each round t, the eight confining zombies have established a region of the grid called the confined territory in round t that contains the survivor’s position. More specifically, the confined territory consists of the vertices whose x-coordinate is bounded below by the x-coordinates of both zombies in ZV1 and bounded above by the x-coordinates of both zombies in ZV2, and whose y-coordinate is bounded below by the y-coordinates of both zombies in ZH1, and bounded above by the y-coordinates of both zombies in ZH2. At a high level, the algorithm works by gradually shrinking this region until one of the zombies captures the survivor.

Lemma 6 shows that, in every round t of the algorithm, the confined territory in round t contains the survivor’s location. Moreover, there will be a round in which both ZH1 and ZH2 have caught the survivor’s x-shadow, and, both ZV1 and ZV2 have caught the survivor’s y-shadow. The algorithm’s execution leading up to the first such round can be considered the first phase of the algorithm, and we prove that the first phase terminates within max{da,db}2=d2 rounds.

Lemma 6.

In every round t of the algorithm, the confined territory in round t contains the survivor’s location. Moreover, there exists a round T1max{da,db}2 such that, after the zombies’ move in round r, both ZH1 and ZH2 have caught the survivor’s x-shadow, and, both ZV1 and ZV2 have caught the survivor’s y-shadow.

By Lemma 6, in all rounds, the survivor is trapped and unable to cross the boundaries of the confined territory established by the zombies in ZH1ZH2ZV1ZV2 without being caught. In each round, the survivor’s turn can change the value of at most one of its coordinates. As a result, during the second phase of the algorithm, two of the boundaries of the confined territory get closer together with each round. For example, if the survivor’s x-coordinate changes, then the zombies in ZH1 and ZH2 will move horizontally to catch the survivor’s x-shadow, while the zombies in ZV1 and ZV2 (who have the same y-coordinate as the survivor) will move horizontally such that their x-coordinates get closer to the survivor’s. We prove in Lemma 7 that, within an additional 5max{da,db} rounds after the end of the first phase, the distance between the two horizontal or vertical boundaries of the confined territory is 0 or 1, and that this implies that the survivor is captured.

Lemma 7.

Suppose that, after the zombies’ move in some round T1, both ZH1 and ZH2 have caught the survivor’s x-shadow, and, both ZV1 and ZV2 have caught the survivor’s y-shadow. Then the survivor is caught by round T1+5max{da,db}.

Finally, we obtain an upper bound on the zombie-throttling number by summing the number of zombies in Lemma 5 and the capture time of the two phases in Lemmas 6 and 7.

Lemma 8.

For any integers ab1, the zombie-throttling number of PaPb is at most 5(a1)(b1)dadb+112max{da,db}+8.

It remains to set the values of da,db, i.e., the width and height of the subgrids. We separately consider two cases depending on the relationship between a and b. First, we consider Cartesian grids PaPb that are “square-like”, i.e., both dimensions are large. In particular, if ab>(ab)1/3, we set da=db=(ab)1/3, so the entire grid is divided into subgrids of size (ab)1/3-by-(ab)1/3, and we obtain the following upper bound on the zombie-throttling number.

Lemma 9.

For any integers ab(ab)1/3, the zombie-throttling number of PaPb satisfies thz(PaPb)212(ab)1/3+14O((ab)13)=O(|V(PaPb)|13).

Otherwise, the grid PaPb is “path-like”, i.e., one dimension is significantly larger. In particular, if a(ab)1/3>b, we set da=a1/2 and db=b1, the entire grid is divided into subgrids of size a1/2-by-(b1). In particular, the height of each subgrid is equal to the height of the entire grid PaPb, so there are only multiple subgrids in the horizontal direction. We obtain the following upper bound on the zombie-throttling number.

Lemma 10.

For any integers a(ab)1/3>b, the zombie-throttling number of PaPb satisfies thz(PaPb)212a1/2+14=O(a1/2)=O((|PaPb|12logaba).

Next, we prove two general lower bounds on the zombie-throttling number of PaPb. These bounds will be applied differently: one for square-like grids and the other for path-like grids. The proof idea behind the lower bounds is to cover the entire grid using neighborhoods of radius k, with the center of each neighborhood occupied by a zombie for some fixed capture time kN. Since the initial survivor position must be within distance k of at least one zombie, the minimum number of neighborhoods of radius k needed to cover the entire grid provides a lower bound on the number of zombies needed to capture the survivor within k rounds. Then, a lower bound on the throttling number is obtained by the minimizing the sum of capture time k and the number of neighborhoods of radius k.

Lemma 11.

For any integers a,b1, the zombie-throttling number of PaPb satisfies thz(PaPb)>32(ab)1312Ω(|PaPb|1/3).

Lemma 12.

For any integers a,b1, the zombie-throttling number of PaPb satisfies thz(PaPb)2(a/2)1/21/2=Ω(a1/2)=Ω(|PaPb|12logaba).

From Lemmas 9 and 11, we get asymptotically tight bounds on the zombie-throttling number when ab(ab)1/3. From Lemmas 10 and 12, we get asymptotically tight bounds on the zombie-throttling number when a(ab)1/3>b.

Theorem 13.

For any integers ab>1, the zombie-throttling number of PaPb satisfies

thz(PaPb)={Θ((ab)1/3)=Θ(|PaPb|1/3) if ab(ab)13,Θ(a1/2)=Θ(|PaPb|12logaba) if a(ab)13>b.

3.2 Zombie-Throttling Number of the Strong Grid

In this section, we modify our approach for the Cartesian grid PaPb from Section 3.1 to prove tight asymptotic bounds on the zombie-throttling number in the strong grid PaPb. The main difference is that, in a strong grid, if a zombie doesn’t have the same x and y coordinates as the survivor, then the zombie can move closer to the survivor in both coordinates during its turn. Let PaPb be the a×b strong grid with vertex set V={(x,y)x{0,1,2,,a1},y{0,1,2,,b1}}. As in Section 3.1, suppose that the grid PaPb is drawn in the Euclidean plane.

For the upper bound, we initially place the zombies as we did in Section 3.1, but we don’t place four additional zombies at the four corners of the graph. Figure 2(a) illustrates an example of the initial zombie placement for P10P10 with da=db=(99)1/3=5, and the corresponding subgrids. Subtracting 4 from the bound obtained in Lemma 5, we obtain the following upper bound on the number of zombies.

Lemma 14.

For all integers a,b1, the number of zombies placed in PaPb is at most 5(a1)(b1)dadb+4.

(a) Initial placement of zombies (black dot: one zombie).
(b) Corresponding subgrids with boundaries in red.
Figure 2: Example of P10P10 with da=db=(ab)1/3=5.

Next, the survivor chooses its starting vertex, which lies within a subgrid SGα,β for some α{0,,sa1} and β{0,,sb1}. We refer to this subgrid as the survivor’s home subgrid (and if the survivor is on the boundary of multiple subgrids, the home subgrid is defined as the one that minimizes both α and β.) The four corners of the home subgrid are occupied by zombies Zα,β,Zα,β+1,Zα+1,β+1,Zα+1,β, and we call these four zombies the corner zombies. We define four pairs of zombies using the four corner zombies of the home subgrid SGα,β, and each pair is lying on the boundaries of SGα,β in four directions: bottom, top, left, and right. More specifically, let ZH1={Zα,β,Zα+1,β}, ZH2={Zα,β+1,Zα+1,β+1}, ZV1={Zα,β,Zα,β+1}, ZV2={Zα+1,β,Zα+1,β+1}.

In Lemma 15, we show that at least one of the four corner zombies in the set ZH1ZH2ZV1ZV2 will capture the survivor, and this will happen within max{da,db}2 rounds.

Lemma 15.

In some round Tmax{da,db}2, at least one zombie in ZH1ZH2ZV1ZV2 will capture the survivor.

Combining Lemmas 14 and 15, we get an upper bound on the zombie-throttling number of PaPb.

Lemma 16.

For all integers a,b1, the zombie-throttling number of PaPb satisfies thz(PaPb)5(a1)(b1)dadb+max{da,db}2+4.

It remains to set the values of da,db, i.e., the width and height of the subgrids. We separately consider two cases depending on the relationship between a and b. For strong grids PaPb that are “square-like”, i.e., if ab>(ab)1/3, we set da=db=(ab)1/3, so the entire grid is divided into subgrids of size (ab)1/3-by-(ab)1/3. Otherwise, the grid PaPb is “path-like”, i.e., one dimension is significantly larger. In particular, if a(ab)1/3>b, we set da=a1/2 and db=b1, the entire grid is divided into subgrids of size a1/2-by-(b1). Analogously to Lemmas 9 and 10, we obtain the following upper bounds on the zombie-throttling number.

Lemma 17.

For any integers ab(ab)1/3, the zombie-throttling number of PaPb satisfies thz(PaPb)112(ab)1/3+5O((ab)13)=O(|PaPb|13). For any integers a(ab)1/3>b, the zombie-throttling number of PaPb satisfies thz(PaPb)112a1/2+5=O(a1/2)=O(|PaPb|12logaba).

To prove lower bounds on the zombie-throttling number for PaPb, we use the same approach as for Lemma 11 in Section 3.1, except that the bound differs since the number of neighborhoods of radius k needed to cover the strong grid is smaller. The same lower bound from Lemma 12 holds.

Lemma 18.

For all integers a,b1, the zombie-throttling number of PaPb satisfies thz(PaPb)324/3(ab)1312Ω(|PaPb|1/3). Moreover, thz(PaPb)2(a/2)1/21/2=Ω(a1/2)=Ω(|PaPb|12logaba).

Combining Lemmas 17 and 18, we get the following asymptotically tight bounds on the zombie-throttling number of PaPb.

Theorem 19.

For any integers ab1, the zombie-throttling number of PaPb satisfies

thz(PaPb)={Θ((ab)1/3)=Θ(|PaPb|1/3) if ab(ab)13,Θ(a1/2)=Θ(|PaPb|12logaba) if a(ab)13>b.

3.3 Cop-Throttling Numbers of Grids

The lower bounds from Sections 3.1 and 3.2 also apply to Cops and Robbers, since the proofs only rely on the fact that the game pieces can move to at most one adjacent vertex, once per round. Moreover, upper bounds from Zombies and Survivors immediately apply to Cops and Robbers since the cops can follow the zombie strategy. Thus, we get the following bounds on the cop-throttling number.

Corollary 20.

For any integers ab1, and G{PaPb,PaPb}, the cop-throttling number of G satisfies

thc(G)={Θ((ab)1/3)=Θ(|G|1/3) if ab(ab)13,Θ(a1/2)=Θ(|G|12logaba) if a(ab)13>b.

4 Open Questions and Future Work

We leave open the characterization of foliage graphs for each zombie number z>2. For throttling numbers, a natural question to ask is whether our asymptotic bounds generalize for grids in higher dimensions. To start, one could study the graph G=kPn or G=kPn and determine whether the zombie-throttling number and/or cop-throttling number is Θ(|G|1k+1). We believe that our techniques should also extend to obtain the same asymptotic bounds on the throttling numbers of the Cartesian torus CaCb and the strong torus CaCb.

References

  • [1] Valentin Bartier, Laurine Bénéteau, Marthe Bonamy, Hoang La, and Jonathan Narboni. A note on deterministic zombies. Discrete Applied Mathematics, 301:65–68, 2021. doi:10.1016/j.dam.2021.05.001.
  • [2] A. Berarducci and B. Intrigila. On the cop number of a graph. Advances in Applied Mathematics, 14(4):389–403, 1993. doi:10.1006/aama.1993.1019.
  • [3] A. Bonato, P. Golovach, G. Hahn, and J. Kratochvíl. The capture time of a graph. Discrete Mathematics, 309(18):5588–5595, 2009. doi:10.1016/j.disc.2008.04.004.
  • [4] Prosenjit Bose, Jean-Lou De Carufel, and Thomas C. Shermer. Pursuit-evasion in graphs: Zombies, lazy zombies and a survivor. Discret. Math., 348(1):114220, 2025. doi:10.1016/J.DISC.2024.114220.
  • [5] Prosenjit Bose, Jean-Lou De Carufel, and Thomas Shermer. On the zombie number of various graph classes. In LATIN 2022: Theoretical Informatics: 15th Latin American Symposium, pages 527–543, 2022. doi:10.1007/978-3-031-20624-5_32.
  • [6] Jane Breen, Boris Brimkov, Joshua Carlson, Leslie Hogben, K.E. Perry, and Carolyn Reinhart. Throttling for the game of cops and robbers on graphs. Discrete Mathematics, 341:2418–2430, September 2018. doi:10.1016/j.disc.2018.05.017.
  • [7] Nancy E Clarke and Richard J Nowakowski. Cops, robber and traps. Utilitas Mathematica, 60:91–98, 2001. URL: https://new.utilitasmathematica.com/?journal=Index&page=article&op=view&path[]=209.
  • [8] Shannon L. Fitzpatrick. The game of zombies and survivors on the cartesian products of trees. ArXiv e-prints, 2018. arXiv:1806.04628. arXiv:1806.04628.
  • [9] S.L. Fitzpatrick, J. Howell, M.E. Messinger, and D.A. Pike. A deterministic version of the game of zombies and survivors on graphs. Discrete Applied Mathematics, 213:1–12, 2016. doi:10.1016/j.dam.2016.06.019.
  • [10] Tomáš Gavenčiak. Cop-win graphs with maximum capture-time. Discrete Mathematics, 310(10):1557–1563, 2010. doi:10.1016/j.disc.2010.01.015.
  • [11] Ali Keramatipour and Behnam Bahrak. Zombie number of the cartesian product of graphs. Discrete Applied Mathematics, 289:545–549, 2021. doi:10.1016/j.dam.2020.10.023.
  • [12] Fengyi Liu. Zombies and survivors on graph classes. Master’s thesis, University of Manitoba, 2024. URL: http://hdl.handle.net/1993/38062.
  • [13] M. Maamoun and H. Meyniel. On a game of policemen and robber. Discrete Applied Mathematics, 17(3):307–309, 1987. doi:10.1016/0166-218X(87)90034-5.
  • [14] S. Neufeld and R. Nowakowski. A game of cops and robbers played on products of graphs. Discrete Mathematics, 186:253–268, May 1998. doi:10.1016/S0012-365X(97)00165-9.
  • [15] Richard J. Nowakowski and Peter Winkler. Vertex-to-vertex pursuit in a graph. Discret. Math., 43(2):235–239, 1983. doi:10.1016/0012-365X(83)90160-7.
  • [16] David Offner and Kerry Ojakian. Comparing the power of cops to zombies in pursuit-evasion games. Discrete Applied Mathematics, 271:144–151, December 2019. doi:10.1016/j.dam.2019.07.026.
  • [17] Alain Quilliot. Jeux et pointes fixes sur les graphes. PhD thesis, Université de Paris VI, 1978.
  • [18] Ratko Tošic. On cops and robber game. Studia Scientiarum Mathematicarum Hungarica, 23:225–229, January 1988.