MAPS 2 : Multi-robot autonomous motion planning under signal temporal logic specifications

Abstract

This article presents MAPS²: a distributed algorithm that allows multi-robot systems to deliver coupled tasks expressed as Signal Temporal Logic (STL) constraints. Classical control theoretical tools addressing STL constraints either adopt a limited fragment of the STL formula or require approximations of min/max operators. Meanwhile, works maximising robustness through optimisation-based methods often suffer from local minima, thus relaxing any completeness arguments due to the NP-hard nature of the problem. Endowed with probabilistic guarantees, MAPS² provides an autonomous algorithm that iteratively improves the robots’ trajectories. The algorithm selectively imposes spatial constraints by taking advantage of the temporal properties of the STL. The algorithm is distributed in the sense that each robot calculates its trajectory by communicating only with its immediate neighbours as defined via a communication graph. We illustrate the efficiency of MAPS² by conducting extensive simulation and experimental studies, verifying the generation of STL satisfying trajectories.

Keywords

mobile manipulation autonomy for mobility and manipulation path planning for manipulators manipulation and grasping path planning for multiple mobile robots or agents multiple and distributed systems constrained motion planning planning and simulation task and motion planning

Introduction

Autonomous robots can solve significant problems when provided with a set of guidelines. These guidelines can be derived from either the physical constraints of the robot, such as joint limits, or imposed as human-specified requirements, such as pick-and-place objects. An efficient method of imposing such guidelines is by using logic-based tools, which enable reasoning about the desired behaviour of robots. These tools help us describe the behaviour of a robot at various levels of abstraction, such as interactions between its internal components to the overall high-level behaviour of the robot (Lamport, 1983). This strong expressivity helps us efficiently encode complex mission specifications into a logical formula. Recent research has focused on utilising these logic-based tools to express requirements on the behaviour of robots. Once these requirements are established, algorithms are developed to generate satisfying trajectories. Such is the focus of our work.

Examples of logic-based tools include formal languages, such as Linear Temporal Logic (LTL), Metric Interval Temporal Logic (MITL), and Signal Temporal Logic (STL). The main distinguishing feature between these logics is their ability to encode time. While LTL operates in discrete-time and discrete-space domain, MITL operates in the continuous-time domain but only enforces qualitative space constraints. On the other hand, STL allows for the expression of both qualitative and quantitative semantics of the system in both continuous-time and continuous-space domains (Maler and Nickovic, 2004). STL thus provides a natural and compact way to reason about a robot’s motion since it operates in a continuously evolving space-time environment. Additionally, STL is accompanied by a robustness metric which allows us to determine the extent of satisfaction compared to only absolute satisfaction (Donzé, 2013).

Another important property of autonomous robots is their ability to coordinate and work in teams. The use of multiple robots is often necessary in situations where a single robot is either insufficient, the task is high-energy demanding, or unable to physically perform certain tasks. However, multi-robot systems present their own set of challenges, such as communication overload, the need for a central authority for commands, and high computational demands. The challenge, therefore, is to derive solutions for multi-robot problems utilising logic-based tools, ensuring the achievement of specified high-level behaviour.

In this article, we propose MAPS² – Multi-Robot Autonomous Motion Planning under Signal Temporal Logic Specifications – to address the multi-robot motion-planning problem subject to coupled STL constraints. The algorithm encodes these constraints into an optimisation function and selectively activates them based on the temporal requirements of the STL formula. While doing so, each robot only communicates with its neighbours and iteratively searches for STL satisfying trajectories. The algorithm ensures distributed trajectory generation to satisfy STL formulas that consist of coupled constraints for multiple robots. The article’s contributions are summarised in the following attributes:

• The algorithm’s effectiveness lies in its ability to distribute STL planning for multiple robots and in providing a mechanism to decouple the STL formula among robots, thereby facilitating the distribution of tasks.

• As opposed to previous work, it covers the entire STL formula and is not limited to a smaller fragment. It reduces conservatism by eliminating the need for approximations of max/min operators and samples in continuous time to avoid abstractions.

• It incorporates a wide range of coupled constraints (both linear and nonlinear) into the distributed optimisation framework, enabling the handling of diverse tasks such as pick-and-place operations and time-varying activities like trajectory tracking.

• We present extensive simulation and hardware experiments that demonstrate the execution of complex tasks using MAPS².

Additionally, the algorithm presented is sound, meaning that it produces a trajectory that meets the STL formula and is probabilistically complete, meaning that it will find such a trajectory if one exists.

In our prior study (Sewlia et al., 2023), we addressed the STL motion-planning problem for two coupled agents. There, we extended the conventional Rapidly exploring Random Trees (RRT) algorithm to sample in both the time and space domains. Our approach incrementally built spatio-temporal trees through which we enforced space and time constraints as specified by the STL formula. The algorithm employed a sequential planning method, wherein each agent communicated and waited for the other agent to build its tree. In contrast, the present work addresses the STL motion-planning problem for multiple robots. Here, our algorithm adopts a distributed optimisation-based approach, where spatial and temporal aspects are decoupled to satisfy the STL formula. Instead of constructing an incremental tree, as done in the previous work, we introduce a novel metric called the validity domain and initialise the process with an initial trajectory. In the current research, we only incorporate the STL parse tree and the Satisfaction variable tree from our previous work. Additionally, we present experimental validation results and introduce a novel STL verification architecture.

The rest of the paper is organised as follows. The related work is presented next. Then preliminaries and problem formulation are discussed, followed by the decomposition of the STL formula into temporal and spatial constraints. Next, the main algorithm MAPS² with its analyses is presented. Afterwards, simulations of various robotics tasks are shown, followed by experimental validation on a real multi-robot setup. Finally, the conclusion is presented.

Related work

In the domain of single-agent motion planning, different algorithms have been proposed to generate safe paths for robots. Sampling-based algorithms, such as CBF-RRT (Yang et al., 2019), have achieved success in providing a solution to the motion-planning problem in dynamic environments. However, they do not consider high-level complex mission specifications. Works that impose high-level specifications in the form of LTL, such as Ayala et al. (2013); Bhatia et al. (2010); Fainekos et al. (2009); Vasile and Belta (2013), resort to a hybrid hierarchical control regime resulting in abstraction and explosion of state-space. While a mixed-integer program can encode this problem for linear systems and linear predicates (Wolff et al., 2014), the resulting algorithm has exponential complexity, making it impractical for high-dimensional systems, complex specifications, and long duration tasks. To address this issue, Kurtz and Lin (2022) propose a more efficient encoding for STL to reduce the exponential complexity in binary variables. Additionally, Lindemann and Dimarogonas (2017) introduce a new metric, discrete average space robustness, and composes a Model Predictive Control (MPC) cost function for a subset of STL formulas.

In multi-agent temporal logic control, works such as Verginis and Dimarogonas (2018) and Kress-Gazit et al. (2009) employ workspace discretisation and abstraction techniques, which we avoid in this article due to it being computationally demanding. Some approaches to STL synthesis involve using mixed-integer linear programming (MILP) to encode constraints, as previously explored in Belta and Sadraddini (2019), Raman et al. (2014), and Sadraddini and Belta (2015). However, MILPs are computationally intractable when dealing with complex specifications or long-term plans because of the large number of binary variables required in the encoding process. The work in Sun et al. (2022) encodes a new specification called multi-agent STL (MA-STL) using mixed-integer linear programs (MILP). However, the predicates here depend only on the states of a single agent, can only represent polytope regions, and finally, temporal operations can only be applied to a single agent at a time. In contrast, this work explores coupled constraints between robots and predicates are allowed to be of nonlinear nature.

As a result, researchers have turned to transient control-based approaches such as gradient-based, neural network-based, and control barrier-based methods to provide algorithms to tackle the multi-robot STL satisfaction problem (Kurtz and Lin, 2022). Such approaches, at the cost of imposing dynamical constraints on the optimisation problem, often resort to using smooth approximations of temporal operators at the expense of completeness arguments or end-up considering only a smaller fragment of the syntax (Lindemann et al., 2017; Charitidou and Dimarogonas, 2021; Chen and Dimarogonas, 2022; Lindemann and Dimarogonas, 2018). STL’s robust semantics are used to construct cost functions to convert a synthesis problem to an optimisation problem that benefits from gradient-based solutions. However, such approaches result in non-smooth and non-convex problems and solutions are prone to local minima (Gilpin et al., 2020). In this work, we avoid approximations and consider the full expression of the STL syntax. The proposed solution adopts a purely geometrical approach to the multi-robot STL planning problem. Our current focus is directed towards the planning problem, specifically the generation of trajectories that fulfil STL constraints, rather than the dynamical constraints or the precise control techniques used to execute the trajectory.

Notations: The set of natural numbers is denoted by $N$ and the set of real numbers by $R$ . With $n \in N$ , $R^{n}$ is the set of n-coordinate real-valued vectors and $R_{+}^{n}$ is the set of real n-vector with non-negative elements. The cardinality of a set A is denoted by |A|. If $a \in R$ and $[b, c] \in R^{2}$ , the Kronecker sum is defined as $a \oplus [b, c] = [a + b, a + c] \in R^{2}$ . We further define the Boolean set as $B = {⊤, ⊥}$ (True, False). The acronym DOF stands for degrees of freedom.

Preliminaries and problem formulation

In this section, we start by introducing STL and STL parse tree, followed by the problem formulation.

Signal Temporal Logic (STL)

Let $x : R_{+} \to R^{n}$ be a continuous-time signal. Signal temporal logic (Maler and Nickovic, 2004) is a predicate-based logic with the following syntax:

φ = ⊤ | μ^{h} | \neg φ | φ_{1} U_{[a, b]} φ_{2} | φ_{1} \land φ_{2}

(1)

where φ₁, φ₂ are STL formulas and

U_{[a, b]}

encodes the operator until, with 0 ≤ a < b < ∞; μ^h is a predicate of the form

μ^{h} : R^{n} \to B

defined by means of a vector-valued predicate function

h : R^{n} \to R

μ^{h} = \{\begin{cases} ⊤ & h (x (t)) \leq 0 \\ ⊥ & h (x (t)) > 0 \end{cases} .

(2)

The satisfaction relation (x, t)⊧φ indicates that signal x satisfies φ at time t and is defined recursively as follows:

\begin{array}{l} (x, t) ⊧ μ^{h} & \Leftrightarrow h (x (t)) \leq 0 \\ (x, t) ⊧ \neg φ & \Leftrightarrow \neg ((x, t) ⊧ φ) \\ (x, t) ⊧ φ_{1} \land φ_{2} & \Leftrightarrow (x, t) ⊧ φ_{1} \land (x, t) ⊧ φ_{2} \\ (x, t) ⊧ φ_{1} U_{[a, b]} φ_{2} & \Leftrightarrow \exists t_{1} \in [t + a, t + b] s.t. (x, t_{1}) ⊧ φ_{2} \\ \land \forall t_{2} \in [t, t_{1}], (x, t_{2}) ⊧ φ_{1} . \end{array}

We also define the operators disjunction, eventually, and always as φ₁ ∨ φ₂ ≡ ¬(¬φ₁ ∧¬φ₂),

F_{[a, b]} φ \equiv ⊤ U_{[a, b]} φ

, and

G_{[a, b]} φ \equiv \neg F_{[a, b]} \neg φ

, respectively. Each STL formula is valid over a time horizon defined as follows.

Definition 1

(Madsen et al., 2018). The time horizon th(φ) of an STL formula φ is recursively defined as

t h (φ) = \{\begin{cases} 0, & if φ = μ \\ t h (φ_{1}), & if φ = \neg φ_{1} \\ \max {t h (φ_{1}), t h (φ_{2})}, & if φ = φ_{1} \land φ_{2} \\ b + \max {t h (φ_{1}), t h (φ_{2})}, & if φ = φ_{1} U_{[a, b]} φ_{2} . \end{cases}

(3)

In this work, we consider only time bounded temporal operators, that is, when th(φ) < ∞. In the case of unbounded STL formulas, it is only possible to either falsify an always operator or satisfy an eventually operator in finite time, thus we consider only bounded time operators. Next, we state a common assumption regarding the STL formula.

Assumption 1

The STL formula is in positive normal form, that is, it does not contain the negation operator.

The above assumption does not cause any loss of expression of the STL syntax (1). As shown in Sadraddini and Belta (2015), any STL formula can be written in positive normal form by moving the negation operator to the predicate.

STL parse Tree

An STL parse tree is a tree representation of an STL formula (Sewlia et al., 2023). It can be constructed as follows:

• Each node is either a temporal operator node ${G_{I}, F_{I}}$ , a logical operator node {∨, ∧, ¬}, or a predicate node {μ^h}, where $I \subset R$ is a closed interval;

• temporal and logical operator nodes are called set nodes;

• a root node has no parent node and a leaf node has no child node. The leaf nodes constitute the predicate nodes of the tree.

A path in a tree is a sequence of nodes that starts at a root node and ends at a leaf node. The set of all such paths constitutes the entire tree. A subpath is a path that starts at a set node and ends at a leaf node; a subpath could also be a path. The resulting formula from a subpath is called a subformula of the original formula. In the following, we denote any subformula of an STL formula φ by $\bar{φ}$ . Each set node is accompanied by a satisfaction variable $τ : \bar{φ} \to {+ 1, - 1}$ and each leaf node is accompanied by a predicate variable π = μ^h where h is the corresponding predicate function. A signal x satisfies a subformula $\bar{φ}$ if τ = +1 corresponding to the set node where the subpath of $\bar{φ}$ begins. Similarly, τ(root(φ)) = +1 ⇔ (x, t) ⊧ φ where root is the root node of φ. An analogous tree of satisfaction and predicate variables can be drawn, called satisfaction variable tree. The satisfaction variable tree borrows the same tree structure as the STL parse tree. Each set node from the STL parse tree maps uniquely to a satisfaction variable τ_i and each leaf node maps uniquely to a predicate variable π_i, where i is an enumeration of the nodes in the satisfaction variable tree. An example of construction of such trees is shown below.

Example 1

The STL parse tree and the satisfaction variable tree for the STL formula

φ = F_{I_{1}} (μ^{h_{1}} \lor G_{I_{2}} (μ^{h_{2}})) \land G_{I_{3}} F_{I_{4}} (μ^{h_{3}}) \land G_{I_{5}} (μ^{h_{4}}) .

(4)

are shown in Figure 1. From the trees, one obtains the implications

τ_{2} = + 1 \Rightarrow (x, t) ⊧ F_{I_{1}} (μ^{h_{1}} \lor G_{I_{2}} (μ^{h_{2}}))

, and

τ_{7} = + 1 \Rightarrow (x, t) ⊧ G_{I_{5}} (μ^{h_{4}})

Problem formulation

We consider a team of N robots, where each robot has state $x_{i} \in W_{i} \subset R^{n_{i}}$ , i ∈ {1, …, N} and n_i is the number of degrees of freedom of robot i. The overall state vector is then $x ≔ {[x_{1}^{⊤} \dots x_{N}^{⊤}]}^{⊤}$ evolving in a workspace $W = W_{1} \times \dots \times W_{N}$ and we denote by n = n₁ + ⋯ + n_N the number of degrees of freedom of the multi-robot system. We consider the STL formula of the form (1) with a total of K predicates,

μ^{h^{(k)}} = \{\begin{cases} ⊤ & h^{(k)} (x (t)) \leq 0 \\ ⊥ & h^{(k)} (x (t)) > 0 \end{cases}, k = 1, \dots, K .

(5)

Before we present the problem statement, we will introduce the multi-robot STL notation and the communication structure of the multi-robot system. In this direction, define a support set for each predicate function h^(k)(x) that captures all the robots upon which the predicate function imposes constraints. Define a projection matrix

E_{i} \in R^{n \times n_{i}}

such that

E_{i}^{⊤} x = x_{i}

. The matrix E_i takes the form,

E_{i} = [\begin{matrix} 0_{n_{1}} \\ ⋮ \\ I_{n_{i}} \\ ⋮ \\ 0_{n_{N}} \end{matrix}] \in R^{n \times n_{i}},

that is,

E_{i} v = {[\begin{matrix} 0, \dots, 0, v, 0 \dots, 0 \end{matrix}]}^{⊤}

inserts any

v \in R^{n_{i}}

at the i-th position of the vector. The support set is then defined for each predicate function h^(k) as

\begin{array}{l} S_{k} ≔ {i \in I | \exists x \in R^{n}, v \in R^{n_{i}}, ϵ > 0 \\ : h^{(k)} (x + ϵ E_{i} v) \neq h^{(k)} (x)} . \end{array}

The support set thus captures all robots i for which some perturbation confined to their own state x_i can change the value of the predicate function h^(k). If a predicate function h^(k) imposes constraints on the states of multiple robots, that is, |S_k| ≥ 2, then we say that the predicate function is coupled.

Example 2

For an STL formula φ = (‖x₁ − x₂‖ > 5) ∧ (‖x₂ − x₃‖ < 2), h⁽¹⁾ = 5 − ‖x₁ − x₂‖ and h⁽²⁾ = ‖x₂ − x₃‖ − 2. Then S₁ = {1, 2} and S₂ = {2, 3}.

Let K_c ≤ K denote the number of coupled predicate functions, and let these be indexed as $h_{j}^{c}$ , where j ∈ {1, …, K_c}. For each j, there exists an index k_j ∈ {1, …, K} such that $h_{j}^{c} = h^{(k_{j})}$ ; let $S_{k_{j}} \subseteq {1, \dots, N}$ denote the support set of $h_{j}^{c}$ , that is, the set of robots whose states appear in $h_{j}^{c}$ . Each robot $i \in S_{k_{j}}$ then uses a local copy $h_{i, j}^{c} ≔ h_{j}^{c}$ . This local copy is provided to the robots manually offline prior the start of the algorithm. The robots can also obtain the functions $h_{i, l}^{d}$ and $h_{i, j}^{c}$ that are coupled to their own states directly from φ. This could, for example, be done by defining a regular expression(regex) pattern and extracting predicate functions that involve the states x_i (Goyvaerts, 2016).

Next, let L_i be the number of independent predicate functions that involve only the states of robot i, with $\sum_{i = 1}^{N} L_{i} = K - K_{c}$ . Such predicate functions are indexed as $h_{i, l}^{d}$ , i ∈ {1, …, N} and l ∈ {1, …, L_i}.

Let $Π_{k_{j}}$ be the projection that keeps the indicated state components of the robots in $S_{k_{j}}$ only, that is, $Π_{k_{j}} x ≔ {E_{m}^{⊤} x | m \in S_{k_{j}}}$ . The predicate function constraints for each robot i are then defined as follows:

h_{i, l}^{d} (x_{i}) \leq 0 and h_{i, j}^{c} (Π_{k_{j}} x) \leq 0

(6)

for all i ∈ {1, …, N}, l ∈ {1, …, L_i} and

j \in {1, \dots, K_{c} | i \in S_{k_{j}}}

. The coupled predicate functions

h_{i, j}^{c}

can reflect physical interactions between the robots if the constraint is such, for example, if

h_{i, j}^{c}

specifies an obstacle avoidance constraint or an object handover task.

Example 3

Consider the STL formula,

\begin{array}{l} φ = (‖ x_{1} - x_{2} ‖ < 1) & \land (‖ x_{2} - x_{3} ‖ < 1) \\ (‖ x_{3} - x_{4} ‖ < 1) & \land (‖ x_{4} - x_{1} ‖ < 1) \\ (‖ x_{1} ‖ < 1) & \land (‖ x_{2} - x_{3} - x_{4} ‖ < 1) \\ (‖ x_{2} ‖ < 1) & \land (‖ x_{5} ‖ < 1) \end{array}

For the above STL formula, K = 8 and K_c = 5. The number of independent predicates for each robot are L₁ = 1, L₂ = 1, L₃ = L₄ = 0 and L₅ = 1. Table 1 depicts the labelled predicates for the above STL formula. The subscript i in the labels of the predicate functions

h_{i, l}^{d}

and

h_{i, j}^{c}

specifies the robot responsible for the predicate function.

Now we are ready to define the communication structure of the multi-robot system, which is dictated by a graph. Let the communication graph be given by G = (V, E) where V is the set of vertices corresponding to the indices of the robots and E is the set of edges. In particular, the edge (i, j) ∈ E indicates that robot i can communicate with robot j as the subsequent assumption states.

Table 1.

Labelled predicates for the example STL formula.

‖x₁ − x₂‖ − 1	$h_{1,1}^{c}, h_{2,1}^{c}$
‖x₂ − x₃‖ − 1	$h_{2,2}^{c}, h_{3,1}^{c}$
‖x₃ − x₄‖ − 1	$h_{3,2}^{c}, h_{4,1}^{c}$
‖x₄ − x₁‖ − 1	$h_{4,2}^{c}, h_{1,2}^{c}$
‖x₁‖ − 1	$h_{1,1}^{d}$
‖x₂ − x₃ − x₄‖ − 1	$h_{2,3}^{c}, h_{3,3}^{c}, h_{4,3}^{c}$
‖x₂‖ − 1	$h_{2,1}^{d}$
‖x₅‖ − 1	$h_{5,1}^{d}$

Assumption 2

If (i, j) ∈ E, then robots i and j can continuously communicate with each other.

We further assume that, every coupled predicate function induces an edge, ensuring that all state variables needed to compute the predicate function are locally available for each robot.

Assumption 3

If there exists k ∈ {1, …, K} such that i, j ∈ S_k, for i ≠ j, then (i, j) ∈ E.

Note that the aforementioned assumption implies that the graph is undirected, that is, (i, j) ∈ E implies (j, i) ∈ E. Additionally, based on G, the neighbourhood set $N_{i}$ of a robot i is defined as $N_{i} = {j \in V | (i, j) \in E}$ . We also assume that G is static, meaning that no new vertices are added and no edges are created or deleted. With the above assumptions, we are ready to define the distributed information flow:

Definition 2

An algorithm is called distributed, if it can be executed individually by each robot i (a local version of the algorithm) by using only information from its neighbours $N_{i}$ .

This definition of distributed algorithm does not allow for any global information sharing among robots that are not neighbours with each other, thus a central computer cannot evaluate an STL formula. For example, consider the STL formula:

φ = (‖ x_{1} - x_{2} ‖ \leq 1) \land (‖ x_{2} - x_{3} ‖ \leq 1)

where x₁, x₂, and x₃ are the states of robot 1, 2, and 3 respectively. Then, Assumption 3 allows for a communication link between robot 1 and robot 2, and between robot 2 and robot 3. A distributed algorithm, in the sense of our work, does not allow for communication between robot 1 and robot 3.

We are now ready to formally state the problem addressed in this paper.

Problem 1. Given an STL formula φ that specifies tasks on a multi-robot system with N robots, design a distributed algorithm to find continuous time-varying trajectories $y_{i} : [0, t h (φ)] \to W_{i}$ , starting at an initial configuration y_i(0) = x_i(0), such that (y, t) ⊧ φ, ∀t ∈ [0, th(φ)] with $y ≔ {[y_{1}^{⊤}, y_{2}^{⊤}, \dots, y_{N}^{⊤}]}^{⊤}$ .

It should be noted that we do not currently address the closed-loop stability of the underlying multi-robot system. Instead, we focus on the trajectory generation aspect and rely on existing low-level control approaches to track the generated trajectories. For more information, see Remark 3. The above problem is addressed assuming that at least one such solution exists. This will help us provide probabilistic completeness guarantees later on. Formally, we state the following assumption:

Assumption 4

There exists at least one y such that (y, t) ⊧ φ.

STL formula decomposition

In this section, we present how to retrieve spatial and temporal constraints from a given STL formula φ.

Spatial constraints

In Section ‘Problem Formulation', we provisioned each predicate function h^(k)(x) appearing in the STL formula φ over the complete multi-robot system to the corresponding robot i, denoting them as $h_{i, l}^{d}$ and $h_{i j}^{c}$ , depending om whether the robot is responsible for an independent or a coupled task.

For robot i, cast the constraints (6) into the cost function Fⁱ as

F^{i} ≔ \sum_{l = 1}^{L_{i}} \frac{1}{2} \max {(0, h_{i, l}^{d})}^{2} + \sum_{\begin{array}{c} j \in {1, \dots, K_{c}} \\ : i \in S_{j} \end{array}} \frac{1}{2} \max {(0, h_{i, j}^{c})}^{2}

(7)

Observe that

F^{i} : W \to R_{+}

and Fⁱ = 0 if and only if all the constraints in (6) are satisfied. Then, enforcing conditions (6) is equivalent to finding x_i for a given

x_{j} (j \in N_{i})

such that Fⁱ = 0. This problem can be posed as

\min_{x_{i} \in W_{i}} F^{i}

(8)

whose solution

x_{i}^{⋆}

satisfies Fⁱ(x^⋆) = 0. In the cost function (7), to reduce computational costs, we only minimise h^(k)(x(t)) when h^(k)(x(t)) > 0 while leaving h^(k)(x(t)) ≤ 0 unchanged. This leads us to minimise: Fⁱ = max(0, h^(k)(x(t))), which results in Fⁱ = h^(k)(x(t)) when h^(k)(x(t)) > 0 and Fⁱ = 0 when h^(k)(x(t)) ≤ 0. Additionally, squaring the function penalises larger errors more than smaller ones. Other cost functions that enforce h^(k)(x(t)) ≤ 0 within the validity domain can also be considered. For example, the cost function

F^{i} ≔ \sum_{l = 1}^{L_{i}} {h_{i, l}^{d}}^{2} + \sum_{j} {h_{i, j}^{c}}^{2}

, j ∈ {1, …, K_c}: i ∈ S_j could also be used. However, it was not our first choice, as we aimed to minimise h^(k)(x(t)) only when h^(k)(x(t)) > 0, whereas this cost function would attempt to minimise h^(k)(x(t)) regardless of its sign. Additionally, our formulation is general and works for any type of STL formula as any type of objectives can be encoded in the STL formula, from which, we can extract the predicate functions and minimise the function Fⁱ.

The solution for finding the global minimum of a non-convex function is a subject of extensive research. We argue that employing gradient descent with random initialisations is adequate for addressing this problem, particularly since the initialisations are sampled from a compact set, $W_{i}$ . Furthermore, using the knowledge that the minimum of the function, Fⁱ(x) = 0, acts as a stopping criterion and facilitates the attainment of the desired solution. We direct readers to the seminal work in Nedic and Ozdaglar (2009), which presents a distributed gradient descent algorithm for multi-agent systems. Additionally, under certain assumptions, Daneshmand et al. (2020) demonstrate that gradient descent with a constant step size avoids entrapment at saddle points. Gradient descent is also shown to efficiently manage most reach-avoid constraints without the need for re-initialisation, given that such constraints are expressible using norms. For our application of gradient descent, we utilise the function presented in Function 1. Function 1 implements the gradient descent

algorithm as described in Algorithm 9.3 of Boyd and Vandenberghe (2004), utilising initial conditions x_i, step size δ, maximum number of iterations L′, and activation variables λ_ij as inputs. The activation variables are presented later in Function 3. It returns the optimised states $x_{i}^{⋆}$ as output. In line 4, the function GradientComputation() computes the gradient, either analytically or numerically. The stopping criterion is met either when a feasible state is determined, indicated by Fⁱ = 0, or when the iteration count exceeds L′ (line 4), which may occur due to multiple conflicting predicates active within Fⁱ. This situation arises because the algorithm accounts for the possibility that the eventually operator may not be satisfied at every sampled point within its validity domain. This occurs, for example, if $φ = F_{[0,5]} G_{[0,5]} (g^{(1)} (x) \leq ϵ_{1}) \land G_{[5,10]} (g^{(2)} (x) \leq ϵ_{2})$ , and there is a conflict between h⁽¹⁾(x) ≔ g⁽¹⁾(x) − ϵ₁ and h⁽²⁾(x) ≔ g⁽²⁾(x) − ϵ₂ (i.e. $∄ x_{i}^{⋆} \in W_{i}$ such that $h^{(1)} (x) (x_{i}^{⋆}) \leq 0 \land h^{(2)} (x) (x_{i}^{⋆}) \leq 0$ ). In such cases, it becomes necessary for h⁽¹⁾(x) ≤ 0 to be true exclusively within the interval [0,5][s] and for h⁽²⁾(x) ≤ 0 to be true exclusively within the interval [5,10][s].

The robots solve their respective optimisation problem cooperatively in a distributed manner via inter-neighbour communication. This makes the problem distributed, as every interaction between robots is part of the communication graph. Given the nature of the optimisation problem, there is a trade-off between robustness and optimisation performance since x^⋆ converges to the boundaries imposed by the STL formula constraints, making it vulnerable to potential perturbations. However, introducing a slack variable into the equation can enhance robustness, albeit at the cost of sacrificing completeness arguments. The example below shows how to construct the optimisation functions Fⁱ.

Example 4

Consider a system with 3 agents and the corresponding states {x₁, x₂, x₃}, and let the STL formula be: φ = (‖x₁ − x₂‖ > 5) ∧ (‖x₂ − x₃‖ < 2); then, the functions Fⁱ, for i ∈ {1, 2, 3}, are

\begin{array}{l} F^{1} & = \frac{1}{2} \max {(0,5 - ‖ x_{1} - x_{2} ‖)}^{2} \\ F^{2} & = \frac{1}{2} \max {(0,5 - ‖ x_{1} - x_{2} ‖)}^{2} + \frac{1}{2} \max {(0, ‖ x_{2} - x_{3} ‖ - 2)}^{2} \\ F^{3} & = \frac{1}{2} \max {(0, ‖ x_{2} - x_{3} ‖ - 2)}^{2} . \end{array}

Now that spatial constraints are encoded into the optimisation problem, we are ready to encode temporal constraints in the following section, thus completing our STL decomposition into spatial and temporal constraints.

Temporal constraints

We now introduce the concept of validity domain, a time interval associated with every predicate and defined for every path in the STL formula. This interval represents the time domain over which each predicate applies and is defined as follows:

Definition 3

The validity domain $v d (\bar{φ})$ of each path $\bar{φ}$ of an STL formula φ, is recursively defined as

v d (\bar{φ}) = \{\begin{cases} 0, & if \bar{φ} = μ^{h} \\ v d ({\bar{φ}}_{1}), & if \bar{φ} = \neg \bar{φ_{1}} \\ [a, b], & if \bar{φ} = G_{[a, b]} μ^{h} \\ a \oplus v d ({\bar{φ}}_{1}), & if \bar{φ} = G_{[a, b]} {\bar{φ}}_{1}, {\bar{φ}}_{1} \neq μ^{h} \\ t^{⋆} + T^{⋆} \oplus v d ({\bar{φ}}_{1}), & if \bar{φ} = F_{[a, b]} {\bar{φ}}_{1} \end{cases}

(9)

where

T^{⋆} ≔ {t \in [a, b] | (x, t) ⊧ F_{[a, b]} \bar{φ}}

is a time instant in [a, b] when the state x evaluated at t of a signal x(t) satisfies the eventually operator. The variable t^⋆ is initialised to 0, but takes the value t^⋆ = T^⋆ every time T^⋆ is updated and thus captures the last instance of satisfaction for the eventually operator.

The above definition of t^⋆ is necessary due to the redundancy of the eventually operator; we must ascertain the specific instances where the eventually condition is met to ensure finding a feasible trajectory. Additionally, we need to maintain the history of T^⋆ for nested temporal operators which require recursive satisfaction. The validity domain is determined for each path of an STL formula in a hierarchical manner, beginning at the root of the tree, and each path has a distinct validity domain. The number of leaf nodes in an STL formula is equal to the total number of validity domains. In Definition 3, we do not include the operators ∧ and ∨ because they do not impose temporal constraints on the predicates and thus inherit the validity domains of their parent node. If there is no parent node, operators ∧ and ∨ inherit the validity domains of their child node.

Remark 1

The validity domain is specially defined in the following cases. If a path contains only predicates, the validity domain of μ^h is equal to the time horizon of φ (i.e. vd(μ^h) = th(φ)). Furthermore, if a path contains nested formulas with the same operators, such as $\bar{φ} = G_{[1,10]} G_{[0,2]} (\cdot)$ , then the validity domain of $\bar{φ}$ is equal to the time horizon of the path i.e. $v d (\bar{φ}) = t h (\bar{φ})$ . For example, $v d (G_{[1,10]} G_{[0,2]} (\cdot)) = t h (\bar{φ}) = [1,12]$ .

Example 5

Consider the following examples of the validity domain:

• $φ_{1} = G_{[5,10]} (g^{(1)} (x) \leq ϵ_{1})$ , then vd(φ₁) = [5, 10], which is the interval over which $μ^{h^{(1)}}$ must hold. Here $μ^{h^{(1)}}$ is the predicate corresponding to the predicate function h⁽¹⁾(x) = g⁽¹⁾(x) − ϵ₁.

• $φ_{2} = F_{[5,10]} (g^{(1)} (x) \leq ϵ_{1})$ , then t^⋆ is initialised to 0, T^⋆ ∈ [5, 10] and $v d (μ^{h^{(1)}}) = 0$ . Therefore, vd(φ₂) = T^⋆ ∈ [5, 10] is the instance when $μ^{h^{(1)}}$ must hold.

• $φ_{3} = F_{[5,10]} G_{[0,2]} (g^{(1)} (x) \leq ϵ_{1})$ , then t^⋆ is initialised to 0, T^⋆ ∈ [5, 10], $v d (G_{[0,2]} (g^{(1)} (x) \leq ϵ_{1})) = [0,2]$ . Therefore, vd(φ₃) = 0 + T^⋆ ⊕ [0, 2] = [T^⋆, T^⋆ + 2] is the interval over which $μ^{h^{(1)}}$ must hold such that φ₃ is satisfied.

• $φ_{4} = G_{[2,10]} F_{[0,5]} (g^{(1)} (x) \leq ϵ_{1})$ , then a = 2 and $v d (φ_{4}) = 2 \oplus v d (F_{[0,5]} (g^{(1)} (x) \leq ϵ_{1})) = 2 + 0 + T^{⋆}$ where T^⋆ ∈ [0, 5]. Suppose T^⋆ = 1, then vd(φ₄) = 3 is the time instance when $μ^{h^{(1)}}$ must hold. Once $μ^{h^{(1)}} = ⊤$ , then t^⋆ = T^⋆ and the new vd(φ₄) = 2 + 1 + T^⋆ where T^⋆ ∈ [0, 5].

• $φ_{5} = F_{[0,100]} G_{[5,10]} F_{[0,1]} (g^{(1)} (x) \leq ϵ_{1})$ , then t^⋆ = 0, T^⋆ ∈ [0, 100] and $v d (φ_{5}) = T^{⋆} + a \oplus v d (F_{[0,1]} (g^{(1)} (x) \leq ϵ_{1}))$ . Suppose T^⋆ = 50, then $v d (φ_{5}) = 55 \oplus v d (F_{[0,1]} (g^{(1)} (x) \leq ϵ_{1}))$ and so on.

Regarding the STL formula in equation (4), the validity domains are defined for the following paths: $F_{I_{1}} \to μ^{h^{1}}, F_{I_{1}} \to G_{I_{2}} \to μ^{h^{2}}, G_{I_{3}} \to F_{I_{4}} \to μ^{h^{3}}$ , and $G_{I_{5}} \to μ^{h^{4}} .$

We use the following notational convenience in this work: if a parent node of a leaf node of a path $\bar{φ}$ is an eventually operator we denote the corresponding validity domain by vd^F(), and, if the parent node of a leaf node of a path $\bar{φ}$ is an always operator we denote the corresponding validity domain by vd^G(). The notation vd^F() indicates that the predicate of the respective leaf node needs to hold at some instance in the said interval, and vd^G() indicates that the predicate of the respective leaf node needs to hold throughout the interval. The following lemma formalises the relation between the STL formula and its corresponding encoding as described above.

Lemma 1

Suppose $x (t) = [x_{1}^{⊤}, x_{2}^{⊤}, \dots]$ represents the states of all robots, and ${\bar{φ}}_{k}$ encompasses all subformulas associated with the STL formula φ. Let ∑_iFⁱ(x(t)) = 0 for all $t \in ⋃_{k} v d ({\bar{φ}}_{k})$ . Then, it holds that y(t) ⊧ φ.

Proof

The proof follows from the construction of the optimisation function (7) and the validity domain. Notice that if the optimisation problem (8) converges to the desired minima at Fⁱ(x) = 0, then $μ^{h_{i, l}^{d}} = ⊤$ and $μ^{h_{i, j}^{c}} = ⊤$ for all l ∈ {1, …, L_i} and j ∈ {1, …, K_c}: i ∈ S_j. Next, by definition, the validity domain is defined for the STL formula and if Fⁱ is minimised during the validity domain, then y(t) ⊧ φ.

In the next Section, we present how to integrate the validity domain with the optimisation problem in (8), completing thus the spatial and temporal integration.

Main results

In this section, we present the algorithm for generating continuous trajectories that meet the requirements of a given STL formula φ. The algorithm is executed by the robots offline in a distributed manner, in the sense that they only communicate with their neighbouring robots. The algorithm builds a tree $T_{i} = {V_{i}, E_{i}}$ for robot i where $V_{i}$ is the vertex set and $E_{i}$ is the edge set. Each vertex $z \in R_{+} \times W_{i}$ is sampled from a space-time plane. Until now, we denoted the states of robot i as x_i, but from here onward, we denote them as xⁱ.

In what follows, we give a high-level description of the algorithm. The general idea is to start with an initial trajectory that spans the time horizon of the formula th(φ), then repeatedly sample random points along the trajectory and use gradient-based techniques to find solutions that satisfy the specification at these points. More specifically, the algorithm begins by connecting the initial and final points $z_{0}^{i} = {t_{0}^{i}, x_{0}^{i}}$ and $z_{f}^{i} = {t_{f}^{i}, x_{f}^{i}}$ with a single edge $E_{i} = {(z_{0}^{i}, z_{f}^{i})}$ . The initial conditions $z_{0}^{i} = {t_{0}^{i}, x_{0}^{i}}$ depend on the robot’s initial position and time. The final conditions are chosen to be $z_{f}^{i} = {t h (φ) + ϵ, x_{f}^{i}}$ where ϵ > 0 and $x_{f}^{i} \in W^{i}$ . Let $t_{0}^{i} = 0$ and $t_{f}^{i} = t h (φ) + ϵ$ . The final states $x_{f}^{i}$ can be randomly chosen since the states in the interval [0, th(φ)] will be determined by the algorithm based on the constraints imposed by φ. The algorithm then randomly selects a time instant t⁰ ∈ [0, th(φ)] and uses linear interpolation to determine the states of each robot at that time, denoted by x⁰. The robots then solve the distributed optimisation problem (8) to find new positions x^⋆ that meet the specification at time t⁰. The algorithm then repeats this process at a user-specified time density, updating the trajectories as necessary. The result is a trajectory that asymptotically improves the task satisfaction of the STL formula.

Example 6

Before we get into the technical details, let us consider an example of 4 agents, represented by the colours blue, green, yellow and magenta, to illustrate the procedure. Suppose, at a specific instance in time, say t⁰, the STL formula requires agent 1 () and agent 2 () to be more than 6 units apart and agent 3 () and agent 4 () to be closer than 6 units, that is, for ϵ > 0,

We begin the process by connecting the initial and final points $z_{0}^{i}$ and $z_{f}^{i}$ with an initial trajectory for all agents, as shown in Figure 2(a). Each agent’s vertex set is $V_{i}$ and consists of the start and end points denoted by $z_{0}^{i}$ and $z_{f}^{i}$ respectively, while its edge set $E_{i}$ contains only one edge connecting the start and end points. From the initial trajectory, the algorithm randomly selects a point at time instance t⁰ from the entire time domain and uses linear interpolation to determine the state of each agent at that time. The agents solve (8) using the initial position x⁰ to find new position x^⋆, as seen in Figure 2(b). As shown in Figure 2(c), the distributed optimisation problem (8) is solved, resulting in a solution x^⋆, in which agent 1 and agent 2 are positioned so that they are more than 6 units apart and agent 3 and agent 4 remain undisturbed. The latter is the result of using functions of the form $1 / 2 \max {(0, h_{i, j}^{c})}^{2}$ , and since agent 3 and agent 4 already satisfy the requirements, that is, $h_{i, j}^{c} < 0$ , the function is valued 0. The newly determined positions of agents 1 and 2 are added to the tree, allowing the trajectory to be shaped to meet the requirements. The updated trajectory can be seen in Figure 2(d). This process of randomly selecting a point in time, determining the state of the agents and updating their positions is repeated for a user-defined number of times L, to ensure that the trajectory satisfies the STL formula φ throughout the time horizon.

Figure 1.

STL parse tree and satisfaction variable tree for the formula in (4).

MAPS²

The architecture of the algorithm MAPS² (short for ‘multi-robot anytime motion planning under signal temporal logic specifications’), is depicted in Figure 3. The algorithm, outlined in Algorithm 2, begins with an initial trajectory connecting $z_{0}^{i}$ and $z_{0}^{f}$ , along with a random seed and design constants as input (see lines 1-1). The random seed ensures that all robots select the same time instance. The algorithm proceeds by repeatedly sampling a time instance within the interval, interpolating states at the said time instance, applying gradient descent to minimise the function (7), and either adding or discarding the resulting optimal solution. This process is repeated until the total number of vertices, L, is reached, see lines 3-4. This is also illustrated in Figure 2.

Figure 2.

Illustration of the proposed algorithm.

These steps are implemented as follows: In line 4, the SearchSort() function separates the vertices $V_{i}$ into two sets based on their time values: one set with time values lower than t⁰ (the vertex with the highest time in this set is indexed with ‘index’), and another with values greater than t⁰ (the vertex with the lowest time in this set is indexed with ‘index + 1’). The corresponding vertices are $z_{index}^{i} = {t_{index}^{i}, x_{index}^{i}}$ and $z_{index + 1}^{i} = {t_{index + 1}^{i}, x_{index + 1}^{i}}$ . Then, the algorithm uses linear interpolation in line 4 via the function Interpolate() to obtain the vertex $z_{inter}^{i} = {t^{0}, x_{inter}^{i}}$ . This is obtained by solving for $x_{inter}^{i}$ element-wise as the solution of

x_{inter}^{i} = (\frac{x_{index + 1}^{i} - x_{index}^{i}}{t_{index + 1}^{i} - t_{index}^{i}}) (t^{0} - t_{index}^{i}) + x_{index}^{i} .

The vertex

z_{inter}^{i}

is the initial condition to solve the optimisation problem (8); and once a solution

z_{opt}^{i}

is obtained, it is added to the vertex set

V_{i}

in line 4. The edge set

E_{i}

is reorganised to include

z_{opt}^{i}

in lines 4-4.

Moreover, as a safeguard, if a solution remains undiscovered following L iterations, line 4 initiates a reset procedure. This involves setting the satisfaction variable for all eventually operators back to −1 and restarting the search. Since we assume that at least one viable solution always exists (refer to Assumption 4), the absence of a solution occurs solely when an eventually operator is satisfied at an impractical instance of time. Such an impractical instance of time affects the solution of the algorithm since there are redundancies in picking the satisfaction instance ( $x (t) ⊧ F_{[a, b]} (g^{(1)} (x) \leq ϵ_{1})$ if h⁽¹⁾(x) ≔ g⁽¹⁾(x) − ϵ₁ ≤ 0 at any single instance in [a, b]). By resetting these operators, the algorithm aims to locate a solution under feasible instances.

GradientDescent

The function is presented in Function 3 and computes the optimal value, $z_{opt}^{i}$ , by solving the problem presented in equation (8). This allows the robots to compute vertices that locally do not violate the STL formula. Once $z_{opt}^{i}$ is determined through Function 1, the satisfaction variables are updated in Function 4.

Based on the validity domain, the Function 3 determines which predicate functions are active in (7) at every sampled time instance t⁰. The Function ValidityDomain() in line 4 calculates the validity domains of each path $\bar{φ}$ based on Definition 3. Let K_i be the total number of independent and coupled predicate functions associated with robot i, a binary variable λ_ij ∈ {0, 1}, j ∈ {1, …, K_i} is assigned to determine whether a predicate function is active or not. It is set to 1 if the predicate is active and 0 otherwise. For example,

• If $φ_{1} = G_{[5,10]} (‖ x_{1} - x_{2} ‖ \leq 2)$ , then λ₁₁ = λ₂₁ = 1 whenever t⁰ ∈ [5, 10] and 0 otherwise.

• If $φ_{2} = F_{[10,15]} (‖ x_{3} ‖ \leq 5)$ , then λ₃₁ = 1 whenever t⁰ ∈ [10, 15] and 0 otherwise. Once x₃(t) ⊧ φ₂, λ₃₁ = 0 ∀t.

The indices i and j in λ_ij and vd_ij refer to robot i and the jth predicate function associated with robot i, respectively. Here j ∈ {1, …, K_i}. We distinguish three cases: if the sampled point belongs to the validity domain of a single eventually operator and/or a single always operator, λ_ij = 1. If the sampled point belongs to the validity domain of multiple eventually operators, we activate only one of them at random, that is, λ_ij = 1 only for one of them. This avoids enforcing conflicting predicates as it can happen that multiple eventually operators may not be satisfied at the same time instance (e.g. $φ = F_{[0,1]} (x > 0) \land F_{[0,1]} (x < 0)$ ); see lines 5-20.

In lines 21-34, the algorithm updates the satisfaction variable of all paths in the STL formula that impose restrictions on robot i’s states. The algorithm goes bottom-up, starting from the leaf node to the root node. First, it determines if $z_{opt}^{i}$ is the desired minimum (i.e. $F^{i} (x_{opt}^{i}) \leq 0$ ) in line 27, and in lines 30-33, the algorithm updates the satisfaction variable of all nodes in the path $\bar{φ}$ through the function SatisfactionVariable(). If $z_{opt}^{i}$ is not the desired minimum, then all the satisfaction variables of the path $\bar{φ}$ are reset to −1 in line 35. This could result from conflicting predicates at the same time instance.

SatisfactionVariable

This function, presented in Function 4, updates the satisfaction variable tree, τ. The aforementioned procedure decides if the satisfaction variable corresponding to each node listed is +1 (satisfied) or −1 (not yet satisfied). The discussion of handling disjunction operators is deferred to Section ‘MAPS²:Branch-and-Pick for Disjunctions', as they are handled differently. Considering the premise that the predicate is true, as indicated in line 27 of Function 3, we evaluate the satisfaction variable as follows:

• $F_{I}$ : The satisfaction variable of the eventually operator is updated along with t^⋆ = t⁰. This updated t^⋆ is used to determine the new validity domains in line 4 of Function 3; see Example 3 for an illustration of this procedure.

• $G_{I}$ : Unlike the eventually operator, determining $τ (G_{I})$ necessitates the computation of robustness over the entire validity domain of the operator. The function robust() uses the robust semantics of the STL presented in Maler and Nickovic (2004). Particularly, it samples a user-defined number of points in the interval ${v d}_{i j}^{G} ()$ and computes $\inf_{t \in {v d}_{i j}^{G}} h_{i, l}^{d} (x^{i} (t))$ or $\inf_{t \in {v d}_{i j}^{G}} h_{i, j}^{c} (x^{i} (t))$ . If the robustness is non-negative, indicating satisfaction of the task, the value of $τ (G_{I})$ is updated to +1.

• ∧: This set node returns the satisfaction variable as +1 since it does not impose spatial or temporal restrictions.

Branch-and-pick for disjunctions

In our approach, we address disjunctions as follows: Given an STL formula of the form φ =∨_i∈1,…,Kϕ_i, which can also be represented as φ = ∨(ϕ₁, ϕ₂, …, ϕ_K), we divide it into K individual STL formulas. The agents then run Algorithm 2 separately for each φ = ϕ_i, where i ∈ 1, …, K. For instance, consider the STL formula represented as (4)

φ = F_{I_{1}} (μ^{h_{1}} \lor G_{I_{2}} (μ^{h_{2}})) \land G_{I_{3}} F_{I_{4}} (μ^{h_{3}}) \land G_{I_{5}} (μ^{h_{4}}) .

We branch it into two STL formulas:

ϕ_{1} = F_{I_{1}} μ_{1} \land G_{I_{3}} F_{I_{4}} (μ_{3}) \land G_{I_{5}} (μ_{4})

and

ϕ_{2} = F_{I_{1}} G_{I_{2}} (μ_{2}) \land G_{I_{3}} F_{I_{4}} (μ_{3}) \land G_{I_{5}} (μ_{4})

, as illustrated in Figure 4. The search terminates when any branch of the disjunction satisfies the condition τ(root) ≠ + 1, as specified on line 3 of Algorithm 1. We acknowledge that this naive method of handling disjunctions can result in exponential growth with the addition of more operators. An alternative approach, akin to the branch-and-bound method from optimisation (Morrison et al., 2016), involves evaluating the robustness of each ϕ_i for i ∈ 1, …, K and executing MAPS² only for the formulas that show a faster increase in satisfaction. However, this strategy might necessitate a higher level of communication among robots which goes beyond their existing communication network and possibly require a central authority to coordinate task fulfilment. For example, the STL formula

φ = G_{[0,5]} (x_{1} < 5) \lor (F_{[0,5]} (| x_{2} - x_{3} | > 2)) .

comprises disjunction between

ϕ_{1} = G_{[0,5]} (x_{1} < 5)

and

ϕ_{2} = F_{[0,5]} (| x_{2} - x_{3} | > 2)

. Observe that ϕ₁ requires no inter-robot communication, while ϕ₂ necessitates communication between robots 2 and 3. In the implementation of a method akin to branch-and-bound, we would branch into two formulas, ϕ₁ and ϕ₂, and repeatedly switch between them if we observe the robustness of one formula decaying faster compared to the other. This switching must be performed by a central authority that observes the decay in robustness. If the switching is decided among the robots, then robot 1 of ϕ₁ needs to communicate the robustness decay with the network of robots 2 and 3. This requires robot 1 to establish communication with the network of robots 2 and 3 in order to decide which branch to grow, thereby necessitating communication links where none existed before. Without such a communication link, both ϕ₁ and ϕ₂ would need to be satisfied using the naive approach presented in our work. This motivates our choice to use the naive approach.

Figure 3.

Architecture of the proposed algorithm.

Analysis

In this section, we analyse the proposed algorithm and arrive at proving the probabilistic completeness.

Let the set $S \subseteq W$ be a compact set where a trajectory $y : [0, t h (φ)] \to S$ satisfies the STL formula. Along the lines of Kleinbort et al. (2019), let a trajectory y be located on the boundary of the set $S$ , the satisfiable set, dividing $W$ into a feasible set $S$ and an infeasible set $W \ S$ .

Starting with an initial linear trajectory in the augmented time-space domain, each uniformly sampled time point t⁰ corresponds to a position x_inter either in $S$ or $W \ S$ . If $x_{inter} \in S$ , we leave it unchanged as it meets the requirements. But if $x_{inter} \notin S$ , we use gradient descent to reach a point on y, since it lies on the boundary of the constraints’ set.

Next, divide the trajectory $y : [0, t h (φ)] \to S$ into L + 1 points x_k, where 0 ≤ k ≤ L and y(th(φ)) = x_f = x_L by dividing the time duration into equal intervals of δ_t. Without loss of generality, assume that the points x_k and x_k+1 are separated by δ_t in time. With Lδ_t = th(φ), the probability of sampling a point in an interval of length δ_t can be calculated as $p = \frac{δ_{t}}{t h (φ)}$ . If δ_t ≪th(φ), then p < 1/2. Denote the sequential covering class¹ of trajectory y as $Y_{δ_{t}} (x_{k})$ . The length of $Y_{δ_{t}} (x_{k})$ is δ_t in the time domain and is centred at x_k. See Figure 5 for reference.A trial is counted as successful if we sample a point t⁰ within the interval δ_t/2 on either side of x_k, that is, within $Y_{δ_{t}} (x_{k})$ . If there are L successful trials, the entire trajectory y is covered, and the motion-planning problem is solved. Consider m total samples, where m ≫ L, and treat this as m Bernoulli trials with success probability p since each sample is independent with only two outcomes. We are now ready to state the following lemma.

Figure 4.

Disjunction representation for disjunctive components using STL parse tree.

Lemma 2

Let a constant L and probability p such that $p < \frac{1}{2}$ . Further, let m represent the number of samples taken by the MAPS ² algorithm. Then, the probability that MAPS ² fails to sample a segment after m samples is at most $\frac{(m - L) p}{{(m p - L)}^{2}}$ .

Proof

The probability of not having L successful trials after m samples can be expressed as

P [X_{m} \leq L] = \sum_{k = 0}^{L - 1} (\binom{m}{k}) p^{k} {(1 - p)}^{m - k}

and according to Feller (1968), if

p < \frac{1}{2}

, we can upper bound this probability as:

P [X_{m} \leq L] \leq \frac{(m - L) p}{{(m p - L)}^{2}} .

As p and L are fixed and independent of m, the expression

\frac{(m - L) p}{{(m p - L)}^{2}}

approaches 0 with as m increases, thus completing the proof.

Next, we present a final lemma which helps us prove the probabilistic completeness of the algorithm.

Lemma 3

No sampled point x_k is falsely labelled as satisfying the STL formula φ unless it actually does.

Proof

The algorithm initiates by setting all satisfaction variables, τ, to −1, as inputs to Algorithm 2. These variables are updated in Function 4 designed for evaluating whether τ meets the satisfaction criteria. The function adjusts τ in accordance with the definition of STL operators presented in the preliminaries section, ensuring that updates accurately reflect the satisfaction status. Furthermore, the update to τ(leaf) within Function 3 (referenced at line 20) occurs only when the condition Fⁱ ≤ 0 is met. This condition indicates that all active predicates are satisfied by definition. Thus, no satisfaction variable is incorrectly updated.

Next, the paper’s final result is presented, which states that the probability of the algorithm providing an STL formula satisfying trajectory (if one exists) approaches one as the number of samples tends to infinity. This is a desirable property for sampling-based planners and such algorithms are termed probabilistically complete.

Theorem 1

Algorithm 2 is probabilistically complete.

Proof

The proof follows from Lemmas 1, 2, and 3. From Lemma 1 and Lemma 3, we know that every sample added to the trajectory satisfies the STL formula. Thus, what needs to be shown is that the algorithm samples infinitely many times and covers the entire time horizon. From Lemma 2, we know that the probability of covering the entire time horizon is 1 − P[X_m ≤ L]. Suppose the Algorithm 2 reaches J = L′ samples without finding a feasible solution, then it discards J samples as seen in line 4 of Algorithm 2. Given Assumption 4, we have J < ∞, and since J is the number of discarded samples, we also have J ≤ m where m is the total number of samples sampled so far (including the discarded ones). Thus, the probability of the trajectory satisfying the STL formula is $1 - \frac{((m - J) - L) p}{{((m - J) p - L)}^{2}}$ , which approaches one as m → ∞. Thus, the algorithm is probabilistically complete.

Remark 2

Our algorithm can be endowed in a post-processing stage with a module that smoothens the trajectory to avoid large accelerations. However, care needs to be taken since the smoothened paths may no longer satisfy the STL formula. One could also use more sophisticated approaches like B-splines to impose velocity and acceleration limits as shown in Lapandić et al. (2024).

Remark 3

At present, our approach does not incorporate kinematic or dynamic constraints. Incorporation of such constraints could be attempted by either deploying the kinodynamic version of the RRT algorithm (Webb and van Den Berg, 2012), or by using an existing low-level controller to track the generated open-loop trajectories. Some examples of such controllers include the Model Predictive Controller (Poignet and Gautier, 2000) and the input constrained Prescribed Performance Controller (Fotiadis and Rovithakis, 2024; Trakas and Bechlioulis, 2023). This incorporation is by no means straightforward but requires fusion with another type of methodological machinery that goes beyond the scope of the current work. Moreover, such controllers have been developed for a large variety of dynamical systems and hence the proposed algorithm is practical and applicable to a large class of robots.

Simulations

In this section, we present simulations of various scenarios encountered in a multi-robot system. Restrictions are imposed using an STL formula and MAPS² is utilised to create trajectories that comply with the STL formula. In the following we consider 4 agents, with δ = 0.1, η = 0.01 and L = L′ = 100. The simulations were run on an 8 core Intel^® Core^TM i7 1.9 GHz CPU with 16 GB RAM.²

Collision avoidance

We begin with a fundamental requirement in multi-robot systems: avoiding collisions. In this scenario, it is assumed that all agents can communicate or sense each other’s positions. The following STL formula is used to ensure collision avoidance in the interval 20[s] to 80[s]:

φ = G_{[20,80]} (‖ x_{i} - x_{j} ‖ \geq 1)

where {i, j} ∈ {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}. As depicted in Figure 6a, all four agents maintain a distance of at least 1 unit from each other during the interval [20,80][s]. The maximum computation time by any agent is 0.1143[s].

Figure 5.

Illustration of $Y_{δ_{t}} (x_{k})$ .

Rendezvous

The next scenario is rendezvous. We use the eventually operator to express this requirement. The STL formula specifies that agents 1 and 3 must approach each other within 1 distance unit during the interval [40,60][s] and similarly, agents 2 and 4 must meet at a minimum distance of 1 unit during the same interval. The STL formula is

φ = F_{[40,60]} (‖ x_{1} - x_{3} ‖ \leq 1 \land ‖ x_{2} - x_{4} ‖ \leq 1) .

As seen in Figure 6b, agents 1 and 3 and agents 2 and 4 approach each other within a distance of 1 unit during the specified interval. It’s worth noting that the algorithm randomly selects the specific time t^⋆ within the continuous interval [40,60][s] at which the satisfaction occurs. The maximum computation time by any agent is 0.0637[s].

Stability

The last task is that of stability, which is represented by the STL formula $F_{[a_{1}, b_{1}]} G_{[a_{2}, b_{2}]} (g^{(1)} (x) \leq ϵ_{1})$ . This formula requires that (g⁽¹⁾(x) ≤ ϵ₁) must always hold within the interval [t^⋆ + a₂, t^⋆ + b₂], where t^⋆ ∈ [a₁, b₁]. This represents stability, as it requires (g⁽¹⁾(x) ≤ ϵ₁) to always hold within the interval [t^⋆ + a₂, t^⋆ + b₂], despite any transients that may occur in the interval [a₁, t^⋆). Figure 6c presents a simulation of the following STL formula:

\begin{array}{l} φ = F_{[0,100]} G_{[0,20]} & ((1.9 \leq x_{1} \leq 2.1) \land (3.9 \leq x_{2} \leq 4.1) \\ \land (5.9 \leq x_{3} \leq 6.1) \land (7.9 \leq x_{4} \leq 8.1)) \end{array}

where t^⋆ = 63.97[s]. The maximum computation time by any agent is 0.0211[s].

Recurring tasks

The next scenario is that of recurring tasks. This can be useful when an autonomous vehicle needs to repeatedly survey an area at regular intervals, a bipedal robot needs to plan periodic foot movements, or a ground robot needs to visit a charging station at specified intervals. The STL formula to express such requirements is given by $G_{[a_{1}, b_{1}]} F_{[a_{2}, b_{2}]} (g^{(1)} (x) \leq ϵ_{1})$ , which reads as ‘beginning at a₁[s], g⁽¹⁾(x) ≤ ϵ₁ must be satisfied at some point in the interval [a₁ + a₂, a₁ + b₂][s] and this should be repeated every [b₂ − a₂][s]’. A simulation of the following task is shown in Figure 6d:

φ = G_{[0,100]} F_{[0,20]} (‖ x_{1} - x_{3} ‖ \leq 1) .

Every 20[s], the condition |x₁ − x₃| ≤ 1 is met. It’s worth noting that the specific time t^⋆ at which satisfaction occurs is randomly chosen by the algorithm. The maximum computation time by any agent is 0.2017[s].

In reference to Remark 2, an example of post-processing the trajectories is shown in Figure 7 for the STL formula,

φ = G_{[0,100]} F_{[0,20]} (‖ x_{1} - x_{2} ‖ \leq 1) .

(10)

A 3rd order polynomial was applied using the Savitzky-Golay filter to smoothen the trajectory. Smoothening helps to avoid any large accelerations and sudden velocity changes, though it may come at the cost of potential STL violations.

Figure 6.

Simulation results of MAPS² with four agents

Multi-agent case study

In this case study, we design trajectories for a team of 100 agents that exist in a 100 × 100[m] space and [0,100][s] time span. The team needs to adhere to the following STL formula,

φ = G_{[10,90]} [‖ x_{i} - x_{j} ‖ \geq 0.01 \land ‖ x_{i} - (50,50) ‖ \leq 5]

(11)

∀i, j ∈ {1, 2, …, 100} and i ≠ j. Note that the above STL formula has 5150 predicates. In the interval [10,90][s], the STL formula dictates every agent to be at least 0.01[m] apart from every other agent and to be at least 5[m] close to the centre point (50,50)[m]. The simulation results are shown in Figure 8 where the Figures 8(a)-8(c) are the trajectories before the start of the algorithm while Figures 8(d)-8(f) shows the trajectories at the end of j = 1000 iterations, as mentioned in Algorithm 2. The simulation took 17.84[s] to complete without parallelisation. The faster computation can be attributed to the nature of the design of the cost function in (8), which allows for points that do not violate the formula not to be changed. The robustness of the STL formula is shown in Figure 9, a negative robustness signifies task satisfaction. Here, the robustness converges to 0, because the robustness for an always operator reflects the worst-case scenario. It is important to note that computing the result for Figure 9 required 12 hours and 10 minutes of computation time since it had to be performed centrally.

Figure 7.

Non-smooth and smooth paths for the formula (10).

Figure 8.

Simulation of trajectory generation for 100 agents for the STL formula (11).

Overall case study

In this case study, we demonstrate the application of the aforementioned scenarios by setting up the following tasks:

• Agent 1 always stays above 8 units.

• Agents 2 and 4 are required to satisfy the predicate $x_{2}^{2} + x_{4}^{2} \leq 2$ within the time interval [10,30][s].

• Agent 3 is required to track an exponential path within the time interval [20,60][s].

• Agent 2 is required to repeatedly visit Agent 1 and Agent 3 every 10 s within the interval [30,50][s].

• Agent 1 is required to maintain at least 1 unit distance from the other three agents within the interval [80,100][s].

The STL formula for the above tasks is as follows:

\begin{array}{l} φ & = (x_{1} \geq 8) \land G_{[10,30]} (x_{2}^{2} + x_{4}^{2} \leq 2) \land \\ G_{[20,60]} (‖ x_{3} - 50 \exp (- 0.1 t) ‖ \leq 0.05) \land \\ G_{[30,50]} F_{[0,10]} ((‖ x_{2} - x_{1} ‖ \leq 0.5) \land (‖ x_{2} - x_{3} ‖ \leq 0.5)) \land \\ F_{[79.9, 80.1]} G_{[0,20]} ((‖ x_{1} - x_{2} ‖ \geq 1) \land (‖ x_{1} - x_{3} ‖ \geq 1) \\ \land (‖ x_{1} - x_{4} ‖ \geq 1)) \end{array}

The parameter L was increased to 1000, and η was decreased to 0.001. In Figure 10, we show the resulting trajectories of each agent generated by MAPS² satisfying the above STL formula. The maximum computation time by any agent is 4.611[s].

Figure 9.

Robustness of the STL formula in (11).

Experiments

We now present an experimental demonstration of the proposed algorithm. The multi-robot setup involves three robots, as shown in Figure 11, and consists of 3 mobile bases and two 6-DOF manipulator arms. The locations of the three bases are denoted as $x_{1} \in R^{2}$ , $x_{2} \in R^{2}$ , and $x_{3} \in R^{2}$ , respectively. Base 2 and base 3 are equipped with manipulator arms, whose end-effector positions are represented as $e_{1} \in R^{3}$ and $e_{2} \in R^{3}$ , respectively.

Figure 10.

Overall case study.

Figure 11.

Experimental setup with three mobile bases and two 6-dof manipulators

The STL formula defining the tasks is the following,

\begin{array}{l} φ = ‖ x_{1} - x_{2} ‖ \geq 0.6 \land ‖ x_{2} - x_{3} ‖ \geq 0.6 \land ‖ x_{3} - x_{1} ‖ \geq 0.6 \land \\ G_{[10,125]} ‖ x_{1} - 1.8 {[- \cos 0.0698 t, \sin (0.0698 t)]}^{⊤} ‖ \leq 0.05 \land \\ G_{[30,70]} ‖ e_{1} - {[x_{1}^{⊤}, 0.35]}^{⊤} ‖ \leq 0.01 \land \\ G_{[30,70]} ‖ x_{2} - 1.1 {[- \cos 0.0698 t, \sin (0.0698 t)]}^{⊤} ‖ \leq 0.05 \land \\ G_{[80,120]} ‖ e_{2} - {[x_{1}^{⊤}, 0.35]}^{⊤} ‖ \leq 0.01 \land \\ G_{[80,120]} ‖ x_{3} - 1.1 {[- \cos 0.0698 t, \sin (0.0698 t)]}^{⊤} ‖ \leq 0.05 \land \\ F_{[180,200]} ‖ x_{1} - {[0,0]}^{⊤} ‖ \leq 0.05 \land \\ F_{[180,200]} (‖ x_{2} - [1, - 1] ‖ \leq 0.05 \land ‖ e_{1} - [x_{2}, 0.6] ‖ \leq 0.05) \land \\ F_{[180,200]} (‖ x_{3} - [- 1,1] ‖ \leq 0.05 \land ‖ e_{2} - [x_{3}, 0.6] ‖ \leq 0.05) . \end{array}

The above task involves collision avoidance constraints that are always active given by the subformula ${\bar{φ}}_{1} = (‖ x_{1} - x_{2} ‖ \geq 0.6) \land (‖ x_{2} - x_{3} ‖ \geq 0.6) \land (‖ x_{3} - x_{1} ‖ \geq 0.6)$ . Next, in the duration [10,125][s], base 1 surveils the arena and follows a circular time-varying trajectory given by the subformula ${\bar{φ}}_{2} = (G_{[10,125]} ‖ x_{1} - c_{1} (t) ‖ \leq 0.05)$ where c₁(t) is the circular trajectory. In the duration [30,70][s], end-effector 1 tracks a virtual point 0.35[m] over base 1 to simulate a pick-and-place task, given by the subformula ${\bar{φ}}_{3} = G_{[30,70]} ‖ e_{1} - {[x_{1}^{⊤}, 0.35]}^{⊤} ‖ \leq 0.01 \land G_{[30,70]} ‖ x_{2} - c_{2} (t) ‖ \leq 0.05$ where c₂(t) is the circular trajectory. Similarly, in the duration [80,120][s], end-effector 2 takes over the task to track a virtual point 0.35[m] over base 1, given by the subformula ${\bar{φ}}_{4} = G_{[80,120]} ‖ e_{2} - {[x_{1}^{⊤}, 0.35]}^{⊤} ‖ \leq 0.01 \land G_{[80,120]} ‖ x_{3} - c_{2} (t) ‖ \leq 0.05$ . Finally, eventually in the duration [180,200][s], the robots assume a final position given by the subformula $\bar{φ_{5}} = F_{[180,200]} ‖ x_{1} - {[0,0]}^{⊤} ‖ \leq 0.05 \land F_{[180,200]} (‖ x_{2} - [1, - 1] ‖ \leq 0.05 \land ‖ e_{1} - [x_{2}, 0.6] ‖ \leq 0.05) \land F_{[180,200]} (‖ x_{3} - [- 1,1] ‖ \leq 0.05 \land ‖ e_{2} - [x_{3}, 0.6] ‖ \leq 0.05)$ .

The results are shown in Figure 12, where the x-axis represents time in seconds, and the y-axis represents the predicate functions defined by (5). The dashed line in the plots represents the predicate functions of the trajectories obtained by solving the optimisation problem (8), while the solid line represents the predicate functions of the actual trajectories by the robots. In the context of (5), negative values indicate task satisfaction. However, due to the lack of an accurate model of the robots and the fact that the optimisation solution converges to the boundary of the constraints, the tracking is imperfect, and we observe slight violations of the formula by the robots in certain cases. Nonetheless, the trajectories generated by the algorithm do not violate the STL formula. The coloured lines represent the functions that lie within the validity domain of the formula. Figure 12(a) shows that the collision constraint imposed on all 3 bases is not violated, and they maintain a separation of at least 60 cm. In Figure 12(b), base 1 tracks a circular trajectory in the interval [10, 125] seconds. In Figures 12(c) and 12(d), the end effectors mounted on top of bases 2 and 3 track a virtual point over the moving base 1 sequentially. In the last 20 seconds, the bases and end effectors move to their desired final positions, as seen in Figures 12(e) and 12(f). The maximum computation time by any robot is 3.611[s]. Figure 13 shows front-view and side-view at different time instances during the experimental run.³

Figure 12.

Experimental verification of MAPS² with the setup in Figure 11.

Figure 13.

Front-view and side-view during experimental run with the setup in Figure 11.

Conclusion

This work proposed MAPS², a distributed planner that solves the multi-robot motion-planning problem subject to tasks encoded as STL constraints. By using the notion of validity domain and formulating the optimisation problem as shown in (8), MAPS² transforms the spatio-temporal problem into a spatial planning task, for which efficient optimisation algorithms already exist. Task satisfaction is probabilistically guaranteed in a distributed manner by presenting an optimisation problem that necessitates communication only between robots that share coupled constraints. Extensive simulations involving benchmark formulas and experiments involving varied tasks highlight the algorithms functionality. Future work involves incorporating dynamical constraints such as velocity and acceleration limits into the optimisation problem.

Supplemental Material

Footnotes

ORCID iD

Mayank Sewlia

Funding

The authors disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This work was supported by the ERC CoG LEAFHOUND, the Swedish Research Council (VR), the Knut och Alice Wallenberg Foundation (KAW) and the H2020 European Project CANOPIES.

Declaration of conflicting interests

The authors declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Supplemental Material

Supplemental material for this article is available online.

Notes

References

Ayala

Andersson

Belta

(2013) Temporal logic motion planning in unknown environments. In: 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems. IEEE, 5279–5284.

Belta

Sadraddini

(2019) Formal methods for control synthesis: an optimization perspective. Annual Review of Control, Robotics, and Autonomous Systems 2: 115–140.

Bhatia

Kavraki

Vardi

(2010) Sampling-based motion planning with temporal goals. In: 2010 IEEE International Conference on Robotics and Automation. IEEE, 2689–2696.

Boyd

Vandenberghe

(2004) Convex Optimization. Cambridge University Press.

Charitidou

Dimarogonas

(2021) Barrier function-based model predictive control under signal temporal logic specifications. In: 2021 European Control Conference (ECC). IEEE, 734–739.

Chen

Dimarogonas

(2022) Funnel-based cooperative control of leader-follower multi-agent systems under signal temporal logic specifications. In: 2022 European Control Conference (ECC). IEEE, 906–911.

Daneshmand

Scutari

Kungurtsev

(2020) Second-order guarantees of distributed gradient algorithms. SIAM Journal on Optimization 30(4): 3029–3068.

Donzé

(2013) On signal temporal logic. In: International Conference on Runtime Verification. Springer, 382–383.

Fainekos

Girard

Kress-Gazit

, et al. (2009) Temporal logic motion planning for dynamic robots. Automatica 45(2): 343–352.

10.

Feller

(1968) An Introduction to Probability Theory and its Applications. Wiley, Vol. 1.

11.

Fotiadis

Rovithakis

(2024) Input-constrained prescribed performance control for high-order mimo uncertain nonlinear systems via reference modification. IEEE Transactions on Automatic Control 69(5): 3301–3308.

12.

Gilpin

Kurtz

Lin

(2020) A smooth robustness measure of signal temporal logic for symbolic control. IEEE Control Systems Letters 5(1): 241–246.

13.

Goyvaerts

(2016) Regular expression tutorial - learn how to use regular expressions. https://www.regular-expressions.info/tutorial.html

14.

Kleinbort

Solovey

Littlefield

, et al. (2019) Probabilistic completeness of rrt for geometric and kinodynamic planning with forward propagation. IEEE Robotics and Automation Letters 4(2): i–vii.

15.

Kress-Gazit

Fainekos

Pappas

(2009) Temporal-logic-based reactive mission and motion planning. IEEE Transactions on Robotics 25(6): 1370–1381.

16.

Kurtz

Lin

(2022) Mixed-integer programming for signal temporal logic with fewer binary variables. IEEE Control Systems Letters 6: 2635–2640.

17.

Lamport

(1983) What good is temporal logic? In: Mason

REA

(ed) Information Processing 83. Elsevier Publishers, Vol. 83, 657–668.

18.

Lapandić

Verginis

Dimarogonas

, et al. (2024) Kinodynamic motion planning via funnel control for underactuated unmanned surface vehicles. IEEE Transactions on Control Systems Technology 32(6): 2114–2125.

19.

Lindemann

Dimarogonas

(2017) Robust motion planning employing signal temporal logic. In: 2017 American Control Conference (ACC). IEEE, 2950–2955.

20.

Lindemann

Dimarogonas

(2018) Decentralized robust control of coupled multi-agent systems under local signal temporal logic tasks. In: 2018 Annual American Control Conference (ACC), 1567–1573.

21.

Lindemann

Verginis

Dimarogonas

(2017) Prescribed performance control for signal temporal logic specifications. In: 2017 IEEE 56th Annual Conference on Decision and Control (CDC). IEEE Press, 2997–3002.

22.

Madsen

Vaidyanathan

Sadraddini

, et al. (2018) Metrics for signal temporal logic formulae. In: 2018 IEEE Conference on Decision and Control (CDC). IEEE, 1542–1547.

23.

Maler

Nickovic

(2004) Monitoring temporal properties of continuous signals. In: Formal Techniques, Modelling and Analysis of Timed and Fault-Tolerant Systems. Springer, 152–166.

24.

Morrison

Jacobson

Sauppe

, et al. (2016) Branch-and-bound algorithms: a survey of recent advances in searching, branching, and pruning. Discrete Optimization 19: 79–102.

25.

Nedic

Ozdaglar

(2009) Distributed subgradient methods for multi-agent optimization. IEEE Transactions on Automatic Control 54(1): 48–61.

26.

Poignet

Gautier

(2000) Nonlinear model predictive control of a robot manipulator. In: 6th International Workshop on Advanced Motion Control. Proceedings (Cat. No.00TH8494). IEEE, 401–406.

27.

Raman

Donzé

Maasoumy

, et al. (2014) Model predictive control with signal temporal logic specifications. In: 53rd IEEE Conference on Decision and Control. IEEE, 81–87.

28.

Sadraddini

Belta

(2015) Robust temporal logic model predictive control. In: 2015 53rd Annual Allerton Conference on Communication, Control, and Computing (Allerton). IEEE, 772–779.

29.

Sewlia

Verginis

Dimarogonas

(2023) Cooperative sampling-based motion planning under signal temporal logic specifications. In: 2023 American Control Conference (ACC). IEEE, 2697–2702.

30.

Sun

Chen

Mitra

, et al. (2022) Multi-agent motion planning from signal temporal logic specifications. IEEE Robotics and Automation Letters 7(2): 3451–3458.

31.

Trakas

Bechlioulis

(2023) Robust adaptive prescribed performance control for unknown nonlinear systems with input amplitude and rate constraints. IEEE Control Systems Letters 7: 1801–1806.

32.

Vasile

Belta

(2013) Sampling-based temporal logic path planning. In: 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems. IEEE, 4817–4822.

33.

Verginis

Dimarogonas

(2018) Timed abstractions for distributed cooperative manipulation. Autonomous Robots 42: 781–799.

34.

Webb

van den Berg

(2012) Kinodynamic rrt*: optimal motion planning for systems with linear differential constraints. ArXiv, abs/1205.5088.

35.

Wolff

Topcu

Murray

(2014) Optimization-based trajectory generation with linear temporal logic specifications. In: 2014 IEEE International Conference on Robotics and Automation (ICRA), 5319–5325.

36.

Yang

Vang

Serlin

, et al. (2019) Sampling-based motion planning via control barrier functions. In: Proceedings of the 2019 3rd International Conference on Automation, Control and Robots. IEEE, 22–29.

Supplementary Material

Please find the following supplemental material available below.

For Open Access articles published under a Creative Commons License, all supplemental material carries the same license as the article it is associated with.

For non-Open Access articles published, all supplemental material carries a non-exclusive license, and permission requests for re-use of supplemental material or any part of supplemental material shall be sent directly to the copyright owner as specified in the copyright notice associated with the article.

0.00 MB

MAPS 2 : Multi-robot autonomous motion planning under signal temporal logic specifications

Abstract

Keywords

Introduction

Related work

Preliminaries and problem formulation

Signal Temporal Logic (STL)

STL parse Tree

Problem formulation

STL formula decomposition

Spatial constraints

Temporal constraints

Main results

MAPS2

GradientDescent

SatisfactionVariable

Branch-and-pick for disjunctions

Analysis

Simulations

Collision avoidance

Rendezvous

Stability

Recurring tasks

Multi-agent case study

Overall case study

Experiments

Conclusion

Supplemental Material

Footnotes

ORCID iD

Funding

Declaration of conflicting interests

Supplemental Material

Notes

References

Supplementary Material

MAPS²