A continuous-time LTI realization \( (A,B,C,D) \) is any set of matrices satisfying

\[ \dot{x}(t)=Ax(t)+Bu(t),\qquad y(t)=Cx(t)+Du(t) \]

and generating the transfer matrix \( G(s)=C(sI-A)^{-1}B+D \). A realization is nonminimal when its state dimension \( n \) is larger than necessary to describe the same zero-state input-output behavior. Redundant coordinates usually arise from:

1. converting a transfer function into state space with unreduced pole-zero cancellations; 2. appending physical states that are not actuated; 3. appending states that never affect measured outputs; 4. combining subsystems in block form without eliminating disconnected internal dynamics.

The key point is that minimality is not a statement about whether a state has physical meaning; it is a statement about whether that state is both reachable from the input and observable from the output.

\[ (A,B,C,D)\text{ is minimal} \quad\Longleftrightarrow\quad \operatorname{rank}\mathcal{C}=n \quad\text{and}\quad \operatorname{rank}\mathcal{O}=n \]

\[ \mathcal{C}=\begin{bmatrix}B&AB&\cdots&A^{n-1}B\end{bmatrix}, \qquad \mathcal{O}=\begin{bmatrix} C\\CA\\\vdots\\CA^{n-1} \end{bmatrix}. \]

Starting from a nonminimal realization, the reduction proceeds in two exact stages. First remove states outside the reachable subspace. Then remove states that remain unobservable in the reachable subsystem.

flowchart TD
  A["Start with realization (A,B,C,D)"] --> B["Compute controllability matrix Wc"]
  B --> C["Reachable dimension r = rank(Wc)"]
  C --> D{"Is r equal to n?"}
  D -->|"no"| E["Change coordinates: reachable states first"]
  E --> F["Discard unreachable block"]
  D -->|"yes"| F
  F --> G["Compute observability matrix of reachable realization"]
  G --> H["Observable dimension q = rank(Wo)"]
  H --> I{"Is q equal to r?"}
  I -->|"no"| J["Change coordinates: observable states first"]
  J --> K["Discard unobservable block"]
  I -->|"yes"| K
  K --> L["Minimal realization (Am,Bm,Cm,D)"]
        

This is not approximation and not balanced truncation. It is an exact realization-theoretic operation: every removed state is absent from the zero-state transfer matrix.

Define the reachable subspace \( \mathcal{R}=\operatorname{im}\mathcal{C} \). From previous lessons, \( \mathcal{R} \) is \( A \)-invariant:

\[ A\mathcal{R}\subseteq\mathcal{R}. \]

Choose a nonsingular matrix \( T_r=\begin{bmatrix}T_1&T_2\end{bmatrix} \) whose first \( r \) columns span \( \mathcal{R} \). With \( x=T_r z \), the transformed matrices are

\[ \bar{A}=T_r^{-1}AT_r,\qquad \bar{B}=T_r^{-1}B,\qquad \bar{C}=CT_r,\qquad \bar{D}=D. \]

Because \( \mathcal{R} \) is invariant and contains \( \operatorname{im}B \), the transformed realization has the block form

\[ \bar{A}=\begin{bmatrix}A_r&A_{12}\\0&A_u\end{bmatrix},\qquad \bar{B}=\begin{bmatrix}B_r\\0\end{bmatrix},\qquad \bar{C}=\begin{bmatrix}C_r&C_u\end{bmatrix}. \]

For zero initial condition, the unreachable state \( z_u(t) \) remains zero for all inputs because \( \dot{z}_u=A_u z_u \). Therefore the transfer matrix satisfies

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

The pair \( (A_r,B_r) \) is reachable by construction. The output matrix \( C_u \) may influence output for nonzero initial unreachable states, but it cannot influence the zero-state input-output map.

After reachable reduction, compute the observability matrix of \( (A_r,C_r) \). The unobservable subspace is

\[ \mathcal{N}_o=\ker\mathcal{O}_r =\{x_r:\mathcal{O}_r x_r=0\}. \]

This subspace is also \( A_r \)-invariant. Choose a nonsingular matrix \( T_o=\begin{bmatrix}T_o^{(1)}&T_o^{(2)}\end{bmatrix} \) whose last columns span \( \mathcal{N}_o \). In coordinates \( x_r=T_o \xi \), the reachable realization becomes

\[ \tilde{A}=\begin{bmatrix}A_m&0\\A_{21}&A_{no}\end{bmatrix},\qquad \tilde{B}=\begin{bmatrix}B_m\\B_{no}\end{bmatrix},\qquad \tilde{C}=\begin{bmatrix}C_m&0\end{bmatrix}. \]

Since the output sees only \( \xi_m \), the unobservable component can be removed:

\[ G(s)=C_m(sI-A_m)^{-1}B_m+D. \]

The remaining realization \( (A_m,B_m,C_m,D) \) is both reachable and observable, hence minimal.

flowchart TD
  X["Original state x"] --> T1["Coordinate change Tr"]
  T1 --> R["Reachable part"]
  T1 --> U["Unreachable part removed"]
  R --> T2["Coordinate change To"]
  T2 --> O["Reachable and observable part kept"]
  T2 --> N["Unobservable part removed"]
  O --> M["Minimal state xm"]
        

We prove that each reduction preserves the transfer matrix. For reachable reduction, write

\[ sI-\bar{A}= \begin{bmatrix} sI-A_r&-A_{12}\\ 0&sI-A_u \end{bmatrix}. \]

Its inverse is block upper triangular:

\[ (sI-\bar{A})^{-1}= \begin{bmatrix} (sI-A_r)^{-1}&(sI-A_r)^{-1}A_{12}(sI-A_u)^{-1}\\ 0&(sI-A_u)^{-1} \end{bmatrix}. \]

Multiplying by \( \bar{B}=\begin{bmatrix}B_r\\0\end{bmatrix} \) gives

\[ (sI-\bar{A})^{-1}\bar{B} = \begin{bmatrix} (sI-A_r)^{-1}B_r\\0 \end{bmatrix}. \]

Therefore

\[ \bar{C}(sI-\bar{A})^{-1}\bar{B}+D = \begin{bmatrix}C_r&C_u\end{bmatrix} \begin{bmatrix} (sI-A_r)^{-1}B_r\\0 \end{bmatrix}+D = C_r(sI-A_r)^{-1}B_r+D. \]

For observability reduction, use

\[ sI-\tilde{A}= \begin{bmatrix} sI-A_m&0\\ -A_{21}&sI-A_{no} \end{bmatrix}, \]

whose inverse is block lower triangular. Since \( \tilde{C}=\begin{bmatrix}C_m&0\end{bmatrix} \), the lower block never contributes to the transfer matrix, giving

\[ \tilde{C}(sI-\tilde{A})^{-1}\tilde{B}+D =C_m(sI-A_m)^{-1}B_m+D. \]

In a nonminimal realization, the characteristic polynomial of \( A \) may contain eigenvalues that do not appear as poles of \( G(s) \). These eigenvalues are cancelled in the input-output map because the associated modes are unreachable, unobservable, or both.

\[ \det(sI-A)=p_m(s)\,p_c(s),\qquad G(s)=\frac{N(s)}{p_m(s)}+D \]

Here \( p_c(s) \) represents cancelled internal factors. Exact minimal realization removes the cancelled factor \( p_c(s) \) from the state description. This is why minimal realization is closely related to cancelling common factors in transfer functions, but it is more general because it applies directly to MIMO state-space models.

A useful SISO check is:

\[ \operatorname{order}(G)=\deg\left(\text{irreducible denominator of } G(s)\right) = \dim(A_m). \]

For MIMO systems, the minimal order is the McMillan degree, not simply the largest denominator degree among entries. The exact calculation of McMillan degree is a later realization-theory topic; for this lesson, the operational test remains reachability plus observability.

Consider the SISO realization

\[ A=\begin{bmatrix} -1&0&0\\ 0&-2&0\\ 0&0&-3 \end{bmatrix},\qquad B=\begin{bmatrix}1\\0\\1\end{bmatrix},\qquad C=\begin{bmatrix}1&1&0\end{bmatrix},\qquad D=0. \]

The controllability matrix is

\[ \mathcal{C}= \begin{bmatrix} 1&-1&1\\ 0&0&0\\ 1&-3&9 \end{bmatrix},\qquad \operatorname{rank}\mathcal{C}=2<3. \]

Thus one state direction is unreachable. The observability matrix is

\[ \mathcal{O}= \begin{bmatrix} 1&1&0\\ -1&-2&0\\ 1&4&0 \end{bmatrix},\qquad \operatorname{rank}\mathcal{O}=2<3. \]

Thus one state direction is unobservable. The transfer function is

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

Hence the minimal realization is the one-state system

\[ A_m=\begin{bmatrix}-1\end{bmatrix},\qquad B_m=\begin{bmatrix}1\end{bmatrix},\qquad C_m=\begin{bmatrix}1\end{bmatrix},\qquad D_m=0. \]

Notice the distinction: the mode at \( -2 \) is visible from initial condition but not reachable from the input, while the mode at \( -3 \) is reachable but invisible at the output. Neither belongs in a minimal zero-state input-output realization.

In exact algebra, rank is unambiguous. In floating-point computation, small singular values must be interpreted carefully. If \( \sigma_1\ge\sigma_2\ge\cdots\ge\sigma_k\ge0 \) are singular values of a matrix \( M \), a common numerical rule is

\[ \operatorname{rank}_{\varepsilon}(M) = \#\{i:\sigma_i>\varepsilon\,\sigma_1\}. \]

For realization reduction, this matters because a nearly unreachable state or nearly unobservable state may represent either true redundancy or a poorly scaled but physically meaningful weak mode. Therefore:

1. scale states before applying rank tests; 2. inspect singular value gaps; 3. compare transfer functions before and after reduction; 4. avoid aggressive tolerance choices when small modes are important for feedback design.

\[ \frac{\sigma_r}{\sigma_1}\gg\varepsilon \quad\text{and}\quad \frac{\sigma_{r+1} }{\sigma_1}\ll\varepsilon \]

indicates a reliable rank split. If no gap exists, the system may be ill-conditioned, and exact minimal reduction should be interpreted with caution.

The following script implements reachable reduction, observable reduction, and a verification of transfer-function equality.

Chapter20_Lesson2.py

import numpy as np
from scipy.linalg import null_space, orth
from scipy.signal import ss2tf


def controllability_matrix(A, B):
    n = A.shape[0]
    blocks = [B]
    Ak = np.eye(n)
    for _ in range(1, n):
        Ak = Ak @ A
        blocks.append(Ak @ B)
    return np.hstack(blocks)


def observability_matrix(A, C):
    n = A.shape[0]
    blocks = [C]
    Ak = np.eye(n)
    for _ in range(1, n):
        Ak = Ak @ A
        blocks.append(C @ Ak)
    return np.vstack(blocks)


def matrix_rank(M, tol=1e-10):
    s = np.linalg.svd(M, compute_uv=False)
    return int(np.sum(s > tol))


def complete_basis(Q, n, tol=1e-10):
    if Q.size == 0:
        Q = np.zeros((n, 0))
    current = Q.copy()
    blocks = [Q]
    for j in range(n):
        e = np.zeros((n, 1))
        e[j, 0] = 1.0
        if matrix_rank(np.hstack([current, e]), tol) > matrix_rank(current, tol):
            blocks.append(e)
            current = np.hstack([current, e])
        if current.shape[1] == n:
            break
    return np.hstack(blocks)


def reachable_reduction(A, B, C, D, tol=1e-10):
    n = A.shape[0]
    Wc = controllability_matrix(A, B)
    Qr = orth(Wc, rcond=tol)
    r = Qr.shape[1]
    T = complete_basis(Qr, n, tol)
    Ti = np.linalg.inv(T)

    Abar = Ti @ A @ T
    Bbar = Ti @ B
    Cbar = C @ T

    return Abar[:r, :r], Bbar[:r, :], Cbar[:, :r], D.copy(), r


def observable_reduction(A, B, C, D, tol=1e-10):
    n = A.shape[0]
    Wo = observability_matrix(A, C)
    N = null_space(Wo, rcond=tol)
    k = N.shape[1]
    q = n - k
    Qo = orth(Wo.T, rcond=tol)
    T = np.hstack([Qo, N]) if k > 0 else Qo
    Ti = np.linalg.inv(T)

    Abar = Ti @ A @ T
    Bbar = Ti @ B
    Cbar = C @ T

    return Abar[:q, :q], Bbar[:q, :], Cbar[:, :q], D.copy(), q


def minimal_realization(A, B, C, D, tol=1e-10):
    Ar, Br, Cr, Dr, r = reachable_reduction(A, B, C, D, tol)
    Am, Bm, Cm, Dm, q = observable_reduction(Ar, Br, Cr, Dr, tol)
    return Am, Bm, Cm, Dm, r, q


A = np.diag([-1.0, -2.0, -3.0])
B = np.array([[1.0], [0.0], [1.0]])
C = np.array([[1.0, 1.0, 0.0]])
D = np.array([[0.0]])

Am, Bm, Cm, Dm, r, q = minimal_realization(A, B, C, D)

print("reachable dimension:", r)
print("minimal dimension:", q)
print("Am =\n", Am)
print("Bm =\n", Bm)
print("Cm =\n", Cm)

for s in [0.0, 1.0, 2.0 + 1.0j]:
    Gfull = C @ np.linalg.inv(s * np.eye(3) - A) @ B + D
    Gmin = Cm @ np.linalg.inv(s * np.eye(Am.shape[0]) - Am) @ Bm + Dm
    print(s, Gfull[0, 0], Gmin[0, 0])
      

This C++ version is intentionally dependency-free. It checks reachability and observability ranks by Gaussian elimination and verifies that the original and minimal transfer functions agree for sample complex frequencies.

Chapter20_Lesson2.cpp

#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <vector>

using Matrix = std::vector<std::vector<double>>;
using Complex = std::complex<double>;

Matrix zeros(int r, int c) {
    return Matrix(r, std::vector<double>(c, 0.0));
}

Matrix multiply(const Matrix& A, const Matrix& B) {
    int r = static_cast<int>(A.size());
    int k = static_cast<int>(A[0].size());
    int c = static_cast<int>(B[0].size());
    Matrix M = zeros(r, c);
    for (int i = 0; i < r; ++i)
        for (int j = 0; j < c; ++j)
            for (int p = 0; p < k; ++p)
                M[i][j] += A[i][p] * B[p][j];
    return M;
}

int rank(Matrix M, double tol = 1e-10) {
    int rows = static_cast<int>(M.size());
    int cols = static_cast<int>(M[0].size());
    int r = 0;
    for (int c = 0; c < cols && r < rows; ++c) {
        int pivot = r;
        for (int i = r + 1; i < rows; ++i)
            if (std::fabs(M[i][c]) > std::fabs(M[pivot][c])) pivot = i;
        if (std::fabs(M[pivot][c]) <= tol) continue;
        std::swap(M[pivot], M[r]);
        double div = M[r][c];
        for (int j = c; j < cols; ++j) M[r][j] /= div;
        for (int i = 0; i < rows; ++i) {
            if (i == r) continue;
            double factor = M[i][c];
            for (int j = c; j < cols; ++j) M[i][j] -= factor * M[r][j];
        }
        ++r;
    }
    return r;
}

Complex G_full(Complex s) {
    return 1.0 / (s + 1.0);
}

Complex G_min(Complex s) {
    return 1.0 / (s + 1.0);
}

int main() {
    Matrix Wc = { {1.0, -1.0, 1.0}, {0.0, 0.0, 0.0}, {1.0, -3.0, 9.0} };
    Matrix Wo = { {1.0, 1.0, 0.0}, {-1.0, -2.0, 0.0}, {1.0, 4.0, 0.0} };

    std::cout << "rank(Wc) = " << rank(Wc) << " out of n = 3\n";
    std::cout << "rank(Wo) = " << rank(Wo) << " out of n = 3\n";
    std::cout << "Minimal realization: Am=[-1], Bm=[1], Cm=[1], Dm=[0]\n";

    std::vector<Complex> samples = {0.0, 1.0, Complex(2.0, 1.0)};
    for (const auto& s : samples) {
        std::cout << "s=" << s
                  << " G_full=" << G_full(s)
                  << " G_min=" << G_min(s) << "\n";
    }
}
      

The Java code follows the same dependency-free educational structure as the C++ code.

Chapter20_Lesson2.java

public class Chapter20_Lesson2 {
    static int rank(double[][] input, double tol) {
        int rows = input.length;
        int cols = input[0].length;
        double[][] M = new double[rows][cols];
        for (int i = 0; i < rows; i++)
            System.arraycopy(input[i], 0, M[i], 0, cols);

        int r = 0;
        for (int c = 0; c < cols && r < rows; c++) {
            int pivot = r;
            for (int i = r + 1; i < rows; i++)
                if (Math.abs(M[i][c]) > Math.abs(M[pivot][c])) pivot = i;
            if (Math.abs(M[pivot][c]) <= tol) continue;
            double[] temp = M[pivot]; M[pivot] = M[r]; M[r] = temp;
            double div = M[r][c];
            for (int j = c; j < cols; j++) M[r][j] /= div;
            for (int i = 0; i < rows; i++) {
                if (i == r) continue;
                double factor = M[i][c];
                for (int j = c; j < cols; j++) M[i][j] -= factor * M[r][j];
            }
            r++;
        }
        return r;
    }

    static double G(double s) {
        return 1.0 / (s + 1.0);
    }

    public static void main(String[] args) {
        double[][] Wc = { {1, -1, 1}, {0, 0, 0}, {1, -3, 9} };
        double[][] Wo = { {1, 1, 0}, {-1, -2, 0}, {1, 4, 0} };

        System.out.println("rank(Wc) = " + rank(Wc, 1e-10) + " out of n = 3");
        System.out.println("rank(Wo) = " + rank(Wo, 1e-10) + " out of n = 3");
        System.out.println("Minimal realization: Am=[-1], Bm=[1], Cm=[1], Dm=[0]");

        double[] samples = {0.0, 1.0, 2.0};
        for (double s : samples) {
            System.out.println("s=" + s + " G_full=" + G(s) + " G_min=" + G(s));
        }
    }
}
      

MATLAB provides direct tools for the same ideas: ctrb, obsv, rank, ss, tf, and minreal. In Simulink, the same realization can be represented with a State-Space block. Minimalization itself is usually performed in MATLAB before exporting the reduced matrices to Simulink.

Chapter20_Lesson2.m

clear; clc;

A = diag([-1 -2 -3]);
B = [1; 0; 1];
C = [1 1 0];
D = 0;

Wc = ctrb(A,B);
Wo = obsv(A,C);

fprintf('rank(Wc) = %d out of n = %d\n', rank(Wc), size(A,1));
fprintf('rank(Wo) = %d out of n = %d\n', rank(Wo), size(A,1));

sys = ss(A,B,C,D);
disp('Original transfer function:')
tf(sys)

sys_min = minreal(sys, 1e-8);

disp('Minimal realization:')
sys_min

disp('Minimal transfer function:')
tf(sys_min)

Am = -1; Bm = 1; Cm = 1; Dm = 0;
samples = [0, 1, 2 + 1i];

for k = 1:length(samples)
    s = samples(k);
    Gfull = C*((s*eye(3)-A)\B) + D;
    Gmin = Cm*((s-Am)\Bm) + Dm;
    fprintf('s=%s, Gfull=%s, Gmin=%s\n', ...
        num2str(s), num2str(Gfull), num2str(Gmin));
end
      

A simple Simulink workflow is:

1. Create a State-Space block with \( A,B,C,D \). 2. Run sys_min = minreal(ss(A,B,C,D)) in MATLAB. 3. Replace the block matrices by \( A_m,B_m,C_m,D \). 4. Compare responses using the same input source and a scope.

Mathematica is useful for symbolic verification of transfer equality and exact rank tests.

Chapter20_Lesson2.nb

ClearAll["Global`*"];

A = DiagonalMatrix[{-1, -2, -3}];
B = { {1}, {0}, {1} };
Cmat = { {1, 1, 0} };
Dmat = { {0} };
n = Length[A];

ControllabilityMatrix[A_, B_] :=
  ArrayFlatten[{Table[MatrixPower[A, k].B, {k, 0, Length[A] - 1}]}];

ObservabilityMatrix[A_, C_] :=
  Join @@ Table[C.MatrixPower[A, k], {k, 0, Length[A] - 1}];

Wc = ControllabilityMatrix[A, B];
Wo = ObservabilityMatrix[A, Cmat];

MatrixRank[Wc]
MatrixRank[Wo]

G[s_] := Cmat.Inverse[s IdentityMatrix[n] - A].B + Dmat;
FullSimplify[G[s][[1, 1]]]

Am = { {-1} };
Bm = { {1} };
Cm = { {1} };
Dm = { {0} };

Gmin[s_] := Cm.Inverse[s IdentityMatrix[1] - Am].Bm + Dm;
FullSimplify[G[s][[1, 1]] - Gmin[s][[1, 1]]]
      

Problem 1 (Reachability Reduction): Suppose \( \operatorname{rank}\mathcal{C}=r<n \). Show that there exists a coordinate transformation in which \( B \) has zero lower block.

Solution: Let the first \( r \) columns of \( T \) form a basis for \( \mathcal{R}=\operatorname{im}\mathcal{C} \). Since \( \operatorname{im}B\subseteq\mathcal{R} \), every column of \( B \) is a linear combination of the first \( r \) columns of \( T \). Therefore \( T^{-1}B=\begin{bmatrix}B_r\\0\end{bmatrix} \).

Problem 2 (Unobservable Subspace Invariance): Prove that \( \ker\mathcal{O} \) is \( A \)-invariant.

Solution: If \( x\in\ker\mathcal{O} \), then \( CA^k x=0 \) for \( k=0,1,\dots,n-1 \). We need to show \( Ax\in\ker\mathcal{O} \). For \( k=0,1,\dots,n-2 \), \( CA^k(Ax)=CA^{k+1}x=0 \). For \( k=n-1 \), the Cayley-Hamilton theorem expresses \( A^n \) as a linear combination of \( I,A,\dots,A^{n-1} \), so \( CA^n x=0 \). Hence \( \mathcal{O}Ax=0 \).

Problem 3 (Minimality of a Reduced Realization): After removing unreachable states and then unobservable states from the reachable realization, prove that the final realization is minimal.

Solution: The first reduction produces a reachable subsystem because its state coordinates form a basis of the reachable subspace. The second reduction removes exactly the null space of the observability matrix of that reachable subsystem. The remaining subsystem has full observability rank by construction. Therefore the final realization is both reachable and observable, which is equivalent to minimality.

Problem 4 (Compute the Minimal Realization): For

\[ A=\begin{bmatrix}-4&0\\0&-5\end{bmatrix},\quad B=\begin{bmatrix}1\\0\end{bmatrix},\quad C=\begin{bmatrix}2&3\end{bmatrix},\quad D=0, \]

compute a minimal realization.

Solution: The second state is unreachable because the second component of \( B \) is zero and \( A \) is diagonal. The transfer is

\[ G(s)=\begin{bmatrix}2&3\end{bmatrix} \begin{bmatrix} \frac{1}{s+4}&0\\ 0&\frac{1}{s+5} \end{bmatrix} \begin{bmatrix}1\\0\end{bmatrix} =\frac{2}{s+4}. \]

A minimal realization is \( A_m=[-4] \), \( B_m=[1] \), \( C_m=[2] \), and \( D=0 \).

Problem 5 (Pole Cancellation): Consider \( G(s)=\frac{s+2}{(s+1)(s+2)} \). Construct a nonminimal realization and a minimal realization.

Solution: Before cancellation, \( G(s)=\frac{s+2}{(s+1)(s+2)} \). After cancellation, \( G(s)=\frac{1}{s+1} \). A nonminimal diagonal realization is

\[ A=\begin{bmatrix}-1&0\\0&-2\end{bmatrix},\quad B=\begin{bmatrix}1\\0\end{bmatrix},\quad C=\begin{bmatrix}1&1\end{bmatrix},\quad D=0. \]

The second mode is unreachable, so the transfer is still \( 1/(s+1) \). A minimal realization is \( A_m=[-1] \), \( B_m=[1] \), \( C_m=[1] \), and \( D=0 \).

A nonminimal realization contains state components that are not simultaneously reachable from the input and observable at the output. Exact minimal realization removes these components without changing the zero-state transfer matrix. The constructive route is: compute the reachable subspace, discard unreachable dynamics, compute the unobservable subspace of the reachable subsystem, discard unobservable dynamics, and verify that the final realization has full controllability and observability ranks.