A topic in the Open Knowledge Graph — a free, open map of 15,290 topics and the order to learn them in.
Robust control designs controllers that maintain stability and acceptable performance despite uncertainty in the plant model — acknowledging that every model is an approximation and the true plant dynamics are never exactly known. Uncertainty is typically modeled as multiplicative uncertainty G_true(s) = G_nom(s)(1 + Δ(s)W(s)), where G_nom is the nominal model, W(s) is a known frequency-dependent weighting function bounding the uncertainty magnitude, and Δ(s) is an unknown stable transfer function with ||Δ||_∞ ≤ 1. The robust stability condition requires |T(jω)W(jω)| < 1 for all frequencies, meaning the complementary sensitivity function T(s) must be small wherever model uncertainty is large — typically at high frequencies where unmodeled dynamics, resonances, and parasitic effects dominate. Classical gain and phase margins are scalar robustness measures: they quantify how much the loop gain or phase can change before instability, but they capture only specific perturbation directions and can miss structured uncertainty. The H∞ framework generalizes this by formulating the controller design as an optimization: minimize ||T_zw||_∞ (the peak gain from disturbance inputs to performance outputs across all frequencies), which directly shapes the sensitivity and complementary sensitivity functions to meet weighted performance and robustness specifications simultaneously. The small gain theorem provides the foundational result: interconnection of two stable systems with loop gain less than one is stable, and this generalizes to the robust stability condition for multiplicative uncertainty.
Start by computing gain and phase margins for a feedback system and then introducing plant perturbations that violate one margin but not the other, demonstrating that scalar margins can be misleading. Next, model the perturbation as multiplicative uncertainty with a weighting function W(s) and verify the robust stability condition |T(jω)W(jω)| < 1 graphically. Finally, use MATLAB's hinfsyn or Python's control library to design an H∞ controller for a simple plant and compare its sensitivity/complementary sensitivity tradeoff with a classically tuned PID, observing how the H∞ controller explicitly shapes these functions to meet specifications.
From your study of sensitivity and disturbance rejection, you know that the sensitivity function S(s) = 1/[1 + L(s)] and the complementary sensitivity function T(s) = L(s)/[1 + L(s)] characterize how a closed-loop system responds to disturbances and reference inputs respectively (S + T = 1). From the Nyquist stability criterion, you know that closed-loop stability depends on how the loop transfer function L(jω) encircles the critical point −1 in the complex plane. Robust control begins by asking: if the true plant differs from your model, how does the Nyquist plot shift, and can it encircle −1 when the nominal plot did not?
The standard way to model this uncertainty is multiplicative uncertainty: the true plant is written as G_true(s) = G_nom(s)[1 + Δ(s)W(s)], where G_nom is your nominal model, W(s) is a known weighting function that describes *how large* the uncertainty can be as a function of frequency, and Δ(s) is an unknown stable transfer function with |Δ(jω)| ≤ 1 for all ω. At low frequencies, your model is usually accurate — physical parameters are well-measured and low-frequency dynamics are well-understood. At high frequencies, unmodeled resonances, computational delays, and parasitic effects can make the true plant deviate substantially from the model. W(s) is typically small at low frequencies and large (possibly greater than 1) at high frequencies, encoding this frequency-dependent uncertainty profile.
The robust stability condition follows from the small gain theorem: two stable systems in a feedback loop are stable if the product of their gains is less than one at every frequency. Applied to multiplicative uncertainty, the loop is robustly stable for all perturbations |Δ| ≤ 1 if and only if |T(jω)·W(jω)| < 1 for all ω. Rearranged: |T(jω)| < 1/|W(jω)|. Where uncertainty is large (high frequencies, |W| large), the complementary sensitivity must be small. This is precisely the Bode "waterbed" tradeoff you saw in sensitivity analysis: pushing T down at high frequencies requires accepting a larger S (reduced disturbance rejection) at low frequencies, and vice versa. Robust control makes this tradeoff explicit and quantitative rather than handled informally.
Classical gain and phase margins are special cases of this framework, but they only measure robustness along specific directions: how much can loop gain increase (gain margin) or phase rotate (phase margin) before crossing the −1 point. A system can have large gain and phase margins yet be brittle to *simultaneous* gain and phase perturbations — the classical margins miss this. The H∞ framework generalizes robustness to arbitrary perturbation types by posing the controller design as a minimax optimization: find the controller C(s) that minimizes the peak gain ||T_zw||_∞ from a vector of exogenous inputs (disturbances, noise, reference signals, uncertainty inputs) to a vector of performance outputs. The ∞-norm picks out the worst-case frequency — the frequency at which the gain from disturbance to error is largest — and the controller is designed to make even the worst case acceptable. Choosing the weighting functions W_S(s) on sensitivity, W_T(s) on complementary sensitivity, and W_U(s) on control effort is the designer's art: it encodes domain knowledge about where the system must reject disturbances, what uncertainty profile the plant has, and how large a control signal is acceptable. The resulting H∞ controller automatically trades off all these objectives simultaneously, something a classically tuned PID cannot do systematically.