In previous lessons of this chapter, we studied the time response of standard second-order systems, characterized by natural frequency \( \omega_n \) and damping ratio \( \zeta \), and we saw how pole locations in the complex \( s \)-plane determine transient behavior. Real-world systems, however, often have higher-order dynamics:

\[ G(s) = \frac{Y(s)}{U(s)} = K \frac{\prod_{i=1}^{m} (s - z_i)}{\prod_{i=1}^{n} (s - p_i)}, \qquad \Re(p_i) < 0 \text{ for all } i \]

where \( p_i \) are poles and \( z_i \) are zeros. When some poles are much closer to the imaginary axis than others (i.e., their real parts are less negative in magnitude), the corresponding modes decay slowly and dominate the transient response.

The dominant pole approximation consists of:

• Identifying the slow (dominant) poles from the higher-order denominator.
• Forming a reduced-order transfer function that retains only those poles (often a second-order model).
• Adjusting the static gain so that steady-state values match the original system.
• Verifying that the approximation error in time response is small in the time interval of interest.

This is extremely useful in control design: we can use second-order design formulas for rise time, overshoot, and settling time while still accounting for the essential behavior of the original higher-order plant or closed-loop system.

For a strictly proper, stable LTI system with distinct poles \( p_1, \dots, p_n \) (no repeated roots), we can express the transfer function as a partial fraction expansion:

\[ G(s) = \sum_{i=1}^{n} \frac{A_i}{s - p_i} \]

where \( A_i \) are residues that can be computed from \( G(s) \) using methods from the Laplace transform and partial fraction expansion (Chapter 2).

The impulse response \( g(t) \) is then

\[ g(t) = \mathcal{L}^{-1}\{G(s)\}(t) = \sum_{i=1}^{n} A_i e^{p_i t} u(t), \qquad t \ge 0 \]

where \( u(t) \) is the unit step (Heaviside) function. For a unit-step input \( u(t) \), the Laplace transform is \( U(s)=1/s \), giving

\[ C(s) = \frac{Y(s)}{U(s)} U(s) = G(s) \frac{1}{s} = \frac{K_0}{s} + \sum_{i=1}^{n} \frac{K_i}{s - p_i}, \]

where \( K_0 \) determines the steady-state value. The corresponding step response is

\[ c(t) = K_{\infty} + \sum_{i=1}^{n} K_i e^{p_i t} u(t), \qquad K_{\infty} = \lim_{t \to \infty} c(t) = \lim_{s \to 0} s C(s). \]

Each pole \( p_i \) contributes an exponential mode \( e^{p_i t} \). If \( p_i \) is real and negative, \( e^{p_i t} \) is a decaying exponential with time constant \( T_i = -1/\Re(p_i) \). If \( p_i = \sigma \pm \mathrm{j} \omega_d \), the contribution is a decaying sinusoid with envelope \( e^{\sigma t} \).

Suppose the poles of a stable system are ordered by real part:

\[ 0 > \Re(p_1) \ge \Re(p_2) \ge \cdots \ge \Re(p_n). \]

We call the first \( r \) poles \( p_1, \dots, p_r \) dominant if

• their real parts are much closer to zero than the remaining poles, and
• their associated residues \( K_i \) are not negligible in magnitude.

Denote the step response as

\[ c(t) = K_{\infty} + \sum_{i=1}^{n} K_i e^{p_i t}. \]

Split the sum into a dominant part and a remainder:

\[ \begin{aligned} c(t) &= K_{\infty} + \underbrace{\sum_{i=1}^{r} K_i e^{p_i t}}_{c_d(t)} + \underbrace{\sum_{i=r+1}^{n} K_i e^{p_i t}}_{e(t)}. \end{aligned} \]

The reduced-order (dominant-pole) approximation keeps only the dominant part: \( c_d(t) \). The approximation error is \( e(t) = c(t) - c_d(t) \). Using the triangle inequality,

\[ |e(t)| \le \sum_{i=r+1}^{n} |K_i| \, e^{\Re(p_i) t}. \]

If we define \( \sigma_f = \max_{i>r} \Re(p_i) < 0 \) and \( S_f = \sum_{i=r+1}^{n} |K_i| \), then

\[ |e(t)| \le S_f e^{\sigma_f t}, \]

so the remainder decays at least as fast as \( e^{\sigma_f t} \). If the dominant poles have real part \( \sigma_d = \Re(p_1) \), then the dominant part decays like \( e^{\sigma_d t} \). The relative error can be bounded by

\[ \frac{|e(t)|}{\left|\sum_{i=1}^r K_i e^{p_i t}\right|} \lesssim \frac{S_f}{S_d} e^{(\sigma_f - \sigma_d)t},\quad S_d = \sum_{i=1}^r |K_i|. \]

If \( \sigma_f \ll \sigma_d < 0 \) (i.e., the fast poles are far to the left), then \( \sigma_f - \sigma_d \ll 0 \) and the exponential factor is very small in the time range where the system's settling is determined by the dominant poles.

A common engineering rule-of-thumb is:

• If the real parts of the non-dominant poles are at least 5 times more negative than the real parts of the dominant poles, i.e. \( |\Re(p_{\text{fast}})| \gtrsim 5 |\Re(p_{\text{dom}})| \), then a second-order dominant-pole approximation is usually adequate for qualitative design (overshoot, settling time).

Consider a third-order transfer function with a pair of complex conjugate poles and one additional fast real pole:

\[ G_3(s) = \frac{\omega_n^2}{(s + \alpha)\bigl(s^2 + 2\zeta \omega_n s + \omega_n^2\bigr)}, \quad \alpha \gg \zeta \omega_n > 0. \]

For a unit-step input, the Laplace-domain output is

\[ C_3(s) = \frac{\omega_n^2}{s (s + \alpha)\bigl(s^2 + 2\zeta \omega_n s + \omega_n^2\bigr)}. \]

We write the partial fraction expansion

\[ C_3(s) = \frac{A}{s} + \frac{B}{s + \alpha} + \frac{Cs + D}{s^2 + 2\zeta \omega_n s + \omega_n^2}. \]

In the time domain, the step response has the general form

\[ c_3(t) = A + B e^{-\alpha t} + e^{-\zeta \omega_n t} \bigl( E \cos(\omega_d t) + F \sin(\omega_d t) \bigr), \quad \omega_d = \omega_n \sqrt{1 - \zeta^2}, \]

where \( A \) is the steady-state value (often 1), and \( B, E, F \) depend on the system parameters. The term \( B e^{-\alpha t} \) decays extremely fast when \( \alpha \) is large.

The corresponding second-order transfer function (keeping only the complex conjugate poles) is

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

where \( k \) is chosen so that \( G_2(0) = G_3(0) \) (matching the DC gain). This gives

\[ G_3(0) = \frac{\omega_n^2}{\alpha \omega_n^2} = \frac{1}{\alpha}, \quad G_2(0) = \frac{k \, \omega_n^2}{\omega_n^2} = k \quad \Rightarrow \quad k = \frac{1}{\alpha}. \]

Thus

\[ G_2(s) = \frac{\omega_n^2 / \alpha}{s^2 + 2\zeta \omega_n s + \omega_n^2}. \]

For the second-order system, the unit-step response \( c_2(t) \) is known from previous lessons:

\[ c_2(t) = 1 - \frac{1}{\sqrt{1 - \zeta^2}} e^{-\zeta \omega_n t} \sin\!\Bigl(\omega_d t + \phi\Bigr), \quad \phi = \arctan\!\Bigl(\frac{\sqrt{1 - \zeta^2}}{\zeta}\Bigr), \]

scaled appropriately by the DC gain \( 1/\alpha \). The full third-order response differs from this by a fast-decaying term of order \( e^{-\alpha t} \).

To see the magnitude of the approximation error at the second-order settling time \( t_s \approx \frac{4}{\zeta \omega_n} \), we estimate

\[ \left| B e^{-\alpha t_s} \right| = |B| \exp\!\Bigl(-\alpha \frac{4}{\zeta \omega_n}\Bigr). \]

If \( \alpha = 10 \zeta \omega_n \), then

\[ e^{-\alpha t_s} = \exp(-40) \approx 4.2 \times 10^{-18}, \]

so the third-order response is essentially indistinguishable from the second-order response at and after the settling time determined by the dominant conjugate poles.

In practice, we use the following workflow to construct a dominant pole approximation:

1. Obtain the closed-loop or open-loop transfer function of interest.
2. Factor the denominator and compute all poles (analytically or numerically).
3. Identify dominant poles: those with smallest magnitude of real part (closest to the imaginary axis) and significant residues.
4. Construct a reduced-order transfer function retaining only dominant poles.
5. Adjust the numerator coefficients to preserve DC gain and, if desired, low-frequency behavior.
6. Validate the approximation by comparing step responses (or other relevant responses).

The workflow below summarizes this process.

flowchart TD
  A["Start: high order G(s)"] --> B["Compute poles p_i"]
  B --> C["Sort by real part Re(p_i)"]
  C --> D["Choose dominant subset (1 or 2 poles)"]
  D --> E["Form reduced G_red(s) with these poles"]
  E --> F["Match DC gain: G_red(0) = G(0)"]
  F --> G["Simulate step response of both models"]
  G --> H{"Is error small \nin time window?"}
  H -->|yes| J["Use reduced model for design"]
  H -->|no| I["Include more poles or refine approximation"]
        

Using Python, the python-control library is convenient for constructing transfer functions and computing step responses. In robotics, this often appears together with ROS (Robot Operating System) and toolboxes such as roboticstoolbox-python for modeling robot dynamics; the plant model passed to a feedback controller can be simplified using dominant pole approximations.

The example below compares the step response of the full third-order system from Section 4 with its dominant second-order approximation.

import numpy as np
import matplotlib.pyplot as plt

# Use the "control" library: pip install control
import control as ctrl

# Parameters of the example
wn = 5.0      # natural frequency (rad/s)
zeta = 0.4    # damping ratio
alpha = 50.0  # fast real pole

# Full third-order transfer function:
# G3(s) = wn^2 / ((s + alpha)(s^2 + 2*zeta*wn*s + wn^2))
num_full = [wn**2]
den_full = np.polymul([1.0, alpha], [1.0, 2.0 * zeta * wn, wn**2])
G3 = ctrl.tf(num_full, den_full)

# Dominant second-order approximation:
# Keep only the complex pair and adjust DC gain.
# G2(s) = (wn^2 / alpha) / (s^2 + 2*zeta*wn*s + wn^2)
num_dom = [wn**2 / alpha]
den_dom = [1.0, 2.0 * zeta * wn, wn**2]
G2 = ctrl.tf(num_dom, den_dom)

print("Full system poles:", ctrl.pole(G3))
print("Dominant approx poles:", ctrl.pole(G2))

# Step responses for comparison
t = np.linspace(0.0, 4.0, 1000)  # time window
t1, y_full = ctrl.step_response(G3, T=t)
t2, y_dom  = ctrl.step_response(G2, T=t)

plt.figure()
plt.plot(t1, y_full, label="Full 3rd order")
plt.plot(t2, y_dom,  label="Dominant 2nd order", linestyle="--")
plt.xlabel("Time (s)")
plt.ylabel("Output")
plt.title("Dominant Pole Approximation Example")
plt.legend()
plt.grid(True)
plt.show()
      

In a robotics stack, the same G2 model can be used inside simulation and controller design, while more complex dynamics (flexibilities, sensor filtering, motor electrical dynamics) remain inside the full model used for offline validation.

In C++, higher-order continuous-time dynamics are often simulated using numerical integration (e.g., explicit Euler) over the underlying differential equation. In ROS-based systems, this can be combined with packages such as ros_control and matrix libraries like Eigen to implement model-based controllers where a second-order approximation of a robot joint or link is sufficient for tuning gains.

The code below simulates the step response of the dominant second-order system using a simple Euler integrator for the state variables \( x_1 = y \), \( x_2 = \dot{y} \):

#include <iostream>
#include <vector>

struct SecondOrderSystem {
    double wn;    // natural frequency
    double zeta;  // damping ratio
    double k;     // DC gain

    // State: x1 = y, x2 = y_dot
    double x1;
    double x2;

    SecondOrderSystem(double wn_, double zeta_, double k_)
        : wn(wn_), zeta(zeta_), k(k_), x1(0.0), x2(0.0) {}

    // Compute derivatives for unit-step input u(t) = 1
    void derivatives(double& dx1, double& dx2) const {
        double u = 1.0;
        dx1 = x2;
        // y_ddot + 2*zeta*wn*y_dot + wn^2*y = wn^2*k*u
        dx2 = wn * wn * (k * u - x1) - 2.0 * zeta * wn * x2;
    }
};

int main() {
    double wn   = 5.0;
    double zeta = 0.4;
    double alpha = 50.0;
    double k = 1.0 / alpha;  // match DC gain of third-order system

    SecondOrderSystem sys(wn, zeta, k);

    double dt = 0.0005;
    double t_end = 4.0;
    int steps = static_cast<int>(t_end / dt);

    std::vector<double> t_vals;
    std::vector<double> y_vals;
    t_vals.reserve(steps + 1);
    y_vals.reserve(steps + 1);

    double t = 0.0;
    for (int k_step = 0; k_step <= steps; ++k_step) {
        t_vals.push_back(t);
        y_vals.push_back(sys.x1);

        double dx1, dx2;
        sys.derivatives(dx1, dx2);

        // Explicit Euler integration
        sys.x1 += dt * dx1;
        sys.x2 += dt * dx2;

        t += dt;
    }

    // Print a few samples (in practice, log to file or plot offline)
    for (int i = 0; i < t_vals.size(); i += steps / 10) {
        std::cout << "t = " << t_vals[i]
                  << "  y = " << y_vals[i] << std::endl;
    }

    return 0;
}
      

In a ROS node, this integrator can be called at each control cycle to simulate the dominant second-order dynamics of a robot joint, while the underlying full-order model is used in offline analysis.

8.1 Java (e.g., with WPILib in Educational Robotics)

In Java-based educational robotics (e.g., FRC robots using WPILib), robot subsystems (like flywheels and arm joints) are frequently modeled as second-order systems whose poles approximate the dominant behavior of higher-order dynamics. Below is a simple Java example integrating the same dominant second-order model as in the C++ code:

public class DominantSecondOrder {
    private double wn;
    private double zeta;
    private double k;
    private double x1;  // output y
    private double x2;  // derivative y_dot

    public DominantSecondOrder(double wn, double zeta, double k) {
        this.wn = wn;
        this.zeta = zeta;
        this.k = k;
        this.x1 = 0.0;
        this.x2 = 0.0;
    }

    // Compute derivatives for unit-step input u(t) = 1
    public void derivatives(double[] dx) {
        double u = 1.0;
        dx[0] = x2;
        dx[1] = wn * wn * (k * u - x1) - 2.0 * zeta * wn * x2;
    }

    public void step(double dt) {
        double[] dx = new double[2];
        derivatives(dx);
        x1 += dt * dx[0];
        x2 += dt * dx[1];
    }

    public double getOutput() {
        return x1;
    }

    public static void main(String[] args) {
        double wn = 5.0;
        double zeta = 0.4;
        double alpha = 50.0;
        double k = 1.0 / alpha;

        DominantSecondOrder sys = new DominantSecondOrder(wn, zeta, k);

        double dt = 0.001;
        double tEnd = 4.0;
        int steps = (int)(tEnd / dt);

        for (int i = 0; i <= steps; ++i) {
            double t = i * dt;
            sys.step(dt);
            if (i % (steps / 10) == 0) {
                System.out.println("t = " + t + "  y = " + sys.getOutput());
            }
        }
    }
}
      

Libraries such as WPILib provide higher-level classes for linear systems and state observers, but the underlying models are often second-order approximations derived by dominant pole considerations.

8.2 MATLAB/Simulink and Robotics System Toolbox

MATLAB has extensive facilities for transfer-function and time-response analysis. The Robotics System Toolbox and Simscape Multibody can model full robot dynamics, while control design often uses simpler dominant-pole models for each joint. The following script reproduces the Python comparison:

wn   = 5.0;
zeta = 0.4;
alpha = 50.0;

% Full third-order transfer function
num_full = [wn^2];
den_full = conv([1 alpha], [1 2*zeta*wn wn^2]);
G3 = tf(num_full, den_full);

% Dominant second-order approximation
num_dom = [wn^2 / alpha];
den_dom = [1 2*zeta*wn wn^2];
G2 = tf(num_dom, den_dom);

% Step responses
t = linspace(0, 4, 1000);
[y_full, t1] = step(G3, t);
[y_dom,  t2] = step(G2, t);

figure;
plot(t1, y_full, t2, y_dom, '--');
grid on;
xlabel('Time (s)');
ylabel('Output');
legend('Full 3rd order', 'Dominant 2nd order');
title('Dominant Pole Approximation in MATLAB');

% Robotics context (sketch):
%   - Use Robotics System Toolbox to build a rigid-body tree for a manipulator
%   - Linearize a joint around an operating point to obtain G3(s)
%   - Reduce to G2(s) using dominant poles, then design a PID controller on G2(s)
      

In Simulink, one would simply replace a high-order Transfer Fcn block by a second-order Transfer Fcn block using the dominant poles and compare the outputs via Scope blocks.

Wolfram Mathematica (Wolfram Language) offers symbolic and numeric tools for control systems. While it does not focus on robotics-specific toolboxes to the same extent as MATLAB, its general modeling functions are suitable for deriving and simplifying robot joint models via dominant pole approximations.

The code fragment below demonstrates the time response of the full and reduced systems:

(* Parameters *)
wn   = 5.0;
zeta = 0.4;
alpha = 50.0;

s = LaplaceTransformVariable;

(* Full third-order transfer function *)
G3 = TransferFunctionModel[
  wn^2 / ((s + alpha) (s^2 + 2 zeta wn s + wn^2)), s
];

(* Dominant second-order approximation *)
G2 = TransferFunctionModel[
  (wn^2/alpha) / (s^2 + 2 zeta wn s + wn^2), s
];

(* Step responses *)
{yFull, tFull} = StepResponse[G3, {0, 4}];
{yDom,  tDom}  = StepResponse[G2, {0, 4}];

ListLinePlot[
  {
    Transpose[{tFull, yFull}],
    Transpose[{tDom,  yDom}]
  },
  PlotLegends -> {"Full 3rd order", "Dominant 2nd order"},
  AxesLabel -> {"t (s)", "y(t)"},
  PlotLabel -> "Dominant Pole Approximation"
]
      

For robotics applications, one can first derive the full dynamics using multibody modeling tools and then extract a linearized transfer function for a particular joint; the dominant pole approximation is then performed at the level of the transfer function or state-space model.

Problem 1 (Error bound for fast pole): Consider the third-order transfer function

\[ G_3(s) = \frac{\omega_n^2}{(s + \alpha)\bigl(s^2 + 2\zeta \omega_n s + \omega_n^2\bigr)}, \quad \alpha > 0, \ 0 < \zeta < 1. \]

Derive an upper bound for the magnitude of the error between the full unit-step response \( c_3(t) \) and the second-order approximation \( c_2(t) \) obtained by neglecting the pole at \( s=-\alpha \) and matching DC gain. Show that this error decays at least as fast as \( e^{-\alpha t} \).

Solution:

As in Section 4, we write the step response of the full system as

\[ c_3(t) = A + B e^{-\alpha t} + e^{-\zeta \omega_n t} \bigl( E \cos(\omega_d t) + F \sin(\omega_d t) \bigr), \]

where \( \omega_d = \omega_n \sqrt{1 - \zeta^2} \) and \( A \) is the steady-state value. The second-order approximation \( c_2(t) \) retains the decaying sinusoidal term and the same steady-state value, so

\[ c_2(t) = A + e^{-\zeta \omega_n t} \bigl( E \cos(\omega_d t) + F \sin(\omega_d t) \bigr). \]

The error is therefore

\[ e(t) = c_3(t) - c_2(t) = B e^{-\alpha t}. \]

Taking absolute values,

\[ |e(t)| = |B| e^{-\alpha t} \le |B| e^{-\alpha t}, \]

so the error decays at least as fast as \( e^{-\alpha t} \), with an amplitude bound \( |B| \) that depends on the parameters of \( G_3(s) \).

Problem 2 (Numerical check of dominance): A closed-loop system has poles at \( p_{1,2} = -2 \pm 4 \mathrm{j} \) and \( p_3 = -20 \). Using the rule-of-thumb that non-dominant poles should be at least 5 times faster than dominant poles, decide whether \( p_3 \) can be neglected. What is the approximate second-order dominant system in terms of \( \zeta \) and \( \omega_n \)?

Solution:

The dominant conjugate poles are \( p_{1,2} = -2 \pm 4 \mathrm{j} \), with real part \( \sigma_d = -2 \). The fast pole is \( p_3 = -20 \), so

\[ \frac{|\Re(p_3)|}{|\Re(p_1)|} = \frac{20}{2} = 10. \]

Since this ratio is greater than 5, the fast pole is an order of magnitude faster and can be neglected in a first approximation. To map the dominant poles to standard second-order parameters, we recall that

\[ p_{1,2} = -\zeta \omega_n \pm \mathrm{j} \omega_n \sqrt{1 - \zeta^2}. \]

Matching real and imaginary parts:

\[ \zeta \omega_n = 2, \quad \omega_n \sqrt{1 - \zeta^2} = 4. \]

From the second equation,

\[ 16 = \omega_n^2 (1 - \zeta^2). \]

From the first, \( \omega_n = 2 / \zeta \). Substituting:

\[ 16 = \left(\frac{2}{\zeta}\right)^2 (1 - \zeta^2) = \frac{4}{\zeta^2} (1 - \zeta^2) = \frac{4}{\zeta^2} - 4. \]

Thus

\[ 16 + 4 = \frac{4}{\zeta^2} \quad \Rightarrow \quad \frac{4}{\zeta^2} = 20 \quad \Rightarrow \quad \zeta^2 = \frac{1}{5} \quad \Rightarrow \quad \zeta = \sqrt{\frac{1}{5}} \approx 0.447. \]

Then

\[ \omega_n = \frac{2}{\zeta} \approx \frac{2}{0.447} \approx 4.472. \]

The approximate second-order dominant system has \( \zeta \approx 0.447 \) and \( \omega_n \approx 4.47 \).

Problem 3 (Dominant poles in a robot joint model): A simplified single-joint robot model has the closed-loop characteristic polynomial

\[ (s + 80)\bigl(s^2 + 6 s + 25\bigr) = 0. \]

Interpret physically which dynamics correspond to the fast pole and which to the dominant pair, and argue why a second-order approximation using only \( s^2 + 6 s + 25 \) is appropriate for studying overshoot and settling time.

Solution:

The roots of \( s^2 + 6 s + 25 \) describe a pair of complex conjugate poles with real part \( \sigma_d = -3 \) and imaginary part \( \omega_d = 4 \) (since the discriminant is negative: \( 6^2 - 4 \cdot 25 = 36 - 100 < 0 \)). These correspond to the main inertia and damping associated with the joint and load.

The fast pole \( s = -80 \) is far to the left, so its associated time constant is \( T_f = 1/80 \), much smaller than the time constant associated with \( \sigma_d = -3 \), which is \( T_d \approx 1/3 \). In a robot joint, such a fast pole typically corresponds to electrical dynamics of the motor or very fast inner current loops that settle almost instantaneously compared to mechanical motion.

Therefore, for studying mechanical overshoot and settling time of the joint angle, the dominant pair is sufficient, and we can approximate the system by the second-order factor \( s^2 + 6 s + 25 \) with properly adjusted gain.

Problem 4 (Flow-based criterion for keeping poles): Suppose you have a fourth-order system with real poles at \( -1, -5, -20, -50 \). Using the rule that poles with \( |\Re(p)| \) greater than 5 times that of the dominant one may be neglected, construct a decision flow for choosing whether to use a first-, second-, or higher-order approximation.

Solution (flow):

flowchart TD
  S["Poles: -1, -5, -20, -50"] --> A["Identify slowest pole: -1"]
  A --> B{"Are other poles >= 5 times faster?"}
  B -->|"{-5}"| C["5 times faster → \nmay keep or neglect"]
  B -->|"{-20, -50}"| D["20, 50 times faster → \nnegligible"]
  C --> E{"Need underdamped \ndynamics?"}
  E -->|yes| F["Use at least 2-pole model \nif complex pair present"]
  E -->|no| G["First-order model with \npole at -1 may suffice"]
        

Here all poles other than \( -1 \) are at least 5 times faster; thus, in the absence of complex conjugate poles, a first-order dominant approximation with pole at \( -1 \) is usually acceptable. If the original system had a dominant complex pair instead of a single real pole, we would use a second-order approximation.

Problem 5 (When dominant pole approximation fails): Give two situations where the dominant pole approximation can be misleading or invalid, even if some poles are much faster than others.

Solution:

• Large non-minimum-phase zeros: Even if the fast poles are far to the left, right-half-plane zeros or large magnitude left-half-plane zeros can strongly influence the time response (e.g., large undershoot), so a reduced model that ignores zero locations may fail.
• Mode cancellation in feedback: In some feedback configurations, approximate pole-zero cancellation between the controller and plant can make fast modes reappear in the closed-loop sensitivity function. A reduced model that ignores those modes might predict a stable or well-damped response when the full system has poor robustness or hidden resonances.

In this lesson, we expressed the time response of higher-order LTI systems directly in terms of their poles and residues, and we formalized the notion of dominant poles whose modes decay slowly and govern the transient behavior. We derived error bounds showing that contributions from fast poles decay at least as \( e^{\sigma_f t} \) with real part \( \sigma_f \ll \sigma_d < 0 \), and we illustrated how to reduce a third-order system with one fast pole to an equivalent second-order model with matched DC gain. We also implemented this approximation numerically in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, noting how such simplifications are exploited in robotics control stacks for joint-level control design. Dominant pole approximations will be used repeatedly in later chapters when we relate pole locations to time-domain performance specifications and carry out controller design.