Robust LMI Parser: A Toolbox to Construct LMI Conditions for

Uncertain Systems

Cristiano M. Agulhari, Ricardo C. L. F. Oliveira and Pedro L. D. Peres

December 26, 2012

Abstract
A toolbox to construct linear matrix inequality (LMI) conditions from parameter-dependent LMI
conditions, named Robust LMI Parser, is proposed. The toolbox is developed for Matlab and works
jointly with YALMIP, returning the entire set of LMIs through simple commands that describe the
structure of the matrices involved and the robust LMI conditions to be programmed. As an illustration,
an example of H guaranteed cost computation for an uncertain linear system is presented.

1 Introduction
In the last decades, problems formulated in terms of Linear Matrix Inequality (LMI) conditions and solved
by Semidefinite Programming (SPD) techniques became more and more common in several fields related to
engineering and applied mathematics. Specifically in control theory, the growing usage of such important
tools have led to important results on the analysis of systems stability, synthesis of stabilizing robust
controllers for uncertain systems and synthesis of optimal control models, just to name a few [1].
Accompanying the growth of the usage of LMI conditions, a large number of solvers based on interior
point methods were developed, as well as interfaces for parsing the LMIs, most of them free and easily
accessible. Thanks to such remarkable advance in the computational tools to define, manipulate and solve
LMIs, in many cases one can say that if a problem can be cast as a set of LMIs, then it can be considered as
solved [1]. Unfortunately, this is not completely true for large scale systems, since LMI solvers are limited
to a few thousands of variables and LMI rows, but progresses are being made.
Usually, LMIs are solved in two steps: first, an interface for parsing the conditions is used, for example
the YALMIP parser [2] or the LMI Control Toolbox from Matlab [3]; a LMI solver is then applied to find
a solution (if any), for example SeDuMi [4] or SDPT3 [5]. Some auxiliary toolboxes may also be used in
addition to the parser and the solver, for example the SOSTOOLS [6], which is used to transform a sum of
squares problem into a SDP formulation, and the GLOPTIPOLY [7], used to handle optimization problems
over polynomials.
Consider, for instance, the problem of analyzing the stability of a discrete-time linear system given by

x(k + 1) = Ax(k), (1)

with x(k) Rn being the state vector of the system and A Rnn being the dynamic matrix. Using the
Lyapunov stability theory, such system is stable if and only if there exists a symmetric matrix P Rnn
such that the LMI  
P A P
>0 (2)
PA P
holds. Such LMI can be easily programmed and solved using, respectively, any LMI parser and solver
available.
Consider now that system (1) is affected by uncertainties, i.e., the system matrix is parameter-dependent
and is given by A(). The robust stability analysis of such system can be realized by rewriting the LMI
condition (2) as  
P () A() P ()
>0 (3)
P ()A() P ()

School of Electrical and Computer Engineering, University of Campinas UNICAMP, 13083-852, Campinas, SP, Brazil.
(e-mails: {agulhari,ricfow,peres}@dt.fee.unicamp.br)

1
but, in this case, (3) must hold for all admissible . In order to transform the parameter-dependent LMI
into a finite set of standard LMIs, some information about A() must be added, as well as some structure
must be imposed to the unknown variable P (). For instance, consider that A() and P () have a polytopic
structure
X N N
X
A() = i Ai , P () = i Pi , N , (4)
i=1 i=1
being Ai and Pi the vertices of the respective polytopes, N the number of vertices and N the set known
as unit simplex, given by
N
X
N

N = R : i = 1 , i 0 , i = 1, . . . , N . (5)
i=1

Applying the definition of A() and the chosen structure for P (), given by (4), to the robust stability
condition expressed in the parameter-dependent LMI (3), one gets the following homogeneous polynomial
matrix inequality, of degree 2 on ,
  XN  
P () A() P () 2 Pi Ai Pi
= i +
P ()A() P () Pi Ai Pi
i=1
(6)
N 1 N  
X X Pi + Pj Ai Pj + Aj Pi
+ i j > 0.
Pi Aj + Pj Ai Pi + Pj
i=1 j=i+1

A sufficient (but not necessary) way to guarantee that (3) holds is to impose that all the matrix coefficients
of the monomials are positive definite. This has been done, for instance, in [8] (discrete-time systems) and [9]
(continuous-time systems). A less conservative set of conditions may be obtained by modeling the variable
P () in (6) as a homogeneous polynomial with generic degree g > 1 and then imposing the positivity of
all matrix coefficients [10, 11]. Programming these LMIs requires an a priori knowledge on the formation
law of the monomials, which depends on the number N of uncertain parameters and on the degree of the
polynomial variable P (). In [12], a systematic way to deal with such cases has been developed, but in
the context of robust LMIs presenting at most products between two parameter-dependent matrices. When
the LMIs to be solved are more complex and have products involving three or more parameter-dependent
matrices, the rules to compose the monomials become more complicated. Moreover, each new case demands
the manipulation of different polynomials. Such task, as well as programming the resulting LMIs, is tedious,
time-demanding and can be a source of programming errors.
The toolbox presented in this paper, called Robust LMI Parser1 , intends to overcome these problems
by automatically computing all the coefficients of the monomials of a given parameter-dependent LMI. The
toolbox is developed for Matlab and works jointly with YALMIP, returning the entire set of LMIs through
a few simple commands that describe the structure of the known matrices and variables involved in the
parameter-dependent LMIs to be investigated.
The paper is organized as follows. Section 2 presents the assumptions considered in the toolbox and
the notation used throughout the paper. The details on the syntaxes of the commands are presented in
Sections 3, 4, 5 and 6. An example is presented in Section 7 and Section 8 concludes the paper.

2 Preliminaries
The Robust LMI Parser currently considers the following assumptions:
The matrices are described as homogeneous polynomials on the uncertain parameters;
The vector of parameters belong to the unit simplex N , defined in (5);
All parameter-dependent matrices in a given condition have the same number of vertices.
Several examples illustrating the usage of the commands are presented throughout the paper. Such
commands are displayed using the Typewriter font and start with >>.
1
Available at http://www.dt.fee.unicamp.br/~ agulhari/softwares/robust_lmi_parser.zip

2
3 Defining the polynomial structure
The first step for using the Robust LMI Parser is to define all the variables and constants used in the LMIs
through the procedure poly struct, which has basically three possible syntaxes. If the coefficients of the
monomials are already defined, the related polynomial structure is obtained by

[poly] = poly struct(M,label,vertices,degree).

The output poly is a structured variable that fully describes the polynomial variable, whose fields are
given by:

poly.label: String with the label used to refer the polynomial in the procedure parser poly;

poly.data(n): Structure with the data corresponding to the n-th monomial. This structure has two
fields:

- poly.data(n).exponent: Values of the exponent of the monomial. For example, [0 2 1] indicates

that the current monomial is 01 22 13 ;
- poly.data(n).value: Value of the coefficient.

poly.vertices: Number of vertices considered in the current variable;

poly.opcode: Cell array that contains a representation of the operations performed to generate the
monomials. This field is used only to generate the Matlab executable files.

All the terms used in the LMIs must be defined through the poly struct procedure, even the scalars and
the precisely known matrices. Since the variables defined by poly struct are automatically stored by the
Robust LMI Parser, the output poly is not mandatory.
The variable M corresponds to the coefficients of the monomials of the homogeneous polynomial to be
defined. If the polynomial has a number r of monomials, all the r components must be given in M. For
example, consider that matrix A() has the following structure

A() = 1 A1 + 2 A2 , 1 + 2 = 1, 1 0, 2 0

i.e., A() is characterized by a polytope of N = 2 vertices and is modeled as a homogeneous polynomial of

degree g = 1. There are three ways of inputting the coefficients A1 and A2 through the variable M:

Concatenating the matrices A1 and A2 ;

>> M = [A1 A2];

Using M as a cell array;

>> M{1} = A1; M{2} = A2; (7)

Informing, on the cell array M, the exponent of the monomial to which each matrix is related.

>> M{1} = {[1 0],A1}; M{2} = {[0 1],A2}; (8)

Generically, the exponent of the monomial n1 1 n2 2 . . . nNN is encoded as [n1 n2 . . . nN ].

When the monomial is not informed, it is supposed that the elements are informed using a predefined order.
Such order can be obtained by the command

>> [exponents] = generate homogeneous exponents(vertices,degree);

The number r of monomials that must be provided in M depends on the number N of vertices and on the
degree g of the polynomial [12], being calculated by

(N + g 1)!
r= .
g!(N 1)!

3
Note that the number of vertices and the degree are also input parameters of the poly struct procedure.
If the variable to be defined is not parameter-dependent, the parameters vertices and degree may be
omitted.
The variable label is a string and consists of a name used to refer the variable when defining the
polynomial operations, described later. The string is case sensitive and must correspond to a valid variable
of Matlab.
NOTE: A constant matrix may be defined by setting vertices with the number of vertices of the
considered system and degree = 0. However, the structure will be more complex and may result on more
expensive computations.
NOTE: According to the assumptions made in Section 2 all the matrix variables must have the same
number of vertices. The only exception is for constant matrices, where the number of vertices may be set
to zero or does not need to be informed, as well as the degree.
If the coefficients of the monomials are variables of the problem, one may use the following syntax:

[poly,M] = poly struct(rows,cols,label,param,vertices,degree).

The matrix coefficients M with dimensions rows cols will be internally declared, being the output variable
M a cell array that contains the variables as coefficients. The argument param is a string that indicates if the
variable is symmetric (symmetric), rectangular (full), symmetric Toeplitz (toeplitz), symmetric
Hankel (hankel) or Skew-symmetric (skew). The matrices will be declared as symmetric if param is
not informed. Note that such command is similar to the SDPVAR instruction used to define the variables in
the YALMIP parser.
If the variable is a scalar one may use the syntax

[poly] = poly struct(M,label,scalar),

which returns the structure related to the scalar M with label given by label. If the scalar is a variable the
following syntax may be used

[poly,M] = poly struct(label,scalar),

which returns a scalar variable M.

NOTE: A scalar may also be defined as a 1 1 matrix, omitting the variables vertices and degree,
without using the parameter scalar. However, this approach may cause dimensional problems when the
Robust LMI Parser is used to generate a Matlab executable file, as presented in Section 6.

Example 1
A polynomial matrix A() with degree g = 1 that represents a system with N = 3 vertices is given by

A() = 1 A1 + 2 A2 + 3 A3 , 3

and can be defined using the following sequence of Matlab commands.

>> A = [A1 A2 A3];

>> poly A = poly struct(A,A,3,1);

Example 2
A polynomial matrix A() with degree g = 2 that represents a system with N = 2 vertices is given by

A() = 21 A20 + 1 2 A11 + 22 A02 , 2

and can be defined using the following sequence of Matlab commands.

>> A = [A20 A11 A02];

>> poly A = poly struct(A,A,2,2);
In this example, it could be important to know in which order the monomials A20, A11 and A02 must
be defined in the first line so the monomials correspond to the exact exponents in the structure poly A. The

4
order of the exponents considered in the construction of the polynomial structures can be obtained by the
procedure
[exponents] = generate homogeneous exponents(vertices,degree)
which generates all the possible monomial combinations for such polynomial.
An easier way to define A() in the example is by using the poly struct with the following syntax.

>> A{1} = {[2 0],A20}; A{2} = {[1 1],A11}; A{3} = {[0 2],A02};
>> poly A = poly struct(A,A,2,2);
In this case, the order for the definition of A{i} is irrelevant.

Example 3
A 3 3 identity matrix can be defined using

>> poly I = poly struct(eye(3),I);

Example 4
A symmetric polynomial variable P () R33 of degree 2, used in an uncertain system with N = 3 vertices,
can be defined by

>> [poly P,P] = poly struct(3,3,P,symmetric,3,2);

3.1 Multi-simplex structure

ROLMIP can also deal with variables in a multi-simplex domain, which is the cartesian product of a finite
number of different simplexes [13]. The multi-simplex structure can be considered, for example, when dealing
with time-varying parameters or when converting a variable dependent on multiple parameters in a simplex-
based representation; in the latter case, depending on the conversion applied, each parameter generates a
differente simplex. Consider, for example, two simplexes given by

= {1 , 2 } 2 , = {1 , 2 , 3 } 3 ,

i.e., is a simplex of 2 vertices and is a simplex of 3 vertices. A multi-simplex matrix M (, ) is any

matrix that is given in terms of the variables of both simplexes. Consider that M (, ) is given by

M (, ) = 21 1 M 1+21 2 M 2+21 3 M 3+1 2 1 M 4+1 2 2 M 5+1 2 3 M 6+22 1 M 7+22 2 M 8+22 3 M 9.

Using ROLMIP, the matrix M (, ) is defined by

>> M{1} = {[2 0],[1 0 0],M1};

>> M{2} = {[2 0],[0 1 0],M2};
>> M{3} = {[2 0],[0 0 1],M3};
>> M{4} = {[1 1],[1 0 0],M4};
>> M{5} = {[1 1],[0 1 0],M5};
>> M{6} = {[1 1],[0 0 1],M6};
>> M{7} = {[0 2],[1 0 0],M7};
>> M{8} = {[0 2],[0 1 0],M8};
>> M{9} = {[0 2],[0 0 1],M9};
>> poly = poly struct(M,M,[2 3],[2 1]);
Note that the variables vertices and degree are both vectors, whose dimensions are equal to the
number of simplexes considered. The order in defining each monomial M{i} is not important, and the
coefficients of the monomials that are not informed are considered to be zero matrices. In the multi-simplex
representation, the field exponent in the structure poly is a cell array whose i-th cell contais the exponent
of the i-th simplex.
The definition of variables in the multi-simplex domain is done in the same way as the definition of
variables in the simplex.

5
Example 5
The definition of a symmetric variable P (, ) Rnn , of degree 3 in 2 and of degree 1 in 3 , is
given by
>> poly = poly struct(n,n,P,symmetric,[2 3],[3 1]);

Example 6
Considering that 2 and 3 , the matrices H() = 1 H1 + 2 H2 and G() = 1 G1 + 2 G2 + 3 G3
are defined by

>> H{1} = {[1 0],[0],H1};

>> H{2} = {[0 1],[0],H2};
>> G{1} = {[0],[1 0 0],G1};
>> G{2} = {[0],[0 1 0],G2};
>> G{3} = {[0],[0 0 1],G3};
>> poly H = poly struct(H,H,[2 3],[1 0]);
>> poly G = poly struct(G,G,[2 3],[0 1]);
Note that it is important to define the number of vertices of every simplex even if a given matrix is
defined only in a subset of the simplexes.
Suppose that a matrix is affinely dependent on a set of parameters that are not necessarily in the unit
simplex, but their bounds are known a priori, as the matrix M () given by

M () = M 0 + M 11 + . . . + M qq , a1 1 b1, . . . , aq q bq.

The conversion of the matrix M (), affinely dependent on q parameters, to a multi-simplex representation
M (1 , . . . , q ), is performed automatically by ROLMIP when using the function affine2poly, whose syntax
is given by
>> [poly] = affine2poly(M,label,bounds).
The input M can be defined by two different syntaxes:

Concatenating the coefficient matrices:

>> M = [M0 M1 ...Mq];

Using M as a cell array:

>> M{1} = M0; M{2} = M1; ...; M{q+1} = Mq; (9)

The input label corresponds to the label of the polynomial matrix, and bounds is a q 2 matrix
containing the bounds of the q parameters, generically given by

>> bounds = [a1 b1; a2 b2; ...; aq bq];

The output of the function affine2poly is the same polynomial obtained when using the poly struct
function.

4 Operating on polynomials
The basic mathematical operations (sum, subtraction and multiplication), as well as the transpose operation,
can be performed in polynomial variables by using the procedure parser poly, whose syntax is

[poly res] = parser poly(expr,newlabel)

The variable expr is a string that describes the operation to be performed in the polynomials. The names
of the variables used in expr must be equal to the labels given to the polynomials in their definition. The
label of the resulting polynomial will be equal to newlabel if such parameter is informed, otherwise the
label will be equal to expr.

6
Example 7
Consider the polynomial matrices A() = 1 A1 + 2 A2 ; B() = 1 B1 + 2 B2 ; C() = 1 C1 + 2 C2 .
The polynomial R() = A()C() + B()C() can be calculated by performing the following sequence of
Matlab commands

>> A = [A1 A2];

>> B = [B1 B2];
>> C = [C1 C2];
>> poly struct(A,A,2,1);
>> poly struct(B,B,2,1);
>> poly struct(C,C,2,1);
>> poly R = parser poly(-A*C + B*C);
In this example, since A()C()+ B()C() = (A()+ B())C(), the procedure parser poly may
also be used as

>> poly R = parser poly((-A+B)*C);

Example 8
Consider the variables A() = 1 A1 + 2 A2 ; B() = 1 B1 + 2 B2 ; C() = 1 C1 + 2 C2 . The polynomial
R() = A()B() + C() can be calculated by performing the following sequence of Matlab commands.

>> poly struct(A,A,2,1);

>> poly struct(B,B,2,1);
>> poly struct(C,C,2,1);
>> poly R = parser poly(A*B + C);
Mathematically, such operation results on

A()B() + C() = 21 (A1 B1 ) + 1 2 (A1 B2 + A2 B1 ) + 22 (A2 B2 ) + 1 C1 + 2 C2 .

Note that the polynomial A()B() has degree g = 2 and C() has degree g = 1. According to the assump-
tions on Section 2, all the polynomials are considered to be homogeneous and the uncertain parameters are
considered to be in the unit simplex. In order to return a homogeneous polynomial the following operation
is automatically performed by the procedure parser poly on matrix C()

C() = (1 + 2 )C() = 21 C1 + 1 2 (C1 + C2 ) + 22 C2 .

The resulting homogeneous polynomial R() is then given by

R() = 21 (A1 B1 + C1 ) + 1 2 (A1 B2 + A2 B1 + C1 + C2 ) + 22 (A2 B2 + C2 ).

Example 9
The homogenization procedure is also automatically performed in the multi-simplex representation. For
example, consider the simplexes 2 and 2 , and the variables H() = 1 H1 + 2 H2 and
G() = 1 G1 + 2 G2. The polynomial R(, ) = H() + G() can be calculated by performing the following
sequence of Matlab commands.

>> poly struct(H,H,[2 2],[1 0]);

>> poly struct(G,G,[2 2],[0 1]);
>> poly R = parser poly(H + G);
Mathematically, such operation results on

H() + G() = (1 + 2 )(1 H1 + 2 H2) + (1 + 2 )(1 G1 + 2 G2) =

= 1 1 (H1 + G1) + 1 2 (H1 + G2) + 2 1 (H2 + G1) + 2 2 (H2 + G2).

7
Example 10
Consider the variables

A() = 1 A1 + 2 A2 ; B() = 1 B1 + 2 B2 , 2

The polynomial R() = B() A() can be calculated by performing the following sequence of Matlab
commands.

>> poly struct(A,A,2,1);

>> poly struct(B,B,2,1);
>> poly R = parser poly(B*A);
Since B() A() = (A()B()) , the procedure parser poly may also be used as

>> poly R = parser poly((A*B));

5 Composing matrices and LMIs

Consider again the parameter-dependent LMI (3). Each entry (i.e. block) of such matrix can be calculated
by using the procedure parser poly, as presented in Section 4. In order to construct a matrix of polynomials,
as well as the set of LMIs generated by a parameter-dependent condition as the one given by (3), one can
use the procedure named construct lmi, whose syntax is

[poly matr] = construct lmi(Term,param)

The variable Term is a cell array, in which Term{i,j} corresponds to the element (i, j) of the matrix
to be defined. If the matrix to be defined is square and symmetric, which is the case when working with
LMIs, it suffices to inform only the higher (or lower) triangular elements. The input param is a string
either containing an inequality symbol (>, <, >=, <=), meaning that the desired result is a set of
LMIs (defined using the command set from YALMIP [2]), or representing the label of the new polynomial
variable. The procedure construct lmi also applies a homogenization operation, assuring that all the
elements in the matrix are homogeneous polynomials with the same degree.
NOTE: If a LMI is to be defined, then the matrix represented by the variable Term must be symmetric
and, therefore, square. If the matrix is rectangular and the variable param is an inequality symbol an error
will occur.

Example 11
The LMI presented in (3), considering a system with N = 2 vertices and polynomial variables with degree
g = 1, can be implemented through the following sequence of Matlab commands

>> poly struct(A,A,2,1);

>> poly struct(P,P,2,1);
>> Term{1,1} = parser poly(P);
>> Term{1,2} = parser poly(A*P);
>> Term{2,2} = parser poly(P);
>> LMIs = construct lmi(Term,>);

Example 12
Multiplying inequality (3) on the left by  
I A()
and on the right by its transpose yields

P () A() P ()A() > 0, (10)

which is, along with the inequality P () > 0, an equivalent stability condition. The above multiplication
can be performed by the following sequence of Matlab commands

8
 >> poly struct(A,A,2,1);
>> poly P = poly struct(P,P,2,1);
>> Term{1,1} = parser poly(P);
>> Term{1,2} = parser poly(A*P);
>> Term{2,2} = parser poly(P);
>> construct lmi(Term,M);
>> T{1,1} = poly struct(eye(2),I);
>> T{1,2} = parser poly(-A);
>> construct lmi(T,T);
>> parser poly(T*M*T,R);
>> LMIs = construct lmi(parser poly(R),>);
>> LMIs = LMIs + construct lmi(poly P,>);
When working with auxiliar variables as in the last example, it is recommended to avoid giving the same
name to different variables.

6 Creating a Matlab executable file

Although the Robust LMI Parser toolbox is a very practical package and allows the programming of complex
parameter-dependent LMIs without spending much effort, it is true that the computational time required
for the toolbox to compose the LMIs is considerably higher than setting the LMIs monomial by monomial.
To circumvent this drawback it is possible to use the Robust LMI Parser to create a Matlab executable file
that solves the same set of LMIs without consuming much time. To do so it is necessary to use the command
lmifiles to open the file, to insert the LMIs and to close the file.
The syntax used for opening the file is
fid = lmifiles(open,filename).
The first argument may be replaced by o. The parameter filename is both the name of the file and the
name of the main function, being declared without the extension .m. The file identifier fid associated is
returned. The file must be opened at least before the definition of the first LMI, but it is recommended to
open the file before the definition of the first variable.
The insertion of the informations on the problem to be solved are done by using the lmifiles procedure
in either of the following syntaxes.
To insert an LMI:
lmifiles(insert,fid,Term,ineq).
The first argument may be replaced by i. The parameter fid is the file identifier returned when
opening the file. The structure Term is the cell array that defines the LMI, in which Term{i,j}
corresponds to the element (i, j) of the matrix, and ineq is the signal of the inequality.
To define the objective function:
lmifiles(insert,fid,obj min).
The parameter obj min is the label of the variable to be minimized.
To define the settings of the optimization procedure:
lmifiles(insert,fid,sdpsettings,name1,value1,name2,value2,...).
The argument sdpsettings is used to specify that the following arguments will be the names and
values of the properties of the solver options to be changed. The options names and values are the
ones used in the command solvesdp of the YALMIP toolbox [2].
After inserting all the informations of the problem, the file needs to be closed by using the command
lmifiles(close,fid).
The first argument may be replaced by c. The new Matlab executable file is stored at the same directory
of the program used to create it. The input parameters of the main function are the system matrices and
other user-defined variables, and the output is a structure whose fields contain the values of the resulting
variables, if the LMI could be solved.

9
Example 13
The creation of a Matlab executable file to solve the LMI presented in (3), considering a system with N = 2
vertices and polynomial variables with degree g = 1, can be done through the following sequence of Matlab
commands

>> fid = lmifiles(o,discr stab);

>> poly struct(A,A,2,1);
>> poly struct(P,P,2,1);
>> Term{1,1} = parser poly(P);
>> Term{1,2} = parser poly(A*P);
>> Term{2,2} = parser poly(P);
>> lmifiles(i,fid,Term,>);
>> lmifiles(c,fid);
The resulting function can then be called through the command

>> Output = discr stab(A);

An example with the definition of the objective function and the optimization options is given in the
next section.

7 Guaranteed H Cost Computation

Consider the continuous-time uncertain time-invariant system given by


x(t) = A()x(t) + B()w(t)
(11)
y(t) = C()x(t) + D()w(t)

with A() Rnn , B() Rnr , C() Rqn and D() Rqr . The transfer function from the
disturbance input w to the output y, for a fixed , is given by

1
H(s, ) = C() sI A() B() + D()

The bounded real lemma assures the Hurwitz stability of A() (i.e. all eigenvalues have negative real part)
for all N and a bound to the H norm of the transfer function from w to y. It can be formulated
as follows [1].

Lemma 1
Matrix A() is Hurwitz and kH(s, )k < for all N if there exists a positive definite symmetric
matrix P () = P () > 0 such that
 
A() P () + P ()A() + C() C()
< 0, N (12)
B() P () + D() C() D() D() 2 I

The implementation of LMI relaxations that search for a feasible solution while minimizing = 2 is
given below. The system matrices are supposed to be defined as cell arrays, as shown in (7).

10
 function gama = calculate hinf(A,B,C,D,degP)

n = length(A{1});
r = size(B{1},2);
q = size(C{1},1);
vert = length(A);
poly struct(A,A,vert,1);
poly struct(B,B,vert,1);
poly struct(C,C,vert,1);
poly struct(D,D,vert,1);
poly struct(n,n,P,vert,degP);
poly struct(eye(r),Ir);
[polymu,mu] = poly struct(mu,scalar);
LMIs = construct lmi(parser poly(P),>);
Term{1,1} = parser poly(A*P+P*A+C*C);
Term{2,1} = parser poly(B*P+D*C);
Term{2,2} = parser poly(D*D - mu*Ir);
LMIs = LMIs + construct lmi(Term,<);
solvesdp(LMIs,mu,sdpsettings(solver,sedumi));
gama = sqrt(double(mu));
return

The following implementation solves the same problem, but creating also a Matlab executable file.

function calculate hinf exe file(A,B,C,D,degP)

n = length(A{1});
r = size(B{1},2);
q = size(C{1},1);
vert = length(A);
fid = lmifiles(o,exe calculate hinf);
poly struct(A,A,vert,1);
poly struct(B,B,vert,1);
poly struct(C,C,vert,1);
poly struct(D,D,vert,1);
poly struct(n,n,P,vert,degP);
poly struct(eye(r),Ir);
[polymu,mu] = poly struct(mu,scalar);
Term{1,1} = parser poly(P);
lmifiles(i,fid,Term,>);
Term{1,1} = parser poly(A*P+P*A+C*C);
Term{2,1} = parser poly(B*P+D*C);
Term{2,2} = parser poly(D*D - mu*Ir);
lmifiles(i,fid,Term,<);
lmifiles(i,fid,mu);
lmifiles(i,fid,sdpsettings,solver,sedumi);
lmifiles(c,fid);
return

The resulting function can then be called through the command

>> Output = exe calculate hinf(A,B,C,D)

The optimized variable mu can be accessed by output.mu if the problem was a feasible one, i.e., if
output.feas == 1.

11
 As illustrated, the implementation of LMI conditions using the Robust LMI Parser is simple and straight-
forward. Moreover, the different sets of LMIs for larger degrees of the homogeneous polynomial variable
P () can be readily obtained by simply changing degP. Those LMIs, that would demand complex and
tedious manipulations without using the parser, provide clear improvements in the computation of the H
guaranteed cost. Table 1 shows the values of = min subject to (12) obtained when the degree of the
variable P () increases. The example considered is a fourth-order mass-spring system, also investigated in
[14]. With g = 5, reaches the worst case value of the H norm (computed through brute force).

Table 1: Values of = min obtained when varying the degree of the polynomial variable P ().

degP
0 2.299
1 1.056
2 1.012
3 1.003
4 1.001
5 1.000

8 Conclusion
A computational package, named Robust LMI Parser, is presented in this paper. The main objective of
the toolbox is to facilitate the task of programming LMIs that are sufficient conditions for robust LMIs,
i.e. for parameter-dependent LMI conditions whose entries are algebraic manipulations of homogeneous
polynomials of generic degree with parameters in the unit simplex. The toolbox is under constant evolution
and some new features are to be implemented, such as code optimizations and the capacity of handling
uncertain parameters in the multi-simplex domain.

References
[1] S. Boyd, L. El Ghaoui, E. Feron, and V. Balakrishnan, Linear Matrix Inequalities in System and Control
Theory. Philadelphia, PA: SIAM Studies in Applied Mathematics, 1994.

[2] J. L
ofberg, YALMIP: A toolbox for modeling and optimization in MATLAB, in Proceedings of the
2004 IEEE International Symposium on Computer Aided Control Systems Design, Taipei, Taiwan,
September 2004, pp. 284289, http://control.ee.ethz.ch/ joloef/yalmip.php.

[3] P. Gahinet, A. Nemirovskii, A. J. Laub, and M. Chilali, LMI Control Toolbox Users Guide. Natick,
MA: The Math Works, 1995.

[4] J. F. Sturm, Using SeDuMi 1.02, a MATLAB toolbox for optimization over symmetric cones, Opti-
mization Methods and Software, vol. 11, no. 14, pp. 625653, 1999, http://sedumi.mcmaster.ca/.

[5] K. C. Toh, M. J. Todd, and R. T utunc

u, SDPT3 A Matlab software package for semidefinite
programming, Version 1.3, Optimization Methods and Software, vol. 11, no. 1, pp. 545581, 1999.

[6] S. Prajna, A. Papachristodoulou, P. Seiler, and P. A. Parrilo, SOSTOOLS: Sum of squares optimization
toolbox for MATLAB, Available from http://www.cds.caltech.edu/sostools and http://www.mit.edu/
parrilo/sostools, 2004.

[7] D. Henrion and J. B. Lasserre, GloptiPoly: global optimization over polynomials with Matlab and
SeDuMi, ACM Transactions on Mathematical Software, vol. 29, no. 2, pp. 165194, June 2003.

[8] D. C. W. Ramos and P. L. D. Peres, A less conservative LMI condition for the robust stability of
discrete-time uncertain systems, Systems & Control Letters, vol. 43, no. 5, pp. 371378, August 2001.

12
 [9] , An LMI condition for the robust stability of uncertain continuous-time linear systems, IEEE
Transactions on Automatic Control, vol. 47, no. 4, pp. 675678, April 2002.

[10] R. C. L. F. Oliveira and P. L. D. Peres, LMI conditions for robust stability analysis based on polyno-
mially parameter-dependent Lyapunov functions, Systems & Control Letters, vol. 55, no. 1, pp. 5261,
January 2006.

[11] P.-A. Bliman, R. C. L. F. Oliveira, V. F. Montagner, and P. L. D. Peres, Existence of homogeneous

polynomial solutions for parameter-dependent linear matrix inequalities with parameters in the sim-
plex, in Proceedings of the 45th IEEE Conference on Decision and Control, San Diego, CA, USA,
December 2006, pp. 14861491.

[12] R. C. L. F. Oliveira and P. L. D. Peres, Parameter-dependent LMIs in robust analysis: Characterization

of homogeneous polynomially parameter-dependent solutions via LMI relaxations, IEEE Transactions
on Automatic Control, vol. 52, no. 7, pp. 13341340, July 2007.

[13] R. C. L. F. Oliveira, P.-A. Bliman, and P. L. D. Peres, Robust LMIs with parameters in multi-simplex:
Existence of solutions and applications, in Proceedings of the 47th IEEE Conference on Decision and
Control, Cancun, Mexico, December 2008, pp. 22262231.

[14] R. C. L. F. Oliveira and P. L. D. Peres, A convex optimization procedure to compute H2 and H

norms for uncertain linear systems in polytopic domains, Optimal Control Applications and Methods,
vol. 29, no. 4, pp. 295312, July/August 2008.

13