Control from Signal Temporal Logic Specifications with Smooth Cumulative Quantitative Semantics

TL;DR

This paper introduces a new smooth quantitative semantics for Signal Temporal Logic, enabling efficient control policy synthesis for nonlinear systems through gradient-based optimization and model predictive control, demonstrated in case studies.

Contribution

It proposes a novel smooth and differentiable STL quantitative semantics called cumulative robustness, facilitating control synthesis via gradient ascent and model predictive control.

Findings

Effective control policy synthesis for nonlinear systems using smooth STL semantics.

Demonstrated advantages in long-horizon control through case studies.

Integration of cumulative robustness with gradient-based optimization methods.

Abstract

We present a framework to synthesize control policies for nonlinear dynamical systems from complex temporal constraints specified in a rich temporal logic called Signal Temporal Logic (STL). We propose a novel smooth and differentiable STL quantitative semantics called cumulative robustness, and efficiently compute control policies through a series of smooth optimization problems that are solved using gradient ascent algorithms. Furthermore, we demonstrate how these techniques can be incorporated in a model predictive control framework in order to synthesize control policies over long time horizons. The advantages of combining the cumulative robustness function with smooth optimization methods as well as model predictive control are illustrated in case studies.

Figures

Tables

Table 1. TABLE I: Probability that a noisy linear system ( 24 ) satisfies the STL specification of ( 12 ).

Objective Function	Probability of Satisfaction	Simulation Sample Size	Margin of Error	Confidence Level
${\tilde{\rho }}^{+}$	44.9%	328	1%	95%
$\tilde{\rho }$	10.5%	273	1%	95%

Equations

$$\phi :=\top |\mu |\neg \phi |{\phi }_1\wedge {\phi }_2|{\phi }_1{\mathbf{U}}_I{\phi }_2,$$

$$\begin{array}[]{lcr}\rho(\top,\sigma,t_{k})&:=&+\infty,\\ \rho(l(\sigma)\geq 0,\sigma,t_{k})&:=&l(\sigma[k]),\\ \rho(\neg\varphi,\sigma,t_{k})&:=&-\rho(\varphi,\sigma,t_{k}),\\ \rho(\psi\wedge\varphi,\sigma,t_{k})&:=&\min\{\rho(\psi,\sigma,t_{k}),\rho(\varphi,\sigma,t_{k})\},\\ \rho(\psi\mathbf{U}_{I}\varphi,\sigma,t_{k})&:=&\max\limits_{k^{\prime}\in I}(\min\{\rho(\varphi,\sigma,t_{k+k^{\prime}}),\\ &&\min\limits_{k^{\prime\prime}\in[k,k+k^{\prime}]}\rho(\psi,\sigma,t_{k^{\prime\prime}})\}).\\ \end{array}$$

$$\begin{array}[]{c}\rho(\varphi,\sigma,t_{k})>0\Rightarrow\sigma^{t_{k}}\models\varphi,\\ \rho(\varphi,\sigma,t_{k})<0\Rightarrow\sigma^{t_{k}}\not\models\varphi.\\ \end{array}$$

$$\begin{array}[]{l}\widetilde{\max_{\beta}}(a_{1},\ldots,a_{m}):=\frac{1}{\beta}\ln\sum_{i=1}^{m}e^{\beta a_{i}},\\ \widetilde{\min_{\beta}}(a_{1},\ldots,a_{m}):=-\widetilde{\max}(-a_{1},\ldots,-a_{m}).\end{array}$$

$$\begin{array}[]{l}0\leq\widetilde{\max_{\beta}}(a_{1},\ldots,a_{m})-\max(a_{1},\ldots,a_{m})\leq\frac{\ln(m)}{\beta},\\ 0\leq\widetilde{\min_{\beta}}(a_{1},\ldots,a_{m})-\min(a_{1},\ldots,a_{m})\leq\frac{\ln(m)}{\beta},\end{array}$$

$$\begin{array}[]{l}\sigma[k+1]=f(\sigma[k],u[k]),\\ \sigma[0]=\gamma,\\ \end{array}$$

$$\begin{array}[]{c}u^{*}=\arg\min\sum\limits_{k=0}^{h_{\varphi}-1}J(\sigma[k],u[k]),\\ \text{s.t.}\;\;\;\;\;\langle\sigma,{u^{*}}\rangle\models\varphi.\end{array}$$

$$\begin{array}[]{l}x[k+1]=x[k]+\cos\theta[k]v[k]\Delta t,\\ y[k+1]=y[k]+\sin\theta[k]v[k]\Delta t,\\ \theta[k+1]=\theta[k]+v[k]\omega[k]\Delta t,\\ \end{array}$$

$${\varphi }_1=({\mathbf{G}}_{[0,40]}\neg {\mu }_4){\mathbf{U}}_{[0,60]}[({\mu }_1\vee {\mu }_2)\wedge ({\mathbf{F}}_{[0,40]}{\mathbf{G}}_{[0,20]}{\mu }_3)],$$

$$\begin{array}[]{l}\mu_{1}=x>4\wedge x<7\wedge y>0\wedge y<2,\\ \mu_{2}=x>0\wedge x<2\wedge y>4\wedge y<7,\\ \mu_{3}=x>5\wedge x<7\wedge y>5\wedge y<7,\\ \mu_{4}=x>2\wedge x<5\wedge y>2\wedge y<5.\\ \end{array}\vspace{-4pt}$$

$$\begin{array}[]{c}u^{*}=\arg\min\sum\limits_{k=0}^{h_{\varphi}+h_{M}-1}J(\sigma[k],u[k]),\\ \text{s.t.}\;\;\;\;\;\langle\sigma,u^{*}\rangle\models\mathbf{G}_{[0,h_{M}]}\varphi.\\ \end{array}$$

$$x[k+1]=\left[\begin{array}{cc}1& 0.5\\ 0& 0.8\end{array}\right]x[k]+\left[\begin{array}{c}0\\ 1\end{array}\right]u[k],$$

$${\varphi }_2={\mathbf{F}}_{[0,4]}{\mu }_5\wedge {\mathbf{F}}_{[0,4]}{\mu }_6,$$

$$\begin{array}[]{l}\mathfrak{R}^{+}(a)=\max(0,a),\\ \mathfrak{R}^{-}(a)=\min(0,a).\\ \end{array}$$

$$\begin{array}[]{l}\widetilde{\mathfrak{R}}_{\beta}^{+}(a)=\frac{1}{\beta}\ln(1+e^{\beta a}),\\ \widetilde{\mathfrak{R}}_{\beta}^{-}(a)=-\frac{1}{\beta}\ln(1+e^{-\beta a}).\\ \end{array}$$

$$\begin{array}[]{lcr}\rho^{+}(l(\sigma)\geq 0,\sigma,t_{k})&:=&\mathfrak{R}^{+}(l(\sigma[k])),\\ \rho^{-}(l(\sigma)\geq 0,\sigma,t_{k})&:=&\mathfrak{R}^{-}(l(\sigma[k])),\\ \rho^{+}(\neg\varphi,\sigma,t_{k})&:=&-\rho^{-}(\varphi,\sigma,t_{k}),\\ \rho^{-}(\neg\varphi,\sigma,t_{k})&:=&-\rho^{+}(\varphi,\sigma,t_{k}),\\ \rho^{+}(\psi\vee\varphi,\sigma,t_{k})&:=&\max\{\rho^{+}(\psi,\sigma,t_{k}),\rho^{+}(\varphi,\sigma,t_{k})\},\\ \rho^{-}(\psi\vee\varphi,\sigma,t_{k})&:=&\max\{\rho^{-}(\psi,\sigma,t_{k}),\rho^{-}(\varphi,\sigma,t_{k})\},\\ \rho^{+}(\psi\wedge\varphi,\sigma,t_{k})&:=&\min\{\rho^{+}(\psi,\sigma,t_{k}),\rho^{+}(\varphi,\sigma,t_{k})\},\\ \rho^{-}(\psi\wedge\varphi,\sigma,t_{k})&:=&\min\{\rho^{-}(\psi,\sigma,t_{k}),\rho^{-}(\varphi,\sigma,t_{k})\},\\ \rho^{+}(\mathbf{F}_{I}\varphi,\sigma,t_{k})&:=&\sum\limits_{k^{\prime}\in I}\rho^{+}(\varphi,\sigma,t_{k+k^{\prime}}),\\ \rho^{-}(\mathbf{F}_{I}\varphi,\sigma,t_{k})&:=&\sum\limits_{k^{\prime}\in I}\rho^{-}(\varphi,\sigma,t_{k+k^{\prime}}),\\ \rho^{+}(\mathbf{G}_{I}\varphi,\sigma,t_{k})&:=&\min\limits_{k^{\prime}\in I}\rho^{+}(\varphi,\sigma,t_{k+k^{\prime}}),\\ \rho^{-}(\mathbf{G}_{I}\varphi,\sigma,t_{k})&:=&\min\limits_{k^{\prime}\in I}\rho^{-}(\varphi,\sigma,t_{k+k^{\prime}}),\\ \end{array}$$

$$\begin{array}[]{lcr}\rho^{+}(\psi\mathbf{U}_{I}\varphi,\sigma,t_{k})&:=&\sum\limits_{k^{\prime}\in I}(\min\{\rho^{+}(\varphi,\sigma,t_{k+k^{\prime}}),\\ &&\min\limits_{k^{\prime\prime}\in[k,k+k^{\prime}]}\rho^{+}(\psi,\sigma,t_{k^{\prime\prime}})\}),\\ \rho^{-}(\psi\mathbf{U}_{I}\varphi,\sigma,t_{k})&:=&\sum\limits_{k^{\prime}\in I}(\min\{\rho^{-}(\varphi,\sigma,t_{k+k^{\prime}}),\\ &&\min\limits_{k^{\prime\prime}\in[k,k+k^{\prime}]}\rho^{-}(\psi,\sigma,t_{k^{\prime\prime}})\}).\\ \end{array}$$

$${\rho }^{+}(\phi ,\sigma ,t_k)>0\iff \rho (\phi ,\sigma ,t_k)>0\Rightarrow {\sigma }^{t_k}\models \phi .$$

$$\begin{array}[]{l}\rho^{+}(\neg(\neg\varphi),\sigma,t_{k})=\rho^{+}(\varphi,\sigma,t_{k}),\\ \rho^{+}(\neg(\psi\wedge\varphi),\sigma,t_{k})=\rho^{+}(\neg\psi\vee\neg\varphi,\sigma,t_{k}).\\ \end{array}$$

$$\phi \leftarrow \phi \wedge {\mathbf{G}}_{[0,h_{\phi }]}(\sigma \in \mathcal{X}).$$

$$u\leftarrow u+{\alpha }_i\nabla Q,$$

$$\nabla_{p}Q[k]=\frac{\partial Q}{\partial u_{p}[k]}+\sum\limits_{q=1}^{n}\big{(}\frac{\partial Q}{\partial\sigma_{q}[k+1]}.\frac{\partial f_{q}[k+1]}{\partial u_{p}[k]}\big{)},$$

$$u_p[k]\leftarrow \max \{\min \{u_p[k],{\mathcal{U}}_p^{\prime }\},{\mathcal{U}}_p\}.$$

$$u^{\ast }[k]=u^{h_k}[0]k=0,\dots h_M.$$

$$\exists k\in \tau ,\exists K\in \mathbb{N}s.t.\sigma [k+K]=\sigma [k],K>h_{\phi }.$$

$$x[k+1]=\left[\begin{array}{cc}1& 0.5\\ 0& 0.8\end{array}\right]x[k]+\left[\begin{array}{c}0\\ 1\end{array}\right]u[k]+w[k],$$

Full text

I Introduction

In the last decade, formal methods have become powerful mathematical tools not only for specification and verification of systems, but also to enable control engineers to move beyond classical notions such as stability and safety, and to synthesize controllers that can satisfy much richer specifications [1]. For example, temporal logics such as Linear Temporal Logic (LTL) [2], Metric Temporal Logic (MTL) [3], and Signal Temporal Logic (STL) [4] have been used to define rich time-dependent constraints for control systems in a wide variety of applications, ranging from biological networks to multi-agent robotics [5, 6, 7].

The existing methods for temporal logic control can be divided into two general categories: automata-based [1] and optimization- based [8, 9, 10]. In the first, a finite abstraction for the system and an automaton representing the temporal logic specifications are computed. A controller is then synthesized by solving a game over the product automaton [1]. Even though this approach has shown some promising results, automata-based solutions are generally very expensive computationally. The second approach leverages the definition of quantitative semantics [11, 12, 13] for temporal logics that interpret a formula with respect to a system trajectory by computing a real-value (called robustness) measuring how strongly a specification is satisfied or violated. Consequently, the control problem becomes an optimization problem with the goal of maximizing robustness.

In this paper, we propose a novel framework to synthesize cost-optimal control policies for possibly nonlinear dynamical systems under STL constraints. First, we introduce a new quantitative semantics for STL, called cumulative quantitative semantics or cumulative robustness degree. The traditional STL robustness degree [11] is very conservative since it only considers the robustness at the most critical time (the time that is closest to violation). On the other hand, we cumulate the robustness over the time horizon of the specification. This results in a robustness degree that is more useful and meaningful in many control applications. Specifically, we show that control policies obtained by optimizing the robustness introduced here leads to reaching desired states faster, and the system spends more time in those states.

We demonstrate how to extend smooth approximation techniques described in [10] to address the novel notion of cumulative robustness introduced here. We then show how to leverage the smooth cumulative robustness function to perform Model Predictive Control (MPC) [14] under STL constraints for nonlinear dynamical systems using a gradient ascent algorithms. We evaluate our approach on three different case studies: (1) path planning for an autonomous vehicle, (2) MPC for linear systems and (3) MPC for noisy linear systems.

The rest of the paper is organized as follows. In Section II, we discuss the related work. In Section III, we introduce the necessary theoretical background. Section IV presents the control problems considered in this paper. Section V shows how to compute the cumulative robustness and its smooth approximation. Sections VI and VII provide the optimization framework to perform model predictive control using gradient ascent algorithm for the smooth cumulative robustness function. The capabilities of our algorithms are demonstrated through case studies in Section VIII.

II Related Work and Contributions

In [13], the authors introduce an extension of STL, called AvSTL, and propose a quantitative semantics for it. The AvSTL quantitative semantics has some similarities with the cumulative robustness proposed here, but computes the average robustness over specification horizons instead of cumulating the robustness. Moreover, the work in [13] only investigates a falsification problem, while we consider a more general control problem.

In [8], Karaman et al. demonstrate that temporal logic control problems can be formulated as mixed integer linear problems (MILP), avoiding the issues with state space abstraction and dealing with systems in continuous space. Since this paper, many researchers have adopted this technique and demonstrated Mixed Integer Linear or Quadratic Programs (MILP/MIQP) are often more scalable and reliable than automata-based solutions [15, 16]. However, MILP has an exponential complexity with respect to the number of its integer variables and the computational times for MILP-based solutions are extremely unpredictable. These types of solutions generally suffer when dealing with very large and nested specifications. More recently, Pant et al. in [10] have presented a technique to compute a smooth abstraction for the traditional STL quantitative semantics defined in [11]. The authors show that control problems can be solved using smooth optimization algorithms such as gradient descent in a much more time efficient way than MILP. This technique also works for any smooth nonlinear dynamics while MILP and MIQP require the system dynamics to be linear or quadratic. Additionally, the same smoothing technique enabled the authors in [17] to solve reinforcement learning problems. We show here how to extend this technique to smoothly approximate the proposed cumulative robustness function improving the control synthesis.

We consider the problem of Model Predictive Control (MPC) under temporal logics constraints that is based on iterative, finite-horizon optimization of a plant model and its input in order to satisfy a signal temporal logic specification. The work in [5] employs MPC to control the plant to satisfy a formal specification expressed in a fragment of LTL that can be translated into finite state automata and [18] used it for finite state systems and Büchi automata to synthesize controllers under full LTL specification. MPC has also been used in conjunction with mixed integer linear and quadratic programs for temporal logic control [15, 19, 20].

The methodology presented in this paper has some connections to economic model predictive control (EMPC) [21], in that both frameworks consider cost functions which are more general and complex than the simple quadratic costs of conventional MPC. While EMPC defines costs over system state and input values, signal temporal logic control synthesis can be thought of as optimization problems with objective functions over system trajectories.

III preliminaries

III-A Signal Temporal Logic

Signal Temporal Logic (STL) was introduced in [4]. Consider a discrete unbounded time series $\tau:=\{t_{k}|k\in\mathbb{Z}_{\geq 0}\}$. A signal is a function $\sigma:\tau\rightarrow\mathbb{R}^{n}$ that maps each time point $t_{k}\in\mathbb{R}_{\geq 0}$ to an $n$-dimensional vector of real values $\sigma[k]$, with $\sigma_{i}[k]$ being the $i$th component. Given a signal $\sigma$ and $k\in\mathbb{Z}_{\geq 0}$, $\sigma^{t_{k}}:=\{\sigma[k^{\prime}]|k^{\prime}\geq k\}$ is the portion of the signal starting at the $k$th time step of $\tau$.

Definition 1** (STL Syntax)**

[TABLE]

where $\phi$, $\varphi_{1}$, $\varphi_{2}$ are formulas and $\top$ stands for the Boolean constant True. We use the standard notation for the Boolean operators. $I=[k_{1},k_{2}]$ denotes a bounded time interval containing all time points (integers) starting from $k_{1}$ up to $k_{2}$ and $k_{2}>k_{1}\geq 0$. The building blocks of STL formulas are predicates of the form $\mu:=l(\sigma)\geq 0$ where $l$ is a linear or nonlinear combination of the elements of $\sigma$ (e.g., $\sigma_{1}+2\sigma_{2}-3\geq 0$ or $\sigma_{1}^{2}+\sigma_{2}^{2}-1\geq 0$). In this paper, we assume that $l$ is smooth and differentiable. In order to construct a STL formula, different predicates ($\mu$) or STL sub-formulas ($\varphi$) are recursively combined using Boolean logical operators ($\neg,\vee,\wedge$) as well as temporal operators. $\mathbf{U}_{I}$ is the until operator and $\varphi_{1}\mathbf{U}_{I}\varphi_{2}$ is interpreted as ”$\varphi_{2}$ must become true at least once in the future within $I$ and $\varphi_{1}$ must be always true prior to that time”. Other temporal operator can also be derived from $\mathbf{U}_{I}$. $\mathbf{F}_{I}$ is the finally or eventually operator and $\mathbf{F}_{I}\varphi$ is interpreted as ”$\varphi$ must become true at least once in the future within $I$”. $\mathbf{G}_{I}$ is the globally or always operator and $\mathbf{G}_{I}\varphi$ is interpreted as ”$\varphi$ must always be true during the interval $I$ in the future”. For instance, $\mathbf{G}_{[0,10]}(\sigma_{1}>0)$ means $\sigma_{1}$ must be positive all the time from now until $10$ units of time from now; $\mathbf{F}_{[0,5]}\mathbf{G}_{[0,10]}(\sigma_{1}>0)$ means that $\sigma_{1}$ must become positive within $5$ units of time in the future and stay positive for $10$ steps after that; and $(\sigma_{2}>0)\mathbf{U}_{[0,10]}(\sigma_{1}>0)$ means that $\sigma_{1}$ should become positive at a time point within $10$ units of time and $\sigma_{2}$ must be always positive before that.

STL has a qualitative semantics which can be used to determine whether a formula $\varphi$ with respect to a given signal $\sigma^{t_{k}}$ starting at the $k$th time step of $\tau$ is satisfied ($\sigma^{t_{k}}\models\varphi$) or violated ($\sigma^{t_{k}}\not\models\varphi$) [4, 11]. Additionally, [11] introduces a quantitative semantics that can be interpreted as ”How much a signal satisfies or violates a formula”. The quantitative valuation of a STL formula $\varphi$ with respect to a signal $\sigma$ at the $k$th time step is denoted by $\rho(\varphi,\sigma,t_{k})$ and called the robustness degree. The robustness degree for any STL formula at time $t_{k}\in\tau$ with respect to signal $\sigma$ can be recursively computed using the following definition.

Definition 2** (STL robustness)**

[TABLE]

The robustness degree for $\vee$, $\mathbf{F}_{I}$, and $\mathbf{G}_{I}$ can be easily derived [11]. The robustness degree is sound, meaning that:

[TABLE]

A formal definition for the horizon ($h_{\varphi}$) of a STL formula $\varphi$ is presented in [22]. Informally, it is the smallest time step in the future for which signal values are needed to compute the robustness for the current time point. For instance, the horizon of the formula $\mathbf{F}_{[0,5]}\mathbf{G}_{[0,10]}(\sigma_{1}>0)$ is $5+10=15$.

In the rest of this paper, if we do not specify the time of satisfaction or violation of a formula, we mean satisfaction or violation at time [math] (i.e., $\sigma\models\varphi$ means $\sigma^{0}\models\varphi$).

III-B Smooth Approximation of STL Robustness Degree

The robustness degree that results from (2) is not differentiable. This poses a challenge in solving optimal control problems using the robustness degree as part of the objective function. The authors in [10] introduce a technique for computing smooth approximations of the robustness degree for Metric Temporal Logic (MTL), which is based on smooth approximations of the max and min functions:

Definition 3** (Smooth Operators)**

[TABLE]

It is easily shown that [10]:

[TABLE]

Therefore, the approximation error approaches [math] as $\beta$ goes to $\infty$. We denote the smooth approximation of any robustness function $\rho$ by $\tilde{\rho}$.

IV Problem Statement

Consider a discrete time continuous space dynamical system of the following form:

[TABLE]

where $\sigma[k]\in\mathcal{X}\subseteq\mathbb{R}^{n}$ is the state of the system at the $k$th time step of $\tau:=\{t_{k}|k\in\mathbb{Z}_{\geq 0}\}$, $\mathcal{X}$ is the state space, and $\gamma\in\mathcal{X}$ is the initial condition. $u[k]\in\mathcal{U}\subseteq\mathbb{R}^{m}$ is the control input at time step $k$ that belongs to a hyper-rectangle control space $\mathcal{U}=[\mathcal{U}_{1},\mathcal{U}_{1}^{\prime}]\times\ldots\times[\mathcal{U}_{m},\mathcal{U}_{m}^{\prime}]$. $f$ is a smooth function representing the dynamics of the system. The $i$th component of $\sigma$, $u$, $f$, and $\gamma$ are denoted by $\sigma_{i}$, $u_{i}$, $f_{i}$, and $\gamma_{i}$, respectively. The system trajectory ($n$-dimensional signal) produced by applying control policy $u=\{u[k]\}$ is denoted by $\langle\sigma,u\rangle$.

A specification over the state of the system is given as a STL formula $\varphi$ with horizon $h_{\varphi}$. We also consider a cost function $J:\mathcal{X}\times\mathcal{U}\rightarrow\mathbb{R}$ where $J(\sigma[k],u[k])$ is a smooth function representing the cost of applying the control input $u[k]$ at state $\sigma[k]$. In the first problem, we intend to determine a control policy $u^{*}=\{u^{*}[k]|k=0,\ldots,h_{\varphi}-1\}$ over the time horizon of the specification $\varphi$ such that $\varphi$ is satisfied, while optimizing the cumulative cost.

Problem 1** (Finite Horizon Control)**

[TABLE]

Furthermore, we intend to find the control policy that results in highest possible robustness degree.

Remark 1

A solution to Problem 1 based on mixed integer linear programming was presented in [15]. A smooth gradient descent solution was also provided in [10]. In both cases, the quantitative semantics defined in (2) was used. In this paper, we utilize an alternative quantitative semantics. We will demonstrate in Section VIII that this will result in a better control synthesis in certain types of applications.

Example 1

Consider an autonomous vehicle on a two dimensional square workspace (Fig. 1). The state of the vehicle consists of the horizontal and vertical position of its center as well as the heading angle ($\sigma=[x,y,\theta]$) The state space is $\mathcal{X}=[0,7]\times[0,7]\times\mathbb{R}$. In Fig. 1, the gray ellipse represents the vehicle. The state evolves according to the following dynamics:

[TABLE]

where $u[k]=[v[k],\omega[k]]$ is the control input and belongs to the space $\mathcal{U}=[0,2]\times[-0.75,0.75]$. $\Delta t$ is the time step size. We consider the cost function $J(\sigma[k],u[k])=||\sigma[k+1]-\sigma[k]||_{2}^{2}$, assigning higher costs to motions over longer distances. Consider the following specification: ”Eventually visit region 1 or 2 (cyan) within $6$ seconds. Afterwards, move to region 3 (green) in at most $4$ seconds and stay there for at least $2$ seconds, while always avoiding the unsafe region 4 (red).” Assuming $\Delta t=0.1$, this translates to:

[TABLE]

where $\mu_{i}$ is the logical formula representing region $i$:

[TABLE]

Note that the horizon of $\phi_{1}$ is $h_{\phi_{1}}=60+40+20=120$.

We intend to determine the control policy $[v[k],\omega[k]]$ over this time horizon that satisfies this specification with highest possible robustness performance and minimum cost.

In the next problem, a time horizon $h_{M}$ is specified by the user such that $h_{M}\geq h_{\varphi}$ and we intend to find the control policy $u^{*}=\{u^{*}[k]|k=0,\ldots,h_{M}\}$ that results in the satisfaction of a given specification $\varphi$ at all times.

Problem 2** (Model Predictive Control for Finite Horizon)**

[TABLE]

Example 2

Consider a linear system as follows:

[TABLE]

where $x\in\mathbb{R}^{2}$, $x_{1}[0]=x_{2}[0]=0$, and $u[k]\in\mathbb{R}$. Consider the following STL specification.

[TABLE]

where $\mu_{5}=(x_{1}>2\wedge x_{1}<4)$ and $\mu_{6}=(x_{1}<-2\wedge x_{1}>-4)$. $\phi_{2}$ requires the value of $x_{1}$ (the first component in $x$) to satisfy both $\mu_{5}$ and $\mu_{6}$ within $4$ time steps in the future. Note that in this example, $h_{\phi_{2}}=4$. Globally satisfying this specification for $h_{M}=15$ time steps ($\mathbf{G}_{[0,15]}\phi_{2}$) means that we require $x_{1}$ to periodically alternate between $\mu_{5}$ and $\mu_{6}$.

V Smooth Cumulative Robustness

The robustness degree from Definition 2 has been widely used in the past few years to solve control problems in various applications. Its soundness and correctness properties have enabled researchers to reduce complex control problems to manageable optimization problems. However, this definition is very conservative, since it only considers the system performance at the most critical time. Hence, any information about the performance of the system at other times is lost. Inspired by [13], we introduce an alternative approach to compute the robustness degree, which we call the cumulative robustness. This robustness is less conservative than (2), and generally results in better performance if employed to solve control problems such as (7) (see Section VIII).

For any STL formula $\varphi$, we define a positive cumulative robustness $\rho^{+}(\varphi,\sigma,t_{k})\in\mathbb{R}_{\geq 0}$ and a negative cumulative robustness $\rho^{-}(\varphi,\sigma,t_{k})\in\mathbb{R}_{\leq 0}$. For this purpose, we use two functions $\mathfrak{R}^{+}:\mathbb{R}\rightarrow\mathbb{R}_{\geq 0}$ and $\mathfrak{R}^{-}:\mathbb{R}\rightarrow\mathbb{R}_{\leq 0}$, which we call the positive and negative rectifier, respectively.

Definition 4** (Rectifier Function)**

[TABLE]

We can use (4) to smoothly approximate both rectifiers:

[TABLE]

The positive and negative cumulative robustness are recursively defined as follows:

Definition 5** (Cumulative Robustness)**

[TABLE]

[TABLE]

An extension to STL, called AvSTL, was introduced in [13]. The authors employed AvSTL to solve falsification problems and did not consider the general control problem in that work. The cumulative robustness for STL as defined in Definition 5 has two main differences from AvSTL. First, we consider signals in discrete time. Second, AvSTL computes the average robustness of $\mathbf{F}_{I}$ and $\mathbf{U}_{I}$ over their time intervals, while we cumulate the robustness. Our purpose is to reward trajectories that satisfy the specification in front of $\mathbf{F}_{I}$ and $\mathbf{U}_{I}$ for longer time periods.

The positive cumulative robustness can be interpreted as robustness for portions of the signal that satisfy the formula and the negative cumulative robustness can be interpreted as robustness for portions of the signal that violate the formula. Our motivation for defining this alternative robustness degree was to modify the robustness of the finally operator in order to cumulate the robustness for all the times in which the formula is true, whereas the traditional robustness degree only considers the most critical time point and does not take other portions of the signal into account. However, this cannot be done in one robustness degree, since the positive and negative values of robustness cancel each other in time. We divide the robustness into two separate positive and negative values to avoid this issue.

The following example demonstrates the advantages of the cumulative robustness (15) in comparison with (2).

Example 3

Consider the STL formula $\varphi_{e}=\mathbf{F}_{[0,10]}(\sigma>1\wedge\sigma<3)$ over a one dimensional signal $\sigma$ in a discrete time space $\tau=\{0,1,2,\ldots\}$. Fig. 2 demonstrates two different instances of this signal $\sigma^{(1)}$ and $\sigma^{(2)}$ starting at $\sigma[0]=0$, both satisfying the formula. $\varphi_{e}$ has the same robustness score with respect to $\sigma^{(1)}$ and $\sigma^{(2)}$ at time 0, $\rho(\varphi_{e},\sigma^{(1)},0)=\rho(\varphi_{e},\sigma^{(2)},0)=1$. This is because the traditional robustness degree of the finally operator $\mathbf{F}_{I}\psi$ only returns the robustness of $\psi$ at the most critical time point in $I$, which is the same for both instances in this case. However, the positive cumulative robustness of $\mathbf{F}_{I}\psi$ adds the robustness at all times in which $\psi$ is satisfied, hence rewarding signals that reach the condition specified by $\psi$ faster and stay in the satisfactory region longer. In this example, $\rho^{+}(\varphi_{e},\sigma^{(1)},0)=2.5$ while $\rho^{+}(\varphi_{e},\sigma^{(2)},0)=7.5$. This is a desirable property in many control applications since by synthesizing controls that optimize the cumulative robustness for the finally operator, we are producing a trajectory of the system that reaches the specified condition as soon as possible and holds it true for as long as possible.

By comparing Definition 5 with Definition 2, it is easy to see that a STL formula is satisfied if the corresponding positive robustness is strictly positive.

Proposition 1

[TABLE]

Furthermore, by combining different operators according to Definition 5, it can be proven that:

Proposition 2

[TABLE]

The same properties hold for $\rho^{-}$ as well. This is important to consider since some of the similar robustness notions, such as the one introduced in [12], neglect these basic properties.

Remark 2

The causes of non-smoothness in (15) are the $\max$, $\min$, $\mathfrak{R}^{+}$, and $\mathfrak{R}^{-}$ functions. Therefore, any cumulative robustness function can be smoothly approximated by replacing any appearance of these terms with their corresponding smooth approximations from (4) and (14). The smooth approximation of $\rho^{+}$ and $\rho^{-}$ are denoted by $\tilde{\rho}^{+}$ and $\tilde{\rho}^{-}$.

Remark 3

Cumulative robustness prohibits the globally operator to be defined from finally, meaning that $\rho^{+}(\mathbf{G}_{I}\varphi,\sigma,t_{k})$ is not the same as $\rho^{+}(\neg\mathbf{F}_{I}\neg\varphi,\sigma,t_{k})$. This is because we are altering the interpretation of finally to mean ”as soon as possible”. In the rest of this paper, we assume that any given STL formula $\varphi$ does not include $\neg\mathbf{F}_{I}{\varphi}$. Any such requirement can be specified with $\mathbf{G}_{I}\neg\varphi$ instead.

VI Smooth Optimization

In previous sections, we demonstrated that two different sound quantitative semantics (traditional robustness $\rho$ and positive cumulative robustness $\rho^{+}$) may be defined for STL specifications. Furthermore, they can be approximated as smooth functions, denoted by $\tilde{\rho}$ and $\tilde{\rho}^{+}$, respectively. In this section, our approach to solve Problem 1 is explained.

To ensure that the state $\sigma$ always remains in the state space $\mathcal{X}$, we add the following requirement to specification $\varphi$:

[TABLE]

We aim to use $\tilde{\rho}^{+}$ in a gradient ascent setting similar to [10] to solve this problem. However, note that $\rho^{+}=0$ any time that a formula is violated. Therefore, $\nabla\rho^{+}=0$ when $\rho^{+}=0$ unless the formula is on the boundaries of violation and very close to being satisfied. As a result, $\tilde{\rho}^{+}$ is almost guaranteed to fall in its local minimum when one initializes the gradient ascent algorithm for $\tilde{\rho}^{+}$, unless there is significant a priori knowledge about the system. The negative cumulative robustness $\rho^{-}$ is not helpful either since there is no soundness theorem associated with it (see Section V).

We can circumvent this setback if we initialize the gradient ascent algorithm such that the specification is already satisfied and we only intend to maximize the level of satisfaction and minimize the cost. Hence, we propose the three-stage algorithm SmoothOptimization (Algorithm 1). The first stage aims to find a control policy that minimally satisfies $\varphi$, the second stage aims to maximize $\tilde{\rho}^{+}$, and the third stage aims to minimize the cumulative cost. In each stage, one optimization problem is solved using the GradientAscent subroutine (Algorithm 2).

Given a generic smooth objective function $Q(\sigma,u)$, an initial control policy $u^{\iota}=\{u^{\iota}[k]|k=1,\ldots,h_{\varphi}\}$, and a termination condition $\mathcal{T}$, Algorithm 2 uses gradient ascent [23] to find the optimal control policy $u^{\Delta}$. It starts by initializing a control policy $u^{\iota}$ for every time step $k\in\{0,\ldots,h_{\varphi}\}$, and computing the corresponding system trajectory $\langle\sigma,u\rangle$ from the system dynamics (6) (lines 2 to 2). At each gradient ascent iteration $i$, it updates the control policy for every time step according to the following rule (line 2).

[TABLE]

where $\alpha_{i}>0$. In the case studies presented in this paper, we used decreasing gradient coefficients $\alpha_{i+1}<\alpha_{i}$. However, one can employ other strategies that might work more efficiently depending on the application [23]. Each component of $\nabla Q$ can be computed as (lines 2 to 2):

[TABLE]

for $p=1,\ldots,m$ and $k=0,\ldots,h_{\varphi}-1$. We continue this process until we find a control policy $u^{\Delta}$ that satisfies $\mathcal{T}$.

Recall that the problem setup in Section IV included constraints for both state ($\sigma[k]\in\mathcal{X}$) and control inputs ($u[k]\in\mathcal{U}$). we have already dealt with state constraints as part of the specification (18). Considering the fact that $\mathcal{U}=[\mathcal{U}_{1},\mathcal{U}_{1}^{\prime}]\times\ldots\times[\mathcal{U}_{m},\mathcal{U}_{m}^{\prime}]$ is assumed to be a hyper-rectangle, the input constraints are included using a projected gradient (line 2) [24].

[TABLE]

At any point in the optimization process, if a component of the control input $u_{p}[k]$ falls outside of the admissible interval $[\mathcal{U}_{p},\mathcal{U}^{\prime}_{p}]$, we simply project it into the interval.

In the first stage of SmoothOptimization (Algorithm 1), we randomly initialize a control policy $u^{0}=\{u^{0}[k]|k=0,\ldots,h_{\varphi}-1\}$ and use the smooth approximation for traditional robustness function $\tilde{\rho}$ as the objective function in GradientAscent, only to find a control policy that minimally satisfies the specification ($\mathcal{T}$ is $\tilde{\rho}>0$).

In the second stage, we use the policy that we get at stage 1 to initialize a second GradientAscent with the objective function $\tilde{\rho}^{+}$ and termination condition $\nabla\rho^{+}<\epsilon$ where $\epsilon$ is a small positive number. Note that $\tilde{\rho}^{+}$ is guaranteed to be strictly positive at the first iteration ($i=0$) due to (16). Therefore, it will remain strictly positive as we proceed in the gradient ascent algorithm since this algorithm is designed such that the objective function only increases at each iteration [23]. This prohibits the algorithm to ever fall in a local minimum at $\tilde{\rho}^{+}=0$.

At the end of the second stage, we have a control policy $u^{\Delta_{2}}$ with a maximal level of cumulative robustness. However, we intend to minimize the cumulative cost $\sum_{k}J$ in Problem 1. We perform a third GradientAscnet with the objective function $-\sum_{k}J$ and control policy initialized at $u^{\Delta_{2}}$. In other words, we are updating the entire control policy gradually in order to decrease the cumulative cost at the expense of cumulative robustness. This stage must terminate before the specification is violated (i.e., while the cumulative robustness is still strictly positive). Hence, the termination condition at this stage is $\tilde{\rho}^{+}<\xi$ with $\xi>0$.

A small choice for $\xi$ results in a control policy with an almost optimal cost that minimally satisfies $\varphi$, while a large choice for $\xi$ results in a control policy with a higher level of cumulative robustness that is sub-optimal with respect to the cost. The user can tune $\xi$ to achieve the desirable balance between the level of satisfaction and cost-optimality.

It is common in the literature to combine the robustness degree and control cost in a single optimization problem, using $\xi\tilde{\rho}-\sum J$ as the objective function [25]. We cannot do the same here since the combination of cumulative robustness $\tilde{\rho}^{+}$ with cost $\sum J$ in a single objective function can lead the value of $\tilde{\rho}^{+}$ to become zero again in the second stage of Algorithm 1. That is why we need to optimize cumulative robustness and cost in two separate stages.

Remark 4

If stage 1 does not terminate, it means that $\varphi$ is infeasible and we do not need to proceed to stage 2.

VII Model Predictive Control

In this section, we describe our solution to Problem 2. Note that while Problem 1 requires specification $\varphi$ to be satisfied at time [math] (i.e., $\langle\sigma,u^{*}\rangle^{0}\models\varphi$), Problem 2 requires it to be satisfied at all times in a $h_{M}$ horizon (i.e., $\langle\sigma,u^{*}\rangle^{t_{k}}\models\varphi\;\forall k\in\{0,\ldots,h_{M}\}$ or equivalently $\langle\sigma,u^{*}\rangle^{0}\models\mathbf{G}_{[0,h_{M}]}\varphi$).

The following procedure is performed to solve this problem. For time step $k=0$, we fix $\sigma[0]$ and use Algorithm 1 to synthesize control policy $u^{h_{0}}=\{u^{h_{0}}[k^{\prime}]|k^{\prime}=0,\ldots,h_{\varphi}-1\}$. This ensures that $\phi$ is satisfied at time $t_{0}$. Now, we only execute $u^{h_{0}}[0]$. At time $k=1$, we fix $\sigma[1]$, use Algorithm 1 to synthesize $u^{h_{1}}=\{u^{h_{1}}[k^{\prime}]|k^{\prime}=0,\ldots,h_{\varphi}-1\}$, and only execute $u^{h_{1}}[0]$, which ensure satisfaction of $\varphi$ at time $t_{1}$. We continue this process until we reach $k=h_{M}$. Consequently, $\mathbf{G}_{[0,h_{M}]}\varphi$ is guaranteed to be satisfied for the following control policy, assuming that it is feasible at all times.

[TABLE]

The smooth optimization procedure becomes particularly advantageous when employed instead of mixed integer programming in a model predictive control setting, since a separate optimization problem needs to be solved at every time step and smooth optimization has a much greater potential for being fast enough to be applied online. Moreover, MILP solvers are very sensitive to the changes in the initial state $\gamma$, which is challenging since one has to solve a new MILP from scratch for any changes that occur in $\gamma$. This becomes a much more complex challenge when a MILP-based approach is used for multi-agent systems [26]. On the other hand, smooth gradient ascent is much less sensitive to small changes in individual variables such as initial state $\gamma$ [23].

Similar to [15], we can stitch together trajectories of length $h_{M}$ using a receding horizon approach to produce trajectories that satisfy $\mathbf{G}_{[0,\infty)}\varphi$. However, this does not guarantee recursive feasibility. In other words, we need to make sure that the resulting trajectory from the optimal controller consists of a loop. If this is the case, we can terminate the computation and keep repeating the control loop forever, which guarantees the satisfaction of the specification at all times, since we know that each loop satisfies the specification.

Formally, we add the following constraint to our optimization problem at every step.

[TABLE]

This ensures that the resulting system trajectory contains a loop. If we find a solution to the optimization problem with positive robustness ($\rho>0$), this loop satisfies the given specification $\varphi$. Therefore, repeating the control strategy that produced this loop forever results in the satisfaction of the formula at all times, ensuring recursive feasibility.

We use a brute force approach to find $k,K$ that satisfy (23). In other words, we start by guessing values for these parameters and keep changing them until we find values for which a solution to the optimization problem exists. Fixing the values of $k$ and $K$ eliminates the quantifiers in (23) and turns it into a linear constraint which is handled easily by any gradient descent solver through projection methods.

In the future, we plan to investigate other approaches to solve the problem with this additional constraint.

VIII Case Study

In this section, we illustrate how our algorithms are able to solve Examples 1 and 2 in Section IV. All implementations were performed using MATLAB on a MacBook Pro with a 3.3 GHz Intel Core i7 processor and 16 GB of RAM.

VIII-A Example 1: Path Planning for Autonomous Vehicles

Consider the system and specification of Example 1 with the dynamics of (8) and specification $\phi_{1}$ presented in (9). We assume that there are two vehicles (Yielding a 6 dimensional state space). Each vehicle starts from a different initial position and orientation, but follows the same dynamics. Both are required to follow the specification $\phi_{1}$ while avoiding collision. Recall that the objective is to visit one of the cyan regions in $6$ seconds and go to the green destination in at most $4$ seconds after that, while avoiding the red region (Fig. 1). We used Algorithm 1 to solve this problem. The solution was computed in 18.3 seconds and the optimal path for each vehicle is shown in Fig. 3(a). The optimal path with respect to the traditional robustness score was also computed in 13.4 seconds and demonstrated in Fig. 3(b). It is obvious from these figures that optimizing the cumulative robustness results in paths in which the vehicles get to the their respective destinations faster and remain there longer.

VIII-B Example 2: MPC for a Linear System

Consider the system and specification of Example 2 with the dynamics shown in (11) and specification $\phi_{2}$ presented in (12). We used Algorithm 1 in conjunction with the MPC framework as described in Section VII to solve Example 2 with optimal cumulative robustness. The computation took 6.73 seconds. Additionally, we computed the control policy derived from only optimizing the traditional robustness $\tilde{\rho}$.

The corresponding evolution of $x_{1}$ according to the system dynamics (11) for both cases is presented in Fig. 4. According to (12), the goal is for $x_{1}$ to periodically visit both of the green regions in this figure, always visiting each region within at most 4 time steps in the future. Fig. 4 shows that both control policies satisfy this requirement. However, the trajectory that results from optimizing $\tilde{\rho}^{+}$ (dashed blue) tends to stay in the green regions as long as possible. On the other hand, by optimizing the traditional STL robustness $\tilde{\rho}$, we are only ensuring that the green regions are visited once every $4$ time steps, and do not have any control over the duration of satisfaction. Fig. 4 shows that the dotted black trajectory visits the green regions, but does not stay in them.In fact, it goes beyond the green regions three times.

VIII-C MPC for a Noisy Linear System

We have demonstrated in previous case studies that cumulative robustness has a more desirable performance than conventional STL robustness. Now, we discuss the possibility that cumulative robustness can result in more robust control policies once noise is introduced to the system. Intuitively, since cumulative robustness adds up STL robustness over time, it may provide the added benefit of canceling out some of the perturbations caused by environmental noise over time. We investigate this phenomenon in this case study.

Assume that we introduce disturbance to the system considered in the previous example:

[TABLE]

where $w[k]\in\mathbb{R}^{2}$ and $w_{i}[k]\thicksim\mathcal{N}(0,0.1)$ represents system disturbances with a normal distribution of [math] mean and $0.1$ variance. We consider the same specification as before (12).

We employed statistical model checking [27] to investigate how the control policies that were synthesized in Section VIII-B perform if system disturbances are considered. The Bayesian estimation algorithm from [27] was implemented, which computes the probability that a stochastic system satisfies a given specification, given a pre-determined margin of error and confidence level (i.e., the likelihood that the actual probability of satisfaction fall within the margin of error from the reported probability of satisfaction by the algorithm). The results are presented in Table I.

Fig. 5 illustrates 20 sample trajectories from the system of (24) resulting from the control policies synthesized in the previous example (Section VIII-B). Recall that the specification was for $x_{1}$ to reach the green regions periodically within $4$ time steps. Indeed, the trajectories derived from cumulative robustness (blue) are more resistant to disturbances and follow the specification much more consistently.

Remark 5

The intention in this case study was merely to demonstrate that cumulative robustness has the potential to improve controller performance under uncertainty and noise. We plan to study a provably robust MPC framework for this robustness function in the future.