Recall from earlier lessons in this chapter that a (continuous-time, LTI) state-space model \( (A,B,C,D) \) induces an input–output transfer function \( G(s)=C(sI-A)^{-1}B + D \). However, different choices of state coordinates and even different state dimensions can produce exactly the same \( G(s) \).

Intuitively:

• A minimal realization uses the fewest states necessary to reproduce the transfer function.
• A nonminimal realization contains extra internal dynamics that do not affect the input–output behavior (e.g., states not influenced by the input, or not seen in the output, or cancelled internally).

flowchart TD
  A["Given transfer function G(s)"] --> B["Represent as rational N(s)/D(s)"]
  B --> C["Reduce: cancel common factors to get Nr(s)/Dr(s)"]
  C --> D["McMillan degree = deg(Dr) (SISO)"]
  D --> E["Any realization must have order n >= deg(Dr)"]
  E --> F["If n = deg(Dr): minimal candidate"]
  E --> G["If n > deg(Dr): redundant states exist"]
  G --> H["Redundancy types: input-decoupled / output-decoupled / internal cancellation"]
        

In later chapters, the course will formalize “states influenced by input” and “states visible in output” using dedicated rank tests. In this lesson, we keep the view conceptual and algebraic: we detect redundancy through the transfer function structure (pole–zero cancellations) and by direct inspection of how states enter the equations.

A (finite-dimensional) realization of a proper transfer function \( G(s) \) is any quadruple \( (A,B,C,D) \) such that

\[ G(s) = C(sI-A)^{-1}B + D. \]

The order of the realization is the state dimension \( n \) where \( A\in\mathbb{R}^{n\times n} \).

A realization is called minimal if its order is the smallest among all realizations of the same \( G(s) \), i.e.,

\[ n_{\min} \;=\; \min \Big\{ n \;:\; \exists\ (A,B,C,D)\ \text{with}\ A\in\mathbb{R}^{n\times n}\ \text{and}\ G(s)=C(sI-A)^{-1}B+D \Big\}. \]

Any realization with order \( n > n_{\min} \) is nonminimal.

Consider a strictly proper SISO transfer function written as a ratio of polynomials: \( G(s)=\frac{N(s)}{D(s)} \), with \( \deg N(s) < \deg D(s) \). Let \( \gcd(N,D)=q(s) \) and define the reduced (coprime) form:

\[ G(s) = \frac{N(s)}{D(s)} = \frac{N_r(s)}{D_r(s)},\qquad N(s)=q(s)N_r(s),\ \ D(s)=q(s)D_r(s),\ \ \gcd(N_r,D_r)=1. \]

For SISO rational functions, the quantity \( \deg(D_r) \) is the number of poles counting multiplicity after cancellations; this is the key “complexity” measure of the input–output behavior. A core fact is:

Proposition (Denominator-degree lower bound). Any finite-dimensional realization of \( G(s) \) has order \( n \ge \deg(D_r) \).

Proof. For any realization \( (A,B,C,D) \) of order \( n \), we have the identity (from adjugate formulas):

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

Therefore,

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

The polynomial \( \det(sI-A) \) has degree \( n \). When we combine the two terms over a common denominator, the resulting rational function can only have a denominator whose reduced degree is \( \le n \) (because any cancellation can only reduce degree). Since the reduced denominator of \( G(s) \) is \( D_r(s) \), it follows that \( \deg(D_r)\le n \). Hence \( n \ge \deg(D_r) \). ∎

This proposition gives a clean conceptual takeaway: if your state dimension exceeds the reduced denominator degree, you must have hidden internal dynamics.

From Lesson 2, poles describe external (input–output) dynamics. Internally, the matrix \( A \) may have eigenvalues that never show up as poles of \( G(s) \). Such eigenvalues correspond to hidden modes (redundant dynamics).

To make this precise in an accessible way, assume for this section that \( A \) is diagonalizable: \( A=V\Lambda V^{-1} \), with eigenvalues \( \lambda_1,\dots,\lambda_n \). Using eigen-decomposition,

\[ (sI-A)^{-1} = V(sI-\Lambda)^{-1}V^{-1} = \sum_{i=1}^{n}\frac{v_i w_i^{\mathsf{T}}}{(s-\lambda_i)\, w_i^{\mathsf{T}}v_i}, \]

where \( v_i \) is a right eigenvector and \( w_i \) is a left eigenvector (so \( Av_i=\lambda_i v_i \) and \( w_i^{\mathsf{T}}A=\lambda_i w_i^{\mathsf{T}} \)).

Substituting into \( G(s)=C(sI-A)^{-1}B+D \) yields a partial-fraction style expansion:

\[ G(s)= \sum_{i=1}^{n} \frac{ C v_i\, w_i^{\mathsf{T}} B }{(s-\lambda_i)\, w_i^{\mathsf{T}} v_i} + D. \]

The coefficient \( \rho_i = \frac{ C v_i\, w_i^{\mathsf{T}} B }{ w_i^{\mathsf{T}} v_i} \) is the residue associated with \( \lambda_i \). If \( \rho_i=0 \), then the term \( \frac{\rho_i}{s-\lambda_i} \) vanishes, so \( \lambda_i \) is not a pole of \( G(s) \).

Interpretation. The product structure is revealing:

• \( w_i^{\mathsf{T}}B=0 \) means the input does not excite mode \( i \).
• \( Cv_i=0 \) means mode \( i \) does not show up in the output.
• Either condition implies \( \rho_i=0 \), so the mode is hidden externally.

This is one concrete way nonminimality arises: extra eigenvalues of \( A \) become invisible in \( G(s) \).

Nonminimal realizations can be created deliberately in two standard ways.

5.1 Add decoupled internal dynamics (state augmentation)

Start from any realization \( (A,B,C,D) \) of order \( n \) and choose any matrix \( A_h\in\mathbb{R}^{k\times k} \). Define an augmented model of order \( n+k \):

\[ A_a=\begin{bmatrix}A & 0\\ 0 & A_h\end{bmatrix},\quad B_a=\begin{bmatrix}B\\ 0\end{bmatrix},\quad C_a=\begin{bmatrix}C & 0\end{bmatrix},\quad D_a=D. \]

Proposition (augmentation does not change the transfer function). The augmented system satisfies \( G_a(s)=C_a(sI-A_a)^{-1}B_a + D_a = G(s) \).

Proof. Since \( A_a \) is block diagonal,

\[ (sI-A_a)^{-1}= \begin{bmatrix} (sI-A)^{-1} & 0\\ 0 & (sI-A_h)^{-1} \end{bmatrix}. \]

Thus,

\[ C_a(sI-A_a)^{-1}B_a = \begin{bmatrix}C & 0\end{bmatrix} \begin{bmatrix} (sI-A)^{-1} & 0\\ 0 & (sI-A_h)^{-1} \end{bmatrix} \begin{bmatrix}B\\ 0\end{bmatrix} = C(sI-A)^{-1}B. \]

Adding \( D_a=D \) gives \( G_a(s)=G(s) \). ∎

flowchart LR
  U["u"] --> SYS["Input-output subsystem"]
  SYS --> Y["y"]
  H["Hidden internal subsystem"] --> H
  U -. "no connection" .-> H
  H -. "no connection" .-> Y
        

5.2 Build a higher-order differential equation realization before cancellation

From Chapters 5–6, a common realization pipeline is: (i) interpret \( G(s) \) as an input–output differential equation, (ii) select states (e.g., \( x_1=y, x_2=\dot{y}, \dots \)), (iii) obtain a state-space model.

If the transfer function is not first reduced (i.e., it contains a common factor in numerator and denominator), this pipeline can produce a state dimension larger than necessary. The “extra” dynamics correspond exactly to the canceled factor.

Example. Consider

\[ G(s)=\frac{s+1}{(s+1)(s+2)}=\frac{1}{s+2}. \]

The reduced transfer function has denominator degree 1, so a minimal realization must have \( n_{\min}=1 \). However, if we start from the unreduced denominator \( (s+1)(s+2) \) we can easily construct a 2-state model, which is necessarily nonminimal.

Without yet using later-chapter rank machinery, you can still perform strong minimality diagnostics:

1. Compute \( G(s)=C(sI-A)^{-1}B+D \).
2. Reduce \( G(s) \) by cancelling pole–zero factors, obtaining \( \frac{N_r(s)}{D_r(s)} \).
3. Compare degrees: if \( \deg(D_r) < n \), then the realization is nonminimal.
4. Compare poles: if an eigenvalue of \( A \) does not appear among the poles of \( G(s) \), there are hidden internal modes.

These checks are algebraic, consistent with the transfer-function focus of Chapter 6, and they anticipate the later formal theory of state relevance.

We use python-control (common in modern control workflows) to: (i) build a reduced transfer function, (ii) form a minimal state-space realization, (iii) construct a nonminimal augmented realization, (iv) verify that both have the same \( G(s) \).

import numpy as np

# Libraries for modern control computations
import control as ct

# Example: G(s) = (s+1)/((s+1)(s+2)) = 1/(s+2)
s = ct.TransferFunction.s
G_nonreduced = (s + 1) / ((s + 1) * (s + 2))
G_reduced = 1 / (s + 2)

print("G_nonreduced =", G_nonreduced)
print("G_reduced    =", G_reduced)

# Minimal realization (state-space) from reduced TF
sys_min = ct.ss(G_reduced)  # realization produced by library (will be minimal here)
print("Minimal order n =", sys_min.nstates)

# Construct a nonminimal realization by adding a hidden state x_h:
# x_hdot = -1 * x_h, with no input coupling and no output coupling.
A = np.array(sys_min.A, dtype=float)
B = np.array(sys_min.B, dtype=float)
C = np.array(sys_min.C, dtype=float)
D = np.array(sys_min.D, dtype=float)

Ah = np.array([[-1.0]])
A_aug = np.block([[A,               np.zeros((A.shape[0], 1))],
                  [np.zeros((1, A.shape[1])), Ah]])
B_aug = np.vstack([B, np.zeros((1, B.shape[1]))])
C_aug = np.hstack([C, np.zeros((C.shape[0], 1))])
D_aug = D.copy()

sys_nonmin = ct.ss(A_aug, B_aug, C_aug, D_aug)
print("Nonminimal order n =", sys_nonmin.nstates)

# Compare transfer functions
G_from_min = ct.tf(sys_min)
G_from_nonmin = ct.tf(sys_nonmin)

print("TF from minimal realization   =", G_from_min)
print("TF from nonminimal realization =", G_from_nonmin)

# Optional: "minreal" to remove cancellations numerically (tolerance-based)
G_minreal = ct.minreal(G_from_nonmin, verbose=False)
print("minreal(TF from nonminimal) =", G_minreal)

# Check frequency responses match
w = np.logspace(-2, 2, 50)
mag1, phase1, _ = ct.freqresp(sys_min, w)
mag2, phase2, _ = ct.freqresp(sys_nonmin, w)

max_mag_err = np.max(np.abs(mag1 - mag2))
max_phase_err = np.max(np.abs(phase1 - phase2))
print("Max magnitude error:", max_mag_err)
print("Max phase error:", max_phase_err)
      

Notes:

• Numerically, cancellation tests depend on tolerances. In exact algebra, the hidden state is perfectly decoupled, so the transfer function is exactly unchanged.
• The augmentation construction in Section 5.1 is a robust way to generate nonminimal realizations intentionally for conceptual demonstrations.

In C++, a practical approach is to compare frequency responses \( G(j\omega)=C(j\omega I-A)^{-1}B + D \) at sample frequencies. We use Eigen for matrix computations.

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

using cd = std::complex<double>;
using Eigen::MatrixXd;
using Eigen::VectorXd;

cd freqresp(const MatrixXd& A, const VectorXd& B, const VectorXd& C, double D, double w) {
  // Computes scalar SISO G(jw) = C*(jwI - A)^(-1)*B + D
  const int n = A.rows();
  Eigen::Matrix<cd, Eigen::Dynamic, Eigen::Dynamic> M(n, n);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      M(i,j) = cd(0.0, 0.0) - cd(A(i,j), 0.0);
    }
    M(i,i) += cd(0.0, w); // add jw on diagonal: jwI - A
  }

  Eigen::Matrix<cd, Eigen::Dynamic, 1> Bb(n);
  Eigen::Matrix<cd, 1, Eigen::Dynamic> Cc(n);
  for (int i = 0; i < n; ++i) {
    Bb(i) = cd(B(i), 0.0);
    Cc(i) = cd(C(i), 0.0);
  }

  Eigen::Matrix<cd, Eigen::Dynamic, 1> x = M.fullPivLu().solve(Bb);
  cd y = Cc * x;
  return y + cd(D, 0.0);
}

int main() {
  // Minimal system for G(s)=1/(s+2):
  // xdot = -2 x + 1 u, y = 1 x
  MatrixXd A1(1,1); A1 << -2.0;
  VectorXd B1(1);   B1 <<  1.0;
  VectorXd C1(1);   C1 <<  1.0;
  double D1 = 0.0;

  // Nonminimal augmented system: add hidden state xh with xhdot=-1*xh, no coupling
  MatrixXd A2 = MatrixXd::Zero(2,2);
  A2(0,0) = -2.0; A2(1,1) = -1.0;
  VectorXd B2(2); B2 << 1.0, 0.0;
  VectorXd C2(2); C2 << 1.0, 0.0;
  double D2 = 0.0;

  std::vector<double> ws = {0.01, 0.1, 1.0, 10.0, 100.0};
  for (double w : ws) {
    cd G1 = freqresp(A1, B1, C1, D1, w);
    cd G2 = freqresp(A2, B2, C2, D2, w);
    std::cout << "w=" << w
              << "  G_min=" << G1
              << "  G_nonmin=" << G2
              << "  diff=" << (G1 - G2)
              << std::endl;
  }
  return 0;
}
      

Engineering interpretation: if the differences remain at numerical round-off over a frequency grid, the two models are externally equivalent (same transfer function), even if their internal state dimensions differ.

Java does not have a single de-facto “modern control” standard library equivalent to MATLAB, but a common stack is: EJML for linear algebra plus custom control routines. Below is a compact SISO frequency-response check.

import org.ejml.data.ZMatrixRMaj;
import org.ejml.dense.row.CommonOps_ZDRM;
import org.ejml.dense.row.NormOps_ZDRM;

public class FreqRespCheck {

  // Computes scalar G(jw)=C*(jwI - A)^(-1)*B + D for SISO
  static double[] freqresp(double[][] A, double[] B, double[] C, double D, double w) {
    int n = A.length;

    // Build M = jwI - A as complex matrix
    ZMatrixRMaj M = new ZMatrixRMaj(n, n);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        double re = -A[i][j];
        double im = 0.0;
        if (i == j) im += w; // add jw on diagonal
        M.set(i, j, re, im);
      }
    }

    // Build complex vector Bb
    ZMatrixRMaj Bb = new ZMatrixRMaj(n, 1);
    for (int i = 0; i < n; i++) Bb.set(i, 0, B[i], 0.0);

    // Solve M x = B
    ZMatrixRMaj x = new ZMatrixRMaj(n, 1);
    CommonOps_ZDRM.solve(M, Bb, x);

    // y = C x
    double yRe = 0.0, yIm = 0.0;
    for (int i = 0; i < n; i++) {
      double xr = x.getReal(i, 0);
      double xi = x.getImag(i, 0);
      yRe += C[i] * xr;
      yIm += C[i] * xi;
    }

    // Add D
    yRe += D;
    return new double[]{yRe, yIm};
  }

  public static void main(String[] args) {
    // Minimal: xdot=-2x+u, y=x
    double[][] A1 = {{-2.0}};
    double[] B1 = {1.0};
    double[] C1 = {1.0};
    double D1 = 0.0;

    // Nonminimal: add hidden state xh, xhdot=-1*xh, no coupling
    double[][] A2 = { {-2.0, 0.0},{0.0, -1.0} };
    double[] B2 = {1.0, 0.0};
    double[] C2 = {1.0, 0.0};
    double D2 = 0.0;

    double[] ws = {0.01, 0.1, 1.0, 10.0, 100.0};
    for (double w : ws) {
      double[] Gm = freqresp(A1, B1, C1, D1, w);
      double[] Gn = freqresp(A2, B2, C2, D2, w);
      System.out.printf("w=%f  G_min=(%e,%e)  G_nonmin=(%e,%e)  diff=(%e,%e)%n",
          w, Gm[0], Gm[1], Gn[0], Gn[1], (Gm[0]-Gn[0]), (Gm[1]-Gn[1]));
    }
  }
}
      

For larger-scale work, you would typically wrap these computations into reusable classes and add polynomial manipulation utilities for automated pole–zero cancellation.

MATLAB provides direct functions for realization and minimality reduction.

% Example: (s+1)/((s+1)(s+2)) = 1/(s+2)
s = tf('s');
G_nonreduced = (s+1)/((s+1)*(s+2));
G_reduced    = 1/(s+2);

% State-space realizations
sys_nonred = ss(G_nonreduced);   % may contain cancellation depending on realization/tolerance
sys_red    = ss(G_reduced);

% Minimal reduction (numerical pole-zero cancellation)
sys_nonred_min = minreal(sys_nonred);

disp('Orders:')
disp(size(sys_nonred.A,1))
disp(size(sys_red.A,1))
disp(size(sys_nonred_min.A,1))

% Verify transfer functions
tf(sys_red)
tf(sys_nonred_min)

% Compare frequency responses
w = logspace(-2,2,50);
[mag1,ph1] = bode(sys_red,w);
[mag2,ph2] = bode(sys_nonred_min,w);
maxMagErr = max(abs(mag1(:)-mag2(:)));
maxPhErr  = max(abs(ph1(:)-ph2(:)));
disp(maxMagErr)
disp(maxPhErr)
      

10.1 Simulink note (model-building by script)

You can programmatically create two State-Space blocks (minimal and nonminimal) and compare their outputs for a common input signal. The nonminimal block can be created by augmenting \( A,B,C \) exactly as in Section 5.1.

% Minimal state-space for 1/(s+2)
A = -2; B = 1; C = 1; D = 0;

% Augment with hidden state xh_dot = -1*xh, no coupling
A_aug = [A 0; 0 -1];
B_aug = [B; 0];
C_aug = [C 0];
D_aug = D;

% Create a Simulink model
mdl = 'min_vs_nonmin_demo';
new_system(mdl); open_system(mdl);

add_block('simulink/Sources/Step', [mdl '/u']);
add_block('simulink/Continuous/State-Space', [mdl '/SS_min']);
add_block('simulink/Continuous/State-Space', [mdl '/SS_nonmin']);
add_block('simulink/Sinks/Scope', [mdl '/Scope']);

set_param([mdl '/SS_min'],   'A', mat2str(A),     'B', mat2str(B),     'C', mat2str(C),     'D', mat2str(D));
set_param([mdl '/SS_nonmin'],'A', mat2str(A_aug), 'B', mat2str(B_aug), 'C', mat2str(C_aug), 'D', mat2str(D_aug));

add_line(mdl,'u/1','SS_min/1');
add_line(mdl,'u/1','SS_nonmin/1');
add_line(mdl,'SS_min/1','Scope/1');
add_line(mdl,'SS_nonmin/1','Scope/2');

set_param(mdl, 'StopTime', '10');
sim(mdl);
      

Mathematica supports transfer-function and state-space objects with built-in minimality reduction.

(* Example: (s+1)/((s+1)(s+2)) = 1/(s+2) *)
s = I*0; (* just to avoid symbol warnings in some contexts *)

Gnon = TransferFunctionModel[{ { {1, 1} } }, s] /;
  True; (* placeholder; we'll define explicitly below *)

(* Define transfer functions using polynomials in p *)
p =.; (* clear *)
Gnon = TransferFunctionModel[(p + 1)/((p + 1) (p + 2)), p];
Gred = TransferFunctionModel[1/(p + 2), p];

(* Convert to state space *)
SSnon = StateSpaceModel[Gnon];
SSred = StateSpaceModel[Gred];

(* Minimal reduction *)
SSnonMin = MinimalStateSpaceModel[SSnon];

{StateDimension[SSnon], StateDimension[SSred], StateDimension[SSnonMin]}

(* Compare transfer functions *)
TransferFunctionModel[SSred] // Simplify
TransferFunctionModel[SSnonMin] // Simplify

(* Frequency response check at a few points *)
freqs = {0.01, 0.1, 1, 10, 100};
Table[
  {
    w,
    FrequencyResponse[SSred, I w][[1,1]],
    FrequencyResponse[SSnonMin, I w][[1,1]]
  },
  {w, freqs}
]
      

The function MinimalStateSpaceModel reduces away redundant internal dynamics while preserving the same input–output map.

Problem 1 (Augmentation invariance). Let \( (A,B,C,D) \) realize \( G(s) \). Consider the augmented realization \( (A_a,B_a,C_a,D_a) \) defined by

\[ A_a=\begin{bmatrix}A & 0\\ 0 & A_h\end{bmatrix},\quad B_a=\begin{bmatrix}B\\ 0\end{bmatrix},\quad C_a=\begin{bmatrix}C & 0\end{bmatrix},\quad D_a=D. \]

Prove that \( G_a(s)=G(s) \) for any \( A_h \).

Solution. This is exactly the computation in Section 5.1. Because the resolvent is block diagonal,

\[ (sI-A_a)^{-1}= \begin{bmatrix}(sI-A)^{-1} & 0\\ 0 & (sI-A_h)^{-1}\end{bmatrix}, \]

and therefore

\[ C_a(sI-A_a)^{-1}B_a = \begin{bmatrix}C & 0\end{bmatrix} \begin{bmatrix}(sI-A)^{-1} & 0\\ 0 & (sI-A_h)^{-1}\end{bmatrix} \begin{bmatrix}B\\ 0\end{bmatrix} = C(sI-A)^{-1}B. \]

Adding \( D_a=D \) yields \( G_a(s)=G(s) \). ∎

Problem 2 (Lower bound on realization order). Prove that for any realization \( (A,B,C,D) \) of order \( n \), the reduced denominator degree of \( G(s) \) satisfies \( \deg(D_r)\le n \).

Solution. Using \( (sI-A)^{-1}=\operatorname{adj}(sI-A)/\det(sI-A) \),

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

The polynomial \( \det(sI-A) \) has degree \( n \). When expressing \( G(s) \) as a single rational function and then reducing by cancellation, the reduced denominator cannot have degree exceeding the original denominator degree \( n \). Thus \( \deg(D_r)\le n \), so \( n \ge \deg(D_r) \). ∎

Problem 3 (Identify nonminimality by eigenvalue/pole mismatch). Consider the realization: \( A=\begin{bmatrix}-2 & 0\\ 0 & -1\end{bmatrix} \), \( B=\begin{bmatrix}1\\ 0\end{bmatrix} \), \( C=\begin{bmatrix}1 & 0\end{bmatrix} \), \( D=0 \). Compute \( G(s) \) and decide whether the realization is minimal.

Solution. Because \( A \) is diagonal,

\[ (sI-A)^{-1}= \begin{bmatrix} \frac{1}{s+2} & 0\\ 0 & \frac{1}{s+1} \end{bmatrix}. \]

Hence

\[ G(s)=C(sI-A)^{-1}B = \begin{bmatrix}1 & 0\end{bmatrix} \begin{bmatrix} \frac{1}{s+2} & 0\\ 0 & \frac{1}{s+1} \end{bmatrix} \begin{bmatrix}1\\ 0\end{bmatrix} =\frac{1}{s+2}. \]

The transfer function has only one pole at \( -2 \), while \( A \) has eigenvalues \( -2 \) and \( -1 \). Since \( -1 \) does not appear as a pole, the second state is hidden externally. Therefore the realization is nonminimal; a minimal realization has order 1. ∎

Problem 4 (Minimal order from cancellation). Let \( G(s)=\frac{s+3}{s^2+5s+6} \). Compute the minimal order and produce a minimal first-order realization.

Solution. Factor the denominator: \( s^2+5s+6=(s+2)(s+3) \). Then

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

Thus the reduced denominator degree is 1, so \( n_{\min}=1 \). A minimal realization is

\[ \dot{x}=-2x + u,\qquad y=x, \]

i.e., \( A=[-2] \), \( B=[1] \), \( C=[1] \), \( D=[0] \). ∎

Problem 5 (Residue criterion for hidden modes, diagonalizable case). Assume \( A \) is diagonalizable with eigenpairs \( (\lambda_i,v_i,w_i) \). Show that if either \( w_i^{\mathsf{T}}B=0 \) or \( Cv_i=0 \), then \( \lambda_i \) is not a pole of \( G(s)=C(sI-A)^{-1}B+D \).

Solution. From Section 4,

\[ G(s)= \sum_{i=1}^{n} \frac{ C v_i\, w_i^{\mathsf{T}} B }{(s-\lambda_i)\, w_i^{\mathsf{T}} v_i} + D. \]

The residue at \( \lambda_i \) is \( \rho_i = \frac{ C v_i\, w_i^{\mathsf{T}} B }{ w_i^{\mathsf{T}} v_i} \). If \( w_i^{\mathsf{T}}B=0 \) or \( Cv_i=0 \), then \( \rho_i=0 \), so the term \( \rho_i/(s-\lambda_i) \) is absent. Therefore \( \lambda_i \) does not appear as a pole of \( G(s) \). ∎

Minimality is fundamentally about eliminating redundant internal state dynamics while preserving the same transfer function. For SISO systems, the reduced denominator degree gives a direct lower bound on realization order, and any realization with more states must hide some internal modes (eigenvalues of \( A \) that do not appear as poles). Nonminimal realizations arise naturally from pole–zero cancellations or by explicit state augmentation with decoupled dynamics. In later chapters, the course will formalize these ideas with systematic tests and decomposition tools.