{'fraction_non_alphanumeric': 0.04737743593058204, 'fraction_numerical': 0.0077238793911385455, 'mean_word_length': 4.152181152181152, 'pattern_counts': {'":': 0, '<': 9, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 17, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A System Level Approach to Discrete-Time Nonlinear Systems

We will show that there is a universal connection between the achievable closed-loop dynamics and the corresponding feedback controller that produces it. This connection shows promise to lead to new methods for robust nonlinear control in discrete-time. We will show that, given a causal nonlinear discrete-time system and controller, the resulting closed-loop is a solution to a nonlinear operator equation. Conversely, any causal solution to the nonlinear operator equation is a closed-loop that can be achieved by some causal controller. Moreover, solutions can be substituted into a simple dynamic controller structure, which we will refer to as a system level controller, to obtain an implementation of the unique corresponding feedback controller. System level controllers could be an attractive approach for robust nonlinear control, as we will show that even when they are parametrized with approximate solutions to the operator equation, they can still produce robustly stable closed loops. We will provide theoretical results that state how grade of approximation and robust stability of the closed loop are related. Additionally, we will explore some first applications of our results. Using the cart-pole system as an illustrative example, we will derive how to design robust discrete-time trajectory tracking controllers for continuous-time nonlinear systems. Secondly, we will introduce a particular class of system level controller that shows to be particularly useful for linear systems with actuator saturation and state constraints. The special structure of the controller allows for simple stability and performance analysis of the closed-loop in presence of disturbances. A particular application to large-scale systems with actuator saturation and safety constraints is presented in our companion paper.


I. INTRODUCTION
Compared to linear control theory, there are fewer mathematical tools for tackling controller synthesis of general nonlinear systems. Nevertheless, with the recent explosion of available computational resources and progress in the optimization and control theory community, significant progress has been made towards achieving a more generalized, datadriven approach to nonlinear control design. With the sumof-squares methods (SOS) [2], [3], it became possible to compute Lyapunov functions for stability analysis through convex optimization. SOS-based controller synthesis methods are presented in [4], [5] and [6] for the continuous-time (CT) and discrete-time (DT) settings, respectively. Examples of computational methods based on approximating solutions of Hamilton-Jacobi-Bellman type of equations are found in [7], [8], [9]. Other, more recent works [10] (CT), [11] (DT) provide alternative formulations of optimal controller synthesis through occupation measures. Dimitar Ho is with the Department of Computing and Mathematical Sciences, California Institute of Technology, Pasadena, CA.

dho@caltech.edu
Inspired by the recently developed system level approach to linear control theory [12], we will present a new insight on nonlinear discrete-time systems that we believe could lead to entirely new synthesis methods for nonlinear discretetime systems. The system level approach, as introduced in [12], enabled new efficient controller synthesis methods [13], [14] that allow for localized, distributed and scalable control design in large-scale systems. This is achieved by transforming constrained optimal control problems as convex optimization problems over achievable closed-loop maps that can be solved efficiently. A key component of the system level synthesis (SLS) procedure is that once we have solved for the desired closed-loop map, there is a simple way to construct a controller that stably realizes this on the system.
In this paper we will show that this connection between closed-loop maps and their corresponding realizing controller is not a mere phenomenon of linear systems, but rather a surprisingly universal control principle that extends to general nonlinear discrete time systems. We will show that given a feasible nonlinear closed-loop map from disturbance to state and input, we can follow a procedure to construct an internally stable dynamic controller that realizes the given closed-loop maps. More specifically, we will characterize the space of all feasible closed-loop maps as solutions to a nonlinear operator equation and define a dynamic controller that realizes them. In particular, the realizing dynamic controller is obtained by parameterizing a simple controller structure with the solutions of the operator equation. Yet as it turns out, this controller structure, which we will refer to as system level (SL) controller, offers more benefits than its intended original purpose. In fact, we will show that we can parameterize an SL controller with approximate solutions of the operator equation and still obtain stabilizing feedback controllers, if the approximation error is small enough. To this end, we will discuss a simple sufficient stability condition based on the small-gain theorem.
The presented approach motivates new paths towards nonlinear control synthesis: 1, finding approximate solutions to the closed-loop operator equation and 2, Obtaining a stabilizing controller by parameterizing an SL controller with the approximate solutions. We will conclude this work by exploring two direct applications of this approach: 1) We apply the approach to the problem of trajectory tracking for nonlinear continuous-time systems through discrete-time zero-order hold feedback control. As a case study, we evaluate the SL controller on the cartpole system and demonstrate that despite using only a rough model for synthesis, the resulting controller produces very robust closed loop performance.
2) We will show that the presented framework gives a systematic way to "blend" multiple linear controllers into one stabilizing nonlinear controller. The resulting structure of the controller fits particularly well into the problem setting of linear systems with actuator saturation and provides new ways to do simple stability and performance analysis of the closed loop. In our companion paper [1], we will show how this technique can be used to improve performance in large-scale linear systems that are subjected to actuator saturation, while guaranteeing that specified safety constraints are never violated.
We will begin with some notational conventions and mathematical preliminaries.

II. PRELIMINARIES AND NOTATION
We will define to be the space of real scalar sequences and n to be the space of all sequences in R n over the index set N. Furthermore, sequences will be denoted by small bold letters x := (x k ) ∞ k=0 and occasionally we will define sequences explicitly with the tuple notation x := (x 0 , x 1 , x 2 , . . . ). In addition, we will use the notation x i:j to refer to the truncation of the sequence to the tuple (x i , x i+1 , . . . , x j ) for (i < j) and in reordered form (x i , x i−1 , . . . , x j ) for (i > j). Denote δ = (1, 0, 0, . . . ) as the scalar unit impulse sequence. Furthermore, if not otherwise specified, we will use | · | to denote an arbitrary norm in R n and for matrices A, |A| refers to the corresponding induced norm of A. · will be reserved for norms on sequence spaces and n . We will use the following definition of the norm · p over vector sequences x ∈ n : Correspondingly, define the vector sequence space n p ⊂ n as n p = {x ∈ n | x p < ∞}.

A. Causal Operators
Operators will be denoted in bold capital letters A and will represent maps between vector sequence spaces n → m . An operator will be called causal, if for any pair of input x ∈ n and corresponding output y = A(x), the values of y t do not depend on future input values x t+k , k ≥ 1. More precisely, we will define A : n → m to be a causal operator if there are functions, A t : R n×(t+1) → R m that allow A to be equivalently represented as If in addition, the functions A t satisfy A t (x t:0 ) = A t (0, x t−1:0 ), i.e. are constant in their first parameter, then A will be called strictly causal. The functions {A t } fully characterize a causal operator and will also be called component functions of A. Notice that every component function A t has t+1 arguments which are populated in reverse-chronological order in Definition (1). For notational convenience define A i:j : R n×(max{i,j}+1) → R k×(|j−i|+1) for j ≥ i as and for j < i as Define the space of all causal and strictly causal operators X → Y as C(X , Y) and C s (X , Y), respectively. Similarly, define LC(X , Y) ⊂ C(X , Y) and LC s (X , Y) ⊂ C s (X , Y) the space of all linear causal and strictly causal operators.

B. Addition and Multiplication of Operators
Sums and products of operators are defined as binary operations on the space of causal operators where It is crucial to remember that for general operators, the above defined multiplication is not commutative and is only leftdistributed over the summation but not right-distributed, i.e.: ) and with slight abuse of notation, we will also use the notation A = (A 1 , A 2 ) to define A 1 ∈ C( n , m ) and A 2 ∈ C( n , h ) as the partial maps of A ∈ C( n , m × h ).

III. CLOSED-LOOP MAPS AND REALIZING CONTROLLERS
This section will focus on introducing the notion of closedloop maps as causal operators w.r.t. general discrete-time nonlinear systems with additive disturbances. Moreover, we will derive necessary and sufficient conditions for operators to be closed-loop maps and how they can be realized by a dynamic controller.
Define the discrete-time nonlinear closed-loop S 1 as the dynamical system described by the following equations: with x t ∈ R n , u t ∈ R m , w t ∈ R n being the state, input and disturbance of the system. The functions f t : R n×t × R m×t → R n characterize the open-loop system behavior and K t : R n×t+1 → R m represents some causal feedback control applied to the system. Alternatively, we can express the dynamics of S 1 as a nonlinear equation in signal space. First, group together the functions f t and K t into the strictly causal operator F : n × m → n and causal operator K : n → m as Now, we can equivalently define the closed-loop S 1 as all trajectories x ∈ n , u ∈ m and w ∈ n that are solutions to the nonlinear equation: We will use F and K to refer to the plant (2a) and controller (2b) of the closed-loop S 1 and will refer to (5) as the operator form of the closed-loop.
From the equations (2a) it is clear that for any disturbance sequence w, the closed-loop S 1 produces unique trajectories x and u. Therefore, the closed-loop S 1 induces a welldefined mapping between disturbances w and state/input trajectories (x, u) and it is clear that the mapping is causal. We will define the map w → (x, u) as the closed-loop map Φ S1 [F, K]: Definition III.1 (Closed-Loop Maps). Define Φ S1 [F, K] ∈ C( n , n × m ) as the unique operator that satisfies for all trajectories w, x, u of S 1 , the relationship Φ S1 [F, K](w) = (x, u). Φ S1 [F, K] will be called the closed-loop map of the plant F w.r.t K. Moreover we will refer to the partial Moreover, we will define the set of all such maps Ψ, the space of all realizable CLMs Φ S1 [F]: Definition III.2 (Space of Realizable CLMs). Given a plant F, the space of all realizable closed-loop maps Φ S1 [F] ⊂ C( n , n × m ) is defined as: A main result of this paper is the following characterization of the space Φ S1 [F]: Proof. See appendix.
As it turns out, the space of realizable CLMs Φ S1 [F] can be precisely characterized as solutions to the nonlinear operator equation (6). We will therefore also refer to (6) as the CLM equation. Writing out the CLM equation (6) in terms of component functions gives the more explicit condition on the functions Ψ x t , Ψ u t : The map Ψ = (Ψ x , Ψ u ) satisfies (6) if and only if its component functions satisfy the following infinite set of function equations for all inputs w t:0 : Moreover, Theorem III.3 states that the mapping between CLMs (Ψ x , Ψ u ) ∈ Φ S1 [F] and the corresponding realizing controllers K is one-to-one, via the relationship K = Ψ u (Ψ x ) −1 . A crucial step of establishing Theorem III.3, is to show that (Ψ x ) −1 always exists. This partial result follows from the following important fact, which will be used frequently: Now, since A − I is strictly causal, the component function and proves existence and uniqueness of b as it describes a concrete recursive procedure of its computation.
The above proposition explains the guaranteed existence of (Ψ

A. System Level Implementation of Realizing Controllers
Furthermore, the previous Prop. III.1 shows us a concrete way to implement the realizing controller K = Ψ u (Ψ x ) −1 of Theorem III.3: Given an input a, the output b = K (a) can be computed recursively through the equations The above implementation represents a dynamical system with input a, output b and internal state c and will be referred to as the system level implementation of K . Moreover, in later sections we will make use of this implementation to define controllers K that are parametrized by operators Ψ x , Ψ u that are not necessarily CLMs. In particular, the next section will show that such an implementation can give closed-loop stability if Ψ is satisfying (6) approximately. Therefore we will define such structured controllers separately as System Level (SL)-controllers: . Consider the dynamical system with input a, output b and internal state c according to the equations The above dynamical system will be referred to as the system level controller SL[A, B].
A simple yet important consequence of the definition Def. III.4 is that both input a and output b can always be expressed through the internal state c as a = Ac, b = Bc.

IV. ROBUST STABILITY OF CLOSED-LOOP
As shown in the previous section, any closed- , then for any disturbance w, the trajectories (x, u) of the closed-loop S 1 will be (x, u) = Ψ(w). In this section, we will show that under mild assumptions, the controller K = SL[Ψ x , Ψ u ] guarantees internal stability of the closed-loop. Moreover, we will show that closed-loop stability is guaranteed even if Ψ is satisfying the CLM equation (6) only approximately.
To setup the stability analysis we will take the original closed-loop (2a) with K chosen to be SL[Ψ x , Ψ u ] and add additional perturbation signals v and d to the internal state of the system level controller and control input. We will call the new perturbed closed-loop S 1 : As before, w, x and u represent system disturbance, state and input, and the added stateŵ represents the internal state of the system level controller. Furthermore, in line with the definition Def. III.4 we will assume Ψ x −I ∈ C s ( n , n ), yet we will for now not restrict the maps Ψ to lie in the space of feasible CLMs Φ S1 [F]. With F defined as in (3), S 1 can be equivalently written in operator form as Analogously to Def. III.1, define between the perturbation signals δ and system/controller states of the closed-loop S 1 . Accordingly, define the partial We will analyze stability of the closed-loop S 1 by defining a nominal perturbation δ * with corresponding nominal response (x * , u * ,ŵ * ) = Φ S 1 (δ * ) of S 1 and then investigating how much the closed-loop response (x, u,ŵ) = Φ S 1 (δ) changes if δ deviates from δ * . We will then call S 1 to be p -stable at δ * , if Φ S 1 (δ) − Φ S 1 (δ * ) p is small for perturbations δ close to δ * in the p -sense. More formally, we will use the following notion of p -stability for operators in the statement of our results: Definition IV.1. An operator A ∈ C( n , m ) is called: • finite gain (f.g.) p -stable 1 at a 0 ∈ n p , if there exists γ, β ≥ 0 such that for all a ∈ n p : A(a) − A(a 0 ) p ≤ γ a − a 0 p + β.
• incrementally finite gain 2 (i.f.g.) p -stable if there exists γ, β ≥ 0 such that for all a, a ∈ n p holds: Notice that while the above definition might not be standard, it allows for stability analysis of equilibria, trajectories and limit cycles all within the same definition. With respect to Def. IV.1, the result of Theorem IV.2 presents general conditions for closed-loop stability of S 1 : Proof. See appendix.
Remark IV.1. Note that F being i.f.g p -stable does not imply that the open loop system has to be stable. Rather, it can be seen as a generalized smoothness condition. For example: Remark IV.2. Using the small-gain theorem presented in the Appendix II, further global and local results can be obtained that do not require the i.f.g property.
Assuming F is i.f.g p -stable, an immediate corollary of Theorem IV.2 is that if we choose Ψ ∈ Φ S1 [F] to be an i.f.g p -stable closed-loop map, then the perturbed closedloop S 1 is f.g.p stable, i.e. this shows that SL controllers implement CLMs in an internally stable way. Moreover, Theorem IV.2 also states that if Ψ is an approximate solution to the CLM equation (6) We derived that in theory we only need operators (Ψ x , Ψ u ) to approximately satisfy the CLM condition (6) to obtain robustly stabilizing controllers SL[Ψ x , Ψ u ]. The generality of the robustness result argues that system level controllers could be a promising design tool in practical control applications. Nevertheless, further research needs to quantify the trade-off between grade of approximation of the condition (6) and corresponding achievable control performance. As a first step towards that, we present some first empirical results that show that system level controllers can achieve good robust control performance in challenging-to-control nonlinear systems while using only crude models of the system for synthesis: Fig. 1 shows simulation results of using a system level controller SL[Ψ x , Ψ u ] at 30 Hz sampling time to swing up a cart pole system under small and large closedloop perturbations. Rather than satisfying the CLM condition (6) of the zero-order hold actuated cart pole system, the maps Ψ are synthesized using the following approximations: • Ψ are taken to be affine operators, where the affine term is a sampled continuous-time desired trajectory (x d (t), u d (t)) for the system and linear part is chosen to be finite memory (2 s window in continuous-time). Remark V.1. See Appendix III for derivations and more detailed discussion of the synthesis procedure.
The above simplifications make clear that Ψ serves only as a very coarse approximation of the exact CLM condition (6). On the other hand, the above approximations allow to synthesize the linear part of Ψ analytically and in parallel, allowing for efficient computation. Leaning on the discussion in Section IV, the closed-loop S2 of the cart pole simulation can be written as where w, d and v are state, input and internal controller state perturbations and e t is due to errors in the trajectory synthesis. The matrices R t,k ∈ R n×n , M t,k ∈ R m×n are parameterizing the linear part of Ψ. Due to the approximation steps taken in the synthesis of Ψ, there is a considerable gap between the real system and the model used for synthesis.
Nevertheless, Fig. 1 shows that despite large model uncertainty, the closed-loop provides robust performance against a variety of perturbations: Large initial condition errors, large perturbation signals and errors in trajectory.

B. Nonlinear Controller Synthesis for Constrained Linear Systems
In our companion paper [1], we show that system level controllers SL[Ψ x , Ψ u ] parametrized with a special class of nonlinear maps Ψ = (Ψ x , Ψ u ) are particularly useful for linear systems subject to state/input constraints with actuator saturation. In Appendix IV we present the generalized procedure to construct such nonlinear system level controllers and derive the robust closed loop stability and performance bounds for linear systems with actuator saturation. The particular controller structure SL[Ψ x , Ψ u ] used in [1] takes the following general form where R i t,k ∈ R n×n , M i t,k ∈ R m×n and P Ωi (w) are projection maps onto some closed bounded convex nested sets Ω 1 ⊂ · · · ⊂ Ω i ⊂ · · · ⊂ Ω N −1 in R n . [1] shows that the above controllers can be synthesized to merge benefits of different linear controllers together into one nonlinear controller and shows how this proves useful when dealing with optimal control problems that have competing performance and safety objectives. In particular, [1] considers the linear optimal control problem of minimizing the closed-loop LQG-cost while also guaranteeing state and input constraints in presence of adversarial disturbances and demonstrates a synthesis procedure for R i t,k , M i t,k that provably outperforms the optimal linear controller for this problem. An additional benefit of the above SL controller is that it has natural anti-windup properties, i.e. it can be easily synthesized to guarantee closed-loop stability and graceful degradation of performance in presence of actuator saturation (See Appendix IV for detailed discussion). Furthermore, [1] points out that the nonlinear "blended" SL controller preserves a main benefit of the original linear SLS framework of [12]: It allows for distributed implementation and naturally incorporates delay and sparsity constraints into the synthesis procedure, all features that allows the approach to scale to the large-scale system setting.

VI. FUTURE WORK AND OUTLOOK
The presented discussion and results are in principle applicable or extendable to a broad frontier of possible use cases. Nevertheless, further research is necessary in order to investigate the systems and conditions for which the CLM operator equation can be approximated in a computationally efficient manner. This paper showed some initial results that demonstrate the former can be accomplished with meaningful closed-loop performance in the problem settings of nonlinear trajectory tracking and control synthesis for linear systems with actuator saturation and state constraints. It would be interesting to see if the approach could produce robust trajectory tracking for other nonlinear systems. For example, based on our simulation results, it is conceivable that the approach could be applied to tracking control of trajectories and periodic orbits in other robotic systems. Another question for future research is whether our discussion in Appendix IV can be extended to piece-wise linear systems and how other existing approaches in the literature relate to the presented "blended" system level controllers. Furthermore, upcoming work will investigate implications of the presented theory for model predictive control.

VII. CONCLUSION
This paper highlights a surprisingly general and fundamental relationship between closed-loop maps and corresponding realizing controllers in general nonlinear discrete-time systems.
The key findings are: 1. All closed-loop maps are solutions to an operator equation and all solutions of the equation are achievable closed-loop maps. 2. Given a solution of the operator equation, we can obtain a realizing controller by parameterizing a system level controller with the solution. This controller then imposes the given solution as the closedloop map of the system. 3. This same procedure produces robust closed-loop stability even when the system level controllers are parametrized with approximate solutions of the operator equation. We conclude with an outlook on the new opportunities this framework could provide for nonlinear control synthesis.
Taking the difference of the equations forŵ andŵ * and applying Lemma I.1 gives the desired result.

APPENDIX II A BRIEF DISCUSSION ON SMALL GAIN THEOREM
For convenience of the reader, we will present a self-contained discussion of the small-gain theorem used in this paper. Recall Section II for nomenclature.
The following Lemma will be used in the derivation of the Small Gain Theorem: Proof. Notice that if QP τ (x) p = ∞ the statement is true, since P τ Q(x) p < ∞, regardless of Q (see Corollary II.1). p < ∞: QP τ (x) p p can be decomposed as and gives us directly the inequality P τ (Q(x)) p ≤ p (I − P τ )Q(x) p p + P τ (Q(x)) p p = Q(P τ (x)) p . p = ∞: Q(P τ (x)) ∞ can be decomposed as and similarly leads to P τ (Q(x)) ∞ ≤ Q(P τ (x)) ∞ .

B. A Local Small Gain Theorem
Consider the dynamical system in operator form: where y, w ∈ n and ∆ ∈ C s ( n , n ). Recall that the Proposition tells us that (I − ∆) −1 ∈ C( n , n ) exists and we can write the mapping from w to y as: Lemma II.2. Assume that for some ρ > 0 and 0 ≤ γ < 1, β ≥ 0 the operator ∆ satisfies ∆(x) p ≤ γ x p + β for all x p < ρ and some p ∈ {1, 2, . . . , ∞}. Then, for any w bounded by w p < (1 − γ)ρ − β, the corresponding y as defined in (18) satisfies the bound: Proof. Pick an arbitrary w such that w p < (1 − γ)ρ − β and notice We will take the following linear approximation of φ τs around the reference trajectory: the true linearization of φ τs at (x d t−1 , u d t−1 ) and notice that the above approximation (30) is only an approximation of the linearization, since . Using Taylor's theorem and assuming φ τs is differentiable, we can write φ τs as where lim |z|→0 |r t−1 (z)|/|z| = 0. We can factor out equation (29) into the following components where e t and e t (x t−1 , u t−1 ) are disturbance terms introduced due to errors in the reference trajectory and linearization and the remaining terms represent our linear approximation of the dynamics. We can express this more compactly in operator form: DefineF φ ∈ C s ( n , n ) with the components , then we can factor out the original equations of (29) as where per definition we have the decompositionF φ + ∆ φ = F φ .
Our approach for synthesis is now to useF φ as a model to the design a system level controller and treat ∆ φ as disturbance terms we want to be robust against. We do this, by first solving for CLMsΨ = (Ψ x ,Ψ u ) ofF φ and then choosing our feedback controller as SL[Ψ x ,Ψ u ].
Due to Theorem III.3,Ψ is a CLM ofF φ if and only if it satisfies the CLM equation (6) forF φ , i.e:Ψ x =F φ (Ψ)+I. We will restrictΨ to be of the affine formΨ = (r, m) + (R, M) with (r, m) ∈ n × m and R ∈ LC( n , n ), M ∈ LC( n , m ). Thus the component functions ofΨ take the from where R t,j ∈ R n×n , M t,j ∈ R n×m , r t , m t are some fix sequences and α 1:t+1 denote the t + 1 arguments of the component function. StructuringΨ in this form and using linearity ofF φ reduces the original operator equationΨ x =F φ (Ψ) + I simply to the following set of linear equations for R t,j , M t,j and r t , m t : Equation (37) is an affine subspace constraint and opens up many possible ways to synthesize for solutions R t,k , M t,k . In fact, (37) matches the linear time-varying formulation of SLS as discussed in [13], [16] and for our case-study here, we are synthesizing for R t,k , M t,k by solving the following H 2 / LQR problem for the LTV systemF φ subject to an FIR constraint with horizon T = 60 time-steps: Remark III.3. See [16] for details of the H 2 /LQR problem setup and derivation of the convex optimization problem. The FIR horizon can be understood as a time-window [t, t + T ] given to the controller to kill off the disturbanceŵ t . Considering the sampling time of our example, T = 60 translates here to a 2-second window in continuous-time.
Furthermore, H denotes the length of the trajectory in sampling time-steps. The above problem can be solved in closed form, since it is a QP without inequality constraints. Moreover, the change of variables R j+h,j+1 ,M j+h,j+1 with 0 ≤ j ≤ T − 1, 0 ≤ h ≤ H shows that (39) can be decomposed over h into H separate QP's that can be solved analytically and in parallel, hence showing that the computational complexity of our synthesis approach is independent of the trajectory length H.
The solutions of (39) are taken to parametrize the operators (35) which give us the system level controller SL[Ψ x ,Ψ u ]. The resulting closed loop of the cart pole system (29) and controller SL[Ψ x ,Ψ u ] can be put into the form of our robust stability analysis in Section IV:

APPENDIX IV BLENDING SL CONTROLLERS
We will present a class of SL controllers that can be viewed as nonlinear "blends" of multiple linear controllers and demonstrate their use in application to linear systems with state and input constraints. Consider the maps Ψ = (Ψ x , Ψ u ) of the form: where R i ∈ LC( n , n ), M i ∈ LC( n , m ) are N linear operators. In addition, R i are chosen such that R i −I ∈ LC s ( n , n ). Let R i t,k ∈ R n×n and M i t,k ∈ R n×m be the matrices associated with the component functions R i t , M i t of R i , M i : Remark IV.1. R i − I being strictly causal is equivalent to R i t,1 = I for all t and i. Using the above notation, the implementation of SL[Ψ x , Ψ u ] can be written out aŝ Remark IV.2. In the above implementation we are assuming explicit knowledge of the functions G i t (.) and thereforew is not an internal state, but merely a placeholder. In an implementation where G i t (.) were to be computed implicitly via recursion, additional internal states would need to be added and included in the stability analysis.
Next, we will derive under which conditions the operator Ψ of the form (41) is a closed loop map of a general linear causal system. Define a system in operator form where we assume F : n × m → n to be a linear, strictly causal operator. Due to linearity, we can split F into two operators F x : n → n , F u : m → n and write F as F(x, u) := (F x (x) + F u (u)). Correspondingly, F has the component functions where F x t,k ∈ R n×n , F u t,k ∈ R n×m and due to the strict causality we have F x t,1 = 0, F u t,1 = 0, for all t.
With the above definitions the usual system description is Now recall that per construction, the implementation SL[Ψ x , Ψ u ] ensures the identity Ψ xŵ = x, Ψ uŵ = u. Plugging this relation into (44) and using (43) to simplify the equations results in the following dynamics forŵ In light of our discussion in Section IV, the solutionsŵ of (48) characterize the partial map Φŵ S 1 [F, Ψ] and it holdŝ w = Φŵ S 1 [F, Ψ](w, 0, 0). We denoted ∆ i as the residual linear operators which are capturing the residual terms of the CLM equation of the maps (R i , M i ). From the above equation, we see that if we choose each of (R i , M i ) to be feasible closed-loop maps for the system (44) (i.e. ∆ i = 0) and also choose G i to satisfy N i=1 G i = I, then the operator Ψ = (Ψ x , Ψ u ) of (43) becomes a CLM of the linear system (44). This is summarized in the Lemma below: Lemma IV.1. Assume F is linear and strictly causal and define Ψ = (Ψ x , Ψ u ) according to (43) with some linear (R i , M i ) ∈ Φ S1 [F] and potentially nonlinear G i . Then, if G i satisfy N i=1 G i = I, then Ψ ∈ Φ S1 [F]. We will discuss the importance of the above nonlinear system level controllers for control design problems in linear systems with input saturation and state constraints.