In the previous lessons we worked with the standard second-order closed-loop transfer function (for a unit-step input, e.g. a position servo or a robot joint under simple feedback):

\[ G_0(s) \;=\; \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \qquad 0 < \zeta < 1, \ \omega_n > 0. \]

For a unit-step input \( u(t) = 1(t) \) the Laplace transform of the output is

\[ Y_0(s) \;=\; \frac{G_0(s)}{s} \;=\; \frac{\omega_n^2}{s\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)}. \]

The corresponding time response \( y_0(t) \) (for \( 0 < \zeta < 1 \)) is

\[ y_0(t) \;=\; 1 - \frac{e^{-\zeta\omega_n t}}{\sqrt{1-\zeta^2}} \sin\!\big(\omega_d t + \phi\big), \quad \omega_d = \omega_n\sqrt{1-\zeta^2}, \quad \phi = \arccos(\zeta). \]

Real systems are rarely exactly second order. In robotics, for example, actuator dynamics, sensor dynamics, and structural flexibilities contribute additional poles and zeros. A general single-input single-output (SISO) transfer function can be written as

\[ G(s) \;=\; \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0} {s^n + a_{n-1}s^{n-1} + \cdots + a_0}, \qquad n \ge 2,\ m \le n-1, \]

where the roots of the denominator are the poles and the roots of the numerator are the zeros. In this lesson, we consider how adding real poles and zeros to the baseline second-order form changes the time response while keeping the basic feedback structure unchanged.

flowchart LR
  R["Reference r(t)"] --> C["Controller (unity)"]
  C --> P0["Second-order plant G0(s)"]
  P0 --> Y0["Output y0(t)"]
  C --> Pp["G0(s) with extra pole"]
  Pp --> Yp["Output yp(t)"]
  C --> Pz["G0(s) with extra zero"]
  Pz --> Yz["Output yz(t)"]
        

Consider adding a single real pole at \( s = -a \), \( a > 0 \), to the second-order transfer function. We start with

\[ G_p(s) \;=\; \frac{k_p \omega_n^2}{(s+a)\big(s^2 + 2\zeta\omega_n s + \omega_n^2\big)}. \]

To make a fair comparison of time responses, we often normalize the DC gain to unity: \( G_p(0) = 1 \). Evaluating at \( s=0 \) gives

\[ G_p(0) \;=\; \frac{k_p \omega_n^2}{a \omega_n^2} \;=\; \frac{k_p}{a}, \qquad \Rightarrow \qquad k_p = a. \]

With this choice,

\[ G_p(s) = \frac{a \omega_n^2}{(s+a)\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)}. \]

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

\[ Y_p(s) = \frac{G_p(s)}{s} = \frac{a\omega_n^2}{s(s+a)\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)}. \]

Using partial fraction expansion, we can write

\[ Y_p(s) = \frac{A}{s} + \frac{B}{s+a} + \frac{Cs + D}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

where the constants \( A,B,C,D \) are determined algebraically. The final value theorem confirms that \( A = 1 \), since

\[ \lim_{t\to\infty} y_p(t) = \lim_{s\to 0} s Y_p(s) = G_p(0) = 1. \]

Taking the inverse Laplace transform, the time-domain response has the form

\[ y_p(t) = 1 + B e^{-a t} + e^{-\zeta\omega_n t}\big(\alpha \cos(\omega_d t) + \beta \sin(\omega_d t)\big), \]

where \( \omega_d = \omega_n \sqrt{1 - \zeta^2} \) and \( \alpha,\beta \) are functions of \( a,\zeta,\omega_n \). Thus, the response is a sum of:

• a slow or fast real mode \( e^{-a t} \), and
• the familiar second-order oscillatory mode \( e^{-\zeta\omega_n t}\sin(\cdot), e^{-\zeta\omega_n t}\cos(\cdot) \).

The time constant associated with the new pole is \( \tau_p = \frac{1}{a} \). Comparing the dominant decay rates:

\[ T_{s,2} \approx \frac{4}{\zeta\omega_n}, \qquad T_{s,p} \approx 4 \tau_p = \frac{4}{a}. \]

The effective settling time of the combined system is roughly

\[ T_s^{(\text{overall})} \approx \max\!\left\{\frac{4}{\zeta\omega_n}, \frac{4}{a}\right\}. \]

Qualitative conclusions:

• If \( a \gg \zeta\omega_n \) (the additional pole is far to the left), then \( T_{s,p} \ll T_{s,2} \) and the extra mode dies out quickly. The step response is still dominated by the original second-order part, and classical formulas for rise time, overshoot, and settling time remain accurate.
• If \( a \approx \zeta\omega_n \), the additional pole is not negligible; it introduces a comparable real mode that slightly slows down the decay envelope and can modify overshoot.
• If \( a \ll \zeta\omega_n \) (very slow pole), then the slow exponential \( e^{-a t} \) dominates the late-time behavior, increasing the settling time significantly and sometimes creating a sluggish tail in the response.

This analysis is the basis of the dominant pole approximation, which will be formalized in the next lesson.

Now consider adding a real zero at \( s = -z \) with \( z > 0 \) to the second-order system. We choose the gain so that the DC gain is still unity:

\[ G_z(s) \;=\; \frac{k_z (s+z)\omega_n^2} {s^2 + 2\zeta\omega_n s + \omega_n^2}. \]

Enforcing \( G_z(0) = 1 \) gives

\[ G_z(0) = \frac{k_z z \omega_n^2}{\omega_n^2} = k_z z = 1 \quad\Rightarrow\quad k_z = \frac{1}{z}. \]

Thus we take

\[ G_z(s) = \frac{(s+z)\omega_n^2}{z\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)}. \]

For a unit-step input,

\[ Y_z(s) = \frac{G_z(s)}{s} = \frac{(s+z)\omega_n^2} {z\,s\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)}. \]

Using partial fractions, we obtain

\[ Y_z(s) = \frac{A}{s} + \frac{B}{s^2 + 2\zeta\omega_n s + \omega_n^2} + \frac{C s}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

with \( A = 1 \) (from the final value theorem) and \( B,C \) depending on \( z,\zeta,\omega_n \). In the time domain,

\[ y_z(t) = 1 + e^{-\zeta\omega_n t} \Big( \alpha_z \cos(\omega_d t) + \beta_z \sin(\omega_d t) \Big), \]

where \( \alpha_z,\beta_z \) are functions of \( z \). Compared with the pure second-order case, the coefficients of the oscillatory terms are modified; this changes overshoot and rise time.

A useful quantity is the initial slope of the step response. Using the Laplace derivative property:

\[ \left. \frac{dy_z}{dt} \right|_{t=0^+} = \lim_{s\to\infty} s^2 Y_z(s) = \lim_{s\to\infty} s G_z(s). \]

For large \( s \),

\[ G_z(s) \approx \frac{s\omega_n^2}{z s^2} = \frac{\omega_n^2}{z s} \quad\Rightarrow\quad s G_z(s) \approx \frac{\omega_n^2}{z}. \]

Hence, the initial slope is approximately

\[ \left. \frac{dy_z}{dt} \right|_{t=0^+} \approx \frac{\omega_n^2}{z}. \]

Compared with the baseline second-order system, a smaller \( z \) (zero closer to the origin) yields a larger initial slope, i.e. a faster initial rise. However, this often comes with:

• increased overshoot (because the oscillatory part has larger magnitude), and
• potentially increased sensitivity to disturbances and modeling errors in early transient behavior.

Thus, adding a left-half-plane real zero generally makes the response faster and more aggressive, but often at the cost of higher overshoot.

Suppose the zero is located at \( s = +z_0 \) with \( z_0 > 0 \). The numerator factor is then \( s - z_0 \). Again we choose the gain so that \( G(0) = 1 \):

\[ G_{z_0}(s) = \frac{k (s - z_0)\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \qquad G_{z_0}(0) = \frac{-k z_0 \omega_n^2}{\omega_n^2} = -k z_0 = 1 \]

\[ \Rightarrow \quad k = -\frac{1}{z_0}. \]

The high-frequency behavior is again characterized by

\[ \left.\frac{dy}{dt}\right|_{t=0^+} = \lim_{s\to\infty} s G_{z_0}(s) = \lim_{s\to\infty} \frac{-s(s - z_0)\omega_n^2}{z_0 s^2} = -\frac{\omega_n^2}{z_0}. \]

Therefore, the initial slope of the step response is negative: the output first moves in the wrong direction (an inverse response) before eventually moving toward the positive steady-state value. Such behavior is undesirable in many control applications (e.g. a robot joint that briefly moves backward before moving forward).

In summary:

• Left-half-plane zeros accelerate the response and increase overshoot.
• Right-half-plane zeros cause an initial inverse motion, typically reducing overshoot but complicating controller design.

The analysis above leads to several useful rules of thumb for predicting qualitative effects of additional poles and zeros on time responses:

• Additional poles always make the system at least as slow, never faster. A pole far to the left has minor impact; a pole near the imaginary axis dominates the settling behavior.
• Left-half-plane zeros tend to sharpen the response, decreasing rise time but increasing overshoot.
• Right-half-plane zeros induce an initial inverse response and often yield more conservative transient behavior requirements.
• When several poles are present, the pair (or one real pole) closest to the imaginary axis usually dominates the long-term transient behavior.

The following flow diagram summarizes an analysis procedure for a given higher-order transfer function:

flowchart TD
  A["Start: Given G(s)"] --> B["Factor numerator and denominator"]
  B --> C["Locate poles: find ones near imaginary axis"]
  C --> D["Locate zeros: left or right half plane?"]
  D --> E["Compare time constants / damping of modes"]
  E --> F["Predict rise time, overshoot, settling trend"]
        

We now simulate a baseline second-order system, the same system with an additional pole, and the same system with an additional left-half-plane zero using Python. Libraries such as numpy, matplotlib, and the control package are standard. For robotics, such transfer-function models are often embedded in higher-level simulation environments (e.g. Python-based robotic toolboxes) to model joint dynamics or link motion.

import numpy as np
import matplotlib.pyplot as plt

# If available, use the python-control package
# pip install control
import control as ctl

# Baseline second-order parameters
zeta = 0.4
wn   = 5.0  # rad/s

# Baseline second-order transfer function: G0(s) = wn^2 / (s^2 + 2 zeta wn s + wn^2)
num0 = [wn**2]
den0 = [1.0, 2.0*zeta*wn, wn**2]
G0 = ctl.TransferFunction(num0, den0)

# Extra pole at s = -a
a = 20.0  # fast pole
kp = a
num_p = [kp * wn**2]
den_p = np.polymul([1.0, a], den0)
Gp = ctl.TransferFunction(num_p, den_p)

# Extra left-half-plane zero at s = -z
z = 2.0
kz = 1.0 / z
num_z = [kz*wn**2, kz*z*wn**2]  # (s + z)*wn^2 / z
den_z = den0
Gz = ctl.TransferFunction(num_z, den_z)

t = np.linspace(0, 4.0, 1000)
t0, y0 = ctl.step_response(G0, T=t)
tp, yp = ctl.step_response(Gp, T=t)
tz, yz = ctl.step_response(Gz, T=t)

plt.figure()
plt.plot(t0, y0, label="Second-order")
plt.plot(tp, yp, label="With extra pole at -a")
plt.plot(tz, yz, label="With zero at -z")
plt.xlabel("Time [s]")
plt.ylabel("Response y(t)")
plt.title("Effect of Additional Pole and Zero on Step Response")
plt.grid(True)
plt.legend()
plt.show()
      

In a robotics context, G0(s) could represent a single joint with a simple actuator model. Additional poles might represent actuator current dynamics, while zeros can arise from sensor dynamics or feedback linearization structures. Python toolboxes for robotics (e.g. those providing kinematics and dynamics) can be coupled with this kind of low-order joint model for more realistic simulation of robot motion.

In C++, a common approach is to represent the system in state-space form and integrate the ordinary differential equations numerically. The Eigen library is widely used for linear algebra and appears in many robotics frameworks (e.g. ROS-based controllers and model-based control stacks).

For the third-order system with an extra pole at \( s = -a \), one possible controllable canonical state-space realization is

\[ \dot{\mathbf{x}} = A\mathbf{x} + B u, \quad y = C\mathbf{x}, \]

with appropriately chosen matrices \( A,B,C \). The code below integrates the state using simple forward Euler (for illustration only).

#include <iostream>
#include <vector>
#include <Eigen/Dense>

int main() {
    double zeta = 0.4;
    double wn   = 5.0;
    double a    = 20.0;

    // Third-order denominator: (s + a)(s^2 + 2 zeta wn s + wn^2)
    // For simulation, we pick a companion form realization.
    // x_dot = A x + B u, y = C x

    Eigen::Matrix3d A;
    Eigen::Vector3d B;
    Eigen::RowVector3d C;

    // Coefficients of s^3 + alpha2 s^2 + alpha1 s + alpha0
    double alpha2 = 2.0*zeta*wn + a;
    double alpha1 = wn*wn + 2.0*zeta*wn*a;
    double alpha0 = wn*wn*a;

    // Companion matrix (controllable canonical form)
    A <<  0.0,     1.0,     0.0,
           0.0,     0.0,     1.0,
          -alpha0, -alpha1, -alpha2;

    B << 0.0, 0.0, 1.0;
    // Choose C so that DC gain is approximately 1 (here we set C = [c0 c1 c2])
    // For simplicity, pick C = [0 0 k]; in practice, compute from transfer function.
    double kp = a;
    double k  = kp * wn*wn;
    C << 0.0, 0.0, k;

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

    Eigen::Vector3d x = Eigen::Vector3d::Zero();
    double u = 1.0;  // unit step
    for (int kstep = 0; kstep <= steps; ++kstep) {
        double t = kstep * dt;
        double y = (C * x)(0);

        std::cout << t << " " << y << std::endl;

        Eigen::Vector3d xdot = A * x + B * u;
        x += dt * xdot;
    }
    return 0;
}
      

In a robotics stack, a similar state-space model would be embedded inside a real-time controller, with states representing joint position, velocity, and additional actuator dynamics. Libraries such as ros_control (for ROS) often rely on such state-space structures combined with Eigen-based computations.

Java is frequently used in educational robotics (e.g. for competition robots) and industrial control interfaces. Below, we simulate the same third-order system using a simple Euler integrator. Java libraries such as EJML can be used for more advanced linear algebra, and robotics frameworks (e.g. FIRST WPILib) often expose similar numerical integration patterns.

public class ExtraPoleSimulation {

    public static void main(String[] args) {
        double zeta = 0.4;
        double wn   = 5.0;
        double a    = 20.0;

        double alpha2 = 2.0*zeta*wn + a;
        double alpha1 = wn*wn + 2.0*zeta*wn*a;
        double alpha0 = wn*wn*a;

        double kp = a;
        double k  = kp * wn*wn;

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

        // State x = [x1; x2; x3]
        double x1 = 0.0, x2 = 0.0, x3 = 0.0;
        double u  = 1.0;

        for (int i = 0; i <= steps; i++) {
            double t = i * dt;
            double y = k * x3;  // y = C x, with C = [0 0 k]

            System.out.println(t + " " + y);

            // xdot = A x + B u, with companion A and B = [0; 0; 1]
            double dx1 = x2;
            double dx2 = x3;
            double dx3 = -alpha0*x1 - alpha1*x2 - alpha2*x3 + u;

            x1 += dt * dx1;
            x2 += dt * dx2;
            x3 += dt * dx3;
        }
    }
}
      

By changing the coefficients alpha2, alpha1, and alpha0 according to different pole locations, and similarly adjusting the numerator gain and zeros, one can quickly visualize how the time response changes. In robotics frameworks, these models can represent low-level actuator subsystems.

MATLAB and Simulink are standard tools in control engineering and robotics. MATLAB's tf and step functions allow easy comparison of time responses, and Simulink enables block-diagram simulation where additional poles and zeros are introduced as first-order blocks and zero blocks.

% Parameters
zeta = 0.4;
wn   = 5.0;

% Baseline second-order
num0 = wn^2;
den0 = [1  2*zeta*wn  wn^2];
G0 = tf(num0, den0);

% Extra pole at s = -a
a  = 20;
kp = a;
num_p = kp * wn^2;
den_p = conv([1 a], den0);
Gp = tf(num_p, den_p);

% Extra zero at s = -z
z  = 2;
kz = 1/z;
num_z = [kz*wn^2  kz*z*wn^2];  % (s + z)*wn^2 / z
den_z = den0;
Gz = tf(num_z, den_z);

% Step responses
t = 0:0.001:4;
[y0, t0] = step(G0, t);
[yp, tp] = step(Gp, t);
[yz, tz] = step(Gz, t);

figure;
plot(t0, y0, 'LineWidth', 1.5); hold on;
plot(tp, yp, 'LineWidth', 1.5);
plot(tz, yz, 'LineWidth', 1.5);
grid on;
xlabel('Time [s]');
ylabel('Response y(t)');
legend('Second-order', 'Extra pole', 'Extra zero');

title('Effect of Additional Pole and Zero on Step Response');

% -------------------------
% Simple Simulink setup (script-driven)
% -------------------------
% You can create a Simulink model programmatically:
%   new_system('extraPoleZeroModel');
%   open_system('extraPoleZeroModel');
% Then insert Transfer Fcn blocks with numerator/denominator corresponding
% to G0, Gp, and Gz, and connect them to a Step block and Scope blocks.
% Robotics System Toolbox can be used to connect these low-order models
% to manipulator or mobile-robot dynamics blocks.
      

In Simulink, additional poles are represented naturally by cascaded first-order transfer function blocks, and zeros by adding numerator terms. The Robotics System Toolbox allows connecting such low-order actuator models to rigid-body dynamics of robot arms and mobile robots for realistic simulations.

Wolfram Mathematica provides symbolic and numeric tools for time-response analysis. The following example constructs the same transfer functions and plots their step responses.

zeta = 0.4;
wn   = 5.0;

G0[s_] := wn^2 / (s^2 + 2 zeta wn s + wn^2);

a  = 20.0;
kp = a;
Gp[s_] := (kp wn^2) / ((s + a) (s^2 + 2 zeta wn s + wn^2));

z  = 2.0;
kz = 1.0/z;
Gz[s_] := (kz (s + z) wn^2) / (s^2 + 2 zeta wn s + wn^2);

tf0 = TransferFunctionModel[G0[s], s];
tfp = TransferFunctionModel[Gp[s], s];
tfz = TransferFunctionModel[Gz[s], s];

PlotRangeAll = {0, 4};

StepResponsePlot[{tf0, tfp, tfz}, {t, 0, 4},
  PlotLegends -> {"Second-order", "Extra pole", "Extra zero"},
  AxesLabel -> {"t [s]", "y(t)"},
  PlotRange -> All
]
      

Symbolic tools can also be used to compute exact expressions for the time responses and to verify approximations such as the dominant pole approximation and the effect of shifting zeros.

Problem 1 (Extra Fast Pole):

Consider a second-order system with \( \zeta = 0.5 \) and \( \omega_n = 4 \,\text{rad/s} \). An additional real pole is placed at \( s = -20 \). Assume the DC gain is normalized to one.

1. Write the third-order transfer function.
2. Estimate the settling time (2 % criterion) using the dominant pole argument.

Solution:

1) The baseline second-order denominator is \( s^2 + 2\zeta\omega_n s + \omega_n^2 = s^2 + 4 s + 16 \). Adding a pole at \( -20 \) gives

\[ G_p(s) = \frac{k_p \omega_n^2}{(s+20)(s^2 + 4 s + 16)}. \]

With \( G_p(0) = 1 \), we get \( k_p = 20 \), so

\[ G_p(s) = \frac{20 \cdot 16}{(s+20)(s^2 + 4 s + 16)} = \frac{320}{(s+20)(s^2 + 4 s + 16)}. \]

2) The second-order settling time (2 %) is approximately \( T_{s,2} \approx \frac{4}{\zeta\omega_n} = \frac{4}{0.5 \cdot 4} = 2 \,\text{s} \). The new pole time constant is \( \tau_p = 1/20 = 0.05 \,\text{s} \), so its own settling time is \( T_{s,p} \approx 4 \tau_p = 0.2 \,\text{s} \).

\[ T_s^{(\text{overall})} \approx \max\{2,\ 0.2\} = 2 \,\text{s}. \]

Hence the additional fast pole has negligible effect on the 2 % settling time.

Problem 2 (Extra Slow Pole):

Repeat Problem 1 but with the additional pole at \( s = -0.5 \). Estimate the new settling time.

Solution:

The pole time constant is now \( \tau_p = 1/0.5 = 2 \,\text{s} \), giving \( T_{s,p} \approx 4 \tau_p = 8 \,\text{s} \). The second-order part still has \( T_{s,2} \approx 2 \,\text{s} \), but the slow pole now dominates:

\[ T_s^{(\text{overall})} \approx \max\{2,\ 8\} = 8 \,\text{s}. \]

The additional slow pole significantly increases the settling time, creating a long tail in the response.

Problem 3 (Initial Slope with Left-Half-Plane Zero):

For the system in Section 3 with \( G_z(s) = \frac{(s+z)\omega_n^2} {z\left(s^2 + 2\zeta\omega_n s + \omega_n^2\right)} \), compute the initial slope of the step response and compare it with the baseline second-order system whose initial slope is \( \omega_n^2 \).

Solution:

As derived in Section 3, for a unit step,

\[ \left. \frac{dy_z}{dt} \right|_{t=0^+} = \lim_{s\to\infty} s^2 Y_z(s) = \lim_{s\to\infty} s G_z(s) = \frac{\omega_n^2}{z}. \]

The baseline second-order system has

\[ \left.\frac{dy_0}{dt}\right|_{t=0^+} = \omega_n^2. \]

Thus, if \( z < 1 \), then \( \omega_n^2 / z > \omega_n^2 \), yielding a larger initial slope and faster early response. If \( z > 1 \), the initial slope is reduced.

Problem 4 (Inverse Response Due to Right-Half-Plane Zero):

For the system in Section 4 with a zero at \( s = +z_0, z_0 > 0 \), show that the output initially moves in the direction opposite to the final step change.

Solution:

As derived in Section 4, with gain chosen so that \( G_{z_0}(0) = 1 \), the initial slope is

\[ \left.\frac{dy}{dt}\right|_{t=0^+} = \lim_{s\to\infty} s G_{z_0}(s) = -\frac{\omega_n^2}{z_0} < 0. \]

For a positive unit-step input, the final value is \( y(\infty)=1 \), but the negative initial slope implies that \( y(t) \) first decreases for small \( t \) before eventually increasing toward 1. This is the characteristic inverse response associated with right-half-plane zeros.

Problem 5 (Qualitative Classification via Pole/Zero Map):

You are given a transfer function whose poles and zeros are: \( \{-1, -4 \pm 3j, -15\} \) and \( \{-2, +3\} \). Make qualitative predictions about:

• the dominant mode determining settling time,
• the effect of the left-half-plane zero at \( -2 \), and
• the effect of the right-half-plane zero at \( +3 \).

Solution:

The pole closest to the imaginary axis is \( -1 \), so the corresponding real mode with time constant \( \tau = 1 \) dominates the settling behavior. The complex pair \( -4 \pm 3j \) is faster and mainly shapes the oscillatory portion of the early transient.

The zero at \( -2 \) lies in the left half-plane and will tend to increase the initial slope and possibly the overshoot, making the response more aggressive. The zero at \( +3 \) is in the right half-plane, so the initial response will show an inverse motion before eventually moving toward the final steady state. The combination of a slow pole and a right-half-plane zero leads to challenging transient behavior for controller design.

In this lesson, we extended the analysis of second-order systems to higher-order systems obtained by adding poles and zeros. By expressing the step response as a sum of exponential modes, we saw how an additional real pole introduces a new time constant that can be negligible (fast pole) or dominant (slow pole). We characterized left-half-plane zeros as elements that tend to speed up the response and increase overshoot, and right-half-plane zeros as sources of inverse responses.

We implemented numerical simulations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, illustrating how these theoretical concepts appear in practice, especially in robotic actuator models. The next lesson formalizes the idea of dominant poles and provides systematic approximation techniques for complex higher-order systems.