We consider a standard unity-feedback loop with controller \( C(s) \) and plant \( P(s) \). The loop transfer function is \( L(s) = C(s)P(s) \). The sensitivity function and complementary sensitivity function are, as in Chapter 22:

\[ S(s) = \frac{1}{1 + L(s)}, \qquad T(s) = \frac{L(s)}{1 + L(s)}. \]

Let the external signals be: reference \( r \), plant input disturbance \( d \), and sensor noise \( n \). For unity feedback with disturbance added at the plant input and noise added at the sensor, block-diagram algebra yields the closed-loop transfer relations

\[ y(s) = T(s)\,r(s) + P(s)S(s)\,d(s) - T(s)\,n(s), \]

and the control input

\[ u(s) = C(s)S(s)\,r(s) + C(s)S(s)\,d(s) - C(s)S(s)\,n(s). \]

Thus:

• Tracking quality is governed mainly by \( T(s) \) (from \( r \) to \( y \)).
• Disturbance rejection is governed by \( P(s)S(s) \).
• Noise attenuation is governed by \( T(s) \) (from \( n \) to \( y \)) and by \( C(s)S(s) \) (from \( n \) to \( u \)).

Robust performance means that these closed-loop behaviors remain acceptable for all admissible model uncertainties while preserving stability (robust stability, covered in Lesson 1).

Before considering uncertainty, we encode nominal performance as frequency-domain inequalities on \( S(j\omega) \) and \( T(j\omega) \). For a stable nominal loop, these are well-defined for all \( \omega \in \mathbb{R} \).

A typical disturbance-rejection requirement is of the form

\[ |P(j\omega) S(j\omega)| \leq \gamma_d(\omega) \quad \text{for low } \omega, \]

where the shaping function \( \gamma_d(\omega) \) is small at low frequencies (to enforce strong attenuation) and allowed to grow at high frequencies. Because \( |P(j\omega)| \) is typically known from the nominal model, this becomes a constraint on \( |S(j\omega)| \).

Similarly, a noise-attenuation requirement can be written as

\[ |T(j\omega)| \leq \gamma_n(\omega) \quad \text{for high } \omega, \]

with \( \gamma_n(\omega) \) small at high frequencies to prevent amplification of measurement noise.

It is convenient to use weighting functions that encode the reciprocal of allowable magnitudes. For example, a performance weight \( W_P(s) \) defines

\[ |W_P(j\omega) S(j\omega)| \leq 1 \quad \text{for all } \omega. \]

At frequencies where \( |W_P(j\omega)| \) is large, the inequality forces \( |S(j\omega)| \) to be very small; where \( |W_P(j\omega)| \) is small, the constraint is relaxed.

Analogously, a noise weight \( W_N(s) \) imposes

\[ |W_N(j\omega) T(j\omega)| \leq 1 \quad \text{for all } \omega. \]

These inequalities are the building blocks of robust performance conditions in the presence of uncertainty.

Suppose we model multiplicative output uncertainty (reviewed in Chapter 23) as

\[ \tilde{P}(s) = P(s) \bigl(1 + W_\Delta(s)\Delta(s)\bigr), \qquad |\Delta(j\omega)| \leq 1 \text{ for all } \omega. \]

Here \( W_\Delta(s) \) describes the frequency-dependent size of modeling error. With this model, a standard sufficient condition for robust stability is

\[ |W_\Delta(j\omega) T(j\omega)| < 1 \quad \text{for all } \omega, \]

which guarantees that all admissible perturbed plants \( \tilde{P} \) are stabilized by \( C \).

Robust performance strengthens this by requiring that performance constraints hold for all admissible uncertainties. A typical formulation is:

\[ |W_P(j\omega) S_{\tilde{P}}(j\omega)| \leq 1, \quad |W_N(j\omega) T_{\tilde{P}}(j\omega)| \leq 1 \quad \text{for all } \omega \text{ and all admissible } \tilde{P}, \]

where \( S_{\tilde{P}} \) and \( T_{\tilde{P}} \) are the closed-loop sensitivity functions for the perturbed plant.

In classical SISO analysis, we often use conservative frequency-by-frequency tests that ensure both robust stability and approximate robust performance, such as:

\[ |W_\Delta(j\omega) T(j\omega)| + |W_P(j\omega) S(j\omega)| \leq 1 \quad \text{for all } \omega. \]

This inequality illustrates the competition between robustness (small \( |T| \) where \( |W_\Delta| \) is large) and nominal disturbance rejection/tracking (small \( |S| \) where \( |W_P| \) is large). Their product cannot be made arbitrarily small over all frequencies, consistent with the “waterbed” effect discussed in Chapter 22.

flowchart TD
  SP["Specify perf. weights W_P(jw), W_N(jw)"] --> U["Specify uncertainty weight W_Delta(jw)"]
  U --> L["Design controller C(s) => loop L(s) = C(s)P(s)"]
  L --> ST["Compute S(s) = 1/(1+L), T(s) = L/(1+L)"]
  ST --> CH["Check inequalities: W_P S, W_N T, W_Delta T"]
  CH --> OK["If all freq. constraints satisfied => \nrobust performance"]
  CH --> ADJ["If violated => \nadjust controller or weights"]
        

Because \( S(s) + T(s) = 1 \), we cannot independently shape \( S \) and \( T \). At each frequency \( \omega \),

\[ S(j\omega) = \frac{1}{1 + L(j\omega)}, \qquad T(j\omega) = \frac{L(j\omega)}{1 + L(j\omega)}. \]

If we enforce strong disturbance rejection at low frequency by making \( |L(j\omega)| \) very large, then \( |S(j\omega)| \approx |1/L(j\omega)| \) becomes very small, but \( |T(j\omega)| \approx 1 \). At high frequency, to prevent noise amplification and to maintain robust stability under unmodeled high-frequency dynamics, we usually design \( |L(j\omega)| \ll 1 \), giving \( |T(j\omega)| \approx |L(j\omega)| \) small and \( |S(j\omega)| \approx 1 \).

The Bode integral constraint for a stable, minimum-phase plant (reviewed qualitatively in Chapter 22) can be written in the form

\[ \int_{0}^{\infty} \log |S(j\omega)| \,\mathrm{d}\omega = \pi \sum_{p_i \in \mathbb{C}_{\text{unstable}}} \operatorname{Re}(p_i), \]

where the sum is over open-loop unstable poles \( p_i \). This integral identity shows that any reduction of \( |S| \) in some frequency bands must be compensated by increases elsewhere, which fundamentally limits robust performance, especially for plants with open-loop unstable poles.

In practice, we proceed by:

1. Choosing performance weights \( W_P \) and \( W_N \).
2. Choosing an uncertainty weight \( W_\Delta \).
3. Designing \( C(s) \) (via Bode/Root Locus/Nichols methods).
4. Checking frequency inequalities and iterating.

We illustrate numerical evaluation of \( S(j\omega) \), \( T(j\omega) \), and the weighted inequalities for a second-order plant, representative of a robot joint or motor axis:

\[ P(s) = \frac{1}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \qquad C(s) = K \frac{s + z}{s}. \]

We choose simple performance and uncertainty weights:

\[ W_P(s) = \frac{s/M_P + \omega_P}{s + \omega_P A_P}, \quad W_N(s) = \frac{s/M_N + \omega_N}{s + \omega_N A_N}, \quad W_\Delta(s) = \frac{s/\alpha + \omega_\Delta}{s + \omega_\Delta}, \]

with design constants \( M_P, A_P, M_N, A_N, \alpha \). The following Python code (using python-control) evaluates the frequency inequalities and prints the worst-case margins.

import numpy as np
import control  # python-control library, often used in robotics & mechatronics

# Plant P(s) = 1 / (s^2 + 2*zeta*wn*s + wn^2)
zeta = 0.7
wn   = 10.0
s = control.TransferFunction([1, 0], [0, 1])  # s variable
P = 1 / (s**2 + 2*zeta*wn*s + wn**2)

# Lead-lag type controller C(s) = K * (s + z) / s
K = 20.0
z = 2.0
C = K * (s + z) / s

# Loop L(s), sensitivity S(s), complementary sensitivity T(s)
L = C * P
S = 1 / (1 + L)
T = L / (1 + L)

# Performance and uncertainty weighting functions
M_P, A_P, wP = 1.5, 1e-3, 1.0   # low-freq perf weight
M_N, A_N, wN = 2.0, 1e-3, 50.0  # high-freq noise weight
alpha, wD    = 1.5, 30.0        # uncertainty weight

W_P = (s/M_P + wP) / (s + wP*A_P)
W_N = (s/M_N + wN) / (s + wN*A_N)
W_D = (s/alpha + wD) / (s + wD)

# Frequency grid (rad/s)
w = np.logspace(-2, 3, 500)

# Frequency responses
_, S_mag, _  = control.bode(S,  w, Plot=False)
_, T_mag, _  = control.bode(T,  w, Plot=False)
_, WP_mag, _ = control.bode(W_P, w, Plot=False)
_, WN_mag, _ = control.bode(W_N, w, Plot=False)
_, WD_mag, _ = control.bode(W_D, w, Plot=False)

# Pointwise robustness & performance checks
perf_metric   = WP_mag * S_mag          # |W_P S|
noise_metric  = WN_mag * T_mag          # |W_N T|
robust_metric = WD_mag * T_mag          # |W_D T|
combined      = perf_metric + robust_metric

print("max |W_P(jw) S(jw)|      =", np.max(perf_metric))
print("max |W_N(jw) T(jw)|      =", np.max(noise_metric))
print("max |W_D(jw) T(jw)|      =", np.max(robust_metric))
print("max (|W_P S| + |W_D T|)  =", np.max(combined))

# In a robotics context, P(s) could be a linearized joint or axis model
# obtained from a more complex multi-DOF model using robotics toolboxes
# (e.g. roboticstoolbox-python) and then reduced to a SISO transfer function.
      

In a robotics setting, one typically obtains \( P(s) \) by linearizing a joint or axis dynamic model (e.g., from a robotics toolbox) around an operating point, then performing robust performance checks as above for each axis.

C++ is widely used in robotics (e.g., in ROS control). Below is a simplified example that evaluates \( |W_P(j\omega) S(j\omega)| \) and \( |W_\Delta(j\omega) T(j\omega)| \) for a low-order plant/controller, using a basic complex-number implementation and std::vector<double>. In practice, linear control utilities are often embedded in ROS packages such as control_toolbox.

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

using cd = std::complex<double>;

// Evaluate P(jw) = 1 / (jw^2 + 2*zeta*wn*jw + wn^2)
cd Pjw(double w, double zeta, double wn) {
    cd jw(0.0, w);
    cd denom = jw * jw + cd(2.0 * zeta * wn, 0.0) * jw + cd(wn * wn, 0.0);
    return cd(1.0, 0.0) / denom;
}

// Controller C(s) = K (s + z) / s evaluated at s = jw
cd Cjw(double w, double K, double z) {
    cd jw(0.0, w);
    return K * (jw + cd(z, 0.0)) / jw;
}

// First-order performance weight W_P(s) = (s/M + wp) / (s + wp*A)
cd WPjw(double w, double M, double A, double wp) {
    cd jw(0.0, w);
    return (jw / M + cd(wp, 0.0)) / (jw + cd(wp * A, 0.0));
}

// Multiplicative uncertainty weight W_D(s) = (s/alpha + wD) / (s + wD)
cd WDjw(double w, double alpha, double wD) {
    cd jw(0.0, w);
    return (jw / alpha + cd(wD, 0.0)) / (jw + cd(wD, 0.0));
}

int main() {
    double zeta = 0.7, wn = 10.0;
    double K = 20.0, z = 2.0;
    double M_P = 1.5, A_P = 1e-3, wP = 1.0;
    double alpha = 1.5, wD = 30.0;

    std::vector<double> wgrid;
    for (int i = 0; i <= 500; ++i) {
        double frac = static_cast<double>(i) / 500.0;
        double w = std::pow(10.0, -2.0 + 5.0 * frac); // 1e-2 to 1e3
        wgrid.push_back(w);
    }

    double max_WP_S = 0.0;
    double max_WD_T = 0.0;

    for (double w : wgrid) {
        cd P = Pjw(w, zeta, wn);
        cd C = Cjw(w, K, z);
        cd L = C * P;
        cd S = cd(1.0, 0.0) / (cd(1.0, 0.0) + L);
        cd T = L / (cd(1.0, 0.0) + L);

        cd WP = WPjw(w, M_P, A_P, wP);
        cd WD = WDjw(w, alpha, wD);

        double WP_S = std::abs(WP * S);
        double WD_T = std::abs(WD * T);

        if (WP_S > max_WP_S) max_WP_S = WP_S;
        if (WD_T > max_WD_T) max_WD_T = WD_T;
    }

    std::cout << "max |W_P(jw) S(jw)| = " << max_WP_S << std::endl;
    std::cout << "max |W_D(jw) T(jw)| = " << max_WD_T << std::endl;
    return 0;
}
      

This computation can be integrated into a robotics control stack to verify that joint or end-effector controllers meet specified robust performance margins before deployment.

Java is used in robotics platforms like FIRST Robotics (WPILib). Below is a compact example of evaluating \( S(j\omega) \) and \( T(j\omega) \) for a simple plant/controller, using a small complex-number helper class. In an industrial setting, linear analysis utilities are often wrapped inside higher-level robot libraries, but the core computations remain the same.

public final class Complex {
    public final double re, im;
    public Complex(double re, double im) { this.re = re; this.im = im; }
    public Complex add(Complex o) { return new Complex(re + o.re, im + o.im); }
    public Complex sub(Complex o) { return new Complex(re - o.re, im - o.im); }
    public Complex mul(Complex o) {
        return new Complex(re * o.re - im * o.im, re * o.im + im * o.re);
    }
    public Complex div(Complex o) {
        double den = o.re * o.re + o.im * o.im;
        return new Complex((re * o.re + im * o.im) / den,
                           (im * o.re - re * o.im) / den);
    }
    public double abs() { return Math.hypot(re, im); }
    public static final Complex ONE = new Complex(1.0, 0.0);
}

// Example: evaluate S(jw), T(jw) on a grid
public class RobustPerfCheck {

    static Complex Pjw(double w, double zeta, double wn) {
        Complex jw = new Complex(0.0, w);
        Complex denom = jw.mul(jw)
            .add(new Complex(2.0 * zeta * wn, 0.0).mul(jw))
            .add(new Complex(wn * wn, 0.0));
        return Complex.ONE.div(denom);
    }

    static Complex Cjw(double w, double K, double z) {
        Complex jw = new Complex(0.0, w);
        return new Complex(K, 0.0)
            .mul(jw.add(new Complex(z, 0.0)))
            .div(jw);
    }

    public static void main(String[] args) {
        double zeta = 0.7, wn = 10.0;
        double K = 20.0, z = 2.0;

        double maxS = 0.0, maxT = 0.0;
        for (int i = 0; i <= 500; ++i) {
            double frac = i / 500.0;
            double w = Math.pow(10.0, -2.0 + 5.0 * frac); // 1e-2..1e3

            Complex P = Pjw(w, zeta, wn);
            Complex C = Cjw(w, K, z);
            Complex L = C.mul(P);
            Complex denom = Complex.ONE.add(L);
            Complex S = Complex.ONE.div(denom);
            Complex T = L.div(denom);

            maxS = Math.max(maxS, S.abs());
            maxT = Math.max(maxT, T.abs());
        }

        System.out.println("max |S(jw)| = " + maxS);
        System.out.println("max |T(jw)| = " + maxT);
        // These can be compared with target bounds implied by weights W_P, W_N, W_D.
    }
}
      

In a Java-based robot controller (e.g., WPILib), such computations can be used offline to validate that a PID or lead-lag controller meets robust performance bounds for the robot mechanism’s linearized dynamics.

MATLAB/Simulink and Mathematica provide convenient high-level tools for robust performance evaluation in linear control and robotics.

8.1 MATLAB/Simulink

% Second-order plant and lead controller
zeta = 0.7; wn = 10;
s = tf('s');
P = 1 / (s^2 + 2*zeta*wn*s + wn^2);
K = 20; z = 2;
C = K * (s + z) / s;

L = C*P;
S = 1/(1+L);
T = L/(1+L);

% Weights
M_P = 1.5; A_P = 1e-3; wP = 1;
M_N = 2.0; A_N = 1e-3; wN = 50;
alpha = 1.5; wD = 30;

W_P = (s/M_P + wP) / (s + wP*A_P);
W_N = (s/M_N + wN) / (s + wN*A_N);
W_D = (s/alpha + wD) / (s + wD);

w = logspace(-2,3,500);
[magS,~,~]  = bode(S,  w);
[magT,~,~]  = bode(T,  w);
[magWP,~,~] = bode(W_P,w);
[magWN,~,~] = bode(W_N,w);
[magWD,~,~] = bode(W_D,w);

magS  = squeeze(magS);
magT  = squeeze(magT);
magWP = squeeze(magWP);
magWN = squeeze(magWN);
magWD = squeeze(magWD);

perfMetric   = magWP .* magS;
noiseMetric  = magWN .* magT;
robustMetric = magWD .* magT;
combined     = perfMetric + robustMetric;

fprintf('max |W_P S|      = %.3f\n', max(perfMetric));
fprintf('max |W_N T|      = %.3f\n', max(noiseMetric));
fprintf('max |W_D T|      = %.3f\n', max(robustMetric));
fprintf('max (|W_P S| + |W_D T|) = %.3f\n', max(combined));

% Simulink: represent P and C as blocks, inject disturbances and noise,
% and then log y,u to verify time-domain performance under worst-case signals.
      

8.2 Wolfram Mathematica

(* Plant and controller *)
zeta = 0.7; wn = 10.0;
s = LaplaceTransformVariable[];
P[s_] := 1/(s^2 + 2 zeta wn s + wn^2);
K = 20.0; zc = 2.0;
C[s_] := K (s + zc)/s;

L[s_] := C[s] P[s];
S[s_] := 1/(1 + L[s]);
T[s_] := L[s]/(1 + L[s]);

(* Weights *)
M_P = 1.5; A_P = 1.*10^-3; wP = 1.0;
M_N = 2.0; A_N = 1.*10^-3; wN = 50.0;
alpha = 1.5; wD = 30.0;

W_P[s_] := (s/M_P + wP)/(s + wP A_P);
W_N[s_] := (s/M_N + wN)/(s + wN A_N);
W_D[s_] := (s/alpha + wD)/(s + wD);

wgrid = LogSpace[-2, 3, 500];

mag[f_] := Abs[f /. s -> I #] & /@ wgrid;

magS  = mag[S[s]];
magT  = mag[T[s]];
magWP = mag[W_P[s]];
magWN = mag[W_N[s]];
magWD = mag[W_D[s]];

perfMetric   = magWP magS;
noiseMetric  = magWN magT;
robustMetric = magWD magT;
combined     = perfMetric + robustMetric;

Max[perfMetric]
Max[noiseMetric]
Max[robustMetric]
Max[combined]

(* Visualization *)
ListLogLinearPlot[
 {
  Transpose[{wgrid, perfMetric}],
  Transpose[{wgrid, robustMetric}]
 },
 Joined -> True,
 PlotLegends -> {"|W_P S|", "|W_D T|"},
 Frame -> True,
 FrameLabel -> {"w (rad/s)", "Magnitude"}
]
      

These tools allow rapid exploration of controller designs and robust performance trade-offs for linearized robotic subsystems (e.g., joints, end-effectors, or mobile bases).

Problem 1 (Sensitivity-Based Disturbance Rejection): Consider a stable loop with plant \( P(s) \), loop transfer \( L(s) = C(s)P(s) \), and sensitivity \( S(s) = 1/(1+L(s)) \). A step disturbance \( d(t) = D_0 u(t) \) (unit step \( u(t) \)) is injected at the plant input. Show that the steady-state output change \( \Delta y(\infty) \) is

\[ \Delta y(\infty) = D_0 P(0) S(0), \]

assuming all relevant steady-state values exist.

Solution:

The disturbance-to-output transfer function is \( G_{dy}(s) = P(s)S(s) \). For a step disturbance \( d(s) = D_0/s \), the output is

\[ y_d(s) = G_{dy}(s) d(s) = \frac{D_0}{s} P(s) S(s). \]

By the final value theorem (for a stable closed loop),

\[ \Delta y(\infty) = \lim_{t \rightarrow \infty} y_d(t) = \lim_{s \rightarrow 0} s y_d(s) = \lim_{s \rightarrow 0} D_0 P(s) S(s) = D_0 P(0) S(0). \]

Thus, reducing \( |S(0)| \) (while \( P(0) \) is fixed) directly reduces the steady-state disturbance effect.

Problem 2 (Noise Attenuation via T): For the same loop, suppose measurement noise \( n(t) \) enters just before the sensor. Derive the noise-to-output transfer function and explain why making \( |T(j\omega)| \) small at high frequencies is desirable.

Solution:

With unity feedback, the measurement is \( y(t) + n(t) \). The error is \( e(t) = r(t) - y(t) - n(t) \). Taking Laplace transforms and solving the block algebra yields the noise-to-output transfer function

\[ G_{ny}(s) = \frac{Y(s)}{N(s)} = - T(s). \]

Hence, the noise spectrum is shaped by \( T(j\omega) \). If \( |T(j\omega)| \) is small at high frequency, then high-frequency noise (where sensors are often noisy) is strongly attenuated at the plant output, improving robust performance with respect to measurement noise.

Problem 3 (Simple Robust Stability Condition): Assume multiplicative output uncertainty

\[ \tilde{P}(s) = P(s)\bigl(1 + W_\Delta(s)\Delta(s)\bigr), \quad |\Delta(j\omega)| \leq 1. \]

Show that a sufficient condition for robust stability is

\[ |W_\Delta(j\omega) T(j\omega)| < 1 \quad \text{for all } \omega, \]

by viewing the uncertainty as feedback interconnection of \( W_\Delta T \) and \( \Delta \).

Solution:

Rewrite the closed loop as a nominal loop (with plant \( P \)) plus an additional feedback loop where \( \Delta \) is a unit-bounded gain. The effective loop transfer of this inner loop is \( W_\Delta(s) T(s) \). For a scalar loop with uncertainty \( \Delta \) satisfying \( |\Delta(j\omega)| \leq 1 \), a sufficient (small-gain) condition for stability is that the magnitude of the product be less than one:

\[ |W_\Delta(j\omega) T(j\omega)| \cdot |\Delta(j\omega)| < 1 \quad \Rightarrow \quad |W_\Delta(j\omega) T(j\omega)| < 1. \]

If this holds for all \( \omega \), then the inner uncertainty loop is stable for all admissible \( \Delta \), and thus the overall system is robustly stable.

Problem 4 (Combined Robust Performance Inequality): Let performance weight \( W_P(s) \) and uncertainty weight \( W_\Delta(s) \) be given. Show that the inequality

\[ |W_P(j\omega) S(j\omega)| + |W_\Delta(j\omega) T(j\omega)| \leq 1 \quad \text{for all } \omega \]

implies both \( |W_P(j\omega) S(j\omega)| \leq 1 \) and \( |W_\Delta(j\omega) T(j\omega)| \leq 1 \) for all \( \omega \).

Solution:

Since both terms are nonnegative, the inequality \( a(\omega) + b(\omega) \leq 1 \) implies \( a(\omega) \leq 1 \) and \( b(\omega) \leq 1 \) separately. With \( a(\omega) = |W_P(j\omega) S(j\omega)| \) and \( b(\omega) = |W_\Delta(j\omega) T(j\omega)| \), the statement follows directly. Thus, this combined inequality is a conservative way to enforce both performance and robust-stability bounds simultaneously.

Problem 5 (Design Workflow Sketch): Outline a design workflow that uses \( S \), \( T \), and weighting functions to achieve robust performance for a SISO servo axis, starting from time-domain tracking and disturbance specifications.

Solution (flow):

flowchart TD
  R["Time-domain specs (overshoot, settling, disturbance rejection)"]
    --> F["Translate to freq specs for S(jw), T(jw)"]
  F --> W["Choose weights W_P, W_N (performance) and W_Delta (uncertainty)"]
  W --> D["Design controller C(s) via Bode/Root-Locus/Nichols"]
  D --> E["Evaluate S,T and weighted magnitudes"]
  E --> C1["Check: |W_P S|, |W_N T|, |W_Delta T| constraints"]
  C1 --> OK["If satisfied: accept design"]
  C1 --> ITER["If violated: adjust C(s) or weights and repeat"]
        

In this lesson we characterized robust performance of SISO feedback systems using the sensitivity function \( S(s) \) and complementary sensitivity function \( T(s) \). We expressed tracking, disturbance rejection, and noise attenuation requirements as frequency-domain inequalities on \( |S(j\omega)| \) and \( |T(j\omega)| \), and introduced performance and uncertainty weights \( W_P \), \( W_N \), and \( W_\Delta \). By combining these with classical uncertainty models (e.g., multiplicative output uncertainty), we obtained sufficient robust performance conditions such as \( |W_\Delta(j\omega) T(j\omega)| < 1 \) and \( |W_P(j\omega) S(j\omega)| + |W_\Delta(j\omega) T(j\omega)| \leq 1 \). We illustrated how to numerically evaluate these conditions in Python, C++, Java, MATLAB/Simulink, and Mathematica, which is particularly relevant for robotics applications where linear controllers must maintain performance under significant uncertainty and disturbances.