In previous chapters, we typically assumed a known LTI plant model, either in transfer-function form \( G_0(s) \) or state-space form \( (\mathbf{A}_0,\mathbf{B}_0,\mathbf{C}_0,\mathbf{D}_0) \). For a single-input single-output (SISO) plant with disturbance and measurement noise, the nominal state-space description is

\[ \dot{\mathbf{x}}(t) = \mathbf{A}_0\,\mathbf{x}(t) + \mathbf{B}_0\,u(t) + \mathbf{E}_0\,w(t),\qquad y(t) = \mathbf{C}_0\,\mathbf{x}(t) + \mathbf{D}_0\,u(t) + \mathbf{F}_0\,v(t). \]

Here \( w(t) \) models process disturbances (unmeasured inputs acting on the plant) and \( v(t) \) models measurement noise. In practice, the physical system rarely coincides exactly with this nominal model. Instead, the true dynamics may be written as

\[ \dot{\mathbf{x}}(t) = (\mathbf{A}_0 + \Delta\mathbf{A})\,\mathbf{x}(t) + (\mathbf{B}_0 + \Delta\mathbf{B})\,u(t) + (\mathbf{E}_0 + \Delta\mathbf{E})\,w(t), \]

\[ y(t) = (\mathbf{C}_0 + \Delta\mathbf{C})\,\mathbf{x}(t) + (\mathbf{D}_0 + \Delta\mathbf{D})\,u(t) + (\mathbf{F}_0 + \Delta\mathbf{F})\,v(t), \]

where the matrices \( \Delta\mathbf{A},\Delta\mathbf{B},\Delta\mathbf{C},\Delta\mathbf{D},\Delta\mathbf{E},\Delta\mathbf{F} \) represent deviations from the nominal model. These deviations arise from several sources of uncertainty that we classify as follows:

• Parametric uncertainty: imprecisely known physical parameters (mass, inertia, damping, gains).
• Structural or unmodeled dynamics: neglected flexible modes, actuator dynamics, or saturations.
• Operating-point and linearization errors: mismatch due to using a linearized model around a specific equilibrium.
• Disturbances: unknown but bounded or stochastic signals acting on the plant.
• Measurement noise: sensor noise and quantization effects.
• Implementation uncertainty: sampling, computation delays, and actuator limits in digital/embedded implementations.

In robust control, these uncertainties are modeled in a structured way, but in this introductory lesson we focus on where they come from and how to express them mathematically in the LTI framework.

flowchart LR
  P["Physical system"] --> M["Nominal LTI model \n(A0,B0,C0,D0 or G0(s))"]
  M --> U1["Parametric deviations \n(delta parameters)"]
  M --> U2["Unmodeled dynamics \n(neglected modes, delays)"]
  M --> U3["Operating-point / \nlinearization error"]
  M --> U4["Disturbances and noise"]
  M --> U5["Implementation effects \n(sampling, quantization)"]
  U1 --> L["Uncertainty description \nfor analysis"]
  U2 --> L
  U3 --> L
  U4 --> L
  U5 --> L
        

Consider a standard translational mass-spring-damper system, previously studied in modeling chapters:

\[ m\,\ddot{x}(t) + c\,\dot{x}(t) + k\,x(t) = u(t), \]

where \( m \) is the mass, \( c \) the viscous friction coefficient, and \( k \) the stiffness. The transfer function from input \( u(t) \) to output \( x(t) \) is

\[ G(s;m,c,k) = \frac{X(s)}{U(s)} = \frac{1}{m s^2 + c s + k}. \]

In practice, the parameters are not known exactly. We instead work with nominal values \( m_0,c_0,k_0 \) and define relative parameter perturbations

\[ m = m_0(1 + \delta_m),\quad c = c_0(1 + \delta_c),\quad k = k_0(1 + \delta_k), \]

where typically \( |\delta_m|,|\delta_c|,|\delta_k| \ll 1 \). The uncertain transfer function is then

\[ G(s;\boldsymbol{\theta}) = \frac{1}{m_0(1 + \delta_m) s^2 + c_0(1 + \delta_c) s + k_0(1 + \delta_k)}, \]

where \( \boldsymbol{\theta} = (m,c,k)^\top \). For sufficiently small perturbations we can linearize \( G(s;\boldsymbol{\theta}) \) with respect to the parameters using a first-order Taylor expansion:

\[ G(s;\boldsymbol{\theta}) \approx G_0(s) + \sum_{i=1}^3 \frac{\partial G}{\partial \theta_i}(s;\boldsymbol{\theta}_0)\, \Delta\theta_i,\quad \Delta\theta_i = \theta_i - \theta_{0,i}, \]

with \( G_0(s) = G(s;\boldsymbol{\theta}_0) \). This representation explicitly relates the transfer function error to parameter errors and will be useful later when we connect parameter uncertainty to closed-loop sensitivity.

For the mass-spring-damper example, one can compute the partial derivatives analytically. Denoting \( D(s) = m s^2 + c s + k \), we have

\[ \frac{\partial G}{\partial m}(s;\boldsymbol{\theta}) = -\frac{s^2}{D(s)^2},\quad \frac{\partial G}{\partial c}(s;\boldsymbol{\theta}) = -\frac{s}{D(s)^2},\quad \frac{\partial G}{\partial k}(s;\boldsymbol{\theta}) = -\frac{1}{D(s)^2}. \]

These derivatives quantify the frequency-dependent sensitivity of the transfer function to each parameter. At low frequencies (small \( |s| \)), the stiffness perturbation dominates, whereas at high frequencies the mass perturbation is dominant.

Structural uncertainty refers to mismatches due to the form of the model rather than just the numerical values of its parameters. Typical examples in mechanical and robotic systems include:

• Neglecting flexible modes in a robot arm, modeling it as rigid.
• Ignoring actuator and sensor dynamics (e.g., motor electrical dynamics, encoder filtering).
• Approximating distributed-parameter structures (beams, cables, fluids) by a few lumped modes.
• Neglecting dead zones, backlash, friction nonlinearities, or saturations.

Suppose the true plant transfer function is \( G_{\text{true}}(s) \) and our nominal model is \( G_0(s) \). The most primitive way to express structural uncertainty is via an additive uncertainty:

\[ G_{\text{true}}(s) = G_0(s) + \Delta_G(s), \]

where \( \Delta_G(s) \) captures all neglected dynamics. For example, if we neglect a high-frequency flexible mode,

\[ G_{\text{true}}(s) = G_0(s)\, \frac{\omega_f^2}{s^2 + 2\zeta_f\omega_f s + \omega_f^2}, \]

then \( \Delta_G(s) = G_{\text{true}}(s) - G_0(s) \). The magnitude of \( \Delta_G(j\omega) \) will be small at low frequencies compared with \( |G_0(j\omega)| \), but large near the flexible resonance. This frequency dependence is crucial for robustness: controllers that push the loop bandwidth too close to neglected modes may destabilize the system.

Structural uncertainty can also arise when we assume an LTI model for a system that is only approximately linear. The linearized model describes the system accurately near the chosen operating point, but large excursions may excite nonlinear effects that are completely absent from the nominal LTI representation.

Many physical systems, especially in robotics, are inherently nonlinear:

\[ \dot{\mathbf{x}}(t) = \mathbf{f}(\mathbf{x}(t),u(t)),\qquad y(t) = \mathbf{h}(\mathbf{x}(t),u(t)). \]

Around a steady-state operating point \( (\mathbf{x}^\star,u^\star) \) with \( \mathbf{f}(\mathbf{x}^\star,u^\star) = \mathbf{0} \), the standard linearization gives

\[ \delta\dot{\mathbf{x}}(t) = \mathbf{A}\,\delta\mathbf{x}(t) + \mathbf{B}\,\delta u(t) + \mathbf{r}_x(t),\qquad \delta y(t) = \mathbf{C}\,\delta\mathbf{x}(t) + \mathbf{D}\,\delta u(t) + \mathbf{r}_y(t), \]

where \( \mathbf{A} = \left.\frac{\partial \mathbf{f}}{\partial \mathbf{x}}\right|_{(\mathbf{x}^\star,u^\star)} \), \( \mathbf{B} = \left.\frac{\partial \mathbf{f}}{\partial u}\right|_{(\mathbf{x}^\star,u^\star)} \), and similarly for \( \mathbf{C},\mathbf{D} \). The terms \( \mathbf{r}_x(t),\mathbf{r}_y(t) \) collect the higher-order Taylor remainders.

Under mild smoothness assumptions, \( \mathbf{r}_x(t),\mathbf{r}_y(t) \) are of second order in the deviations:

\[ \|\mathbf{r}_x(t)\| = \mathcal{O}\!\left(\|\delta\mathbf{x}(t)\|^2 + |\delta u(t)|^2\right),\quad \|\mathbf{r}_y(t)\| = \mathcal{O}\!\left(\|\delta\mathbf{x}(t)\|^2 + |\delta u(t)|^2\right). \]

Therefore, as long as the closed-loop controller keeps \( \delta\mathbf{x}(t) \) and \( \delta u(t) \) small, the linear approximation is accurate. But if the operating conditions change significantly (different load, different configuration of a robot manipulator, etc.), the Jacobians \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \) change as well, and the model uncertainty becomes parametric in the operating point.

In practice, this leads to:

• Scheduling in operating point: using different linear models for different configurations (gain scheduling).
• Linearization uncertainty: treating the higher-order remainders as an additive perturbation on the nominal LTI model.

Exogenous inputs that are not directly under the control of the controller are another major source of uncertainty. We distinguish:

• Load disturbances: unmeasured torques, forces, or inflows acting on the plant.
• Reference disturbances: variations in the commanded trajectory that are not perfectly known in advance.
• Measurement noise: sensor noise, quantization, aliasing from sampling.

In the LTI framework, process disturbances and measurement noise are modeled as additional inputs:

\[ \dot{\mathbf{x}}(t) = \mathbf{A}_0\,\mathbf{x}(t) + \mathbf{B}_0\,u(t) + \mathbf{E}_0\,w(t),\qquad y(t) = \mathbf{C}_0\,\mathbf{x}(t) + \mathbf{D}_0\,u(t) + \mathbf{F}_0\,v(t). \]

From a robust-design perspective, we rarely know the exact time signals \( w(t),v(t) \). Instead, we assume they belong to some function class, e.g.

• Bounded disturbances: \( \|w\|_{\infty} \leq W_{\max} \).
• Energy-bounded disturbances: \( \|w\|_2 \leq W_2 \).
• Stochastic disturbances: zero-mean white noise with given spectral density.

In later chapters, the closed-loop maps from \( w \) to \( y \) and from \( v \) to \( y \) will be expressed using the sensitivity \( S(s) \) and complementary sensitivity \( T(s) \) functions introduced in Chapter 22, and these maps will be used to quantify disturbance rejection and noise amplification.

Even if the physical plant were perfectly known, the implemented controller may behave differently from the ideal continuous-time design due to:

• Sampling: the continuous-time plant is controlled at discrete instants with sampling period \( h \), which changes the effective plant seen by the controller.
• Computation and communication delays: non-zero processing time and network latencies introduce effective time delays.
• Finite precision: quantization in sensors, A/D and D/A converters, and arithmetic operations.
• Actuator limits: saturation in torque, voltage, or speed.

A standard example is a joint of a robot arm controlled by a digital processor. The ideal joint dynamics (ignoring flexibility) may be

\[ J\ddot{\theta}(t) + b\dot{\theta}(t) = \tau(t), \]

while the implemented torque is actually a saturated, delayed, and quantized version of the controller output \( u_c[k] \):

\[ \tau(t) \approx \text{sat}\!\bigl(q(u_c[k - k_d])\bigr),\quad t \in [k h,(k+1) h), \]

where \( q(\cdot) \) denotes quantization, \( \text{sat}(\cdot) \) saturation, and \( k_d \) a delay in sampling periods. The difference between this real actuation and the ideal continuous-time torque is part of the implementation uncertainty. Later, such effects will be captured either via explicit delay blocks or through uncertain-gain models.

flowchart TD
  P["Nominal controller C(s)"] --> D1["Digital implementation (sampling h)"]
  D1 --> D2["Code execution and scheduling"]
  D2 --> D3["Quantization, saturation, delays"]
  D3 --> CERR["Implementation uncertainty (difference from ideal C(s))"]
  CERR --> CL["Closed-loop behavior with real hardware"]
        

Consider a simplified rotational joint (e.g., one link of a robotic manipulator) modeled as

\[ J\ddot{\theta}(t) + b\dot{\theta}(t) = u(t), \]

where \( J \) is the joint inertia and \( b \) effective damping. The transfer function from torque to angular position is

\[ G(s;J,b) = \frac{\Theta(s)}{U(s)} = \frac{1}{J s^2 + b s}. \]

The following Python code (using numpy, scipy, and the python-control library often used in robotics) simulates step responses for multiple samples of \( J \) and \( b \), each perturbed within ±20% of their nominal values.

import numpy as np
import matplotlib.pyplot as plt
import control as ct  # python-control, widely used in robotics/control

# Nominal parameters (e.g. small robot joint)
J0 = 0.01  # kg m^2
b0 = 0.05  # N m s/rad

def joint_tf(J, b):
    # G(s) = 1 / (J s^2 + b s)
    num = [1.0]
    den = [J, b, 0.0]
    return ct.TransferFunction(num, den)

G_nom = joint_tf(J0, b0)

# Generate random parametric variations (±20%)
rng = np.random.default_rng(seed=1)
n_samples = 8
Js = J0 * (1.0 + 0.4 * (rng.random(n_samples) - 0.5))
bs = b0 * (1.0 + 0.4 * (rng.random(n_samples) - 0.5))

t = np.linspace(0, 4.0, 500)
plt.figure()
for J, b in zip(Js, bs):
    G = joint_tf(J, b)
    tout, yout = ct.step_response(G, t)
    plt.plot(tout, yout, alpha=0.6)

# Nominal response highlighted
tout_nom, y_nom = ct.step_response(G_nom, t)
plt.plot(tout_nom, y_nom, linestyle="--", linewidth=2)

plt.xlabel("time [s]")
plt.ylabel("joint angle response to unit step torque")
plt.title("Effect of parametric uncertainty on robot joint step response")
plt.grid(True)
plt.show()
      

In a robotics context, the same plant model could be embedded in higher-level simulation libraries such as roboticstoolbox-python or used in ROS-based simulation nodes. The uncertainties in \( J \) and \( b \) represent modeling errors due to unknown link masses, unmodeled payloads, or friction.

The same joint model can be simulated in C++ using a simple Euler integrator. In practical robotic software stacks (e.g. ROS 2), one would typically combine such models with libraries like Eigen for linear algebra and the ROS control framework for real-time control.

#include <iostream>
#include <vector>
#include <random>

// Simple Euler integration of J*theta_ddot + b*theta_dot = u
struct JointState {
    double theta;      // position
    double theta_dot;  // velocity
};

void simulate_joint(double J, double b,
                    double u,  // constant torque
                    double dt, double T,
                    std::vector<JointState>& traj)
{
    JointState x{0.0, 0.0};
    int N = static_cast<int>(T / dt);
    traj.clear();
    traj.reserve(N + 1);
    traj.push_back(x);

    for (int k = 0; k < N; ++k) {
        double theta_ddot = (u - b * x.theta_dot) / J;
        x.theta_dot += dt * theta_ddot;
        x.theta     += dt * x.theta_dot;
        traj.push_back(x);
    }
}

int main() {
    double J0 = 0.01;
    double b0 = 0.05;
    double dt = 0.001;
    double T  = 4.0;
    double u  = 1.0;    // step torque

    std::mt19937 gen(1);
    std::uniform_real_distribution<double> dist(-0.2, 0.2);

    for (int i = 0; i < 5; ++i) {
        double J = J0 * (1.0 + dist(gen));
        double b = b0 * (1.0 + dist(gen));

        std::vector<JointState> traj;
        simulate_joint(J, b, u, dt, T, traj);

        std::cout << "Sample " << i
                  << ": J=" << J
                  << ", b=" << b
                  << ", final theta=" << traj.back().theta
                  << std::endl;
    }

    return 0;
}
      

In a ROS 2 controller node, the function simulate_joint could be replaced by real sensor feedback, and the uncertain parameters J, b would be identified online or treated as uncertain when tuning controllers using frameworks such as control_toolbox combined with Eigen.

Java is less common than C++ or Python in low-level robotics, but is used in some robotic middleware and simulation environments. The following example performs a basic Euler-based simulation for several samples of \( J \) and \( b \). In larger projects, one may employ libraries such as Apache Commons Math (ODE solvers, linear algebra) for more advanced modeling.

import java.util.Random;

public class JointUncertaintySweep {

    static class State {
        double theta;
        double thetaDot;
    }

    static State[] simulate(double J, double b,
                            double u, double dt, double T) {
        int N = (int) (T / dt);
        State[] traj = new State[N + 1];
        State x = new State();
        x.theta = 0.0;
        x.thetaDot = 0.0;
        traj[0] = x;

        for (int k = 0; k < N; ++k) {
            State xnew = new State();
            double thetaDDot = (u - b * x.thetaDot) / J;
            xnew.thetaDot = x.thetaDot + dt * thetaDDot;
            xnew.theta    = x.theta + dt * xnew.thetaDot;
            traj[k + 1] = xnew;
            x = xnew;
        }
        return traj;
    }

    public static void main(String[] args) {
        double J0 = 0.01;
        double b0 = 0.05;
        double u  = 1.0;
        double dt = 0.001;
        double T  = 4.0;

        Random rng = new Random(1L);
        for (int i = 0; i < 5; ++i) {
            double deltaJ = 0.4 * (rng.nextDouble() - 0.5);
            double deltaB = 0.4 * (rng.nextDouble() - 0.5);
            double J = J0 * (1.0 + deltaJ);
            double b = b0 * (1.0 + deltaB);

            State[] traj = simulate(J, b, u, dt, T);
            State xf = traj[traj.length - 1];
            System.out.printf(
                "Sample %d: J=%.4f, b=%.4f, final theta=%.4f%n",
                i, J, b, xf.theta
            );
        }
    }
}
      

Such Java-based simulation can be interfaced with higher-level robotic frameworks (for example, Java bindings to Gazebo or custom middleware) to explore the impact of modeling uncertainty on performance metrics.

MATLAB and Simulink are standard tools in control and robotics. The following script constructs the nominal transfer function \( G_0(s) \) and then simulates step responses for perturbed parameters. This can be integrated with Robotics System Toolbox models of manipulator dynamics.

% Nominal parameters
J0 = 0.01;   % kg m^2
b0 = 0.05;   % N m s/rad

s = tf('s');
G0 = 1 / (J0*s^2 + b0*s);  % nominal joint model

% Parameter sweep (±20%)
nSamples = 6;
Jvals = J0 * (1 + 0.4*(rand(1,nSamples)-0.5));
bvals = b0 * (1 + 0.4*(rand(1,nSamples)-0.5));

t = linspace(0,4,500);
figure; hold on;
for k = 1:nSamples
    J = Jvals(k);
    b = bvals(k);
    G = 1 / (J*s^2 + b*s);
    step(G, t);
end
step(G0, t);  % nominal response
grid on;
title('Step responses with parametric uncertainty');
xlabel('Time [s]');
ylabel('Joint angle [rad]');

% Simulink hint:
% 1. Build a block diagram with Transfer Fcn block 1/(J*s^2 + b*s).
% 2. Use mask parameters for J and b and a "Model Variants" or parameter
%    sweep script to simulate different uncertainty samples.
% 3. Connect to a manipulator model from Robotics System Toolbox by
%    connecting joint torques and positions.
      

Simulink facilitates combining uncertain joint models with more realistic robot plant models, including multi-body dynamics and actuator/sensor blocks, thereby visualizing the impact of structural and parametric uncertainty on closed-loop behavior.

Finally, we illustrate uncertainty in the mass-spring-damper model using Wolfram Mathematica and NDSolve. We simulate several realizations of the parameters and compare their responses.

(* Nominal parameters *)
m0 = 1.0;
c0 = 0.6;
k0 = 4.0;

u[t_] := UnitStep[t]; (* unit step force *)

randomParams[] := Module[{dm, dc, dk},
  dm = 0.4 (RandomReal[] - 0.5);
  dc = 0.4 (RandomReal[] - 0.5);
  dk = 0.4 (RandomReal[] - 0.5);
  {m0 (1 + dm), c0 (1 + dc), k0 (1 + dk)}
];

sim[m_, c_, k_] := Module[{x, t, sol},
  sol = NDSolve[
    {
      m x''[t] + c x'[t] + k x[t] == u[t],
      x[0] == 0, x'[0] == 0
    },
    x, {t, 0, 5}
  ];
  Evaluate[x[t] /. sol[[1]]]
];

nSamples = 6;
curves = Table[
  With[{pars = randomParams[]},
    {pars, sim @@ pars}
  ],
  {nSamples}
];

Plot[
  Evaluate[Last /@ curves],
  {t, 0, 5},
  PlotRange -> All,
  AxesLabel -> {"t", "x(t)"},
  PlotLegends -> None,
  GridLines -> Automatic,
  PlotLabel -> "Mass-spring-damper responses with parametric uncertainty"
]
      

While the nominal parameters \( m_0,c_0,k_0 \) define a specific response, the ensemble of trajectories illustrates how uncertainty in the model translates into variability in the time response of the physical system.

Problem 1 (Effect of Parametric Uncertainty on Natural Frequency and Damping): For the mass-spring-damper system \( m\ddot{x} + c\dot{x} + kx = 0 \), the undamped natural frequency and damping ratio are \( \omega_n = \sqrt{k/m} \) and \( \zeta = c / (2\sqrt{km}) \). Suppose \( m = m_0(1 + \delta_m) \) and \( k = k_0(1 + \delta_k) \) with \( |\delta_m|,|\delta_k| \ll 1 \) and \( c = c_0 \) fixed. Derive first-order approximations for the relative changes \( \Delta\omega_n / \omega_{n,0} \) and \( \Delta\zeta / \zeta_0 \).

Solution:

The nominal quantities are \( \omega_{n,0} = \sqrt{k_0/m_0} \) and \( \zeta_0 = c_0 / (2\sqrt{k_0 m_0}) \). Using logarithmic differentiation,

\[ \ln \omega_n = \tfrac{1}{2}(\ln k - \ln m) \quad \Rightarrow \quad \frac{\Delta\omega_n}{\omega_{n,0}} \approx \tfrac{1}{2}(\delta_k - \delta_m). \]

For the damping ratio with \( c = c_0 \) fixed,

\[ \ln \zeta = \ln c_0 - \tfrac{1}{2}(\ln k + \ln m) \quad \Rightarrow \quad \frac{\Delta\zeta}{\zeta_0} \approx -\tfrac{1}{2}(\delta_k + \delta_m). \]

Thus, increasing stiffness and mass by the same relative amount leaves \( \omega_n \) approximately unchanged but decreases \( \zeta \).

Problem 2 (Order of Linearization Error): Consider a smooth nonlinear system \( \dot{\mathbf{x}} = \mathbf{f}(\mathbf{x}) \) with equilibrium \( \mathbf{x}^\star \). Show that the linearization error is of second order in \( \delta\mathbf{x} = \mathbf{x} - \mathbf{x}^\star \), i.e. justify that \( \mathbf{r}_x(t) = \mathcal{O}(\|\delta\mathbf{x}(t)\|^2) \).

Solution:

By Taylor's theorem around \( \mathbf{x}^\star \), we have

\[ \mathbf{f}(\mathbf{x}^\star + \delta\mathbf{x}) = \mathbf{f}(\mathbf{x}^\star) + \mathbf{A}\,\delta\mathbf{x} + \mathbf{r}_x, \]

where \( \mathbf{A} = \left.\frac{\partial \mathbf{f}}{\partial \mathbf{x}}\right|_{\mathbf{x}^\star} \) and the remainder satisfies

\[ \|\mathbf{r}_x\| \leq \tfrac{1}{2} L \|\delta\mathbf{x}\|^2 \]

for some constant \( L \) that depends on bounds on the second derivatives of \( \mathbf{f} \) in a neighborhood of \( \mathbf{x}^\star \). Hence the linearization is exact to first order and the error term is indeed quadratic in \( \delta\mathbf{x} \).

Problem 3 (Disturbance Channel Modeling): A plant has nominal transfer function \( G_0(s) = \frac{1}{m s^2 + c s + k} \). A constant load disturbance \( d(t) \) acts additively on the force input. Show how to represent this disturbance as an additional input in the block diagram and write the transfer function from \( d(t) \) to \( x(t) \).

Solution:

The equation of motion becomes \( m\ddot{x} + c\dot{x} + kx = u + d \). Taking the Laplace transform and solving for \( X(s) \) gives

\[ X(s) = \frac{1}{m s^2 + c s + k} U(s) + \frac{1}{m s^2 + c s + k} D(s). \]

Thus the disturbance-to-output transfer function is \( G_d(s) = \frac{X(s)}{D(s)} = G_0(s) \), while the control input-to-output map remains \( G_0(s) \). In block-diagram form, the disturbance enters through a summing junction at the plant input, adding to the control signal \( u \).

Problem 4 (Bounding DC Gain Error from Parameter Bounds): For the mass-spring-damper system, the DC gain from force to position is \( G(0) = 1/k \). Suppose the stiffness is uncertain with \( k \in [k_{\min},k_{\max}] \). Give an upper bound on the absolute DC gain error \( |G(0) - G_0(0)| \) when the nominal stiffness is \( k_0 \in [k_{\min},k_{\max}] \).

Solution:

We have \( G(0) = 1/k \) and \( G_0(0) = 1/k_0 \). Then

\[ |G(0) - G_0(0)| = \left|\frac{1}{k} - \frac{1}{k_0}\right| = \frac{|k_0 - k|}{|k k_0|}. \]

Since \( k,k_0 \in [k_{\min},k_{\max}] \), we have \( |k_0 - k| \leq k_{\max} - k_{\min} \) and \( |k k_0| \geq k_{\min}^2 \). Therefore,

\[ |G(0) - G_0(0)| \leq \frac{k_{\max} - k_{\min}}{k_{\min}^2}. \]

This inequality provides a worst-case bound on the DC gain error based solely on the known parameter interval.

Problem 5 (Classifying Uncertainties in a Robot Joint): For a single revolute robot joint actuated by a DC motor and driven by a digital controller, identify which uncertainties are (a) parametric, (b) structural, (c) disturbances, (d) implementation-related. Sketch a conceptual classification flow.

Solution:

• Parametric: unknown exact inertia of the link and payload, uncertain viscous friction coefficient, uncertain motor torque constant.
• Structural: neglected gear backlash and Coulomb friction, neglected joint flexibility, unmodeled motor current dynamics.
• Disturbances: contact forces, gravity torques from other links, external pushes.
• Implementation: sampling and zero-order hold, computation delay, encoder quantization, saturation of motor voltage or current.

flowchart LR
  S["Robot joint scenario"] --> P1["Identify parametric items \n(J, b, motor constant)"]
  S --> P2["Identify structural effects \n(flexibility, friction, backlash)"]
  S --> P3["Identify exogenous signals \n(contact forces, gravity)"]
  S --> P4["Identify implementation issues \n(sampling, delays, limits)"]
  P1 --> C["Map to parametric uncertainty \nin model matrices"]
  P2 --> C
  P3 --> C
  P4 --> C
        

In this lesson we formalized the main sources of uncertainty that separate ideal LTI models from real physical systems: parametric uncertainty in physical parameters, structural uncertainty due to neglected dynamics and nonlinearities, operating-point and linearization errors, disturbances and measurement noise, and implementation uncertainties in digital controllers and robotic platforms. We expressed these uncertainties within the state-space and transfer-function frameworks and illustrated them with simple simulations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

Subsequent lessons in this chapter will develop uncertainty models (e.g. parametric uncertainty sets, additive and multiplicative perturbations) that allow us to perform rigorous robustness analysis using the sensitivity tools introduced earlier in the course.