## Decomposing Uncertain Objects

Each uncertain model or matrix (such as `uss`, `genss`, `ufrd`, or `umat`, ) is a generalized feedback connection (`lft`) of a not-uncertain object (e.g., `double`, `ss`, `frd`) with a diagonal augmentation of uncertain elements (`ureal`, `ultidyn`, `umargin`, `ucomplex`, `ucomplexm`, `udyn`). In robust control jargon, if the uncertain elements are normalized, this decomposition is often called “the M/D form.”

The purpose of the uncertain objects (`ureal`, `ultidyn`, `umat`, `uss`, etc.) is to hide this underlying decomposition, and allow the user to focus on modeling and analyzing uncertain systems, rather than the details of correctly propagating the M/D representation in manipulations. Nevertheless, advanced users may want access to the familiar M/D form. The command `lftdata` accomplishes this decomposition.

Since `ureal`, `umargin`, `ucomplex` and `ucomplexm` do not have their `NominalValue` necessarily at zero, and in the case of `ureal` and `umargin` objects, are not necessarily symmetric about the `NominalValue`, some details are required in describing the decomposition.

### Normalizing Functions for Uncertain Elements

Associated with each uncertain element is a normalizing function. The normalizing function maps the uncertain element into a normalized uncertain element. Regardless of element type, as the uncertain element varies over its range, the absolute value of the normalizing function (or norm, in the matrix case) varies from 0 and 1.

#### Uncertain Real Parameter (`ureal`)

If ρ is an uncertain real parameter, with range `[L R]` and nominal value `N`, then the normalizing function F is

`$F\left(\rho \right)=\frac{A+B\rho }{C+D\rho }$`

with the property that for all ρ satisfying L ≤ ρ ≤ R, it follows that –1 ≤ F(ρ) ≤ 1, moreover, F(L) = –1, F(N) = 0, and F(R) = 1. If the nominal value is centered in the range, then it is easy to conclude that

`$\begin{array}{l}A=\frac{R+L}{R-L}\\ B=\frac{2}{R-L}\\ C=1\\ D=0.\end{array}$`

It is left as an algebra exercise for the user to work out the various values for `A, B, C` and `D` when the nominal value is not centered.

#### Uncertain Linear Time-Invariant Dynamic Uncertainty (`ultidyn`)

If E is an uncertain gain-bounded, linear, time-invariant dynamic uncertainty, with gain-bound β, then the normalizing function F is

`$F\left(E\right)=\frac{1}{\beta }E.$`

If E is an uncertain positive-real, linear, time-invariant dynamic uncertainty, with positivity bound β, then the normalizing function F is

`$F\left(E\right)=\left[I-\alpha \left(E-\frac{\beta }{2}I\right)\right]{\left[I+\alpha \left(E-\frac{\beta }{2}I\right)\right]}^{-1}$`

where α = 2|β| + 1.

#### Uncertain Gain and Phase (`umargin`)

For a `umargin` block Q(s), the normalized value F(Q(s)) = δ(s), where δ(s) is a gain-bounded dynamic uncertainty, normalized so that it always varies within the unit disk (||δ|| < 1). In other words, F(Q) is a unit-gain `ultidyn` uncertain element.

The actual values of Q map to the unit-gain δ via the parameterization

`$Q\left(s\right)=\frac{1+\alpha \left[\left(1-E\right)/2\right]\delta \left(s\right)}{1-\alpha \left[\left(1+E\right)/2\right]\delta \left(s\right)}.$`

For details about this parameterization, see `umargin`.

#### Uncertain Complex Parameters (`ucomplex`)

The normalizing function for an uncertain complex parameter ξ, with nominal value C and radius γ, is

`$F\left(\xi \right)=\frac{1}{\gamma }\left(\xi -C\right).$`

#### Uncertain Complex Matrices (`umat`)

The normalizing function for uncertain complex matrices H, with nominal value N and weights WL and WR is

`$F\left(H\right)={W}_{L}^{-1}\left(H-N\right){W}_{R}^{-1}$`

### Properties of the Decomposition

Take an uncertain object A, dependent on:

• Uncertain real parameters ρ1,...,ρNρ

• Uncertain complex parameters ξ1,...,ξNξ

• Uncertain complex matrices H1,...,HNH

• Uncertain gain-bounded linear, time-invariant dynamics E1,...,ENE

• Uncertain positive-real linear, time-invariant dynamics P1,...,PNP

• Uncertain gain and phase Q1,…,QNQ

Write A(ρ,ξ,H,E,P,Q) to indicate this dependence. Using `lftdata`, A can be decomposed into two separate pieces: M and Δ(ρ,ξ,H,E,P,Q) with the following properties:

• M is certain (i.e., if A is `uss`, then M is `ss`; if A is `umat`, then M is `double`; if A is `ufrd`, then M is `frd`).

• Δ is always a `umat`, depending on the same uncertain elements as A, with ranges, bounds, weights, etc., unaltered.

• The form of Δ is block diagonal, with elements made up of the normalizing functions acting on the individual uncertain elements:

`$\Delta \left(\rho ,\xi ,H,E,P,Q\right)=\left[\begin{array}{cccccc}F\left(\rho \right)& 0& 0& 0& 0& 0\\ 0& F\left(\xi \right)& 0& 0& 0& 0\\ 0& 0& F\left(H\right)& 0& 0& 0\\ 0& 0& 0& F\left(E\right)& 0& 0\\ 0& 0& 0& 0& F\left(P\right)& \\ 0& 0& 0& 0& 0& F\left(Q\right)\end{array}\right].$`
• A(ρ,ξ,H,E,P,Q) is given by a linear fractional transformation of M and Δ(ρ,ξ,H,E,P,Q),

`$A\left(\rho ,\xi ,H,E,P,Q\right)={M}_{22}+{M}_{21}\Delta \left(\rho ,\xi ,H,E,P,Q\right){\left[I-{M}_{11}\Delta \left(\rho ,\xi ,H,E,P,Q\right)\right]}^{-1}{M}_{12}.$`

The order of the normalized elements making up `A` is not the simple order shown above. It is actually the same order as given by the command `fieldnames(M.Uncertainty)`, as shown in the following example.

### Decompose Uncertain Model Using lftdata

You decompose an uncertain model into a fixed certain part and normalized uncertain part using the `lftdata` command. To see how this command works, create a 2-by-2 uncertain matrix (`umat`) using three uncertain real parameters.

```delta = ureal('delta',2); eta = ureal('eta',6); rho = ureal('rho',-1); A = [3+delta+eta delta/eta;7+rho rho+delta*eta]```
```A = Uncertain matrix with 2 rows and 2 columns. The uncertainty consists of the following blocks: delta: Uncertain real, nominal = 2, variability = [-1,1], 2 occurrences eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences Type "A.NominalValue" to see the nominal value, "get(A)" to see all properties, and "A.Uncertainty" to interact with the uncertain elements. ```

The `umat` `A` depends on two occurrences of `delta`, three occurrences of `eta`, and one occurrence of `rho`.

Decompose `A` into `M` and `Delta`.

`[M,Delta] = lftdata(A);`

`M` is a numeric matrix.

`M`
```M = 8×8 0 0 0 -0.1667 0 0 1.0000 0.1667 0 0 0 0 1.0000 0 0 6.0000 0 0 0 0 0 0 1.0000 0 0 0 0 -0.1667 0 0 0 0.1667 0 0 0 0 0 0 0 1.0000 0 0 0 0 0 0 1.0000 1.0000 1.0000 0 1.0000 -0.3333 0 0 11.0000 0.3333 0 1.0000 0 0 2.0000 1.0000 6.0000 11.0000 ```

`Delta` is a `umat` with the same uncertainty dependence as `A`.

`Delta`
```Delta = Uncertain matrix with 6 rows and 6 columns. The uncertainty consists of the following blocks: delta: Uncertain real, nominal = 2, variability = [-1,1], 2 occurrences eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences Type "Delta.NominalValue" to see the nominal value, "get(Delta)" to see all properties, and "Delta.Uncertainty" to interact with the uncertain elements. ```

To examine some of the characteristics of `Delta`, sample it at three points. Note that:

• The sampled value of `Delta` is always diagonal.

• The sampled values always range between -1 and 1, because `Delta` is normalized.

• The sampled matrices each contain three independent values. Duplication of the entries is consistent with the dependence of `Delta` and `A` on the three uncertain real parameters.

`usample(Delta,3)`
```ans = ans(:,:,1) = 0.6294 0 0 0 0 0 0 0.6294 0 0 0 0 0 0 0.8268 0 0 0 0 0 0 0.8268 0 0 0 0 0 0 0.8268 0 0 0 0 0 0 -0.4430 ans(:,:,2) = 0.8116 0 0 0 0 0 0 0.8116 0 0 0 0 0 0 0.2647 0 0 0 0 0 0 0.2647 0 0 0 0 0 0 0.2647 0 0 0 0 0 0 0.0938 ans(:,:,3) = -0.7460 0 0 0 0 0 0 -0.7460 0 0 0 0 0 0 -0.8049 0 0 0 0 0 0 -0.8049 0 0 0 0 0 0 -0.8049 0 0 0 0 0 0 0.9150 ```

Verify that the maximum gain of `Delta` is 1.

`maxnorm = wcnorm(Delta)`
```maxnorm = struct with fields: LowerBound: 0 UpperBound: 1.0008 ```

Finally, verify that `lft(Delta,M)` is the same as `A`. To do so, take the difference, and use the `'full'` option in `simplify` to remove redundant dependencies on uncertain elements.

`simplify(lft(Delta,M)-A,'full')`
```ans = 2×2 10-17 × 0 -0.5156 0 0 ```

Even for the advanced user, the variable `Delta` will actually not be that useful, as it is still a complex object. On the other hand, its internal structure is described completely using a 3rd (and 4th) output argument.

`[M,Delta,BlkStruct,NormUnc] = lftdata(A); `

The rows of `BlkStruct` correspond to the uncertain elements named in `fieldnames(A.Uncertainty)`. The elements of `BlkStruct` describe the size, type and number-of-copies of the uncertain elements in `A`, and implicitly delineate the exact block-diagonal structure of `Delta`. Note that the range/bound information about each uncertain element is not included in BlkStruct.

`BlkStruct(1)`
```ans = struct with fields: Name: 'delta' Size: [1 1] Type: 'ureal' Occurrences: 2 Simplify: 2 ```
`BlkStruct(2) `
```ans = struct with fields: Name: 'eta' Size: [1 1] Type: 'ureal' Occurrences: 3 Simplify: 2 ```
`BlkStruct(3) `
```ans = struct with fields: Name: 'rho' Size: [1 1] Type: 'ureal' Occurrences: 1 Simplify: 2 ```

Together, these entries mean that `Delta` is a block diagonal augmentation of the normalized version of the three uncertain elements.

The first element is named `'delta'`. It is 1-by-1; it is of class `ureal`; and there are two copies diagonally augmented.

The second element is named `'eta'`. It is 1-by-1; it is of class `ureal`; and there are three copies diagonally augmented.

The third element is named `'rho'`. It is 1-by-1; it is of class `ureal`; and there is one copy,

The fourth output argument of `lftdata` contains a cell array of normalized uncertain elements. The cell array contains as many occurrences of each element as there are occurrences in the original uncertain object `A`.

`size(NormUnc) `
```ans = 1×2 6 1 ```
`NormUnc{1} `
```ans = Uncertain real parameter "deltaNormalized" with nominal value 0 and variability [-1,1]. ```
`isequal(NormUnc{2},NormUnc{1}) `
```ans = logical 1 ```
`NormUnc{3} `
```ans = Uncertain real parameter "etaNormalized" with nominal value 0 and variability [-1,1]. ```
`isequal(NormUnc{4},NormUnc{3}) `
```ans = logical 1 ```
`isequal(NormUnc{5},NormUnc{3}) `
```ans = logical 1 ```
`NormUnc{6} `
```ans = Uncertain real parameter "rhoNormalized" with nominal value 0 and variability [-1,1]. ```

Each normalized element has `'Normalized'` appended to its original name to avoid confusion. When normalized,

• `ureal` objects have nominal value of 0, and range from –1 to 1.

• `ultidyn` objects are norm bounded, with norm bound of 1.

• `umargin` objects are converted to norm-bounded `ultidyn` objects with norm bound of 1.

• `ucomplex` objects have nominal value of 0, and radius 1.

• `ucomplexm` objects have nominal value of 0, and identity matrices for each of the `WL` and `WR` weights.

The possible behaviors of `Delta` and `blkdiag(NormUnc{:})` are the same. Consequently, the possible behaviors of `A` and `lft(blkdiag(NormUnc{:}),M)` are the same.

Hence, by manipulating `M`, `BlkStruct` and `NormUnc`, a you can have direct access to all of the linear fractional transformation details, and can work at the level of the theorems and algorithms that underlie the methods. 