Computation of robust positively invariant set based on direct data-driven approach

1. INTRODUCTION

A set is defined as a robust positively invariant (RPI) set, if every initial state contained within it, the trajectory of the system's state remains confined to that set, regardless of any disturbances or uncertainties in its parameters ^[1]. In the domain of automatic control, the significance of RPI sets is self-evident. The theories and computational approaches of RPI sets have not only attracted significant interest in the academic community but also demonstrated extensive application values in multiple practical fields such as system stability analysis, controller design, and nonlinear system theory ^[1-6]. Moreover, RPI sets offer us a powerful tool for evaluating and resolving a series of issues closely related to external unknown disturbances.

For linear discrete systems, several approaches have been proposed to compute the RPI sets ^[7-10]. These are model-based approaches that assume the system is usable. However, achieving precise and dependable models in practical applications is challenging, and imprecise models can result in a loss of system invariance and breach associated constraints ^{[11, 12]}, potentially leading to unstable system operation or suboptimal controller performance. To address these limitations, direct data-driven approaches have emerged as a viable alternative, eliminating the need for model identification ^[12]. As we all know, the two important forms of invariant sets are polyhedral and ellipsoidal sets ^[4]. Ellipsoidal sets may be more conservative than polyhedral sets. Since polyhedral sets offer more flexible and complex representations, they have an advantage over ellipsoidal sets both in theory and practice ^[1]. Additionally, polyhedral representations naturally capture physical constraints on state and control variables ^[3]. Due to these factors, this paper emphasizes the study of polyhedral sets.

In this paper, we propose a direct data-driven method ^{[11, 13]} for computing polyhedral RPI sets. We assume that the RPI set is a 0-symmetric convex polyhedron of predetermined complexity. The method presented in ^[14] involves a relatively high number of algorithm optimization variables and linearized matrix inequality constraints, resulting in slow running speeds. Our method expands upon and optimizes the approach recently developed by Mejari $$ et\; al $$^[14]. We have derived a new invariance condition and developed an iterative algorithm based on this condition. In addressing the nonlinear problem of the invariance condition, we ingeniously utilize relevant variable transformations and appropriate scaling techniques. Subsequently, a series of LMIs ^[15] are employed to precisely represent the constraints and invariance requirements of the system. Finally, we resort to the semidefinite programming (SDP) problem for solution, aiming to maximize the volume of the RPI sets. Notably, our method does not require an accurate system model or system identification steps; it merely requires a state trajectory composed of a finite number of data samples as input. Furthermore, the number of optimization variables and LMIs in this iterative algorithm is less than that in ^[14], thereby reducing running time and operating costs to some extent.

The primary contribution of this paper lies in the introduction of a novel data-driven methodology tailored for computing systems equipped with RPI sets. This approach holds significant relevance, particularly within the realms of control system design and analysis. A standout feature of our method is its reliance on a limited dataset, bypassing the need for comprehensive mathematical model knowledge-a pivotal advantage in numerous practical applications where precise mathematical models are elusive or challenging to derive. Our work commences by establishing two fundamental equivalence criteria pertaining to invariance properties. Building upon these, we devise two single-step algorithms grounded in LMI frameworks for the computation of RPI sets, denominated as Algorithm 1 and Algorithm 2. A comparative assessment between these algorithms is subsequently undertaken.

Experimental evaluations disclose that although both algorithms converge upon identical RPI sets, Algorithm 1 distinguishes itself through reduced optimization variable requirements and exhibits superior computational efficiency relative to Algorithm 2. This distinction carries substantial weight in practical implementations, as augmented computational speed directly contributes to enhanced real-time system performance and cost efficiency.

Capitalizing on the merits of Algorithm 1, we further propose an iterative refinement strategy aimed at incrementally approximating the target volume of RPI sets over successive iterations. This iterative algorithm ingeniously retains the computational efficiency hallmark of Algorithm 1 while simultaneously alleviating resultant conservatism, thereby striking a balance between precision and performance.

The structure of this paper is as follows: Preliminaries and problem formulation are given in Section $$ {\text{ 2.1 }} $$. Section $$ {\text{ 2.2 }} $$ presents data-based invariances and constraints. Section $$ {\text{ 2.3 }} $$ gives the relevant algorithms to maximize the RPI $$ {\text{sets}} $$. Numerical examples are given in Section $$ {\text{ 3 }} $$. Section 4 provides the discussion. Section 5 gives a summary of this article.

Notations: The following notations are made in this paper. The set of positive real numbers is denoted by $$ R_{+} $$; a diagonal matrix with positive members is denoted by $$ D_+^n $$; the matrix $$ A $$'s transpose is $$ A^T $$. $$ R^{n} $$ denotes $$ n $$-dimensional Euclidean space, and $$ R^{n \times m} $$ denotes a set of $$ n \times m $$-dimensional matrices. A matrix containing zeros in the relevant dimension is written as $$ \mathbf{0} $$. $$ \mathbf{1}_m $$ represents the vector of ones of dimension $$ m $$. The identity matrix in $$ m $$ dimensions is written as $$ I_m $$, and the $$ i $$-th column of the identity matrix is denoted by the symbol $$ e_i $$. $$ \ast $$'s represents the matrix element that is uniquely identifiable by symmetry. For the symmetry matrix $$ X $$, $$ X $$$$ \succeq $$ 0 ($$ \succ $$ 0) indicates that the matrix $$ X $$ is a semi-positive definite matrix (positive definite matrix). Let $$ A\in R^{m \times n} $$ be a matrix of $$ n $$ vectors $$ A $$ = [$$ a_1\dots a_n $$], we define the vectorization of $$ A $$ as $$ \vec{A} = [a_{1}^{T}\dots a_{n}^{T}]^T \in R^{mn} $$. For the finite set $$ \Theta_{v} $$ = $$ \left\lbrace \theta^1,\dots,\theta^t\right\rbrace $$ with $$ \theta ^j\in R^n $$ for $$ j=1,\dots, t $$, $$ conv(\Theta_{v}) = \left\lbrace \theta \in R^{n}:\theta =\sum_{j=1}^{t}\alpha_{j}\theta^{j},s.t \sum_{j=1}^{t}\alpha_{j}=1,\alpha_{j}\in [0,1]\right\rbrace $$ denotes the convex-hull of a $$ \Theta_{v} $$, and $$ A \otimes B $$ denotes the Kronecker product between $$ A $$ and $$ B $$.

2. METHODS

3. RESULTS

The algorithms in the experiments are implemented in Matlab by using CVX ^[23] and solver SeDuMi. And the MPT toolbox is used to manage polytopes ^[24]. The following liner discrete-time system is considered:

The matrice $$ A $$ is unknown, but it is only used to gather data. $$ T $$ = 20 samples of data are collected by system (43), as shown in Figure 1. Assume the disturbance $$ w $$ in system (43) ranges between -0.1 and 0.1, with the state constraints being $$ (x_{1}, x_{2}) \in [-2, 2] \times [-2,2] $$.

Figure 1. The data samples collected from the liner discrete-time system (43).

Example 1: By taking different matrices $$ P $$, the complexity of the RPI set is denoted as $$ n_{p} $$ = 2, 3, 4 respectively, and the corresponding matrices are computed as follows

$$ P_{2}=\left[ \begin{array}{cc} 1&0 \\ 0&1 \end{array}\right] $$, $$ P_{3}=\left[ \begin{array}{ccc} 10&10 \\ 10&0\\ 1&11 \end{array}\right] $$, $$ P_{4}=\left[ \begin{array}{cccc} -18&-55 \\ 18&55\\ 55&-18\\ 55&18 \end{array}\right] $$.

The matrice $$ W $$ is computed by running Algorithms 1 and 2 as follows:

$$ W_{21}=\left[ \begin{array}{cc} 3.5&0 \\ 0&1 \end{array}\right] $$(Algorithm 1, 2.039 $$ {\text{s}} $$), $$ W_{22}=\left[ \begin{array}{cc} 3.5&0 \\ 0&1 \end{array}\right] $$(Algorithm 2, 2.770 $$ {\text{s}} $$),

$$ W_{31}=\left[ \begin{array}{cc} 35&1 \\ 1&11 \end{array}\right] $$(Algorithm 1, 2.418 $$ {\text{s}} $$), $$ W_{32}=\left[ \begin{array}{cc} 35&1 \\ 1&11 \end{array}\right] $$(Algorithm 2, 4.552 $$ {\text{s}} $$),

$$ W_{41}=\left[ \begin{array}{cc} 151.4106&18.1135 \\ 18.1135&55.0114 \end{array}\right] $$(Algorithm 1, 2.410 $$ {\text{s}} $$), $$ W_{42}=\left[ \begin{array}{cc} 151.4106&18.1135 \\ 18.1135&55.0114 \end{array}\right] $$(Algorithm 2, 4.725 $$ {\text{s}} $$),

where $$ W_{21} $$ and $$ W_{22} $$ are obtained from $$ P_{2} $$; $$ W_{31} $$ and $$ W_{32} $$ are obtained by taking $$ P_{3} $$; $$ W_{41} $$ and $$ W_{42} $$ are obtained by taking $$ P_{4} $$.

It is discovered from experiment results that while Algorithm 2 yields the same results, Algorithm 1 runs faster and requires fewer optimization variables (see Remark $$ {\text{2}} $$) than Algorithm 2.

Example 2: The RPI sets with complexities $$ n_{p} $$ = 2, 3, 4 (i.e., $$ P_{2} $$, $$ P_{3} $$, $$ P_{4} $$ are selected respectively) which are obtained by Algorithm 1 are as follows

$$ W_{2}=\left[ \begin{array}{cc} 3.5&0 \\ 0&1 \end{array}\right] $$, $$ W_{3}=\left[ \begin{array}{cc} 35&1\\ 1&11 \end{array}\right] $$, $$ W_{4}=\left[ \begin{array}{cc} 151.4106&18.1135 \\ 18.1135& 55.0114 \end{array}\right] $$.

The corresponding RPI sets obtained by Algorithm 1 are shown in Figure 2.

Figure 2. Maximum volume RPI sets $$ \mathcal{P} $$ with different complexities: $$ n_{p} $$ = 2 (left), $$ n_{p} $$ = 3 (right), $$ n_{p} $$ = 4 (bottom).

After five times iterations of the $$ {\text{iterative algorithm}} $$, the RPI sets $$ \mathcal{P} $$ with complexities $$ n_{p} $$ = 2, 3, 4 are obtained as

$$ W_{2}=\left[ \begin{array}{cc} 3.5&0 \\ 0&1 \end{array}\right] $$, $$ W_{3}=\left[ \begin{array}{cc} 35&1\\ 1&11 \end{array}\right] $$, $$ W_{4}=\left[ \begin{array}{cc} 192.5402&-63.3969 \\ 18.1136& 55.0115 \end{array}\right] $$.

The corresponding RPI sets obtained by iterative algorithm are shown in Figure 3.

Figure 3. Maximum volume RPI sets $$ \mathcal{P} $$ with different complexities: $$ n_{p} $$ = 3 (left), $$ n_{p} $$ = 4 (right).

We find that the volume of RPI $$ {\text{sets}} $$ obtained by the $$ {\text{iterative algorithm }} $$ is larger than that obtained by Algorithm 1 (see Table 1 and Table 2), which indicates that Algorithm $$ 1 $$ is more conservative than the $$ {\text{iterative algorithm}} $$. For the given matrix $$ P $$, $$ {\text{the volume of} \mathcal{P} } $$ is proportional to the determinant $$ \left|det(W)\right| $$^[19]. And as $$ n_{p} $$ rises, the absolute value of the determinant of $$ W $$ grows; thus, the volume of the RPI set increases (see Table 1 and Figure 4), so that an invariant set with a higher volume can be obtained by adding $$ n_{p} $$ as a parameter.

Figure 4. $$ |det(W)|\; {vs.} $$ iterations of iterative algorithm.

4. DISCUSSION

A direct data-driven method is proposed to calculate the robust positive invariant (RPI) sets for discrete-time systems. To further reduce conservatism, an iterative algorithm based on Algorithm 1 is introduced. This approach does not require prior knowledge of the model or system identification. Future research could extend this methodology to nonlinear systems. Additionally, while the RPI sets discussed here are symmetric, the exploration of asymmetric RPI sets is another potential area for investigation.

5. CONCLUSIONS

This paper proposes a direct data-driven method to calculate RPI sets for discrete-time systems by deriving a set of invariance conditions expressed as linear matrix inequalities (LMIs). Subsequently, we maximize the volume of the invariant set using a SDP problem. We have developed two one-step algorithms based on LMIs to compute the RPI sets; experimental results indicate that Algorithm 1 requires fewer optimization variables compared to Algorithm 2 and demonstrates superior computational efficiency. Additionally, we have introduced an iterative approach based on Algorithm 1 to further reduce conservatism. Numerical examples have verified the effectiveness of the proposed algorithm.

DECLARATIONS