In Lesson 1, transmission zeros were defined as complex values \( z \in \mathbb{C} \) at which the system loses input-output rank. For a continuous-time LTI system

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

the transfer matrix is \( \mathbf{G}(s)=\mathbf{C}(s\mathbf{I}-\mathbf{A})^{-1}\mathbf{B} +\mathbf{D} \) . For SISO systems, zeros are roots of the numerator polynomial. For MIMO systems, however, there is generally no single numerator polynomial. Therefore, a more intrinsic state-space object is needed.

The key object is the Rosenbrock system matrix

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

A finite transmission zero is a value \( z \in \mathbb{C} \) for which this matrix loses normal rank:

\[ z \text{ is a transmission zero} \quad\Longleftrightarrow\quad \operatorname{rank}\mathcal{R}(z)< \operatorname{normalrank}\mathcal{R}(s). \]

flowchart TD
  A["State-space realization: A, B, C, D"] --> B["Build Rosenbrock matrix R(s)"]
  B --> C["Find normal rank over generic s"]
  C --> D["Search for values z where rank R(z) drops"]
  D --> E["Transmission / invariant zeros"]
  E --> F["Use zeros for zero dynamics, minimum-phase tests, and design limits"]
        

The rank-drop condition has a direct state-space interpretation. A complex number \( z \) is an invariant zero if there exist a nonzero pair \( (\mathbf{x}_0,\mathbf{u}_0) \neq (\mathbf{0},\mathbf{0}) \) satisfying

\[ \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}. \]

Equivalently,

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

The first equation means that the state trajectory \( \mathbf{x}(t)=e^{zt}\mathbf{x}_0 \) can be supported by the input \( \mathbf{u}(t)=e^{zt}\mathbf{u}_0 \). The second equation means the corresponding output is identically zero:

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

Thus, a transmission zero corresponds to a nontrivial internal motion and input direction that is completely invisible at the output.

When the number of inputs equals the number of outputs, \( m=p \), the Rosenbrock matrix is square:

\[ \mathcal{R}(s)\in\mathbb{C}^{(n+p)\times(n+m)} = \mathbb{C}^{(n+m)\times(n+m)}. \]

In this case, finite invariant zeros can be computed as generalized eigenvalues of a matrix pencil. Write

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

Define

\[ \mathbf{E}= \begin{bmatrix} \mathbf{I} & \mathbf{0}\\ \mathbf{0} & \mathbf{0} \end{bmatrix}, \qquad \mathbf{M}= \begin{bmatrix} \mathbf{A} & \mathbf{B}\\ -\mathbf{C} & -\mathbf{D} \end{bmatrix}. \]

Then

\[ \mathcal{R}(s)=s\mathbf{E}-\mathbf{M}. \]

Therefore, the zeros are the finite generalized eigenvalues satisfying

\[ \mathbf{M}\mathbf{v}=z\mathbf{E}\mathbf{v}, \qquad \mathbf{v}\neq\mathbf{0}. \]

Since \( \mathbf{E} \) is singular, this pencil usually also has infinite eigenvalues. The finite generalized eigenvalues are the finite invariant zeros.

flowchart TD
  A["Input: square system with p = m"] --> B["Form E = blockdiag(I, 0)"]
  A --> C["Form M = [A B; -C -D]"]
  B --> D["Solve generalized eigenproblem M v = z E v"]
  C --> D
  D --> E["Discard infinite eigenvalues"]
  E --> F["Remaining finite values are invariant zeros"]
        

For square systems and values of \( s \) that are not eigenvalues of \( \mathbf{A} \), the determinant of the Rosenbrock matrix can be factorized using the Schur complement:

\[ \det \begin{bmatrix} s\mathbf{I}-\mathbf{A} & -\mathbf{B}\\ \mathbf{C} & \mathbf{D} \end{bmatrix} = \det(s\mathbf{I}-\mathbf{A}) \det\!\left( \mathbf{D} + \mathbf{C}(s\mathbf{I}-\mathbf{A})^{-1}\mathbf{B} \right). \]

Since

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

we obtain

\[ \det\mathcal{R}(s) = \det(s\mathbf{I}-\mathbf{A})\det\mathbf{G}(s). \]

Hence, away from poles, zeros of \( \det\mathbf{G}(s) \) correspond to rank loss in the Rosenbrock matrix. This explains why the Rosenbrock method generalizes the SISO numerator-root method.

If the realization is minimal, pole-zero cancellations due to uncontrollable or unobservable internal modes are absent. If the realization is nonminimal, apparent numerator cancellations may not represent true invariant zeros of the minimal input-output behavior.

If the system is square and \( \mathbf{D} \) is nonsingular, the zeros can be computed without a singular pencil. Applying the Schur complement with respect to \( \mathbf{D} \) gives

\[ \det\mathcal{R}(s) = \det(\mathbf{D}) \det\!\left( s\mathbf{I}-\mathbf{A}+\mathbf{B}\mathbf{D}^{-1}\mathbf{C} \right). \]

Therefore, finite zeros are eigenvalues of

\[ \mathbf{A}_z = \mathbf{A}-\mathbf{B}\mathbf{D}^{-1}\mathbf{C}. \]

This formula is computationally attractive but limited. It cannot be used when \( \mathbf{D} \) is singular, and many strictly proper systems have \( \mathbf{D}=\mathbf{0} \).

If \( p\neq m \), the Rosenbrock matrix is rectangular. In that case, zeros are still defined by normal-rank loss:

\[ z \text{ is a zero} \quad\Longleftrightarrow\quad \operatorname{rank}\mathcal{R}(z)< \rho, \qquad \rho=\operatorname{normalrank}\mathcal{R}(s). \]

However, zeros are no longer obtained simply as eigenvalues of a square determinant. Numerically reliable computation uses staircase algorithms, Kronecker canonical forms, or specialized routines such as tzero in MATLAB or robust state-space routines in SLICOT.

A practical numerical procedure is:

\[ \mathcal{R}(s) = \begin{bmatrix} s\mathbf{I}-\mathbf{A} & -\mathbf{B}\\ \mathbf{C} & \mathbf{D} \end{bmatrix}, \qquad \rho=\max_{s\in\Omega} \operatorname{rank}\mathcal{R}(s), \]

followed by locating values where the smallest relevant singular values drop sharply. For serious computations, however, direct root-searching on singular values is less reliable than pencil reduction methods.

Zero computation is more delicate than pole computation. Poles are eigenvalues of \( \mathbf{A} \), whereas zeros depend on the joint geometry of \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \). Small perturbations in any of these matrices may move zeros substantially, especially if the Rosenbrock matrix is nearly rank deficient over a region of the complex plane.

Important numerical issues include:

• scaling of state, input, and output variables;
• near pole-zero cancellations in nonminimal realizations;
• distinguishing finite zeros from infinite zeros in singular pencils;
• detecting rank with singular-value thresholds;
• handling rectangular MIMO systems with staircase algorithms.

A common singular-value rank estimate is

\[ \operatorname{rank}_{\epsilon}(\mathbf{M}) = \#\left\{ \sigma_i(\mathbf{M}) : \sigma_i(\mathbf{M}) > \epsilon\max(n_r,n_c)\sigma_1(\mathbf{M}) \right\}, \]

where \( n_r \) and \( n_c \) are row and column dimensions. The tolerance \( \epsilon \) should reflect both machine precision and model uncertainty.

The following code uses NumPy and SciPy. For a square system, it forms the Rosenbrock pencil and extracts finite generalized eigenvalues.

Chapter21_Lesson2.py

import numpy as np
from scipy.linalg import eig, svdvals

def rosenbrock_pencil(A, B, C, D):
    A = np.asarray(A, dtype=float)
    B = np.asarray(B, dtype=float)
    C = np.asarray(C, dtype=float)
    D = np.asarray(D, dtype=float)

    n = A.shape[0]
    p, m = D.shape

    E = np.block([
        [np.eye(n), np.zeros((n, m))],
        [np.zeros((p, n)), np.zeros((p, m))]
    ])

    M = np.block([
        [A, B],
        [-C, -D]
    ])

    return M, E

def finite_invariant_zeros_square(A, B, C, D):
    p, m = np.asarray(D).shape
    if p != m:
        raise ValueError("This implementation requires a square system: p == m.")

    M, E = rosenbrock_pencil(A, B, C, D)
    vals = eig(M, E, right=False)

    finite_zeros = []
    for z in vals:
        if np.isfinite(z.real) and np.isfinite(z.imag):
            finite_zeros.append(z)

    return np.array(finite_zeros, dtype=complex)

def rank_rosenbrock_at(A, B, C, D, s, tol=1e-9):
    A = np.asarray(A, dtype=float)
    B = np.asarray(B, dtype=float)
    C = np.asarray(C, dtype=float)
    D = np.asarray(D, dtype=float)

    n = A.shape[0]
    R = np.block([
        [s*np.eye(n) - A, -B],
        [C, D]
    ]).astype(complex)

    sigma = svdvals(R)
    return np.sum(sigma > tol * max(R.shape) * sigma[0])

if __name__ == "__main__":
    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]])

    zeros = finite_invariant_zeros_square(A, B, C, D)
    print("Finite invariant zeros:", zeros)

    for s in [-4.0, -2.0, -1.0, 0.0]:
        print(f"rank R({s}) =", rank_rosenbrock_at(A, B, C, D, s))
      

In C++, the Eigen library can solve generalized eigenvalue problems. The following example assumes a square system.

Chapter21_Lesson2.cpp

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

using Eigen::MatrixXd;
using Eigen::VectorXcd;
using std::complex;

struct Pencil {
    MatrixXd M;
    MatrixXd E;
};

Pencil rosenbrockPencil(const MatrixXd& A,
                        const MatrixXd& B,
                        const MatrixXd& C,
                        const MatrixXd& D) {
    int n = A.rows();
    int p = C.rows();
    int m = B.cols();

    MatrixXd E = MatrixXd::Zero(n + p, n + m);
    E.block(0, 0, n, n) = MatrixXd::Identity(n, n);

    MatrixXd M(n + p, n + m);
    M.block(0, 0, n, n) = A;
    M.block(0, n, n, m) = B;
    M.block(n, 0, p, n) = -C;
    M.block(n, n, p, m) = -D;

    return {M, E};
}

std::vector<complex<double>> finiteInvariantZerosSquare(
    const MatrixXd& A,
    const MatrixXd& B,
    const MatrixXd& C,
    const MatrixXd& D) {

    if (D.rows() != D.cols()) {
        throw std::runtime_error("Square system required: p == m.");
    }

    Pencil P = rosenbrockPencil(A, B, C, D);
    Eigen::GeneralizedEigenSolver<MatrixXd> ges(P.M, P.E);
    VectorXcd vals = ges.eigenvalues();

    std::vector<complex<double>> zeros;
    for (int i = 0; i < vals.size(); ++i) {
        if (std::isfinite(vals(i).real()) &&
            std::isfinite(vals(i).imag())) {
            zeros.push_back(vals(i));
        }
    }

    return zeros;
}

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

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

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

    MatrixXd D = MatrixXd::Zero(1, 1);

    auto zeros = finiteInvariantZerosSquare(A, B, C, D);

    std::cout << "Finite invariant zeros:" << std::endl;
    for (const auto& z : zeros) {
        std::cout << z << std::endl;
    }

    return 0;
}
      

Java does not provide built-in generalized eigenvalue routines in the standard library. For teaching and engineering use, EJML is convenient. The following code demonstrates the important nonsingular \( \mathbf{D} \) case:

\[ \mathbf{A}_z=\mathbf{A}-\mathbf{B}\mathbf{D}^{-1}\mathbf{C}. \]

Chapter21_Lesson2.java

import org.ejml.simple.SimpleEVD;
import org.ejml.simple.SimpleMatrix;
import org.ejml.data.Complex_F64;

public class Chapter21_Lesson2 {
    public static SimpleMatrix zeroMatrixWhenDInvertible(
            SimpleMatrix A,
            SimpleMatrix B,
            SimpleMatrix C,
            SimpleMatrix D) {

        if (D.numRows() != D.numCols()) {
            throw new IllegalArgumentException("D must be square.");
        }

        return A.minus(B.mult(D.invert()).mult(C));
    }

    public static void main(String[] args) {
        SimpleMatrix A = new SimpleMatrix(new double[][]{
            {0.0, 1.0},
            {-2.0, -3.0}
        });

        SimpleMatrix B = new SimpleMatrix(new double[][]{
            {0.0},
            {1.0}
        });

        SimpleMatrix C = new SimpleMatrix(new double[][]{
            {4.0, 1.0}
        });

        SimpleMatrix D = new SimpleMatrix(new double[][]{
            {1.0}
        });

        SimpleMatrix Az = zeroMatrixWhenDInvertible(A, B, C, D);
        SimpleEVD<SimpleMatrix> evd = Az.eig();

        System.out.println("A_z = A - B D^{-1} C:");
        Az.print();

        System.out.println("Transmission zeros:");
        for (int i = 0; i < evd.getNumberOfEigenvalues(); i++) {
            Complex_F64 lambda = evd.getEigenvalue(i);
            System.out.println(lambda);
        }
    }
}
      

MATLAB provides the built-in command tzero for transmission-zero computation. The generalized-eigenvalue method can also be implemented directly.

Chapter21_Lesson2.m

clear; clc;

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

sys = ss(A, B, C, D);

zeros_builtin = tzero(sys);
disp('Transmission zeros from tzero:');
disp(zeros_builtin);

[n, ~] = size(A);
[p, m] = size(D);

E = [eye(n), zeros(n, m);
     zeros(p, n), zeros(p, m)];

M = [A, B;
     -C, -D];

all_gen_eigs = eig(M, E);
finite_zeros = all_gen_eigs(isfinite(all_gen_eigs));

disp('Finite generalized eigenvalues of Rosenbrock pencil:');
disp(finite_zeros);

D2 = 1;
Az = A - B * (D2 \ C);

disp('Zeros for nonsingular D from eig(A - B*D^{-1}*C):');
disp(eig(Az));

if license('test', 'Simulink')
    model = 'Chapter21_Lesson2_Simulink_Zero_Computation';

    if bdIsLoaded(model)
        close_system(model, 0);
    end

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

    set_param([model '/State-Space'], ...
        'A', mat2str(A), ...
        'B', mat2str(B), ...
        'C', mat2str(C), ...
        'D', mat2str(D));

    add_line(model, 'Step/1', 'State-Space/1');
    add_line(model, 'State-Space/1', 'Scope/1');

    save_system(model);
    disp(['Created Simulink model: ' model '.slx']);
end
      

Mathematica can compute zeros through transfer-function conversion and through generalized eigenvalues of the Rosenbrock pencil.

Chapter21_Lesson2.nb

ClearAll["Global`*"]

A = { {0, 1}, {-2, -3} };
B = { {0}, {1} };
Cmat = { {4, 1} };
Dmat = { {0} };

sys = StateSpaceModel[{A, B, Cmat, Dmat}];
tf = TransferFunctionModel[sys, s];

TransferFunctionZeros[tf]

n = Length[A];
m = Dimensions[B][[2]];
p = Dimensions[Cmat][[1]];

Epen = ArrayFlatten[{
   {IdentityMatrix[n], ConstantArray[0, {n, m}]},
   {ConstantArray[0, {p, n}], ConstantArray[0, {p, m}]}
}];

Mpen = ArrayFlatten[{
   {A, B},
   {-Cmat, -Dmat}
}];

allGeneralizedEigenvalues = Eigenvalues[{Mpen, Epen}];

finiteZeros = Select[
   allGeneralizedEigenvalues,
   NumberQ[N[#]] && Abs[N[#]] < 10^12 &
];

finiteZeros

D2 = { {1} };
Az = A - B . Inverse[D2] . Cmat;
Eigenvalues[Az]
      

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 zero is

\[ z=-4. \]

The Rosenbrock matrix is

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

Its determinant is

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

Therefore, \( \mathcal{R}(s) \) loses rank at \( s=-4 \), confirming the zero obtained from the transfer function.

Problem 1: For the SISO realization \( A=\begin{bmatrix}0&1\\-6&-5\end{bmatrix} \), \( B=\begin{bmatrix}0\\1\end{bmatrix} \), \( C=\begin{bmatrix}2&1\end{bmatrix} \), \( D=0 \) , compute the transmission zero.

Solution:

\[ G(s)=C(sI-A)^{-1}B = \frac{s+2}{s^2+5s+6}. \]

Therefore the zero is

\[ z=-2. \]

Notice that \( -2 \) is also a pole of the unreduced transfer expression. If the realization is nonminimal, this indicates that controllability or observability should be checked before interpreting the input-output cancellation.

Problem 2: Show that if \( D \) is nonsingular in a square system, the zeros are eigenvalues of \( A-BD^{-1}C \).

Solution:

Starting from the Rosenbrock determinant and taking the Schur complement with respect to \( D \),

\[ \det \begin{bmatrix} sI-A & -B\\ C & D \end{bmatrix} = \det(D) \det\left(sI-A+BD^{-1}C\right). \]

Since \( \det(D)\neq 0 \), zeros satisfy

\[ \det\left(sI-(A-BD^{-1}C)\right)=0. \]

Hence zeros are eigenvalues of \( A-BD^{-1}C \).

Problem 3: Explain why generalized eigenvalue computation of \( Mv=zEv \) may produce infinite eigenvalues.

Solution:

The matrix \( E=\begin{bmatrix}I&0\\0&0\end{bmatrix} \) is singular. In a generalized eigenvalue problem, directions in the nullspace of \( E \) may correspond to eigenvalues at infinity. These infinite eigenvalues are associated with algebraic constraints and relative-degree structure, not finite transmission zeros. Therefore, finite zeros are obtained after discarding infinite generalized eigenvalues.

Problem 4: Let \( R(z) \) denote the Rosenbrock matrix. Why is a small singular value of \( R(z) \) evidence of a zero near \( z \)?

Solution:

If \( z \) is exactly a zero, then \( R(z) \) loses rank, so at least one singular value is exactly zero:

\[ \sigma_{\min}(R(z))=0. \]

In floating-point computation or uncertain models, rank loss is rarely exact. A very small singular value indicates that the matrix is close to rank deficient, suggesting a nearby zero or a poorly conditioned zero-direction.

Problem 5: Why is zero computation more difficult for rectangular MIMO systems than for square systems?

Solution:

For square systems, zeros can often be found from a determinant or a square generalized eigenvalue pencil. For rectangular systems, the Rosenbrock matrix is rectangular, so determinant-based computation is unavailable. The correct definition is normal-rank loss:

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

Detecting this condition reliably requires staircase or Kronecker-form algorithms rather than simple polynomial root finding.

Transmission zeros can be computed directly from the state-space realization using the Rosenbrock system matrix. For square systems, finite zeros are generalized eigenvalues of the pencil \( sE-M \). If \( D \) is nonsingular, they reduce to eigenvalues of \( A-BD^{-1}C \). For rectangular systems and singular feedthrough cases, robust numerical algorithms based on staircase or Kronecker decompositions are preferred.

This computational machinery prepares us for Lesson 3, where the same zero directions will be used to define zero dynamics and explain internal behavior under output-constrained motion.