In classical control, a SISO transfer function is a rational function \( G(s) \). In modern control, the same map is represented by \( (A,B,C,D) \) via \( G(s) = C(sI-A)^{-1}B + D \). A key bridge between these perspectives is the observation that transfer functions can be algebraically simplified (by canceling common factors), while the underlying internal dynamics may still exist in a nonminimal realization.

By the end of this lesson, you will be able to:

• Factor a rational transfer function into polynomial factors and perform exact cancellation using the greatest common divisor (gcd) of polynomials.
• Explain (and prove) why pole-zero cancellation can remove poles from \( G(s) \) while leaving dynamical behavior in internal signals of an interconnection.
• Construct a series (cascade) realization whose overall transfer function has cancellations, and identify the internal state(s) corresponding to canceled factors.
• Implement factorization and cancellation in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

flowchart TD
  A["Start with transfer function G(s)=N(s)/D(s)"] --> B["Factor N(s), D(s) over R (or C)"]
  B --> C["Compute q(s)=gcd(N(s),D(s))"]
  C --> D["Cancel: G_min(s)=Nbar(s)/Dbar(s) where Nbar=N/q and Dbar=D/q"]
  D --> E["Pick interconnection: direct realization or cascade of factors"]
  E --> F["Build state-space (A,B,C,D) for chosen structure"]
  F --> G["Compare: external map y/u vs internal signals and states"]
        

Consider a proper rational transfer function (SISO) \( G(s) = \dfrac{N(s)}{D(s)} \), where \( N(s), D(s) \in \mathbb{R}[s] \), and \( D(s)\neq 0 \). We assume \( N \) and \( D \) are not both zero and that \( D \) is monic (this normalization is always possible by dividing numerator and denominator by the leading coefficient of \( D \)).

Let \( q(s) = \gcd(N(s),D(s)) \) be the greatest common divisor in \( \mathbb{R}[s] \), chosen monic. Define reduced polynomials \( \bar{N}(s) = N(s)/q(s) \) and \( \bar{D}(s) = D(s)/q(s) \).

2.1 Reduced (Canceled) Form and Coprimeness

The reduced transfer function is \( G_{\min}(s) = \dfrac{\bar{N}(s)}{\bar{D}(s)} \). By construction, \( \gcd(\bar{N},\bar{D}) = 1 \) (coprime polynomials).

Proposition 1 (Uniqueness of Reduced Form up to Scaling).

Suppose \( \dfrac{N_1(s)}{D_1(s)} = \dfrac{N_2(s)}{D_2(s)} \) with \( \gcd(N_1,D_1)=\gcd(N_2,D_2)=1 \). Then there exists a nonzero constant \( \alpha \in \mathbb{R}\setminus\{0\} \) such that \( N_2(s)=\alpha N_1(s) \) and \( D_2(s)=\alpha D_1(s) \).

Proof. Cross-multiplying yields

\[ N_1(s)D_2(s) = N_2(s)D_1(s). \]

Since \( \gcd(N_1,D_1)=1 \), any irreducible factor of \( N_1 \) cannot divide \( D_1 \). From the identity above, every factor of \( N_1 \) must divide \( N_2 \). Thus \( N_1 \mid N_2 \). By symmetry, \( N_2 \mid N_1 \). Therefore \( N_2 = \alpha N_1 \) for some nonzero constant \( \alpha \). Substituting back gives \( D_2 = \alpha D_1 \). ■

This proposition formalizes that after cancellation, the remaining poles (roots of \( \bar{D}(s) \)) and zeros (roots of \( \bar{N}(s) \)) are intrinsic to the input-output behavior. Any canceled factor \( q(s) \) is not visible in \( G_{\min}(s) \).

2.2 A Useful State-Space Identity: Adjugate Representation

From Lesson 1, we have \( G(s)=C(sI-A)^{-1}B+D \). For square \( (sI-A) \), the inverse admits the adjugate form:

\[ (sI-A)^{-1} = \frac{\operatorname{adj}(sI-A)}{\det(sI-A)}. \]

Therefore,

\[ G(s) = \frac{C\,\operatorname{adj}(sI-A)\,B}{\det(sI-A)} + D. \]

This shows explicitly how transfer-function poles arise from the characteristic polynomial \( \det(sI-A) \), and how cancellations can occur if the scalar polynomial \( C\,\operatorname{adj}(sI-A)\,B \) shares factors with \( \det(sI-A) \). The key lesson is: the matrix \( A \) can contain eigenvalues that do not appear as poles of \( G(s) \) after cancellation.

Algebraic factorization becomes physically meaningful when interpreted as an interconnection of subsystems. The most important case (for internal dynamics) is a series (cascade) interconnection. If \( G(s) = G_2(s)G_1(s) \), then the intermediate signal \( v \) (output of \( G_1 \) and input to \( G_2 \)) is an internal signal. Its behavior is not determined solely by the reduced transfer function of \( y/u \).

3.1 A Canonical Cancellation Example

Consider the factorization \( G(s)=G_2(s)G_1(s) \) with

\[ G_1(s)=\frac{s+1}{s+2},\qquad G_2(s)=\frac{s+2}{s+3}. \]

Then the overall transfer function is

\[ G(s)=\frac{s+2}{s+3}\cdot\frac{s+1}{s+2}=\frac{s+1}{s+3}, \]

which has a cancellation of the factor \( (s+2) \).

Key point: Even though the external map \( y/u \) does not have a pole at \( s=-2 \), the internal signal \( v/u \) generally does.

Indeed, \( v = G_1(s)u \) implies

\[ \frac{v(s)}{u(s)} = \frac{s+1}{s+2}, \]

which still contains the pole at \( s=-2 \). This pole is “hidden” from the overall output but appears in internal signals. This is one rigorous interpretation of internal dynamics.

flowchart TD
  U["u (input)"] --> G1["Block 1: (s+1)/(s+2)"]
  G1 --> V["v (internal signal)"]
  V --> G2["Block 2: (s+2)/(s+3)"]
  G2 --> Y["y (output)"]
  note1["Overall y/u = (s+1)/(s+3) (factor (s+2) cancels)"] --- Y
  note2["Internal v/u = (s+1)/(s+2) keeps pole at -2"] --- V
        

3.2 Constructive State-Space Realizations Showing Hidden Modes

We now realize \( G_1 \) and \( G_2 \) in state space and connect them in series. Use the identity (partial fraction style):

\[ \frac{s+a}{s+b} = 1 + \frac{a-b}{s+b}. \]

For \( G_1(s)=\dfrac{s+1}{s+2} \), we get \( G_1(s)=1-\dfrac{1}{s+2} \). A realization is:

\[ \dot{x}_1 = -2x_1 + u,\qquad v = -x_1 + u. \]

For \( G_2(s)=\dfrac{s+2}{s+3}=1-\dfrac{1}{s+3} \), a realization is:

\[ \dot{x}_2 = -3x_2 + v,\qquad y = -x_2 + v. \]

The cascade state vector is \( x = \begin{bmatrix}x_1 & x_2\end{bmatrix}^T \) and the combined dynamics are:

\[ \begin{aligned} \dot{x}_1 &= -2x_1 + u,\\ \dot{x}_2 &= -3x_2 + (-x_1 + u),\\ y &= -x_2 + (-x_1 + u). \end{aligned} \]

Proposition 2 (External cancellation with nontrivial internal state).

The transfer function from \( u \) to \( y \) of the cascade equals \( \dfrac{s+1}{s+3} \), but the internal signal transfer \( v/u \) equals \( \dfrac{s+1}{s+2} \) and thus retains the pole at \( s=-2 \).

Proof. Taking Laplace transforms with zero initial conditions:

\[ (s+2)X_1(s)=U(s)\;\Rightarrow\; X_1(s)=\frac{1}{s+2}U(s). \]

Then \( V(s)= -X_1(s)+U(s) = \left(1-\dfrac{1}{s+2}\right)U(s)=\dfrac{s+1}{s+2}U(s) \), establishing \( v/u = (s+1)/(s+2) \).

Next,

\[ (s+3)X_2(s)=V(s)\;\Rightarrow\; X_2(s)=\frac{1}{s+3}V(s). \]

Hence \( Y(s)= -X_2(s)+V(s)=\left(1-\dfrac{1}{s+3}\right)V(s)=\dfrac{s+2}{s+3}V(s) \). Substituting the expression for \( V(s) \) yields

\[ \frac{Y(s)}{U(s)}=\frac{s+2}{s+3}\cdot\frac{s+1}{s+2}=\frac{s+1}{s+3}. \]

The pole \( s=-2 \) cancels externally but remains present in the internal signal \( v \). ■

This proposition clarifies why nonminimal realizations can have more states than suggested by the canceled transfer function: different interconnections (and thus different internal signals) can “store” energy in modes not visible at the output.

Let \( G(s)=\dfrac{N(s)}{D(s)} \) be SISO and proper. After cancellation, the reduced denominator \( \bar{D}(s) \) has degree \( \deg \bar{D} \). In realization theory, this degree equals the McMillan degree of the scalar transfer function (the minimal number of state variables required to realize it). This lesson uses this statement operationally (as a guideline), and the next lesson formalizes it via minimal versus nonminimal realizations.

For the example, \( G(s)=(s+1)/(s+3) \) has \( \deg \bar{D}=1 \), yet the cascade realization above has two states. The extra state is associated with the canceled factor \( (s+2) \) and becomes visible in internal signals.

4.1 A Polynomial View: Decomposing Canceled and Uncanceled Parts

Suppose \( N(s)=q(s)N_0(s) \) and \( D(s)=q(s)D_0(s) \) with \( \gcd(N_0,D_0)=1 \). Then

\[ G(s)=\frac{N(s)}{D(s)}=\frac{q(s)N_0(s)}{q(s)D_0(s)}=\frac{N_0(s)}{D_0(s)}. \]

The canceled polynomial \( q(s) \) can be interpreted as dynamics that can appear in an internal signal of an interconnection, even though they are absent from the reduced input-output transfer function. Cascade factorizations are the simplest mechanism to generate such internal signals.

For MIMO systems, the transfer function becomes a rational matrix \( G(s)\in\mathbb{R}(s)^{p\times m} \). While “numerator and denominator polynomials” are no longer unique, a standard representation uses a right matrix fraction description:

\[ G(s)=N(s)D(s)^{-1}, \]

where \( N(s)\in\mathbb{R}[s]^{p\times m} \), \( D(s)\in\mathbb{R}[s]^{m\times m} \) is polynomial and \( \det D(s)\neq 0 \).

A central concept is right coprimeness: the pair \( (N,D) \) is right-coprime if there exist polynomial matrices \( X(s),Y(s) \) such that

\[ X(s)N(s)+Y(s)D(s)=I_m. \]

This is a matrix analogue of the scalar Bezout identity and prevents hidden common right-divisors that would correspond to cancellations. While full MIMO factorization theory is developed later in advanced courses, the message here is parallel to SISO: “cancellations” correspond to non-uniqueness of internal structures, and coprime factorizations are designed to eliminate such ambiguity.

In Python, use: SymPy for exact polynomial factorization/cancellation and python-control (or scipy.signal) for transfer/state-space objects.

import sympy as sp
from control import tf, ss, series, minreal, forced_response

# --- Exact algebraic cancellation (symbolic) ---
s = sp.Symbol("s")
G1 = (s + 1) / (s + 2)
G2 = (s + 2) / (s + 3)
G = sp.simplify(G2 * G1)          # symbolic simplification
G_cancel = sp.cancel(G2 * G1)     # exact cancellation in rational function

print("G(s) simplified:", G)      # should be (s+1)/(s+3)
print("G(s) canceled:", G_cancel) # same

# --- Control objects: build cascade and compare with minreal ---
G1c = tf([1, 1], [1, 2])          # (s+1)/(s+2)
G2c = tf([1, 2], [1, 3])          # (s+2)/(s+3)
G_series = series(G2c, G1c)       # cascade interconnection
G_min = minreal(G_series, verbose=False)  # cancels near pole-zero pairs numerically

print("G_series:", G_series)
print("G_min:", G_min)

# --- One possible (nonminimal) cascade state-space realization ---
# Realizations consistent with: (s+1)/(s+2) = 1 - 1/(s+2) and (s+2)/(s+3) = 1 - 1/(s+3)

A1, B1, C1, D1 = [[-2.0]], [[1.0]], [[-1.0]], [[1.0]]  # v = -x1 + u
A2, B2, C2, D2 = [[-3.0]], [[1.0]], [[-1.0]], [[1.0]]  # y = -x2 + v

S1 = ss(A1, B1, C1, D1)  # u -> v
S2 = ss(A2, B2, C2, D2)  # v -> y
S_cascade = series(S2, S1)

# Minimal realization (numerical) for comparison
S_min = minreal(S_cascade, verbose=False)

# --- Compare output responses (they match), but internal state dimension differs ---
import numpy as np
T = np.linspace(0.0, 10.0, 1000)
U = np.ones_like(T)  # step input

t1, y1 = forced_response(S_cascade, T=T, U=U)
t2, y2 = forced_response(S_min, T=T, U=U)

print("Cascade order:", S_cascade.nstates, "Minimal order:", S_min.nstates)
print("Max |y_cascade - y_min|:", np.max(np.abs(y1 - y2)))
      

Notes:

• minreal performs numerical cancellation using tolerances; symbolic cancellation (SymPy) is exact.
• The cascade state-space system contains internal dynamics associated with the canceled factor, even when the output transfer function is reduced.

C++ does not have a single standard “control toolbox,” so a common approach is: Eigen for matrices and a small integrator (e.g., RK4) for simulation. Below is a direct simulation of the cascade realization in Section 3.2, showing that the internal state exists even though the reduced transfer function has lower order.

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

struct CascadeSystem {
  // x1' = -2 x1 + u
  // x2' = -3 x2 + v,  v = -x1 + u
  // y   = -x2 + v
  Eigen::Vector2d x;

  CascadeSystem() { x.setZero(); }

  void dynamics(double u, Eigen::Vector2d& xdot) const {
    double x1 = x(0);
    double x2 = x(1);
    double v  = -x1 + u;
    xdot(0) = -2.0 * x1 + u;
    xdot(1) = -3.0 * x2 + v;
  }

  double output(double u) const {
    double x1 = x(0);
    double x2 = x(1);
    double v  = -x1 + u;
    double y  = -x2 + v;
    return y;
  }
};

int main() {
  CascadeSystem sys;
  double dt = 0.001;
  double T  = 10.0;
  int N = static_cast<int>(T / dt);

  for (int k = 0; k <= N; ++k) {
    double t = k * dt;
    double u = 1.0; // step input

    // RK4
    Eigen::Vector2d k1, k2, k3, k4, xtmp;
    sys.dynamics(u, k1);

    xtmp = sys.x + 0.5 * dt * k1;
    CascadeSystem s2 = sys; s2.x = xtmp;
    s2.dynamics(u, k2);

    xtmp = sys.x + 0.5 * dt * k2;
    CascadeSystem s3 = sys; s3.x = xtmp;
    s3.dynamics(u, k3);

    xtmp = sys.x + dt * k3;
    CascadeSystem s4 = sys; s4.x = xtmp;
    s4.dynamics(u, k4);

    sys.x += (dt / 6.0) * (k1 + 2.0*k2 + 2.0*k3 + k4);

    if (k % 1000 == 0) {
      double y = sys.output(u);
      std::cout << "t=" << t
                << "  x1=" << sys.x(0)
                << "  x2=" << sys.x(1)
                << "  y="  << y << std::endl;
    }
  }

  return 0;
}
      

Practical note: The reduced (canceled) transfer function \( (s+1)/(s+3) \) admits a first-order realization. The code above intentionally simulates a second-order cascade to expose internal states.

The Java example mirrors the C++ simulation and avoids specialized libraries. It integrates the cascade ODEs using RK4. This is sufficient to demonstrate internal states associated with cancellations.

public class CascadeRK4 {

  // x1' = -2 x1 + u
  // x2' = -3 x2 + v, v = -x1 + u
  // y   = -x2 + v
  static double[] f(double[] x, double u) {
    double x1 = x[0];
    double x2 = x[1];
    double v  = -x1 + u;

    double dx1 = -2.0 * x1 + u;
    double dx2 = -3.0 * x2 + v;

    return new double[] { dx1, dx2 };
  }

  static double y(double[] x, double u) {
    double x1 = x[0];
    double x2 = x[1];
    double v  = -x1 + u;
    return -x2 + v;
  }

  public static void main(String[] args) {
    double[] x = new double[] { 0.0, 0.0 };
    double dt = 0.001;
    double T = 10.0;
    int N = (int)(T / dt);

    for (int k = 0; k <= N; k++) {
      double t = k * dt;
      double u = 1.0; // step input

      // RK4
      double[] k1 = f(x, u);

      double[] x2 = new double[] { x[0] + 0.5*dt*k1[0], x[1] + 0.5*dt*k1[1] };
      double[] k2 = f(x2, u);

      double[] x3 = new double[] { x[0] + 0.5*dt*k2[0], x[1] + 0.5*dt*k2[1] };
      double[] k3 = f(x3, u);

      double[] x4 = new double[] { x[0] + dt*k3[0], x[1] + dt*k3[1] };
      double[] k4 = f(x4, u);

      x[0] = x[0] + (dt/6.0) * (k1[0] + 2.0*k2[0] + 2.0*k3[0] + k4[0]);
      x[1] = x[1] + (dt/6.0) * (k1[1] + 2.0*k2[1] + 2.0*k3[1] + k4[1]);

      if (k % 1000 == 0) {
        System.out.println("t=" + t + " x1=" + x[0] + " x2=" + x[1] + " y=" + y(x, u));
      }
    }
  }
}
      

If you prefer library support, typical choices (beyond the scope of this snippet) include: Apache Commons Math (ODE solvers) and EJML (matrix algebra). The conceptual point remains the same: internal state dimension can exceed the canceled transfer-function order.

MATLAB provides direct routines for factorization, interconnection, and cancellation: series, minreal, tf, ss.

s = tf('s');

G1 = (s+1)/(s+2);
G2 = (s+2)/(s+3);

G_series = series(G2, G1);    % cascade
G_min    = minreal(G_series); % cancellation (tolerance-based)

disp('G_series ='); disp(G_series);
disp('G_min =');    disp(G_min);

% State-space realizations and orders
S_series = ss(G_series);
S_min    = ss(G_min);

disp(['Order(series realization) = ', num2str(order(S_series))]);
disp(['Order(minreal)            = ', num2str(order(S_min))]);

% Compare step responses (outputs match)
figure; step(G_series, G_min); grid on;
legend('Cascade (with cancellation)', 'Reduced (minreal)');

% Inspect internal states of the cascade realization
% (Note: the internal states depend on the realization; this is a demonstration.)
A = S_series.A; B = S_series.B; C = S_series.C; D = S_series.D;
disp('A matrix (series realization) ='); disp(A);
      

9.1 Simulink Construction (Scripted)

The following script creates a simple Simulink model that cascades the two transfer functions and compares it to the reduced transfer function. This explicitly builds a structure in which internal signals exist.

modelName = 'ch6_l4_cascade_cancellation';
new_system(modelName); open_system(modelName);

% Blocks
add_block('simulink/Sources/Step', [modelName, '/Step']);
add_block('simulink/Continuous/Transfer Fcn', [modelName, '/G1']);
add_block('simulink/Continuous/Transfer Fcn', [modelName, '/G2']);
add_block('simulink/Continuous/Transfer Fcn', [modelName, '/Gmin']);
add_block('simulink/Sinks/Scope', [modelName, '/Scope']);

% Parameters: (s+1)/(s+2), (s+2)/(s+3), (s+1)/(s+3)
set_param([modelName, '/G1'], 'Numerator', '[1 1]', 'Denominator', '[1 2]');
set_param([modelName, '/G2'], 'Numerator', '[1 2]', 'Denominator', '[1 3]');
set_param([modelName, '/Gmin'], 'Numerator', '[1 1]', 'Denominator', '[1 3]');

% Wiring: Step -> G1 -> G2 -> Scope (input 1), and Step -> Gmin -> Scope (input 2)
add_line(modelName, 'Step/1', 'G1/1');
add_line(modelName, 'G1/1', 'G2/1');
add_line(modelName, 'G2/1', 'Scope/1');

add_line(modelName, 'Step/1', 'Gmin/1');
add_line(modelName, 'Gmin/1', 'Scope/2');

set_param(modelName, 'StopTime', '10');
save_system(modelName);
      

Mathematica supports exact cancellation and conversion between transfer-function and state-space models. The snippet below performs exact reduction and compares a cascade realization to a minimal state-space model.

s = Unique["s"];

G1 = (s + 1)/(s + 2);
G2 = (s + 2)/(s + 3);

G = Together[G2*G1];
Gred = Cancel[G2*G1];

Print["G(s) Together: ", G];
Print["G(s) Cancel:   ", Gred];

(* Control systems objects *)
G1m = TransferFunctionModel[(s + 1)/(s + 2), s];
G2m = TransferFunctionModel[(s + 2)/(s + 3), s];
Gcascade = SystemsModelSeriesConnect[G2m, G1m];

Gmin = TransferFunctionModel[(s + 1)/(s + 3), s];

Sseries = StateSpaceModel[Gcascade];
Smin = MinimalStateSpaceModel[Sseries];

Print["State dimension (cascade SS): ", StateDimension[Sseries]];
Print["State dimension (minimal SS): ", StateDimension[Smin]];
      

Problem 1 (Exact cancellation via gcd). Let \( G(s)=\dfrac{(s+1)(s+2)}{(s+2)(s^2+4s+5)} \). (i) Compute the reduced transfer function. (ii) List the poles of the reduced transfer function.

Solution.

(i) The common factor is \( q(s)=s+2 \). Canceling gives:

\[ G_{\min}(s)=\frac{s+1}{s^2+4s+5}. \]

(ii) The poles are the roots of \( s^2+4s+5=0 \), namely \( s = -2 \pm j \).

Problem 2 (Cascade cancellation and internal signal). Let \( G_1(s)=\dfrac{s+1}{s+2} \), \( G_2(s)=\dfrac{s+2}{s+3} \), and define \( v = G_1(s)u \), \( y = G_2(s)v \). (i) Compute \( y/u \). (ii) Compute \( v/u \). (iii) Which pole is present in \( v/u \) but not in \( y/u \)?

Solution.

(i)

\[ \frac{y}{u}=\frac{s+2}{s+3}\cdot\frac{s+1}{s+2}=\frac{s+1}{s+3}. \]

(ii)

\[ \frac{v}{u}=\frac{s+1}{s+2}. \]

(iii) The pole at \( s=-2 \) is present in \( v/u \) but not in \( y/u \).

Problem 3 (State-space cascade derivation). Consider the cascade realization:

\[ \dot{x}_1 = -2x_1 + u,\quad v = -x_1 + u,\quad \dot{x}_2 = -3x_2 + v,\quad y = -x_2 + v. \]

(i) Derive \( v/u \) using Laplace transforms (zero initial conditions). (ii) Derive \( y/u \) and show external cancellation.

Solution.

(i) From \( (s+2)X_1=U \), \( X_1=U/(s+2) \), hence

\[ V = -X_1 + U = \left(1-\frac{1}{s+2}\right)U = \frac{s+1}{s+2}U, \]

so \( v/u=(s+1)/(s+2) \).

(ii) From \( (s+3)X_2=V \), \( X_2=V/(s+3) \), hence

\[ Y = -X_2 + V = \left(1-\frac{1}{s+3}\right)V = \frac{s+2}{s+3}V. \]

Substituting \( V/U=(s+1)/(s+2) \) gives \( Y/U=(s+1)/(s+3) \), where \( (s+2) \) cancels.

Problem 4 (Adjugate-based numerator/denominator structure). For a strictly proper SISO realization (\( D=0 \)), show that \( G(s)=\dfrac{P(s)}{\det(sI-A)} \) for some polynomial \( P(s) \), and explain how cancellation can occur without changing \( A \).

Solution.

Using the adjugate identity \( (sI-A)^{-1} = \operatorname{adj}(sI-A)/\det(sI-A) \), we obtain

\[ G(s)=C(sI-A)^{-1}B=\frac{C\,\operatorname{adj}(sI-A)\,B}{\det(sI-A)}. \]

Let \( P(s)=C\,\operatorname{adj}(sI-A)\,B \), which is a scalar polynomial because the adjugate matrix has polynomial entries and \( C \), \( B \) are constant. Cancellation occurs if \( P(s) \) and \( \det(sI-A) \) share a common factor. In that case, poles in \( \det(sI-A) \) do not appear in the reduced transfer function even though \( A \) (and thus its eigenvalues) is unchanged.

Problem 5 (Designing a factorization that cancels externally). Let \( a \) be a real constant. Construct \( G_1(s) \) and \( G_2(s) \) such that: (i) \( G_1 \) has a pole at \( s=-a \); (ii) \( G_2 \) has a zero at \( s=-a \); (iii) the product \( G_2G_1 \) has no pole at \( s=-a \).

Solution.

One simple choice is \( G_1(s)=\dfrac{1}{s+a} \) and \( G_2(s)=s+a \). Then

\[ G_2(s)G_1(s) = (s+a)\cdot\frac{1}{s+a}=1, \]

which contains no pole at \( s=-a \). In a physical interconnection, however, the intermediate signal between \( G_1 \) and \( G_2 \) can still exhibit dynamics associated with the pole at \( s=-a \).

We formalized transfer-function factorization using polynomial gcd cancellation and proved the essential uniqueness of the reduced form. We then showed—constructively—that pole-zero cancellation can remove poles from the external transfer function \( y/u \) while internal signals and internal states in a cascade interconnection retain the canceled dynamics. This provides a precise bridge between transfer-function algebra and the existence of nonminimal state-space realizations, setting up Lesson 5 on minimal versus nonminimal realizations.