System-level, Input-output and New Parameterizations of Stabilizing Controllers, and Their Numerical Computation
Yang Zheng Luca Furieri Maryam Kamgarpour Na Li






	
	
		
		
		
		[footnoteinfo]The material of this paper was not presented at any conference. This work is supported by NSF career 1553407, AFOSR Young Investigator Program, and ONR Young Investigator Program. L. Furieri and M. Kamgarpour are gratefully supported by ERC Starting Grant CONENE. 
		
		ucsd]Yang Zhengzhengy@eng.ucsd.edu,
		EPFL,ETH]Luca Furieriluca.furieri@epfl.ch,
		EPFL]Maryam Kamgarpourmaryam.kamgarpour@epfl.ch,
		Harvard1]Na Linali@seas.harvard.edu
		
		[ucsd]Department of Electrical and Computer Engineering, University of California San Diego, CA 92093. 

		[Harvard1]School of Engineering and Applied Sciences, Harvard University, Boston, MA, 02138, U.S. 
 
		
		
		[ETH]Automatic Control Laboratory,  ETH Zurich, Switzerland.  
             
		[EPFL]Institute of Mechanical Engineering, École Polytechnique Fédérale de Lausanne (EPFL), Switzerland 

	 

		
		                           
			Internal stability, Youla parameterization, System-level synthesis, Convex optimization.
		                             
		
		
		
		It is known that the set of internally stabilizing controller 𝒞_stab is non-convex, but it admits convex characterizations using certain closed-loop maps: a classical result is the Youla parameterization, and two recent notions are the system-level parameterization (SLP) and the input-output parameterization (IOP). In this paper, we address the existence of new convex parameterizations and discuss potential tradeoffs of each parametrization in different scenarios. Our main contributions are: 1) We  reveal that only four groups of stable closed-loop transfer matrices are equivalent to internal stability: one of them is used in the SLP, another one is used in the IOP, and the other two are new, leading to two new convex parameterizations of 𝒞_stab. 2) We  investigate the properties of these parameterizations after imposing the finite impulse response (FIR) approximation, revealing that the IOP has the best ability of approximating 𝒞_stab given FIR constraints. 3) These four parameterizations require no a priori doubly-coprime factorization of the plant, but impose a set of equality constraints. However, these equality constraints will never be satisfied exactly in floating-point arithmetic computation and/or implementation. We prove that the IOP is numerically robust for open-loop stable plants, in the sense that small mismatches in the equality constraints do not compromise the closed-loop stability; but a direct IOP implementation will fail to stabilize open-loop unstable systems in practice. The SLP is known to enjoy numerical robustness in the state feedback case; here, we show that numerical robustness of the four-block SLP controller requires case-by-case analysis even the plant is open-loop stable. 
		
		
	





§ INTRODUCTION

Feedback systems must be stable in some appropriate sense for practical deployment, and thus one fundamental problem in control theory is to design a feedback controller that stabilizes a given dynamical system <cit.>. Indeed, many control synthesis problems include stability as a constraint while optimizing some performance <cit.>. However, it is well-known that the set of stabilizing controllers is non-convex, and hence, hard to search directly over. One standard approach is to parameterize all stabilizing controllers and the corresponding closed-loop responses in a convex way, and then to optimize the performance over the new parameter(s) using convex optimization <cit.>.

A classical method for parameterizing  the set of all internally stabilizing controllers is based on the celebrated Youla parameterization <cit.> which relies on a doubly-coprime  factorization  of the system. It is shown in <cit.> that many performance specifications on the closed-loop system can be expressed in the Youla parameterization framework via convex optimization. Moreover, the foundational results of robust and optimal control are built on the Youla parameterization <cit.>. Recently, a system-level parameterization (SLP) <cit.> and an input-output parameterization (IOP) <cit.> were proposed to characterize the set of internally stabilizing controllers, 
without relying on the doubly-coprime factorization technique. In principle, Youla, the SLP, and the IOP all directly treat certain closed-loop responses as design parameters and thus shift the controller synthesis from the design of a controller to the design of the closed-loop responses. We note that an open-source Python-based implementation for the SLP and the IOP is available <cit.>.

Besides the classical control synthesis problems <cit.>, closed-loop parameterizations are powerful tools in other areas, including distributed optimal control <cit.> and quantifying the performance of learning in control <cit.>. In distributed control, the goal is to  design sub-controllers relying on locally available information, which is crucial for many cyber-physical systems. Enforcing these information constraints, however, may make the problems computationally intractable <cit.>. Nevertheless, it is well-known that a notion of quadratic invariance (QI) <cit.> allows equivalently translating information constraints on the controller to convex constraints on the Youla parameter, thus preserving the convexity of distributed controller synthesis. The QI notion can also be integrated with the SLP and the IOP, resulting in equivalent convex reformulations <cit.>. Together with a recent notion of Sparsity Invariance <cit.>, these closed-loop parameterizations enable deriving convex approximations 
for problems with general sparsity constraints 
beyond QI; see <cit.> for example.



For learning in control, the SLP was integrated within a Coarse-ID control procedure to derive a 
sample complexity bound for learning the classical linear quadratic regulator (LQR) <cit.>. This procedure was exploited in <cit.> to derive high probability guarantees of sub-linear regret using an adaptive LQR control architecture. In <cit.>, based on the Youla parameterization, an online gradient descent algorithm was proposed to achieve sub-linear regret for learning the linear quadratic gaussian (LQG) controller.
In <cit.>, the Youla framework was used to derive a sample complexity bound on learning the globally optimal distributed controller subject to QI constraints. The IOP was also used to derive an end-to-end sample complexity bound on learning LQG controllers for stable systems <cit.>.
The results in <cit.> motivate the shift from static controllers to dynamic ones in complex learning-based control tasks.

Youla <cit.>, the SLP <cit.>, and the IOP <cit.> are fundamental building blocks for distributed controller synthesis and learning-based control applications. Nevertheless, a few critical issues have been left unexplored. First, while it is known that Youla, the SLP, and the IOP are all equivalent <cit.>, it remains unclear whether there exist other equivalent parameterizations beyond them. Second, the decision variables in these closed-loop parameterizations are, in general, infinite-dimensional. The works <cit.> enforce finite impulse response (FIR) constraints on the decision variables to enable formulation as finite-dimensional convex optimization problems. However, these works do not characterize the conservatism introduced by the FIR approximation using different parameterizations. Third, unlike Youla, the SLP and the IOP do not need to know a doubly-coprime factorization a priori, and instead introduce a set of equality constraints for achievable closed-loop responses. A fact that is not investigated in the SLP <cit.>, the IOP <cit.> or the recent work <cit.> is that the set of equality constraints can never be satisfied exactly in numerical computation, potentially affecting the closed-loop stability.




 §.§ Contributions


This paper aims to investigate the issues raised above and provide a complete understanding of closed-loop parameterizations. We introduce new parameterizations beyond SLP/IOP and discuss tradeoffs among these parameterizations in different scenarios. Note that our previous work <cit.> established explicit affine mappings among Youla, SLP, and IOP parameters, but it provides no investigation of the issues mentioned above. Specifically, the contributions of this paper are as follows.

First, we examine all possible parameterizations for the set of internally stabilizing controllers 𝒞_stab using closed-loop responses from the disturbances 
(δ_x, δ_y, δ_u) to state, output, control signals (x, y, u); see Figure <ref> for illustration. Our strategy is to examine the cases where the stability of external transfer matrices is equivalent to internal stability. We reveal that only four groups of stable disturbance-to-signal maps can guarantee internal stability (see Theorem <ref>): one of them is used in the SLP <cit.>, another one is a classical result and is used in the IOP <cit.>, and the other two have not been discussed before and thus can be used to derive two new parameterizations (Propositions <ref> and <ref>). Our results are complete and exclusive, in the sense that there are no other parameterizations for 𝒞_stab using closed-loop responses from (δ_x, δ_y, δ_u) to (x, y, u).


Second, we 
investigate the impact of imposing FIR constraints on the closed-loop parameterizations. We show that the IOP provides the tightest approximation of 𝒞_stab 
after imposing FIR constraints (Theorem <ref>). This result is enabled by the fact that the IOP directly deals with the maps from inputs to outputs without passing through the system state, while the SLP and the two new parametrizations explicitly involve the system state or disturbances on the system state. Motivated by <cit.>, we characterize state-space realizations for the controllers in closed-loop parameterizations after imposing FIR approximations (Theorem <ref>). The state-space realizations provide easily implementable controllers for practical deployment.

Third, we quantify the numerical robustness of closed-loop parameterizations due to floating-point arithmetic in both numerical computation and controller implementation.  
We prove that in the IOP, small numerical mismatches in the equality constraints do not compromise closed-loop stability for open-loop stable plants, but will destabilize the closed-loop system for unstable plants (Theorem <ref>). This result holds similarly for the two new closed-loop parameterizations. We also show that, in general, the four-block SLP controller in the output-feedback case is vulnerable to destabilization due to small mismatches in the equality constraints (Theorem <ref>), no matter whether the plant is open-loop stable or unstable. This issue arises irrespective of which SLP controller implementation is used <cit.>. These results suggest that it is unwise to directly apply the IOP or related parameterizations for open-loop unstable systems; instead, utilizing a pre-stabilizing controller is more appealing since it avoids the destabilization issue. 








 §.§ Paper Structure


The rest of this paper is organized as follows. We state the problem in Section <ref>. The relationship between the stability of external transfer matrices and internal stability is revealed in Section <ref>. Four parameterizations of stabilizing controllers using closed-loop responses, including the SLP and the IOP, are presented in Section <ref>. Numerical computation using the FIR constraints and controller implementation are discussed in Section <ref>. We investigate the numerical robustness of closed-loop parameterizations in Section <ref>. A numerical application is shown in Section <ref>, and we conclude the paper in Section <ref>. 




 §.§ Notation


The symbols ℝ and ℕ refer to the set of real and integer numbers, respectively. We use lower and upper case letters (e.g. x and A) to denote vectors and matrices, respectively. Lower and upper case boldface letters (e.g. 𝐱 and 𝐆) are used to denote signals and transfer matrices, respectively.  We denote the set of real-rational proper stable[Throughout the paper, “stable” means “asymptotically stable”, i.e., all eigenvalues/poles have strictly negative real parts in continuous time (magnitudes less than 1 in discrete time).] transfer matrices as ℛℋ_∞.  We use the notation 𝐆∈1/zℛℋ_∞ to denote that 𝐆 is stable and strictly proper. Given 𝐆∈ℛℋ_∞, we denote its ℋ_∞ norm by 𝐆_∞:= sup_ωσ_max (𝐆(e^jω)), where σ_max(·) denotes the maximum singular value. Given a stable transfer matrix 𝐆(z), the square of its ℋ_2 norm is 𝐆^2_ℋ_2:= 1/2π∫_-π^πTrace(𝐆^*(e^jω)𝐆(e^jω))dω. For simplicity, we omit the dimension of transfer matrices, which shall be clear in the context. Also, we use I (resp. 0) to denote the identity matrix (resp. zero matrix) of compatible dimension. In Section <ref>, to avoid ambiguity, we explicitly write the matrix dimension and use I_p to denote the identity matrix of dimension p.  Finally, the state-space realization C(zI - A)^-1B + D is denoted as
 [[ A B; C D ]].




§ PROBLEM STATEMENT







 §.§ System model


We consider strictly proper discrete-time linear time-invariant (LTI) plants of the form

    x[t+1]    = A x[t] + B u[t] + δ_x[t],
    
            y[t]      = Cx[t] + δ_y[t],

where x[t] ∈ℝ^n,u[t]∈ℝ^m,y[t]∈ℝ^p are the state vector, control action, and measurement vector at time t, respectively; δ_x[t]∈ℝ^n and δ_y[t]∈ℝ^p are external disturbances on the state and measurement vectors at time t, respectively. The transfer matrix from 𝐮 to 𝐲 is
𝐆 = C(zI - A)^-1B.
Consider an LTI dynamical controller

    𝐮 = 𝐊𝐲 + δ_u,

where δ_u is the external disturbance on the control action. A state-space realization of (<ref>) is

    ξ[t+1]    = A_k ξ[t] + B_k y[t],
    
            u[t]      = C_kξ[t] + D_k y[t]+ δ_u[t],

where ξ[t]∈ℝ^q is the internal state of the controller at time t. The formulation (<ref>) above reduces to a static controller when (A_k,B_k,C_k,D_k)=(0,0,0,K) for some K ∈ℝ^m × p. In this paper, we make the following standard assumption.

 
    Both the plant and controller realizations are stabilizable and detectable, i.e., (A, B) and (A_k, B_k) are stabilizable, and (A,C) and (A_k,C_k) are detectable.


 Applying the controller (<ref>) to the plant (<ref>) leads to a closed-loop system shown in Fig. <ref>. 
 Since the plant is strictly proper, the closed-loop system is always well-posed <cit.>.



 §.§ Internal stability

Internal stability is defined as follows <cit.>:

    The system in Fig. <ref> is internally stable if it is well-posed, and the states (x[t],ξ[t]) converge to zero as t→∞ for all initial states (x[0],ξ[0]) when δ_x[t] = 0, δ_y[t]=0, δ_u[t] = 0, ∀ t.


We say the controller 𝐊 internally stabilizes the plant 𝐆 if the closed-loop system in Fig. <ref> is internally stable. The set of all LTI internally stabilizing controllers is defined as

    𝒞_stab := {𝐊|𝐊 internally stabilizes 𝐆}.


Note that when an infinite time-horizon is considered, a feedback system must at least be stable, and  any controller synthesis will implicitly or explicitly involve a constraint 𝐊∈𝒞_stab. Therefore, it is of fundamentally importance to characterize 𝒞_stab. Indeed, it is well-known that 𝒞_stab is non-convex, and it is not difficult to find explicit examples where 𝐊_1, 𝐊_2∈𝒞_stab and 1/2(𝐊_1 + 𝐊_2)∉𝒞_stab. Accordingly, it is not easy to directly search over 𝐊∈𝒞_stab for control synthesis, and a suitable change of variables is used in many control synthesis procedures <cit.>.

A standard state-space characterization of
internal stabilization is as follows.
 
    Under Assumption <ref>, 𝐊 internally stabilizes  𝐆 if and only if
    
    A_cl := [ A+BD_kC    BC_k;    B_kC     A_k ]

is stable.


Note that the result in Lemma <ref> is a simplified version of <cit.> because we focus on strictly proper plants for simplicity. Lemma <ref> leads to an explicit state-space characterization of the set 𝒞_stab as follows:

    𝒞_stab = {𝐊| A_cl =[ A+BD_kC    BC_k;    B_kC     A_k ]is stable},

where 𝐊 = C_k(zI - A_k)^-1B_k + D_k. Unfortunately, the stability condition on A_cl in (<ref>) is still non-convex in terms of the parameters A_k,B_k,C_k,D_k.



 §.§ Characterizations based on transfer functions


Unlike the state-space parameterization (<ref>), there are several frequency-domain characterizations for 𝒞_stab, where only convex constraints are involved in certain transfer functions. A classical approach is the celebrated Youla parameterization <cit.>, where a doubly-coprime factorization  of the plant is used.
 
        A collection of stable transfer matrices, 𝐔_l, 𝐕_l,𝐍_l,𝐌_l,𝐔_r, 𝐕_r,𝐍_r,𝐌_r ∈ℛℋ_∞ is called a doubly-coprime factorization of 𝐆 if
        𝐏_22 = 𝐍_r𝐌_r^-1 = 𝐌_l^-1𝐍_l
        and
        
    [  𝐔_l -𝐕_l; -𝐍_l  𝐌_l ][ 𝐌_r 𝐕_r; 𝐍_r 𝐔_r ] = I.

    

    Such doubly-coprime factorization can always be computed if 
    the state-space realization of 𝐆 is stabilizable and detectable <cit.>. We have the following equivalence <cit.>
    
    𝒞_stab = {𝐊 = (𝐕_r - 𝐌_r𝐐)(𝐔_r - 𝐍_r𝐐)^-1|𝐐∈ℛℋ_∞},

    where 𝐐 is denoted as the Youla parameter. Note that the Youla parameter 𝐐 can be freely  chosen in ℛℋ_∞. We refer the interested reader to <cit.> for more details on the Youla parameterization.
  

  Two recent approaches are the system-level parameterization (SLP) <cit.> and the input-output parameterization (IOP) <cit.>, where no doubly-coprime factorization is required a priori.
 Both the SLP and the IOP use certain closed-loop responses for parameterizing 𝒞_stab with the addition of a set of equality constraints.
 In particular, the SLP utilizes the closed-loop responses from (δ_x,δ_y) to (𝐱,𝐮), and the IOP relies on the closed-loop responses from (δ_y,δ_u) to (𝐲,𝐮). It is known that Youla parameterization, the SLP, and the IOP are equivalent to each other <cit.>. Inspired by these results <cit.>, we aim to investigate the following questions:
 
    
  * What are all the possible parameterizations for 𝒞_stab using closed-loop responses, beyond the SLP and the IOP? We present a complete and exclusive answer by examining all closed-loop responses from (δ_x,δ_y,δ_u) to (𝐱,𝐲,𝐮) (Sections <ref> and <ref>).
   
  * All the closed-loop parameterizations for 𝒞_stab are equivalent in theory. When applying FIR approximations for practical computation, are they still equivalent? What are the corresponding state-space realizations for controller implementation? Both of them are answered in Section <ref>.
   
  * Finally, floating-point  arithmetic computation and/or implementation always introduce small numerical mismatches for equality constraints. What are the impact of these numerical mismatches for closed-loop parameterizations? In Section <ref>, we investigate a property termed as numerical robustness of closed-loop parameterizations.
     
     
     
 







 §.§ Optimal controller synthesis

As a particular application, we consider the following optimal control problem

    min_𝐊     lim_T→∞𝔼[1/T∑_t=0^T(y_t^ Qy_t + u_t^ R u_t)] 
    s.t.      x[t+1] = Ax[t] +B(u[t] + δ_u[t]), 
             y[t] = Cx[t] + δ_y[t], 
               𝐮 = 𝐊𝐲,

where δ_u[t] ∼𝒩(0,I), δ_y[t] ∼𝒩(0,I), Q ≻ 0 and R ≻ 0 are performance-weight matrices with compatible dimensions.
Problem (<ref>) can be reformulated into a problem in the frequency domain (see e.g., <cit.>)
    
    min_𝐊     [ Q^1/2      ;       R^1/2 ][  (I-𝐆𝐊)^-1 (I-𝐆𝐊)^-1𝐆; 𝐊(I-𝐆𝐊)^-1  (I-𝐊𝐆)^-1 ]^2_ℋ_2
    s.t.     𝐊∈𝒞_stab,

where 𝐆 = C(zI - A)^-1B.

It is easy to see that the optimal synthesis problem (<ref>) is non-convex in terms of 𝐊 since both the cost function and constraint are non-convex. Instead of optimizing over the controller directly, we will establish a variety of equivalent convex reformulations based upon optimizing over closed-loop responses. Our results will reveal computational properties and numerical robustness of such reformulations based on closed-loop parameterizations.


We conclude this section by stating the following classical result, which will be frequently used.
 
Given a transfer matrix 𝐓(z) = C(zI - A)^-1B + D, we have


  * If (A,B,C) is detectable and stabilizable, then 𝐓(z) ∈ℛℋ_∞ if and only if A is stable;

  * If (A,B) is not stabilizable, or (A,C) is not detectable, then the stability of A is sufficient but not necessary for 𝐓(z) ∈ℛℋ_∞.





§ EXTERNAL TRANSFER MATRIX CHARACTERIZATION OF INTERNAL STABILITY
 
In this section, we revisit the external transfer matrix characterization of internal stability,  which will be applied to characterize 𝒞_stab in the next section.



Combining (<ref>) with (<ref>), we can write the closed-loop responses from (δ_x,δ_y,δ_u) to (𝐱,𝐲,𝐮)  as

    [ 𝐱; 𝐲; 𝐮 ] = [ Φ_xx Φ_xy Φ_xu; Φ_yx Φ_yy Φ_yu; Φ_ux Φ_uy Φ_uu ][ δ_x; δ_y; δ_u ],

where we have Φ_xx = (zI - A - B𝐊C)^-1 and

    Φ_xy   = Φ_xxB𝐊,
               Φ_xu   = Φ_xxB, 
    Φ_yx   = CΦ_xx,     Φ_yy   = CΦ_xxB𝐊 + I,  
    Φ_yu   = CΦ_xxB,
               Φ_ux   = 𝐊CΦ_xx,  
    Φ_uy   = 𝐊(CΦ_xxB𝐊 + I),      Φ_uu   = 𝐊CΦ_xxB + I.

We define the closed-loop response transfer matrix as

    Φ :=  [ Φ_xx Φ_xy Φ_xu; Φ_yx Φ_yy Φ_yu; Φ_ux Φ_uy Φ_uu ].


A notion of external transfer matrix stability is defined as follows.

    The closed-loop system is disturbance-to-signal stable if the closed-loop responses from (δ_x,δ_y,δ_u) to (𝐱,𝐲,𝐮) are all stable, i.e., Φ∈ℛℋ_∞.





 §.§ General plant


Under Assumption <ref>, it is known that the internal stability in Definition 1 and the disturbance-to-signal stability in Definition 2 are equivalent <cit.>, i.e., we have

    𝒞_stab = {𝐊|Φ∈ℛℋ_∞,  with Φ defined in (<ref>)}.

In fact, it is sufficient to enforce a subset of elements in Φ to be stable, as shown in <cit.>.

    Under Assumption <ref>, 𝐊 internally stabilizes  𝐆 if and only if the closed-loop responses from (δ_y,δ_u) to (𝐲,𝐮) are stable, i.e.,
    
    [ Φ_yy Φ_yu; Φ_uy Φ_uu ]∈ℛℋ_∞.



For notational simplicity, we denote

    ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ]) := [ Φ_yy Φ_yu; Φ_uy Φ_uu ].

The result in Lemma <ref> motivates the question of whether we can select different minimal sets of elements in Φ for internal stability. For example, if the closed-loop responses from (δ_x, δ_y) to (𝐱, 𝐲) are stable, i.e.,

    ([ δ_x; δ_y;     ]→[ 𝐱; 𝐲;   ]) := [ Φ_xx Φ_xy; Φ_yx Φ_yy ]∈ℛℋ_∞,

can we guarantee that the closed-loop system is internally stable? The answer is negative, as proved in Theorem <ref> below.

In particular, we consider all possible combinations of four closed-loop responses that may guarantee internal stability. When choosing two disturbances and two outputs from (<ref>), we have in total  3  2×3  2 = 9 choices, i.e.,


    ([ δ_x; δ_y;     ]→[ 𝐱; 𝐲;   ]),    ([ δ_x; δ_y;     ]→[ 𝐲; 𝐮;   ]),  ([ δ_x; δ_y;     ]→[ 𝐱; 𝐮;   ]),  
    ([ δ_y; δ_u;     ]→[ 𝐱; 𝐲;   ]),    ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ]),  ([ δ_y; δ_u;     ]→[ 𝐱; 𝐮;   ]), 
    ([ δ_x; δ_u;     ]→[ 𝐱; 𝐲;   ]),    ([ δ_x; δ_u;     ]→[ 𝐲; 𝐮;   ]),  ([ δ_x; δ_u;     ]→[ 𝐱; 𝐮;   ]).


Note that it is in general not sufficient to select less than four close-loop responses since there are two dynamical parts in system (<ref>) and controller (<ref>).
One main result of this section shows that the stability of any of the groups of four closed-loop responses in the top-right corner of (<ref>), highlighted in blue, is equivalent to internal stability.

  Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). Under Assumption 1, the following statements are equivalent:
   
   
       
  * 𝐊 internally stabilizes 𝐆;
       
  * ([ δ_x; δ_y;     ]→[ 𝐲; 𝐮;   ]) ∈ℛℋ_∞;
        
  * ([ δ_x; δ_y;     ]→[ 𝐱; 𝐮;   ])∈ℛℋ_∞;

        
  * ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ])∈ℛℋ_∞;

        
  * ([ δ_y; δ_u;     ]→[ 𝐱; 𝐮;   ])∈ℛℋ_∞.
   
   Moreover, the stability of any other group of four closed-loop responses in (<ref>) is not sufficient for internal stability.




The idea of our proof is to use a state-space representation of the closed-loop system, which is motivated by <cit.>.
From (<ref>) and (<ref>), we have

    [ x[t+1]; ξ[t+1] ] =[   A   0;   0 A_k ][ x[t]; ξ[t] ]+[   B   0;   0 B_k ][ u[t]; y[t] ]+[ δ_x[t];      0 ],

and

    [    I -D_k;    0    I ][ u[t]; y[t] ] = [   0 C_k;   C   0 ][ x[t]; ξ[t] ] + [ δ_u[t]; δ_y[t] ].


Substituting (<ref>) into (<ref>) leads to

    [ x[t+1]; ξ[t+1] ] = A_cl[ x[t]; ξ[t] ]
         + [    B BD_k;    0  B_k ][ δ_u[t]; δ_y[t] ] + [ δ_x[t];      0 ],

i.e., we have

    [ x[t+1]; ξ[t+1] ] = A_cl[ x[t]; ξ[t] ]
        + [    I BD_k    B;    0  B_k    0 ][ δ_x[t]; δ_y[t]; δ_u[t] ], 
       [ x[t]; y[t]; u[t] ] = [    I    0;    C    0; D_kC  C_k ][ x[t]; ξ[t] ]  + [   0   0   0;   0   I   0;   0 D_k   I ][ δ_x[t]; δ_y[t]; δ_u[t] ].

Therefore, the closed-loop responses from (δ_x,δ_y,δ_u) → (𝐱,𝐲,𝐮) are

    [    I    0;    C    0; D_kC  C_k ] (zI - A_cl)^-1[    I BD_k    B;    0  B_k    0 ]  + [   0   0   0;   0   I   0;   0 D_k   I ],

    from which, we get state-space realizations of the following closed-loop responses
     
    
    ([ δ_x; δ_y;     ]→[ 𝐲; 𝐮;   ])    =  Ĉ_1 (zI - A_cl)^-1B̂_1  + [   0   I;   0 D_k ],
    ([ δ_x; δ_y;     ]→[ 𝐱; 𝐮;   ])    =  Ĉ_2 (zI - A_cl)^-1B̂_1  + [   0   0;   0 D_k ],
    ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ])    =  Ĉ_1 (zI - A_cl)^-1B̂_2  + [   I   0; D_k   I ], 
    ([ δ_y; δ_u;     ]→[ 𝐱; 𝐮;   ])    =  Ĉ_2 (zI - A_cl)^-1B̂_2  + [   0   0; D_k   I ],

    
where

    B̂_1    = [    I BD_k;    0  B_k ],    B̂_2    = [ BD_k    B;  B_k    0 ],  
    Ĉ_1    = [    C    0; D_kC  C_k ],    Ĉ_2    = [    I    0; D_kC  C_k ].


By Lemma 1, we know that 𝐊 internally stabilizes 𝐆 if and only if the closed-loop matrix A_cl defined in (<ref>) is stable. It is obvious true that (1)⇒(2), (1)⇒(3), (1)⇒(4), and (1)⇒(5).

Next, we prove if anyone of (2) – (5) is true, the matrix A_cl is stable. According to Lemma <ref>, it remains to prove that the state-space realizations (<ref>)–(<ref>) are all stabilizable and detectable. This is equivalent to showing that
(A_cl,B̂_1), (A_cl,B̂_2)
are stabilizable and that (A_cl,Ĉ_1), (A_cl,Ĉ_2) are detectable.
We let
F̂_1 = [   F   0;  -C F_k ]
where F and F_k are chosen such that A + F and A_k + B_kF_k are stable (since (A, B_k) is stabilizable).

Then, we have that

    A_cl + B̂_1F̂_1 = [        A + F BC_k+BD_kF_k;            0 A_k + B_kF_k ]

is stable, and thus (A_cl, B̂_1) is stablizable. Similar arguments show that (A_cl,B̂_2) is stabilizable, and (A_cl,Ĉ_1), (A_cl,Ĉ_2) are detectable.

For the second part of Theorem <ref>, we first prove that the stability of  ([ δ_x; δ_y;     ]→[ 𝐱; 𝐲;   ]) is not sufficient for internal stability.
        From (<ref>), a state-space realization of the closed-loop responses from (δ_x,δ_y) to (𝐱,𝐲) is
        
    ([ δ_x; δ_y;     ]→[ 𝐱; 𝐲;   ])= [ I 0; C 0 ](zI - A_cl)^-1B̂_1 +[ 0 0; 0 I ].

    Since
    (A_cl, [ I 0; C 0 ])
    is not detectable in general, the stability of ([ δ_x; δ_y;     ]→[ 𝐱; 𝐲;   ]) cannot guarantee the stability of A_cl. Therefore, it  is not sufficient for internal stability either. The other claims can be proved in a similar way: the corresponding state-space realization of the closed-loop transfer matrix is not stabilizable and/or detectable.


As shown in Theorem <ref>, to guarantee internal stability for general plants, it is always required to select δ_y as an input and 𝐮 as an output, leading to four possible groups of closed-loop responses. The groups of closed-loop responses in (<ref>), except those in blue, do not have either δ_y or 𝐮, and thus fail to guarantee internal stability.


Note that Theorem <ref> is exclusive in the sense that there exist no other combinations of stable closed-loop responses that are equivalent to internal stability, and  Lemma <ref> is included as the equivalence between 1) and 4) in Theorem <ref>. Thus, Theorem <ref> offers a complete picture between internal stability and stable closed-loop responses.



 §.§ Two special cases: Stable plants and State feedback 


Here, we show that the transfer matrix characterization of internal stability can be simplified for special cases: 1) open-loop stable plants; 2) the state feedback case. To guarantee internal stability, instead of considering four closed-loop responses in Theorem <ref>, the stability of one particular closed-loop response is sufficient in the case of open-loop stable plants, and the stability of two particular closed-loop responses is sufficient in the state feedback case.

The following result is classical, which is the same as <cit.>. For completeness, we provide a proof from a state-space perspective.

 
    Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). If the LTI system is open-loop stable (i.e., A is stable), then 𝐊∈𝒞_stab if and only if (δ_y →𝐮):= Φ_uy∈ℛℋ_∞.


    The “only if” direction is true by definition. We now prove the sufficiency. From (<ref>), we have
    
    Φ_uy = [ D_kC  C_k ] (zI - A_cl)^-1[ BD_k;  B_k ]  + D_k.

    Considering the fact that the following matrix
    
    A_cl + [ BD_k;  B_k ][  -C F_k ] = [            A BC_k+BD_kF_k;            0 A_k + B_kF_k ],

    is stable when A and A_k +B_kF_k are stable, we know that (A_cl,[ BD_k;  B_k ]) is stabilizable. Similarly, we can show that (A_cl,[ D_kC  C_k ]) is detectable. Therefore, if Φ_uy∈ℛℋ_∞, we have A_cl is stable, meaning that 𝐊∈𝒞_stab. 


In the state feedback case, we have the following result.
 
    Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). If C = I, then 𝐊∈𝒞_stab if and only if (δ_x →[ 𝐱; 𝐮 ]):=[ Φ_xx; Φ_ux ]∈ℛℋ_∞.


    When C = I, from (<ref>), we have
    
    [ Φ_xx; Φ_ux ] = [   I   0; D_k C_k ](zI -  [ A + BD_k     BC_k;      B_k      A_k ])^-1[ I; 0 ],

    From the proof of Theorem <ref>, we know
    
    ([ A + BD_k     BC_k;      B_k      A_k ], [   I   0; D_k C_k ])

    is detectable. It is not difficult to prove that
    
    ([ A + BD_k     BC_k;      B_k      A_k ], [ I; 0 ])

    is stabilizable (see Appendix <ref> for details).
    Therefore, if Φ_xx∈ℛℋ_∞, Φ_ux∈ℛℋ_∞, we have A_cl is stable, meaning that 𝐊∈𝒞_stab.


The result in Corollary <ref> has been used in the state feedback case of the system-level parametrization <cit.>. The proof in <cit.> used a frequency-based method. Here, we provided an alternative proof from a state-space perspective, which is consistent with the proofs for Theorem <ref> and Corollary <ref>.





§ PARAMETERIZATIONS OF STABILIZING CONTROLLERS
 
The results in Theorem <ref> can be used to parameterize the set of internally stabilizing controllers 𝒞_stab, leading to four equivalent parameterizations. One of them corresponds to the SLP <cit.>, and another one is the IOP <cit.>. The remaining two parameterizations are new and, to the best of the authors' knowledge, have not been characterized before. The results in Corollaries <ref> and <ref> can also be used to parameterize 𝒞_stab in a simplified way.




 §.§ Four equivalent parameterizations for general plants

The closed-loop responses from (δ_x,δ_y) to (𝐱,𝐮) have been utilized in the SLP <cit.>. Specifically, consider

    [ 𝐱; 𝐮 ] = [ Φ_xx Φ_xy; Φ_ux Φ_uy ][ δ_x; δ_y;     ].

We have the following system-level parameterization (SLP).

     Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). The following statements are true:
    
        
  * For any 𝐊∈𝒞_stab, the resulting closed-loop responses (<ref>) are in the following affine subspace

        
    [ zI - A    - B ][ Φ_xx Φ_xy; Φ_ux Φ_uy ]   = [ I 0 ], 
    [ Φ_xx Φ_xy; Φ_ux Φ_uy ][ zI - A;    - C ]   = [ I; 0 ], 
    Φ_xx, Φ_ux,
              Φ_xy,Φ_uy   ∈ℛℋ_∞.

        
  * For any transfer matrices Φ_xx, Φ_ux,
            Φ_xy, Φ_uy satisfying (<ref>), 𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy∈𝒞_stab.
    

We refer to 𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy as the four-block SLP controller. Also, the closed-loop responses from (δ_y,δ_u) to (𝐲,𝐮) have been used in the IOP <cit.>. Specifically, consider

    [ 𝐲; 𝐮 ] = [ Φ_yy Φ_yu; Φ_uy Φ_uu ][ δ_y; δ_u;     ] .

We have the following input-output parameterization (IOP).
 
    Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). The following statements are true:
    
        
  * For any 𝐊∈𝒞_stab, the resulting closed-loop responses (<ref>) are in the following affine subspace
        
    [  I -𝐆 ][ Φ_yy Φ_yu; Φ_uy Φ_uu ]   = [ I 0 ], 
    [ Φ_yy Φ_yu; Φ_uy Φ_uu ][ -𝐆;  I ]   = [ 0; I ], 
    Φ_yy, Φ_uy,
                Φ_yu, Φ_uu   ∈ℛℋ_∞.

        
  * For any transfer matrices Φ_yy, Φ_uy,
            Φ_yu, Φ_uu satisfying (<ref>), 𝐊 = Φ_uyΦ_yy^-1∈𝒞_stab.
    


Next, we consider the following closed-loop responses

    [ 𝐲; 𝐮;   ] =   [ Φ_yx Φ_yy; Φ_ux Φ_uy;      ][ δ_x; δ_y;     ].


We have 
a new parametrization of 𝒞_stab. 


     Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). The following statements are true:
    
        
  * For any 𝐊∈𝒞_stab, the resulting closed-loop responses (<ref>) are in the following affine subspace
        
    [   I - 𝐆 ][ Φ_yx Φ_yy; Φ_ux Φ_uy;      ]   = [ C(zI - A)^-1            I ],
    [ Φ_yx Φ_yy; Φ_ux Φ_uy;      ][ zI - A;     -C ]   = 0,
            
    Φ_yx, Φ_ux,
                Φ_yy, Φ_uy   ∈ℛℋ_∞.

        
  * For any transfer matrices Φ_yx, Φ_ux,
            Φ_yy, Φ_uy satisfying (<ref>), 𝐊 = Φ_uyΦ_yy^-1∈𝒞_stab.
    


The proof is provided in Appendix <ref>.










































































Finally, we consider the case

    [ 𝐱; 𝐮;   ] =   [ Φ_xy Φ_xu; Φ_uy Φ_uu;      ][ δ_y; δ_u;     ].


The following result mirrors Proposition <ref> for an additional new parametrization of 𝒞_stab. 
 

     Consider the LTI system (<ref>), evolving under a dynamic control policy (<ref>). The following statements are true:
    
        
  * For any 𝐊∈𝒞_stab, the resulting closed-loop responses (<ref>) are in the following affine subspace
        
    [ zI - A    - B ][ Φ_xy Φ_xu; Φ_uy Φ_uu;      ]   = 0,
    [ Φ_xy Φ_xu; Φ_uy Φ_uu;      ][ -𝐆;  I ]   = [ (zI - A)^-1B;            I ],
            
    Φ_xy, Φ_uy,
                Φ_xu, Φ_uu   ∈ℛℋ_∞.

        
  * For any transfer matrices Φ_xy, Φ_uy,
            Φ_xu, Φ_uu satisfying (<ref>), 𝐊 = Φ_uu^-1Φ_uy∈𝒞_stab.
    

The proof of Proposition <ref> is similar to that of Proposition <ref>, 
which is provided in Appendix <ref>  for completeness.

To summarize, Propositions <ref>– <ref> establish four equivalent methods to parameterize the set of internally stabilizing controllers using closed-loop responses:
 
    𝒞_stab   = {𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy|Φ_xx,  Φ_ux,
                  Φ_xy,  Φ_uy 
                         are in the affine subspace (<ref>)}, 
    𝒞_stab   = {𝐊 = Φ_uyΦ_yy^-1|Φ_yy, Φ_uy, Φ_yu,  Φ_uu 
                         are in the affine subspace (<ref>)}, 
    𝒞_stab   = {𝐊 = Φ_uyΦ_yy^-1|Φ_yx, Φ_ux,
                Φ_yy , Φ_uy 
                         are in the affine subspace (<ref>)}, 
    𝒞_stab   = {𝐊 = Φ_uu^-1Φ_uy|Φ_xy, Φ_uy,
                Φ_xu , Φ_uu 
                         are in the affine subspace (<ref>)}.


Unlike the state-space characterization (<ref>), the constraints (<ref>), (<ref>), (<ref>), and (<ref>) are all affine in the new parameters. Based on (<ref>), (<ref>), (<ref>), and (<ref>), convex optimization problems can be derived for the classical optimal controller synthesis; see <cit.> for details. We will present a case study in Section <ref>.


    The explicit equ-ivalence between Propositions <ref> & <ref> and the Youla parameterization has been derived in <cit.>. It is not difficult to derive the explicit relationship between Propositions <ref> & <ref> and the Youla parameterization (<ref>) using the approach of <cit.>. While there are four parameters in (<ref>), (<ref>), (<ref>), or (<ref>), there is only one freedom due to the affine constraints. This is consistent with the Youla parameterization, where only one parameter is involved with no explicit affine constraints. In Proposition <ref>, we will show that any doubly-coprime factorization of the plant can exactly eliminate the affine constraints (<ref>), (<ref>), (<ref>), and (<ref>). 




   
We note that while being convex, the decision variables in (<ref>), (<ref>), (<ref>), and (<ref>) are infinite-dimensional. Thus, finite-dimensional approximations are usually needed for numerical computations, which will be discussed in Section <ref>. However, the affine constraints (<ref>), (<ref>), (<ref>), and (<ref>) can never be exactly satisfied in numerical computation. Section <ref> will formally discuss the issue of numerical robustness.




 §.§ Two special cases: stable plants and state feedback

The results in Corollaries <ref> and <ref> can be exploited to derive simplified versions of Propositions <ref>–<ref>. 
We will later show that these simplified parametrizations enjoy provable numerical robustness. When the plant is open-loop stable, the IOP (Proposition <ref>) and the Mixed I (Proposition <ref>) are simplified as follows.


    Consider the LTI system (<ref>), evolving under a dynamic controller policy (<ref>). If the LTI system is open-loop stable, then we have
    
    𝒞_stab ={𝐊= Φ_uyΦ_yy^-1| [   I - 𝐆 ][ Φ_yy; Φ_uy ]  = I, .Φ_uy∈ℛℋ_∞}.


 
 This result is consistent with the classical one in <cit.>. Note that for open-loop stable plants, the transfer matrix Φ_uy from the measurement disturbance δ_y to the control input 𝐮 is the same as the Youla parameter 𝐐. Under the condition in Corollary <ref>, the Mixed II (Proposition <ref>) can be simplified as well:
 
    𝒞_stab = {𝐊= Φ_uu^-1Φ_uy| [ Φ_uy Φ_uu ][ - 𝐆;   I ]  = I, . Φ_uy∈ℛℋ_∞}.



If the state is directly measurable for control, i.e., C=I, Corollary <ref> leads to the following simplified version of SLP.

    Consider the LTI system (<ref>), evolving under a dynamic controller policy (<ref>). If C = I, then we have
    
    𝒞_stab = {𝐊= Φ_uxΦ_xx^-1   | (zI -A)Φ_xx - BΦ_ux = I, .
            
            
               Φ_ux, Φ_xx∈1/zℛℋ_∞}.



Note that the simplified IOP/Mixed I/Mixed II requires the stability of only one parameter, while the simplified SLP requires the stability of two parameters. The proofs for Corollaries <ref> and <ref> are similar to that of Proposition <ref>.




§ NUMERICAL COMPUTATION AND CONTROLLER IMPLEMENTATION


This section investigates the numerical computation and controller implementation using the closed-loop parameterization for 𝒞_stab. As noted in Remark <ref>, since the decision variables in the affine constraints (<ref>), (<ref>), (<ref>), and (<ref>) are infinite-dimensional, it is not immediately obvious to derive efficient numerical computation to search over the feasible region. One practical method is to apply the finite impulse response (FIR) approximation, which is extensively used in <cit.>. As we will see, the SLP, the IOP and the two new mixed parametrizations are not equivalent to each other after imposing FIR constraints. In this section, we also present standard state-space realizations (<ref>) for the controllers using closed-loop responses.



 §.§ Numerical computation via FIR


We denote the space of finite impulse response (FIR) transfer matrices with horizon T as

    ℱ_T : = {𝐇∈ℛℋ_∞|  𝐇 = ∑_k=0^T 1/z^kH_k.},

where H_k denotes the i-th spectral component of the FIR transfer matrix 𝐇. It is known that on letting the FIR length T go to infinity, ℱ_T converges to the space ℛℋ_∞ <cit.>.

It is not difficult to check that after imposing the decision variables to be FIR transfer matrices of horizon T, the constraints (<ref>), (<ref>), (<ref>), and (<ref>) all become finite-dimensional affine constraints in terms of the spectral components of the closed-loop responses. Specifically, the constraints are obtained by matching the coefficients associated with the terms z^-k. Thus, searching for an internally stabilizing controller only requires solving a linear program (LP) under the FIR assumption[Depending on the choice of the cost function, optimal controller synthesis may be cast as a quadratic program (QP) under the FIR assumption; see a case study in Section <ref>.].

Here, we show that imposing the FIR assumption has different effects depending on the chosen closed-loop parametrization.
 
Given the LTI system (<ref>), evolving under a dynamic control policy (<ref>), we consider the statements:
 
   

  * Φ∈ℱ_T;
        
  * ([ δ_x; δ_y;     ]→[ 𝐱; 𝐮;   ]) ∈ℱ_T; (SLP)


        
  * ([ δ_x; δ_y;     ]→[ 𝐲; 𝐮;   ]) ∈ℱ_T; (Mixed I)

        
  * ([ δ_y; δ_u;     ]→[ 𝐱; 𝐮;   ]) ∈ℱ_T;  (Mixed II)

        
  * ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ]) ∈ℱ_T.  (IOP)


   
   
  If (A, B, C) and (A_k, B_k, C_k) are both stabilizable and detectable, we have  (i) ⇔ (ii)⇒ (iii)⇒ (v)
      and (i) ⇔ (ii) ⇒ (iv)⇒ (v). In addition, if (A, B, C) and (A_k, B_k, C_k) are both controllable and observable, we have (i) ⇔ (ii) ⇔ (iii) ⇔ (iv)⇔ (v).

The proof is not mathematically involved, and we provide it in Appendix <ref>. Note that minimal state-space realizations of the plant and the controller deserve more investigations in distributed control when particular structures are required; see <cit.> for details.



















































Upon defining the following sets
         
    𝒞_SLP   = {𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy|Φ_xx,  Φ_ux,
                  Φ_xy,  Φ_uy∈ℱ_T 
                           are in the affine subspace (<ref>)},
    𝒞_M1   = {𝐊 = Φ_uyΦ_yy^-1|Φ_yx, Φ_yy,
                Φ_ux , Φ_uy∈ℱ_T  
                           are in the affine subspace (<ref>)},
    𝒞_M2   = {𝐊 = Φ_uu^-1Φ_uy|Φ_xy, Φ_uy,
                Φ_xu , Φ_uu∈ℱ_T  
                           are in the affine subspace (<ref>)},
    𝒞_IOP   = {𝐊 = Φ_uyΦ_yy^-1|Φ_yy, Φ_uy, Φ_yu,  Φ_uu∈ℱ_T  
                           are in the affine subspace (<ref>)},

it is easy to derive the following corollary.



If (A, B, C) and (A_k, B_k, C_k) are both stabilizable and detectable, 
we have
𝒞_SLP⊂𝒞_M1⊂𝒞_IOP⊂𝒞_stab and 𝒞_SLP⊂𝒞_M2⊂𝒞_IOP⊂𝒞_stab. If (A, B, C) and (A_k, B_k, C_k) are both controllable and observable, we have 𝒞_SLP = 𝒞_M1 =  𝒞_M2 = 𝒞_IOP⊂𝒞_stab.


Theoretically, the closed-loop parameterizations in Propositions <ref>-<ref> are equivalent to each other. However, after imposing the FIR approximation on the decision variables, Corollary <ref> shows that the IOP <cit.> in Proposition <ref> has the best ability to approximate the set of stabilizing controllers 𝒞_stab, as it exclusively deals with the maps from inputs to outputs without passing through the system state; see Figure <ref> for illustration. Precisely, when there are some stable uncontrollable and/or unobservable modes in (<ref>), these modes cannot be changed by any feedback controller and will be reflected in the closed-loop responses involving the state 𝐱. Therefore, for systems with stable uncontrollable and/or unobservable 
modes, the parameters in the SLP <cit.>, or the new parameterization in Proposition <ref>/<ref> (Mixed I/II), cannot be made FIR by definition, since these parameterizations involve the state 𝐱 and/or the disturbance on the state δ_x explicitly.
For example, consider an LTI system (<ref>) with matrices as

    A = [ 0.5   0;   0   1 ],   B = [ 0; 1 ],   C = [ 0 1 ].

There is one uncontrollable and unobservable mode z = 0.5, and this mode is stable. The affine constraints (<ref>),  (<ref>), (<ref>) are all infeasible for any FIR approximation with finite horizon T since the mode z = 0.5 cannot be represented by FIR exactly, while the IOP in Proposition <ref> is feasible as long as the horizon T ≥ 1.


    Note that if there are some stable uncontrollable and/or unobservable modes in (<ref>), one may perform a model reduction to get an equivalent state-space realization that is controllable and observable. Then, all the closed-loop parameterizations in Propositions <ref>-<ref> have the same ability for approximating 𝒞_stab when imposing the FIR assumption. We note that model reduction generally destroys the underlying sparsity structure in the original system (<ref>), which may be unfavourable for distributed controller synthesis <cit.>. 






 §.§ Controller implementation via state-space realization


In Propositions <ref>–<ref>, to get the controller 𝐊, we need to compute the inverse of some transfer matrix as well as the product of transfer matrices.
For the SLP in <cit.>, the authors proposed the following implementation of the controller 𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy from the system responses matrices
Φ_xx, Φ_xy,            Φ_ux, Φ_uy:

    zβ   = z(I - z Φ_xx)β - zΦ_xy𝐲,
    𝐮   = zΦ_uxβ + Φ_uy𝐲.

The implementation (<ref>) avoids the explicit computation of matrix inverse and matrix product. We note that a few other realizations have been discussed in <cit.>. However, the controller matrices in (<ref>) still contain transfer matrices.
Motivated by <cit.>, this subsection provides a standard state-space realization (<ref>) for the controller in closed-loop parameterizations after imposing the FIR approximation.


We consider the controller 𝐊 = Φ_uyΦ_yy^-1 in Proposition <ref> and <ref> (IOP and Mixed I). 
We assume that the system response Φ_uy and Φ_yy are FIR with horizon T, i.e.,

    Φ_uy = ∑_t=0^T U_t 1/z^t∈ℛℋ_∞,  Φ_yy = ∑_t=0^T Y_t 1/z^t∈ℛℋ_∞.

Upon defining the following real matrices

    Û   = [ U_1 U_2   … U_T ]∈ℝ^m × pT,  
    Ŷ   = [ Y_1 Y_2   … Y_T ]∈ℝ^p × pT,

and Z_p ∈ℝ^pT × pT as the down shift operator with sub-diagonal containing identity matrices of dimension p × p 
and ℐ_p = [ I_p, 0 , …,  0 ]^∈ℝ^pT × p,

we have the following result.
 
Suppose that 
Φ_uy and Φ_yy are FIR transfer matrices with horizon T in (<ref>). A state-space realization for the output feedback controller 𝐊 = Φ_uyΦ_yy^-1  is given by



    𝐊= [[ Z_p - ℐ_pŶ       -ℐ_p;    U_0Ŷ- Û        U_0 ]].


A state-space realization for the controller 𝐊 = Φ_uu^-1Φ_uy in Proposition <ref> (Mixed II) can be developed similarly. The proof of Theorem <ref> is motivated by <cit.>, and is based on some standard operations on dynamical systems (see, e.g., <cit.>). We provide the proofs in Appendix <ref> for completeness. In Appendix <ref>, we also provide a state-space realization for the SLP controller 𝐊 =  Φ_uy - Φ_uxΦ_xx^-1Φ_xy. Finally, we note that the state-space realization in (<ref>) is in general not minimal.







§ NUMERICAL ROBUSTNESS OF CLOSED-LOOP PARAMETERIZATIONS
 

The previous sections highlighted the benefits of closed-loop parameterizations: the set of internally stabilizing controllers can be fully characterized by a set of affine constraints on certain closed-loop responses, leading to finite-dimensional convex optimization problems for controller synthesis after imposing the FIR constraints. However, numerical solutions computed via arbitrarily precise floating point arithmetic can never solve the affine constraints exactly. This phenomenon is further exacerbated by  the finite stopping criteria used in common solvers, like SeDuMi <cit.> and Mosek <cit.>. Moreover, any controller implementation that uses floating-point arithmetic also introduce errors. Therefore, numerical mismatches in solving the affine constraints in Propositions <ref>–<ref> always exist.

This section investigates how the numerical mismatches in the affine constraints affect the stability of the closed-loop system, a property termed as numerical robustness of closed-loop parameterizations. 
An overview of the results in this section is presented in Table <ref>.




 §.§ Robustness results for the IOP and the SLP

We begin with the IOP in Proposition <ref>. The transfer matrices Φ̂_yy, Φ̂_uy,
            Φ̂_yu, Φ̂_uu only approximately satisfy the affine constraint (<ref>), i.e., we have
 
    [  I -𝐆 ][ Φ̂_yy Φ̂_yu; Φ̂_uy Φ̂_uu ]   = [ I+Δ_1   Δ_2 ], 
    [ Φ̂_yy Φ̂_yu; Φ̂_uy Φ̂_uu ][ -𝐆;  I ]   = [   Δ_3; I+Δ_4 ], 
    Φ̂_yy, Φ̂_uy,
                Φ̂_yu, Φ̂_uu   ∈ℛℋ_∞,

where the residuals are Δ_1 = Φ̂_yy - 𝐆Φ̂_uy - I,  Δ_2 = Φ̂_yu - 𝐆Φ̂_uu,
    Δ_3 = -Φ̂_yy𝐆 +Φ̂_yu,  Δ_4 = -Φ̂_uy𝐆+Φ̂_uu - I.









    We note that the residuals Δ_i (i = 1, …, 4) can come from 1) numerical computation when enforcing the equality constraints numerically,  and 2) the controller implementation that uses floating-point arithmetic. We use Δ_i (i = 1, …, 4) to denote such mismatches from the equality constraints. The results in this section work regardless of the phenomenon  generating Δ_i (i = 1, …, 4).



 
  Let Φ̂_yy, Φ̂_uy,
            Φ̂_yu, Φ̂_uu satisfy (<ref>). Then, we have the following statements.
            
                
  * In the case of 𝐆∈ℛℋ_∞, the controller 𝐊 = Φ̂_uyΦ̂_yy^-1 internally stabilizes the plant 𝐆 if and only if (I + Δ_1)^-1 is stable.
                
  * In the case of 𝐆∉ℛℋ_∞, the controller 𝐊 = Φ̂_uyΦ̂_yy^-1
                fails to internally stabilize the closed-loop system due to non-zero residuals Δ_i.
                
            




Given a controller 𝐊, the closed-loop responses from (δ_y, δ_u) to (𝐲,𝐮) are

    [ 𝐲; 𝐮 ] = [       (I - 𝐆𝐊)^-1      (I - 𝐆𝐊)^-1𝐆;      𝐊(I - 𝐆𝐊)^-1 I + 𝐊(I - 𝐆𝐊)^-1𝐆 ][ δ_y; δ_u ].

Considering 𝐊 = Φ̂_uyΦ̂_yy^-1, where Φ̂_yy, Φ̂_uy,
            Φ̂_yu, Φ̂_uu satisfy (<ref>), we can verify the following identities:

            
    (I - 𝐆𝐊)^-1   = (I - 𝐆Φ̂_uyΦ̂_yy^-1)^-1
       =  Φ̂_yy(I + Δ_1)^-1, 
    
                    (I - 𝐆𝐊)^-1𝐆     = Φ̂_yy(I + Δ_1)^-1𝐆, 
    𝐊(I - 𝐆𝐊)^-1   = Φ̂_uy(I + Δ_1)^-1,

            and I + 𝐊(I - 𝐆𝐊)^-1𝐆 = I + Φ̂_uy(I + Δ_1)^-1𝐆.

    Proof of Statement 1: Suppose that 𝐆∈ℛℋ_∞. If (I + Δ_1)^-1 is stable, it is easy to verify that all transfer matrices in (<ref>) are stable. This means that
    

    
    ([ δ_y; δ_u ]→[ 𝐲; 𝐮 ]) ∈ℛℋ_∞.

    By Theorem <ref>, we know 𝐊 = Φ̂_uyΦ̂_yy^-1 internally stabilizes the plant 𝐆. If (I+Δ_1)^-1 is unstable, then the closed-loop response from δ_y to 𝐲 will be unstable in general, and thus the controller does not internally stabilize the system.

    Proof of Statement 2: If 𝐆 is unstable, the transfer matrices in (<ref>) cannot be guaranteed to be stable if Δ_1 ≠ 0. When Δ_1 = 0, we have (I - 𝐆𝐊)^-1𝐆 = Φ̂_yy𝐆 = Φ̂_yu - Δ_3 and
    I + 𝐊(I - 𝐆𝐊)^-1𝐆 = I + Φ̂_uy𝐆 = Φ̂_uu - Δ_4.
    Note that the residuals Δ_3, Δ_4 in (<ref>) can be unstable if 𝐆 is unstable (since the product of an unstable transfer matrix and a stable one can be unstable). Thus, the controller fails to guarantee the internal stability of the closed-loop system unless Δ_1 = 0,Δ_2 = 0,Δ_3 = 0,Δ_4 = 0.




We now focus on the SLP in Proposition <ref>. The transfer matrices Φ̂_xx, Φ̂_ux,
            Φ̂_xy, Φ̂_uy only approximately satisfy the affine constraint (<ref>), i.e., we have
            

 
    [ zI - A     -B ][ Φ̂_xx Φ̂_xy; Φ̂_ux Φ̂_uy ]   = [ I+Δ̂_1   Δ̂_2 ], 
    [ Φ̂_xx Φ̂_xy; Φ̂_ux Φ̂_uy ][ zI - A;     -C ]   = [ I + Δ̂_3;     Δ̂_4 ], 
    Φ̂_xx, Φ̂_ux,
                Φ̂_xy, Φ̂_uy   ∈ℛℋ_∞,

where the residuals are Δ̂_1 = (zI - A)Φ̂_xx - BΦ̂_ux - I, and






    
    Δ̂_2    = (zI - A)Φ̂_xy - BΦ̂_uy, 
    Δ̂_3    = Φ̂_xx(zI - A) - Φ̂_xyC - I 
    Δ̂_4    = Φ̂_ux(zI - A) - Φ̂_uyC.



Note that there are multiple ways to recover the controller 𝐊 in the SLP framework. The SLP controller can also be recovered in another way as 𝐊 = Φ̂_uy(I + CΦ̂_xy)^-1 <cit.>. Now, we have the following result.

 
  Let Φ̂_xx, Φ̂_ux,
            Φ̂_xy, Φ̂_uy satisfy (<ref>). We have the following statements.
            
                
  * In the state feedback case, i.e., C = I, the controller 𝐊 = Φ̂_uxΦ̂_xx^-1 internally stabilizes the plant 𝐆 if and only if (I + Δ̂_1)^-1 is stable.
                
  * The four-block SLP controller 𝐊 = Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy cannot guarantee the internal stability of the closed-loop system if
                (I + Δ̂)^-1
                is unstable, where[Note that because Δ̂_∞ may large than 1, there is no guarantee that (I + Δ̂)^-1 is always stable. See Example (<ref>).]
                
    Δ̂:=Δ̂_3+ Φ̂_xx(I + Δ̂_1)^-1(BΔ̂_4 - (zI - A)Δ̂_3).

                
  * For the controller 𝐊 = Φ̂_uy(I + CΦ̂_xy)^-1,

                 
                
  a) if 𝐆∈ℛℋ_∞, 𝐊  internally stabilizes the plant 𝐆 if and only if (I + C(zI - A)^-1Δ̂_2)^-1 is stable.
                
  b) if 𝐆∉ℛℋ_∞, 𝐊 fails to internally stabilizes the closed-loop system due to non-zero residuals Δ̂_i, i = 1, …, 4.
                
            
                
         






The proof of Statement 1 is presented in <cit.>. We prove the second statement here. Given Φ̂_xx, Φ̂_ux,
            Φ̂_xy, Φ̂_uy satisfying (<ref>) and the controller 𝐊 = Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy, we consider the closed-loop response from δ_x to 𝐱. After some tedious algebra (see Appendix <ref>), we derive
            
    (zI - A - B 𝐊 C)^-1
    
            = (I + Δ̂)^-1Φ̂_xx(I + Δ̂_1)^-1,

with Δ̂ defined in (<ref>).




If (I + Δ̂)^-1 is unstable, there is no guarantee that the closed-loop response from δ_x to 𝐱 is stable. In this case, the controller 𝐊 = Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy cannot internally stabilize the plant.

For Statement 3, considering Corollary <ref>, we only need to check the closed-loop response from δ_y to 𝐮, which is
    
    𝐊(I - 𝐆𝐊)^-1
    
        =    Φ̂_uy(I + CΦ̂_xy)^-1 (I - 𝐆Φ̂_uy(I + CΦ̂_xy)^-1)^-1
    
        =   Φ̂_uy (I + CΦ̂_xy - C(zI - A)^-1BΦ̂_uy)^-1
    
        =    Φ̂_uy (I + C(zI - A)^-1Δ̂_2)^-1.

   The rest of the proof is similar to Theorem <ref>.



Theorem <ref> quantifies the numerical robustness of different controller recovery in the SLP due to the mismatches of the associated equality constraints. The mismatches come from  floating-point  arithmetic  in either numerical computation or controller implementation. This is irrespective of whether the FIR approximation is used for the closed-loop responses. Similar robustness results can be derived for the Mixed I/II parameterizations (Propositions <ref>/<ref>); see Appendix <ref>.

Theorems <ref> and <ref> can now be combined with the small gain theorem <cit.> to provide simple sufficient conditions for numerical robustness. 
 
    Let Φ̂_yy, Φ̂_uy,
            Φ̂_yu, Φ̂_uu satisfy (<ref>). Then
    
        
  – for open-loop stable plants, the IOP controller 𝐊 = Φ̂_uyΦ̂_yy^-1 internally stabilizes the plant if Δ_1_∞ < 1.
    
         Let Φ̂_xx, Φ̂_ux,
            Φ̂_xy, Φ̂_uy satisfy (<ref>). Then 
     
         
  – for the state feedback case, the SLP controller 𝐊 = Φ̂_uxΦ̂_xx^-1 internally stabilizes the plant  if Δ̂_1_∞ < 1.
         
  – for open-loop stable plants,  the SLP controller 𝐊 = Φ̂_uy(I + CΦ̂_xy)^-1 internally stabilizes the plant if
         
    Δ̂_2_∞≤1/C(zI - A)_∞.

     



The sufficient condition for robustness of the SLP state feedback case 
first appeared in <cit.>, which is one key result in the recent learning-based control applications <cit.>.

 
    The controller recovery in IOP/Mixed I/II, the two-block state-feedback SLP controller, and the SLP controller 𝐊 = Φ̂_uy(I + CΦ̂_xy)^-1 only involve two parameters explicitly. Thus, their robustness analysis is straightforward. The corresponding analysis for the four-block SLP controller 𝐊 = Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy, instead, does not provide a numerical robustness result. As shown in Theorem <ref>, the residuals Δ̂_i, i = 1, …, 4 play a more complex role in the resulting closed-loop responses, irrespective of state- or output-feedback, or open-loop stability of the plant. Since the closed-loop responses from δ_x, δ_y, δ_u to x, y, u can be computed using these residuals Δ̂_i, one may find sophisticated sufficient conditions on the residuals Δ̂_i to ensure the internally stability of the closed-loop system. These conditions might relate these residuals with
   numerical solutions such as Φ̂_xx. Deriving such conditions and finding tractable ways to enforce these conditions are beyond the scope of this paper and left as future work.












 §.§ Implications in numerical computation and controller implementation
 
Here, we discuss the implication of Theorems <ref>, <ref> and Corollary <ref>. 
In practice, the residuals Δ_1 = Φ̂_yy - 𝐆Φ̂_uy - I (when 𝐆 is stable) and  Δ̂_1 = (zI - A)Φ̂_xx - BΦ̂_xy - I are very small numerically. It is fairly safe to say that Δ_1_∞ < 1 and  Δ̂_1_∞ < 1 in floating-point implementation and numerical computation using any common interior-point solvers, such as SeDuMi <cit.> and Mosek <cit.>. Similar statements are true for the Mixed I/II parameterizations. This observation leads to the following summary (see Table <ref> for an overview).


 


 Numerical Robustness. Consider closed-loop parameterizations (SLP, IOP, Mixed I/II) in numerical computation. We have

    
  (i) the SLP with controller 𝐊 = Φ̂_uxΦ̂_xx^-1 is numerically robust in the state feedback case;
    
  (ii) the IOP, Mixed I/II, and SLP with controller Φ̂_uy(I + CΦ̂_xy)^-1 are numerically robust for open-loop stable plants.

On the other hand, we have


  (I) the IOP, Mixed I/II, and SLP with controller Φ̂_uy(I + CΦ̂_xy)^-1 are not numerically robust for open-loop unstable plants, irrespective of having state- or output-feedback;

  (II) the SLP with controller 𝐊 =Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy is not numerically robust in general, irrespective of open-loop stability of the plant. 








The statements (i), (ii) and (I) are easy to see from the previous section.

The statement (II) comes form Theorem <ref> but requires more attention. Although the computational residuals Δ̂_1, Δ̂_2, Δ̂_3, Δ̂_4 in (<ref>) are typically very small element-wise by interior-point solvers, we still cannot guarantee that Δ̂_∞ < 1 (where Δ̂ is defined in (<ref>)), since Δ̂ involves Φ̂_xx explicitly.  Consequently, it is possible that (I + Δ̂)^-1 is unstable in numerical computation. Therefore, one may argue that the four-block SLP controller 𝐊 =  Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy is not numerically robust in general[As discussed in Remark <ref>,
sufficient conditions could exist to ensure internal stability, and they will depend on Φ̂_xx.]. Further, we notice that the controller implementation (<ref>) proposed in <cit.> also suffers the issue of numerical instability, as the right-hand-side of  (<ref>) represents the corresponding closed-loop response using (<ref>).

 
To understand the role of the residuals, we present a simple example. Consider a stable LTI system (<ref>) with
A = 0,    B = 1,    C = 1.
It can be verified that the following transfer functions

    Φ̂_xx   =  1/z+(z - 5)(z + 6)^2/z^5, 
    Φ̂_ux   =(z - 5)(z + 6)^2/z^4,
    Φ̂_xy   =(z - 5)(z + 6)^2/z^4 - 1/1000(z + 2)^2/z^3,
    Φ̂_uy   = (z - 5)(z + 6)^2/z^3,

satisfy (<ref>) with residuals

    Δ̂_1 = 0,
    Δ̂_2 = -(z + 2)^2/1000z^2,
    Δ̂_3 =(z + 2)^2/1000z^3,
    Δ̂_4 = 0.

For this example, we verify that (I + Δ̂)^-1 has a pair of unstable poles z = 0.9522 ± 0.5226i, despite the norm Δ̂_3_∞=9× 10^-3 being very small, and that this pair of unstable poles also appears in the closed-loop system (zI - A - B𝐊C)^-1 using the controller 𝐊 =  Φ̂_uy - Φ̂_uxΦ̂_xx^-1Φ̂_xy.
This example is open-loop stable and it is also in state feedback form. Nonetheless, a small residual can destabilize the closed-loop using the four-block SLP controller.


We remark that in Example <ref>, since A = 0, the optimal LQR controller will be 𝐊 = 0 for any weight matrices Q and R. Thus, any sensible formulation of optimal control problems using the SLP will not lead to the highly suboptimal solution (<ref>). However, we emphasize that the numerical residuals play a complex role in the closed-loop system using the four-block SLP controller, and residuals with a small norm may lead to an undesirable destabilization situation. Indeed, numerical instability is tightly linked to the specific controller recovery.
Unlike the four-block SLP controller, from Corollary <ref>, the state feedback SLP controller 𝐊 = Φ̂_uxΦ̂_xx^-1 is numerically robust as long as Δ̂_1_∞< 1. Since Δ̂_1 = 0 in Example <ref>, the closed-loop system (zI - A - B𝐊C)^-1 has all zero eigenvalues using 𝐊 = Φ̂_uxΦ̂_xx^-1. Meanwhile, we can verify that C(zI - A)^-1Δ̂_2_∞ = 0.009 < 1, thus it is guaranteed that the controller 𝐊 = Φ̂_uy(I +C Φ̂_xy)^-1 internally stabilizes the plant (the largest norm of the closed-loop eigenvalues is 0.1675).

The question remains whether the phenomenon highlighted in Example <ref> may lead to numerical instability when solving optimal control formulation in practice. We observed several cases where the four-block SLP controller failed to stabilize the plant even using the default setting (high precision) in Mosek <cit.> for numerical computation[See the examples at <https://github.com/zhengy09/h2_clp>, where the system matrices A ∈ℝ^3 × 3, B ∈ℝ^3 × 1, C ∈ℝ^1 × 3 have integer elements randomly generated from -5 to 5, and the weight matrices are chosen Q = I, R = I in (<ref>). ]. This is likely due to Φ̂_xx_∞ being high, despite solving an optimal control formulation. How to avoid this issue requires more investigations, which is left for future work.






 §.§ Open-loop unstable plants and relation with the Youla parameterization

To characterize the set of internally stabilizing controllers 𝒞_stab, the closed-loop parameterizations in Proposition <ref>–<ref> can avoid computing the doubly co-prime factorization of the plant a priori, but they all need to impose a set of affine constraints for achievable closed-loop responses. As discussed above, any small mismatch in the additional affine constraints can make the resulting controller un-implementable when the plant is open-loop unstable (IOP, Mixed I/II), and the four-block SLP controller requires a case-by-case investigation.

For the case of open-loop unstable plants, there exists a valid remedy by pre-stabilizing the plant. Suppose that 𝐆 is unstable, and that a stable and stabilizing controller 𝐊_0 is known a priori. We can split the control signal as
 𝐮 = 𝐊_0𝐲 + 𝐮_1,
 and design 𝐮_1. This is equivalent to applying the closed-loop parameterization to the new stable plant 𝐆̂ := (I - 𝐆𝐊_0)^-1𝐆 (see Figure <ref> for illustration).


Upon defining

    𝒞̂_stab := {𝐊_0 + 𝐊_1 |𝐊_1  internally stabilizes  𝐆̂},

we have the following result.

 
Given an initial controller 𝐊_0 ∈𝒞_stab∩ℛℋ_∞, we have
   𝒞_stab =  𝒞̂_stab.

The proof is based on algebra verification; see Appendix <ref>. Proposition <ref> shows that searching over 𝒞̂_stab has no conservatism. The new plant 𝐆̂ = (I - 𝐆𝐊_0)^-1𝐆 is stable, and thus any closed-loop parameterization in Propositions <ref>–<ref> for this plant has good numerical robustness[For the SLP, we use the controller 𝐊 = Φ̂_uy(I + CΦ̂_xy)^-1.]. As shown in <cit.>, giving 𝐊_0 ∈𝒞_stab∩ℛℋ_∞, the Youla parameterization (<ref>) has a simple form as well, since one can choose an explicit doubly-coprime factorization as

    𝐌_l    = (I - 𝐆𝐊_0)^-1,     𝐌_r = -(I - 𝐊_0𝐆)^-1
    𝐍_l    = 𝐆(I - 𝐊_0𝐆)^-1,    𝐍_r = -𝐆(I - 𝐊_0𝐆)^-1, 
    𝐔_l    = -I,   𝐕_l = - 𝐊_0,    𝐔_r = I,    𝐕_r = 𝐊_0.

If the plant is open-loop stable, we can choose 𝐊_0 = 0.


Unlike the closed-loop parameterizations in Propositions <ref>–<ref>, the Youla parameterization (<ref>) allows 
the parameter 𝐐 to be freely chosen in ℛℋ_∞ with no equality constraints. Indeed, any doubly-coprime factorization of the plant can be used to eliminate the affine constraints in Propositions <ref>–<ref> exactly, as shown below.

 
     Let 𝐔_r,𝐕_r,𝐔_l,𝐕_l,𝐌_r,𝐌_l,𝐍_r,𝐍_l be any  doubly-coprime factorization of 𝐆. For any 𝐐∈ℛℋ_∞, the following transfer matrices
    
    Φ_yy   =(𝐔_r-𝐍_r𝐐)𝐌_l ,
    Φ_uy   =(𝐕_r-𝐌_r𝐐)𝐌_l ,
    Φ_yu   =(𝐔_r-𝐍_r𝐐)𝐍_l ,
    Φ_uu   =I+(𝐕_r-𝐌_r𝐐)𝐍_l ,

    and Φ_xx = (zI - A)^-1 +
    (zI - A)^-1BΦ_uyC(zI - A)^-1,

    
    Φ_ux    = Φ_uyC(zI - A)^-1,
    Φ_xy   = (zI - A)^-1BΦ_uy, 
    Φ_xu   = (zI - A)^-1BΦ_uu,
    Φ_yx   = Φ_uuC(zI - A)^-1,

satisfy the affine constraints (<ref>), (<ref>), (<ref>), (<ref>).

The proof is based on direct verification, which is omitted here; see <cit.> for further discussions on the equivalence of the Youla parameterization, the IOP, and the SLP. We note that a doubly-coprime factorization can be found in the state-space domain <cit.>, and this pre-process might introduce  numerical issues that affect closed-loop stability, which is beyond the scope of this paper.





§ CASE STUDIES



In this section, we present a case study of optimal controller synthesis for open-loop stable plants using Propositions <ref>-<ref>. We show that the optimal controller synthesis problem can be cast into a quadratic program (QP) after imposing the FIR constraint.[Code is available at <https://github.com/soc-ucsd/h2_clp>.]



 §.§ Application to optimal controller synthesis




















Consider the optimal controller synthesis (<ref>). Using a change of variables, as suggested in Propositions <ref>-<ref>, it is equivalent to replace 𝐊∈𝒞_stab with the affine constraints (<ref>), (<ref>), (<ref>), or (<ref>). It remains to reformulate the cost function in terms of these new variables. Simple algebra shows that

    (I-𝐆𝐊)^-1   = Φ_yy = CΦ_xy+ I, 
    𝐊(I-𝐆𝐊)^-1   = Φ_uy, 
    
        (I-𝐊𝐆)^-1   = Φ_uu = Φ_uxB + I,

and
(I-𝐆𝐊)^-1𝐆 = Φ_yu = CΦ_xxB = CΦ_xu = Φ_yxB.

Therefore, problem (<ref>) is equivalent to any of the following convex optimization problems (<ref>)-(<ref>)  corresponding to Propositions <ref>–<ref>, respectively.

    min     [ Q^1/2     0;     0 R^1/2 ][  CΦ_xy+ I    CΦ_xxB;      Φ_uy Φ_uxB + I ]^2_ℋ_2
    s.t.     Φ_xx,Φ_xy,Φ_ux,Φ_uy  satisfy (<ref>).


    min     [ Q^1/2     0;     0 R^1/2 ][ Φ_yy Φ_yu; Φ_uy Φ_uu ]^2_ℋ_2
    s.t.     Φ_yy, Φ_yu, Φ_uy, Φ_uu  satisfy (<ref>).

 
    min     [ Q^1/2     0;     0 R^1/2 ][      Φ_yy     Φ_yxB;      Φ_uy Φ_uxB + I ]^2_ℋ_2
    s.t.     Φ_yy,Φ_uy,Φ_yx,Φ_ux  satisfy (<ref>).

 
    min     [ Q^1/2     0;     0 R^1/2 ][ CΦ_xy+I   CΦ_xu;    Φ_uy    Φ_uu ]^2_ℋ_2
    s.t.     Φ_xy,Φ_uy,Φ_xu,Φ_uu  satisfy (<ref>).


Note that the ℋ_2 norm of an FIR transfer matrix 𝐇 = ∑_k=1^T 1/z^kH_k admits the following expression
𝐇^2_ℋ_2 = ∑_k=1^T Trace(H_k^ H_k).
Thus, after imposing the FIR constraint on the decision variables, problems (<ref>)-(<ref>) can be reformulated into QPs, for which very efficient solvers exist. 










 §.§ Numerical experiments


Here, we use a car-following control scenario <cit.> (see Figure <ref> for illustration) to demonstrate the numerical performance of the parameterizations in Propositions <ref>-<ref>.

Modelling: We denote the position and velocity of vehicle i as p_i and v_i. The spacing of vehicle i, i.e., its relative distance from vehicle i-1, is defined as s_i = p_i-1 - p_i, i=1, 2. Without loss of generality, the vehicle length is ignored. It is assumed that the leading vehicle 0 runs at a constant velocity v_0. Each vehicle has pre-existing car-following dynamics, and we aim to design an additional control signal u_i(t) to improve the car-following performance, i.e.,

    v̇_i(t) = F(s_i(t),ṡ_i(t),v_i(t)) + u_i(t),

where ṡ_i(t) = v_i-1(t) - v_i(t), and F(·) characterizes the driver's natural car-following behavior (see <cit.> for details). In an equilibrium car-following state, each vehicle moves with the same equilibrium velocity, i.e., v_i(t) = v_0, ṡ_i(t) = 0, for i = 1, 2. Assuming that each vehicle has a small perturbation from the equilibrium state (s_i^*,v^*), we define the error state between actual and equilibrium state of vehicle i as
x_i(t)=[ s̃_i(t),ṽ_i(t) ]^=[ s_i(t)-s_i^*,v_i(t)-v^* ]^.
Applying the first-order Taylor expansion to (<ref>), we can derive a linearized model for each vehicle (i=1, 2)

    ṡ̃̇_i(t)=ṽ_i-1(t)-ṽ_i(t),
    ṽ̇_i(t)=α_1s̃_i(t)-α_2ṽ_i(t)+α_3ṽ_i-1(t) + u_i(t),

with α_1 = ∂ F/∂ s_i, α_2 = ∂ F/∂ṡ_i - ∂ F/∂ v_i, α_3 = ∂ F/∂ṡ_i evaluated at the equilibrium state. Assuming that we can measure the relative spacing, we arrive at the following state-space model

    ẋ   = [ P_1   0; P_2 P_1 ]  x  + [ B_1   0;   0 B_1 ]( u + δ_u), 
    
            y    = [ C_1   0;   0 C_1 ]x + δ_y,

where  x = [ x_1^ x_2^ ]^, u = [ u_1 u_2 ]^, y = [ s̃_1(t) s̃_2(t) ]^, δ_u and δ_y are control input noise and measurement noise, respectively, and

    P_1 = [    0   -1;  α_1 -α_2 ],     P_2 = [   0   1;   0 α_3 ], B_1 = [ 0; 1 ], C_1 = [ 1 0 ].

The objective is to design u_i(t) to regulate the spacing error s_i(t)-s_i^* and velocity error v_i(t)-v^* based on the output information y(t). This problem can be formulated into (<ref>) in the discrete-time domain.







Numerical results: In our numerical simulations, the car-following parameters α_1 = 0.94, α_2 = 1.5, α_3 = 0.9 are chosen according to the setup in <cit.>, and the open-loop system is stable. Using a forward Euler-discretization of (<ref>) with a sampling time of dT = 0.1s, we formulate the corresponding optimal controller synthesis problem (<ref>) in discrete-time with Q = I and R = I. This can be solved via any of the convex problems (<ref>)-(<ref>). We varied the FIR length T from 10 to 75, and the results are listed in Table I. As expected, when increasing the FIR length, the optimal cost from (<ref>)-(<ref>) converges to the true value returned by the standard synthesis  in MATLAB. Given an initial state x_0 = [3, 0, -2, 0]^, Figure <ref> shows the time-domain responses[The responses from (<ref>)-(<ref>) have no visible difference.] of the closed-loop system using the resulting controllers from (<ref>)-(<ref>) when the FIR length is T = 30. By design, the closed-loop system converges to the equilibrium state within 3 seconds.  
For the same initial state, Figure <ref> shows the time-domain responses of the closed-loop system when the FIR length is T = 75, where the system converges the equilibrium state within 7.5 seconds with lower peak values during the transient process compared to the case T = 30.















§ CONCLUSIONS



In this paper, we have characterized all possible parameterizations for the set of stabilizing controllers using closed-loop maps. We have revealed two other parallel choices beyond the recent notions of SLP <cit.> and IOP <cit.>. In fact, our analysis allows to treat the SLP <cit.> and the IOP <cit.> in a unified way. 
After imposing the FIR approximation, the ability of the four parameterizations for encoding 𝒞_stab becomes different, and the IOP enjoys the best approximation ability. These closed-loop parameterizations can avoid computing the doubly co-prime factorization of the plant a priori, but instead require imposing a set of affine constraints for achievable closed-loop responses. We have discussed 
two numerically robust scenarios: the SLP in the state feedback case and the IOP for open-loop stable plants.


One future direction is to address decentralized control, e.g., the notion of quadratic invariance (QI) <cit.> and sparsity invariance (SI) <cit.>, using different parameterizations. Also, similar to SLP <cit.> and Youla <cit.>, it will be extremely interesting to investigate the features of different parameterizations in robust synthesis for uncertain systems and their applications in learning-based control. Finally, we have established that  closed-loop parameterizations are more subtle in practice for open-loop unstable plants with output feedback, and further investigation is needed to unravel a more precise and thorough understanding of related aspects.







Acknowledgement: The authors would like to thank Nikolai Matni, James Anderson and John C Doyle for several insightful discussions, particularly around the robustness of the SLS framework. The authors thank John C Doyle for his encouragement to find a simple SISO example, eventually leading to (<ref>). We also thank three anonymous reviewers and Associate Editor, whose suggestions improved the quality of this work.









Appendix



§ PROOF OF PROPOSITION <REF>
 

Statement 1: Given any 𝐊∈𝒞_stab, it is easy to derive that the closed-loop responses (<ref>) are
        
    Φ_yx   = (I - 𝐆𝐊)^-1C(zI - A)^-1,
    Φ_yy   = (I - 𝐆𝐊)^-1,
    Φ_ux   =𝐊(I - 𝐆𝐊)^-1C(zI - A)^-1, 
    Φ_uy   = 𝐊(I - 𝐆𝐊)^-1,

        which are all stable by definition. Then, it is not difficult to verify that
        
    Φ_yx - 𝐆Φ_ux    
                = C(zI - A)^-1, 
    Φ_yy - 𝐆Φ_uy   = (I - 𝐆𝐊)^-1-  𝐆𝐊(I - 𝐆𝐊)^-1 = I,

         and that
        
    Φ_yx(zI - A) - Φ_yyC    = 0,  
    Φ_ux(zI - A) - Φ_uyC    = 0.

        
        Therefore, the closed-loop responses Φ_yx, Φ_yy,
            Φ_ux , Φ_uy satisfy (<ref>).

        Statement 2: Consider any Φ_yx, Φ_yy,
            Φ_ux , Φ_uy satisfying (<ref>). Since Φ_yy = I + 𝐆Φ_uy and 𝐆 is strictly proper, we know that Φ_yy is always invertible. Let 𝐊 = Φ_uyΦ_yy^-1.
            We now verify the resulting closed-loop responses in (<ref>) are all stable. In particular, we have
             
    𝐲 = (I - 𝐆𝐊)^-1C(zI - A)^-1δ_x,

             and with 𝐊 = Φ_uyΦ_yy^-1, we have
             
    (I - 𝐆Φ_uyΦ_yy^-1)^-1C(zI - A)^-1
    
                =   Φ_yy(Φ_yy - 𝐆Φ_uy)^-1C(zI - A)^-1
    
                =    Φ_yyC(zI - A)^-1
    
                =    Φ_yx∈ℛℋ_∞,

            where the 
            equalities follow from the fact that Φ_yx, Φ_yy,
            Φ_ux, Φ_uy satisfy (<ref>).
            Also, we have that
            
    𝐲 = (I - 𝐆Φ_uyΦ_yy^-1)^-1δ_y = Φ_yyδ_y.

            Similarly, we can show that
        
    𝐮   = 𝐊(I - 𝐏_22𝐊)^-1C_2(zI - A)^-1δ_x =  Φ_uxδ_x,
              
    𝐮   =𝐊(I - 𝐏_22𝐊)^-1δ_y =  Φ_uyδ_y.

        Therefore, we have proved that
        ([ δ_x; δ_y;     ]→[ 𝐲; 𝐮;   ])∈ℛℋ_∞,
        using the controller 𝐊 = Φ_uyΦ_yy^-1.
        By Theorem <ref>, we know 𝐊 = Φ_uyΦ_yy^-1∈𝒞_stab.




§ PROOF OF THEOREM <REF>
 

    The direction (i) ⇒ (ii), (iii), (iv), (v) is true by definition. For any controller 𝐊, the closed-loop responses are given in (<ref>) and (<ref>).

    We now prove (ii) ⇒ (i). Suppose we have

    ([ δ_x; δ_y;     ]→[ 𝐱; 𝐮;   ]) = [ Φ_xx Φ_xy; Φ_ux Φ_uy ]∈ℱ_T.


From (<ref>), it is not difficult to check Φ_xu = Φ_xxB ∈ℱ_T, and

    Φ_yx   = CΦ_xx∈ℱ_T,    Φ_yy   = CΦ_xy+ I ∈ℱ_T 
    Φ_yu   = CΦ_xxB ∈ℱ_T,    Φ_uu   = Φ_uxB + I ∈ℱ_T.


This means that the statement (i) is true. Similar arguments can prove (iii) ⇒ (v) and (iv) ⇒ (v).

        Finally, if (A, B, C) and (A_k, B_k, C_k) are both controllable and observable, we prove that (v) ⇒ (i). According to (<ref>), we have the following state-space realization
        
    ([ δ_y; δ_u;     ]→[ 𝐲; 𝐮;   ]) =  Ĉ_1 (zI - A_cl)^-1B̂_2  + [   I   0; D_k   I ],

    where Ĉ_1 and B̂_2 are defined in (<ref>).
    We can show that
    (A_cl,B̂_2,Ĉ_1)
    is controllable and observable (see Appendix <ref>). This means that the eigenvalues of A_cl are the same as the poles of the transfer matrices <cit.>. Therefore, if the statement (v) 
    is true, then the closed-loop matrix  A_cl only has zero eigenvalues and no eigenvalues of A_cl is hidden from the input-output behavior. 
    This completes the proof.




§ PROOF OF STABILIZABILITY OF (<REF>)

Consider a feedback gain
K = [ K_1 K_2 ],
where K_1 ∈ℝ^n × n,K_2 ∈ℝ^n × p.
We have

    [ A+BD_k   BC_k;    B_k    A_k ] +  [ I; 0 ][ K_1 K_2 ]
    
        =    [ A+BD_k + K_1   BC_k + K_2;          B_k          A_k ].






Since (A_k,B_k) is stabilizable, there exists F_k∈ℝ^n × q such that A_k + B_kF_k is stable.
By choosing

    K_1    = - A - BD_k -  I + F_kB_k
    
            K_2     = -BC_k - (A+BD_k + K_1)F_k + F_k(A_k+B_kF_k),

it can be easily verify that

    [   I F_k;   0   I ]^-1[ A+BD_k + K_1   BC_k + K_2;          B_k          A_k ][   I F_k;   0   I ]
       =  [         -I          0;        B_k A_k+B_kF_k ].

is stable. Since the similarity transformation does not change eigenvalues,
there exist K_1, K_2 such that

    [ A+BD_k + K_1   BC_k + K_2;          B_k          A_k ]

is stable. This completes the proof. 



§ PROOF OF PROPOSITION <REF>
 
Statement 1: Given 𝐊∈𝒞_stab, it  is  easy  to derive that the closed-loop responses (<ref>) are

    Φ_xy   = Φ_xxB𝐊,     Φ_xu   = Φ_xxB,  
    Φ_uy   = 𝐊(CΦ_xxB𝐊 + I),     Φ_uu   = 𝐊CΦ_xxB + I,

 where  Φ_xx = (zI - A - B𝐊C)^-1∈ℛℋ_∞. They are all stable by definition. Then, it is not difficult to verify that
 
    (zI - A) Φ_xy - B Φ_uy
    
            =     (zI - A)Φ_xxB𝐊 - B𝐊(CΦ_xxB𝐊 + I) 
    
            =    ((zI - A)Φ_xx - B𝐊CΦ_xx - I)B𝐊
             =  0,

         and
         
    (zI - A) Φ_xu - B Φ_uu
    
            =     (zI - A)Φ_xxB - B(CΦ_xxB𝐊 + I) 
    
            =    ((zI - A)Φ_xx - B𝐊CΦ_xx - I)B
             =   0,

and that
 
    -Φ_xy𝐆 + Φ_xu   =(zI - A)^-1B,
    
            -Φ_uy𝐆 + Φ_uu   = I.

Therefore, the closed-loop responses Φ_yx, Φ_uy,
            Φ_xu, Φ_uu satisfy (<ref>).

 Statement 2: Consider any Φ_xy, Φ_uy,
            Φ_xu , Φ_uu satisfying (<ref>). Since Φ_uu = I + Φ_uy𝐆, Φ_uu is always invertible. Let 𝐊 = Φ_uu^-1Φ_uy.
            We now verify that the resulting closed-loop responses (<ref>) are all stable. In particular, we have
            
    𝐱 = (zI - A - B𝐊C)^-1B δ_u,

            and with the controller 𝐊 = Φ_uu^-1Φ_uy, we have
            
    (zI - A - BΦ_uu^-1Φ_uyC)^-1B   
    
                         =   (zI -A)^-1(I - BΦ_uu^-1Φ_uyC(zI -A)^-1)^-1B  
    
                         =   (zI -A)^-1B(I - Φ_uu^-1Φ_uy𝐆)^-1
    
                         =   (zI -A)^-1B(Φ_uu - Φ_uy𝐆)^-1Φ_uu
    
                         =   Φ_xu∈ℛℋ_∞,

            where the last equality follows from the fact that Φ_xy, Φ_uy,
            Φ_xu , Φ_uu satisfy (<ref>).
    Also, it is not difficult to derive that
 
    𝐱   = (zI - A - B𝐊C)^-1B𝐊δ_y = Φ_xyδ_y, 
    𝐮   = 𝐊(CΦ_xxB𝐊 + I)δ_y = Φ_uyδ_y, 
    𝐮   = (𝐊C(zI - A - B𝐊C)^-1B +I)δ_u = Φ_uuδ_u.

 Thus, we have proved that
        
    ([ δ_y; δ_u ]→[ 𝐱; 𝐮;   ]) ∈ℛℋ_∞.

        By Theorem <ref>, we conclude that 𝐊 =Φ_uu^-1Φ_uy∈𝒞_stab.




§ CONTROLLABILITY AND OBSERVABILITY OF (<REF>)
 


    The following statements are equivalent:
    
        
  * (A,B) is controllable;
        
  * (A+BF,B) is controllable for any compatible matrix F;
        
  * [A-λ I, B] has full row rank,  ∀λ∈ℂ.
    


We are ready to prove the controllability of (A_cl, B̂_2). First, controllability is invariant under state feedback. We consider

    [ A + BD_kC      BC_k;      B_kC       A_k ] - [ BD_k    B;  B_k    0 ][ C 0; 0 0 ] =  [    A BC_k;    0  A_k ].

Since (A, B) and (A_k, B_k) are controllable, we have rank(λ I - A, B) = n and rank(λ I - A_k, B_k) = n_k, ∀λ∈ℂ. Thus,

    rank([   λ I - A     -BC_k      BD_k         B;         0 λ I - A_k       B_k         0 ]) = n+ n_k, ∀λ∈ℂ,

indicating that (A_cl,B̂_2) is controllable. The observability of (A_cl,Ĉ_1) can be proved in a similar way.



§ STATE SPACE REALIZATIONS





In this section, we use the following system operations very often (see <cit.>). Consider two dynamic systems 
    𝐆_i = [[ A_i B_i; C_i D_i ]],    i = 1, 2.

Their inverses are given by

    𝐆_i^-1 = [[ A_i - B_iD_i^-1C_i         -B_iD_i^-1;          D_i^-1C_i             D_i^-1 ]],

where we assume D_i is invertible. If the system is strictly proper, then the inverse will be non-proper and there is no state-space realization. The cascade connection of two systems such that 𝐲 = 𝐆_1𝐆_2𝐮 has a realization

    𝐆_1𝐆_2 = [[    A_1 B_1C_2 B_1D_2;      0    A_2    B_2;    C_1 D_1C_2 D_1D_2 ]]

and a parallel connection 𝐲 = (𝐆_1 - 𝐆_2)𝐮 has a realization

    𝐆_1 - 𝐆_2 = [[     A_1       0     B_1;       0     A_2     B_2;     C_1    -C_2 D_1-D_2 ]].

We note that (<ref>) and (<ref>) are in general not  minimal. 

In addition, we use the following fact: for any invertible matrix T with proper dimension,

    𝐆_i = [[ A_i B_i; C_i D_i ]] =  [[ TA_iT^-1     TB_i;  C_iT^-1      D_i ]].





 §.§ State space realization of the SLP controller


    For the SLP controller 𝐊 =  Φ_uy - Φ_uxΦ_xx^-1Φ_xy in Proposition <ref>, we assume the system responses Φ_uy, Φ_ux, Φ_xx, Φ_xy are FIR transfer matrices of horizon T, i.e.,
    
    Φ_ux   =∑_t=0^T M_t 1/z^t∈ℛℋ_∞, Φ_xx = ∑_t=0^T R_t 1/z^t∈ℛℋ_∞,  
    Φ_xy   =∑_t=0^T N_t 1/z^t∈ℛℋ_∞.

Upon defining the following matrices

    M̂   = [ M_2 M_3   … M_T ]∈ℝ^m × nT̂, 
    R̂   = [ R_2 R_3   … R_T ]∈ℝ^n × nT̂, 
    N̂   = [ N_1 N_2   … N_T ]∈ℝ^n × pT,

and
Z_n ∈ℝ^nT̂× n T̂ as the down shift operator with sub-diagonal containing identity matrices of dimension n × n, and ℐ_n = [ I_n, 0 , …,  0 ]^∈ℝ^n T̂× n,
with T̂ = T - 1, we have the following result.
 
Suppose that 
Φ_uy, Φ_ux, Φ_xx, Φ_xy are FIR transfer matrices with horizon T in (<ref>) and (<ref>). A state-space realization for the output feedback controller 𝐊 = Φ_uy - Φ_uxΦ_xx^-1Φ_xy  is given by 
    
    𝐊 =  [[ Z_n - ℐ_nR̂      -ℐ_nN̂           0;           0         Z_p         ℐ_p;    M̂-M_1R̂     Û-M_1N̂         U_0 ]].







 §.§ Proof of Theorem <ref>


Considering the FIR transfer matrices Φ_uy and Φ_yy in (<ref>). By the affine constraint (<ref>), we always have Y_0 = I_p. The following state-space realizations of Φ_uy and Φ_yy are
   
    Φ_uy = [[ Z_p ℐ_p;   Û U_0 ]],   Φ_yy = [[ Z_p ℐ_p;   Ŷ I_p ]],

with Û and Ŷ defined in (<ref>), and Z_p and ℐ_p defined as 

    Z_p = [   0   0   0   …   0; I_p   0   0   …   0;   0 I_p   0   …   0;   ⋮   ⋮   ⋱   ⋱   ⋮;   0   0   … I_p   0 ]∈ℝ^pT × pT,  ℐ_p = [ I_p;   0;   ⋮;   0 ]∈ℝ^pT × p.

Then, we have

    Φ_uyΦ_yy^-1   = [[ Z_p ℐ_p;   Û U_0 ]] [[ Z_p ℐ_p;   Ŷ I_p ]]^-1
       = [[ Z_p ℐ_p;   Û U_0 ]] [[ Z_p -ℐ_pŶ      -ℐ_p;         Ŷ       I_p ]] 
       = [[        Z_p       ℐ_pŶ        ℐ_p;          0 Z_p - ℐ_pŶ       -ℐ_p;          Û       U_0Ŷ        U_0 ]].

By defining a transformation

    T = [ I I; 0 I ], T^-1 = [  I -I;  0  I ],

with compatible dimension, and according to (<ref>), we have 
    Φ_uyΦ_yy^-1 = [[        Z_p          0          0;          0 Z_p - ℐ_pŶ       -ℐ_p;          Û    U_0Ŷ- Û        U_0 ]] = [[ Z_p - ℐ_pŶ       -ℐ_p;    U_0Ŷ- Û        U_0 ]].

In the last step, we have removed some uncontrollable and unobservable modes.





 §.§ Proof of Theorem <ref>

First, similar to the realization of Φ_uyΦ_yy^-1, we have

    Φ_uxΦ_xx^-1 = (zΦ_ux)(zΦ_xx)^-1 =  [[ Z_n - ℐ_nR̂        -ℐ_n;    M_1R̂-M̂         M_1 ]],

where M̂ and R̂ are defined in (<ref>), and Z_n and ℐ_n are defined as

    Z_n = [   0   0   0   …   0; I_n   0   0   …   0;   0 I_n   0   …   0;   ⋮   ⋮   ⋱   ⋱   ⋮;   0   0   … I_n   0 ]∈ℝ^nT̂× nT̂,  ℐ_n = [ I_n;   0;   ⋮;   0 ]∈ℝ^nT̂× n.

Then, we have

    Φ_uy - (zΦ_ux)(zΦ_xx)^-1Φ_xy
    
    
    
    
    
        =   [[ Z_p ℐ_p;  L̂ L_0 ]]-  [[ Z_n - ℐ_nR̂      -ℐ_nN̂           0;           0         Z_p         ℐ_p;    M_1R̂-M̂      M_1 N̂           0 ]]  
    
    
    
    
    
       =   [[         Z_p           0           0         ℐ_p;           0 Z_n - ℐ_nR̂      -ℐ_nN̂           0;           0           0         Z_p         ℐ_p;          L̂   -M_1R̂+M̂     -M_1 N̂         L_0 ]]

Define a similarity transformation

    T̂ = [  I  0 -I;  0  I  0;  0  0  I;    ], T̂^-1 = [ I 0 I; 0 I 0; 0 0 I;   ].

We derive

    Φ_uy - Φ_uxΦ_xx^-1Φ_xy=  [[ Z_n - ℐ_nR̂      -ℐ_nN̂           0;           0         Z_p         ℐ_p;   -M_1R̂+M̂   -M_1N̂+L̂         L_0 ]].







§ DERIVATIONS OF (<REF>)


For notational convenience, we use (𝐑,𝐌,𝐍,𝐋) in place of (Φ̂_xx,Φ̂_ux,Φ̂_xy,Φ̂_uy) here, as used in <cit.>. The following derivations utilize the affine relationship (<ref>) multiple times:

    (zI - A - B 𝐊 C)^-1
    
            =    (zI - A - B (𝐋 - 𝐌𝐌^-1𝐍) C)^-1
    
             =    (zI - A - B 𝐋C + B𝐌𝐑^-1𝐍C)^-1
    
            =   (zI - A - B (𝐌(zI - A) - Δ̂_4) + B𝐌𝐑^-1𝐍C)^-1
    
            =    (zI - A - B𝐌(zI - A)  + BΔ̂_4 + B𝐌𝐑^-1𝐍C)^-1

        
    =    (zI - A - B𝐌𝐑^-1(𝐑(zI - A)  - 𝐍C) + BΔ̂_4 )^-1
    
            =    (zI - A - B𝐌𝐑^-1(I + Δ̂_3) + BΔ̂_4 )^-1
    
            =    (zI - A - B𝐌𝐑^-1 - B𝐌𝐑^-1Δ̂_3 + BΔ̂_4 )^-1
    
        =   𝐑((zI - A)𝐑 - B𝐌 - B𝐌𝐑^-1Δ̂_3𝐑 + BΔ̂_4𝐑)^-1
    
            =    𝐑(I + Δ̂_1 - B𝐌𝐑^-1Δ̂_3𝐑 + BΔ̂_4𝐑)^-1
    
            =    𝐑(I + Δ̂_1 - ((zI-A)𝐑 - I - Δ̂_1)𝐑^-1Δ̂_3𝐑 + BΔ̂_4𝐑)^-1.

We can further simplified this expression:

    𝐑(I + Δ̂_1 - ((zI-A)𝐑 - I - Δ̂_1)𝐑^-1Δ̂_3𝐑 + BΔ̂_4𝐑)^-1
    
             
             =   ((I + Δ̂_1)𝐑^-1 - (zI - A)Δ̂_3 + (I + Δ̂_1)𝐑^-1Δ̂_3 + BΔ̂_4)^-1
    
             
             =   (I + Δ̂)^-1𝐑(I + Δ̂_1)^-1,

where Δ̂ is defined in (<ref>).



§ ROBUSTNESS OF MIXED I/II PARAMETERIZATIONS
 
We consider the Mixed I parameterization in Proposition <ref>. The transfer matrices Φ̂_yx, Φ̂_ux,
            Φ̂_yy, Φ̂_uy only approximately satisfy the affine constraint (<ref>), i.e., we have
  
    [   I - 𝐆 ][ Φ̂_yx Φ̂_yy; Φ̂_ux Φ̂_uy;       ]   = [ C(zI - A)^-1 + Δ_1            I + Δ_2 ],
    [ Φ̂_yx Φ̂_yy; Φ̂_ux Φ̂_uy;       ][ zI - A;     -C ]   = [ Δ_3; Δ_4 ],
            
    Φ̂_yx, Φ̂_ux,
                Φ̂_yy, Φ̂_uy   ∈ℛℋ_∞,

where Δ_1,  Δ_2,
    Δ_3, Δ_4 are the computational residuals.

 
  Let Φ̂_yx, Φ̂_ux,
            Φ̂_yy, Φ̂_uy satisfy (<ref>). Then, we have the following statements.
            
                
  * In the case of 𝐆∈ℛℋ_∞, the controller 𝐊 = Φ̂_uyΦ̂_yy^-1 internally stabilizes the plant 𝐆 if and only if (I + Δ_2)^-1 is stable.
                
  * In the case of 𝐆∉ℛℋ_∞, the controller 𝐊 = Φ̂_uyΦ̂_yy^-1 cannot guarantee the internal stability of the closed-loop system unless Δ_1 = 0,Δ_2 = 0,Δ_3 = 0,Δ_4 = 0.
            

The proof is almost identical to that of Theorem <ref>.

We then consider Mixed II parameterization in Proposition <ref>. The transfer matrices Φ̂_xy, Φ̂_uy,
            Φ̂_xu, Φ̂_uu only approximately satisfy the affine constraint (<ref>), i.e., we have
  
    [ zI - A    - B ][ Φ̂_xy Φ̂_xu; Φ̂_uy Φ̂_uu;       ]   = [ Δ_1 Δ_2 ],
    [ Φ̂_xy Φ̂_xu; Φ̂_uy Φ̂_uu;       ][ -𝐆;  I ]   = [ (zI - A)^-1B + Δ_3;            I + Δ_4 ],
            
    Φ̂_xy, Φ̂_uy,
                Φ̂_xu, Φ̂_uu   ∈ℛℋ_∞,

where Δ_1,  Δ_2,
    Δ_3, Δ_4 are the computational residuals.

 
  Let Φ̂_xy, Φ̂_uy,
            Φ̂_xu, Φ̂_uu satisfy (<ref>). Then, we have the following statements.
            
                
  * In the case of 𝐆∈ℛℋ_∞, the controller 𝐊 = Φ̂_uu^-1Φ̂_uy internally stabilizes the plant 𝐆 if and only if (I + Δ_4)^-1 is stable.
                
  * In the case of 𝐆∉ℛℋ_∞, the controller 𝐊 = Φ̂_uu^-1Φ̂_uy cannot guarantee the internal stability of the closed-loop system unless Δ_1 = 0,Δ_2 = 0,Δ_3 = 0,Δ_4 = 0.
            

The proof is similar to that of Theorem <ref>. We just highlight that for the case  𝐆∈ℛℋ_∞, we only need to check the closed-loop response from δ_y to u, which is

    u   = 𝐊(I - 𝐆𝐊)^-1δ_y 
       = (I - 𝐊𝐆)^-1𝐊δ_y 
        = (I - Φ̂_uu^-1Φ̂_uy𝐆)^-1Φ̂_uu^-1Φ̂_uyδ_y 
       = (I + Δ_4)^-1Φ̂_uyδ_y.

Then, the first statement in Theorem <ref> becomes obvious.



§ PROOF OF PROPOSITION <REF>



    ⇐  We first prove that ∀ 𝐊∈𝒞̂_stab, we have 𝐊∈𝒞_stab. Since 𝐊∈𝒞̂_stab, we know
    
    [    (I - 𝐆̂𝐊_1)^-1  (I - 𝐆̂𝐊_1)^-1𝐆̂; 𝐊_1(I - 𝐆̂𝐊_1)^-1    (I - 𝐊_1𝐆̂)^-1 ]∈ℛℋ_∞,

    where 𝐆̂ = (I - 𝐆𝐊_0)^-1𝐆 and 𝐊 = 𝐊_1 + 𝐊_0 with 𝐊_0 ∈𝒞_stab∩ℛℋ_∞. Now, we verify that
     
    (I - 𝐆(𝐊_0 + 𝐊_1))^-1   =(I - 𝐆̂𝐊_1)^-1(I - 𝐆𝐊_0)^-1∈ℛℋ_∞
    
                  (I - 𝐆(𝐊_0 + 𝐊_1))^-1𝐆   =(I - 𝐆̂𝐊_1)^-1𝐆̂∈ℛℋ_∞

    and that
    
    (𝐊_0 +𝐊_1)(I - 𝐆𝐊)^-1
    
                  =   𝐊_0 (I - 𝐆𝐊)^-1 + 𝐊_1(I - 𝐆𝐊)^-1∈ℛℋ_∞.

    Finally, we show
    
    (I - (𝐊_0 + 𝐊_1)𝐆)^-1 = (I - 𝐊_1𝐆̂)^-1(I - 𝐊_0𝐆)^-1∈ℛℋ_∞.

    By Theorem <ref>, we have proved 𝐊 = 𝐊_0 + 𝐊_1 ∈𝒞_stab.

    ⇒: This direction is similar: ∀𝐊∈𝒞_stab, we prove that 𝐊_1 = 𝐊 - 𝐊_0 internally stabilizes 𝐆̂. 
    For example
    
    (I - 𝐆̂𝐊_1)^-1   = (I - 𝐆𝐊)^-1 (I + 𝐆𝐊_0) 
       = (I - 𝐆𝐊)^-1 + (I - 𝐆𝐊)^-1𝐆𝐊_0 ∈ℛℋ_∞,

     and other conditions can be proved similarly. We complete the proof.










1.1
IEEEtran        





