In classical single-input single-output control, a stable transfer function is called minimum-phase when all of its finite zeros are stable. In continuous time, this means every finite zero lies in the open left-half complex plane. In state-space language, the same idea is deeper: it says that the internal motion compatible with the constraint \( y(t)=0 \) is itself stable.

Consider the continuous-time LTI system \( \dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \), \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \). Its Rosenbrock system matrix is

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

A complex number \( z \) is a transmission zero if \( \mathbf{P}(z) \) loses normal rank:

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

Equivalently, for some nonzero pair \( (\mathbf{x}_z,\mathbf{u}_z) \),

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

This means that the system can support a nontrivial exponential internal trajectory \( \mathbf{x}(t)=e^{zt}\mathbf{x}_z \) and input \( \mathbf{u}(t)=e^{zt}\mathbf{u}_z \) while the output remains exactly zero:

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

flowchart TD
  A["Start with state-space model A, B, C, D"] --> B["Build Rosenbrock matrix P(s)"]
  B --> C["Find values z where rank P(z) drops"]
  C --> D["Transmission zeros"]
  D --> E["Check zero locations"]
  E --> F["All zeros have Re(z) negative"]
  E --> G["Some zero has Re(z) positive or \nzero lies on imaginary axis"]
  F --> H["Minimum-phase in continuous time"]
  G --> I["Non-minimum-phase or borderline case"]
  D --> J["Interpret as zero-output internal motion"]
        

For a minimal continuous-time LTI realization, the finite transmission zeros are input-output invariants. They do not depend on the particular state coordinates used to realize the system.

A minimal continuous-time LTI system is called minimum-phase if every finite transmission zero satisfies

\[ \operatorname{Re}(z_i)<0,\qquad i=1,\dots,n_z. \]

It is called non-minimum-phase if at least one finite transmission zero satisfies

\[ \operatorname{Re}(z_i)>0. \]

A zero on the imaginary axis is not strictly minimum-phase. It is often called a borderline, critical, or weakly non-minimum-phase case because the zero dynamics are not asymptotically stable:

\[ \operatorname{Re}(z_i)=0 \quad \Longrightarrow \quad \text{zero dynamics are not asymptotically stable}. \]

In discrete time, the analogous condition is that every finite transmission zero lies strictly inside the unit disk:

\[ |z_i|<1. \]

Thus the continuous-time and discrete-time definitions are parallel:

\[ \begin{array}{c|c} \text{continuous time} & \operatorname{Re}(z_i)<0\\ \text{discrete time} & |z_i|<1 \end{array} \]

In SISO frequency-domain theory, among transfer functions with the same magnitude response, the one whose zeros are all stable has the least phase lag. For a stable proper transfer function

\[ G(s)=k \frac{\prod_{i=1}^{m}(s-z_i)} {\prod_{j=1}^{n}(s-p_j)}, \]

reflecting a stable left-half-plane zero across the imaginary axis preserves magnitude on the imaginary axis:

\[ |j\omega-a|=|j\omega+a|, \qquad a>0. \]

However, the phase is changed. A right-half-plane zero contributes extra phase lag. Therefore two systems may have identical gain magnitudes but different phase behavior. The system with no right-half-plane zeros has minimum phase lag.

In modern control, the stronger state-space interpretation is more important: a right-half-plane zero means there exists a hidden zero-output motion that grows exponentially while the measured output is held at zero. This hidden motion is what makes exact stable inversion impossible.

To see the state-space mechanism explicitly, consider a SISO system with \( D=0 \):

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

Assume relative degree one, so \( \mathbf{C}\mathbf{B}\neq 0 \). The zero-output constraint is

\[ y=0 \quad \Longleftrightarrow \quad \mathbf{C}\mathbf{x}=0. \]

Therefore the zero-output state must lie in \( \ker \mathbf{C} \). Let the columns of \( \mathbf{N} \) form a basis for \( \ker \mathbf{C} \), so \( \mathbf{x}=\mathbf{N}\boldsymbol{\eta} \). To keep the output zero, we also require \( \dot{y}=0 \):

\[ \dot{y} =\mathbf{C}\dot{\mathbf{x} } =\mathbf{C}\mathbf{A}\mathbf{x} +\mathbf{C}\mathbf{B}u=0. \]

Because \( \mathbf{C}\mathbf{B}\neq 0 \), the input needed to enforce zero output is

\[ u=-(\mathbf{C}\mathbf{B})^{-1} \mathbf{C}\mathbf{A}\mathbf{x} =-(\mathbf{C}\mathbf{B})^{-1} \mathbf{C}\mathbf{A}\mathbf{N}\boldsymbol{\eta}. \]

Substitute this input into the state equation:

\[ \dot{\mathbf{x} } = \left[ \mathbf{I} -\mathbf{B}(\mathbf{C}\mathbf{B})^{-1}\mathbf{C} \right] \mathbf{A}\mathbf{N}\boldsymbol{\eta}. \]

If \( \mathbf{L}\mathbf{N}=\mathbf{I} \), then the reduced zero-dynamics matrix is

\[ \dot{\boldsymbol{\eta} } = \mathbf{A}_0\boldsymbol{\eta}, \qquad \mathbf{A}_0 = \mathbf{L} \left[ \mathbf{I} -\mathbf{B}(\mathbf{C}\mathbf{B})^{-1}\mathbf{C} \right] \mathbf{A}\mathbf{N}. \]

For a minimal SISO system under this relative-degree-one construction, the eigenvalues of \( \mathbf{A}_0 \) coincide with the finite transmission zeros.

flowchart TD
  A["Impose y = C x = 0"] --> B["State lies in null space of C"]
  B --> C["Write x = N eta"]
  C --> D["Differentiate output: ydot = C A x + C B u"]
  D --> E["Choose u to keep ydot = 0"]
  E --> F["Substitute constrained u into state equation"]
  F --> G["Reduced internal dynamics: etadot = A0 eta"]
  G --> H["Eigenvalues of A0 are transmission zeros"]
        

Theorem: For a minimal continuous-time SISO LTI system whose zero dynamics are well-defined, the system is minimum-phase if and only if its zero dynamics are asymptotically stable.

\[ \text{minimum-phase} \quad \Longleftrightarrow \quad \sigma(\mathbf{A}_0)\subset \{s\in\mathbb{C}: \operatorname{Re}(s)<0\}. \]

Proof idea: The zero-dynamics state \( \boldsymbol{\eta} \) evolves according to \( \dot{\boldsymbol{\eta} }=\mathbf{A}_0\boldsymbol{\eta} \). Its modal solutions have the form

\[ \boldsymbol{\eta}(t)= \sum_i \alpha_i e^{\lambda_i(\mathbf{A}_0)t}\mathbf{v}_i \]

when \( \mathbf{A}_0 \) is diagonalizable. Jordan blocks add polynomial factors but do not change the exponential growth rate. Therefore the zero dynamics are asymptotically stable exactly when

\[ \operatorname{Re}\lambda_i(\mathbf{A}_0)<0 \quad \text{for all } i. \]

Since the eigenvalues of \( \mathbf{A}_0 \) are the finite transmission zeros, the zero dynamics are asymptotically stable exactly when all finite transmission zeros are in the open left-half plane. This is precisely the continuous-time minimum-phase condition.

Consider the stable state matrix \( \mathbf{A}=\begin{bmatrix}0&1\\-6&-5\end{bmatrix} \) and input matrix \( \mathbf{B}=\begin{bmatrix}0\\1\end{bmatrix} \). The poles are

\[ \det(s\mathbf{I}-\mathbf{A}) =s^2+5s+6=(s+2)(s+3). \]

First choose \( \mathbf{C}_1=\begin{bmatrix}1&1\end{bmatrix} \). Then

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

The finite zero is \( z=-1 \), so the system is minimum-phase.

Now choose \( \mathbf{C}_2=\begin{bmatrix}1&-1\end{bmatrix} \). Then

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

The finite zero is \( z=1 \). The state matrix is still internally stable, but the system is non-minimum-phase because the zero-output internal motion has unstable growth rate.

\[ \begin{array}{c|c|c|c} \text{system} & \text{poles} & \text{zero} & \text{classification}\\ \hline G_1(s) & -2,\,-3 & -1 & \text{minimum-phase}\\ G_2(s) & -2,\,-3 & 1 & \text{non-minimum-phase} \end{array} \]

Minimum-phase behavior is directly related to stable inversion. For a square transfer matrix \( \mathbf{G}(s) \), zeros of \( \mathbf{G}(s) \) become poles of a formal inverse \( \mathbf{G}(s)^{-1} \). In the SISO case,

\[ G(s)=\frac{N(s)}{D(s)} \quad \Longrightarrow \quad G(s)^{-1}=\frac{D(s)}{N(s)}. \]

Therefore, if \( N(s) \) has a right-half-plane zero, then \( G(s)^{-1} \) has a right-half-plane pole. Exact causal stable inversion is impossible.

\[ z\in\mathbb{C},\quad \operatorname{Re}(z)>0,\quad N(z)=0 \quad \Longrightarrow \quad G(s)^{-1}\text{ has an unstable pole at }s=z. \]

This is why non-minimum-phase plants commonly show inverse response: the output initially moves in the direction opposite to its final steady motion. The issue is not merely poor tuning. It is encoded in the plant's zero structure.

For MIMO systems, zeros cannot generally be read from scalar numerator polynomials. Instead, the Rosenbrock rank condition is essential:

\[ z\text{ is a transmission zero} \quad \Longleftrightarrow \quad \operatorname{rank} \begin{bmatrix} z\mathbf{I}-\mathbf{A} & -\mathbf{B}\\ \mathbf{C} & \mathbf{D} \end{bmatrix} < \operatorname{normalrank}\mathbf{P}(s). \]

For square MIMO systems with a nonsingular transfer matrix \( \mathbf{G}(s) \), finite zeros also appear where \( \det\mathbf{G}(s)=0 \), after canceling pole-zero artifacts caused by nonminimal descriptions. However, the Rosenbrock definition is more fundamental because it remains valid for nonsquare systems.

Continuous-time MIMO minimum-phase behavior is commonly defined by requiring all invariant or transmission zeros to lie in the open left-half plane:

\[ \operatorname{Re}(z_i)<0 \quad \text{for every finite invariant zero } z_i. \]

The following Python script computes SISO transmission zeros from state-space data, classifies the continuous-time system, and constructs the relative-degree-one zero-dynamics matrix.

Chapter21_Lesson4.py

"""
Chapter21_Lesson4.py
Minimum-phase vs non-minimum-phase systems in state-space.

This script computes transmission zeros from a SISO state-space model,
classifies the system, and constructs the relative-degree-one zero dynamics.
Dependencies: numpy, scipy.
"""

import numpy as np
from numpy.linalg import eigvals
from scipy.signal import ss2tf, StateSpace, step
from scipy.linalg import null_space


def siso_zeros_from_state_space(A, B, C, D, tol=1e-9):
    """Return finite zeros of a SISO state-space model using ss2tf."""
    A = np.asarray(A, dtype=float)
    B = np.asarray(B, dtype=float)
    C = np.asarray(C, dtype=float)
    D = np.asarray(D, dtype=float)

    num, den = ss2tf(A, B, C, D)
    num = np.trim_zeros(num[0], trim="f")
    if len(num) == 0:
        return np.array([]), num, den

    while len(num) > 1 and abs(num[0]) < tol:
        num = num[1:]
    zeros = np.roots(num) if len(num) > 1 else np.array([])
    return zeros, num, den


def classify_continuous_time(zeros, tol=1e-8):
    """Classify continuous-time finite zeros by real part."""
    zeros = np.asarray(zeros, dtype=complex)
    if zeros.size == 0:
        return "minimum-phase (no finite transmission zeros)"
    if np.any(np.real(zeros) > tol):
        return "non-minimum-phase (at least one right-half-plane zero)"
    if np.any(np.abs(np.real(zeros)) <= tol):
        return "borderline non-minimum-phase (zero on imaginary axis)"
    return "minimum-phase (all finite zeros in the open left-half-plane)"


def zero_dynamics_rd1(A, B, C, tol=1e-10):
    """
    Relative-degree-one SISO zero dynamics for D=0 and C B != 0.

    y = C x = 0, so x = N z with columns of N spanning ker(C).
    Enforce dot(y) = C A x + C B u = 0, hence
    u = -(C B)^(-1) C A N z.
    Then dot(z) = L (I - B(CB)^(-1)C) A N z, where L N = I.
    """
    A = np.asarray(A, dtype=float)
    B = np.asarray(B, dtype=float)
    C = np.asarray(C, dtype=float)

    CB = C @ B
    if abs(CB.item()) < tol:
        raise ValueError("This formula requires relative degree one: C B must be nonzero.")

    N = null_space(C)
    L = N.T
    projection = np.eye(A.shape[0]) - B @ np.linalg.inv(CB) @ C
    A0 = L @ projection @ A @ N
    return A0, eigvals(A0), N


def print_analysis(name, A, B, C, D):
    print("\n" + "=" * 72)
    print(name)
    print("A eigenvalues (poles):", eigvals(A))
    zeros, num, den = siso_zeros_from_state_space(A, B, C, D)
    print("Transfer numerator coefficients:", num)
    print("Transfer denominator coefficients:", den)
    print("Transmission zeros:", zeros)
    print("Classification:", classify_continuous_time(zeros))

    if abs(float(D)) < 1e-12:
        try:
            A0, zd_eigs, _ = zero_dynamics_rd1(A, B, C)
            print("Zero-dynamics matrix A0:\n", A0)
            print("Zero-dynamics eigenvalues:", zd_eigs)
        except ValueError as exc:
            print("Zero-dynamics rd=1 construction skipped:", exc)


def main():
    A_min = np.array([[0.0, 1.0], [-6.0, -5.0]])
    B_min = np.array([[0.0], [1.0]])
    C_min = np.array([[1.0, 1.0]])
    D_min = np.array([[0.0]])

    A_nmp = np.array([[0.0, 1.0], [-6.0, -5.0]])
    B_nmp = np.array([[0.0], [1.0]])
    C_nmp = np.array([[1.0, -1.0]])
    D_nmp = np.array([[0.0]])

    print_analysis("Minimum-phase example", A_min, B_min, C_min, D_min)
    print_analysis("Non-minimum-phase example", A_nmp, B_nmp, C_nmp, D_nmp)

    t = np.linspace(0.0, 8.0, 300)
    _, y_min = step(StateSpace(A_min, B_min, C_min, D_min), T=t)
    _, y_nmp = step(StateSpace(A_nmp, B_nmp, C_nmp, D_nmp), T=t)
    print("\nFirst five step samples for minimum-phase plant:", y_min[:5])
    print("First five step samples for non-minimum-phase plant:", y_nmp[:5])
    print("The NMP response initially moves in the opposite direction because of the RHP zero.")


if __name__ == "__main__":
    main()
      

The C++ and Java examples implement the two-state SISO numerator directly from the state-space matrices. For a two-state system,

\[ q(s)=\mathbf{C}\operatorname{adj}(s\mathbf{I}-\mathbf{A})\mathbf{B} +D\det(s\mathbf{I}-\mathbf{A}). \]

Chapter21_Lesson4.cpp

/*
Chapter21_Lesson4.cpp
Scratch 2-state SISO transmission-zero classifier.

Compile:
  g++ -std=c++17 Chapter21_Lesson4.cpp -o Chapter21_Lesson4
*/

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

struct StateSpace2 {
    double a11, a12, a21, a22;
    double b1, b2;
    double c1, c2;
    double d;
};

std::vector<std::complex<double>> roots_quadratic_or_linear(double q2, double q1, double q0) {
    const double eps = 1e-12;
    std::vector<std::complex<double>> roots;
    if (std::abs(q2) < eps) {
        if (std::abs(q1) >= eps) {
            roots.push_back(std::complex<double>(-q0 / q1, 0.0));
        }
        return roots;
    }
    std::complex<double> disc(q1 * q1 - 4.0 * q2 * q0, 0.0);
    std::complex<double> sqrt_disc = std::sqrt(disc);
    roots.push_back((-q1 + sqrt_disc) / (2.0 * q2));
    roots.push_back((-q1 - sqrt_disc) / (2.0 * q2));
    return roots;
}

std::vector<std::complex<double>> transmission_zeros_2state(const StateSpace2& s) {
    double q2 = s.d;
    double q1 = s.c1 * s.b1 + s.c2 * s.b2 - s.d * (s.a11 + s.a22);
    double q0 = s.c1 * (-s.a22 * s.b1 + s.a12 * s.b2)
              + s.c2 * ( s.a21 * s.b1 - s.a11 * s.b2)
              + s.d * (s.a11 * s.a22 - s.a12 * s.a21);
    return roots_quadratic_or_linear(q2, q1, q0);
}

std::string classify_ct(const std::vector<std::complex<double>>& zeros) {
    const double tol = 1e-9;
    if (zeros.empty()) return "minimum-phase: no finite zeros detected";
    bool rhp = false;
    bool axis = false;
    for (const auto& z : zeros) {
        if (z.real() > tol) rhp = true;
        if (std::abs(z.real()) <= tol) axis = true;
    }
    if (rhp) return "non-minimum-phase: right-half-plane zero exists";
    if (axis) return "borderline non-minimum-phase: imaginary-axis zero exists";
    return "minimum-phase: all finite zeros are in the open left-half-plane";
}

void analyze(const std::string& name, const StateSpace2& sys) {
    auto zeros = transmission_zeros_2state(sys);
    std::cout << "\n" << name << "\n";
    std::cout << "Transmission zeros: ";
    if (zeros.empty()) std::cout << "none";
    for (const auto& z : zeros) std::cout << z << " ";
    std::cout << "\n" << classify_ct(zeros) << "\n";
}

int main() {
    StateSpace2 minphase {0.0, 1.0, -6.0, -5.0, 0.0, 1.0, 1.0, 1.0, 0.0};
    StateSpace2 nonmin  {0.0, 1.0, -6.0, -5.0, 0.0, 1.0, 1.0,-1.0, 0.0};

    analyze("Minimum-phase example: G(s)=(s+1)/((s+2)(s+3))", minphase);
    analyze("Non-minimum-phase example: G(s)=(-s+1)/((s+2)(s+3))", nonmin);
    return 0;
}
      

Chapter21_Lesson4.java

/*
Chapter21_Lesson4.java
Scratch 2-state SISO transmission-zero classifier.

Compile and run:
  javac Chapter21_Lesson4.java
  java Chapter21_Lesson4
*/

public class Chapter21_Lesson4 {
    static class Complex {
        final double re;
        final double im;
        Complex(double re, double im) { this.re = re; this.im = im; }
        public String toString() {
            if (Math.abs(im) < 1e-12) return String.format("%.6f", re);
            return String.format("%.6f%+.6fi", re, im);
        }
    }

    static class StateSpace2 {
        double a11, a12, a21, a22, b1, b2, c1, c2, d;
        StateSpace2(double a11, double a12, double a21, double a22,
                    double b1, double b2, double c1, double c2, double d) {
            this.a11 = a11; this.a12 = a12; this.a21 = a21; this.a22 = a22;
            this.b1 = b1; this.b2 = b2; this.c1 = c1; this.c2 = c2; this.d = d;
        }
    }

    static Complex[] rootsQuadraticOrLinear(double q2, double q1, double q0) {
        double eps = 1e-12;
        if (Math.abs(q2) < eps) {
            if (Math.abs(q1) < eps) return new Complex[]{};
            return new Complex[]{ new Complex(-q0 / q1, 0.0) };
        }
        double disc = q1 * q1 - 4.0 * q2 * q0;
        if (disc >= 0.0) {
            double sd = Math.sqrt(disc);
            return new Complex[]{ new Complex((-q1 + sd) / (2.0 * q2), 0.0),
                                  new Complex((-q1 - sd) / (2.0 * q2), 0.0) };
        }
        double sd = Math.sqrt(-disc);
        return new Complex[]{ new Complex(-q1 / (2.0 * q2),  sd / (2.0 * q2)),
                              new Complex(-q1 / (2.0 * q2), -sd / (2.0 * q2)) };
    }

    static Complex[] transmissionZeros2State(StateSpace2 s) {
        double q2 = s.d;
        double q1 = s.c1 * s.b1 + s.c2 * s.b2 - s.d * (s.a11 + s.a22);
        double q0 = s.c1 * (-s.a22 * s.b1 + s.a12 * s.b2)
                  + s.c2 * ( s.a21 * s.b1 - s.a11 * s.b2)
                  + s.d * (s.a11 * s.a22 - s.a12 * s.a21);
        return rootsQuadraticOrLinear(q2, q1, q0);
    }

    static String classifyCT(Complex[] zeros) {
        double tol = 1e-9;
        if (zeros.length == 0) return "minimum-phase: no finite zeros detected";
        boolean rhp = false;
        boolean axis = false;
        for (Complex z : zeros) {
            if (z.re > tol) rhp = true;
            if (Math.abs(z.re) <= tol) axis = true;
        }
        if (rhp) return "non-minimum-phase: right-half-plane zero exists";
        if (axis) return "borderline non-minimum-phase: imaginary-axis zero exists";
        return "minimum-phase: all finite zeros are in the open left-half-plane";
    }

    static void analyze(String name, StateSpace2 sys) {
        Complex[] zeros = transmissionZeros2State(sys);
        System.out.println("\n" + name);
        System.out.print("Transmission zeros: ");
        if (zeros.length == 0) System.out.print("none");
        for (Complex z : zeros) System.out.print(z + " ");
        System.out.println("\n" + classifyCT(zeros));
    }

    public static void main(String[] args) {
        StateSpace2 minphase = new StateSpace2(0.0, 1.0, -6.0, -5.0, 0.0, 1.0, 1.0, 1.0, 0.0);
        StateSpace2 nonmin   = new StateSpace2(0.0, 1.0, -6.0, -5.0, 0.0, 1.0, 1.0,-1.0, 0.0);

        analyze("Minimum-phase example: G(s)=(s+1)/((s+2)(s+3))", minphase);
        analyze("Non-minimum-phase example: G(s)=(-s+1)/((s+2)(s+3))", nonmin);
    }
}
      

Chapter21_Lesson4.m

% Chapter21_Lesson4.m
% Minimum-phase vs non-minimum-phase systems in state-space.
% Requires Control System Toolbox for ss, tf, tzero, zero, step.

clear; clc; close all;

A = [0 1; -6 -5];
B = [0; 1];
D = 0;

% G_min(s) = (s + 1)/((s + 2)(s + 3))
Cmin = [1 1];
sysMin = ss(A, B, Cmin, D);

% G_nmp(s) = (-s + 1)/((s + 2)(s + 3)); zero at +1, DC gain positive.
Cnmp = [1 -1];
sysNmp = ss(A, B, Cnmp, D);

analyzeSystem('Minimum-phase example', sysMin);
analyzeSystem('Non-minimum-phase example', sysNmp);

figure;
step(sysMin, sysNmp, 8);
grid on;
legend('minimum phase', 'non-minimum phase', 'Location', 'best');
title('Step responses: RHP zero creates inverse initial motion');

function analyzeSystem(name, sys)
    fprintf('\n%s\n', name);
    z = tzero(sys);
    p = pole(sys);
    disp('Poles:'); disp(p.');
    disp('Transmission zeros:'); disp(z.');

    tol = 1e-8;
    if isempty(z)
        disp('Classification: minimum-phase, no finite zeros detected');
    elseif any(real(z) > tol)
        disp('Classification: non-minimum-phase, right-half-plane zero exists');
    elseif any(abs(real(z)) <= tol)
        disp('Classification: borderline non-minimum-phase, imaginary-axis zero exists');
    else
        disp('Classification: minimum-phase, all finite zeros are in the open left-half-plane');
    end

    [num, den] = tfdata(tf(sys), 'v');
    fprintf('Transfer numerator: '); disp(num);
    fprintf('Transfer denominator: '); disp(den);
end
      

Simulink note:

In Simulink, use a State-Space block with the same A, B, C, and D matrices. Connect a Step block to the input and a Scope to the output. Run once with C=[1 1] and once with C=[1 -1]. The second system shows inverse response because its transmission zero is in the right-half plane.

Chapter21_Lesson4.nb

Notebook[{
Cell["Chapter21_Lesson4.nb", "Title"],
Cell["Minimum-phase vs non-minimum-phase systems in state-space. This notebook computes finite zeros, classifies continuous-time systems, and compares two state-space examples.", "Text"],
Cell[BoxData[ToBoxes[
ClearAll[s, classifyCT, A, B, Cmin, Cnmp, D, gmin, gnmp, zerosMin, zerosNmp];
A = { {0, 1}, {-6, -5} };
B = { {0}, {1} };
D = { {0} };
Cmin = { {1, 1} };
Cnmp = { {1, -1} };
gmin = Cmin . Inverse[s IdentityMatrix[2] - A] . B + D;
gnmp = Cnmp . Inverse[s IdentityMatrix[2] - A] . B + D;
zerosMin = s /. Solve[Numerator[Together[gmin[[1, 1]]]] == 0, s];
zerosNmp = s /. Solve[Numerator[Together[gnmp[[1, 1]]]] == 0, s];
classifyCT[z_List] := Which[
  Length[z] == 0, "minimum-phase: no finite zeros detected",
  Max[Re[N[z]]] > 10^-8, "non-minimum-phase: right-half-plane zero exists",
  Min[Abs[Re[N[z]]]] <= 10^-8, "borderline non-minimum-phase: imaginary-axis zero exists",
  True, "minimum-phase: all finite zeros are in the open left-half-plane"
];
{TraditionalForm[gmin[[1, 1]]], zerosMin, classifyCT[zerosMin],
 TraditionalForm[gnmp[[1, 1]]], zerosNmp, classifyCT[zerosNmp]}
]], "Input"],
Cell[BoxData[ToBoxes[
Rosenbrock = ArrayFlatten[{ {s IdentityMatrix[2] - A, -B}, {Cnmp, D} }];
{MatrixForm[Rosenbrock], Factor[Det[Rosenbrock]]}
]], "Input"],
Cell[BoxData[ToBoxes[
yMin = OutputResponse[TransferFunctionModel[gmin[[1, 1]], s], UnitStep[t], {t, 0, 8}];
yNmp = OutputResponse[TransferFunctionModel[gnmp[[1, 1]], s], UnitStep[t], {t, 0, 8}];
Plot[{yMin, yNmp}, {t, 0, 8}, PlotLegends -> {"minimum phase", "non-minimum phase"},
 PlotLabel -> "Step responses", AxesLabel -> {"t", "y(t)"}]
]], "Input"]
}]
      

Problem 1: For \( G(s)=\dfrac{s+4}{(s+1)(s+3)} \) , determine whether the system is minimum-phase.

Solution:

The only finite zero is \( z=-4 \). Since \( \operatorname{Re}(-4)<0 \), the system is minimum-phase. The poles are also stable, but minimum-phase classification depends on zeros, not poles.

Problem 2: For \( G(s)=\dfrac{-s+2}{(s+1)(s+5)} \) , determine whether the system is minimum-phase and explain the inversion implication.

Solution:

The zero satisfies \( -s+2=0 \), hence \( z=2 \). Since \( \operatorname{Re}(2)>0 \), the system is non-minimum-phase. Its inverse has a pole at \( s=2 \), so exact stable causal inversion is impossible.

Problem 3: Let \( \mathbf{A}=\begin{bmatrix}0&1\\-6&-5\end{bmatrix} \), \( \mathbf{B}=\begin{bmatrix}0\\1\end{bmatrix} \), \( \mathbf{C}=\begin{bmatrix}1&-1\end{bmatrix} \), and \( D=0 \). Compute the transfer function and classify the system.

Solution:

First,

\[ s\mathbf{I}-\mathbf{A} = \begin{bmatrix} s & -1\\ 6 & s+5 \end{bmatrix}, \qquad \det(s\mathbf{I}-\mathbf{A})=s^2+5s+6. \]

Its inverse is

\[ (s\mathbf{I}-\mathbf{A})^{-1} = \frac{1}{s^2+5s+6} \begin{bmatrix} s+5 & 1\\ -6 & s \end{bmatrix}. \]

Therefore,

\[ G(s) = \begin{bmatrix}1&-1\end{bmatrix} \frac{1}{s^2+5s+6} \begin{bmatrix} 1\\ s \end{bmatrix} = \frac{1-s}{s^2+5s+6}. \]

The zero is \( z=1 \), so the system is non-minimum-phase.

Problem 4: Explain why internal stability of \( \mathbf{A} \) does not imply minimum-phase behavior.

Solution:

Internal stability is a statement about the eigenvalues of \( \mathbf{A} \). Minimum-phase behavior is a statement about the transmission zeros, equivalently the eigenvalues of the zero-dynamics matrix. A system may have \( \operatorname{Re}\lambda_i(\mathbf{A})<0 \) for every pole while still having a right-half-plane zero. The example in Problem 3 has poles \( -2 \) and \( -3 \) but zero \( +1 \).

Problem 5: For a relative-degree-one SISO realization with \( D=0 \) and \( \mathbf{C}\mathbf{B}\neq 0 \), derive the input that keeps \( y=0 \).

Solution:

Since \( y=\mathbf{C}\mathbf{x}=0 \), zero output must remain zero:

\[ \dot{y} = \mathbf{C}\dot{\mathbf{x} } = \mathbf{C}\mathbf{A}\mathbf{x} + \mathbf{C}\mathbf{B}u = 0. \]

Because \( \mathbf{C}\mathbf{B}\neq 0 \), solve for \( u \):

\[ u=-(\mathbf{C}\mathbf{B})^{-1} \mathbf{C}\mathbf{A}\mathbf{x}. \]

This is the input that constrains the state trajectory to the zero-output manifold.

Minimum-phase behavior is not merely a frequency-domain label. In state-space theory, it means that the zero-output internal dynamics are asymptotically stable. Transmission zeros are values at which the Rosenbrock system matrix loses rank. For minimal continuous-time systems, stable finite zeros correspond to stable zero dynamics, while right-half-plane zeros correspond to unstable hidden internal motion.

A non-minimum-phase system may have stable poles and still be difficult to invert, track, or regulate aggressively. The limitation comes from the zero structure, not from poor controller design. This prepares the next lesson, where we study how zeros constrain achievable performance.