## Decomposing Uncertain Objects

Each uncertain object (`umat`, `uss`, `ufrd`) 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`, `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`, `ucomplex` and `ucomplexm` do not have their `NominalValue` necessarily at zero, and in the case of `ureal` objects, are not 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.

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.

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.

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).$`

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}$`

In each case, 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.

### Properties of the Decomposition

Take an uncertain object A, dependent on uncertain real parameters ρ1,...,ρN, uncertain complex parameters ξ1,...,ξK, uncertain complex matrices H1,...,HB, uncertain gain-bounded linear, time-invariant dynamics E1,...,ED, and uncertain positive-real linear, time-invariant dynamics P1,...,PQ.

Write A(ρ,ξ,H,E,P) to indicate this dependence. Using `lftdata`, A can be decomposed into two separate pieces: M and Δ(ρ,ξ,H,E,P) 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\right)=\left[\begin{array}{ccccc}F\left(\rho \right)& 0& 0& 0& 0\\ 0& F\left(\xi \right)& 0& 0& 0\\ 0& 0& F\left(H\right)& 0& 0\\ 0& 0& 0& F\left(E\right)& 0\\ 0& 0& 0& 0& F\left(P\right)\end{array}\right].$`
• A(ρ,ξ,H,E,P) is given by a linear fractional transformation of M and Δ(ρ,ξ,H,E,P),

`$A\left(\rho ,\xi \right)={M}_{22}+{M}_{21}\Delta \left(\rho ,\xi ,H,E,P\right){\left[I-{M}_{11}\Delta \left(\rho ,\xi ,H,E,P\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)`. See Advanced Syntax of lftdata for more information.

### 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-18 × 0 0.3955 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)`. Note that the range/bound information about each uncertain element is not included in `BlkStruct`.

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 = Name: 'delta' Size: [1 1] Type: 'ureal' Occurrences: 2 BlkStruct(2) ans = Name: 'eta' Size: [1 1] Type: 'ureal' Occurrences: 3 BlkStruct(3) ans = Name: 'rho' Size: [1 1] Type: 'ureal' Occurrences: 1 ```

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

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

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

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

The 4th output argument 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 = 6 1 NormUnc{1} Uncertain Real Parameter: Name deltaNormalized, NominalValue 0, variability = [-1 1] isequal(NormUnc{2},NormUnc{1}) ans = 1 NormUnc{3} Uncertain Real Parameter: Name etaNormalized, NominalValue 0, variability = [-1 1] isequal(NormUnc{4},NormUnc{3}) ans = 1 isequal(NormUnc{5},NormUnc{3}) ans = 1 NormUnc{6} Uncertain Real Parameter: Name rhoNormalized, NominalValue 0, variability = [-1 1] ```

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

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 power-user has direct access to all of the linear fractional transformation details, and can easily work at the level of the theorems and algorithms that underlie the methods. 