Previous lessons defined transmission zeros using the Rosenbrock system matrix and interpreted zero dynamics as internal motion compatible with zero output. The central message of this lesson is:

\[ \begin{aligned} &\text{Transmission zeros constrain what the input-output map can do,}\\ &\text{even if the poles are moved by feedback later.} \end{aligned} \]

For a square, 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} \), a complex number \( z\in\mathbb{C} \) is a transmission zero when the Rosenbrock matrix loses normal rank:

\[ \mathcal{R}(z)= \begin{bmatrix} z\mathbf{I}-\mathbf{A} & -\mathbf{B}\\ \mathbf{C} & \mathbf{D} \end{bmatrix}, \qquad \operatorname{rank}\mathcal{R}(z) < \operatorname{normalrank}\mathcal{R}(s). \]

Equivalently, there exist nonzero vectors \( \mathbf{x}_z \) and \( \mathbf{u}_z \) such that

\[ \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} = \mathbf{0}. \]

This means the exponential input \( \mathbf{u}(t)=\mathbf{u}_z e^{zt} \) can generate an internal state motion \( \mathbf{x}(t)=\mathbf{x}_z e^{zt} \) while producing zero output:

\[ \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)=\mathbf{0}. \]

If \( \operatorname{Re}(z)>0 \), this hidden trajectory is unstable. Such a zero is a right-half-plane zero, also called a non-minimum-phase zero. It cannot be cancelled by a stable causal inverse without introducing internal instability.

flowchart TD
  A["Transmission zero exists"] --> B["There is an input direction that produces zero output"]
  B --> C["Internal zero dynamics are activated"]
  C --> D{"Zero location"}
  D -->|"left half-plane"| E["Stable inverse behavior may be possible"]
  D -->|"right half-plane"| F["Unstable hidden behavior"]
  F --> G["Inverse response, bandwidth limits, tracking limits"]
  G --> H["Performance cannot be improved arbitrarily"]
        

In many tracking problems, one implicitly asks the plant to behave like an inverse map: given a desired output \( y_d(t) \), find an input \( u(t) \) such that \( y(t)=y_d(t) \). For a SISO transfer function \( G(s) \), exact inversion would formally require

\[ U(s)=G^{-1}(s)Y_d(s). \]

Suppose

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

Then

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

Therefore every zero \( z_i \) of the plant becomes a pole of the inverse. If \( \operatorname{Re}(z_i)>0 \), the inverse contains an unstable pole. This is the basic reason non-minimum-phase zeros create fundamental limitations.

Proposition 1 (No stable causal exact inverse for an RHP zero).

Let \( G(s) \) be a proper stable SISO plant with a zero \( z \) satisfying \( \operatorname{Re}(z)>0 \). Then \( G^{-1}(s) \) is unstable. Hence exact causal stable inversion is impossible.

Proof. Since \( G(z)=0 \), the denominator of \( G^{-1}(s) \) vanishes at \( s=z \). Therefore \( z \) is a pole of \( G^{-1}(s) \). Because \( \operatorname{Re}(z)>0 \), the inverse has a right-half-plane pole and is unstable. Thus a bounded desired output may require an unbounded or noncausal input. \( \square \)

A right-half-plane zero often produces an initial motion in the direction opposite to the final desired direction. Consider the stable second-order plants

\[ G_{\min}(s)=\frac{6(s+1)}{(s+2)(s+3)}, \qquad G_{\mathrm{nmp}}(s)=\frac{6(1-s)}{(s+2)(s+3)}. \]

Both have stable poles at \( -2 \) and \( -3 \), and both have unit DC gain:

\[ G_{\min}(0)=G_{\mathrm{nmp}}(0)=1. \]

But their zeros differ:

\[ z_{\min}=-1, \qquad z_{\mathrm{nmp}}=+1. \]

The zero at \( +1 \) is non-minimum-phase. Its step response must contain an inverse-response component. This is not due to unstable poles; it is due to the unstable zero of the input-output map.

Proposition 2 (A positive RHP zero forces sign change in the impulse response).

Let \( T(s) \) be stable, strictly proper, real-rational, have unit DC gain, and have a real zero at \( z>0 \). Let \( h(t) \) be its impulse response. Then \( h(t) \) cannot be nonnegative for all \( t\ge 0 \).

Proof. Since \( T(0)=1 \),

\[ T(0)=\int_{0}^{\infty}h(t)\,dt=1. \]

Since \( T(z)=0 \),

\[ T(z)=\int_{0}^{\infty}h(t)e^{-zt}\,dt=0. \]

If \( h(t)\ge 0 \) for all \( t\ge 0 \) and \( h(t) \) is not identically zero, then \( h(t)e^{-zt}\ge 0 \) and the integral must be positive. This contradicts \( T(z)=0 \). Hence \( h(t) \) must change sign. \( \square \)

For step tracking, a sign-changing impulse response frequently appears as undershoot or initial movement in the wrong direction. The closer the RHP zero is to the imaginary axis, the stronger the practical performance restriction.

Although full feedback design is introduced in later chapters, one important limitation can already be stated using the standard unity feedback definitions:

\[ L(s)=G(s)K(s), \qquad S(s)=\frac{1}{1+L(s)}, \qquad T(s)=\frac{L(s)}{1+L(s)}. \]

Here \( S(s) \) is the sensitivity function and \( T(s) \) is the complementary sensitivity function. They satisfy

\[ S(s)+T(s)=1. \]

Suppose \( G(s) \) has an uncancelled zero at \( z \) with \( \operatorname{Re}(z)>0 \). Since \( G(z)=0 \), the loop transfer satisfies \( L(z)=0 \), provided no unstable pole-zero cancellation is used. Thus

\[ T(z)=\frac{L(z)}{1+L(z)}=0, \qquad S(z)=\frac{1}{1+L(z)}=1. \]

This is an interpolation constraint: every internally stable feedback design must pass through fixed values at the plant RHP zero. The designer may reduce sensitivity over some frequency range, but the value at the RHP zero is pinned.

Implication. If a designer asks for an ideal closed-loop model \( T_d(s) \) with fast tracking, then the desired model must be compatible with the zero constraint:

\[ T_d(z)\approx 0. \]

A standard first-order desired model

\[ T_d(s)=\frac{1}{T_f s+1} \]

gives

\[ T_d(z)=\frac{1}{T_f z+1}. \]

If the desired response is very fast, then \( T_f \) is small, so \( T_d(z) \) is close to \( 1 \), not \( 0 \). This conflicts with the unavoidable condition \( T(z)=0 \). Therefore the RHP zero enforces a lower bound on how fast the closed-loop response can be made without severe overshoot, undershoot, or control effort.

A useful practical rule is that closed-loop bandwidth should normally be kept sufficiently below the magnitude of a non-minimum-phase zero:

\[ \omega_b \ll |z_{\mathrm{rhp}}|. \]

This is not an exact theorem for every architecture, but it is a reliable engineering interpretation of the interpolation and inversion constraints. If one attempts to force \( \omega_b \) close to or above the RHP zero, the closed-loop response typically pays by producing one or more of the following:

• large undershoot or overshoot,
• large control input,
• poor robustness margins,
• large sensitivity peak \( M_s=\|S\|_{\infty} \),
• large complementary sensitivity peak \( M_t=\|T\|_{\infty} \).

The qualitative tradeoff is often called a waterbed effect: reducing sensitivity in one region tends to increase it elsewhere when unstable poles or non-minimum-phase zeros are present.

flowchart TD
  A["Try faster tracking"] --> B["Increase closed-loop bandwidth"]
  B --> C{"RHP zero nearby?"}
  C -->|"no"| D["Performance may improve if \neffort and uncertainty allow"]
  C -->|"yes"| E["Interpolation constraint \nbecomes active"]
  E --> F["Undershoot / overshoot"]
  E --> G["Large control effort"]
  E --> H["High sensitivity peak"]
  F --> I["Achievable performance is limited"]
  G --> I
  H --> I
        

A classical integral limitation for stable minimum-loop assumptions can be expressed in sensitivity form. For appropriate stable closed loops, RHP poles increase the sensitivity integral:

\[ \int_{0}^{\infty}\log|S(j\omega)|\,d\omega = \pi\sum_{p_i\in\mathbb{C}_{+}}\operatorname{Re}(p_i). \]

More refined versions include RHP zeros and weighted sensitivity constraints. The important lesson here is not the exact integral formula but the interpretation: unstable poles and non-minimum-phase zeros prevent sensitivity from being made small everywhere.

In MIMO systems, a transmission zero is associated not only with a complex number but also with input and output directions. For a transfer matrix \( \mathbf{G}(s) \), if there exists a nonzero vector \( \mathbf{v} \) such that

\[ \mathbf{G}(z)\mathbf{v}=\mathbf{0}, \]

then the input direction \( \mathbf{v} \) is blocked at \( s=z \). In a square system, this is related to

\[ \det \mathbf{G}(z)=0, \]

when \( \mathbf{G}(s) \) is proper and has no pole-zero ambiguity at \( z \). For a non-square system, the normal-rank definition using the Rosenbrock matrix is more reliable.

The performance consequence is directional: some output combinations may be tracked quickly, while others are constrained by zero directions. In multivariable design, this is why singular-value plots alone are not enough; one must also inspect the directions associated with RHP zeros.

The following libraries are commonly used for the computations in this lesson:

• Python: scipy.signal, numpy, matplotlib, and optionally python-control with slycot for advanced state-space and MIMO computations.
• C++: Eigen, Armadillo, SLICOT, and custom state-space simulation code.
• Java: EJML, Apache Commons Math, or Hipparchus for matrix and polynomial computations.
• MATLAB/Simulink: Control System Toolbox, Robust Control Toolbox, and Simulink transfer-function/state-space blocks.
• Wolfram Mathematica: built-in TransferFunctionModel, StateSpaceModel, and control-system analysis functions.

Chapter21_Lesson5.py compares a minimum-phase plant and a non-minimum-phase plant with identical stable poles and identical DC gain. It also verifies the interpolation constraint \( S(z)=1 \), \( T(z)=0 \) at the RHP zero.

"""
Chapter21_Lesson5.py
Impact of transmission zeros on achievable performance and limitations.
"""

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal


def eval_poly(coefficients, s):
    """Evaluate polynomial with coefficients in descending powers at complex s."""
    value = 0.0 + 0.0j
    for c in coefficients:
        value = value * s + c
    return value


def plant(num):
    den = [1.0, 5.0, 6.0]  # (s+2)(s+3)
    return signal.TransferFunction(num, den), den


def closed_loop_values(num, den, k, s):
    """
    Unity-feedback loop with L(s)=kP(s).
    T=L/(1+L), S=1/(1+L).
    At a plant zero z, L(z)=0, so T(z)=0 and S(z)=1.
    """
    p = eval_poly(num, s) / eval_poly(den, s)
    loop = k * p
    sensitivity = 1.0 / (1.0 + loop)
    complementary = loop / (1.0 + loop)
    return sensitivity, complementary


def main():
    num_min = [6.0, 6.0]    # 6(s+1), zero at -1
    num_nmp = [-6.0, 6.0]   # 6(1-s), zero at +1
    sys_min, den = plant(num_min)
    sys_nmp, _ = plant(num_nmp)

    print("Minimum-phase zeros:", np.roots(num_min))
    print("Non-minimum-phase zeros:", np.roots(num_nmp))
    print("Common poles:", np.roots(den))

    t = np.linspace(0.0, 8.0, 1200)
    tout_min, y_min = signal.step(sys_min, T=t)
    tout_nmp, y_nmp = signal.step(sys_nmp, T=t)

    plt.figure(figsize=(9, 5))
    plt.plot(tout_min, y_min, label="zero at -1: minimum phase")
    plt.plot(tout_nmp, y_nmp, label="zero at +1: non-minimum phase")
    plt.axhline(1.0, linestyle="--", linewidth=1.0, label="unit steady value")
    plt.xlabel("time (s)")
    plt.ylabel("step response")
    plt.title("RHP zero produces inverse response and limits fast tracking")
    plt.grid(True)
    plt.legend()
    plt.tight_layout()
    plt.show()

    z = 1.0
    print("\nInterpolation at the non-minimum-phase zero z=1:")
    for k in [0.5, 2.0, 10.0, 100.0]:
        s_val, t_val = closed_loop_values(num_nmp, den, k, z)
        print(f"K={k:6.1f}  S(z)={s_val.real:.6f}  T(z)={t_val.real:.6f}")

    undershoot = np.trapz(np.maximum(0.0, -y_nmp), t)
    print(f"\nApproximate negative undershoot area: {undershoot:.6f}")


if __name__ == "__main__":
    main()
      

Chapter21_Lesson5.cpp implements the same comparison from scratch using a controllable canonical state-space realization and fourth-order Runge-Kutta integration.

/*
Chapter21_Lesson5.cpp
Scratch C++ demonstration of inverse response caused by an RHP zero.
*/

#include <array>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>

struct State {
    double x1;
    double x2;
};

State derivative(const State& x, double u) {
    return State{x.x2, -6.0 * x.x1 - 5.0 * x.x2 + u};
}

State add_scaled(const State& x, const State& k, double h) {
    return State{x.x1 + h * k.x1, x.x2 + h * k.x2};
}

State rk4_step(const State& x, double u, double dt) {
    State k1 = derivative(x, u);
    State k2 = derivative(add_scaled(x, k1, dt / 2.0), u);
    State k3 = derivative(add_scaled(x, k2, dt / 2.0), u);
    State k4 = derivative(add_scaled(x, k3, dt), u);
    return State{
        x.x1 + dt * (k1.x1 + 2.0 * k2.x1 + 2.0 * k3.x1 + k4.x1) / 6.0,
        x.x2 + dt * (k1.x2 + 2.0 * k2.x2 + 2.0 * k3.x2 + k4.x2) / 6.0
    };
}

double output(const State& x, double b0, double b1) {
    return b0 * x.x1 + b1 * x.x2;
}

double zero_location(double b0, double b1) {
    return -b0 / b1;
}

int main() {
    const double dt = 0.002;
    const double tf = 8.0;
    const double u = 1.0;

    const double b0_min = 6.0;
    const double b1_min = 6.0;

    const double b0_nmp = 6.0;
    const double b1_nmp = -6.0;

    std::cout << "Minimum-phase zero: " << zero_location(b0_min, b1_min) << "\n";
    std::cout << "Non-minimum-phase zero: " << zero_location(b0_nmp, b1_nmp) << "\n";
    std::cout << "Common poles: -2, -3\n";

    std::ofstream csv("Chapter21_Lesson5_cpp_step_response.csv");
    csv << "t,y_minimum_phase,y_nonminimum_phase\n";

    State xmin{0.0, 0.0};
    State xnmp{0.0, 0.0};
    double negative_area = 0.0;

    for (int i = 0; i <= static_cast<int>(tf / dt); ++i) {
        double t = i * dt;
        double ymin = output(xmin, b0_min, b1_min);
        double ynmp = output(xnmp, b0_nmp, b1_nmp);
        csv << std::fixed << std::setprecision(6)
            << t << "," << ymin << "," << ynmp << "\n";

        if (ynmp < 0.0) {
            negative_area += -ynmp * dt;
        }

        xmin = rk4_step(xmin, u, dt);
        xnmp = rk4_step(xnmp, u, dt);
    }

    std::cout << "Wrote Chapter21_Lesson5_cpp_step_response.csv\n";
    std::cout << "Approximate negative undershoot area: " << negative_area << "\n";
    return 0;
}
      

Chapter21_Lesson5.java repeats the state-space simulation in Java. For larger projects, matrix operations can be moved to EJML or Apache Commons Math.

/*
Chapter21_Lesson5.java
Scratch Java simulation of minimum-phase and non-minimum-phase zeros.
*/

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Chapter21_Lesson5 {
    static class State {
        double x1;
        double x2;

        State(double x1, double x2) {
            this.x1 = x1;
            this.x2 = x2;
        }
    }

    static State derivative(State x, double u) {
        return new State(x.x2, -6.0 * x.x1 - 5.0 * x.x2 + u);
    }

    static State addScaled(State x, State k, double h) {
        return new State(x.x1 + h * k.x1, x.x2 + h * k.x2);
    }

    static State rk4Step(State x, double u, double dt) {
        State k1 = derivative(x, u);
        State k2 = derivative(addScaled(x, k1, dt / 2.0), u);
        State k3 = derivative(addScaled(x, k2, dt / 2.0), u);
        State k4 = derivative(addScaled(x, k3, dt), u);

        return new State(
            x.x1 + dt * (k1.x1 + 2.0 * k2.x1 + 2.0 * k3.x1 + k4.x1) / 6.0,
            x.x2 + dt * (k1.x2 + 2.0 * k2.x2 + 2.0 * k3.x2 + k4.x2) / 6.0
        );
    }

    static double output(State x, double b0, double b1) {
        return b0 * x.x1 + b1 * x.x2;
    }

    static double zeroLocation(double b0, double b1) {
        return -b0 / b1;
    }

    public static void main(String[] args) throws IOException {
        double dt = 0.002;
        double tf = 8.0;
        double u = 1.0;

        double b0Min = 6.0;
        double b1Min = 6.0;

        double b0Nmp = 6.0;
        double b1Nmp = -6.0;

        System.out.println("Minimum-phase zero: " + zeroLocation(b0Min, b1Min));
        System.out.println("Non-minimum-phase zero: " + zeroLocation(b0Nmp, b1Nmp));
        System.out.println("Common poles: -2, -3");

        State xMin = new State(0.0, 0.0);
        State xNmp = new State(0.0, 0.0);
        double negativeArea = 0.0;

        try (PrintWriter csv = new PrintWriter(new FileWriter("Chapter21_Lesson5_java_step_response.csv"))) {
            csv.println("t,y_minimum_phase,y_nonminimum_phase");

            int steps = (int) Math.round(tf / dt);
            for (int i = 0; i <= steps; i++) {
                double t = i * dt;
                double yMin = output(xMin, b0Min, b1Min);
                double yNmp = output(xNmp, b0Nmp, b1Nmp);

                csv.printf("%.6f,%.10f,%.10f%n", t, yMin, yNmp);

                if (yNmp < 0.0) {
                    negativeArea += -yNmp * dt;
                }

                xMin = rk4Step(xMin, u, dt);
                xNmp = rk4Step(xNmp, u, dt);
            }
        }

        System.out.println("Wrote Chapter21_Lesson5_java_step_response.csv");
        System.out.println("Approximate negative undershoot area: " + negativeArea);
    }
}
      

Chapter21_Lesson5.m uses MATLAB Control System Toolbox. The same transfer functions can also be placed in Simulink using Transfer Fcn blocks with numerators [6 6] and [-6 6], and denominator [1 5 6].

% Chapter21_Lesson5.m
% Impact of zeros on achievable performance and limitations.
% Requires MATLAB Control System Toolbox.

clear; clc; close all;

s = tf('s');
Gmin = 6*(s + 1)/(s^2 + 5*s + 6);
Gnmp = 6*(1 - s)/(s^2 + 5*s + 6);

fprintf('Minimum-phase zero:\n');
disp(zero(Gmin));

fprintf('Non-minimum-phase zero:\n');
disp(zero(Gnmp));

fprintf('Common poles:\n');
disp(pole(Gnmp));

figure;
step(Gmin, Gnmp, 8);
grid on;
legend('zero at -1: minimum phase', ...
       'zero at +1: non-minimum phase', ...
       'Location', 'best');
title('RHP zero produces inverse response and limits fast tracking');

z = 1;
for K = [0.5 2 10 100]
    L = K*Gnmp;
    T = feedback(L, 1);
    S = feedback(1, L);

    fprintf('K = %7.2f,  S(z) = %.8f,  T(z) = %.8f\n', ...
        K, real(evalfr(S, z)), real(evalfr(T, z)));
end

figure;
hold on;
for K = [0.5 2 10]
    Tnmp = feedback(K*Gnmp, 1);
    step(Tnmp, 8);
end
grid on;
legend('K=0.5', 'K=2', 'K=10', 'Location', 'best');
title('Increasing gain cannot remove the RHP-zero interpolation constraint');
hold off;
      

Chapter21_Lesson5.nb uses Wolfram control-system objects to compute zeros, poles, and step responses.

(* Chapter21_Lesson5.nb *)
ClearAll[s, t, k, z];

gmin = TransferFunctionModel[6 (s + 1)/(s^2 + 5 s + 6), s];
gnmp = TransferFunctionModel[6 (1 - s)/(s^2 + 5 s + 6), s];

Print["Minimum-phase zeros: ", TransferFunctionZeros[gmin]];
Print["Non-minimum-phase zeros: ", TransferFunctionZeros[gnmp]];
Print["Common poles: ", TransferFunctionPoles[gnmp]];

resp = OutputResponse[{gmin, gnmp}, UnitStep[t], {t, 0, 8}];

Plot[
  Evaluate[resp],
  {t, 0, 8},
  PlotLegends -> {"zero at -1", "zero at +1"},
  GridLines -> Automatic,
  PlotLabel -> "RHP zero inverse response"
]

gNmpExpr = 6 (1 - s)/(s^2 + 5 s + 6);
sensitivity[kk_] := 1/(1 + kk gNmpExpr);
complementary[kk_] := kk gNmpExpr/(1 + kk gNmpExpr);

z = 1;
Table[
  {kk, sensitivity[kk] /. s -> z, complementary[kk] /. s -> z},
  {kk, {0.5, 2, 10, 100}}
]
      

Problem 1 (Stable inversion): Let \( G(s)=\dfrac{s-2}{(s+1)(s+3)} \). Determine whether a stable causal exact inverse exists.

Solution:

The plant zero is \( z=2 \), which lies in the right-half plane. The inverse is

\[ G^{-1}(s)=\frac{(s+1)(s+3)}{s-2}. \]

This inverse has a pole at \( s=2 \). Since \( \operatorname{Re}(2)>0 \), the inverse is unstable. Therefore no stable causal exact inverse exists.

Problem 2 (Interpolation constraint): Suppose a plant \( G(s) \) has an uncancelled RHP zero at \( z=4 \). Under unity feedback, with \( L(s)=G(s)K(s) \), compute \( S(4) \) and \( T(4) \).

Solution:

Since \( G(4)=0 \), we have \( L(4)=G(4)K(4)=0 \), provided there is no unstable cancellation. Hence

\[ S(4)=\frac{1}{1+L(4)}=1, \qquad T(4)=\frac{L(4)}{1+L(4)}=0. \]

Thus the closed-loop complementary sensitivity must vanish at the RHP zero, and the sensitivity must equal one there.

Problem 3 (Desired model compatibility): A plant has an RHP zero at \( z=2 \). A designer wants a first-order closed-loop model \( T_d(s)=\dfrac{1}{0.1s+1} \). Check whether this is compatible with the zero interpolation condition.

Solution:

The interpolation condition requires approximately \( T_d(2)\approx 0 \). But

\[ T_d(2)=\frac{1}{0.1(2)+1}=\frac{1}{1.2}\approx 0.833. \]

This is far from zero. Therefore the desired model is too fast relative to the RHP zero. Attempting to realize it would cause severe undershoot, overshoot, large control effort, or poor robustness.

Problem 4 (Impulse-response sign change): Let \( T(s) \) be stable, strictly proper, and have \( T(0)=1 \). If \( T(3)=0 \), prove that the impulse response \( h(t) \) cannot satisfy \( h(t)\ge 0 \) for all \( t\ge 0 \).

Solution:

Because \( T(3)=0 \),

\[ \int_0^\infty h(t)e^{-3t}\,dt=0. \]

If \( h(t)\ge 0 \) for all \( t\ge 0 \) and the system is not identically zero, then \( h(t)e^{-3t}\ge 0 \) and the integral must be positive. This contradicts the zero condition. Therefore \( h(t) \) must change sign.

Problem 5 (MIMO zero direction): Suppose a transfer matrix satisfies \( \mathbf{G}(z)\mathbf{v}=\mathbf{0} \) for some nonzero vector \( \mathbf{v} \) and \( \operatorname{Re}(z)>0 \). Explain the performance implication.

Solution:

The direction \( \mathbf{v} \) is an input direction that produces no output at the exponential rate \( e^{zt} \). Since \( z \) is in the right-half plane, the associated zero dynamics are unstable. Therefore output commands requiring strong response in the corresponding direction cannot be tracked arbitrarily fast without exciting hidden unstable behavior, large control effort, or poor robustness.

Transmission zeros impose structural performance limits. Left-half-plane zeros may shape transients but do not prevent stable inversion in the same way. Right-half-plane zeros are more severe: they become unstable poles of the inverse, force sign changes in impulse response, create inverse response in step tracking, impose interpolation constraints on feedback sensitivity functions, and restrict achievable bandwidth. In MIMO systems, these limits are directional and must be interpreted using zero directions as well as zero locations.