Sampling-Based Temporal Logic Path Planning

Sampling-Based Temporal Logic Path Planning

Cristian Ioan Vasile and Calin Belta This work was partially supported by the ONR under grants MURI N00014-09-1051 and MURI N00014-10-10952 and by the NSF under grant NSF CNS-1035588. The authors are with the Division of Systems Engineering, Boston University, Boston MA, {cvasile, cbelta}@bu.edu).
Abstract

In this paper, we propose a sampling-based motion planning algorithm that finds an infinite path satisfying a Linear Temporal Logic (LTL) formula over a set of properties satisfied by some regions in a given environment. The algorithm has three main features. First, it is incremental, in the sense that the procedure for finding a satisfying path at each iteration scales only with the number of new samples generated at that iteration. Second, the underlying graph is sparse, which guarantees the low complexity of the overall method. Third, it is probabilistically complete. Examples illustrating the usefulness and the performance of the method are included.

I Introduction

Motion planning is a fundamental problem that has received a lot of attention from the robotics community [16]. The goal is to generate a feasible path for a robot to move from an initial to a final configuration while avoiding obstacles. Exact solutions to this problem are intractable, and relaxations using potential fields, navigation functions, and cell decompositions are commonly used [5]. These approaches, however, become prohibitively expensive in high dimensional configuration spaces. Sampling-based methods were proposed to overcome this limitation. Examples include the probabilistic roadmap (PRM) algorithm proposed by Kavraki et.al. in [13], which is very useful for multi-query problems, but is not well suited for the integration of differential constraints. In [17], Kuffner and LaValle proposed rapidly-exploring random trees (RRT). RRTs grow randomly, are biased to explore “new” space [17] (Voronoi bias), and find solutions quite fast. Moreover, PRM and RRT were shown to be probabilistically complete [13, 17], but not probabilistically optimal [12]. Karaman and Frazzoli proposed RRT and PRM, the probabilistically optimal counterparts of RRT and PRM in [12].

Recently, there has been increasing interest in improving the expressivity of motion planning specifications from the classical scenario (“Move from A to B and avoid obstacles.”) to richer languages that allow for Boolean and temporal requirements, e.g., “Visit A, then B, and then C, in this order infinitely often. Always avoid D unless E was visited.” It has been shown that temporal logics, such as Linear Temporal Logic (LTL), Computation Tree Logic (CTL), -calculus, and their probabilistic versions (PLTL, PCTL) [1] can be used as formal and expressive specification languages for robot motion [15, 21, 3, 11, 7]. In the above works, adapted model checking algorithms and automata game techniques [15, 4] are used to generate motion plans and control policies for a finite model of robot motion, which is usually obtained through an abstraction process based on partitioning the configuration space [2]. The main limitation of these approaches is their high complexity, as both the synthesis and abstraction algorithms scale at least exponentially with the dimension of the configuration space.

To address this issue, in [11], Karaman and Frazzoli proposed a sampling-based path planning algorithm from specifications given in deterministic -calculus. However, deterministic -calculus formulae have unnatural syntax based on fixed point operators, and are difficult to use by untrained human operators. In contrast, Linear Temporal Logic (LTL), has very friendly syntax and semantics, which can be easily translated to natural language. One idea would be to translate LTL specifications to deterministic -calculus formulae and then proceed with generation of motion plans as in [11]. However, there is no known procedure to transform an LTL formula into a -calculus formula such that the size of is polynomial in the size of (for details see [6]).

In this paper, we propose a sampling-base path planning algorithm that finds an infinite path satisfying an LTL formula over a set of properties that hold at some regions in the configuration space. The procedure is based on the incremental construction of a transition system followed by the search for one of its satisfying paths. One important feature of the algorithm is that, at a given iteration, it only scales with the number of samples and transitions added to the transitions system at that iteration. This, together with a notion of “sparsity” that we define and enforce on the transition system, play an important role in keeping the overall complexity at a manageable level. In fact, we show that, under some mild assumptions, our definition of sparsity leads to the best possible complexity bound for finding a satisfying path. Finally, while the number of samples increases, the probability that a satisfying path is found approaches 1, i.e., our algorithm is probabilistically complete.

Among the above mentioned papers, the closest to this work is [11]. As in this paper, the authors of [11] can guarantee probabilistic completeness and scalability with added samples only at each iteration of their algorithm. However, in [11], the authors employ the fixed point (Knaster-Tarski) theorem to find a satisfying path. Their method is based on maintaining a “product” graph between the transition system and every sub-formula of their deterministic -calculus specification and checking for reachability and the existence of a “type” of cycle on the graph. On the other hand, our algorithm maintains the product automaton between the transition system and a Büchi automaton corresponding to the given LTL specification. Note that, as opposed to LTL model checking [1], we use a modified version of product automaton that ensures reachability of the final states. Moreover, we impose that the states of the transition system be bounded away from each other (by a given function decaying in terms of the size of the transition system). Sparseness is also explored by Dobson and Berkis in [8] for PRM using different techniques.

Our long term goal is to develop a computational framework for automatic deployment of autonomous vehicles from rich, high level specifications that combine static, a priori known information with dynamic, locally sensed events. An example is search and rescue in a disaster relief scenario: an unmanned aircraft is required to keep on photographing some known affected regions and uploading the photos at a known base region. While executing this (global) mission, the aircraft uses its sensors to (locally) identify survivors and fires, with the goal of immediately providing medical assistance to the survivors and extinguishing the fires. The main challenge in this problem is to generate control strategies that guarantee the satisfaction of the global specification in long term while at the same time correctly reacting to locally sensed events. The algorithm proposed in this paper solves the first part of this problem, i.e., the generation of a motion plan satisfying the global specification.

Ii Preliminaries

For a finite set , we use and to denote its cardinality and power set, respectively. denotes the empty set.

Definition II.1 (Deterministic Transition System)

A deterministic transition system (DTS) is a tuple , where:

  • is a finite set of states;

  • is the initial state;

  • is a set of transitions;

  • is a set of properties (atomic propositions);

  • is a labeling function.

We denote a transition by . A trajectory (or run) of the system is an infinite sequence of states such that for all . A state trajectory generates an output trajectory , where for all . The absence of inputs (control actions) in a DTS implicitly means that a transition can be chosen deterministically at every state .

A Linear Temporal Logic (LTL) formula over a set of properties (atomic propositions) is defined using standard Boolean operators, (negation), (conjunction) and (disjunction), and temporal operators, (next), (until), (eventually), (always). The semantics of LTL formulae over are given with respect to infinite words over , such as the output trajectories of the DTS defined above. Any infinite word satisfying a LTL formula can be written in the form of a finite prefix followed by infinitely many repetitions of a suffix. Verifying whether all output trajectories of a DTS with set of propositions satisfy an LTL formula over is called LTL model checking. LTL formulae can be used to describe rich mission specifications. For example, formula specifies a persistent surveillance task: “visit regions and infinitely many times and always avoid obstacle ” (see Figure 1). Formal definitions for the LTL syntax, semantics, and model checking can be found in  [1].

Fig. 1: A simple map with three features: an obstacle and two regions of interest and . The mission specification is . The initial position of the robot is marked by the blue disk. The graph (in black and red) represents the generated transition system . The red arrows specify a satisfying trajectory composed of a prefix and infinitely many repetitions of the suffix .
Definition II.2 (Büchi Automaton)

A (nondeterministic) Büchi automaton is a tuple , where:

  • is a finite set of states;

  • is the set of initial states;

  • is the input alphabet;

  • is the transition function;

  • is the set of accepting states.

A transition is denoted by . A trajectory of the Büchi automaton is generated by an infinite sequence of symbols if and for all . A input infinite sequence over is said to be accepted by a Büchi automaton if it generates at least one trajectory of that intersects the set of accepting states infinitely many times.

It is shown in [1] that for every LTL formula over there exists a Büchi automaton over alphabet such that accepts all and only those infinite sequences over that satisfy . There exist efficient algorithms that translate LTL formulae into Büchi automata [9].

Note, that the converse is not true, there are some Büchi automata for which there is no corresponding LTL formulae. However, there are logics such as deterministic -calculus which are in 1-to-1 correspondence with the set of languages accepted by Büchi automata.

Model checking a DTS against an LTL formula is based on the construction of the product automaton between the DTS and the Büchi automaton corresponding to the formula. In this paper, we used a modified definition of the product automaton that is optimized for incremental search of a satisfying run. Specifically, the product automaton is defined such that all its states are reachable from the set of initial states.

Definition II.3 (Product Automaton)

Given a DTS and a Büchi automaton , their product automaton, denoted by , is a tuple where:

  • is the set of initial states;

  • is a finite set of states which are reachable from some initial state: for every there exists a sequence of , with for all and , and a sequence such that , for all and ;

  • is the set of transitions, defined by: iff and ;

  • is the set of accepting states.

A transition in is denoted by if . A trajectory of is an infinite sequence, where and for all . Such a trajectory is said to be accepting if and only if it intersects the set of final states infinitely many times. It follows by construction that a trajectory of is accepting if and only if the trajectory is accepting in . As a result, a trajectory of obtained from an accepting trajectory of satisfies the given specification encoded by . For , we define as the set of Büchi states that correspond to in . Also, we denote the projection of a trajectory onto by . A similar notation is used for projections of finite trajectories.

For both DTS and automata, we use to denote size, which is the cardinality of the corresponding set of states. A state of a DTS or an automaton is called non-blocking if it has at least one outgoing transition.

Iii Problem Formulation and Approach

Let be a compact set denoting the configuration space of a robot. Let be a set of disjoint regions in and be a set of properties of interest corresponding to these regions. A map specifies how properties are associated to the regions. Throughout this paper, we will assume that is composed of connected sets with non-empty interior, which implies they have non-zero Lebesgue measure (i.e. all regions of interest have full dimension). Also, all connected sets in have full dimension. Examples of properties include “obstacle”, “target”, “drop-off”, etc. (see Fig. 1). In practice, the regions and properties are defined in the workspace, and then mapped to the configuration space by using standard techniques [5].

Problem III.1

Given an environment described by , the initial configuration of the robot and an LTL formula over the set of properties , find a satisfying (infinite) path for the robot originating at .

A possible approach to Problem III.1 is to construct a partition of the configuration space that contains the regions of interest as elements of the partition. By using input - output linearizations and vector field assignments in the regions of the partition, it was shown that “equivalent” abstractions in the form of finite (not necessarily deterministic) transition systems can be constructed for a large variety of robot dynamics that include car-like vehicles and quadrotors [2, 18, 19]. Model checking and automata game techniques can then be used to control the abstractions from the temporal logic specification [14]. The main limitation of this approach is its high complexity, as both the synthesis and abstraction algorithms scale at least exponentially with the dimension of the configuration space.

In this paper, we propose a sampling-based approach that can be summarized as follows: (1) the LTL formula is translated to the Büchi automaton ; (2) a transition system is incrementally constructed from the initial position using an RRG-based algorithm; (3) concurrently with (2), the product automaton is updated and used to check if there is a trajectory of that satisfies . As it will become clear later, our proposed algorithm is probabilistically complete [16, 12] (i.e., it finds a solution with probability 1 if one exists and the number of samples approaches infinity) and the resulting transition system is sparse (i.e., its states are “far” away from each other).

Iv Problem Solution

The starting point for our solution to Problem III.1 is the RRG algorithm, which is an extension of RRT [12] that maintains a digraph instead of a tree, and can therefore be used as a model for general -regular languages [11]. However, we modify the RRG to obtain a “sparse” transition system that satisfies a given LTL formula. More precisely, a transition system is “sparse” if the minimum distance between any two states of is greater than a prescribed function dependent only on the size of (). The distance used to define sparsity is inherited from the underlying configuration space and is not related to the graph theoretical distance between states in . Throughout this paper, we will assume that this distance is Euclidean.

As stated in Section I, sparsity of is desired since the solution to Problem III.1 will be the off-line part of a more general procedure that will combine global and local temporal logic specifications. Sparseness also plays an important role in establishing the complexity bounds for the incremental search algorithm (see Section IV-B).

Iv-a Sparse RRG

We first briefly introduce the functions used by the algorithm.

Sampling function

The algorithm has access to a sampling function , which generates independent and identically distributed samples from a given distribution . We assume that the support of is the entire configuration space .

Steer function

The steer function is defined based on the robot’s dynamics. 111In this paper, we will assume that we have access to such a function. For more details about planning under differential constraints see [16]. Given a configurations and goal configuration , it returns a new configuration that can be reached from by following the dynamics of the robot and that satisfies .

Near function

is a function of a configuration and a parameter , which returns the set of states from the transition system that are at most at distance away from . In other words, returns all states in that are inside the n-dimensional sphere of center and radius .

Far function

is a function of a configuration and two parameters and . It returns the set of states from the transition system that are at most at distance away from . However, the difference from the function is that returns an empty set if any state of is closer to than . Geometrically, this means that returns a non-empty set for a given state if there are states in which are inside the -dimensional sphere of center and radius and all states of are outside the sphere with the same center, but radius . Thus, has to be “far” away from all states in its immediate neighborhood (see Figure 2). This function is used to achieve the “sparseness” of the resulting transition system.

isSimpleSegment function

is a function that takes two configurations , in and returns 1 if the line segment () is simple, otherwise it returns 0. A line segment is simple if and the number of times crosses the boundary of any region is at most one. Therefore, returns 1 if either: (1) and belong to the same region and does not cross the boundary of or (2) and belong to two regions and , respectively, and crosses the common boundary of and once. or at most one of and may be a free space region (a connected set in ). See Figure 2 for examples. In Algorithm 1, a transition is rejected if it corresponds to a non-simple line segment (i.e. function returns 0). Under this condition, the satisfaction of the mission specification can be checked by only looking at the properties corresponding to the states of the transition system.

Bound functions

(lower bound) and (upper bound) are functions that define the bounds on the distance between a configuration in and the states of the transition system in terms of the size of . These are used as parameters for functions and . We impose for all . We also assume that , for some finite and all . Also, tends to 0 as tends to infinity. The rate of decay of has to be fast enough such that a new sample may be generated. Specifically, the set of all configurations where the center of an -sphere of radius may be placed such that it does not intersect any of the -spheres corresponding to the states in has to have non-zero measure with respect to the probability measure used by the sampling function. One conservative upper bound is for all , where is the total measure (volume) of the configuration space, is the dimension of , and is the gamma function. This bound corresponds to the case when there is enough space to insert an -sphere of radius between every two distinct states of . To simplify the notation, we drop the parameter for these functions and assume that is always given by the current size of the transition system, .

Fig. 2: A simple map with three features: an obstacle and two regions , . The robot is assumed to be a fully actuated point. At the current iteration the states of are . The transitions of are represented by the black arrows. The initial configuration is and is marked by the blue disk. The radii of the dark gray (inner) disks and the light gray (outer) disks are and , respectively. A new sample is generated, but it will not be considered as a potential new state of , because it is within distance from state 3 (). Another sample is generated, which is at least distance away from all states in . In this case, and the algorithm attempts to create transition to and from the new sample . The transitions (marked by black dashed lines) are added to , because all these transitions correspond to simple line segments ( returns 1 for all of them). For example, , because and belong to the same region (the free space region) and does not intersect any other region. , because crosses the boundary between the free space region and region once. On the other hand, the transitions (marked by red dashed lines) are not added to , since they pass over the obstacle . In this case, , because and are in the same region, but crosses the boundary of twice.

The goal of the modified RRG algorithm (see Algorithm 1) is to find a satisfying run, but such that the resulting transition system is “sparse”, i.e. states are “sufficiently” apart from each other. The algorithm iterates until a satisfying run originating in is found.

At each iteration, a new sample is generated (line 6 in Algorithm 1). For each state in which is “far” from the sample (), a new configuration is computed such that the robot can be steered from to and the distance to is decreased (line 10). The two loops of the algorithm (lines 7–13 and 16–21) are executed if and only if the function returns a non-empty set. However, is regarded as a potential new state of , and not . Thus, the function plays an important role in the “sparsity” of the final transition system. Next, it is checked if the potential new transition is a simple segment (line 9). It is also verified if may lead to a solution, which is equivalent to testing if induces at least one non-blocking state in (see Algorithm 2). If configuration and the corresponding transition pass all tests, then they are added to the list of new states and list of new transitions of , respectively (lines 12–13).

After all “far” neighbors of are processed, the transition system is updated. Note that at this point was only extended with states that explore “new space”. However, in order to model -regular languages the algorithm must also close cycles. Therefore, the same procedure as before (lines 7–14) is also applied to the newly added states (lines 15–21 of Algorithm 1). The difference is that it is checked if states from can steer the robot back to states in in order to close cycles. Also, because we know that the states in are “far” from their neighbors, the function will be used instead of the function. The algorithm returns a (prefix, suffix) pair in obtained by projection from the corresponding path () and cycle () in , respectively. The above the transition symbol means that the length of the path can be 0, while denotes that the length of the cycle must be at least 1.

Input: – Büchi automaton corresponding to
Input: initial configuration of the robot
Output: (prefix, suffix) in
1 Construct with as initial state Construct Initialize while  s.t.  do
2        , , foreach  do
3               if  then
4                      if  is True then
5                            
6                     
7              
8        , foreach  do
9               foreach  do
10                      if  then
11                             if  is True then
12                                   
13                            
14                     
15              
16       
return , where
Algorithm 1 Sparse RRG

In the end, the result is a transition system which captures the general topology of the environment. In the next section, we will show that also yields a run that satisfies the given specification.

Iv-B Incremental search for a satisfying run

The proposed approach of incrementally constructing a transition system raises the problem of how to efficiently check for a satisfying run at each iteration. As mentioned in the previous section, the search for satisfying runs is performed on the product automaton. Note that testing whether there exists a trajectory of from the initial position that satisfies the given LTL formula is equivalent to searching for a path from an initial state to a final state in the product automaton and for a cycle containing of length greater than 1, where is the Büchi automaton corresponding to . If such a path and a cycle are found then their projection onto represents a satisfying infinite trajectory (line 23 of Algorithm 1). Testing whether belongs to a non-degenerate cycle (length greater than 1) is equivalent to testing if belong to a non-trivial strongly connected component – SCC (the size of the SCC is greater than 1). Checking for a satisfying trajectory in is performed incrementally as the transition system is modified.

The reachability of the final states from initial ones in is guaranteed by construction (see Definition II.3). However, we need to define a procedure (see Algorithm 2) to incrementally update when a new transition is added to . Consider the (non-incremental) case of constructing . This is done by a traversal of from all initial states, where if and . is a product automaton but without the reachability requirement. This suggests that the way to update when a transition is added to , is to do a traversal from all states of such that . Also, it is checked if induces any non-blocking states in (lines 1-3 of Algorithm 2). The test is performed by computing the set of non-blocking states of (line 1) such that has and is obtained by a transition from . If is empty then the transition of is discarded and the procedure stops (line 3). Otherwise, the product automaton is updated recursively to add all states that become reachable because of the states in . The recursive procedure is performed from each state in as follows: if a state (line 7) is not in , then it is added to together with all its outgoing transitions (line 10) and the recursive procedure continues from the outgoing states of ; if is in then the traversal stops, but its outgoing transitions are still added to (line 14). The incremental construction of has the same overall complexity as constructing from the final and , because the recursive procedure just performes traversals that do not visit states already in . Thus, we focus our complexity analysis on the next step of the incremental search algorithm.

Input: -- product automaton
Input: -- Büchi automaton
Input: – new transition in
Output: Boolean value – indicates if was modified
1 non-blocking if  then
2        while  do
3               foreach  do
4                      if  then
5                            
6                     else if  then
7                            
8                     
9              
10       updateSCC(, , ) return True
return False
Algorithm 2 Incremental Search for a Satisfying Run

The second part of the incremental search procedure is concerned with maintaining the strongly connected components (SCCs) of (line 14 of Algorithm 2) as new transitions are added (these are stored in in Algorithm 2). To incrementally maintain the SCCs of the product automaton, we employ the soft-threshold-search algorithm presented in [10]. The algorithm maintains a topological order of the super-vertices corresponding to each SCC. When a new transition is added to , the algorithm proceeds to re-establish a topological order and merges vertices if new SCCs are formed. The details of the algorithm are presented in [10]. The authors also offer insight about the complexity of the algorithm. They show that, under a mild assumption, the incremental algorithm has the best possible complexity bound.

Incrementally maintaining and its SCCs yields a quick way to check if a trajectory of satisfies (line 4 of Algorithm 1). The next theorem establishes the overall complexity of Algorithm 2.

Theorem IV.1

The execution time of the incremental search algorithm 2 is , where is the number of transitions added to in Algorithm 1.

Remark IV.2

First, note that the execution time of the incremental procedure is better by a polynomial factor than naively running a linear-time SCC algorithm at each step, since this will have complexity . The algorithm presented in [10] improves the previously best known bound by a logarithmic factor (for sparse graphs). The proof exploits the fact that the “sparseness” (metric) property we defined implies a topological sparseness, i.e., is a sparse graph.

{proof}

The proof of the theorem is based on the analysis from [10] of incremental SCC algorithms. Haeupler et.al. show that any incremental algorithm that satisfies a “local” property must take at least time, where is the number of nodes in the graph and is the number of edges. The “local” property is a mild assumption that restricts the algorithm to reorder only vertices that are affected by the addition of an edge. This implies that the incremental SCC algorithm has the best possible complexity bound, in asymptotic sense, if and only if the graph is sparse. A graph is sparse if the the number of edges is asymptotically the same as the number of nodes, i.e. . What we need to show is that the transition system generated by Algorithm 1 is sparse. Note that although we run the SCC algorithm on the product automaton, the asymptotic execution time is not affected by analyzing the transition system instead of the product automaton, because the Büchi automaton is fixed. This follows from and .

Intuitively, the underlying graph of is sparse, because the states were generated “far” from each other. When a new state is added to , it will be connected to other states that are at least and at most distance away. Also, all states in are at least distance away from each other. This implies that there is a bound on the density of states. This bound is related to the kissing number [20]. The kissing number is the maximum number of non-overlapping spheres that touch another given sphere. Using this intuition, the problem of estimating the maximum number of neighbors of a state can be restated as a sphere packing problem. Given a state , each neighbor can be thought of as a sphere with radius and center belonging to the volume delimited by two spheres centered at and with radii and , respectively. Since, for some it follows, that there will be only a finite number of spheres which can be placed inside the described volume. Thus there is a finite bound on the number of neighbors a state can have, which depends only on the dimension and shape of the configuration space and the volume between two concentric spheres of radii and , respectively.

Remarks IV.3

The bound on the number of neighbors can become very large as the dimension of the configuration space increases.

As we have seen in the proof, under the “local” property assumption, the incremental search algorithm has the best possible complexity bound. Because we do the search for a satisfying run using a Büchi automaton, through the product automaton, and not the LTL formula directly, the proposed method is general enough to be applied in conjunction with logics (such as -calculus), which are as expressive as the languages accepted by Büchi automata. Also, we do not expect to obtain search algorithms that are asymptotically faster then the proposed one (for sparse graphs), since this would violate the lower bound obtained in [10] (assuming the “local” property).

Iv-C Probabilistic completeness

The presented RRG-based algorithm retains the probabilistic completeness of RRT, since the constructed transition system is composed of an RRT-like tree and some transitions which close cycles.

Theorem IV.4

Algorithm 1 is probabilistically complete.

{proof}

(Sketch) First we start by noting that any word in a -regular language can be represented by a finite prefix and a finite suffix, which is repeated indefinitely [1]. This is important, since this shows that a solution, represented by a transition system, is completely characterized by a finite number of states. Let us denote by the finite set of states that define a solution. It follows from the way regions are defined that we can choose a neighborhood around each state in such that the system can be steered in one step from all points in one neighborhood to all points in the next neighborhood. Thus, we can use induction to show that [KF-ACC12]: (1) there is a non-zero probability that a sample will be generated inside the neighborhood of the first state in the solution sequence; (2) if there is a state in that is inside the neighborhood of the -th state from the solution sequence, then there is a non-zero probability that a sample will be generated inside the -st state’s neighborhood. Therefore, as the number of samples goes to infinity, the probability that the transition system has nodes belonging to all neighborhoods of states in goes to 1. To finish the proof, note that we have to show that the algorithm is always able to generate samples with the desired “sparseness” property. However, recall that the bound functions must converge to 0 (as the number of states goes to infinity) fast enough such that the set of configurations for which “Far” function returns a non-empty list has non-zero measure with respect to the sampling distribution. This concludes the proof.

V Implementation and Case Studies

We implemented the algorithms presented in this paper in Python2.7. In this section, we present some examples in configuration spaces of dimensions 2, 10 and 20. In all cases, we assume for simplicity that the function is trivial, i.e., there are no actuation constraints at any given configuration. All examples were ran on an iMac system with a 3.4 GHz Intel Core i7 processor and 16GB of memory.

Case Study 1: Consider the configuration space depicted in Figure 3. The initial configuration is at . The specification is to visit regions , , and infinitely many times while avoiding regions , , and . The corresponding LTL formula for the given mission specification is

A solution to this problem is shown in Figures 3 and 4. We ran the overall algorithm 20 times and obtained an average execution time of 6.954 sec, out of which the average of the incremental search algorithm was 6.438 sec. The resulting transition system had a mean size of 51 states and 277 transitions, while the corresponding product automaton had a mean size of 643 states and 7414 transitions. The Büchi automaton corresponding to had 20 states and 155 transitions.

Fig. 3: One of the solutions corresponding to Case Study 1: the specification is to visit all the colored regions labelled (yellow), (green), (blue) and (cyan) infinitely often, while avoiding the dark gray obstacles labelled , , , . The black dots represent the states of the transition system (51 states and 264 transitions). The starting configuration of the robot (the initial state of ) is denoted by the blue circle. The red arrows represent the satisfying run (finite prefix, suffix pair) found by Algorithm 1, which is composed of 21 states from . In this case, the prefix and suffix are [0, 1, 4, 3] and [7, 10, 16, 40, 50, 40, 32, 34, 35, 43, 47, 36, 37, 29, 11, 19, 11, 8, 5, 1, 4, 3], respectively.
Fig. 4: Transition systems obtained at earlier iterations corresponding to the solution shown in Figure 3 (to be read from left to right and top to bottom). The black dots and arrows represent the state and transitions of , respectively.

Case Study 2: Consider a 10-dimensional unit hypercube configuration space. The specification is to visit regions , , infinitely many times, while avoiding region . The LTL formula corresponding to this specification is

(2)

The corresponding Büchi automaton has 9 states and 43 transitions. Regions , , and are hypercubes and their volumes are 0.03, 0.03, 0.013 and 0.012, respectively. , , are positioned in the corners of the configuration space, while is positioned in the center. In this case, the algorithm took 16.75 sec on average (20 experiments), while just the incremental search procedure for a satisfying run took 14.471 sec. The transition system had a mean size of 69 states and 1578 transitions, while the product automaton had a mean size of 439 states and 21300 transitions.

Case Study 3: We also considered a 20-dimensional unit hypercube configuration space. Two hypercube regions and were defined and the robot was required to visit both of them infinitely many times (). The overall algorithm took 7.45 minutes, while the transition system grew to 414 states and 75584 transitions. The corresponding product automaton had a size of 1145 states and 425544 transitions. This example illustrates the fact that the bound on the number of neighbors of a state in the transition system grows at least exponentially in the dimension of the configuration space.

The performed tests suggest some possible practical improvements of the execution time of the proposed algorithms. One idea is to postpone the incremental maintenance of SCCs until there is at least one final state in . We are interested in SCCs only for final states anyway, therefore there is no benefit to compute them before final states are found. A linear-time SCC algorithm can be used to initialize the corresponding incremental SCC structure when final states are found. Another important improvement may be obtained by processing transitions of in batches. At each iteration, multiple transitions are added simultaneously, thus a batch version of the incremental SCC may greatly reduce the total execution time. Note that these heuristics will not improve the asymptotic bound of the algorithm. Also, the size of the Büchi automaton has a significant impact on execution time of the procedure, even though it is fixed and does not contribute to the overall asymptotic bound.

Vi Future Work

As already suggested, future work will include integrating the presented algorithm with a local on-line sensing and planning procedure. The overall framework will ensure correctness with respect to both global and local temporal logic specifications. We will also incorporate realistic robot dynamics and environment topologies and we will perform experimental validations with air and ground vehicles in our lab.

References

  • [1] Christel Baier and Joost-Pieter Katoen. Principles of model checking. MIT Press, 2008.
  • [2] C. Belta, V. Isler, and G. J. Pappas. Discrete abstractions for robot planning and control in polygonal environments. IEEE Trans. on Robotics, 21(5):864–874, 2005.
  • [3] A. Bhatia, L.E. Kavraki, and M.Y. Vardi. Sampling-based motion planning with temporal goals. In Robotics and Automation (ICRA), IEEE International Conference on, pages 2689–2696. IEEE, 2010.
  • [4] Yushan Chen, Jana Tumova, and Calin Belta. LTL Robot Motion Control based on Automata Learning of Environmental Dynamics. In IEEE International Conference on Robotics and Automation (ICRA), Saint Paul, MN, USA, 2012.
  • [5] H. Choset, K.M. Lynch, S. Hutchinson, G. Kantor, W. Burgard, L.E. Kavraki, and S. Thrun. Principles of Robot Motion: Theory, Algorithms, and Implementations. MIT Press, Boston, MA, 2005.
  • [6] S. Cranen, J.F. Groote, and M.A. Reniers. A linear translation from LTL to the first-order modal -calculus. Technical Report 10-09, Computer Science Reports, 2010.
  • [7] Xu Chu Ding, Marius Kloetzer, Yushan Chen, and Calin Belta. Formal Methods for Automatic Deployment of Robotic Teams. IEEE Robotics and Automation Magazine, 18:75–86, 2011.
  • [8] A. Dobson and K. E. Bekris. Improving Sparse Roadmap Spanners. In IEEE International Conference on Robotics and Automation (ICRA), March 2013.
  • [9] Paul Gastin and Denis Oddoux. Fast LTL to Büchi automata translation. In Gérard Berry, Hubert Comon, and Alain Finkel, editors, Proceedings of the 13th International Conference on Computer Aided Verification (CAV’01), volume 2102 of Lecture Notes in Computer Science, pages 53–65, Paris, France, jul 2001. Springer.
  • [10] Bernhard Haeupler, Telikepalli Kavitha, Rogers Mathew, Siddhartha Sen, and Robert E. Tarjan. Incremental Cycle Detection, Topological Ordering, and Strong Component Maintenance. ACM Trans. Algorithms, 8(1):3:1–3:33, January 2012.
  • [11] S. Karaman and E. Frazzoli. Sampling-based Motion Planning with Deterministic -Calculus Specifications. In IEEE Conference on Decision and Control (CDC), Shanghai, China, December 2009.
  • [12] S. Karaman and E. Frazzoli. Sampling-based Algorithms for Optimal Motion Planning. International Journal of Robotics Research, 30(7):846–894, June 2011.
  • [13] L.E. Kavraki, P. Svestka, J.C. Latombe, and M.H. Overmars. Probabilistic roadmaps for path planning in high-dimensional configuration spaces. IEEE Transactions on Robotics and Automation, 12(4):566–580, 1996.
  • [14] M. Kloetzer and C. Belta. A fully automated framework for control of linear systems from temporal logic specifications. IEEE Transactions on Automatic Control, 53(1):287–297, 2008.
  • [15] H. Kress-Gazit, G. E. Fainekos, and G. J. Pappas. Where’s Waldo? Sensor-based temporal logic motion planning. In IEEE International Conference on Robotics and Automation, pages 3116–3121, 2007.
  • [16] S. M. LaValle. Planning Algorithms. Cambridge University Press, Cambridge, U.K., 2006. Available at http://planning.cs.uiuc.edu/.
  • [17] S. M. LaValle and J. J. Kuffner. Randomized kinodynamic planning. In IEEE International Conference on Robotics and Automation, pages 473–479, 1999.
  • [18] S. R. Lindemann and S. M. LaValle. Simple and Efficient Algorithms for Computing Smooth, Collision-Free Feedback Laws Over Given Cell Decompositions. International Journal of Robotics Research, 28(5):600–621, 2009.
  • [19] Alphan Ulusoy, Michael Marrazzo, Konstantinos Oikonomopoulos, Ryan Hunter, and Calin Belta. Temporal Logic Control for an Autonomous Quadrotor in a Nondeterministic Environment. In IEEE International Conference on Robotics and Automation (ICRA), 2013.
  • [20] Kissing Number Problem, February 2013.
  • [21] T. Wongpiromsarn, U. Topcu, and R. M. Murray. Receding Horizon Temporal Logic Planning for Dynamical Systems. In Conference on Decision and Control (CDC) 2009, pages 5997 –6004, 2009.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
101494
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description