Computer Science Technical Report Archive

USC Computer Science Technical Reports, no. 907 (2009)

(USC DC Other)

USC Computer Science Technical Reports, no. 907 (2009)

PDF

Download a page range

Download transcript

Copy asset link

Request this asset

Transcript (if available)

Content ESP: Pursuit Evasion on Series-Parallel Graphs ∗ Richard Borie Computer Science University of Alabama borie@cs.ua.edu Craig Tovey Industrial and Systems Engineering Georgia Institute of Technology craig.tovey@isye.gatech.edu Kenny Daniel Sven Koenig Computer Science University of Southern California {kfdaniel,skoenig}@usc.edu Abstract We study pursuit-evasion problems where pursuers have to clear a given graph of fast-moving evaders despite poor visi- bility, for example, where police search a cave system to en- sure that no terrorists are hiding in it. If the vertex connectiv- ity of some part of the graph exceeds the number of pursuers, the evaders can always avoid capture. We therefore focus on graphs whose subgraphs can always be cut at a limited number of vertices, that is, graphs of low treewidth. How- ever, solving pursuit-evasion problems optimally is NP-hard even for the simplest of these graph classes. In this paper, we therefore develop a heuristic approach, called ESP, that solves large pursuit-evasion problems on series-parallel (that is, treewidth-two) graphs quickly and with small costs. It ex- ploits their topology by performing dynamic programming on their decomposition graphs. We apply ESP to different kinds of series-parallel graphs and show that it scales up to larger graphs than a strawman approach based on previous results from the literature. Introduction Pursuit evasion is an important problem in artificial intelli- gence (Gordon, Thrun, and Gerkey 2004), agents (Pellier and Fiorino 2005), robotics (Simov, Slutzki, and LaValle 2000) and theoretical computer science (Parsons 1976). Consider, for example, a scenario where police search a known but twisty cave system to ensure that no terrorists are hiding in it. The police are the pursuers, and the terror- ists are the evaders. The cave system can be modeled as a graph with edges that have lengths. The pursuers (which we call robots) and evaders move on this graph. The evaders can hide anywhere on the vertices or edges. They cannot be seen by the robots and can move much faster than them. They get caught only if they collide with a robot on a vertex or edge. The robots move at unit speed. Their travel times ∗ This material is based upon work supported by, or in part by, the U.S. Army Research Laboratory and the U.S. Army Research Office under contract/grant number W911NF-08-1-0468 and by NSF under contract 0413196. The views and conclusions con- tained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the sponsoring organizations, agencies, companies or the U.S. government. Copyright c ° 2009, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. or distances are thus equal to the lengths of their paths. A solution of the pursuit-evasion problem is a movement strat- egy for a given number of robots with given start vertices on a given graph that enables them to clear the graph, that is, either ensure that no evaders are present or catch them all. An optimal solution minimizes the cost, such as the sum of travel distances or the task-completion time, depending on the desired cost objective. This is a common and very gen- eral model of pursuit-evasion problems on graphs (Parsons 1976). For example, a solution remains a solution even if the evaders can be seen by the robots over longer distances or can move only slowly. If the vertex connectivity of some part of the graph ex- ceeds the number of robots, the evaders can always avoid capture. For instance, suppose that the graph contains aK 7 subgraph. Between any two vertices in that subgraph there are six vertex-disjoint connecting paths, so five robots can not catch an evader. We therefore focus on graphs whose subgraphs can always be cut at a limited number of vertices, that is, graphs of low treewidth. However, solving pursuit- evasion problems optimally is NP-hard even for the simplest of these graph classes (Megiddo et al. 1988; LaPaugh 1993; Borie, Tovey, and Koenig 2009). Yet, large pursuit-evasion problems need to be solved quickly to be of practical help. In this paper, we therefore develop a heuristic approach, called ESP, that solves large pursuit-Evasion problems on Series- Parallel graphs quickly and with small costs, by exploiting their topology in the form of their decomposition graphs. We use series-parallel graphs because their topology is realistic for some applications and their pursuit-evasion approaches might be generalizable to even more realistic graph topolo- gies, by generalizing them from the treewidth two of series- parallel graphs to larger treewidths. Indeed, ESP is couched in terms of the decomposition and intended to generalize to graphs of larger treewidths. In the remainder of the paper, we first define series- parallel graphs, then give a conceptual overview of ESP and finally describe ESP in detail, including how it assigns states to terminal vertices and how it clears subgraphs based on both the states of their terminal vertices and the number of robots that start and end at them. We then apply ESP to dif- ferent kinds of series-parallel graphs and show that it scales up to larger graphs than does a strawman approach based on previous results from the literature. G1 G2 a b c d s(G1,G2) = a bc d p(G1,G2) = ac bd Figure 1: Series and parallel compositions G 1 2 3 4 5 6 p P P P P P P @ @ @ @ @ @ @ @ 1 2 3 4 s @ @ @ @ @ @ @ 1 4 5 6 s @ @ @ @ @ @ @ 1 2 3 3 4 p @ @ @ @ @ @ 1 4 5 6 6 p @ @ @ @ @ @ 1 1 2 3 3 s @ @ @ @ @ @ @ @ 4 4 5 6 6 s @ @ @ @ @ @ 1 2 2 3 4 5 5 6 Figure 2: Series-parallel graph and its decomposition tree Series-Parallel Graphs Series-parallel graphs (Duffin 1965) are defined recursively by starting with single edges as base graphs and succes- sively building larger graphs using series (s) and parallel (p) compositions. Each composition joins two smaller graphs by fusing at most two designated vertices called terminal vertices. The structure of a series-parallel graph can be rep- resented by a decomposition tree, whose nodes correspond to subgraphs. A decomposition tree for a series-parallel graph can be constructed in linear time (Valdes, Tarjan, and Lawler 1982). Figure 1 illustrates the series and parallel compositions. The terminal vertices of each graph are dou- bly circled. Figure 2 shows the decomposition tree of a series-parallel graph that is constructed using several series and parallel operations. As an example of pursuit evasion, consider the following movement strategy for clearing this graph with three robots that all start at vertex 1: Each of the three robots departs vertex 1 along a different incident edge, arriving at vertices 2, 3 and 6, respectively. The robot at ver- tex 2 proceeds to vertex 3. Next, the two robots at vertex 3 both travel to vertex 4. Finally, one of the robots at vertex 4 proceeds to vertex 6, and the other robot travels from vertex guard in out status false true false keeping false false true lookout false true true needy true any any safe false false false unattached Figure 3: Five possible statuses for terminal vertices 4 to vertex 5 and then to vertex 6. Conceptual Overview of ESP ESP is a recursive approach for clearing a graph with a given decomposition tree that is given the distribution of the robots at the terminal vertices of a graph before and after clear- ing the graph. The movement strategy of ESP clears all edges without giving evaders the opportunity to recontam- inate edges that have already been cleared. ESP uses divide and conquer to determine such a movement strategy since it is NP-hard to optimize over all possible movement strategies to find one that clears the graph with minimum cost. ESP de- composes the graph into subgraphs and then computes and combines movement strategies on the subgraphs to clear the graph with small cost. This results in ESP optimizing over a subset of possible movement strategies, namely those that are consistent with the given decomposition of a graph G into subgraphs G 1 and G 2 . Informally, by consistent we mean that either the robots first clear all of one subgraph and then all of the other subgraph or split into two groups that clear both subgraphs separately but simultaneously. For- mally, we mean the following: 1) Each robot begins at a terminal vertex ofG. 2) Each robot ends at a terminal vertex ofG. 3) Once a robot enters the interior of a subgraphG i no robot in G i may leave G i until G i has been cleared. 4) No robot may enter the interior of a subgraph after it has been cleared (except for deployment purposes). Terminal Status We exploit the structure of the pursuit-evasion problem by labeling each terminal vertex with a status that represents the state of the vertex. Let G denote the subgraph of a series-parallel graph corresponding to the node of the de- composition tree that is currently being cleared. Let t 1 and t 2 denote the terminal vertices ofG. Any portion of the en- tire graph that is not in G is called exterior area. Vertex t i might be incident upon a cleared exterior area, an uncleared exterior area, both or neither. We use two boolean variables in and out to denote whether t i is incident upon a cleared or uncleared exterior area, respectively (because we must keep evaders “in” to prevent their escape to cleared exterior areas or “out” to prevent their entry from uncleared exteri- ors areas). We use a third boolean variable guard to denote whether a robot has been stationed att i . Different combina- tions of these three variables yield five statuses, see Figure 3. • Keeping: The term “keeping” derives from the phrase “keep in G”. Since t i is incident upon a cleared exte- rior area, we must prevent evaders from leavingG viat i . Hence, at least one robot must guard t i and remain there until all interior areas incident tot i are cleared. • Lookout: Sincet i is incident upon an uncleared exterior area, we must prevent any potential evaders from entering G via t i . Hence, at least one robot must guard t i by the time any interior area incident tot i is cleared and remain there untilG is cleared. • Needy: t i is incident upon both cleared and uncleared ex- terior areas but no robot guards it to prevent evaders from leaving or enteringG viat i or from entering a cleared ex- terior area from an uncleared one via t i . Hence, t i must be converted to “safe” status, described next. • Safe: t i is guarded by a robot to prevent evaders from leaving or entering G via t i or from entering a cleared exterior area from an uncleared one viat i . • Unattached: t i is a terminal vertex of the entire graph and not incident upon any external areas yet. Hence, we do not have to worry about evaders yet. t i continues to have “unattached” status until the entire graph subdivides via a parallel decomposition. ESP Figure 4 shows the pseudo code of ESP, and Fig- ure 5 shows the pseudo code of its helper functions. ESP(G,r 1 ,r 2 ,r ′ 1 ,r ′ 2 ,s 1 ,s 2 ) computes a cost sufficient for clearing G for the given values: s i is the status of t i and r i is the number of robots at t i at the time we start clear- ingG. r ′ i is the number of robots att i at the time we finish clearing G. We always require these values to be nonnega- tive and r 1 +r 2 = r ′ 1 +r ′ 2 . We do not count a robot that guards a terminal vertex towards these values since such a robot does not actively participate in the clearing (except in maintaining the status of the terminal vertex). The cost can be the sum of travel distances (“minimize distance”) or the task-completion time (“minimize time”). ESP uses the helper function select to select the cost depending on the desired cost objective. A cost of infinity means that the graph cannot be cleared. The cost must admit two opera- tions. ESP(G 1 ,. . . ) ⊕ ESP(G 2 , . . . ) is the cost of the se- quential movement strategies “clearG 1 , then clearG 2 ”, and ESP(G 1 ,. . . )⊙ ESP(G 2 ,. . . ) is the cost of the simultaneous movement strategies “clearG 1 andG 2 separately but simul- taneously.” For example, both⊕ and⊙ are + for minimiz- ing distance and⊕ is + and⊙ is max for minimizing time. ESP is initially called as ESP(G,r 1 ,r 2 ,r ′ 1 ,r ′ 2 , unattached, unattached), where G is the entire graph. If one does not care about the distribution of the robots at the terminal ver- tices before or after clearing the graph, then one can mini- mize the cost over all such distributions, which is what we do in the experiments. For ease of presentation, function ESP includes several nondeterministic choices of values. A deterministic imple- mentation should consider all valid combinations for the nondeterministic choices of values. All nondeterministi- cally chosen numbers must be non-negative integers. Func- tion ESP is expressed recursively (top-down), following the structure of the decomposition tree for the given graph. ESP(G,r1,r2,r ′ 1 ,r ′ 2 ,s1,s2 ) fori := 1,2 do ifsi = needy then ri :=ri−1 r ′ i :=r ′ i −1 si := safe if infeasible(r1,r2,r ′ 1 ,r ′ 2 ,s1,s2 ) then return∞ ifG is base graph with one edge of lengthL then ifr1 >r ′ 1 then return select(r1−r ′ 1 ,1)×L else ifr1 <r ′ 1 then return select(r ′ 1 −r1,1)×L else ifr1 = 0 orr2 = 0 then return2×L else return select(2,1)×L else ifG :=p(G1,G2) then // parallel composition choose minimum of case 1: // clearG1 then clearG2 fori := 1,2 do forj := 1,2 do sij :=si fori := 1,2 do ifsi1 = unattached thensi1 = lookout else ifsi1 = keeping thensi1 := needy ifsi2 = unattached thensi2 := keeping else ifsi2 = lookout thensi2 := needy chooser ′′ 1 ,r ′′ 2 such thatr1 +r2 =r ′′ 1 +r ′′ 2 return ESP(G1,r1,r2,r ′′ 1 ,r ′′ 2 ,s11,s21 )⊕ ESP(G2,r ′′ 1 ,r ′′ 2 ,r ′ 1 ,r ′ 2 ,s12,s22 ) case 2: // clearG2 then clearG1 // symmetric to case 1 case 3: // clearG1 andG2 simultaneously fori := 1,2 do ifsi = safe thenpi := 0 else choosepi := 0 orpi := 1 ifpi = 1 thensi := safe else ifsi = unattached then choosesi := keeping orsi := lookout chooser11,r21,r ′ 11 ,r ′ 21 ,r12,r22,r ′ 12 ,r ′ 22 such that r11 +r21 =r ′ 11 +r ′ 21 ,r12 +r22 =r ′ 12 +r ′ 22 , r11 +r12 =r1−p1 ,r ′ 11 +r ′ 12 =r ′ 1 −p1 , r21 +r22 =r2−p2 andr ′ 21 +r ′ 22 =r ′ 2 −p2 return ESP(G1,r11,r21,r ′ 11 ,r ′ 21 ,s1,s2 )⊙ ESP(G2,r12,r22,r ′ 12 ,r ′ 22 ,s1,s2 ) else ifG =s(G1,G2) then // series composition choosex1,x2,x3 such thatr1 +r2 =x1 +x2 +x3 choose minimum of case 1: // clearG1 then clearG2 x ′ 3 :=x3 +x1−r ′ 1 return deploy(G,r1,r2,x1,x2,x3 )⊕ ESP(G1,x1,x3,r ′ 1 ,x ′ 3 ,s1 , lookout) ⊕ ESP(G2,x ′ 3 ,x2,0,r ′ 2 , keeping,s2 ) case 2: // clearG2 then clearG1 // symmetric to case 1 case 3: // clearG1 andG2 simultaneously choosep3 := 0 orp3 := 1 ifp3 = 1 thens3 := safe else chooses3 := keeping ors3 := lookout choosex ′ 1 ,x ′ 2 such thatx ′ 1 ≤r ′ 1 andx ′ 2 ≤r ′ 2 choosex31,x32 such thatx3 =p3 +x31 +x32 x ′ 31 :=x31 +x1−x ′ 1 x ′ 32 :=x32 +x2−x ′ 2 return deploy(G,r1,r2,x1,x2,x3 )⊕ [ESP(G1,x1,x31,x ′ 1 ,x ′ 31 ,s1,s3 ) ⊙ ESP(G2,x32,x2,x ′ 32 ,x ′ 2 ,s3,s2 )]⊕ cleanup(G,r ′ 1 −x ′ 1 ,r ′ 2 −x ′ 2 ) Figure 4: ESP It should be implemented via dynamic programming (ei- ther bottom-up or top-down), using a dynamic program- ming table to store computed values and thereby avoid- ing repeated calculations of the values. Conventional dy- namic programming techniques can then use the informa- tion stored in the dynamic programming table to build the movement strategy for clearing the graph. Helper func- tion dist should also be implemented via dynamic program- ming. We now explain the steps of ESP when called as ESP(G,r 1 ,r 2 ,r ′ 1 ,r ′ 2 ,s 1 ,s 2 ), closely following the pseudo code in Figure 4. Preparatory Steps If any terminal vertex t i has “needy” status, then a robot needs to guard it since it is incident upon both cleared and uncleared exterior areas. Therefore, ESP changes the status oft i to “safe” and decrements the numberr i andr ′ i of robots att i before and after, respectively, clearing the graph, which can result in a negative number of robots, indicating that the graph cannot be cleared. ESP returns a cost of infinity if infeasible(r1,r2,r ′ 1 ,r ′ 2 ,s1,s2 ) fori := 1,2 do ifri < 0 or (ri = 0 andsi = keeping) orr ′ i < 0 or (r ′ i = 0 andsi = lookout) then return true returnr1 +r2 = 0 select(a,b) if the objective is minimizing distance then returna else if the objective is minimizing time then returnb ⊕(a,b) // infix operator returna+b ⊙(a,b) // infix operator return select(a+b,max(a,b)) dist(G) ifG is base graph with one edge of lengthL then returnL else ifG =p(G1,G2) then returnmin(dist(G1),dist(G2)) else ifG =s(G1,G2) then returndist(G1)+dist(G2) deploy(G,r1,r2,x1,x2,x3 ) ifx1 >r1 then return select((x1−r1)×dist(G)+x3×dist(G2),max(dist(G),dist(G2))) else ifx2 >r2 then return select((x2−r2)×dist(G)+x3×dist(G1),max(dist(G),dist(G1))) else return select((r1−x1)×dist(G1)+(r2−x2)×dist(G2),max(dist(G1),dist(G2)) cleanup(G,z1,z2 ) return select(z1×dist(G1)+z2×dist(G2),max(dist(G1),dist(G2))) Figure 5: Helper functions for ESP the combination of parameter values indicates immediately that the graph cannot be cleared. Helper function infeasible returns true iff any of the following conditions is violated: the number of robots at each terminal vertex must be non- negative; a terminal vertex with “keeping” status must start with at least one robot; a terminal vertex with “lookout” sta- tus must finish with at least one robot; and the number of robots must be positive. We now separately consider what ESP does if the graph is a base graph and if it is formed by a parallel or series composition. Base Graph SupposeG consists of one edge(t 1 ,t 2 ) of lengthL. • Ifr 1 >r ′ 1 , ESP sendsr 1 −r ′ 1 robots fromt 1 tot 2 . • Ifr 1 <r ′ 1 , ESP sendsr ′ 1 −r 1 robots fromt 2 tot 1 . • Ifr 1 =r ′ 1 (and hence alsor 2 =r ′ 2 ): – Ifr 2 = 0, ESP sends one robot fromt 1 tot 2 and return. – Ifr 1 = 0, ESP sends one robot fromt 2 tot 1 and return. – If r 1 > 0 and r 2 > 0, ESP sends one robot from t 1 towardst 2 and one robot fromt 2 towardst 1 . When the two robots meet, each robot returns to where it started. Parallel Composition SupposeG is the parallel composition of subgraphsG 1 and G 2 . ESP then returns the smallest cost of three subcases, namely “clearG 1 , then clearG 2 ,” “clearG 2 , then clearG 1 ” and “clearG 1 andG 2 separately but simultaneously.” ClearG 1 , then clearG 2 The terminal vertices ofG pass on their status to the corresponding terminal vertices of both subgraphs. ESP then changes each terminal vertex with “unattached” status to “lookout” status and each one with “keeping” status to “needy” status when clearingG 1 (result- ing in statuss i1 oft i ) since it is incident upon an uncleared exterior area, namely G 2 . Similarly, ESP changes each ter- minal vertex of G 2 with “unattached” status to “keeping” status and each one with “lookout” status to “needy” sta- tus when clearing G 2 (resulting in status s i2 of t i ) since it is then incident upon a cleared exterior area, namely G 1 . ESP then nondeterministically chooses the number r ′′ i of robots at each terminal vertex t i of G after clearing G 1 but before clearing G 2 such that r 1 + r 2 = r ′′ 1 + r ′′ 2 , result- ing in two subproblems ESP(G 1 ,r 1 ,r 2 ,r ′′ 1 ,r ′′ 2 ,s 11 ,s 21 ) and ESP(G 2 ,r ′′ 1 ,r ′′ 2 ,r ′ 1 ,r ′ 2 ,s 12 ,s 22 ), that can be solved recur- sively. ESP combines the costs of clearing both subgraphs with the⊕ operator, which is used for combining the costs of sequential movement strategies. ClearG 2 , then clearG 1 This subcase is symmetric to the previous subcase, exchanging the roles ofG 1 andG 2 . Clear G 1 and G 2 separately but simultaneously ESP first nondeterministically chooses for each terminal vertex t i whether to change it to “safe” status (in which case it changes the value ofp i from zero to one), except if it already has “safe” status (in which case guarding it again would be wasteful) or “needy” status (in which case guarding it is re- quired). If it afterwards still has “unattached” status, ESP nondeterministically chooses to assign it either “keeping” or “lookout” status. The terminal vertices of G pass on their updated status to the corresponding terminal vertices of both subgraphs. ESP then nondeterministically chooses the num- ber of robots r ij and r ′ ij at t i before and after, respectively, clearingG j among those that clearG j such thatr 1j +r 2j = r ′ 1j +r ′ 2j ,r i1 +r i2 =r i −p i andr ′ i1 +r ′ i2 =r ′ i −p i , resulting in two subproblems ESP(G 1 ,r 11 ,r 21 ,r ′ 11 ,r ′ 21 ,s 1 ,s 2 ) and ESP(G 2 ,r 12 ,r 22 ,r ′ 12 ,r ′ 22 ,s 1 ,s 2 ), that can be solved recur- sively. ESP combines the costs of clearing both subgraphs with the⊙ operator, which is used for combining the costs of simultaneous movement strategies. Series Composition Suppose G is the series composition of subgraphs G 1 and G 2 . Different from a parallel composition, there is now a middle vertex t 3 whose number of robots is zero before clearing G. Let s 3 denote the status of t 3 . ESP can move robots tot 3 to aid in clearingG. It nondeterministically de- ploys the robots from the terminal vertices t 1 and t 2 to t 1 , t 2 andt 3 so that these vertices receivex 1 ,x 2 andx 3 robots, respectively. Thus, r 1 + r 2 = x 1 + x 2 + x 3 . The helper function deploy(G,r 1 ,r 2 ,x 1 ,x 2 ,x 3 ) computes the cost of this deployment step. ESP then returns the smallest cost of three subcases, namely “clearG 1 , then clearG 2 ,” “clearG 2 , then clear G 1 ” and “clear G 1 and G 2 separately but simul- taneously.” Clear G 1 , then clear G 2 The terminal vertices of G pass on their status to the corresponding terminal vertices of both subgraphs. ESP assigns t 3 “lookout” status when clearing G 1 since it is incident upon an uncleared exte- rior area, namely G 2 . Similarly, ESP assigns it “keeping” status when clearing G 2 since it is then incident upon a cleared exterior area. The number of robots x ′ 3 at t 3 af- ter clearing G 1 but before clearing G 2 is determined by the previous choices to be x ′ 3 = x 3 + x 1 − r ′ 1 , resulting in two subproblems ESP(G 1 ,x 1 ,x 3 ,r ′ 1 ,x ′ 3 ,s 1 , lookout) and ESP(G 2 ,x ′ 3 ,x 2 ,0,r ′ 2 , keeping,s 2 ), that can be solved recur- sively. ESP combines the costs of the deployment step and the costs of clearing both subgraphs with the ⊕ operator, which is used for combining the costs of sequential move- ment strategies. ClearG 2 , then clearG 1 This subcase is symmetric to the previous subcase, exchanging the roles ofG 1 andG 2 . ClearG 1 andG 2 separately but simultaneously The ter- minal vertices ofG pass on their status to the corresponding terminal vertices of both subgraphs. ESP nondeterministi- cally chooses for t 3 whether to assign it “safe” status (in which case it changes the value of p 3 from zero to one). If it afterwards does not have “safe” status, ESP nondeter- ministically assigns it either “keeping” or “lookout” status. ESP then nondeterministically chooses the number of robots x ′ i at t i after clearing G i , restricted to x ′ i ≤ r ′ i to sim- plify the cleanup step described below, and nondeterminis- tically partitions the robots at t 3 into x 31 robots that help to clear G 1 and x 32 robots that help to clear G 2 . Thus, x 3 = p 3 + x 31 + x 32 . The number of robots x ′ 3i at t 3 after clearing G i among those that clear G i is determined by the previous choices to be x ′ 3i = x 3i + x i − x ′ i , re- sulting in two subproblems ESP(G 1 ,x 1 ,x 31 ,x ′ 1 ,x ′ 31 ,s 1 ,s 3 ) and ESP(G 2 ,x 32 ,x 2 ,x ′ 32 ,x ′ 2 ,s 3 ,s 2 ), that can be solved re- cursively. Finally, ESP deploysr ′ i −x ′ i robots fromt 3 tot i to make the number of robots at t i equal to r ′ i . The helper function cleanup(G,r ′ 1 −x ′ 1 ,r ′ 2 −x ′ 2 ) computes the cost of this cleanup step. ESP combines the costs of clearing both subgraphs with the⊙ operator, which is used for combining the costs of simultaneous movement strategies. It then com- bines the resulting costs with the costs of the deployment step and the cleanup step with the⊕ operator, which is used for combining the costs of sequential movement strategies. Runtime of ESP ESP, like many algorithms on series-parallel graphs (Borie, Parker, and Tovey 1992), runs in time linear in the size of the graph. In particular, the implementation in Figure 4 runs in timeO(nr 8 ) when graphG hasn edges andr = r 1 +r 2 is the number of robots. Its most costly part is to clear the subgraphs of a series composition separately but simultane- ously, so we justify the runtime bound for this case. There are O(n) nodes in the decomposition tree. For each node, there areO(r) possible values forr 1 ,r 2 andr ′ 1 each, which then force the value of r ′ 2 . There are a constant number of values fors 1 ands 2 each. There areO(r) choices forx 1 and x 2 each, which force the value ofx 3 . There are two choices forp 3 . There areO(r) choices forx 31 , which then forces the value of x 32 . Finally, there are O(r) choices for x ′ 1 and x ′ 2 each. Thus, there areO(nr 8 ) combinations. Helper function dist runs in timeO(n) if it is implemented via dynamic pro- gramming because each traversal doesO(1) work per node of the decomposition tree. However, by more careful anal- ysis, ESP runs in time only O(nr 6 ). The key observation is that the subexpressions can be stored in a dynamic pro- gramming table to avoid recomputations. For eachG, there are O(r 3 ) distinct calls to ESP on each subgraph G 1 and G 2 , which yields O(r 6 ) calls to operator⊙, of which only theO(r 3 ) minimum values for each combination ofx 1 ,x ′ 1 , t 1 t 2 t 1 t 2 Figure 6: Ladder graphL 4 (l) and BTL graphB 4 (r) 0 2 4 6 8 10 12 14 0 50 100 150 200 250 300 Time (seconds) i = # of rungs Ladder Graphs ESP Strawman 0.001 0.01 0.1 1 10 100 1000 1 2 3 4 5 6 7 8 9 Time (seconds) i = tree depth Binary Tree-Like Graphs ESP Strawman Figure 7: Runtime on ladder graphs (l) and BTL graphs (r) x 2 and x ′ 2 must be remembered. These results can then be combined similarly with the results from helper functions deploy and cleanup, such that only O(r 6 ) calculations are performed at each of the O(n) nodes of the decomposition tree. Experimental Results We do not know of any publicly available implementation of pursuit-evasion approaches on graphs. We therefore created a strawman approach to compare against ESP. The straw- man approach determines the minimum number of robots required to clear arbitrary graphs but does not determine movement strategies, neither for minimizing distance nor time. It is based on the idea that “recontamination does not help to clear a graph” (LaPaugh 1993), meaning that, if there is a movement strategy that clears a graph, then there must also be a movement strategy that clears a graph such that no cleared vertex becomes recontaminated. We then im- proved the runtime of the strawman approach by noticing that, if a robot is at a vertex that has only one uncleared ad- jacent vertex, it might as well move to that vertex right away (“forced move”) and thereby reduce the branching factor of the search. The strawman approach assumes that the evaders hide only on the vertices (node searching), while ESP assumes that the evaders hide on the vertices or edges (edge search- ing). However, it is simple to reduce edge searching on graphs to node searching (Bienstock and Seymour 1991). The reduction takes a series-parallel graph G as input and then constructs the dual graph G ′ by creating one vertex in G ′ for each edge inG. Two vertices inG ′ are adjacent iff the corresponding edges share a common vertex inG. The dual graphG ′ is then used as input to the strawman approach. Ladder Graphs The first class of graphs we used in our experiments are lad- der graphs with edges of length one, see Figure 6 (l). These graphs resemble a physical ladder in that there are two sides connected by rungs. We use L i to denote the ladder graph withi rungs. We can construct them as series-parallel graphs with the following recurrence, where e refers to a single edge: L1 = e Li+1 = p(e,s(e,s(Li,e))) The number of vertices and edges of the graphsL i are linear in the number of iterations i since each iteration increases the number of edges by 3 and the number of vertices by 2. At most 3 robots are required to clear any graph. We used ESP with iterative deepening to determine the number of robots required to clear ladder graphs. Both ESP and the strawman approach correctly minimized this num- ber. ESP cleared L i with the minimum number of robots with distance4i−2, which is very close to the optimal value of4i−4. It clearedL i with the minimum number of robots in time 4i− 2, which is about a factor of 2 worse than the optimal value of2i−1. The runtimes of ESP and the straw- man approach are compared in Figure 7 (l). Ladder graphs are well suited for the strawman approach since almost all moves are forced. Yet, the strawman approach could solve graphs only up toL 68 within 10 seconds whereas ESP could solve graphs up to L 295 since its runtime increased much less. AroundL 275 , ESP hit memory limitations. ESP would have been able to solve larger graphs with additional mem- ory that would have allowed for a larger dynamic program- ming table. BTL Graphs The second class of graphs we used in our experiments are what we call BTL (binary tree-like) graphs with edges of length one, see Figure 6 (r). These graphs are complete bi- nary trees with one edge added from the root to the first ter- minal vertex and two parallel edges added from each leaf vertex to the second terminal vertex. We use B i to denote the BTL graph constructed from a complete binary tree of depthi−2. We can construct them as series-parallel graphs with the following recurrence: B1 = e Bi+1 = s(e,p(Bi,Bi)) The number of vertices and edges of the graphsB i are expo- nential in the number of iterations i since, if the number of vertices in graphB i isV i , thenV i+1 = 2×V i −1 and, if the number of edges in graphB i isE i , thenE i+1 = 2×E i +1. The number of robots required to clearB i isi. Both ESP and the strawman approach correctly mini- mized the number of robots required to clear BTL graphs. ESP cleared B i with the minimum number of robots with distance2 i +2i+3, which is quite close to the lower bound 2 i −1 given by the number of edges. It clearedB i with the minimum number of robots in time2 i +2i+3, which is the same as the distance because every subgraph is cleared se- quentially. The runtimes of ESP and the strawman approach are compared in Figure 7 (r). Due to the exponential growth of the graphs, the strawman approach could solve graphs only up toB 4 within 10 seconds but ESP could solve graphs up toB 6 . Note that the runtime scale in Figure 7 (r) is log- arithmic, implying that the runtime of ESP is approximately O(n) but the runtime of the strawman approach is approx- imately O(n 4/3 ), where n is the number of vertices of the graphs. Conclusion We presented ESP, a heuristic approach to pursuit and eva- sion on series parallel graphs, and demonstrated that it scales up to larger graphs than a strawman approach based on pre- vious results from the literature. ESP has the advantage that it allows for edges of different lengths and for different cost objectives, such as minimizing the sum of travel distances or the task-completion time. It is future work to investigate im- proved deployment steps and to extend ESP to more general graph classes. References Bienstock, D., and Seymour, P. 1991. Monotonicity in graph searching. Journal of Algorithms 12(2):239–245. Borie, R.; Parker, R.; and Tovey, C. 1992. Automatic gen- eration of linear-time algorithms from predicate calculus descriptions of problems on recursively constructed graph families. Algorithmica 7(1–6):555–581. Borie, R.; Tovey, C.; and Koenig, S. 2009. Algorithms and complexity results for pursuit-evasion problems. In Pro- ceedings of the International Joint Conference on Artificial Intelligence. Duffin, R. 1965. Topology of series-parallel net- works. Journal of Mathematical Analysis and Applications 10:303–318. Gordon, G.; Thrun, S.; and Gerkey, B. 2004. Visibility- based pursuit-evasion with limited field of view. In Pro- ceedings of the AAAI Conference on Artificial Intelligence, 20–27. LaPaugh, A. 1993. Recontamination does not help to search a graph. Journal of the ACM 40(2):224–245. Megiddo, N.; Hakimi, S.; Garey, M.; Johnson, D.; and Pa- padimitriou, C. 1988. The complexity of searching a graph. Journal of the ACM 35(1):18–44. Parsons, T. 1976. Pursuit-evasion in a graph. In Theory and Applications of Graphs. Springer Verlag. 426–441. Pellier, D., and Fiorino, H. 2005. Coordinated explo- ration of unknown labyrinthine environments applied to the pursuit evasion problem. Proceedings of the International Joint Conference on Autonomous Agents and Multiagent Systems 895–902. Simov, B.; Slutzki, G.; and LaValle, S. 2000. Pursuit- evasion using beam detection. In Proceedings of the IEEE International Conference on Robotics and Automa- tion, 1657–1662. Valdes, J.; Tarjan, R.; and Lawler, E. 1982. The recognition of series parallel digraphs. SIAM Journal on Computing 11(2):298–313.

Linked assets

Computer Science Technical Report Archive

Conceptually similar

PDF

USC Computer Science Technical Reports, no. 902 (2009)

PDF

USC Computer Science Technical Reports, no. 900 (2008)

PDF

USC Computer Science Technical Reports, no. 901 (2008)

PDF

USC Computer Science Technical Reports, no. 913 (2009)

PDF

USC Computer Science Technical Reports, no. 881 (2006)

PDF

USC Computer Science Technical Reports, no. 600 (1995)

PDF

USC Computer Science Technical Reports, no. 589 (1994)

PDF

USC Computer Science Technical Reports, no. 531 (1992)

PDF

USC Computer Science Technical Reports, no. 947 (2014)

PDF

USC Computer Science Technical Reports, no. 558 (1993)

PDF

USC Computer Science Technical Reports, no. 805 (2003)

PDF

USC Computer Science Technical Reports, no. 655 (1997)

PDF

USC Computer Science Technical Reports, no. 606 (1995)

PDF

USC Computer Science Technical Reports, no. 615 (1995)

PDF

USC Computer Science Technical Reports, no. 868 (2005)

PDF

USC Computer Science Technical Reports, no. 605 (1995)

PDF

USC Computer Science Technical Reports, no. 911 (2009)

PDF

USC Computer Science Technical Reports, no. 835 (2004)

PDF

USC Computer Science Technical Reports, no. 965 (2016)

PDF

USC Computer Science Technical Reports, no. 762 (2002)

Description

R. Borie, C. Tovey, K. Daniel and S. Koenig. "ESP: Pursuit evasion on series-parallel graphs." Computer Science Technical Reports (Los Angeles, California, USA: University of Southern California. Department of Computer Science) no. 907 (2009).

Asset Metadata

Creator Borie, R. (author), Daniel, K. (author), Koenig, S. (author), Tovey, C. (author)

Core Title USC Computer Science Technical Reports, no. 907 (2009)

Alternative Title ESP: Pursuit evasion on series-parallel graphs (title)

Publisher Department of Computer Science,USC Viterbi School of Engineering, University of Southern California, 3650 McClintock Avenue, Los Angeles, California, 90089, USA (publisher)

Tag OAI-PMH Harvest

Format 6 pages (extent), technical reports (aat)

Language English

Unique identifier UC16269341

Identifier 09-907 ESP Pursuit Evasion on Series-Parallel Graphs (filename)

Legacy Identifier usc-cstr-09-907

Format 6 pages (extent),technical reports (aat)

Rights Department of Computer Science (University of Southern California) and the author(s).

Internet Media Type application/pdf

Source 20180426-rozan-cstechreports-shoaf (batch), Computer Science Technical Report Archive (collection), University of Southern California. Department of Computer Science. Technical Reports (series)

Access Conditions The author(s) retain rights to their work according to U.S. copyright law. Electronic access is being provided by the USC Libraries, but does not grant the reader permission to use the work if the desired use is covered by copyright. It is the author, as rights holder, who must provide use permission if such use is covered by copyright.

Repository Name USC Viterbi School of Engineering Department of Computer Science

Repository Location Department of Computer Science. USC Viterbi School of Engineering. Los Angeles\, CA\, 90089

Repository Email csdept@usc.edu

Inherited Values

Title Computer Science Technical Report Archive

Description Archive of computer science technical reports published by the USC Department of Computer Science from 1991 - 2017.

Coverage Temporal 1991/2017

Repository Email csdept@usc.edu

Repository Name USC Viterbi School of Engineering Department of Computer Science

Repository Location Department of Computer Science. USC Viterbi School of Engineering. Los Angeles\, CA\, 90089

Publisher Department of Computer Science,USC Viterbi School of Engineering, University of Southern California, 3650 McClintock Avenue, Los Angeles, California, 90089, USA (publisher)