Consider a unity-feedback loop with plant \( G(s) \), controller \( C(s) \), and open-loop transfer function \( L(s) = C(s)G(s) \). With reference \( R(s) \), output disturbance \( D_y(s) \) (added at the plant output), and measurement noise \( N(s) \) (added at the sensor), the standard sensitivity and complementary sensitivity functions are

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

and they satisfy the fundamental identity

\[ S(s) + T(s) = 1. \]

For the configuration described above, the transfer functions from exogenous inputs to the output \( Y(s) \) are

\[ \begin{aligned} Y(s) &= T(s) R(s) + S(s) D_y(s) - T(s) N(s), \\ E(s) &= R(s) - Y(s) = S(s) R(s) - S(s) D_y(s) + S(s) N(s), \end{aligned} \]

where \( E(s) \) is the error signal. These expressions show that:

• Reference tracking: governed by \( T(s) \) via \( Y(s) = T(s)R(s) + \dots \).
• Output disturbance rejection: governed by \( S(s) \) via \( Y(s) = S(s)D_y(s) + \dots \).
• Sensor noise transmission: governed by \( T(s) \) via the term \( -T(s)N(s) \).

Thus, once a controller \( C(s) \) has been designed (via root locus, Bode, PID tuning, etc.), the primary way to evaluate and refine the design is through the shapes of \( S(s) \) and \( T(s) \) in frequency.

We analyze the closed-loop behaviour in the frequency domain by evaluating \( S(\mathrm{j}\omega) \) and \( T(\mathrm{j}\omega) \). Using the identity \( T(\mathrm{j}\omega) = 1 - S(\mathrm{j}\omega) \), we can characterize three canonical bands:

• Low frequencies (tracking/regulation band): We want \( |T(\mathrm{j}\omega)| \approx 1 \) and \( |S(\mathrm{j}\omega)| \ll 1 \), so that the output follows the reference and rejects slowly varying disturbances.
• Mid frequencies (crossover region): The loop transitions from high gain to low gain. Here, peaks in \( |S(\mathrm{j}\omega)| \) indicate sensitivity to modelling errors and external disturbances; peaks in \( |T(\mathrm{j}\omega)| \) correlate with overshoot and resonant behaviour.
• High frequencies (noise band): We want \( |T(\mathrm{j}\omega)| \ll 1 \) so that measurement noise is not amplified, which implies \( |S(\mathrm{j}\omega)| \approx 1 \) in this band.

These qualitative requirements can be summarized as the following mapping from design goals to desired shapes of \( S \) and \( T \).

flowchart TD
  A["Design goals"] --> B["Low-frequency \ntracking/regulation"]
  A --> C["Mid-frequency \nrobustness and damping"]
  A --> D["High-frequency \nnoise attenuation"]
  B --> B1["Require: |S(jw)| small, \n|T(jw)| approx 1"]
  C --> C1["Avoid large peak of |S(jw)|, \nmoderate |T(jw)|"]
  D --> D1["Require: |T(jw)| small (roll-off), \n|S(jw)| approx 1"]
        

The precise numerical targets depend on the application, but the qualitative pattern — small \( |S| \) at low frequencies, small \( |T| \) at high frequencies, and moderate peaks in the crossover region — is universal in linear feedback design.

For quantitative assessment, we often use scalar indices derived from \( S(\mathrm{j}\omega) \) and \( T(\mathrm{j}\omega) \). For a SISO loop, define

\[ M_S = \sup_{\omega \in \mathbb{R}} |S(\mathrm{j}\omega)|, \qquad M_T = \sup_{\omega \in \mathbb{R}} |T(\mathrm{j}\omega)| . \]

Interpretation of \( M_S \). A large peak in \( |S| \) indicates that the loop is very sensitive to disturbances and model errors near that frequency. In particular, if the relative modelling error satisfies

\[ \left| \frac{\Delta G(\mathrm{j}\omega)}{G(\mathrm{j}\omega)} \right| \leq \varepsilon \quad \text{for all } \omega, \]

then a classical bound for closed-loop robust stability is

\[ \varepsilon M_S < 1. \]

Thus, if we anticipate up to \( 20\% \) relative plant uncertainty (\( \varepsilon = 0.2 \)), requiring \( M_S \lesssim 1.5 \) yields a safety margin; this is a typical rule-of-thumb in practice.

Interpretation of \( M_T \). The peak of \( |T| \) is strongly related to resonance and overshoot. For many lightly damped second-order closed-loop systems, \( M_T \) correlates with the maximum overshoot in step response. Qualitatively:

• \( M_T \approx 1 \): non-oscillatory, well-damped transient.
• \( 1 < M_T \lesssim 1.5 \): moderate overshoot (10–20% typical).
• \( M_T \gg 1.5 \): significant resonance, large overshoot, poor robustness.

Bandwidth. The approximate closed-loop bandwidth \( \omega_b \) is often defined as the frequency where

\[ |T(\mathrm{j}\omega_b)| = \frac{1}{\sqrt{2}} \approx -3\ \text{dB}. \]

Faster tracking and disturbance rejection require larger \( \omega_b \), but increasing \( \omega_b \) tends to increase \( M_S \) and \( M_T \), illustrating the fundamental trade-offs.

Once a nominal controller \( C(s) \) is obtained (for example from PID tuning or loop shaping), we can use the following iterative workflow to refine the design:

1. Compute \( S(s) \) and \( T(s) \) from \( C(s) \) and \( G(s) \).
2. Plot Bode magnitudes \( |S(\mathrm{j}\omega)| \) and \( |T(\mathrm{j}\omega)| \).
3. Check low-frequency \( |S| \) for tracking and disturbance rejection.
4. Check peaks of \( |S| \) and \( |T| \) in the crossover region (robustness and damping).
5. Check high-frequency \( |T| \) for sensor noise attenuation.
6. Modify \( C(s) \) (gain, poles/zeros, filters) and repeat until specifications on \( M_S \), \( M_T \), and bandwidth are satisfied.

The loop can be expressed as the following flow:

flowchart TD
  S0["Start with nominal C(s)"] --> S1["Compute S(s)=1/(1+L) and T(s)=L/(1+L)"]
  S1 --> S2["Plot |S(jw)|, |T(jw)|"]
  S2 --> S3["Low freq: is |S(jw)| \nsmall enough?"]
  S3 -->|no| A1["Increase low-freq loop \ngain or add integrator"]
  A1 --> S1
  S3 -->|yes| S4["Mid freq: peaks of \n|S(jw)|, |T(jw)| acceptable?"]
  S4 -->|no| A2["Adjust zeros/poles \n(lead/lag), tune damping"]
  A2 --> S1
  S4 -->|yes| S5["High freq: is |T(jw)| \nsufficiently small?"]
  S5 -->|no| A3["Add roll-off / filters, \nreduce high-freq gain"]
  A3 --> S1
  S5 -->|yes| DONE["Controller accepted"]
        

This diagram is generic and can be implemented with any software tool capable of computing \( S \) and \( T \). The practical steps differ slightly among Python, C++, Java, MATLAB/Simulink, and Mathematica, but the logic remains identical.

Consider a simple plant (e.g., position of a DC motor with friction approximated as a double integrator with viscous damping)

\[ G(s) = \frac{1}{s(s + 1)}. \]

We design a PI controller

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

The open-loop transfer function is

\[ L(s) = C(s)G(s) = \frac{K_p s + K_i}{s} \cdot \frac{1}{s(s+1)} = \frac{K_p s + K_i}{s^2 (s+1)}. \]

Then

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

The closed-loop characteristic polynomial is

\[ s^2 (s+1) + K_p s + K_i = s^3 + s^2 + K_p s + K_i. \]

For a given pair \( (K_p, K_i) \), we can:

• Check stability using Routh–Hurwitz on the coefficients \( 1, 1, K_p, K_i \).
• Plot \( |S(\mathrm{j}\omega)| \) and \( |T(\mathrm{j}\omega)| \) to inspect bandwidth and peaks.
• Adjust \( K_p \) (primarily affecting damping and bandwidth) and \( K_i \) (primarily affecting low-frequency error and disturbance rejection) according to the workflow in Section 4.

For example, increasing \( K_i \) reduces low-frequency \( |S(\mathrm{j}\omega)| \), improving steady-state error and slow disturbance rejection, but it also increases low-frequency loop gain and can raise the peak of \( |T(\mathrm{j}\omega)| \), leading to more overshoot. The trade-off is visible directly on the Bode plots of \( S \) and \( T \).

In Python, the python-control library provides convenient functions for transfer functions and feedback. In robotics, we can combine this with roboticstoolbox-python to obtain a linear joint model and analyze its sensitivity functions.

import numpy as np
import control as ctl
# If available: from roboticstoolbox import DHRobot, RevoluteDH

# Example plant: G(s) = 1 / (s (s + 1))
s = ctl.TransferFunction.s
G = 1 / (s * (s + 1))

# PI controller: C(s) = Kp + Ki / s
Kp = 4.0
Ki = 3.0
C = Kp + Ki / s

L = C * G                 # open-loop transfer function
S = 1 / (1 + L)           # sensitivity
T = L / (1 + L)           # complementary sensitivity

# Frequency grid for analysis
w = np.logspace(-2, 2, 400)
magS, phaseS, _ = ctl.bode(S, w, Plot=False)
magT, phaseT, _ = ctl.bode(T, w, Plot=False)

Ms = np.max(magS)
Mt = np.max(magT)
print("M_S =", Ms, "M_T =", Mt)

# Simple tuning loop: increase Kp until M_S exceeds a limit
Ms_target = 1.8
for Kp_test in np.linspace(1.0, 10.0, 10):
    C_test = Kp_test + Ki / s
    L_test = C_test * G
    S_test = 1 / (1 + L_test)
    magS_test, _, _ = ctl.bode(S_test, w, Plot=False)
    Ms_test = np.max(magS_test)
    if Ms_test > Ms_target:
        print("Kp", Kp_test, "violates M_S > target with M_S =", Ms_test)
        break

# Robotics remark:
# A typical workflow is:
# 1. Use a robotics library to derive or identify a linear joint model G_joint(s).
# 2. Use python-control to form L(s) = C(s) G_joint(s).
# 3. Evaluate S and T as above and adjust controller gains or filters.
      

The same workflow applies when \( G(s) \) is obtained from linearization of a robot joint in a ROS-based stack or from experimental identification. The diagnostics based on \( M_S \), \( M_T \), and bandwidth are independent of the origin of the model.

In embedded or robotics contexts (e.g., ROS control loops), C++ is widely used. We can approximate the frequency response of \( S(\mathrm{j}\omega) \) and \( T(\mathrm{j}\omega) \) numerically. For SISO systems represented as rational functions, complex arithmetic suffices. For multi-axis joints, Eigen matrices can be applied component-wise or to MIMO generalizations later in the curriculum.

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

// Example: G(s) = 1 / (s (s + 1)), C(s) = Kp + Ki / s
// Evaluate S(jw) and T(jw) on a frequency grid

int main() {
    using std::complex;
    using std::cout;
    using std::endl;
    const double Kp = 4.0;
    const double Ki = 3.0;
    const complex<double> j(0.0, 1.0);

    auto G = [&] (complex<double> s) {
        return 1.0 / (s * (s + 1.0));
    };
    auto C = [&] (complex<double> s) {
        return Kp + Ki / s;
    };

    std::vector<double> w;
    for (int k = 0; k <= 400; ++k) {
        double wk = std::pow(10.0, -2.0 + 4.0 * k / 400.0);
        w.push_back(wk);
    }

    double Ms = 0.0;
    double Mt = 0.0;
    for (double wk : w) {
        complex<double> s = j * wk;
        complex<double> L = C(s) * G(s);
        complex<double> S = 1.0 / (1.0 + L);
        complex<double> T = L / (1.0 + L);
        double magS = std::abs(S);
        double magT = std::abs(T);
        if (magS > Ms) Ms = magS;
        if (magT > Mt) Mt = magT;
    }
    cout << "M_S = " << Ms << ", M_T = " << Mt << endl;

    // In a ROS controller, the continuous-time design can be discretized and
    // the same logic applied to the discrete-time sensitivity functions.
    return 0;
}
      

In a ROS setting, Kp and Ki may come from configuration parameters of a joint controller. The code above can be part of an offline analysis tool for verifying that sensitivity peaks do not exceed desired bounds before deploying the controller to the robot.

Java is used in several robotics ecosystems (e.g., mobile robots, FRC, and industrial control platforms). With Apache Commons Math complex numbers, one can perform similar frequency-domain analysis:

import org.apache.commons.math3.complex.Complex;
import java.util.ArrayList;
import java.util.List;

public class STAnalysis {
    private static final double Kp = 4.0;
    private static final double Ki = 3.0;
    private static final Complex j = new Complex(0.0, 1.0);

    static Complex G(Complex s) {
        // G(s) = 1 / (s (s + 1))
        return Complex.ONE.divide(s.multiply(s.add(Complex.ONE)));
    }

    static Complex C(Complex s) {
        // C(s) = Kp + Ki / s
        return new Complex(Kp, 0.0).add(new Complex(Ki, 0.0).divide(s));
    }

    public static void main(String[] args) {
        List<Double> w = new ArrayList<>();
        for (int k = 0; k <= 400; ++k) {
            double wk = Math.pow(10.0, -2.0 + 4.0 * k / 400.0);
            w.add(wk);
        }

        double Ms = 0.0;
        double Mt = 0.0;
        for (double wk : w) {
            Complex s = j.multiply(wk);
            Complex L = C(s).multiply(G(s));
            Complex S = Complex.ONE.divide(Complex.ONE.add(L));
            Complex T = L.divide(Complex.ONE.add(L));
            double magS = S.abs();
            double magT = T.abs();
            Ms = Math.max(Ms, magS);
            Mt = Math.max(Mt, magT);
        }
        System.out.println("M_S = " + Ms + ", M_T = " + Mt);

        // This pattern can be integrated into higher-level Java robotics frameworks
        // for automatic verification of closed-loop designs.
    }
}
      

As in Python and C++, the same pattern is used: define \( G(s) \) and \( C(s) \), form \( L(s) \), then compute \( S \) and \( T \) on a frequency grid and extract key indicators like \( M_S \), \( M_T \), and bandwidth.

MATLAB with the Control System Toolbox is widely used in control and robotics (often together with the Robotics System Toolbox and Simulink). The following script performs analysis similar to the Python and C++ examples:

s = tf('s');
G = 1 / (s * (s + 1));     % plant
Kp = 4; Ki = 3;
C = Kp + Ki / s;           % PI controller

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

w = logspace(-2, 2, 400);
[magS, ~, ~] = bode(S, w);
[magT, ~, ~] = bode(T, w);

magS = squeeze(magS);
magT = squeeze(magT);
Ms = max(magS);
Mt = max(magT);
fprintf('M_S = %g, M_T = %g\n', Ms, Mt);

figure;
bodemag(S, T, w);
legend('S', 'T');
grid on;
title('Sensitivity and Complementary Sensitivity');

% In Simulink:
% - Build a unity-feedback loop with Transfer Fcn blocks for G(s) and C(s).
% - Use "Linear Analysis Tool" or "linmod" to obtain the linear model.
% - Use bode, bodemag, and sigma (for MIMO later) to inspect S and T.
      

In a robotics context, G might be obtained via linearization of a Simulink model of a robot joint using linmod or LinearAnalysisPoint blocks. The same analysis of \( |S| \), \( |T| \), \( M_S \), and \( M_T \) applies directly.

Wolfram Mathematica can handle both symbolic and numeric analysis of \( S \) and \( T \). For the PI-controlled plant above:

(* Define symbolic variables *)
Kp = 4; Ki = 3;

s = ComplexExpand[I*ω]; (* We will substitute s = I ω numerically later *)

(* Transfer functions as TransferFunctionModel *)
G = TransferFunctionModel[1/(s (s + 1)), s];
C = TransferFunctionModel[Kp + Ki/s, s];

L = Series[TransferFunctionExpand[C*G], {s, 0, 0}]; (* Simplify representation *)

S = TransferFunctionModel[1/(1 + L["Function"][s]), s];
T = TransferFunctionModel[L["Function"][s]/(1 + L["Function"][s]), s];

(* Numeric Bode-like plot *)
wlist = LogSpace[-2, 2, 400];
Sresp = Table[Evaluate[S["FrequencyResponse"][I*ω]], {ω, wlist}];
Tresp = Table[Evaluate[T["FrequencyResponse"][I*ω]], {ω, wlist}];

Ms = Max[Abs[Sresp]];
Mt = Max[Abs[Tresp]];
Print["M_S = ", Ms, "  M_T = ", Mt];

ListLogLogPlot[
  {
    Transpose[{wlist, Abs[Sresp]}],
    Transpose[{wlist, Abs[Tresp]}]
  },
  PlotRange -> All,
  PlotLegends -> {"|S(jω)|", "|T(jω)|"},
  GridLines -> Automatic,
  AxesLabel -> {"ω", "Magnitude"}
]
      

Mathematica is particularly useful for symbolic manipulations, such as expressing \( M_S \) as an explicit function of controller parameters in simple cases, which helps in theoretical investigations of trade-offs.

Problem 1 (Low-Frequency Design from a Bound on \( S \)). A unity-feedback loop has open-loop transfer function \( L(s) \). For disturbance rejection at low frequencies, it is required that

\[ |S(\mathrm{j}\omega)| \leq 0.1 \quad \text{for } 0 \leq \omega \leq \omega_0 . \]

Assuming \( L(\mathrm{j}\omega) \) is real and positive for \( 0 \leq \omega \leq \omega_0 \), derive a corresponding inequality on \( L(\mathrm{j}\omega) \) and interpret it.

Solution.

For real, positive \( L(\mathrm{j}\omega) \), we have \( S(\mathrm{j}\omega) = 1 / (1 + L(\mathrm{j}\omega)) \), so

\[ |S(\mathrm{j}\omega)| = \frac{1}{1 + L(\mathrm{j}\omega)}. \]

The requirement \( |S(\mathrm{j}\omega)| \leq 0.1 \) implies

\[ \frac{1}{1 + L(\mathrm{j}\omega)} \leq 0.1 \quad \Rightarrow \quad 1 + L(\mathrm{j}\omega) \geq 10 \quad \Rightarrow \quad L(\mathrm{j}\omega) \geq 9 \]

for all \( 0 \leq \omega \leq \omega_0 \). Thus, in the low-frequency range of interest, the loop must have gain at least \( 9 \) (approximately \( \approx 19\ \mathrm{dB} \)). This connects a specification on the sensitivity directly to a design requirement on the loop gain.

Problem 2 (Peak Sensitivity and Relative Plant Error). Suppose the relative error between the true plant \( G_{\text{true}}(s) \) and the nominal model \( G(s) \) is bounded by

\[ \left| \frac{G_{\text{true}}(\mathrm{j}\omega) - G(\mathrm{j}\omega)}{G(\mathrm{j}\omega)} \right| \leq \varepsilon \quad \text{for all } \omega. \]

Show that if \( \varepsilon M_S < 1 \), the closed-loop system cannot lose stability under this modelling error (within linearized analysis). Give the main idea of the proof.

Solution.

Let \( \Delta(\mathrm{j}\omega) \) denote the normalized error:

\[ G_{\text{true}}(\mathrm{j}\omega) = \bigl(1 + \Delta(\mathrm{j}\omega)\bigr) G(\mathrm{j}\omega), \qquad |\Delta(\mathrm{j}\omega)| \leq \varepsilon. \]

The true open-loop transfer function is \( L_{\text{true}}(s) = C(s) G_{\text{true}}(s) = (1 + \Delta(s)) L(s) \). The closed-loop characteristic equation is \( 1 + L_{\text{true}}(s) = 0 \), i.e.

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

In normalized form this is

\[ \bigl(1 + L(s)\bigr) \Bigl(1 + \Delta(s) \frac{L(s)}{1 + L(s)} \Bigr) = 0 \quad \Rightarrow \quad 1 + \Delta(s) T(s) = 0 \]

on the Nyquist contour. Because \( S(s) = 1 / (1 + L(s)) \), the same analysis can be expressed using \( S \) by noting that the perturbed loop is stable if

\[ \left| \Delta(\mathrm{j}\omega) \right| \cdot \left| T(\mathrm{j}\omega) \right| < 1 \quad \text{for all } \omega. \]

For relative error, a classical bound (which can be derived using small-gain arguments with \( S \)) gives the sufficient condition

\[ \varepsilon M_S < 1. \]

The detailed proof uses the small-gain theorem and the representation of the perturbed loop as a feedback interconnection between the nominal loop and the uncertainty \( \Delta \). Intuitively, small \( M_S \) reduces the amplification of modelling errors, guaranteeing that the feedback of \( \Delta \) cannot destabilize the loop.

Problem 3 (Shape Constraints and Bandwidth). A designer wants:

• Tracking of references up to \( \omega_{\text{tr}} \) with at most 2% steady-state error,
• Disturbance rejection for disturbances up to \( \omega_{\text{dist}} \) with attenuation factor at least 10,
• Noise attenuation for measurement noise above \( \omega_{\text{noise}} \) with attenuation factor at least 10.

Express these three qualitative requirements as conditions on \( |S(\mathrm{j}\omega)| \) and \( |T(\mathrm{j}\omega)| \) over frequency bands.

Solution.

For 2% steady-state error, the DC gain of \( T(s) \) should be close to 1, and for low frequencies \( [0, \omega_{\text{tr}}] \), we require:

\[ |S(\mathrm{j}\omega)| \ll 1, \quad |T(\mathrm{j}\omega)| \approx 1 \quad \text{for } 0 \leq \omega \leq \omega_{\text{tr}}. \]

For disturbance rejection at the output with attenuation factor 10, the disturbance transfer is \( Y(s) = S(s) D_y(s) \). Hence, for \( 0 \leq \omega \leq \omega_{\text{dist}} \),

\[ |S(\mathrm{j}\omega)| \leq 0.1 \quad \text{for } 0 \leq \omega \leq \omega_{\text{dist}}. \]

For measurement noise attenuation, the noise transfer is \( -T(s)N(s) \), so attenuation factor 10 above \( \omega_{\text{noise}} \) demands

\[ |T(\mathrm{j}\omega)| \leq 0.1 \quad \text{for } \omega \geq \omega_{\text{noise}}. \]

Combining these, the desired shape is: \( |S| \) small on low and disturbance frequencies, and \( |T| \) small on high frequencies, with a smooth transition (crossover) somewhere between \( \omega_{\text{dist}} \) and \( \omega_{\text{noise}} \).

Problem 4 (Relating \( M_T \) to Time-Domain Overshoot). Consider a closed-loop system whose dominant dynamics can be approximated by a second-order system with damping ratio \( \zeta \) and natural frequency \( \omega_n \). Argue qualitatively why a large \( M_T \) corresponds to a large overshoot in the step response.

Solution.

For a standard second-order system

\[ T(s) = \frac{\omega_n^2}{s^2 + 2 \zeta \omega_n s + \omega_n^2}, \]

the magnitude \( |T(\mathrm{j}\omega)| \) has a resonant peak near \( \omega \approx \omega_n \sqrt{1 - 2 \zeta^2} \) for small \( \zeta \). The peak height increases as \( \zeta \) decreases. At the same time, the step response overshoot increases as \( \zeta \) decreases. Thus, \( M_T \) and overshoot are correlated: both are driven by underdamping of the closed-loop poles.

In more general systems, if the closed-loop poles are lightly damped, we observe a resonance in \( |T| \), which appears as a peak \( M_T \), and this resonance manifests in the time domain as oscillatory behaviour and overshoot.

Problem 5 (Controller Refinement Using S and T for a DC Motor Joint). A robotics engineer models a joint as \( G(s) = 10 / (0.1 s + 1) \) (first-order approximation) and uses a PI controller. The current design yields \( M_S = 2.5 \) and \( M_T = 1.8 \), and sensor noise at high frequencies is problematic. Suggest qualitative adjustments to the controller using the S/T-based workflow.

Solution.

Since both \( M_S = 2.5 \) and \( M_T = 1.8 \) are relatively large, the loop is somewhat fragile and resonant:

• To reduce \( M_S \), the engineer can slightly reduce the proportional gain \( K_p \) or modify the phase characteristics (e.g., add a lead compensator) to improve damping without increasing loop gain excessively.
• To reduce \( M_T \) and improve noise attenuation, additional high-frequency roll-off can be added, for example by including a first-order low-pass filter in the controller (filtered derivative or explicit output filter).
• The tuning should be iterated according to the flow of Section 4: recompute \( S \) and \( T \), verify that the low-frequency \( |S| \) remains acceptable for tracking and disturbance rejection, and confirm that \( M_S \) and \( M_T \) have decreased while high-frequency \( |T| \) is sufficiently small.

In robotics, this process is often repeated for several operating points (e.g., different arm configurations) to ensure that sensitivity and complementary sensitivity remain within acceptable bounds across the workspace.

In this lesson we have used the sensitivity function \( S(s) \) and the complementary sensitivity function \( T(s) \) as central tools for interpreting and refining controller designs. Starting from the closed-loop signal relations, we connected \( S \) and \( T \) to tracking, disturbance rejection, and noise attenuation, and we introduced scalar indices \( M_S \) and \( M_T \) that summarize robustness and transient behaviour.

The shape of \( |S(\mathrm{j}\omega)| \) and \( |T(\mathrm{j}\omega)| \) across frequency bands provides a compact representation of closed-loop trade-offs: small \( |S| \) at low frequency for performance, small \( |T| \) at high frequency for noise attenuation, and moderate peaks in the crossover region to balance damping and robustness. We formalized an iterative workflow for controller refinement and showed how to implement it in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, with remarks aimed at robotic joint control.

These concepts will be essential in the next chapter, where explicit models of uncertainty are introduced and \( S \) and \( T \) become the main objects in robust stability and robust performance analysis.