Recall the continuous-time LTI state-space model: \( \dot{x}(t)=Ax(t)+Bu(t) \), \( y(t)=Cx(t)+Du(t) \), where \( x(t)\in\mathbb{R}^n \), \( u(t)\in\mathbb{R}^m \), \( y(t)\in\mathbb{R}^p \). From Lesson 1, the transfer matrix is \( G(s)=C(sI-A)^{-1}B + D \).

Definition (Realization). A quadruple \( (A,B,C,D) \) is a realization of \( G(s) \) if \( G(s)=C(sI-A)^{-1}B + D \) for all \( s \) where the inverse exists.

Definition (External equivalence). Two realizations \( (A_1,B_1,C_1,D_1) \) and \( (A_2,B_2,C_2,D_2) \) are externally equivalent if they generate the same transfer function: \( C_1(sI-A_1)^{-1}B_1 + D_1 = C_2(sI-A_2)^{-1}B_2 + D_2 \).

In this lesson we show:

• Same order, many realizations: infinitely many invertible coordinate transforms produce different \( (A,B,C) \) but identical \( G(s) \).
• Different orders, same transfer function: you can append internal states that remain invisible to input–output behavior, leaving \( G(s) \) unchanged.

flowchart TD
  G["Given transfer function G(s)"] --> R1["Pick one realization (A,B,C,D)"]
  R1 --> T["Choose any invertible matrix T"]
  T --> R2["Build new realization (T*A*T^-1, T*B, C*T^-1, D)"]
  R2 --> SAME["Same input-output map: same G(s)"]
        

Consider an invertible change of state coordinates. Define a new state \( z(t) \) by \( z(t)=Tx(t) \), where \( T\in\mathbb{R}^{n\times n} \) is nonsingular. Then \( x(t)=T^{-1}z(t) \) and:

\[ \dot{z}(t) = T\dot{x}(t) = TAx(t) + TBu(t) = TAT^{-1}z(t) + TBu(t), \qquad y(t)=CT^{-1}z(t)+Du(t). \]

Therefore the transformed realization is: \( A' = TAT^{-1} \), \( B'=TB \), \( C'=CT^{-1} \), \( D'=D \).

Theorem 1 (Transfer function invariance under similarity). Let \( T \) be invertible and define \( (A',B',C',D') \) as above. Then \( C'(sI-A')^{-1}B' + D' = C(sI-A)^{-1}B + D \).

Proof. First note the factorization:

\[ sI - A' = sI - TAT^{-1} = T(sI-A)T^{-1}. \]

Because \( T \) is invertible, for any \( s \) where \( (sI-A) \) is invertible:

\[ (sI-A')^{-1} = \bigl(T(sI-A)T^{-1}\bigr)^{-1} = T(sI-A)^{-1}T^{-1}. \]

Substitute into the transfer expression:

\[ \begin{aligned} C'(sI-A')^{-1}B' + D' &= (CT^{-1})\bigl(T(sI-A)^{-1}T^{-1}\bigr)(TB) + D \\ &= C(sI-A)^{-1}B + D. \end{aligned} \]

Hence the transfer function is unchanged. ■

Interpretation. Similarity transformations change the internal coordinates (the meaning of “state”) but not the input–output behavior. In particular, the state trajectory transforms as \( z(t)=Tx(t) \), while \( y(t) \) remains identical for the same input \( u(t) \) (with corresponding initial conditions related by \( z(0)=Tx(0) \)).

A robust way to see external equivalence is through the impulse response. For zero initial condition, the impulse response matrix is:

\[ g(t) = Ce^{At}B + D\delta(t). \]

Lemma 1 (Exponential similarity). If \( A'=TAT^{-1} \), then \( e^{A't} = Te^{At}T^{-1} \).

Proof. Using the power-series definition (introduced in Chapter 3):

\[ e^{A't} = \sum_{k=0}^{\infty}\frac{(A't)^k}{k!} = \sum_{k=0}^{\infty}\frac{(TAT^{-1})^k t^k}{k!} = \sum_{k=0}^{\infty}\frac{TA^kT^{-1} t^k}{k!} = T\left(\sum_{k=0}^{\infty}\frac{A^k t^k}{k!}\right)T^{-1} = Te^{At}T^{-1}. \]

■

Then the impulse response is invariant:

\[ C'e^{A't}B' = (CT^{-1})(Te^{At}T^{-1})(TB) = Ce^{At}B. \]

Markov parameters. For large \( |s| \), the resolvent admits the Neumann expansion provided \( |s| > \|A\| \) (any compatible induced norm):

\[ (sI-A)^{-1} = \frac{1}{s}\left(I-\frac{A}{s}\right)^{-1} = \frac{1}{s}\sum_{k=0}^{\infty}\left(\frac{A}{s}\right)^k = \sum_{k=0}^{\infty}\frac{A^k}{s^{k+1}}. \]

Therefore:

\[ G(s) = D + \sum_{k=0}^{\infty}\frac{CA^kB}{s^{k+1}}. \]

The matrices \( CA^kB \) are invariants of the input–output behavior (they are the coefficients of the high-frequency expansion and relate to impulse response derivatives). Under similarity:

\[ C'(A')^kB' = (CT^{-1})(TAT^{-1})^k(TB) = CA^kB. \]

This provides a practically useful check: if two realizations are related by an invertible coordinate change, then they must share the same sequence \( \{D,\,CB,\,CAB,\,CA^2B,\dots\} \).

Non-uniqueness is not limited to coordinate changes. Even for a fixed transfer function, there can exist realizations of different state dimensions. The simplest construction is to append an autonomous subsystem that does not interact with the input or output.

Let \( (A,B,C,D) \) be any realization of order \( n \). Choose any matrix \( A_h\in\mathbb{R}^{r\times r} \) (the “hidden” dynamics), and define an augmented realization of order \( n+r \):

\[ \tilde{A} = \begin{bmatrix} A & 0 \\ 0 & A_h \end{bmatrix}, \quad \tilde{B} = \begin{bmatrix} B \\ 0 \end{bmatrix}, \quad \tilde{C} = \begin{bmatrix} C & 0 \end{bmatrix}, \quad \tilde{D} = D. \]

Theorem 2 (Augmentation invariance). The augmented realization produces the same transfer function: \( \tilde{G}(s)=\tilde{C}(sI-\tilde{A})^{-1}\tilde{B}+\tilde{D} = C(sI-A)^{-1}B + D \).

Proof. Since \( \tilde{A} \) is block diagonal:

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

Then:

\[ \tilde{C}(sI-\tilde{A})^{-1}\tilde{B} = \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 \( \tilde{D}=D \) yields \( \tilde{G}(s)=G(s) \). ■

Important consequence. The eigenvalues of \( \tilde{A} \) include eigenvalues of \( A_h \), but these additional modes do not appear in the transfer function. This is one precise sense in which “internal dynamics” can exist without affecting external behavior.

flowchart TD
  U["Input u(t)"] --> SYS["Original system (A,B,C,D)"]
  SYS --> Y["Output y(t)"]
  H["Hidden subsystem: z_dot = A_h z"] --> H2["No path from u to z and no path from z to y"]
  H2 --> SYS2["Augmented realization has larger state"]
  SYS2 --> SAME2["Same G(s), different A-tilde spectrum"]
        

Consider the strictly proper SISO transfer function: \( G(s)=\dfrac{s+2}{s^2+3s+2} \). One realization (derived from a second-order ODE to state form, consistent with Chapter 5) is:

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

Choose an invertible coordinate transform: \( T=\begin{bmatrix}1 & 1\\ 0 & 1\end{bmatrix} \). Then \( (A',B',C',D') \) defined by \( A'=TAT^{-1} \), \( B'=TB \), \( C'=CT^{-1} \), \( D'=D \) yields a different set of matrices but the same transfer function by Theorem 1.

Later lessons will formalize which realizations are “redundant” and which are “irreducible.” For now, the key takeaway is: many internal coordinate choices exist even before considering order-changing constructions.

This lab uses python-control (Control Systems Library) to build state-space systems, apply a similarity transform, and verify equality via transfer function coefficients and frequency response samples.

import numpy as np

# Optional: pip install control
import control as ct

# Original realization for G(s) = (s + 2) / (s^2 + 3 s + 2)
A = np.array([[0.0, 1.0],
              [-2.0, -3.0]])
B = np.array([[0.0],
              [1.0]])
C = np.array([[2.0, 1.0]])
D = np.array([[0.0]])

sys1 = ct.ss(A, B, C, D)

# Similarity transform z = T x (T invertible)
T = np.array([[1.0, 1.0],
              [0.0, 1.0]])
Ti = np.linalg.inv(T)

A2 = T @ A @ Ti
B2 = T @ B
C2 = C @ Ti
D2 = D.copy()

sys2 = ct.ss(A2, B2, C2, D2)

# Compare transfer functions
tf1 = ct.tf(sys1)
tf2 = ct.tf(sys2)

print("tf1 =", tf1)
print("tf2 =", tf2)

# Compare numerator/denominator arrays (SISO)
num1, den1 = ct.tfdata(tf1)
num2, den2 = ct.tfdata(tf2)

num1 = np.squeeze(num1)
den1 = np.squeeze(den1)
num2 = np.squeeze(num2)
den2 = np.squeeze(den2)

print("num1:", num1, " den1:", den1)
print("num2:", num2, " den2:", den2)

# Frequency response check (sample a grid)
w = np.logspace(-2, 2, 50)
mag1, phase1, _ = ct.freqresp(sys1, w)
mag2, phase2, _ = ct.freqresp(sys2, w)

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

# Augmentation test: append hidden stable dynamics
Ah = np.array([[-5.0]])   # hidden pole at -5 (does not appear in G(s))
A_aug = np.block([
    [A, np.zeros((2,1))],
    [np.zeros((1,2)), Ah]
])
B_aug = np.vstack([B, np.zeros((1,1))])
C_aug = np.hstack([C, np.zeros((1,1))])
D_aug = D.copy()

sys_aug = ct.ss(A_aug, B_aug, C_aug, D_aug)
tf_aug = ct.tf(sys_aug)

print("tf_aug =", tf_aug)  # should match tf1 exactly (up to numerical formatting)
      

Practical note: numerical printing can differ in formatting, but the transfer functions match as rational functions. Frequency response error should be near machine precision.

This C++ example uses Eigen for linear algebra and evaluates the transfer function at real test points \( s \in \{1,2,3\} \). Matching values for multiple points is a strong numerical sanity check.

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

int main() {
  using Eigen::MatrixXd;
  using Eigen::VectorXd;

  // Original realization (2-state SISO)
  MatrixXd A(2,2);
  A << 0.0, 1.0,
      -2.0, -3.0;

  VectorXd B(2);
  B << 0.0, 1.0;

  Eigen::RowVectorXd C(2);
  C << 2.0, 1.0;

  double D = 0.0;

  // Similarity transform z = T x
  MatrixXd T(2,2);
  T << 1.0, 1.0,
       0.0, 1.0;
  MatrixXd Ti = T.inverse();

  MatrixXd A2 = T * A * Ti;
  VectorXd B2 = T * B;
  Eigen::RowVectorXd C2 = C * Ti;
  double D2 = D;

  auto evalG = [](double s,
                  const MatrixXd& A,
                  const VectorXd& B,
                  const Eigen::RowVectorXd& C,
                  double D) {
    MatrixXd I = MatrixXd::Identity(A.rows(), A.cols());
    MatrixXd M = (s * I - A);
    VectorXd x = M.fullPivLu().solve(B);
    double val = (C * x)(0) + D;
    return val;
  };

  std::vector<double> tests = {1.0, 2.0, 3.0};
  for (double s : tests) {
    double g1 = evalG(s, A, B, C, D);
    double g2 = evalG(s, A2, B2, C2, D2);
    std::cout << "s=" << s << "  G1(s)=" << g1 << "  G2(s)=" << g2 << std::endl;
  }

  return 0;
}
      

Related C++ ecosystem notes for modern control workflows: Eigen covers matrix computations; for simulation of \( \dot{x}=Ax+Bu \), common choices include Boost.Odeint or custom integrators (later lessons will emphasize state propagation).

Java does not have a single standard “control toolbox,” but EJML is a strong option for matrix algebra. Below we evaluate \( G(s) \) at real \( s \) and confirm invariance under similarity.

import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;

public class RealizationEquivalence {
  static double evalG(double s, DMatrixRMaj A, DMatrixRMaj B, DMatrixRMaj C, double D) {
    int n = A.numRows;
    DMatrixRMaj I = CommonOps_DDRM.identity(n);

    // M = s I - A
    DMatrixRMaj M = new DMatrixRMaj(n, n);
    CommonOps_DDRM.scale(s, I, M);
    CommonOps_DDRM.subtractEquals(M, A);

    // Solve M x = B
    DMatrixRMaj x = new DMatrixRMaj(n, 1);
    CommonOps_DDRM.solve(M, B, x);

    // val = C x + D
    DMatrixRMaj Cx = new DMatrixRMaj(1, 1);
    CommonOps_DDRM.mult(C, x, Cx);
    return Cx.get(0, 0) + D;
  }

  public static void main(String[] args) {
    // A, B, C, D for G(s) = (s+2) / (s^2 + 3 s + 2)
    DMatrixRMaj A = new DMatrixRMaj(new double[][]{
        {0.0, 1.0},
        {-2.0, -3.0}
    });
    DMatrixRMaj B = new DMatrixRMaj(new double[][]{
        {0.0},
        {1.0}
    });
    DMatrixRMaj C = new DMatrixRMaj(new double[][]{
        {2.0, 1.0}
    });
    double D = 0.0;

    // Similarity transform z = T x
    DMatrixRMaj T = new DMatrixRMaj(new double[][]{
        {1.0, 1.0},
        {0.0, 1.0}
    });
    DMatrixRMaj Ti = new DMatrixRMaj(2, 2);
    CommonOps_DDRM.invert(T, Ti);

    DMatrixRMaj A2 = new DMatrixRMaj(2, 2);
    DMatrixRMaj temp = new DMatrixRMaj(2, 2);
    CommonOps_DDRM.mult(T, A, temp);
    CommonOps_DDRM.mult(temp, Ti, A2);

    DMatrixRMaj B2 = new DMatrixRMaj(2, 1);
    CommonOps_DDRM.mult(T, B, B2);

    DMatrixRMaj C2 = new DMatrixRMaj(1, 2);
    CommonOps_DDRM.mult(C, Ti, C2);

    double[] tests = new double[]{1.0, 2.0, 3.0};
    for (double s : tests) {
      double g1 = evalG(s, A, B, C, D);
      double g2 = evalG(s, A2, B2, C2, D);
      System.out.println("s=" + s + "  G1(s)=" + g1 + "  G2(s)=" + g2);
    }
  }
}
      

If you need complex-frequency evaluation (\( s=j\omega \)) later, consider using Apache Commons Math for complex arithmetic, and represent complex matrices either via 2-by-2 real block lifting or a dedicated complex matrix library.

MATLAB’s Control System Toolbox supports direct conversion between ss and tf. We verify that similarity transformations and hidden-state augmentation preserve the transfer function.

% Original realization
A = [0 1; -2 -3];
B = [0; 1];
C = [2 1];
D = 0;

sys1 = ss(A,B,C,D);
tf1 = tf(sys1)

% Similarity transform z = T x
T  = [1 1; 0 1];
Ti = inv(T);

A2 = T*A*Ti;
B2 = T*B;
C2 = C*Ti;
D2 = D;

sys2 = ss(A2,B2,C2,D2);
tf2 = tf(sys2)

% Numeric check on frequency response
w = logspace(-2,2,50);
[mag1,ph1] = bode(sys1,w);
[mag2,ph2] = bode(sys2,w);
maxMagErr = max(abs(mag1(:)-mag2(:)));
maxPhErr  = max(abs(ph1(:)-ph2(:)));
disp([maxMagErr, maxPhErr])

% Append hidden dynamics
Ah = -5;                 % hidden pole
Aaug = blkdiag(A, Ah);
Baug = [B; 0];
Caug = [C 0];
Daug = D;

sysAug = ss(Aaug, Baug, Caug, Daug);
tfAug = tf(sysAug)
      

Simulink sketch (programmatic). The script below creates a simple model that compares time responses of sys1 and sys2 under a step input using “State-Space” blocks.

% Build a Simulink model to compare sys1 and sys2 step responses
model = 'ss_similarity_demo';
new_system(model); open_system(model);

add_block('simulink/Sources/Step', [model '/Step']);
add_block('simulink/Continuous/State-Space', [model '/SS1']);
add_block('simulink/Continuous/State-Space', [model '/SS2']);
add_block('simulink/Sinks/Scope', [model '/Scope']);

% Set matrices (as strings)
set_param([model '/SS1'], 'A', mat2str(A),  'B', mat2str(B),  'C', mat2str(C),  'D', mat2str(D));
set_param([model '/SS2'], 'A', mat2str(A2), 'B', mat2str(B2), 'C', mat2str(C2), 'D', mat2str(D2));

% Wire the model
add_line(model, 'Step/1', 'SS1/1');
add_line(model, 'Step/1', 'SS2/1');
add_line(model, 'SS1/1', 'Scope/1');
add_line(model, 'SS2/1', 'Scope/2');

set_param(model, 'StopTime', '5');
sim(model);
      

Mathematica can verify equality symbolically (exact arithmetic) when matrices are rational or integer. We compute \( G(s)=C(sI-A)^{-1}B+D \) and compare it to the similarity-transformed version.

ClearAll["Global`*"];

A = { {0, 1}, {-2, -3} };
B = { {0}, {1} };
C = { {2, 1} };
D = { {0} };

(* Similarity transform z = T x *)
T  = { {1, 1}, {0, 1} };
Ti = Inverse[T];

A2 = T.A.Ti;
B2 = T.B;
C2 = C.Ti;
D2 = D;

(* Transfer functions as symbolic rational expressions *)
G[s_]  := Simplify[C.Inverse[s IdentityMatrix[2] - A].B + D];
G2[s_] := Simplify[C2.Inverse[s IdentityMatrix[2] - A2].B2 + D2];

Simplify[G[s] - G2[s]]
(* Expected output: {{0}} *)

(* Hidden-state augmentation check *)
Ah = {{-5}};
Aaug = ArrayFlatten[{ {A, ConstantArray[0, {2, 1}]},
                    {ConstantArray[0, {1, 2}], Ah} }];
Baug = ArrayFlatten[{ {B}, {{0}} }];
Caug = ArrayFlatten[{ {C, {{0}}} }];
Daug = D;

Gaug[s_] := Simplify[Caug.Inverse[s IdentityMatrix[3] - Aaug].Baug + Daug];
Simplify[G[s] - Gaug[s]]
(* Expected output: {{0}} *)
      

This provides an exact (not merely numerical) confirmation of Theorems 1–2 for the chosen example.

Problem 1 (Similarity invariance): Let \( (A,B,C,D) \) be a realization and define \( A'=TAT^{-1} \), \( B'=TB \), \( C'=CT^{-1} \), \( D'=D \) with \( T \) invertible. Prove that \( G'(s)=G(s) \).

Solution: This is exactly Theorem 1. The key identity is \( (sI-TAT^{-1})^{-1} = T(sI-A)^{-1}T^{-1} \), obtained from \( sI-TAT^{-1}=T(sI-A)T^{-1} \). Substituting yields \( C'(sI-A')^{-1}B'+D' = C(sI-A)^{-1}B + D \).

Problem 2 (Eigenvalues as internal invariants under coordinate change): Show that \( A \) and \( A'=TAT^{-1} \) have the same characteristic polynomial and hence the same eigenvalues.

Solution: The characteristic polynomial of \( A' \) is:

\[ \det(sI-A') = \det(sI-TAT^{-1}) = \det\bigl(T(sI-A)T^{-1}\bigr) = \\ \det(T)\det(sI-A)\det(T^{-1}) = \det(sI-A). \]

Hence the roots (eigenvalues) coincide. This confirms that similarity changes coordinates but preserves the internal spectrum of the order-fixed realization.

Problem 3 (Markov parameter invariance): Using the expansion \( G(s)=D+\sum_{k=0}^\infty \dfrac{CA^kB}{s^{k+1}} \) (valid for \( |s| > \|A\| \)), prove that \( CA^kB \) is invariant under similarity.

Solution: Under similarity, \( A'=TAT^{-1} \), \( B'=TB \), \( C'=CT^{-1} \). Then:

\[ C'(A')^kB' = (CT^{-1})(TAT^{-1})^k(TB) = (CT^{-1})(TA^kT^{-1})(TB) = CA^kB. \]

Therefore every coefficient in the high-frequency expansion is the same, implying identical transfer functions.

Problem 4 (Augmentation invariance): Construct \( (\tilde{A},\tilde{B},\tilde{C},\tilde{D}) \) by appending any \( A_h\in\mathbb{R}^{r\times r} \) with \( \tilde{A}=\begin{bmatrix}A&0\\0&A_h\end{bmatrix} \), \( \tilde{B}=\begin{bmatrix}B\\0\end{bmatrix} \), \( \tilde{C}=\begin{bmatrix}C&0\end{bmatrix} \), \( \tilde{D}=D \). Prove \( \tilde{G}(s)=G(s) \).

Solution: This is Theorem 2. Because \( \tilde{A} \) is block diagonal, the inverse \( (sI-\tilde{A})^{-1} \) is block diagonal with blocks \( (sI-A)^{-1} \) and \( (sI-A_h)^{-1} \). Multiplying by \( \tilde{B} \) zeros out the hidden block, and multiplying by \( \tilde{C} \) discards it. Hence \( \tilde{C}(sI-\tilde{A})^{-1}\tilde{B} = C(sI-A)^{-1}B \).

Problem 5 (Compute an explicit transformed realization): For the example in Section 5, compute \( A',B',C' \) explicitly for \( T=\begin{bmatrix}1&1\\0&1\end{bmatrix} \) and verify that \( C'(sI-A')^{-1}B' \) simplifies to \( \dfrac{s+2}{s^2+3s+2} \).

Solution: First compute \( T^{-1}=\begin{bmatrix}1&-1\\0&1\end{bmatrix} \). Then:

\[ A' = TAT^{-1},\quad B'=TB,\quad C'=CT^{-1}. \]

Carrying out the products gives a concrete triple \( (A',B',C') \). By Theorem 1, the transfer function is guaranteed to be identical; a direct symbolic check can be done exactly in Mathematica (Section 10) or by converting to transfer form in MATLAB/Python (Sections 6 and 9).

A transfer function determines an input–output operator, not a unique internal coordinate system. We proved two core non-uniqueness mechanisms: (i) similarity transformations \( z=Tx \), which preserve order and leave \( G(s) \) unchanged, and (ii) augmented realizations, which increase state dimension by appending hidden dynamics that do not couple to input or output. We also identified invariants such as the impulse response \( Ce^{At}B \) and Markov parameters \( CA^kB \), and verified equivalence across Python, C++, Java, MATLAB/Simulink, and Mathematica implementations.