In previous chapters, we have modeled physical plants by low-order transfer functions such as first- or second-order systems, possibly with time delay. These nominal models are valid only over a limited frequency range. At higher frequencies, neglected dynamics (flexible modes, structural resonances, parasitic capacitances and inductances, sensor lags, computation delays, etc.) cause the true plant to deviate from the nominal model.

Let \( P_{\text{true}}(s) \) be the (unknown) true plant and \( P_0(s) \) the nominal model used for design. Then the unmodeled high-frequency dynamics are encoded in the discrepancy between \( P_{\text{true}}(s) \) and \( P_0(s) \), which is typically small for low frequencies and can be large for high frequencies:

\[ P_{\text{true}}(s) \approx P_0(s) \quad \text{for} \quad |\omega| \ll \omega_{\text{HF}}, \qquad P_{\text{true}}(s) \not\approx P_0(s) \quad \text{for} \quad |\omega| \gtrsim \omega_{\text{HF}} . \]

Here \( \omega_{\text{HF}} \) is a characteristic frequency above which neglected dynamics become important. For robust control design we do not attempt to model all high-frequency dynamics explicitly; instead, we represent them as bounded uncertainty around the nominal model.

flowchart TD
  A["Physical system"] --> B["Derive nominal low-order model P0(s)"]
  B --> C["Validate model in frequency domain"]
  C --> D["Observe mismatch at high frequencies"]
  D --> E["Interpret mismatch as unmodeled high-frequency dynamics"]
  E --> F["Represent via uncertainty around P0(s)"]
  F --> G["Use in robustness and loop-shaping design"]
        

The discrepancy between the true plant and its nominal model can be written in several mathematically equivalent ways. Two common representations are additive and multiplicative uncertainty.

2.1 Additive uncertainty

In the additive representation, we write

\[ P_{\text{true}}(s) = P_0(s) + \Delta_a(s), \]

where \( \Delta_a(s) \) is the additive perturbation. To capture the idea that the perturbation is small at low frequencies and potentially large at high frequencies, we introduce a stable, known weighting transfer function \( W_a(s) \) and an unknown stable \( \Delta(s) \) such that

\[ \Delta_a(s) = W_a(s)\,\Delta(s), \qquad \sup_{\omega \in \mathbb{R}} |\Delta(\mathrm{j}\omega)| \le 1. \]

The weight \( W_a(s) \) is chosen so that \( |W_a(\mathrm{j}\omega)| \) is small for low frequencies (where we trust our model) and large only at higher frequencies.

2.2 Multiplicative uncertainty

For high-frequency unmodeled dynamics, the multiplicative representation is often more natural:

\[ P_{\text{true}}(s) = P_0(s)\,\bigl(1 + \Delta_m(s)\bigr). \]

Again we introduce a weighting function \( W_m(s) \) and an unknown but bounded \( \Delta(s) \):

\[ \Delta_m(s) = W_m(s)\,\Delta(s), \qquad \sup_{\omega \in \mathbb{R}} |\Delta(\mathrm{j}\omega)| \le 1. \]

Then

\[ P_{\text{true}}(s) = P_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr), \qquad |\Delta(\mathrm{j}\omega)| \le 1 \quad \forall \,\omega. \]

In this description, \( W_m(s) \) encodes how large the relative modeling error \( \Delta_m(s) \) can be as a function of frequency. For high-frequency unmodeled dynamics, we typically design \( W_m(s) \) to satisfy

\[ |W_m(\mathrm{j}\omega)| \approx 0 \quad \text{for } |\omega| \ll \omega_{\text{HF}}, \qquad |W_m(\mathrm{j}\omega)| \text{ not small for } |\omega| \gtrsim \omega_{\text{HF}}. \]

Later lessons will show how to choose simple rational forms for these weights; here we focus on the physical and analytical meaning of the high-frequency discrepancy.

Typical sources of unmodeled high-frequency dynamics include:

• Flexible structural modes (robot arms, drive shafts, gear trains) that appear as lightly damped second-order factors.
• Actuator bandwidth limits such as motor current dynamics, valve spool dynamics, or switching power amplifier dynamics.
• Sensor dynamics such as anti-aliasing filters, sensor mechanical resonances, and electronic low-pass filters.
• High-frequency parasitics in electrical circuits (parasitic capacitances, inductances) and cross-couplings.
• Sample-and-hold and computation delay in digital control, which introduce high-frequency phase lag beyond the continuous-time design.

As a prototypical example, consider a lightly damped flexible mode with natural frequency \( \omega_f \) and damping ratio \( \zeta_f \). The corresponding transfer function factor is

\[ G_f(s) = \frac{\omega_f^2}{s^2 + 2\zeta_f \,\omega_f s + \omega_f^2}, \qquad 0 < \zeta_f \ll 1. \]

If the nominal plant \( P_0(s) \) has been identified using low-frequency experiments, this flexible mode may not appear in the model even though it dominates the response near \( \omega_f \). This is precisely the situation we want to capture by a high-frequency uncertainty model.

Consider a unity-feedback loop with controller \( C(s) \) and nominal plant \( P_0(s) \). The nominal loop transfer function is

\[ L_0(s) = C(s) P_0(s), \]

and the nominal sensitivity and complementary sensitivity functions (introduced in Chapter 22) are

\[ S_0(s) = \frac{1}{1 + L_0(s)}, \qquad T_0(s) = \frac{L_0(s)}{1 + L_0(s)}. \]

With multiplicative uncertainty, the true plant is

\[ P_{\text{true}}(s) = P_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr), \qquad |\Delta(\mathrm{j}\omega)| \le 1. \]

The true loop transfer function is then

\[ L(s) = C(s) P_{\text{true}}(s) = L_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr). \]

The true closed-loop transfer function from reference to output is

\[ T(s) = \frac{L(s)}{1 + L(s)} = \frac{L_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr)} {1 + L_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr)}. \]

Factor out \( 1 + L_0(s) \) in the denominator:

\[ 1 + L(s) = 1 + L_0(s) + L_0(s) W_m(s)\,\Delta(s) = \bigl(1 + L_0(s)\bigr) \bigl(1 + W_m(s)\,\Delta(s)\,T_0(s)\bigr). \]

Thus

\[ T(s) = \frac{L_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr)} {\bigl(1 + L_0(s)\bigr)\bigl(1 + W_m(s)\,\Delta(s)\,T_0(s)\bigr)} = \frac{T_0(s)\,\bigl(1 + W_m(s)\,\Delta(s)\bigr)} {1 + W_m(s)\,\Delta(s)\,T_0(s)}. \]

Internal stability of the closed loop requires that the denominator \( 1 + W_m(s)\,\Delta(s)\,T_0(s) \) has no zeros in the right-half plane. A sufficient frequency-domain condition, based on the scalar small-gain argument, is:

\[ \sup_{\omega \in \mathbb{R}} \bigl|W_m(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega)\bigr| < 1. \]

Sketch of reasoning. For any fixed frequency \( \omega \), we have \( |W_m(\mathrm{j}\omega)\,\Delta(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega)| \le |W_m(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega)| \) because \( |\Delta(\mathrm{j}\omega)| \le 1 \). If \( |W_m(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega)| < 1 \) for all \( \omega \), then \( |W_m(\mathrm{j}\omega)\,\Delta(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega)| < 1 \) for all \( \omega \), which forbids \( 1 + W_m(\mathrm{j}\omega)\,\Delta(\mathrm{j}\omega)\,T_0(\mathrm{j}\omega) = 0 \). Thus no Nyquist encirclement of \( -1 \) occurs for the effective loop \( W_m(s)\,T_0(s) \).

This condition shows clearly that making \( T_0(\mathrm{j}\omega) \) small at high frequencies (strong high-frequency roll-off) reduces sensitivity to unmodeled high-frequency dynamics. This is exactly the design philosophy introduced in previous chapters: do not push the bandwidth so high that the loop gain remains large where the model is unreliable.

Consider a single revolute robot joint driven by a DC motor through an elastic transmission. A simplified rigid-body nominal model derived in earlier chapters might be

\[ P_0(s) = \frac{K_m}{J s^2 + b s}, \]

where \( J \) is the equivalent inertia, \( b \) viscous friction, and \( K_m \) a motor gain from voltage input to torque or position response (depending on units).

Suppose that a flexible mode at high frequency \( \omega_f \) arises from transmission elasticity. The corresponding factor is

\[ G_f(s) = \frac{\omega_f^2}{s^2 + 2\zeta_f \,\omega_f s + \omega_f^2}, \qquad 0 < \zeta_f \ll 1, \quad \omega_f \gg \text{bandwidth}. \]

The true plant is then

\[ P_{\text{true}}(s) = P_0(s)\,G_f(s), \]

and the multiplicative deviation is

\[ \Delta_m(s) = \frac{P_{\text{true}}(s) - P_0(s)}{P_0(s)} = G_f(s) - 1. \]

At low frequencies \( |\omega| \ll \omega_f \), we have \( G_f(\mathrm{j}\omega) \approx 1 \) and hence \( \Delta_m(\mathrm{j}\omega) \approx 0 \), so the flexible mode is negligible. At \( \omega = \omega_f \), we obtain

\[ G_f(\mathrm{j}\omega_f) = \frac{\omega_f^2}{-\omega_f^2 + \omega_f^2 + \mathrm{j} 2\zeta_f \,\omega_f^2} = \frac{\omega_f^2}{\mathrm{j} 2\zeta_f \,\omega_f^2} = \frac{1}{\mathrm{j} 2\zeta_f}, \]

so

\[ \bigl|G_f(\mathrm{j}\omega_f)\bigr| = \frac{1}{2\zeta_f}. \]

For a lightly damped mode with \( \zeta_f = 0.05 \), this yields \( |G_f(\mathrm{j}\omega_f)| = 10 \), so \( |\Delta_m(\mathrm{j}\omega_f)| \approx 10 \). The flexible mode acts like a sharp resonance that can severely amplify high-frequency noise and potentially destabilize the loop if the controller maintains high gain near \( \omega_f \).

A reasonable multiplicative weight capturing this high-frequency effect might be

\[ W_m(s) = \frac{\alpha\,s/\omega_f}{1 + s/\omega_f}, \qquad \alpha \approx \frac{1}{2\zeta_f}, \]

so that \( |W_m(\mathrm{j}\omega)| \) is small for \( |\omega| \ll \omega_f \) and approaches \( \alpha \) as \( |\omega| \to \infty \). The robust stability condition \( |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| < 1 \) then penalizes controller designs with excessive high-frequency gain.

We now demonstrate how to evaluate the multiplicative uncertainty for the robot joint example using Python. We use:

• python-control (control package) for transfer functions and frequency response.
• Optional robotics-oriented packages such as roboticstoolbox-python to obtain realistic inertia and friction parameters from robot models (e.g., a 6-DOF manipulator). Here we just comment on their possible use and implement the dynamics explicitly.

import numpy as np
import control as ct

# Nominal robot joint parameters (simplified)
J = 0.01   # kg m^2
b = 0.1    # N m s/rad
Km = 1.0   # gain from voltage to torque*gear ratio units

# Flexible mode parameters (unmodeled in P0)
zeta_f = 0.05
w_f = 200.0  # rad/s, high-frequency flexible mode

# Transfer function variable
s = ct.TransferFunction.s

# Nominal rigid-body plant P0(s) = Km / (J s^2 + b s)
P0 = Km / (J * s**2 + b * s)

# Flexible mode factor Gf(s) = w_f^2 / (s^2 + 2 zeta_f w_f s + w_f^2)
Gf = (w_f**2) / (s**2 + 2 * zeta_f * w_f * s + w_f**2)

# True plant including flexible mode (unknown in nominal design)
P_true = P0 * Gf

# Multiplicative deviation Delta_m(s) = P_true(s)/P0(s) - 1 = Gf(s) - 1
Delta_m = Gf - 1

# Simple proportional controller (for illustration)
Kp = 5.0
C = Kp

L0 = C * P0                 # nominal loop
T0 = ct.feedback(L0, 1)     # nominal complementary sensitivity

# Candidate multiplicative weight Wm(s)
alpha = 1.0 / (2.0 * zeta_f)
Wm = alpha * (s / w_f) / (1 + s / w_f)

# Frequency grid
w = np.logspace(0, 4, 500)  # 1 .. 10000 rad/s

# Frequency responses
_, mag_T0, _ = ct.freqresp(T0, w)
_, mag_Wm, _ = ct.freqresp(Wm, w)
_, mag_Dm, _ = ct.freqresp(Delta_m, w)

# Evaluate robust stability margin sup |Wm(jw) T0(jw)|
prod_mag = (mag_Wm * mag_T0).ravel()
max_prod = np.max(prod_mag)

print("sup_w |Wm(jw) T0(jw)| =", float(max_prod))

# Check that the actual multiplicative error is covered by the weight:
# |Delta_m(jw)| <= |Wm(jw)| ? (not guaranteed, but indicative)
ratio = (mag_Dm / (mag_Wm + 1e-8)).ravel()
print("max_w |Delta_m(jw)| / |Wm(jw)| =", float(np.max(ratio)))

# NOTE (robotics context):
# In a more detailed model, parameters J and b could be obtained from a
# robotics toolbox, e.g.:
#   from roboticstoolbox import models
#   robot = models.DH.Puma560()
#   J = robot.inertia(q)[joint_index, joint_index]
# allowing uncertainty analysis directly on realistic joint dynamics.
      

The quantity \( \sup_{\omega} |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| \) provides a measure of robustness to the flexible mode approximated by the weight. If it is safely below 1, the closed-loop design is relatively insensitive to the unmodeled high-frequency dynamics.

In embedded robotic controllers (e.g., ROS2 nodes), it is common to implement simple analytical checks of model uncertainty offline. The following C++ snippet evaluates the magnitude of the multiplicative error \( \Delta_m(\mathrm{j}\omega) \) for the robot joint example. Linear algebra libraries such as Eigen are standard for larger state-space models; here we work directly with transfer function formulas.

#include <iostream>
#include <complex>
#include <vector>
#include <cmath>

using cd = std::complex<double>;

cd P0(cd s, double J, double b, double Km) {
    return Km / (J * s * s + b * s);
}

cd Gf(cd s, double w_f, double zeta_f) {
    return (w_f * w_f) / (s * s + 2.0 * zeta_f * w_f * s + w_f * w_f);
}

int main() {
    double J = 0.01;
    double b = 0.1;
    double Km = 1.0;
    double w_f = 200.0;
    double zeta_f = 0.05;

    // Logarithmic frequency grid
    std::vector<double> w;
    for (int k = 0; k <= 400; ++k) {
        double exponent = std::log10(1.0) + (4.0 * k) / 400.0;
        w.push_back(std::pow(10.0, exponent));
    }

    double maxDelta = 0.0;
    for (double wi : w) {
        cd s(0.0, wi);
        cd P0jw = P0(s, J, b, Km);
        cd Gfjw = Gf(s, w_f, zeta_f);
        cd Delta_m = Gfjw - cd(1.0, 0.0);
        double mag = std::abs(Delta_m);
        if (mag > maxDelta) {
            maxDelta = mag;
        }
    }

    std::cout << "Maximum |Delta_m(jw)| over the grid = " << maxDelta << std::endl;

    // In a robot controller, this estimate can guide bandwidth selection:
    // ensure loop gain is low around frequencies where |Delta_m(jw)| is large.
    return 0;
}
      

In a ROS-/ROS2-based robotic system, similar code can be integrated into offline design tools that use plant models derived from URDF or other robot descriptions, helping to select controllers that are robust to high-frequency dynamics not explicitly captured in the control loop.

In Java-based robotic frameworks (for example, FIRST Robotics WPILib or custom research frameworks), one may perform similar frequency-domain checks using complex arithmetic libraries such as Apache Commons Math.

import org.apache.commons.math3.complex.Complex;

public class HFUnmodeledDynamics {

    static Complex P0(Complex s, double J, double b, double Km) {
        // Km / (J s^2 + b s)
        Complex denom = s.multiply(s).multiply(J).add(s.multiply(b));
        return new Complex(Km, 0.0).divide(denom);
    }

    static Complex Gf(Complex s, double wF, double zetaF) {
        // wF^2 / (s^2 + 2 zetaF wF s + wF^2)
        Complex denom = s.multiply(s)
                         .add(s.multiply(2.0 * zetaF * wF))
                         .add(new Complex(wF * wF, 0.0));
        return new Complex(wF * wF, 0.0).divide(denom);
    }

    public static void main(String[] args) {
        double J = 0.01;
        double b = 0.1;
        double Km = 1.0;
        double wF = 200.0;
        double zetaF = 0.05;

        double maxDelta = 0.0;
        int N = 400;
        for (int k = 0; k <= N; ++k) {
            double exp = 0.0 + 4.0 * k / (double) N; // 10^0 .. 10^4
            double w = Math.pow(10.0, exp);
            Complex s = new Complex(0.0, w);
            Complex P0jw = P0(s, J, b, Km);
            Complex Gfjw = Gf(s, wF, zetaF);
            Complex DeltaM = Gfjw.subtract(Complex.ONE); // multiplicative deviation
            double mag = DeltaM.abs();
            if (mag > maxDelta) {
                maxDelta = mag;
            }
        }
        System.out.println("Max |Delta_m(jw)| over grid = " + maxDelta);

        // In robot joint velocity loops, this information can be used to
        // reduce controller gain near frequencies with large multiplicative error.
    }
}
      

The Java implementation mirrors the C++ and Python approaches and can be integrated into simulation or autotuning tools that accompany robotic platforms.

MATLAB, with Control System Toolbox and Robotics System Toolbox, is widely used for robotics-oriented control design. The script below implements the same robot joint example, computes the multiplicative deviation, and plots its magnitude.

J = 0.01;
b = 0.1;
Km = 1.0;

zeta_f = 0.05;
w_f = 200;       % rad/s

s = tf('s');

P0 = Km / (J * s^2 + b * s);
Gf = (w_f^2) / (s^2 + 2 * zeta_f * w_f * s + w_f^2);
Ptrue = P0 * Gf;

Delta_m = Gf - 1;   % multiplicative deviation: Ptrue/P0 - 1

Kp = 5;
C = Kp;

L0 = C * P0;
T0 = feedback(L0, 1);

alpha = 1 / (2 * zeta_f);
Wm = alpha * (s / w_f) / (1 + s / w_f);

w = logspace(0, 4, 500);

[magDm, ~, ~] = bode(Delta_m, w);
[magWm, ~, ~] = bode(Wm, w);
[magT0, ~, ~] = bode(T0, w);

magDm = squeeze(magDm);
magWm = squeeze(magWm);
magT0 = squeeze(magT0);

figure;
loglog(w, magDm, 'LineWidth', 1.5); hold on;
loglog(w, magWm, '--', 'LineWidth', 1.5);
xlabel('Frequency (rad/s)');
ylabel('Magnitude');
legend('|Delta_m(jw)|', '|W_m(jw)|');
grid on;

figure;
loglog(w, magWm .* magT0, 'LineWidth', 1.5);
xlabel('Frequency (rad/s)');
ylabel('|W_m(jw) T_0(jw)|');
grid on;

% In a robotics workflow, J and b can be derived from a rigid-body tree model:
%   robot = importrobot('yourRobot.urdf');
%   J = someFunctionOf(robot, jointIndex);
% and then the same uncertainty analysis can be repeated for each joint.
      

In Simulink, a corresponding block diagram uses a Transfer Fcn block for \( P_0(s) \), an additional second-order block for the flexible mode, and a scalar gain block for the controller. The magnitude curves \( |\Delta_m(\mathrm{j}\omega)| \), \( |W_m(\mathrm{j}\omega)| \), and \( |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| \) provide direct visual insight into robustness against high-frequency unmodeled dynamics.

Wolfram Mathematica offers symbolic manipulation of transfer functions and direct plotting of Bode magnitudes. The following code reproduces the flexible mode analysis and plots the multiplicative deviation:

(* Parameters *)
J = 0.01;
b = 0.1;
Km = 1.0;

zetaF = 0.05;
wF = 200.0;

s = ComplexExpand[I*ω] /. ω -> ω; (* symbolic placeholder for s if needed *)

(* Transfer functions using TransferFunctionModel *)
P0 = TransferFunctionModel[Km/{J, b, 0}, s];
Gf = TransferFunctionModel[{wF^2}, {1, 2 zetaF wF, wF^2}, s];

Ptrue = SeriesConnect[P0, Gf];
DeltaM = TransferFunctionModel[(OutputResponse[Ptrue, 1, s]/
           OutputResponse[P0, 1, s]) - 1, s];

(* Bode magnitude of DeltaM and a simple weight Wm *)
alpha = 1/(2 zetaF);
Wm = TransferFunctionModel[{alpha, 0}, {1/wF, 1}, s];

BodePlot[{DeltaM, Wm},
  {ω, 1, 10^4},
  PlotLegends -> {"|Delta_m(jω)|", "|W_m(jω)|"},
  GridLines -> Automatic
]

(* Optional: evaluate |Wm(jω) T0(jω)| for a proportional controller *)
Kp = 5.0;
C = TransferFunctionModel[{Kp}, {1}, s];
L0 = SeriesConnect[C, P0];
T0 = FeedbackConnect[L0, 1];

BodePlot[{Wm*T0}, {ω, 1, 10^4},
  PlotLegends -> {"|W_m(jω) T_0(jω)|"}
]
      

Symbolic tools can also be used to derive approximate expressions for resonance peaks and asymptotic slopes, deepening the analytical understanding of how high-frequency modes affect robustness.

Problem 1 (Flexible Mode as Multiplicative Uncertainty). Let the nominal plant be \( P_0(s) = \dfrac{1}{s(s+1)} \), and suppose the true plant contains an additional flexible mode

\[ G_f(s) = \frac{\omega_f^2}{s^2 + 2\zeta_f \,\omega_f s + \omega_f^2}, \]

so that \( P_{\text{true}}(s) = P_0(s)G_f(s) \). Derive the multiplicative perturbation \( \Delta_m(s) \) and compute \( \Delta_m(\mathrm{j}0) \) and \( \Delta_m(\mathrm{j}\omega_f) \). Give an approximation for \( |\Delta_m(\mathrm{j}\omega_f)| \) when \( \zeta_f \ll 1 \).

Solution:

By definition,

\[ \Delta_m(s) = \frac{P_{\text{true}}(s) - P_0(s)}{P_0(s)} = G_f(s) - 1. \]

At \( \omega = 0 \),

\[ G_f(0) = \frac{\omega_f^2}{0 + 0 + \omega_f^2} = 1, \qquad \Delta_m(\mathrm{j}0) = 1 - 1 = 0. \]

At \( \omega = \omega_f \) we already computed

\[ G_f(\mathrm{j}\omega_f) = \frac{1}{\mathrm{j} 2\zeta_f}, \qquad \bigl|G_f(\mathrm{j}\omega_f)\bigr| = \frac{1}{2\zeta_f}. \]

Thus

\[ \Delta_m(\mathrm{j}\omega_f) = \frac{1}{\mathrm{j} 2\zeta_f} - 1. \]

For \( \zeta_f \ll 1 \), \( |1/(\mathrm{j}2\zeta_f)| \gg 1 \), so \( |\Delta_m(\mathrm{j}\omega_f)| \approx |1/(\mathrm{j}2\zeta_f)| = 1/(2\zeta_f) \). Therefore a very lightly damped flexible mode can correspond to a very large multiplicative uncertainty near its resonance.

Problem 2 (Condition for Robust Stability with Multiplicative Uncertainty). Show that for unity feedback and multiplicative uncertainty \( P_{\text{true}}(s) = P_0(s)\bigl(1 + W_m(s)\Delta(s)\bigr) \) with \( |\Delta(\mathrm{j}\omega)| \le 1 \), the condition

\[ \sup_{\omega \in \mathbb{R}} \bigl|W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)\bigr| < 1 \]

guarantees internal stability for all such plants. Use only the scalar (SISO) case and basic complex analysis.

Solution:

From Section 4, the closed-loop denominator factor due to uncertainty is \( 1 + W_m(s)\Delta(s)T_0(s) \). Instability would require at least one \( s \) in the closed right-half plane such that

\[ 1 + W_m(s)\Delta(s)T_0(s) = 0. \]

In particular, along the imaginary axis \( s = \mathrm{j}\omega \), this would require

\[ W_m(\mathrm{j}\omega)\Delta(\mathrm{j}\omega)T_0(\mathrm{j}\omega) = -1. \]

Taking magnitudes,

\[ \bigl|W_m(\mathrm{j}\omega)\Delta(\mathrm{j}\omega)T_0(\mathrm{j}\omega)\bigr| = 1. \]

But since \( |\Delta(\mathrm{j}\omega)| \le 1 \), we have

\[ \bigl|W_m(\mathrm{j}\omega)\Delta(\mathrm{j}\omega)T_0(\mathrm{j}\omega)\bigr| \le \bigl|W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)\bigr|. \]

If \( \sup_{\omega} |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| < 1 \), then \( |W_m(\mathrm{j}\omega)\Delta(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| < 1 \) for all \( \omega \) and all admissible \( \Delta \), so the above equality cannot hold. Hence \( 1 + W_m(s)\Delta(s)T_0(s) \) has no zeros on or to the right of the imaginary axis, and the closed loop remains internally stable for all admissible multiplicative perturbations.

Problem 3 (Designing a Simple High-Frequency Weight). Suppose measurements of the relative model error for a plant show that

\[ |\Delta_m(\mathrm{j}\omega)| \approx \begin{cases} 0.02, & |\omega| \le 5, \\ 0.1, & 5 < |\omega| \le 50, \\ 2.0, & |\omega| > 50. \end{cases} \]

Propose a first-order multiplicative weight \( W_m(s) \) of the form \( W_m(s) = \dfrac{k\,s/\omega_b}{1 + s/\omega_b} \) that upper bounds \( |\Delta_m(\mathrm{j}\omega)| \) across frequency (approximately).

Solution:

For \( |\omega| \ll \omega_b \), the magnitude of \( W_m(\mathrm{j}\omega) \) behaves like \( k|\omega|/\omega_b \), and for \( |\omega| \gg \omega_b \), it saturates at \( k \). To capture the large high-frequency uncertainty, we choose \( k \approx 2.5 \) so that \( k \ge 2.0 \). To keep low-frequency values small, we choose \( \omega_b \approx 50 \), roughly at the transition where uncertainty becomes large. Then

\[ W_m(s) = \frac{2.5\,s/50}{1 + s/50} = \frac{0.05\,s}{1 + \frac{s}{50}}. \]

For \( |\omega| \le 5 \), \( |W_m(\mathrm{j}\omega)| \approx 2.5\,|\omega|/50 \le 0.25 \), which is larger than \( 0.02 \) but acceptably conservative. For \( 5 < |\omega| \le 50 \), the magnitude increases smoothly from \( 0.25 \) toward \( 2.5 \), exceeding \( 0.1 \). For \( |\omega| > 50 \), we have \( |W_m(\mathrm{j}\omega)| \approx 2.5 \ge 2.0 \), so the high-frequency uncertainty is also upper bounded.

Problem 4 (Interaction with Derivative Action). Explain qualitatively and quantitatively why derivative action in a PID controller increases sensitivity to unmodeled high-frequency dynamics.

Solution:

A PID controller in parallel form has the transfer function

\[ C(s) = K_p + \frac{K_i}{s} + K_d s. \]

The derivative term \( K_d s \) grows unbounded as \( |\omega| \to \infty \). Thus, the loop transfer function \( L_0(s) = C(s)P_0(s) \) scales approximately as \( K_d s P_0(s) \) at high frequency. Even if \( P_0(s) \) decays like \( 1/s^2 \) or \( 1/s \), the derivative term can significantly reduce the high-frequency roll-off of \( L_0(s) \) and hence of \( T_0(s) \).

Since robust stability requires \( |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| \) to be small at frequencies where \( |W_m(\mathrm{j}\omega)| \) is large (i.e., high frequencies), a controller with strong derivative action tends to increase \( |T_0(\mathrm{j}\omega)| \) in exactly the frequency range where the plant model is least reliable. Therefore it increases sensitivity to unmodeled high-frequency dynamics and can undermine robustness unless combined with a low-pass filter (filtered derivative) that restores high-frequency roll-off.

Problem 5 (Block Structure with Multiplicative Uncertainty). Draw a block structure (no detailed parameters) of a unity-feedback loop with nominal plant \( P_0(s) \), controller \( C(s) \), and multiplicative high-frequency uncertainty \( P_{\text{true}}(s) = P_0(s)\bigl(1 + W_m(s)\Delta(s)\bigr) \). Show how the uncertainty block appears relative to the nominal loop.

Solution (diagram):

flowchart LR
  R["r"] --> SUM["+"]
  SUM --> C["C(s)"]
  C --> M["1 + Wm(s) Delta(s)"]
  M --> P0["P0(s)"]
  P0 --> Y["y"]
  Y --> N["-"]
  N --> SUM
        

The block labeled "1 + Wm(s) Delta(s)" represents the uncertain multiplicative factor. It multiplies the nominal plant "P0(s)". This diagram is the starting point for more advanced robust control frameworks such as the small-gain theorem and structured singular value analysis, which formalize the effect of such uncertainty blocks on closed-loop stability and performance.

In this lesson we introduced unmodeled high-frequency dynamics as the discrepancy between a nominal plant model and the true physical system at high frequencies. We formalized this discrepancy using additive and multiplicative uncertainty representations with frequency-dependent weighting functions, and we showed that multiplicative uncertainty is particularly natural for high-frequency effects.

By analyzing the closed-loop transfer function with multiplicative uncertainty, we derived a scalar small-gain-type condition \( \sup_{\omega} |W_m(\mathrm{j}\omega)T_0(\mathrm{j}\omega)| < 1 \) that guarantees internal stability for all perturbations bounded by \( W_m(s) \). A flexible-mode robot joint example illustrated how lightly damped high-frequency dynamics can generate large multiplicative errors even when low-frequency behavior is well captured by the nominal model.

Multi-language numerical labs (Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica) demonstrated how to compute and visualize multiplicative uncertainty and how such analyses can be integrated into robotic control design workflows. The next lesson will develop simple uncertainty models suitable for classical Bode, Nyquist, and Nichols-based robustness analysis.