The *robust H_{∞} performance*
quantifies how modeled uncertainty affects the performance of a feedback loop. Performance
here is measured with the

For a system *T*(*s*), the robust
*H*_{∞} performance *μ* is the
smallest value *γ* such that the peak gain of *T* remains
below *γ* for uncertainty up to 1/*γ*, in normalized units.
For example:

*μ*= 0.5 means that ||*T*(*s*)||_{∞}remains below 0.5 for uncertainty up to twice the uncertainty specified in*T*. The worst-case gain for the specified uncertainty is typically smaller.*μ*= 2 means that ||*T*(*s*)||_{∞}remains below 2 for uncertainty up to half the uncertainty specified in*T*. For this value, the worst-case gain for the full specified uncertainty can be much larger. It can even be infinite, meaning that the system does not remain stable over the full range of the specified uncertainty.

The quantity *μ* is the peak value over frequency of the
*structured singular value*
*μ*(*ω*) for the uncertainty specified in
*T*. This quantity is a generalization of the singular value for uncertain
systems. It depends on the structure of the uncertainty in the system. In practice,
*μ* is difficult to compute exactly, so the software instead computes lower
and upper bounds, $$\underset{\xaf}{\mu}$$ and $$\overline{\mu}$$. The upper bound $$\overline{\mu}$$ has several applications in control system design and analysis. You
can:

Use

`musyn`

to design a controller for an uncertain plant that minimizes $$\overline{\mu}$$ of the closed-loop system. In addition to the resulting controller,`musyn`

returns the corresponding value of $$\overline{\mu}$$ in the`CLperf`

output argument.Use

`musynperf`

evaluate the robust performance of an uncertain system. This function returns lower and upper bounds on*μ*, the uncertainty values that yield the peak*μ*, and other information about the closed-loop robust performance.

To understand the computation of robust *H*_{∞}
performance, consider an uncertain system *T*(*s*),
modeled as a fixed portion *T*_{0} and an uncertain
portion Δ_{unc}/*γ*.

Δ_{unc} collects the uncertain elements
{Δ_{1},…,Δ_{N}}.

$${\Delta}_{unc}=\left(\begin{array}{ccc}{\Delta}_{1}& & \\ & \ddots & \\ & & {\Delta}_{N}\end{array}\right).$$

Each Δ_{j} is an arbitrary real, complex, or
dynamic uncertainty that is normalized such that ||Δ_{j}||_{∞} ≤
1. The factor *γ* adjusts the level of uncertainty.

Suppose that for the system modeled as in diagram (a),

||*T*||_{∞} ≤ *γ* for all
||Δ_{unc}||_{∞} ≤
1.

By the small-gain theorem (see [1]), this robust performance
condition is equivalent to stating that the system of diagram (b), LFT(Δ_{perf}/*γ*,*T*), is stable for all for all ||Δ_{perf}||_{∞} ≤
1.

Δ_{perf} is called the *performance
block*. Expand *T* as in diagram (a), and group
Δ_{perf} with the uncertain blocks
Δ_{unc} to define a new block Δ,

$$\Delta \triangleq \left(\begin{array}{cc}{\Delta}_{perf}& 0\\ 0& {\Delta}_{unc}\end{array}\right).$$

The result is the system in the following diagram.

Thus, the robust performance condition on the system of diagram (a) is equivalent to a stability condition on diagram (c), or

$${\Vert T\Vert}_{\infty}\le \gamma \text{\hspace{0.17em}}\text{forall}\text{\hspace{0.17em}}{\Vert {\Delta}_{unc}\Vert}_{\infty}\le 1\text{\hspace{1em}}\iff \text{\hspace{1em}}{\Vert LFT\left(\Delta /\gamma \right),{T}_{0}\Vert}_{\infty}\text{\hspace{0.17em}}\text{stableforall}\text{\hspace{0.17em}}{\Vert \Delta \Vert}_{\infty}\le \text{\hspace{0.17em}}1.$$

The robust performance *μ* is the smallest *γ* for
which this stability condition holds. Equivalently, 1/*μ* is the largest
uncertainty level 1/*γ* for which the system of diagram (c) is robustly
stable. In other words, 1/*μ* is the robust stability margin of the
feedback loop of diagram (c) for the augmented uncertainty Δ. (For more information on
robust stability margins, see Robustness and Worst-Case Analysis.)

To obtain an estimate on the upper bound of *μ*, the software
introduces *scalings*. If the system in diagram (c) is stable for all ||Δ||_{∞} ≤ 1, then the system of the following diagram is also stable, for any
invertible *D*.

If *D* commutes with Δ, then the system of diagram (d) is the same as
the system in the following diagram.

The matrices *D* that structurally commute with Δ are called
*D* scalings. They can be frequency dependent, which is denoted by
*D*(*ω*).

Define $$\overline{\mu}$$ as:

$$\overline{\mu}\triangleq \underset{D\left(\omega \right)}{\mathrm{inf}}{\Vert D\left(\omega \right){T}_{0}\left(j\omega \right)D{\left(\omega \right)}^{-1}\Vert}_{\infty}.$$

For the optimal *D**(*ω*), and any
*γ* ≥ $$\overline{\mu}$$,

$${\Vert {D}^{*}\left(\omega \right){T}_{0}\left(j\omega \right){D}^{*}{\left(\omega \right)}^{-1}\Vert}_{\infty}\le \text{\hspace{0.17em}}\text{\hspace{0.17em}}\gamma .$$

Therefore, by the small-gain theorem, the system of diagram (e) is stable for all ||Δ||_{∞} ≤ 1. It follows that 1/*γ* ≤ 1/*μ*, or *γ* ≤ *μ*, because 1/*μ* is the robust stability margin.
Consequently, *μ* ≤ $$\overline{\mu}$$, so that $$\overline{\mu}$$ is an upper bound for the robust performance *μ*. This
upper bound $$\overline{\mu}$$ is the quantity computed by `musynperf`

and optimized
by `musyn`

.

When all the uncertain elements Δ_{j} are complex or LTI dynamics,
the software approximates $$\overline{\mu}$$ by picking a frequency grid {*ω*_{1},…,*ω _{N}*}. At each frequency point, the software solves the optimal scaling
problem

$${\overline{\mu}}_{i}=\underset{{D}_{i}}{\mathrm{inf}}\Vert {D}_{i}{T}_{0}\left(j{\omega}_{i}\right){D}_{i}{}^{-1}\Vert .$$

It then sets $$\overline{\mu}$$ to the largest result over all frequencies in the grid,

$$\overline{\mu}=\underset{i}{\mathrm{max}}{\overline{\mu}}_{i}.$$

When some Δ_{j} are real, it is possible to obtain a less
conservative upper bound by using additional scalings called *G* scalings.
In this case, $$\overline{\mu}$$ is the smallest $${\overline{\mu}}_{i}$$ over frequency such that

$${\left(\begin{array}{c}{T}_{0}\left(j{\omega}_{i}\right)\\ I\end{array}\right)}^{H}\left(\begin{array}{cc}{D}_{r}\left({\omega}_{i}\right)& -j{G}_{cr}^{H}\left({\omega}_{i}\right)\\ j{G}_{cr}\left({\omega}_{i}\right)& -{\overline{\mu}}_{i}^{2}{D}_{c}\left({\omega}_{i}\right)\end{array}\right)\left(\begin{array}{c}{T}_{0}\left(j{\omega}_{i}\right)\\ I\end{array}\right)\le 0$$

for some
*D _{r}*(

The `musyn`

command synthesizes robust controllers using an iterative
process that optimizes the robust performance $$\overline{\mu}$$. To learn how to use `musyn`

, see Robust Controller Design Using Mu Synthesis. For details about the
`musyn`

algorithm, see D-K Iteration Process.

[1] Skogestad, S. and I.
Postlethwaite, *Multivariable Feedback Control: Analysis and Design*,
2d ed. West Sussex, England: John Wiley & Sons, 2005, pp. 156, 306.