Consider the standard unity-feedback configuration already used in earlier chapters: a controller \( C(s) \) drives a plant \( P(s) \), and the measured output is compared with the reference. In Lesson 1 of this chapter you introduced the sensitivity function \( S(s) \), which quantifies how disturbances and model perturbations affect the closed-loop system.

In this lesson we focus on the complementary sensitivity function \( T(s) \). For a unity-feedback loop with loop transfer \( L(s) = C(s)P(s) \), we will show that

\[ T(s) \;=\; \frac{L(s)}{1 + L(s)}. \]

When the loop is internally stable, \( T(s) \) is a stable, proper transfer function. It plays two central roles:

• It is the closed-loop transfer from reference \( r(s) \) to output \( y(s) \): \( y(s)/r(s) = T(s) \) (for zero disturbances and noise).
• For additive sensor noise \( n(s) \) at the measurement, the transfer from noise to output is \( y(s)/n(s) = -T(s) \) (for zero reference and other disturbances).

Thus the same function \( T(s) \) that provides good tracking of references also shapes how sensor noise is transmitted to the output. This dual role already hints at design compromises that will be explored in later lessons.

flowchart TD
  R["Reference r"] --> E["Summing junction: e = r - y_meas"]
  N["Sensor noise n"] --> YMEAS["Measured output y_meas = y + n"]
  Y["Output y"] --> YMEAS
  YMEAS --> E
  E --> C["Controller C(s)"]
  C --> P["Plant P(s)"]
  P --> Y
        

We assume a continuous-time, single-input single-output (SISO) unity-feedback loop. The reference is \( r(s) \), the control signal \( u(s) \), the plant output \( y(s) \), and there is additive sensor noise \( n(s) \) at the measurement. The controller \( C(s) \) and plant \( P(s) \) are proper transfer functions, and the loop is asymptotically stable.

From the block diagram, the equations in the Laplace domain are

\[ \begin{aligned} e(s) &= r(s) - y_{\text{meas}}(s) \;=\; r(s) - \big(y(s) + n(s)\big), \\ u(s) &= C(s)\,e(s), \\ y(s) &= P(s)\,u(s). \end{aligned} \]

Substitute \( u(s) = C(s)e(s) \) and \( e(s) = r(s) - y(s) - n(s) \) into the plant equation:

\[ y(s) = P(s)C(s)\,\big(r(s) - y(s) - n(s)\big) \;=\; L(s)\,\big(r(s) - y(s) - n(s)\big), \]

where \( L(s) = C(s)P(s) \) is the loop transfer function. Rearranging,

\[ y(s) + L(s)\,y(s) = L(s)\,\big(r(s) - n(s)\big) \quad\Longrightarrow\quad \big(1 + L(s)\big) y(s) = L(s)\,\big(r(s) - n(s)\big). \]

Therefore the closed-loop mapping from reference and noise to the output is

\[ y(s) = \frac{L(s)}{1 + L(s)}\,r(s) \;-\; \frac{L(s)}{1 + L(s)}\,n(s). \]

Setting \( n(s)=0 \) gives the closed-loop reference-to-output transfer function, which defines the complementary sensitivity:

\[ T(s) \;\triangleq\; \frac{y(s)}{r(s)}\Big|_{n(s)=0} \;=\; \frac{L(s)}{1+L(s)}. \]

Likewise, setting \( r(s)=0 \) yields the sensor-noise-to-output transfer function

\[ \frac{y(s)}{n(s)}\Big|_{r(s)=0} \;=\; -\,\frac{L(s)}{1+L(s)} \;=\; -T(s). \]

In Lesson 1, the sensitivity function was defined as

\[ S(s) \;=\; \frac{1}{1+L(s)}. \]

Combining both definitions we immediately obtain the identities

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

which will be used more systematically in the next lesson to relate loop-shaping, disturbance rejection, and noise behavior.

To characterize noise behavior more precisely, we derive closed-loop transfer functions from sensor noise \( n(s) \) to both the output \( y(s) \) and the control input \( u(s) \). Recall the equations

\[ \begin{aligned} y(s) &= L(s)\,\big(r(s) - y(s) - n(s)\big),\\ u(s) &= C(s)\,\big(r(s) - y(s) - n(s)\big). \end{aligned} \]

From Section 2 we already have, for \( r(s)=0 \),

\[ \frac{y(s)}{n(s)}\Big|_{r(s)=0} \;=\; -\,\frac{L(s)}{1+L(s)} \;=\; -T(s). \]

For the control signal, start with \( u(s) = C(s)\,\big(-y(s)-n(s)\big) \) when \( r(s)=0 \). Substitute \( y(s) = -T(s)n(s) \):

\[ u(s) = C(s)\,\big(-(-T(s)n(s)) - n(s)\big) = C(s)\,\big(T(s) - 1\big)\,n(s). \]

Using \( T(s) = L(s)/(1+L(s)) \) we obtain

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

and therefore

\[ \frac{u(s)}{n(s)}\Big|_{r(s)=0} = -\,C(s)\,S(s). \]

These formulas have clear engineering interpretations:

• Output noise is shaped by \( T(s) \): high values of \( |T(j\omega)| \) at some frequency amplify sensor noise at that frequency.
• Actuator noise (control signal variance) is shaped by \( C(s)S(s) \). Aggressive high-gain controllers tend to increase \( |C(j\omega)S(j\omega)| \) at high frequencies, which can drive actuators unnecessarily hard in response to sensor noise.

In many robotic applications (e.g., joint encoders, IMUs), sensor noise is broadband and approximately white above a certain frequency. Such noise is especially problematic if \( |T(j\omega)| \) is large in that high-frequency region, because it directly contaminates the output and forces the controller to react to high-frequency fluctuations.

Suppose the sensor noise \( n(t) \) is a zero-mean, wide-sense stationary random process with power spectral density \( \Phi_n(\omega) \). In the frequency domain, the output contribution of noise (with \( r(t)=0 \)) is

\[ Y(j\omega) = -T(j\omega)\,N(j\omega). \]

Therefore the power spectral density of the output noise is

\[ \Phi_y(\omega) = |T(j\omega)|^2\,\Phi_n(\omega). \]

If the noise is approximately white beyond some frequency \( \omega_0 \), i.e. \( \Phi_n(\omega) \approx \sigma_n^2 \) for \( |\omega| > \omega_0 \), then the total output noise variance is approximately

\[ \sigma_y^2 \;\approx\; \frac{1}{2\pi} \int_{-\infty}^{\infty} |T(j\omega)|^2 \,\Phi_n(\omega)\,d\omega. \]

This expression clearly shows that \( T(s) \) acts as a frequency-dependent filter on the sensor noise. Reducing \( |T(j\omega)| \) where the noise spectrum is large reduces the output noise variance.

At the same time, for low frequencies where accurate tracking is required, we typically demand \( T(j\omega) \approx 1 \), which implies \( |L(j\omega)| \gg 1 \) and hence \( S(j\omega) \approx 0 \). The detailed trade-offs between low frequency tracking and high frequency noise attenuation will be studied systematically in later lessons; here we only emphasize the key design guideline:

• Tracking region: for \( |\omega| \) small, design \( |T(j\omega)| \approx 1 \).
• Noise region: for frequencies where sensor noise is strong, design \( |T(j\omega)| \) as small as possible while preserving stability and low-frequency performance.

flowchart TD
  A["Specify noise spectrum Phi_n(omega)"] --> B["Identify noise-dominated frequency band"]
  B --> C["Shape loop: choose C(s) to make |T(jw)| small in that band"]
  C --> D["Verify tracking: |T(jw)| approx 1 at low frequencies"]
  D --> E["Check actuator effort via |C(jw) S(jw)|"]
  E --> F["Iterate controller parameters if needed"]
        

Consider a simple first-order plant, which can model a velocity actuator or a heavily damped robot joint:

\[ P(s) = \frac{K_p}{\tau_p s + 1}, \]

where \( K_p > 0 \) is the DC gain and \( \tau_p > 0 \) is the plant time constant. Use a proportional controller \( C(s) = K_c \) with \( K_c > 0 \). The loop transfer function is

\[ L(s) = C(s)P(s) = \frac{K_c K_p}{\tau_p s + 1}. \]

The complementary sensitivity function is

\[ T(s) = \frac{L(s)}{1+L(s)} = \frac{ \dfrac{K_c K_p}{\tau_p s + 1} } { 1 + \dfrac{K_c K_p}{\tau_p s + 1} } = \frac{K_c K_p}{\tau_p s + 1 + K_c K_p}. \]

This is again a first-order system with DC gain 1 and effective time constant

\[ \tau_{\text{cl}} = \frac{\tau_p}{1 + K_c K_p}. \]

Thus increasing \( K_c \) reduces the closed-loop time constant, improving reference tracking. For sensor noise, with \( r(s) = 0 \),

\[ \frac{y(s)}{n(s)} = -T(s) = -\frac{K_c K_p}{\tau_p s + 1 + K_c K_p}. \]

In magnitude, this is a first-order low-pass filter with gain \( K_c K_p/(1+K_c K_p) \approx 1 \) at very low frequency and roll-off of \( -20 \) dB per decade above its corner frequency \( \omega_c \), given by

\[ \omega_c = \frac{1 + K_c K_p}{\tau_p}. \]

A larger \( K_c \) therefore shifts the noise passband to higher frequencies and makes the system track reference faster, but the low-frequency portion of noise is essentially passed with unit gain (since \( |T(0)| = 1 \)). Additional filtering or more sophisticated controller structures (e.g., derivative filtering, two-degree-of-freedom controllers) are often needed to shape the high-frequency behavior of \( T(s) \) more aggressively.

We now implement the above first-order example using Python. We use numpy and matplotlib for numerical work and plotting, and the control package (commonly used in robotics) for transfer-function operations.

import numpy as np
import matplotlib.pyplot as plt
import control as ct  # python-control library

# Plant and controller parameters
Kp = 2.0           # plant DC gain
tau_p = 0.1        # plant time constant
Kc = 5.0           # proportional controller gain

# Define plant P(s) = Kp / (tau_p s + 1)
P = ct.TransferFunction([Kp], [tau_p, 1.0])

# Define controller C(s) = Kc
C = ct.TransferFunction([Kc], [1.0])

# Loop transfer L(s) and complementary sensitivity T(s)
L = C * P
T = ct.feedback(L, 1)  # feedback(L,1) = L / (1 + L)

# Bode magnitude of T(jw) to study noise shaping
w = np.logspace(0, 4, 400)  # 1 rad/s to 10^4 rad/s
mag_T, phase_T, omega = ct.bode_plot(T, w, Plot=False)

plt.figure()
plt.semilogx(omega, 20 * np.log10(mag_T))
plt.xlabel("Frequency (rad/s)")
plt.ylabel("|T(jw)| (dB)")
plt.title("Complementary Sensitivity Magnitude")
plt.grid(True)

# Approximate output noise variance for band-limited white noise
sigma_n2 = 1.0  # noise PSD level
Phi_n = sigma_n2 * np.ones_like(omega)
# Using a simple Riemann sum approximation:
sigma_y2 = (1.0 / (2.0 * np.pi)) * np.trapz((mag_T ** 2) * Phi_n, omega)
print("Approximate output noise variance due to sensor noise:", sigma_y2)

plt.show()
      

This script computes \( T(s) \), plots its magnitude, and approximates the output noise variance for a band-limited white noise model. By varying Kc, you can observe how the bandwidth and noise variance change, illustrating the connection between controller aggressiveness, tracking speed, and noise behavior.

7.1 C++ Example (Eigen and a Simple Utility)

In C++-based robotic software (e.g., within ROS), it is common to evaluate transfer functions at discrete frequencies for analysis. The following example evaluates the magnitude of \( T(j\omega) \) for the same first-order case using basic complex arithmetic. We assume you are compiling in a standard environment with <complex> available.

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

int main() {
    using std::complex;
    using std::cout;
    using std::endl;

    const double Kp = 2.0;
    const double tau_p = 0.1;
    const double Kc = 5.0;

    // Loop over frequencies (rad/s)
    for (double w = 1.0; w <= 1000.0; w *= 10.0) {
        complex<double> s(0.0, w);  // s = j w
        complex<double> P = Kp / (tau_p * s + 1.0);
        complex<double> C = Kc;
        complex<double> L = C * P;
        complex<double> T = L / (1.0 + L);

        double magT = std::abs(T);
        cout << "w = " << w
             << ", |T(jw)| = " << magT << endl;
    }
    return 0;
}
      

In more advanced C++ robotic control frameworks, you might integrate this computation with logging or plotting tools to analyze how controller parameter changes affect \( T(j\omega) \) and thereby noise behavior.

7.2 Java Example (Using EJML for Potential Extension)

For Java-based robotics or embedded control, one can similarly compute \( T(j\omega) \). Here we use standard complex arithmetic via a simple helper class; matrix libraries such as EJML can be introduced later to treat multi-input multi-output models.

// Minimal complex class (or use a library if available)
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 d = o.re * o.re + o.im * o.im;
        return new Complex(
            (re * o.re + im * o.im) / d,
            (im * o.re - re * o.im) / d
        );
    }
    public double abs() { return Math.hypot(re, im); }
}

public class ComplementarySensitivity {
    public static void main(String[] args) {
        double Kp = 2.0;
        double tau_p = 0.1;
        double Kc = 5.0;

        for (double w = 1.0; w <= 1000.0; w *= 10.0) {
            Complex s = new Complex(0.0, w);
            // P(s) = Kp / (tau_p s + 1)
            Complex denomP = new Complex(1.0 + tau_p * s.re, tau_p * s.im);
            // denomP is (1 + tau_p * s)
            Complex P = new Complex(Kp, 0.0).div(denomP);
            Complex C = new Complex(Kc, 0.0);
            Complex L = C.mul(P);
            Complex one = new Complex(1.0, 0.0);
            Complex T = L.div(one.add(L));
            double magT = T.abs();
            System.out.println("w = " + w + ", |T(jw)| = " + magT);
        }
    }
}
      

Both the C++ and Java snippets illustrate numerical evaluation of \( T(j\omega) \), which is the essential ingredient for Bode-style inspection of noise amplification or attenuation in different frequency ranges.

8.1 MATLAB/Simulink – Bode Plot of T(s) and Noise Simulation

In MATLAB, the Control System Toolbox provides direct support for constructing \( T(s) \), and Simulink can be used to simulate time-domain noise effects, which is very common in robotic joint control design.

% Parameters
Kp    = 2.0;
tau_p = 0.1;
Kc    = 5.0;

% Plant and controller
s = tf('s');
P = Kp / (tau_p * s + 1);
C = Kc;

% Loop transfer and complementary sensitivity
L = C * P;
T = feedback(L, 1);  % T(s) = L / (1 + L)

figure;
bode(T);
grid on;
title('Complementary Sensitivity T(s)');

% Time-domain simulation in Simulink (outline):
% 1. Create a Simulink model with:
%    - Sum block for error e = r - y_meas
%    - Gain block C(s) (for proportional control just a constant)
%    - Transfer Fcn block for P(s)
%    - Sum block to form y_meas = y + n
%    - Noise source: Band-limited White Noise block feeding the measurement
% 2. Connect the blocks according to the conceptual diagram.
% 3. Use a Step block for reference r(t) and Scope blocks to observe y(t) and u(t).
% 4. Use the 'sim' command from MATLAB to run parameter sweeps on Kc and observe
%    changes in noise level vs tracking speed.
      

8.2 Wolfram Mathematica – Symbolic and Numeric Analysis

Mathematica has built-in support for transfer functions. The following code constructs \( T(s) \) symbolically and then plots its magnitude.

(* Parameters *)
Kp = 2.0;
tauP = 0.1;
Kc = 5.0;

(* Define s and transfer functions *)
s = ComplexExpand[I*ω] /. ω -> ω; (* frequency variable for substitution *)

P[s_] := Kp / (tauP * s + 1);
C[s_] := Kc;

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

(* Bode magnitude of T(j ω) over a range *)
magT[ω_] := Abs[T[I*ω]];

LogLinearPlot[
  20*Log10[magT[ω]],
  {ω, 1, 10^4},
  Frame -> True,
  FrameLabel -> {"Frequency (rad/s)", "|T(j ω)| (dB)"},
  GridLines -> Automatic,
  PlotRange -> All,
  PlotLabel -> "Complementary Sensitivity Magnitude"
]
      

Symbolic capabilities can be used to verify algebraic properties such as \( S(s)+T(s)=1 \) and to explore how parameter variations in \( K_c \) or \( \tau_p \) affect the location of poles of \( T(s) \).

Problem 1 (Derivation of T(s) and S(s)): Consider a unity-feedback loop with controller \( C(s) \) and plant \( P(s) \). Show that the complementary sensitivity \( T(s) \) and the sensitivity \( S(s) \) are given by \( T(s) = \dfrac{L(s)}{1+L(s)} \), \( S(s) = \dfrac{1}{1+L(s)} \), and prove that \( S(s) + T(s) = 1 \).

Solution:

From Section 2, the relationship between output and reference (with zero noise) is

\[ y(s) = \frac{L(s)}{1+L(s)}\, r(s). \]

Hence by definition

\[ T(s) = \frac{y(s)}{r(s)}\Big|_{n(s)=0} = \frac{L(s)}{1+L(s)}. \]

The sensitivity function is defined (from Lesson 1) as the closed-loop transfer from an additive disturbance at the plant input to the output, or equivalently, as the transfer from reference to error:

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

Now compute \( S(s) + T(s) \):

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

Thus \( S(s) + T(s) = 1 \), an identity that holds for any loop transfer \( L(s) \) for which the closed-loop is well-defined.

Problem 2 (Sensor Noise to Output and Control): In the same unity-feedback configuration, assume additive sensor noise \( n(s) \) at the measurement and set \( r(s)=0 \). Derive the transfer functions \( y(s)/n(s) \) and \( u(s)/n(s) \) in terms of \( L(s) \), \( S(s) \), and \( T(s) \).

Solution:

With \( r(s)=0 \), we have

\[ e(s) = -y(s) - n(s), \quad u(s) = C(s)\,e(s), \quad y(s) = P(s)\,u(s) = L(s)\,e(s). \]

Substituting \( e(s) = -y(s) - n(s) \) into the last equation:

\[ y(s) = L(s)\,(-y(s) - n(s)) = -L(s)y(s) - L(s)n(s), \]

which gives

\[ (1+L(s))\,y(s) = -L(s)\,n(s) \quad\Longrightarrow\quad \frac{y(s)}{n(s)} = -\frac{L(s)}{1+L(s)} = -T(s). \]

For the control signal, we use \( u(s) = C(s)e(s) \) together with \( e(s) = -y(s) - n(s) \) and \( y(s) = -T(s)n(s) \):

\[ u(s) = C(s)\,\big(-(-T(s)n(s)) - n(s)\big) = C(s)\,\big(T(s) - 1\big)\,n(s). \]

Using \( T(s) - 1 = -S(s) \), we obtain

\[ \frac{u(s)}{n(s)} = -C(s)\,S(s). \]

Therefore the sensor noise is filtered to the output by \( -T(s) \) and to the actuator by \( -C(s)S(s) \).

Problem 3 (Complementary Sensitivity of the First-Order Example): For the plant and controller of Section 5, \( P(s) = \dfrac{K_p}{\tau_p s + 1} \) and \( C(s)=K_c \), verify that the closed-loop pole of \( T(s) \) is at \( s = -\dfrac{1 + K_c K_p}{\tau_p} \), and compute the corresponding time constant and bandwidth.

Solution:

From Section 5, we have

\[ T(s) = \frac{K_c K_p}{\tau_p s + 1 + K_c K_p}. \]

The denominator is \( \tau_p s + 1 + K_c K_p \), so the pole is at the root of \( \tau_p s + 1 + K_c K_p = 0 \), i.e.

\[ s = -\frac{1 + K_c K_p}{\tau_p}. \]

The closed-loop time constant is the inverse of the absolute value of the pole coefficient divided by the leading coefficient:

\[ \tau_{\text{cl}} = \frac{\tau_p}{1 + K_c K_p}. \]

A convenient approximate bandwidth (in rad/s) for a first-order system is \( \omega_{\text{bw}} \approx 1/\tau_{\text{cl}} \), so here

\[ \omega_{\text{bw}} \approx \frac{1 + K_c K_p}{\tau_p}. \]

Thus increasing \( K_c \) linearly increases the closed-loop bandwidth and reduces the time constant, but also shifts the noise passband to higher frequencies.

Problem 4 (Noise Power and Bode Diagram Interpretation): Let the sensor noise PSD be constant, \( \Phi_n(\omega) = \sigma_n^2 \), for \( |\omega| \leq \omega_N \) and zero otherwise. Show that the output noise variance can be approximated by \( \sigma_y^2 \approx \dfrac{\sigma_n^2}{\pi} \int_{0}^{\omega_N} |T(j\omega)|^2 d\omega \), and explain qualitatively how the shape of the Bode magnitude of \( T(j\omega) \) determines \( \sigma_y^2 \).

Solution:

By definition of the output PSD, \( \Phi_y(\omega) = |T(j\omega)|^2\Phi_n(\omega) \). The total variance is

\[ \sigma_y^2 = \frac{1}{2\pi} \int_{-\infty}^{\infty} \Phi_y(\omega)\, d\omega = \frac{1}{2\pi} \int_{-\infty}^{\infty} |T(j\omega)|^2 \Phi_n(\omega)\, d\omega. \]

With \( \Phi_n(\omega) = \sigma_n^2 \) for \( |\omega| \leq \omega_N \) and zero otherwise, this becomes

\[ \sigma_y^2 = \frac{\sigma_n^2}{2\pi} \int_{-\omega_N}^{\omega_N} |T(j\omega)|^2 \, d\omega = \frac{\sigma_n^2}{\pi} \int_{0}^{\omega_N} |T(j\omega)|^2 \, d\omega, \]

where we used the evenness of \( |T(j\omega)|^2 \). Thus the area under the curve \( |T(j\omega)|^2 \) on the Bode magnitude (plotted in linear units) over the noise band \( [0,\omega_N] \) directly determines the output noise variance. If \( |T(j\omega)| \) is close to 1 for most of that band, the noise is passed almost unchanged. If \( |T(j\omega)| \) is shaped to be small in the noise-dominated region, the output noise variance is correspondingly reduced.

In this lesson we defined and analyzed the complementary sensitivity function \( T(s) \) for unity-feedback linear systems. We proved that \( T(s) = \dfrac{L(s)}{1+L(s)} \) and \( S(s) + T(s) = 1 \), and showed that sensor noise at the measurement is transmitted to the output via \( -T(s) \) and to the actuator via \( -C(s)S(s) \). Using a first-order example, we saw how increasing proportional gain reduces the closed-loop time constant and increases bandwidth, while also affecting the frequency range over which \( T(s) \) passes sensor noise.

Frequency-domain analysis reveals that the output noise variance is determined by the integral of \( |T(j\omega)|^2 \) weighted by the noise spectrum. Practical implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how to compute and visualize \( T(s) \) and use it as a design tool. Subsequent lessons will build on these foundations to explore the full set of relationships among \( S(s) \), \( T(s) \), and the loop transfer \( L(s) \), and to formalize the trade-offs they impose on tracking, disturbance rejection, and robustness.