Optimal Multi-Robot Path Planning with LTL Constraints: Guaranteeing Correctness Through Synchronization  Alphan Ulusoy, Stephen L. Smith, and Calin Belta  Abstract   In this paper, we consider the automated planning of optimal paths for a robotic team satisfying a high level mission specification. Each robot in the team is modeled as a weighted transition system where the weights have associated de- viation values that capture the non-determinism in the traveling times of the robot during its deployment. The mission is given as a Linear Temporal Logic (LTL) for- mula over a set of propositions satisfied at the regions of the environment. Addi- tionally, we have an optimizing proposition capturing some particular task that must be repeatedly completed by the team. The goal is to minimize the maximum time between successive satisfying instances of the optimizing proposition while guaran- teeing that the mission is satisfied even under non-deterministic traveling times. Our method relies on the communication capabilities of the robots to guarantee correct- ness and maintain performance during deployment. After computing a set of optimal satisfying paths for the members of the team, we also compute a set of synchroniza- tion sequences for each robot to ensure that the LTL formula is never violated during deployment. We implement and experimentally evaluate our method considering a persistent monitoring task in a road network environment.  1 Introduction  Temporal logics [5], such as Linear Temporal Logic (LTL) and Computation Tree Logic (CTL), are extensions of propositional logic that can capture temporal re- lations. Even though temporal logics have been used in model checking of finite systems [1] for quite some time, they have gained popularity as a means for specify- ing complex mission requirements in path planning and control synthesis problems  Alphan Ulusoy, Calin Belta Boston University, Boston, MA, USA e-mail:   alphan@bu.edu,cbelta@bu.edu  Stephen L. Smith University of Waterloo, Waterloo, ON, Canada e-mail:   stephen.smith@uwaterloo.ca  1  arXiv:1207.2415v4 [cs.RO] 17 Dec 2012
2   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  only recently [15, 13, 21]. Existing work on path planning and control synthesis concentrates on LTL specifications for finite state systems, which may be abstrac- tions of their infinite counterparts [15, 18]. Particularly, given the system model and the mission specification expressed in some temporal logic, satisfying paths and cor- responding control strategies can be computed automatically through a search of the state space for deterministic [9], non-deterministic [16, 18, 13, 10] and probabilistic systems [2, 11, 4]. However, more often than not, there are multiple paths that can satisfy a given mission specification. In that case, one generally wants to be able to pick the path that is superior to others with respect to some metric, such as safety, speed, cost, etc. In our previous work, we focused on mission specifications given in LTL along with a particular cost function, and proposed an automated method for finding opti- mal robot paths that satisfy the mission and minimize the cost function for a single robot [14]. Next, we extended this approach to multi-robot teams by utilizing an abstraction based on timed automata [20]. Then, we proposed a robust method that could accomodate uncertainties in the traveling times of robots with limited com- munication capabilities [19]. Extending the optimal path planning problem from a single robot to multiple robots is not trivial, as the joint asynchronous motion of all members of the team must be captured in a finite model. In [9], the authors propose a method for de- centralized motion of multiple robots subject to LTL specifications. Their method, however, results in sub-optimal performance as it requires the robots to travel syn- chronously, blocking the execution of the mission before each transition until all robots are synchronized. The vehicle routing problem (VRP) [17] and its extensions to more general classes of temporal constraints [7, 8] also deal with finding optimal satisfying paths for a given specification. In [8], the authors consider optimal vehi- cle routing with metric temporal logic specifications by converting the problem to a mixed integer linear program (MILP). However, their method does not apply to the missions where robots must repeatedly complete some task, as it does not allow for specifications of the form “always eventually”. Furthermore, none of these methods are robust to timing errors that can occur during deployment, as they rely on the robots’ ability to follow generated trajectories exactly for satisfaction of the mission specification. In [20], we proposed a method that uses timed automata to capture the joint asynchronous motion of the members of the robotic team in the environment. After providing a bisimulation [12] of an infinite-dimensional timed automaton to a finite dimensional transition system, we applied our results from [14] to compute an opti- mal satisfying run. However, multi-robot paths found using this method are imple- mentable only if the traveling times of the robots during deployment exactly match the traveling times used for planning. Otherwise, the order of events may switch resulting in the violation of the mission specification during deployment. In [19], we addressed this issue for robots operating under communication constraints that limit their communication capabilities to a subset of regions. We showed that a trace-closed mission specification will never be violated due to uncertainties in the
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   3  speeds of the robots. Then, we proposed a synchronization protocol to maintain and characterize the field performance of the robotic team. The methods given in [20] and [19] are actually two extremes: In [20], the robots can follow the generated trajectories exactly and do not communicate at all, while in [19] the robots’ traveling times during deployment deviate from those used in planning, and they cannot communicate freely. In this paper, we address the mid- dle between these two extremes: the robots cannot follow the generated trajectories exactly, but they can communicate regardless of their positions in the environment. Thus, after obtaining an optimal satisfying run of the team, we compute synchro- nization sequences that leverage the communication capabilities of the robots to robustify the planned trajectory against deviations in traveling times. The main contribution of this paper is threefold. First, we provide an algorithm to capture the joint asynchronous behavior of a team of robots modeled as tran- sition systems in a single transition system. This team transition system is prov- ably more compact than the approach based on timed automata that we previously proposed in [20]. Second, for a satisfying run made up of a finite length prefix and an infinite length cyclic suffix, we propose a synchronization protocol and an algorithm to compute synchronization sequences that guarantee correctness under non-deterministic traveling times that may be observed during deployment. Finally, we provide an automated framework that leverages these two methods along with the O PTIMAL -R UN   algorithm previously proposed in [14] to solve the multi-robot optimal path planning problem with robustness guarantees. Our experiments show that the computed runs and synchronization sequences indeed provide robustness to uncertainties in traveling times that may occur during the deployment of the team. The rest of the paper is organized as follows: In Sec. 2, we provide some defini- tions and preliminaries in formal methods. In Sec. 3, we formulate the optimal and robust multi-robot path planning problem and give an outline of our approach. We provide a complete solution to this problem in Sec. 4. In Sec. 5, we present exper- iments involving a team of robots performing a persistent surveillance mission in a road network environment. Finally, in Sec. 6, we conclude with final remarks.  2 Preliminaries  In this section, we introduce the notations that we use in the rest of the paper and briefly review some concepts related to automata theory, LTL, and formal verifica- tion. For a more rigorous treatment of these topics, we refer the interested reader to [3, 6, 1] and references therein. For a set   Σ   , we use   | Σ   | , 2 Σ   ,   Σ   ∗ , and   Σ   ω   to denote its cardinality, power set, set of finite words, and set of infinite words, respectively. We define   Σ   ∞   =   Σ   ∗   ∪   Σ   ω   and denote the empty string by / 0.  Definition 1 (Transition System).   A (weighted) transition system (TS) is a tuple  T   : = ( Q T ,   q 0 T ,   δ T ,   Π T ,   L T ,   w T ) , where
4   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  1.   Q T   is a finite set of states; 2.   q 0 T   ∈   Q T   is the initial state; 3.   δ T   ⊆   Q T   ×   Q T   is the transition relation; 4.   Π T   is a finite set of atomic propositions; 5.   L T   :   Q T   →   2 Π T   is a map giving the set of atomic propositions satisfied in a state; 6.   w T   :   δ T   →   N > 0   is a map that assigns a positive integer weight to each transition. We define a run of   T   as an infinite sequence of states   r T   =   q 0 ,   q 1 , . . .   such that  q 0   =   q 0  T   ,   q k   ∈   Q T   and   ( q k ,   q k + 1 )   ∈   δ T   for all   k   ≥   0. A run generates an infinite word  ω T   =   L   ( q 0 ) ,   L   ( q 1 ) , . . .   where   L   ( q k )   is the set of atomic propositions satisfied at state   q k . In this work, we consider mission specifications expressed in Linear Temporal Logic (LTL) [1, 3]. Informally, an LTL formula over the set   Π   of atomic propo- sitions may contain boolean operators   ¬   (negation),   ∨   (disjunction) and   ∧   (con- junction), and temporal operators   X   (next),   U   (until),   F   (eventually) and   G   (glob- ally/always). LTL formulas are interpreted over infinite words (generated by the transition system   T   from Def. 1). For instance,   X   p   states that at the next position of a word, proposition   p   is true. The formula   p 1   U   p 2   states that there is a future position of the word when proposition   p 2   is true, and proposition   p 1   is true at least until   p 2   is true. The formula   G   p   states that   p   is true at all positions of the word; the formula   F   p   states that   p   eventually becomes true in the word. More expressivity can be achieved by combining the temporal and boolean operators. We say a run   r T  satisfies   φ   if and only if the word generated by   r T   satisfies   φ   . An LTL formula   φ  over a set   Π   can be represented by a   B ̈ uchi automaton , which is defined next.  Definition 2 (B  ̈ uchi Automaton).   A B ̈ uchi automaton is a tuple   B   · · = ( Q B ,   Q 0 B ,   Σ B ,  δ B ,   F B ) , consisting of 1. a finite set of states   Q B ; 2. a set of initial states   Q 0 B   ⊆   Q B ; 3. an input alphabet   Σ B ; 4. a non-deterministic transition relation   δ B   ⊆   Q B   ×   Σ B   ×   Q B ; 5. a set of accepting (final) states   F B   ⊆   Q B . A   run   of   B   over an input word   ω   =   ω 0 ,   ω 1 , . . .   is a sequence   r B   =   q 0 ,   q 1 , . . . , such that   q 0   ∈   Q 0 B , and   ( q k ,   ω k ,   q k + 1 )   ∈   δ B , for all   k   ≥   0. A B ̈ uchi automaton   B   accepts a word over   Σ B   if and only if at least one of the corresponding runs intersects with  F B   infinitely many times. For any LTL formula   φ   over a set   Π   , one can construct a B ̈ uchi automaton with input alphabet   Σ B   =   2 Π   accepting all and only words over 2 Π   that satisfy   φ   .  Definition 3 (Prefix-Suffix Structure).   A prefix of a run is a finite path from an initial state to a state   q . A periodic suffix is an infinite run originating at the state  q   reached by the prefix, and periodically repeating a finite path, which we call the suffix cycle, originating and ending at   q . A run is in prefix-suffix form if it consists of a prefix followed by a periodic suffix.
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   5  3 Problem Formulation and Approach  In this section we introduce the multi-robot path planning problem with temporal constraints for robots with uncertain, but bounded traveling times. Let  E   = ( V ,   → E   )   (1) be a directed graph, where   V   is the set of vertices and   → E   ⊆   V   × V   is the set of edges. We consider   E   as the quotient graph of a partitioned environment, where   V   is the set of labels of the regions in the environment and   → E   is the corresponding adjacency relation. For instance,   V   can be a set of labels for the regions and intersections for a road network and   → E   can give their connections (see Fig. 5(a)). Consider a team of   m   robots moving in an environment modeled by   E   . The mo- tion capabilities of robot   i ,   i   =   1 , . . . ,   m   are modeled by a TS   T i   = ( Q i ,   q 0  i   ,   δ i ,   Π i ,  L i ,   w i ) , where   Q i   ⊆   V   ;   q 0  i   is the initial vertex of robot   i ;   δ i   ⊆→ E   is a relation mod- eling the capability of robot   i   to move among the vertices;   Π i   ⊆   Π   is the subset of propositions that can be satisfied by robot   i ;   L i   is a mapping from   Q i   to 2 Π i  showing how the propositions are satisfied at vertices; and   w i ( q ,   q ′ )   gives the   nom- inal   time for robot   i   to go from vertex   q   to   q ′ , which we assume to be a positive integer. However, due to the uncertainty in the traveling times of the robots, the   ac- tual   time it takes for robot   i   to go from   q   to   q ′ , which we denote by  ̃ w i ( q ,   q ′ ) , is a non-deterministic quantity that lies in the interval   [ ρ i w i ( q ,   q ′ ) ,   ρ i w i ( q ,   q ′ )] , where  ρ i ,   ρ i   are the predetermined lower and upper   deviation values   of robot   i   that satisfy 0   <   ρ i   ≤   1   ≤   ρ i . In this model, robot   i   travels along the edges of   T i , and spends zero time at the vertices. We also assume that the robots are equipped with motion prim- itives that allow them to deterministically move from   q   to   q ′   for each   ( q ,   q ′ )   ∈   δ i , even though the time it takes to reach from   q   to   q ′   is uncertain. In the following, we use the expression “ in the field ” to refer to the model with uncertain traveling times, and use   x   and  ̃ x   to denote the   nominal   and   actual   values of some variable   x . We consider the case where the robotic team has a mission in which some particu- lar task must be repeatedly completed and the maximum time in between successive completions of this task must be minimized. For instance, in a persistent data gath- ering mission, the global mission could be   keep gathering data while obeying traffic rules at all times , and the repeating task could be   gathering data . For this example, the robots would operate according to the mission specification while ensuring that the maximum time in between any two successive data gatherings is minimized. Consequently, we assume that there is an   optimizing proposition   π   ∈   Π   that corre- sponds to this particular repeating task and consider multi-robot missions specified by LTL formulae of the form  φ   · · =   φ   ∧   GF π ,   (2) where   φ   can be any LTL formula over   Π   , and   GF π   means that the proposition  π   must be repeatedly satisfied. Our aim is to plan multi-robot paths that satisfy the mission   φ   and minimize the maximum time in between successive satisfying instances of   π .
6   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  To state this problem formally, we assume that each run   r i   =   q 0  i   ,   q 1  i   , . . .   of   T i  (robot   i ) starts at   t   =   0 and generates a word   ω i   =   ω 0  i   ,   ω 1  i   , . . .   and a corresponding sequence of time instances   T i   · · =   t 0  i   , t 1  i   , . . .   such that   ω k i   =   L i ( q k i   )   is satisfied at   t k i   . To define the behavior of the team as a whole, we interpret the sequences   T i   as sets and take the union   ⋃ m i = 1   T i   and order this set in an ascending order to obtain the sequence  T   · · =   t 0 , t 1 , . . . . Then, we define   ω team   =   ω 0  team ,   ω 1  team , . . .   to be the word generated by the team of robots where   ω k team   is the union of all propositions satisfied at   t k . Finally, we define the infinite sequence   T π   =   T π   ( 1 ) ,   T π   ( 2 ) , . . .   where   T π   ( k )   stands for the time instance when   π   is satisfied for the   k th   time by the team and define the cost function  J ( T π   ) =   lim sup  i → + ∞  ( T π   ( i   +   1 )   −   T π   ( i ))   .   (3) The form of the cost function given in Eq. (3) is motivated by persistent surveil- lance missions, where one is interested in the long-term behavior of the team. Given a sequence   T π   corresponding to some run of the team, the cost function in Eq. (3) captures the maximum time between satisfying instances of   π   once the team be- havior reaches a steady-state, which we achieve in finite time as we will discuss in Sec. 4.2. Thus, the problem becomes that of finding an optimal run of the team that satisfies   φ   and minimizes (3). However, the non-determinism in traveling times im- poses two additional difficulties which directly follow from Prop. 3.2 in [19]: First, if the traveling times observed during deployment deviate from those used in plan- ning, then there exist missions that will be violated in the field. Second, the worst case performance of the robotic team during deployment in terms of Eq. 3 will be limited by that of a single member. To guarantee correctness in the field, and limit the deviation of the performance of the team from the planned optimal run during deployment, we propose peri- odic synchronization of the robots. Using this synchronization protocol, robots syn- chronize with each other according to pre-computed synchronization sequences  s i ,   i   =   1 , . . . ,   m   as they execute their runs   r i ,   i   =   1 , . . . ,   m   in the field. We can now formulate the problem.  Problem 1.   Given a team of   m   robots modeled as transition systems   T i ,   i = 1 , . . . ,   m , and an LTL formula   φ   over   Π   in the form (2), synthesize individual runs   r i   and syn- chronization sequences   s i   for each robot such that   T π   minimizes the cost function (3), and  ̃ ω team ,   i.e. , the word observed in the field, satisfies   φ   . Note that our aim in Prob. 1 is to find a run that is optimal under nominal values while ensuring that   φ   is never violated in the field. Since  ̃ T π   ,   i.e. , the sequence of instants at which   π   is satisfied during deployment, is likely to be sub-optimal, we will also seek to bound the deviation from optimality in the field. As we consider LTL formulas containing   GF π , this optimization problem is always well-posed. Our solution to Problem 1 can be outlined as follows: 1. We obtain the team transition system   T   that captures the joint asynchronous be- havior of the members of the team (See Sec. 4.1);
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   7  2. We find an optimal satisfying run   r ?  team   on   T   using the O PTIMAL -R UN   al- gorithm we previously developed in [14] and obtain individual optimal runs  r ?  i   ,   i   =   1 , . . . ,   m   (See Sec. 4.2); 3. We generate the synchronization sequences   s i ,   i   =   1 , . . . ,   m   to guarantee correct- ness in the field and calculate an upper bound on the field value of the cost func- tion (3) (See Sec. 4.3).  4 Problem Solution  In this section, we describe each step of our solution to Prob. 1 in detail with the help of a simple illustrative example. We present our experimental results in Sec. 5.  4.1 Obtaining the Team Transition System  In [20], we showed that the joint asynchronous behavior of a robotic team modeled as   m   transition systems   T i ,   i   =   1 , . . . ,   m   (Def. 1) can be captured using a region au- tomaton. A region automaton, as given in the following definition from   [19], is a finite transition system that keeps track of the relative positions of the robots as they move asynchronously in the environment.  Definition 4 (Region Automaton).   The region automaton   R   is a TS (Def. 1)   R   · · = ( Q R ,   q 0 R ,   δ R ,   Π R ,   L R ,   w R ) , where 1.   Q R   is the set of states of the form   ( q ,   r )   such that a.   q   is a tuple of state pairs   ( q 1 q ′  1 , . . . ,   q m q ′  m )   where the   i th   element   q i q ′  i   is a source-target state pair from   Q i   of   T i   meaning robot   i   is currently on its way from   q i   to   q ′  i , and b.   r   is a tuple of clock values   ( x 1 , . . . ,   x m )   where   x i   ∈   N   denotes the time elapsed since robot   i   left state   q i . 2.   q 0 R   ⊆   Q R   is the set of initial states with   r   = ( 0 , . . . ,   0 )   and   q   = ( q 0 1 q ′  1 , . . . ,   q 0  m q ′  m )  such that   q 0  i   is the initial state of   T i   and   ( q 0  i   ,   q ′  i )   ∈   δ i . 3.   δ R   is the transition relation such that a transition from   ( q ,   r )   to   ( q ′ ,   r ′ )   where the  i th   state pair   q i q ′  i   and the   i th   clock value   x i   in   ( q ,   r )   change to   q ′  i q ′′  i   and   x ′  i   in   ( q ′ ,   r ′ )  exists if and only if a.   ( q i ,   q ′  i ) ,   ( q ′  i ,   q ′′  i   )   ∈   δ i   for all changed state pairs, b.   w i ( q i ,   q ′  i )   −   x i   of all changed state pairs are equal to each other and are strictly smaller than those of unchanged state pairs, and c. for all changed state pairs, the corresponding   x ′  i   in   r ′   becomes   x ′  i   =   0 and all other clock values in   r   are incremented by   w i ( q i ,   q ′  i )   −   x i   in   r ′ . 4.   Π R   =   ∪ m i = 1 Π i   is the set of propositions;
8   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  5.   L R   :   Q R   →   2 Π R   is a map giving the set of atomic propositions satisfied in a state. For a state   ( q ,   r ) ,   L R (( q ,   r )) =   ∪ i | x i = 0 L i ( q i ) ; 6.   w R   :   δ R   →   N > 0   is a map that assigns a positive integer weight to each transition such that   w R (( q ,   r ) ,   ( q ′ ,   r ′ )) =   w i ( q i ,   q ′  i )   −   x i   for each state pair that has changed from   q i q ′  i   to   q ′  i q ′′  i   with a corresponding clock value of   x ′  i   =   0 in   r ′ .  Example 1.   Fig. 1 illustrates the TS’s of two robots that are expected to sat- isfy the mission   φ   : =   G ( p 1   ⇒   X ( ¬ p 1   U   p 3 ))   ∧   GF π , where   Π 1   =   { p 1 ,   π } ,   Π 2   =  { p 2 ,   p 3 ,   π } , and   Π   =   { p 1 ,   p 2 ,   p 3 ,   π } . The region automaton   R   that models the robots is given in Fig. 2.  a  b   p 1 ,   π T 1  2   2  (a)  a  b   p 2 ,   π  c   p 3  T 2  2  2  1  1  (b)  Fig. 1   Figs. (a) and (b) show the transition systems   T 1   and   T 2   of two robots in an environment with three vertices. The states of the transition systems correspond to vertices   { a ,   b ,   c }   and the edges represent the motion capabilities of each robot. The weights of the edges represent the traveling times between any two vertices. The propositions   p 1 ,   p 2 ,   p 3   and   π   are shown next to the vertices where they can be satisfied by the robots.  However, as a region automaton encodes the directions of travel of the robots as op- posed to their locations, it typically contains redundant states, and thus can typically be reduced to a smaller size. The following example illustrates this fact.  ab ,   ab  ( 0 ,   0 )  ba ,   cb  ( 1 ,   0 )  p 3   ab ,   bc  ( 0 ,   0 )  p 2  π  ab ,   ba  ( 0 ,   0 )  p 2  π  ba ,   ba  ( 0 ,   0 )  p 1  p 2  π  ba ,   bc  ( 0 ,   0 )  p 1  p 2  π  ab ,   cb  ( 1 ,   0 )   p 3   ba ,   ab  ( 0 ,   0 )  p 1  π  R  2   2  1  1  1   2   2 2  1  1  1 2   Fig. 2   The finite state region automaton capturing the joint behavior of two robots in 9 states. In a circle representing a state   ( q ,   r ) , the first line is   q  and the second line is   r .  Example 1 Revisited.   State   (( ab ,   bc ) ,   ( 0 ,   0 ))   of the region automaton   R   given in Fig. 2 is equivalent to the state   (( ab ,   ba ) ,   ( 0 ,   0 ))   in the sense that both robots satisfy the same propositions and the positions of both robots are the same at both states,
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   9  i.e., robot 1 is at a and robot 2 is at b. These two states differ only in the future direction of travel of the second robot, i.e., robot 2 travels towards c in the first state whereas it travels towards a in the second state. This information, however, is redundant as it can be obtained just by looking at the next state of the team in any given run.  Motivated by this observation, we define a binary relation   R   to reduce the region automaton   R   to a smaller team transition system   T .  Definition 5 (Binary Relation   R ).   Binary relation   R   =   { ( s , t ) | s   ∈   Q R ,   t   ∈   Q T }   is a mapping between the states of   R   and   T   that maps a state   s   = (( q 1 q ′  1 , . . . ,   q m q ′  m ) ,  ( x 1 , . . . ,   x m ))   in   Q R   to a state   t   = ( t 1 , . . . , t m )   in   Q T , where   t i   =   q i   if   x i   =   0 and  t i   =   q i q ′  i x i   if   x i   >   0. Note that,   x i   =   0 for at least one   i   ∈ { 1 , . . . ,   m } . We refer to a state   t i   ∈   Q T   of the form   q i q ′  i x i   as a traveling state as it captures the instant where robot   i   has traveled from   q i   to   q ′  i   for   x i   time units. Given a region automaton   R , we can obtain the corresponding team transition system   T   using the binary relation   R   and the following procedure.  Procedure 1 (Obtaining T from R)   Using   R   we construct the team transition sys- tem   T   from the region automaton   R   as follows: 1. For each s   ∈   Q R   we define the corresponding t   ∈   Q T   as given in Def. 5 such that  ( s , t )   ∈   R . 2. We set   L T ( t ) =   L R ( s ) . Note that, each s that corresponds to a given t has the same set of propositions due to the way   R   is constructed (Def. 4) [20]. 3. For each s corresponding to a given t, we define the corresponding transitions originating from t in   T   such that   ∃ ( t , t ′ )   ∈   δ T   ∀   ( s ,   s ′ )   ∈   δ R   where   ( s , t )   ∈   R   and  ( s ′ , t ′ )   ∈   R . 4. We mark a state t in   Q T   as the initial state of   T   if the corresponding s is an initial state in   Q R . Note that, all states that correspond to a given t are either in q 0 R   altogether or none of them are in q 0 R .  The following proposition shows that the team transition system   T   obtained us- ing Proc. 1 and the corresponding region automaton   R   are bisimulation equivalent,  i.e. , there exists a binary relation between the states and the transitions of   R   and   T  such that they behave in the same way [1].  Proposition 1 (Bisimulation Equivalence).   The team transition system   T   obtained using Proc. 1 and the region automaton   R   are bisimulation equivalent, i.e.,   R   ∼   T , and   R   is a bisimulation relation for   R   and   T . Proof.   In the following, we use   Post ( s )   to denote the set of states that can be reached from state   s   after taking a single transition out of   s . For any   ( s , t )   ∈   R   where  s   ∈   Q R   and   t   ∈   Q T , it holds that   L   ( s ) =   L   ( t ) . Furthermore, for any   ( s , t )   ∈   R  it also holds by construction that   ∀ s ′   ∈   Post ( s ) ,   ∃ t ′   ∈   Post ( t ) | ( s ′ , t ′ )   ∈   R   and   ∀ t ′   ∈  Post ( t ) ,   ∃ s ′   ∈   Post ( s ) | ( s ′ , t ′ )   ∈   R . Finally, we also have   ∀ s   ∈   q 0 R ,   ∃ t   ∈   q 0 T | ( s , t )   ∈   R  and   ∀ t   ∈   q 0 T ,   ∃ s   ∈   q 0 R | ( s , t )   ∈   R . Therefore,   R   and   T   are bisimulation equivalent,  i.e. ,   R   ∼   T , and   R   is a bisimulation relation for   R   and   T .   
10   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  Example 1 Revisited.   Using   R   we construct   T   (Fig. 3) that captures the joint asynchronous behavior of the team in 6 states whereas the corresponding region automaton   R   had 9 states. A state labeled   ( a ,   b )   means robot 1 is at region a and robot 2 is at region b, whereas a state labeled   ( ba 1 ,   c )   means robot 1 traveled from b to a for 1 time unit and robot 2 is at c.  a ,   a   ba 1 ,   c p 3   a ,   b   p 2  π  b ,   b  p 1  p 2  π  ab 1 ,   c   p 3   b ,   a   p 1  π T  2  1  1  2   2  1  2   1  Fig. 3   The team transition system capturing the joint behavior of two robots in 6 states.  In [20] we showed that the number of states   | Q R |   of the region automaton   R   that models the   m   TSs   T i ,   i   =   1 , . . . ,   m   is bounded by   ( ∏ m i = 1   | δ i | ) ( ∏ m i = 1   W i   −   ∏ m i = 1 ( W i   −   1 )) , where   | δ i |   is the number of transitions in the TS   T i   of robot   i   and   W i   is maximum weight of any transition in   T i . The following proposition provides a bound on the number of states   | Q T |   of   T   and shows that it is indeed significantly smaller than the bound on   | Q R | .  Proposition 2.   The number of states   | Q T |   of   T   is bounded by  m  ∏  i = 1  | Q i |   + ( W   −   1 )  m  ∏  i = 1  | δ i |   (4)  where W is the largest edge weight in all TS’s. Proof.   The first term in (4) is the maximum number of states that we can have in the Cartesian product of   T i ,   i   =   1 , . . . ,   m . The second term in (4) is an upper-bound on the number of traveling states (Def. 5) that we can define as we construct   T . Here,  ∏ m i = 1   | δ i |   is the maximum number of different transition tuples that we can consider at line 8 of Alg. 1 and   ( W   −   1 )   is the upper bound on the number of new traveling states per transition tuple. Thus,   | Q T |   is bounded by the sum of these two terms as given in (4).     Finally, we note that the states of   T   corresponds to the instants where at least one member of the team has completed a transition in its individual TS and is currently at a vertex while other robots may still be traveling. Using this fact, one can construct   T  directly by using a depth first search that runs in parallel on the TS’s of the individual members of the team as given in Alg. 1. Alg. 1 is essentially a recursive depth first search (lines 4 – 17) that starts at the initial state of the team transition system   T   (line 3). The initial state   q 0 T   of   T  is defined as the tuple of the initial states of the   m   T i s (line 2). Given a state   q   of  T , the function   dfsT   first generates all possible tuples of transitions that can be
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   11  Algorithm 1:   C ONSTRUCT -T EAM -TS  Input :   ( T 1 , . . . ,   T m ) .  Output : Corresponding team transition system   T .  1   q 0 T   : = ( q 0 1 , . . . ,   q 0  m ) , where   q 0  i   is the initial state of   T i .  2   dfsT ( q 0 T ).  3   Function dfsT (state tuple   q   ∈   Q T )  4   q [ i ]   is the   i th   element of state tuple   q   ∈   Q T .  5   t i   is a transition of   T i ,   i   =   1 , . . . ,   m , such that   t i   ∈ { ( q [ i ] ,   q ′  i ) | ( q [ i ] ,   q ′  i )   ∈   δ i }   if   q [ i ]   ∈   Q i . Else if  q [ i ] =   q i q ′  i x i , then   t i   = ( q i ,   q ′  i ) .  6   T   : = ( t 1 , . . . , t m )   is a tuple of such transitions.  7   T   is the set of all such transition tuples at   q .  8   foreach   transition tuple T   ∈   T   do  9   w   ←   Shortest time until a robot is at a vertex while the transitions in   T   are being taken.  10   Find the   q ′   that corresponds to this new state of the team using   R .  11   if   q ′   / ∈   Q T   then  12   Add state   q ′   to   Q T .  13   Set   L T ( q ′ ) =   ∪ i | q ′ [ i ] ∈ Q i   L i ( q ′ [ i ]) .  14   Add   ( q ,   q ′ )   to   δ T   with weight   w .  15   Continue search from   q ′ :   dfsT ( q ′ ) .  16   else if   ( q ,   q ′ )   / ∈   δ T   then  17   Add   ( q ,   q ′ )   to   δ T   with weight   w .  taken at the current states of the   m   TSs (lines 4 – 7). The current state of TS   T i   is given by the   i th   element   q [ i ]   of the current state   q   of the   T . At line 5 of Alg. 1, we consider all possible transitions out of the current states of all TSs   T i ,   i   =   1 , . . . ,   m . If  q [ i ]   ∈   Q i ,   i.e. ,   q [ i ]   is a regular state of   T i , then all transitions going out of this state in   T i   will be considered in the transition tuples that we will construct. Else,   q [ i ]   is a traveling state of   T i   of the form   q i q ′  i x i , and the only transition that can be taken is the one that is being taken,   i.e. , the transition from   q i   to   q ′  i . Then, we construct the set of all possible tuples of transitions that can be taken at the current states of the  m   TSs (lines 6–7) and process each tuple one by one (lines 8–17). In a transition tuple   T   , the   i th   element gives the transition that can be taken at the current state of  T i . In lines 9–10, we find the next instant where at least one transition in   T   has been completed and the next state   q ′   of   T   that has been reached. If   q ′   is a new state (lines 11 – 15), we accordingly add it to   Q T   and define its propositions. Then, we add the transition that has just been completed to   δ T   and continue our search from this new state   q ′ . Else, we add the transition that has just been completed to   δ T   if required and proceed to the next transition tuple in   T   . The algorithm concludes when all states and transitions of   T   have been discovered.  Remark 1 (Comparison with Naive Construction).   One can avoid going through Alg. 1 and capture the joint behavior of the team by discretizing each transition in  T i ,   i   =   1 , . . . ,   m to unit-length edges and taking the synchronous product of these m   T i ’s. This approach, however, yields a much larger model whose state count is
12   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  bounded by   m  ∏  i = 1  (  | Q i |   +   ∑  ( q , q ′ ) ∈ δ i  w i ( q ,   q ′ )   − | δ i |  )  .  For the case where we have m identical robots in an environment with Q vertices,  ∆   edges and a largest edge weight of W , the above given bound is O (( Q   +   ∆ W   ) m ) , whereas the bound given by Prop. 2 is O ( Q m   +   ∆   m W   ) .  4.2 Obtaining Optimal Satisfying Runs and Transition Systems with Traveling States  After constructing   T   that models the team, we use Alg. O PTIMAL -R UN   from [14] to obtain an optimal run   r ?  team   on   T   that minimizes the cost function (3). The optimal run   r ?  team   is always in prefix-suffix form, consisting of a finite sequence of states of  T   (prefix), followed by infinite repetitions of another finite sequence of states of   T  (suffix) as given in Def. 3.  Example 1 Revisited.   For the example we have shown, running Alg.   O PTIMAL - R UN   [14] on   T   given in Fig. 3 for the formula   φ   =   G ( p 1   ⇒   X ( ¬ p 1   U   p 3 ))   ∧   GF π  results in the optimal run  T   0   2   3   4   5   6   . . . r ?  team   a,a   b,b   ba1,c   a,b   ab1,c   b,b   . . .  L T ( · )   / 0   p 1 ,   p 2 ,   π   p 3   p 2 ,   π   p 3   p 1 ,   p 2 ,   π   . . . where the first row shows when transitions occur, the second row corresponds the run r ?  team , and the last row shows the satisfying atomic propositions. For this run,  ( a ,   a ) ,   ( b ,   b )   is the finite prefix and   ( ba 1 ,   c ) ,   ( a ,   b ) ,   ( ab 1 ,   c ) ,   ( b ,   b )   is the suffix cycle, which will be repeated infinite number of times. Also, the time sequence   T π   of sat- isfaction of   π   is   T π   =   2 ,   4 ,   6 ,   8 , . . .   and the cost as defined in   (3)   is J ( T π   ) =   2 .  Since   T   captures the asynchronous motion of the robots, the optimal satisfying run  r ?  team   on   T   may contain some traveling states which do not appear in the individ- ual TSs   T i ,   i   =   1 , . . . ,   m   that we started with. But we cannot ignore such traveling states either, as each one of them is a candidate synchronization point for the cor- responding robot as we discuss in Sec. 4.3. Instead, we insert those traveling states into the individual TSs so that the robots will be able to synchronize with each other at those points if needed. In the following, we use   q k [ i ]   to denote the   i th   ele- ment of the   k th   state tuple in   r ?  team , which is also the state of robot   i   at that position of   r ?  team . As given in Def. 5, a traveling state of robot   i   has the form   q i q ′  i x i . First, we construct the set   S   =   { ( i ,   q k [ i ])   |   q k [ i ] =   q i q ′  i x i   ∀   k ,   i }   of all traveling states that appear in   r ?  team . Elements of   S   are tuples where the second element is a travel- ing state and the first element gives the transition system this new traveling state will be added to. Next, we construct the set   T   =   { ( i ,   ( q k [ i ] ,   q k + 1 [ i ]) ,   x )   |   (( i ,   q k [ i ])   ∈
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   13  S   )   ∨   (( i ,   q k + 1 [ i ])   ∈   S   ) ,   x   =   w T ( q k ,   q k + 1 )   ∀   k ,   i }   of all transitions that involve any of the traveling states in   r ?  team . Elements of   T   are triplets where the second element is a transition, the third element is the weight of this transition, and the first element shows the transition system that this new transition will be added to. Then, we add the traveling states in   S   and the transitions in   T   to their corresponding transition systems. Finally, using the following definition, we project the optimal satisfying run   r ?  team   down to individual robots   T i ,   i   =   1 , . . . ,   m   to obtain individual optimal sat- isfying runs   r ?  i   ,   i   =   1 , . . . ,   m .  Definition 6 (Projection of a Run on T to T i ’s).   Given a run   r team   on   T   where  r team   =   q 0 ,   q 1 , . . . , we define its projection on   T i   as run   r i   =   q 0  i   ,   q 1  i   , . . .   for all   i   =  1 , . . . ,   m , such that   q k i   =   q k [ i ]   where   q k [ i ]   is the   i th   element of tuple   q k . It can be easily seen that the set of runs   r i ,   i   =   1 , . . . ,   m   obtained from   r team   using Def. 6 and the run   r team   on   T   indeed correspond to each other: The projection given in Def. 6 simply breaks down a sequence of tuples of states into a tuple of sequences of states, while preserving the order of the states. Thus, the word   ω   and the time sequence   T   generated by   r i ,   i   =   1 , . . . ,   m   are exactly the word   ω team   and the time sequence   T team   generated by   r team . Moreover, if run   r team   is in prefix-suffix form, all individual runs   r i   projected from   r team   are also in prefix-suffix form. Therefore, the individual runs projected from the optimal run   r ?  team   are always in prefix-suffix form.  a  ab 1  b   p1 ,   π  ba 1  T 1  2   2  1  1   1  1  (a)  a  b   p2 ,   π  c   p 3  T 2  2  2  1  1  (b)  Fig. 4   Figs. (a) and (b) show the TSs with new traveling states that correspond to the optimal run   r ?  team   that we computed for Ex. 1. The new traveling states and transitions of   T 1   are highlighted in red.  Example 1 Revisited.   For this example, we have   S   =   { ( 1 ,   ab 1 ) ,   ( 1 ,   ba 1 ) }   and  T   =   { ( 1 ,   ( a ,   ab 1 ) ,   1 ) ,   ( 1 ,   ( ab 1 ,   b ) ,   1 ) ,   ( 1 ,   ( b ,   ba 1 ) ,   1 ) ,   ( 1 ,   ( ba 1 ,   a ) ,   1 ) } . Fig. 4 illus- trates the corresponding TSs with new traveling states and transitions highlighted in red. Using Def. 6, we obtain the runs of the individual robots as r ?  1   =   a ,   b ,   ba 1 ,   a ,   ab 1 ,  b ,   ba 1 ,   a ,   ab 1 , . . .   and r ?  2   =   a ,   b ,   c ,   b ,   c ,   b ,   c ,   b ,   c , . . . .  4.3 Guaranteeing Correctness through Synchronization and the Optimality Bound  As the robots execute their infinite runs in the field, they synchronize with each other according to the synchronization sequences that we generate using Alg. 2.
14   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  The synchronization sequence   s i   of robot   i   is an infinite sequence of pairs of sets. The   k th   element of   s i , denoted by   s k i   , corresponds to the   k th   element   q k i   of   r ?  i   . Each   s k i  is a tuple of two sets of robots:   s k i   = ( s k i , wait   ,   s k i , noti f y ) , where   s k i , wait   and   s k i , noti f y   are the  wait-set   and   notify-set   of   s k i   , respectively. The   wait-set   of   s k i   is the set of robots that robot   i   must wait for at state   q k i   before satisfying its propositions and proceeding to the next state   q k + 1  i   in   r ?  i   . The   notify-set   of   s k i   is the set of robots that robot   i   must notify as soon as it reaches state   q k i   . As we discussed earlier in Sec. 4.2, the optimal run   r ?  team   of the team and the individual optimal runs   r ?  i   ,   i   =   1 , . . . ,   m   of the robots are always in prefix-suffix form (Def. 3). Consequently, individual synchronization sequences   s i   of the robots are also in prefix-suffix form.  Algorithm 2:   S YNC -S EQ  Input : Individual optimal runs of the robots   { r ?  1   , . . . ,   r ?  m } , B ̈ uchi automaton   B ¬ φ   that corresponds to   ¬ φ   .  Output : Synchronization sequence for each robot   { s 1 , . . . ,   s m } .  1   I   =   { 1 , . . . ,   m } .  2   beg   ←   beginning of suffix cycle.  3   end   ←   end of suffix cycle.  4   Initialize each   s i   so that all robots wait for and notify each other at every position of their runs.  5   foreach   k   =   0 , . . . ,   end   do  6   foreach   i   ∈   I   do  7   if   k   6   =   0   and k   6   =   beg   then  8   foreach   j   ∈   I   \   i   do  9   Remove   j   from   s k i , wait   .  10   Remove   i   from   s k j , noti f y .  11   Construct the TS   W   that generates every possible  ̃ ω team .  12   if   the language of   B ¬ φ   ×   W   is not empty   then  13   Add   j   back to   s k i , wait   .  14   Add   i   back to   s k j , noti f y .  15   Rest of each   s i   is an infinite repetition of its suffix-cycle, i.e.   s beg i   , . . . ,   s end i   .  Alg. 2 is essentially a loop (lines 5 – 14) that computes wait-sets and notify- sets for each position of the runs of the robots to guarantee correctness in the field. Initially, synchronization sequences are set so that the robots wait for and notify all other robots at every position of their runs (line 4). At line 7 of Alg. 2, if   k   is the first position of the runs, we do not modify this initial value of   s k i   . This ensures that all robots start executing their runs in a synchronized way. Also, if   k   is the beginning of the suffix cycle, we again keep this initial value of   s k i   so that all robots synchronize with each other globally at the beginning of each suffix cycle. This lets us define a bound on optimality,   i.e. , the value of the cost function (3) observed in the field, as given in Prop. 3. For all other positions of the runs, we try to shrink the wait- set and notify-set of each   s k i   so that communication effort is reduced while we can
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   15  still guarantee correctness in the field (lines 9 – 14). To this end, we consider each one of the robots in robot   i ’s   k th   wait-set,   i.e. ,   s k i , wait   , one by one. After removing some robot   j   from the   s k i , wait   , we also remove robot   i   from   s k j , noti f y   accordingly (lines 10–12). Then, given the   ρ i   and   ρ i   values of the robots, we construct the TS   W  that generates all possible words  ̃ ω team   that can be observed in the field due to the uncertainties in the traveling times. Next, we check if the language of the product  B ¬ φ   ×   W   is empty or not, where   B ¬ φ   is the B ̈ uchi automaton corresponding to the negation of the LTL formula   φ   (line 12). If the language of the product is empty, then robot   i   indeed does not need to wait for robot   j   at the   k th   position of its run. Thus, we keep the new values of   s k i , wait   and   s k j , noti f y . Else, we restore   s k i , wait   and notify-set of   s k j , noti f y   to their previous values (lines 13–14) and proceed with the next robot in  s k i , wait   . Once every robot in   s k i , wait   is considered, we proceed with the next robot in the team, and eventually next position of the run. Notice that, the synchronization sequences generated by Alg. 2 are free from any dead-locks as lines 9 – 10, and lines 13 – 14 ensure that if some robot   i   waits for robot   j   at position   k , then robot   j   notifies robot   i   at position   k ,   i.e. ,   j   ∈   s k i , wait   ⇐⇒   i   ∈   s k j , noti f y   ∀   i ,   j ,   k . As the synchronization sequences of the robots are in prefix-suffix form and the robots synchronize with each other globally at the beginning of each suffix (line 8), at line 15, we define the rest of each synchronization sequence as an infinite repetition of its first suffix-cycle that we have just generated. For a prefix of length   p   and a suffix cycle of length   s , the complexity of Alg. 2 is   O (( p   +   s ) m 2 L )   where   m   is the number of robots and   L  is the complexity of constructing   W   ×   B ¬ φ   and checking emptiness of its language at each iteration. The synchronization protocol that the robots follow in the field is given in Alg. 3.  Algorithm 3:   S YNC -R UN  Input : The run   r i   and synchronization sequence   s i   of robot   i   .  1   k   ←   0.  2   while   True   do  3   Notify   all robots in   s k i , noti f y .  4   Wait   until notification messages of all robots in   s k i , wait   are received.  5   Make transition to   r k + 1  i   after satisfying the propositions at   r k i   .  6   k   ←   k   +   1.  The following proposition slightly extends the result of Prop. 4.5 in [19] by con- sidering unequal lower and upper deviation values.  Proposition 3.   Suppose that each robot’s deviation values are bounded by   ρ   and   ρ  where   ρ   ≥   1   ≥   ρ   >   0   (i.e.,   ρ i   ≥   ρ   and   ρ i   ≤   ρ   for each robot i). Let J ( T π   )   be the cost of the planned robot paths and let J (    ̃ T π   )   be the actual value of the cost observed during deployment. Then, if the robots follow the protocol given in Alg. 3 the field value of the cost satisfies
16   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  J (    ̃ T π   )   ≤   J ( T π   ) ρ   +   d s ( ρ   −   ρ )  where d s   is the planned duration of the suffix cycle.  Example 1 Revisited.   For the example we have shown throughout this section, we obtain the following individual optimal runs and synchronization sequences.  T   0   2   3   4   5   6   . . . r ?  1   a   b   ba1   a   ab1   b   . . . s 1   ( { 2 } ,   { 2 } )   ( {} ,   {} )   ( { 2 } ,   { 2 } )   ( {} ,   {} )   ( {} ,   {} )   ( {} ,   {} )   . . .  L 1 ( . )   p 1 ,   π   p 1 ,   π   . . . r ?  2   a   b   c   b   c   b   . . . s 2   ( { 1 } ,   { 1 } )   ( {} ,   {} )   ( { 1 } ,   { 1 } )   ( {} ,   {} )   ( {} ,   {} )   ( {} ,   {} )   . . .  L 2 ( . )   p 2 ,   π   p 3   p 2 ,   π   p 3   p 2 ,   π   . . . In a line corresponding to a synchronization sequence s i , first and second elements of the tuple at position k are s k i , wait   and s k i , noti f y , respectively.  We finally summarize our approach in Alg. 4 and show that this algorithm indeed solves Prob. 1. We discuss the complexity of our approach in Rem. 2.  Proposition 4.   Alg. 4 solves Prob. 1. Proof.   Note that Alg. 4 combines all steps outlined in this section. The planned word   ω team   generated by the entire team satisfies   φ   , and minimizes (3), as shown in [14]. The synchronization sequences guarantee correctness in the field by ensuring that the    ̃ ω team   generated in the field never violates   φ   for given deviation values. Therefore,   { r ?  1 , . . . ,   r ?  m }   and   { s 1 , . . . ,   s m }   as obtained from Alg. 4 is a solution to Prob. 1.     Remark 2 (Computational Complexity).   The main drawback of our approach is its computational complexity, which is exponential in the number of robots (due to generation of the team transition system and the synchronization sequences) and in the length of the LTL formula (due to the conversion to a B ̈ uchi automaton). This cost, however, is justified by the globally optimal runs that our approach computes, and in practice, we can solve fairly large problems.  5 Implementation and Case-Study  We implemented Alg. 4 as a python module (available at   http://hyness.bu. edu/lomap/ ) and used it to plan optimal satisfying paths and synchronization se- quences for the scenario that we consider in this section. Our experimental platform (Fig. 5(a)) is a road network comprising roads, intersections and task locations. Fig. 5(b) illustrates the model that captures the motion of the robots on this plat- form, where 1 time unit corresponds to 1.574 seconds.
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   17  Algorithm 4:   R OBUST -M ULTI -R OBOT -O PTIMAL -R UN  Input :   m   T i ’s, corresponding deviation values, and a global LTL specification   φ   of the form (2).  Output : A set of optimal runs   { r ?  1   , . . . ,   r ?  m }   that satisfies   φ   and minimizes (3), a set of synchronization sequences   { s 1 , . . . ,   s m }   that guarantees correctness in the field, and the bound on the performance of the team in the field.  1   Construct the team transition system   T   using Alg. 1.  2   Find an optimal run   r ?  team   on   T   using O PTIMAL -R UN   [14].  3   Insert new traveling states to TSs according to   r ?  team   (See. Sec. 4.2).  4   Obtain individual runs   { r ?  1   , . . . ,   r ?  m }   using Def. 6.  5   Generate synchronization sequences   { s 1 , . . . ,   s m }   using S YNC -S EQ   (Alg. 2).  6   Find the bound on optimality as given in Prop. 3.  (a) 1  2   3  4  5  6   7  8   9  10   11  12  13  14   15  16  21  22  17   18   20   19   4  1  1  1  1  1 1  1  1  1  1  1  1  1  1  1  1  1  1   1  1  1  1  4  4  4  2  4  2   2  2  2   2   (b)  Fig. 5   Fig. (a) shows our experimental platform. The squares and the circles on the trajectories of the robots represent the beginning of the suffix cycle and sync. points, respectively. Fig. (b) illustrates the TS that models the robots. The green and red regions are data gather and upload locations, respectively.  In our experiments, we consider a persistent surveillance task involving two robots with deviation values   ρ 1   =   ρ 2   =   1 . 05 and   ρ 1   =   ρ 2   =   0 . 95. The building in the middle of the platform in Fig. 5(a) is our surveillance target. We define the set of propositions   Π   =   { R1Gather18 ,   R1Gather20 ,   R2Gather18 ,   R2Gather20 ,  R1Gather ,   R2Gather ,   R1Upload ,   R2Upload ,   Gather }   and assign them as   L 1 ( 18 ) =   { R1Gather18 ,   R1Gather ,   Gather } ,   L 2 ( 18 ) =   { R2Gather18 ,   R2Gather ,  Gather } ,   L 1 ( 20 ) =   { R1Gather20 ,   R1Gather ,   Gather } ,   L 2 ( 20 ) =   { R2Gather20 ,  R2Gather ,   Gather } ,   L 1 ( 22 ) =   { R1Upload }   and   L 2 ( 22 ) =   { R2Upload } . The main objective is to keep gathering data while minimizing the maximum time be- tween successive gathers. We require the robots to gather data in a synchronous manner at data gather locations 18 and 20 while ensuring that they do not gather data at the same place at the same time. We also require the robots to upload their data at upload location 22 before their next data gather. We express these require- ments in LTL in the form of (2) as
18   Alphan Ulusoy, Stephen L. Smith, and Calin Belta  φ   = G   ( R1gather   ⇒   X ( ¬ R1gather   U   R1upload ))   ∧   G   ( R2gather   ⇒  X ( ¬ R2gather   U   R2upload ))   ∧   G   (( R1Gather18   ⇒   R2Gather20 ) ∧  ( R1gather20   ⇒   R2gather18 )   ∧   ( R2gather18   ⇒   R1gather20 ) ∧  ( R2gather20   ⇒   R1gather18 ))   ∧   GF   Gather ,  where   Gather   is set as the optimizing proposition. Fig. 5(a) illustrates the solution we obtain using our algorithm. Using an iMac i5 quad-core computer, it took our implementation 10 minutes to compute the op- timal runs and synchronization sequences of the robots. The planned value of the cost function was 44.072 seconds (28 time units) with an upper bound of 50.683 seconds (32.2 time units) seconds. We deployed our robots in our experimental platform to demonstrate and verify the result. The maximum time between any two successive data uploads was measured to be 48 seconds. The video available at   http://hyness.bu.edu/lomap/dars2012.mov   demonstrates the execution of this run by the robots.  6 Conclusion  In this paper we presented an automated method for planning optimal paths for a robotic team subject to temporal logic constraints expressed in LTL. The robots that we consider have bounded non-deterministic traveling times characterized by robot specific deviation values. We first compute a set of optimal satisfying paths for the members of the team. Then, leveraging the communication capabilities of the robots, we also compute a set of synchronization sequences for each robot to ensure that the LTL formula is never violated during deployment. Our experiments show that our method has practical value in scenarios where the traveling times of the robots during deployment deviate from those used in planning.  Acknowledgements   This work was supported in part by ONR MURI N00014-09-1051, NSF CNS-0834260, and NSERC.  References  1. Baier, C., Katoen, J.P.: Principles of Model Checking. MIT Press (2008) 2. Bianco, A., Alfaro, L.D.: Model checking of probabilistic and nondeterministic systems. pp. 499–513. Springer-Verlag (1995) 3. Clarke, E.M., Peled, D., Grumberg, O.: Model checking. MIT Press (1999) 4. Ding, X.C., Smith, S.L., Belta, C., Rus, D.: Mdp optimal control under temporal logic con- straints. In: IEEE Conf. on Decision and Control, pp. 532–538. Orlando, FL (2011) 5. Emerson, E.A.: Temporal and modal logic. In: J. van Leeuwen (ed.) Handbook of Theoretical Computer Science: Formal Models and Semantics, vol. B, pp. 995–1072. North-Holland Pub. Co./MIT Press (1990)
Optimal Multi-Robot Path Planning with LTL Constraints and Synchronization   19 6. Hopcroft, J., Motwani, R., Ullman, J.D.: Introduction to Automata Theory, Languages, and Computation. Addison Wesley (2007) 7. Karaman, S., Frazzoli, E.: Complex mission optimization for multiple-uavs using linear tem- poral logic. In: American Control Conference, pp. 2003–2009. Seattle, WA (2008) 8. Karaman, S., Frazzoli, E.: Vehicle routing problem with metric temporal logic specifications. In: IEEE Conf. on Decision and Control, pp. 3953–3958. Canc ́ un, M ́ exico (2008) 9. Kloetzer, M., Belta, C.: Automatic deployment of distributed teams of robots from temporal logic specifications. IEEE Transactions on Robotics   26 (1), 48–61 (2010) 10. Kress-Gazit, H., Fainekos, G., Pappas, G.J.: Where’s waldo? sensor-based temporal logic mo- tion planning. In: IEEE Intl. Conf. on Robotics and Automation, pp. 3116–3121 (2007) 11. Kwiatkowska, M., Norman, G., Parker, D.: Probabilistic symbolic model checking with prism: A hybrid approach. In: International Journal on Software Tools for Technology Transfer, pp. 52–66. Springer (2002) 12. Milner, R.: Communication and concurrency. Prentice-Hall (1989) 13. M.Kloetzer, Belta, C.: Dealing with non-determinism in symbolic control. In: M. Egerstedt, B. Mishra (eds.) Hybrid Systems: Computation and Control: 11th International Workshop, Lecture Notes in Computer Science, pp. 287–300. Springer Berlin / Heidelberg (2008) 14. Smith, S.L., T ̊ umov ́ a, J., Belta, C., Rus, D.: Optimal path planning for surveillance with tem- poral logic constraints. Intl. Journal of Robotics Research   30 (14), 1695–1708 (2011) 15. Tabuada, P., Pappas, G.J.: Linear time logic control of discrete-time linear systems.   IEEE Transactions on Automatic Control   51 (12), 1862–1877 (2006) 16. Thomas, W.: Infinite games and verification. In: Intl. Conf. on Computer Aided Verification, pp. 58–64 (2002) 17. Toth, P., Vigo, D. (eds.): The Vehicle Routing Problem. Monographs on Discrete Mathematics and Applications. SIAM (2001) 18. Tumova, J., Yordanov, B., Belta, C., Cerna, I., Barnat, J.: A symbolic approach to controlling piecewise affine systems. In: IEEE Conf. on Decision and Control, pp. 4230–4235. Atlanta, GA (2010) 19. Ulusoy, A., Smith, S.L., Ding, X.C., Belta, C.: Robust multi-robot optimal path planning with temporal logic constraints. In: IEEE Intl. Conf. on Robotics and Automation, pp. 4693–4698. St. Paul, MN, USA (2012) 20. Ulusoy, A., Smith, S.L., Ding, X.C., Belta, C., Rus, D.: Optimal path planning for surveillance with temporal logic constraints. In: IEEE/RSJ Intl. Conf. on Intelligent Robots & Systems, pp. 3087–3092. San Francisco, CA, USA (2011) 21. Wongpiromsarn, T., Topcu, U., Murray, R.M.: Receding horizon control for temporal logic specifications. In: Hybrid systems: Computation and Control, pp. 101–110. Stockholm, Swe- den (2010)