In classical single-input single-output control, zeros are often introduced as roots of the numerator of a transfer function \( G(s)=N(s)/D(s) \). That definition is useful, but it becomes incomplete for multi-input multi-output systems because the transfer function becomes a matrix \( \mathbf{G}(s)\in\mathbb{C}^{p\times m} \), and there is no unique scalar numerator. State space provides an intrinsic definition that works for SISO and MIMO systems.

Consider the continuous-time LTI system

\[ \dot{\mathbf{x} }(t)=\mathbf{A}\mathbf{x}(t)+\mathbf{B}\mathbf{u}(t), \qquad \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{u}(t). \]

The associated transfer matrix is

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

A transmission zero is a complex frequency at which the system can transmit a nonzero internal/input signal while the output channel loses rank. In SISO language, this is the generalized state-space analogue of numerator cancellation in the input-output map.

Define the Rosenbrock system matrix \( \mathbf{R}(s) \) by

\[ \mathbf{R}(s)= \begin{bmatrix} s\mathbf{I}-\mathbf{A} & -\mathbf{B} \\ \mathbf{C} & \mathbf{D} \end{bmatrix}. \]

The matrix has \( n+p \) rows and \( n+m \) columns, where \( n \) is the number of states, \( m \) is the number of inputs, and \( p \) is the number of outputs.

flowchart TD
  A["State equation: xdot = A x + B u"] --> R["Build Rosenbrock matrix R(s)"]
  B["Output equation: y = C x + D u"] --> R
  R --> NR["Compute normal rank over complex s"]
  NR --> TEST["Find z where rank R(z) drops"]
  TEST --> ZERO["z is a finite transmission zero"]
        

The normal rank of \( \mathbf{R}(s) \) is the largest rank attained by \( \mathbf{R}(s) \) except at isolated exceptional values:

\[ \rho = \operatorname{normalrank}\,\mathbf{R}(s) = \max_{s\in\mathbb{C} } \operatorname{rank}\mathbf{R}(s). \]

Normal rank is important because a zero is not defined by an absolute rank value alone; it is defined by a rank loss relative to the generic rank of the polynomial matrix.

A complex number \( z\in\mathbb{C} \) is called a finite transmission zero of the state-space system if

\[ \operatorname{rank}\mathbf{R}(z) < \operatorname{normalrank}\,\mathbf{R}(s). \]

Equivalently, there exists a nonzero vector \( \begin{bmatrix}\mathbf{x}_0^T & \mathbf{u}_0^T\end{bmatrix}^T \ne \mathbf{0} \) such that

\[ \begin{bmatrix} z\mathbf{I}-\mathbf{A} & -\mathbf{B} \\ \mathbf{C} & \mathbf{D} \end{bmatrix} \begin{bmatrix} \mathbf{x}_0 \\ \mathbf{u}_0 \end{bmatrix} = \begin{bmatrix} \mathbf{0} \\ \mathbf{0} \end{bmatrix}. \]

Written as two equations, this means

\[ z\mathbf{x}_0 = \mathbf{A}\mathbf{x}_0+\mathbf{B}\mathbf{u}_0, \qquad \mathbf{0}=\mathbf{C}\mathbf{x}_0+\mathbf{D}\mathbf{u}_0. \]

Hence \( z \) is a frequency at which a state-input direction can satisfy the state equation while producing zero output. The associated vector \( \mathbf{x}_0 \) is a zero direction in state space, and \( \mathbf{u}_0 \) is a zeroing input direction.

Suppose \( z \) and \( (\mathbf{x}_0,\mathbf{u}_0) \) satisfy the Rosenbrock null-space equations. Define

\[ \mathbf{x}(t)=e^{zt}\mathbf{x}_0,\qquad \mathbf{u}(t)=e^{zt}\mathbf{u}_0. \]

Then

\[ \dot{\mathbf{x} }(t)=ze^{zt}\mathbf{x}_0 =e^{zt}(\mathbf{A}\mathbf{x}_0+\mathbf{B}\mathbf{u}_0) =\mathbf{A}\mathbf{x}(t)+\mathbf{B}\mathbf{u}(t), \]

\[ \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{u}(t) =e^{zt}(\mathbf{C}\mathbf{x}_0+\mathbf{D}\mathbf{u}_0) =\mathbf{0}. \]

Therefore a transmission zero is a frequency of a hidden input-state motion: the system is internally active, but the measured output remains identically zero.

flowchart TD
  Z["Choose complex z"] --> N["Find nonzero vector [x0; u0] in null R(z)"]
  N --> X["x(t) = exp(z t) x0"]
  N --> U["u(t) = exp(z t) u0"]
  X --> Y["y(t) = C x(t) + D u(t)"]
  U --> Y
  Y --> O["Output is identically zero"]
        

For a minimal SISO realization with \( m=p=1 \), the Rosenbrock matrix is square of size \( n+1 \). Its determinant is closely related to the numerator of the transfer function:

\[ \det\mathbf{R}(s)=\kappa N(s), \qquad \kappa\ne 0, \]

where \( G(s)=N(s)/D(s) \) after cancellation has been avoided by using a minimal realization. Thus, in the SISO minimal case,

\[ z \text{ is a transmission zero} \quad \Longleftrightarrow \quad N(z)=0. \]

This connection explains why transmission zeros are the correct state-space generalization of numerator zeros, while also avoiding the ambiguity of matrix numerator factorizations in MIMO systems.

Consider

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

The transfer function is

\[ G(s)=\mathbf{C}(s\mathbf{I}-\mathbf{A})^{-1}\mathbf{B} =\frac{s+4}{s^2+3s+2}. \]

Hence the expected finite transmission zero is \( z=-4 \). The Rosenbrock matrix is

\[ \mathbf{R}(s)= \begin{bmatrix} s & -1 & 0\\ 2 & s+3 & -1\\ 4 & 1 & 0 \end{bmatrix}. \]

Its determinant is

\[ \det\mathbf{R}(s)=s+4. \]

At \( z=-4 \),

\[ \mathbf{R}(-4) \begin{bmatrix}1\\-4\\6\end{bmatrix} = \begin{bmatrix}0\\0\\0\end{bmatrix}. \]

Therefore \( \mathbf{x}_0=[1,-4]^T \) and \( u_0=6 \) generate a nonzero exponential internal motion with zero output:

\[ \mathbf{x}(t)=e^{-4t}\begin{bmatrix}1\\-4\end{bmatrix}, \qquad u(t)=6e^{-4t}, \qquad y(t)=0. \]

Python libraries commonly used for this topic are NumPy for matrix construction, SciPy for SVD and numerical rank, SymPy for exact determinant calculations, and the optional python-control package for higher-level state-space utilities.

Chapter21_Lesson1.py

# Chapter21_Lesson1.py
# Finite transmission zeros from the Rosenbrock system matrix.
# Required packages: numpy, scipy, sympy
#
# Model:
#   x_dot = A x + B u
#   y     = C x + D u
#
# A complex number z is a finite transmission zero if the Rosenbrock matrix
#   R(z) = [[zI - A, -B],
#           [C,       D]]
# loses rank relative to its normal rank.

import numpy as np
import scipy.linalg as la
import sympy as sp


def rosenbrock_matrix(A, B, C, D, s):
    """Return the Rosenbrock system matrix R(s)."""
    A = np.asarray(A, dtype=complex)
    B = np.asarray(B, dtype=complex)
    C = np.asarray(C, dtype=complex)
    D = np.asarray(D, dtype=complex)

    n = A.shape[0]
    top = np.hstack((s * np.eye(n, dtype=complex) - A, -B))
    bottom = np.hstack((C, D))
    return np.vstack((top, bottom))


def numerical_rank(M, tol=1e-9):
    """SVD-based numerical rank."""
    singular_values = la.svd(M, compute_uv=False)
    return int(np.sum(singular_values > tol))


def siso_zeros_by_rosenbrock_determinant(A, B, C, D):
    """
    For a square SISO Rosenbrock matrix, det(R(s)) gives the finite invariant
    zero polynomial up to a nonzero scalar factor when the realization is regular.
    """
    s = sp.symbols("s")
    A_sp = sp.Matrix(A)
    B_sp = sp.Matrix(B)
    C_sp = sp.Matrix(C)
    D_sp = sp.Matrix(D)
    n = A_sp.rows

    R = A_sp.zeros(n + C_sp.rows, n + B_sp.cols)
    R[:n, :n] = s * sp.eye(n) - A_sp
    R[:n, n:] = -B_sp
    R[n:, :n] = C_sp
    R[n:, n:] = D_sp

    zero_polynomial = sp.factor(R.det())
    roots = sp.nroots(zero_polynomial)
    return zero_polynomial, roots, R


def main():
    # Minimal SISO example with transfer function G(s) = (s + 4)/(s^2 + 3s + 2).
    A = np.array([[0.0, 1.0],
                  [-2.0, -3.0]])
    B = np.array([[0.0],
                  [1.0]])
    C = np.array([[4.0, 1.0]])
    D = np.array([[0.0]])

    zero_polynomial, zeros, R_symbolic = siso_zeros_by_rosenbrock_determinant(A, B, C, D)
    print("Symbolic Rosenbrock matrix R(s):")
    print(R_symbolic)
    print("\ndet(R(s)) =", zero_polynomial)
    print("Transmission zeros =", zeros)

    z = complex(-4.0, 0.0)
    Rz = rosenbrock_matrix(A, B, C, D, z)
    print("\nR(-4) =")
    print(np.real_if_close(Rz))
    print("rank R(-4) =", numerical_rank(Rz))
    print("normal rank for this SISO square example =", A.shape[0] + B.shape[1])

    # Verify the zero-output exponential trajectory:
    # x(t) = exp(z t) x0, u(t) = exp(z t) u0.
    x0 = np.array([[1.0], [-4.0]])
    u0 = np.array([[6.0]])
    residual_state = (z * x0) - A @ x0 - B @ u0
    residual_output = C @ x0 + D @ u0
    print("\nState residual z*x0 - A*x0 - B*u0 =")
    print(np.real_if_close(residual_state))
    print("Output residual C*x0 + D*u0 =")
    print(np.real_if_close(residual_output))


if __name__ == "__main__":
    main()

In C++, the standard numerical library for this lesson is Eigen. The implementation below constructs \( \mathbf{R}(s) \), estimates rank using singular values, and scans the real line for a determinant sign change in the SISO square case.

Chapter21_Lesson1.cpp

// Chapter21_Lesson1.cpp
// Finite transmission-zero check using the Rosenbrock system matrix.
// Required library: Eigen 3
//
// Compile example:
//   g++ -std=c++17 Chapter21_Lesson1.cpp -I /path/to/eigen -O2 -o Chapter21_Lesson1
//
// The code verifies that z = -4 is a transmission zero for
// G(s) = (s + 4)/(s^2 + 3s + 2).

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

using Matrix = Eigen::MatrixXd;

Matrix rosenbrockMatrix(const Matrix& A, const Matrix& B, const Matrix& C,
                        const Matrix& D, double s) {
    const int n = static_cast<int>(A.rows());
    const int p = static_cast<int>(C.rows());
    const int m = static_cast<int>(B.cols());

    Matrix R(n + p, n + m);
    R.block(0, 0, n, n) = s * Matrix::Identity(n, n) - A;
    R.block(0, n, n, m) = -B;
    R.block(n, 0, p, n) = C;
    R.block(n, n, p, m) = D;
    return R;
}

int numericalRank(const Matrix& M, double tol = 1.0e-9) {
    Eigen::JacobiSVD<Matrix> svd(M);
    int r = 0;
    for (int i = 0; i < svd.singularValues().size(); ++i) {
        if (svd.singularValues()(i) > tol) {
            ++r;
        }
    }
    return r;
}

double detRosenbrock(const Matrix& A, const Matrix& B, const Matrix& C,
                     const Matrix& D, double s) {
    Matrix R = rosenbrockMatrix(A, B, C, D, s);
    return R.determinant();
}

std::vector<double> scanRealZeros(const Matrix& A, const Matrix& B,
                                  const Matrix& C, const Matrix& D,
                                  double left, double right, double step) {
    std::vector<double> roots;

    double a = left;
    double fa = detRosenbrock(A, B, C, D, a);

    for (double b = left + step; b <= right; b += step) {
        double fb = detRosenbrock(A, B, C, D, b);

        if (std::abs(fa) < 1.0e-8) {
            roots.push_back(a);
        } else if (fa * fb < 0.0) {
            double lo = a;
            double hi = b;
            for (int k = 0; k < 80; ++k) {
                double mid = 0.5 * (lo + hi);
                double fm = detRosenbrock(A, B, C, D, mid);
                if (fa * fm <= 0.0) {
                    hi = mid;
                    fb = fm;
                } else {
                    lo = mid;
                    fa = fm;
                }
            }
            roots.push_back(0.5 * (lo + hi));
        }

        a = b;
        fa = fb;
    }

    return roots;
}

int main() {
    Matrix A(2, 2);
    A << 0.0, 1.0,
        -2.0, -3.0;

    Matrix B(2, 1);
    B << 0.0,
         1.0;

    Matrix C(1, 2);
    C << 4.0, 1.0;

    Matrix D(1, 1);
    D << 0.0;

    std::cout << "det R(s) scanned on the real line." << std::endl;
    auto roots = scanRealZeros(A, B, C, D, -20.0, 20.0, 0.1);
    for (double root : roots) {
        std::cout << "Candidate real transmission zero: " << root << std::endl;
    }

    Matrix Rminus4 = rosenbrockMatrix(A, B, C, D, -4.0);
    std::cout << "\nR(-4) =\n" << Rminus4 << std::endl;
    std::cout << "rank R(-4) = " << numericalRank(Rminus4) << std::endl;
    std::cout << "normal rank = " << A.rows() + B.cols() << std::endl;

    Matrix xu(3, 1);
    xu << 1.0, -4.0, 6.0;
    std::cout << "\nR(-4) * [x; u] =\n" << Rminus4 * xu << std::endl;

    return 0;
}

Java does not include a built-in numerical linear algebra package in the standard library. In engineering projects, Apache Commons Math, EJML, or ojAlgo are common choices. To keep the algorithm transparent, the code below implements Gaussian elimination directly.

Chapter21_Lesson1.java

// Chapter21_Lesson1.java
// Finite transmission-zero check using the Rosenbrock system matrix.
// This version is implemented from scratch, without external libraries.

public class Chapter21_Lesson1 {
    static double[][] rosenbrockMatrix(double[][] A, double[][] B,
                                       double[][] C, double[][] D, double s) {
        int n = A.length;
        int p = C.length;
        int m = B[0].length;
        double[][] R = new double[n + p][n + m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                R[i][j] = -A[i][j];
                if (i == j) {
                    R[i][j] += s;
                }
            }
            for (int j = 0; j < m; j++) {
                R[i][n + j] = -B[i][j];
            }
        }

        for (int i = 0; i < p; i++) {
            for (int j = 0; j < n; j++) {
                R[n + i][j] = C[i][j];
            }
            for (int j = 0; j < m; j++) {
                R[n + i][n + j] = D[i][j];
            }
        }

        return R;
    }

    static double determinant(double[][] input) {
        int n = input.length;
        double[][] A = copy(input);
        double det = 1.0;

        for (int k = 0; k < n; k++) {
            int pivot = k;
            for (int i = k + 1; i < n; i++) {
                if (Math.abs(A[i][k]) > Math.abs(A[pivot][k])) {
                    pivot = i;
                }
            }

            if (Math.abs(A[pivot][k]) < 1e-12) {
                return 0.0;
            }

            if (pivot != k) {
                double[] tmp = A[k];
                A[k] = A[pivot];
                A[pivot] = tmp;
                det *= -1.0;
            }

            det *= A[k][k];
            double pivotValue = A[k][k];
            for (int i = k + 1; i < n; i++) {
                double factor = A[i][k] / pivotValue;
                for (int j = k; j < n; j++) {
                    A[i][j] -= factor * A[k][j];
                }
            }
        }

        return det;
    }

    static int rank(double[][] input, double tol) {
        double[][] A = copy(input);
        int rows = A.length;
        int cols = A[0].length;
        int rank = 0;
        int row = 0;

        for (int col = 0; col < cols && row < rows; col++) {
            int pivot = row;
            for (int i = row + 1; i < rows; i++) {
                if (Math.abs(A[i][col]) > Math.abs(A[pivot][col])) {
                    pivot = i;
                }
            }

            if (Math.abs(A[pivot][col]) <= tol) {
                continue;
            }

            double[] tmp = A[row];
            A[row] = A[pivot];
            A[pivot] = tmp;

            double pivotValue = A[row][col];
            for (int j = col; j < cols; j++) {
                A[row][j] /= pivotValue;
            }

            for (int i = 0; i < rows; i++) {
                if (i != row) {
                    double factor = A[i][col];
                    for (int j = col; j < cols; j++) {
                        A[i][j] -= factor * A[row][j];
                    }
                }
            }

            rank++;
            row++;
        }

        return rank;
    }

    static double[][] copy(double[][] input) {
        double[][] out = new double[input.length][input[0].length];
        for (int i = 0; i < input.length; i++) {
            System.arraycopy(input[i], 0, out[i], 0, input[i].length);
        }
        return out;
    }

    static void printMatrix(double[][] M) {
        for (double[] row : M) {
            for (double value : row) {
                System.out.printf("%12.6f ", value);
            }
            System.out.println();
        }
    }

    static double detR(double[][] A, double[][] B, double[][] C, double[][] D, double s) {
        return determinant(rosenbrockMatrix(A, B, C, D, s));
    }

    public static void main(String[] args) {
        double[][] A = {
            {0.0, 1.0},
            {-2.0, -3.0}
        };
        double[][] B = {
            {0.0},
            {1.0}
        };
        double[][] C = {
            {4.0, 1.0}
        };
        double[][] D = {
            {0.0}
        };

        double z = -4.0;
        double[][] Rz = rosenbrockMatrix(A, B, C, D, z);

        System.out.println("R(-4) =");
        printMatrix(Rz);
        System.out.println("rank R(-4) = " + rank(Rz, 1e-9));
        System.out.println("normal rank = " + (A.length + B[0].length));
        System.out.println("det R(-4) = " + determinant(Rz));

        System.out.println("\nReal-line scan of det R(s):");
        double previousS = -20.0;
        double previousF = detR(A, B, C, D, previousS);

        for (double s = -19.9; s <= 20.0; s += 0.1) {
            double f = detR(A, B, C, D, s);
            if (previousF * f < 0.0 || Math.abs(f) < 1e-8) {
                System.out.printf("candidate zero near s = %.3f%n", s);
            }
            previousS = s;
            previousF = f;
        }
    }
}

MATLAB's Control System Toolbox provides ss and tzero. The same file also demonstrates a symbolic Rosenbrock determinant and optionally creates a small Simulink model using a State-Space block.

Chapter21_Lesson1.m

% Chapter21_Lesson1.m
% Finite transmission zeros from the Rosenbrock system matrix.
% MATLAB functions used:
%   ss, tzero   : Control System Toolbox, if available
%   rank, svd   : core numerical linear algebra
%   syms, det   : Symbolic Math Toolbox, if available
%
% Simulink section:
%   Creates a simple State-Space block model if Simulink is installed.

clear; clc;

A = [0 1; -2 -3];
B = [0; 1];
C = [4 1];
D = 0;

fprintf('System: G(s) = (s + 4)/(s^2 + 3s + 2)\n');

% Control System Toolbox route
if exist('ss', 'file') == 2 && exist('tzero', 'file') == 2
    sys = ss(A, B, C, D);
    z = tzero(sys);
    disp('Transmission zeros from tzero(sys):');
    disp(z);
else
    disp('Control System Toolbox tzero not found; using Rosenbrock rank check.');
end

% Rosenbrock rank check at z = -4
z0 = -4;
Rz = [z0*eye(size(A,1)) - A, -B; C, D];
disp('R(-4) =');
disp(Rz);
fprintf('rank R(-4) = %d\n', rank(Rz));
fprintf('normal rank for this SISO square case = %d\n', size(A,1) + size(B,2));

% Symbolic determinant route
if exist('syms', 'file') == 2
    syms s
    R = [s*eye(size(A,1)) - A, -B; C, D];
    zeroPolynomial = factor(det(R));
    disp('det R(s) =');
    disp(zeroPolynomial);
    disp('roots(det R(s)) =');
    disp(double(solve(zeroPolynomial == 0, s)));
else
    disp('Symbolic Math Toolbox not found; skipping symbolic determinant.');
end

% Verify zero-output exponential trajectory
x0 = [1; -4];
u0 = 6;
stateResidual = z0*x0 - A*x0 - B*u0;
outputResidual = C*x0 + D*u0;
disp('state residual z*x0 - A*x0 - B*u0 =');
disp(stateResidual);
disp('output residual C*x0 + D*u0 =');
disp(outputResidual);

% Optional Simulink model generation
if exist('simulink', 'file') == 2
    modelName = 'Chapter21_Lesson1_Simulink';
    if bdIsLoaded(modelName)
        close_system(modelName, 0);
    end
    new_system(modelName);
    open_system(modelName);

    add_block('simulink/Sources/Step', [modelName '/StepInput'], ...
        'Position', [60 80 100 110]);
    add_block('simulink/Continuous/State-Space', [modelName '/StateSpacePlant'], ...
        'A', mat2str(A), 'B', mat2str(B), 'C', mat2str(C), 'D', mat2str(D), ...
        'Position', [170 70 300 120]);
    add_block('simulink/Sinks/Scope', [modelName '/OutputScope'], ...
        'Position', [380 75 430 115]);

    add_line(modelName, 'StepInput/1', 'StateSpacePlant/1');
    add_line(modelName, 'StateSpacePlant/1', 'OutputScope/1');

    save_system(modelName);
    disp(['Simulink model saved as ', modelName, '.slx']);
else
    disp('Simulink not found; skipping model generation.');
end

Mathematica is useful for exact symbolic manipulation of polynomial matrices. The notebook computes \( \det\mathbf{R}(s) \), solves for the zero, and extracts the Rosenbrock null space.

Chapter21_Lesson1.nb

Notebook[{
 Cell["Chapter21_Lesson1.nb", "Title"],
 Cell["Finite transmission zeros from the Rosenbrock system matrix.", "Text"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"A", "=", RowBox[{"{ {", RowBox[{
      RowBox[{"0", ",", "1"}], "}", ",", "{", RowBox[{
      RowBox[{"-2", ",", "-3"}]}], "} }"}]}], ";"}]], "Input"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"B", "=", RowBox[{"{ {", "0", "}", ",", "{", "1", "} }"}]}], ";"}]], "Input"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"Cmat", "=", RowBox[{"{ {", RowBox[{"4", ",", "1"}], "} }"}]}], ";"}]], "Input"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"Dmat", "=", RowBox[{"{ {", "0", "} }"}]}], ";"}]], "Input"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"R", "[", "s_", "]"}], ":=", RowBox[{"ArrayFlatten", "[", 
    RowBox[{"{ {", RowBox[{
     RowBox[{RowBox[{"s", " ", RowBox[{"IdentityMatrix", "[", "2", "]"}]}], "-", "A"}], ",", RowBox[{"-", "B"}]}],
     "}", ",", "{", RowBox[{"Cmat", ",", "Dmat"}], "} }"}], "]"}]}]], "Input"],
 Cell[BoxData[
  RowBox[{"MatrixForm", "[", RowBox[{"R", "[", "s", "]"}], "]"}]], "Input"],
 Cell[BoxData[
  RowBox[{"zeroPolynomial", "=", RowBox[{"Factor", "[", RowBox[{"Det", "[", RowBox[{"R", "[", "s", "]"}], "]"}], "]"}]}]], "Input"],
 Cell[BoxData[
  RowBox[{"zeros", "=", RowBox[{"s", "/.", RowBox[{"Solve", "[", RowBox[{
    RowBox[{"zeroPolynomial", "==", "0"}], ",", "s"}], "]"}]}]}]], "Input"],
 Cell[BoxData[
  RowBox[{"MatrixRank", "[", RowBox[{"R", "[", RowBox[{"-", "4"}], "]"}], "]"}]], "Input"],
 Cell[BoxData[
  RowBox[{"NullSpace", "[", RowBox[{"R", "[", RowBox[{"-", "4"}], "]"}], "]"}]], "Input"],
 Cell[BoxData[
  RowBox[{
   RowBox[{"x0", "=", RowBox[{"{ {", "1", "}", ",", "{", RowBox[{"-", "4"}], "} }"}]}], ";",
   RowBox[{"u0", "=", RowBox[{"{ {", "6", "} }"}]}], ";"}]], "Input"],
 Cell[BoxData[
  RowBox[{"Simplify", "[", RowBox[{
   RowBox[{RowBox[{"-", "4"}], " ", "x0"}], "-", RowBox[{"A", ".", "x0"}], "-", RowBox[{"B", ".", "u0"}]}], "]"}]], "Input"],
 Cell[BoxData[
  RowBox[{"Simplify", "[", RowBox[{RowBox[{"Cmat", ".", "x0"}], "+", RowBox[{"Dmat", ".", "u0"}]}], "]"}]], "Input"]
}]

Problem 1: Let \( \dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \), \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \). Prove that if \( \mathbf{R}(z)[\mathbf{x}_0^T,\mathbf{u}_0^T]^T=0 \), then \( \mathbf{x}(t)=e^{zt}\mathbf{x}_0 \) and \( \mathbf{u}(t)=e^{zt}\mathbf{u}_0 \) produce \( \mathbf{y}(t)=0 \).

Solution: The Rosenbrock equation gives \( z\mathbf{x}_0=\mathbf{A}\mathbf{x}_0+\mathbf{B}\mathbf{u}_0 \) and \( \mathbf{C}\mathbf{x}_0+\mathbf{D}\mathbf{u}_0=0 \). Differentiating \( \mathbf{x}(t)=e^{zt}\mathbf{x}_0 \) yields

\[ \dot{\mathbf{x} }(t)=ze^{zt}\mathbf{x}_0 =e^{zt}(\mathbf{A}\mathbf{x}_0+\mathbf{B}\mathbf{u}_0) =\mathbf{A}\mathbf{x}(t)+\mathbf{B}\mathbf{u}(t). \]

Also,

\[ \mathbf{y}(t)=e^{zt}(\mathbf{C}\mathbf{x}_0+\mathbf{D}\mathbf{u}_0)=0. \]

Problem 2: For the worked example in Section 6, verify directly that \( z=-4 \) is a transmission zero.

Solution: The Rosenbrock matrix at \( z=-4 \) is

\[ \mathbf{R}(-4)= \begin{bmatrix} -4 & -1 & 0\\ 2 & -1 & -1\\ 4 & 1 & 0 \end{bmatrix}. \]

Multiplying by \( [1,-4,6]^T \) gives

\[ \begin{bmatrix} -4 & -1 & 0\\ 2 & -1 & -1\\ 4 & 1 & 0 \end{bmatrix} \begin{bmatrix}1\\-4\\6\end{bmatrix} = \begin{bmatrix}0\\0\\0\end{bmatrix}. \]

Thus \( \operatorname{rank}\mathbf{R}(-4)<3 \), so \( -4 \) is a finite transmission zero.

Problem 3: Show that for a minimal SISO realization, roots of the numerator of \( G(s) \) are finite transmission zeros.

Solution: In a minimal SISO realization, no pole-zero cancellations are hidden by uncontrollable or unobservable modes. Since the Rosenbrock matrix is square, rank loss is equivalent to \( \det\mathbf{R}(z)=0 \). The determinant equals a nonzero scalar multiple of the transfer numerator:

\[ \det\mathbf{R}(s)=\kappa N(s),\qquad \kappa\ne0. \]

Therefore \( N(z)=0 \) if and only if \( \det\mathbf{R}(z)=0 \), which is precisely a rank drop of \( \mathbf{R}(z) \).

Problem 4: Explain why the rank-drop definition is preferable to simply checking when \( \operatorname{rank}\mathbf{G}(z) \) drops.

Solution: The transfer matrix \( \mathbf{G}(s) \) is undefined at poles, and numerator-denominator cancellations may hide internal structure. The Rosenbrock matrix contains both the state equation and the output equation, so it identifies zero-output state-input motions directly. It also handles non-square MIMO systems without requiring an arbitrary scalar numerator.

Problem 5: Let \( \mathbf{D} \) have full column rank in a system with \( m\le p \). Does this automatically eliminate all finite transmission zeros?

Solution: No. Full column rank of \( \mathbf{D} \) prevents some instantaneous input directions from being hidden at the output, but finite zeros also depend on the dynamic term \( \mathbf{C}(s\mathbf{I}-\mathbf{A})^{-1}\mathbf{B} \). A finite zero can still occur when the dynamic contribution and direct feedthrough combine to produce a rank loss in the Rosenbrock matrix.

A finite transmission zero is a complex value \( z \) at which the Rosenbrock system matrix loses rank relative to its normal rank. Equivalently, there exists a nonzero state-input direction that generates a valid exponential trajectory with identically zero output. In minimal SISO systems this definition reduces to the familiar numerator-zero definition, while in MIMO systems it provides the correct coordinate-invariant formulation.