In the diagonal modal form studied earlier, each independent mode of \(\dot{\mathbf{x} }=\mathbf{A}\mathbf{x}\) contributes a pure exponential term \(e^{\lambda_i t}\). However, when an eigenvalue does not have enough linearly independent eigenvectors, the matrix is not diagonalizable. Its modal representation contains Jordan blocks, and the corresponding response is no longer only a sum of pure exponentials.

The central phenomenon of this lesson is:

\[ \boxed{ \text{Jordan block of size }m \quad\Longrightarrow\quad e^{\lambda t},\; t e^{\lambda t},\; \frac{t^2}{2!}e^{\lambda t}, \dots,\frac{t^{m-1} }{(m-1)!}e^{\lambda t} } \]

These polynomial factors do not create new eigenvalues. They reveal that the repeated eigenvalue is dynamically coupled along a chain of generalized eigenvectors. Therefore, a defective eigenvalue produces a cascade of modal coordinates rather than independent scalar modes.

Let \(\lambda\) be an eigenvalue of \(\mathbf{A}\in\mathbb{C}^{n\times n}\). A Jordan chain of length \(m\) is a sequence of nonzero vectors \(\mathbf{v}_1,\dots,\mathbf{v}_m\) satisfying

\[ (\mathbf{A}-\lambda\mathbf{I})\mathbf{v}_1=\mathbf{0},\qquad (\mathbf{A}-\lambda\mathbf{I})\mathbf{v}_{k+1}=\mathbf{v}_k,\quad k=1,\dots,m-1. \]

The first vector \(\mathbf{v}_1\) is an ordinary eigenvector. The remaining vectors are generalized eigenvectors. Define the chain matrix

\[ \mathbf{V} = \begin{bmatrix} \mathbf{v}_1 & \mathbf{v}_2 & \cdots & \mathbf{v}_m \end{bmatrix}. \]

Inside this chain subspace, multiplication by \(\mathbf{A}\) is represented by the Jordan block

\[ \mathbf{A}\mathbf{V} = \mathbf{V}\mathbf{J}_m(\lambda), \qquad \mathbf{J}_m(\lambda) = \lambda\mathbf{I}_m+\mathbf{N}_m, \]

\[ \mathbf{N}_m= \begin{bmatrix} 0 & 1 & 0 & \cdots & 0\\ 0 & 0 & 1 & \cdots & 0\\ \vdots & \vdots & \vdots & \ddots & \vdots\\ 0 & 0 & 0 & \cdots & 1\\ 0 & 0 & 0 & \cdots & 0 \end{bmatrix}, \qquad \mathbf{N}_m^m=\mathbf{0}. \]

The matrix \(\mathbf{N}_m\) is nilpotent: repeated multiplication eventually gives the zero matrix. This nilpotent part is exactly what generates the polynomial factors in time.

flowchart TD
  V1["v1: eigenvector"] --> V2["v2: generalized vector"]
  V2 --> V3["v3: generalized vector"]
  V3 --> VM["vm: last vector in chain"]
  VM --> J["Jordan block: J = lambda I + N"]
  J --> D["Coupled modal coordinates"]
  D --> R["Response has exp(lambda t), t exp(lambda t), ..., t^(m-1) exp(lambda t)"]
        

Consider the Jordan block \(\mathbf{J}_m(\lambda)=\lambda\mathbf{I}_m+\mathbf{N}_m\). Since \(\lambda\mathbf{I}_m\) commutes with \(\mathbf{N}_m\), we have

\[ e^{\mathbf{J}_m(\lambda)t} = e^{(\lambda\mathbf{I}_m+\mathbf{N}_m)t} = e^{\lambda t\mathbf{I}_m}e^{\mathbf{N}_m t} = e^{\lambda t}e^{\mathbf{N}_m t}. \]

The exponential of the nilpotent matrix is finite because \(\mathbf{N}_m^m=\mathbf{0}\):

\[ e^{\mathbf{N}_m t} = \sum_{\ell=0}^{\infty}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell = \sum_{\ell=0}^{m-1}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell. \]

Therefore,

\[ \boxed{ e^{\mathbf{J}_m(\lambda)t} = e^{\lambda t} \sum_{\ell=0}^{m-1}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell } \]

For a size-three Jordan block,

\[ \mathbf{J}_3(\lambda) = \begin{bmatrix} \lambda & 1 & 0\\ 0 & \lambda & 1\\ 0 & 0 & \lambda \end{bmatrix}, \qquad e^{\mathbf{J}_3(\lambda)t} = e^{\lambda t} \begin{bmatrix} 1 & t & \frac{t^2}{2}\\ 0 & 1 & t\\ 0 & 0 & 1 \end{bmatrix}. \]

This formula is the mathematical origin of the terms \(t e^{\lambda t}\) and \(t^2 e^{\lambda t}\).

Suppose the state is expressed in the Jordan-chain coordinates:

\[ \mathbf{x}(t)=\mathbf{V}\mathbf{z}(t), \qquad \dot{\mathbf{z} }(t)=\mathbf{J}_m(\lambda)\mathbf{z}(t). \]

Then

\[ \mathbf{z}(t) = e^{\mathbf{J}_m(\lambda)t}\mathbf{z}(0) = e^{\lambda t} \left( \sum_{\ell=0}^{m-1}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell \right)\mathbf{z}(0). \]

Let \(\mathbf{z}(0)=\begin{bmatrix}c_1 & c_2 & \cdots & c_m\end{bmatrix}^T\). For the size-three case,

\[ \begin{aligned} z_3(t) &= e^{\lambda t}c_3,\\ z_2(t) &= e^{\lambda t}\left(c_2+t c_3\right),\\ z_1(t) &= e^{\lambda t}\left(c_1+t c_2+\frac{t^2}{2}c_3\right). \end{aligned} \]

Reconstructing the physical state gives

\[ \mathbf{x}(t) = z_1(t)\mathbf{v}_1 + z_2(t)\mathbf{v}_2 + z_3(t)\mathbf{v}_3. \]

Thus, the highest generalized eigenvector coefficient \(c_3\) contributes to every earlier coordinate through a polynomial cascade. This is why a defective eigenvalue causes a response shape that is not captured by independent exponential modes.

A Jordan chain behaves like a cascade of first-order subsystems with the same eigenvalue. For a size-three block:

\[ \begin{aligned} \dot{z}_1 &= \lambda z_1 + z_2,\\ \dot{z}_2 &= \lambda z_2 + z_3,\\ \dot{z}_3 &= \lambda z_3. \end{aligned} \]

The last coordinate \(z_3\) evolves independently. It drives \(z_2\), and \(z_2\) drives \(z_1\). Therefore, the polynomial terms are forced internally by the nilpotent coupling, not by an external input.

The asymptotic stability interpretation remains eigenvalue-based:

\[ \operatorname{Re}(\lambda)<0 \quad\Longrightarrow\quad t^\ell e^{\lambda t}\to 0 \quad\text{for every finite }\ell. \]

Therefore, a stable eigenvalue remains asymptotically stable even if its Jordan block is large. However, the polynomial factor can create large transient growth before the exponential decay dominates. This is one reason nonnormal and nearly defective matrices can be numerically and dynamically sensitive.

If \(\operatorname{Re}(\lambda)=0\) and the Jordan block has size greater than one, the polynomial factor does not decay. For example, \(t e^{j\omega t}\) has growing amplitude. Thus, repeated imaginary-axis eigenvalues are stable only under stronger structural conditions that exclude nontrivial Jordan blocks.

Let

\[ \mathbf{J} = \begin{bmatrix} -2 & 1 & 0\\ 0 & -2 & 1\\ 0 & 0 & -2 \end{bmatrix}, \qquad \mathbf{z}(0) = \begin{bmatrix} 0\\1\\2 \end{bmatrix}. \]

Since \(\lambda=-2\),

\[ e^{\mathbf{J}t} = e^{-2t} \begin{bmatrix} 1 & t & \frac{t^2}{2}\\ 0 & 1 & t\\ 0 & 0 & 1 \end{bmatrix}. \]

Hence

\[ \mathbf{z}(t) = e^{-2t} \begin{bmatrix} 1 & t & \frac{t^2}{2}\\ 0 & 1 & t\\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 0\\1\\2 \end{bmatrix} = e^{-2t} \begin{bmatrix} t+t^2\\ 1+2t\\ 2 \end{bmatrix}. \]

Every component decays to zero because \(\operatorname{Re}(\lambda)=-2<0\). Nevertheless, the first coordinate initially contains both \(t e^{-2t}\) and \(t^2 e^{-2t}\), so its transient shape is not a pure exponential.

For Jordan-chain dynamics, the most important computational idea is to separate the scalar exponential from the finite nilpotent series. This is more transparent than calling a generic matrix exponential routine and helps students see exactly where the polynomial terms originate.

flowchart TD
  A["Choose lambda and block size m"] --> B["Build nilpotent matrix N"]
  B --> C["Use finite series: I + tN + ... + t^(m-1)N^(m-1)/(m-1)!"]
  C --> D["Multiply by exp(lambda t)"]
  D --> E["Apply to initial Jordan coordinates z0"]
  E --> F["Plot or print modal coordinates"]
  F --> G["Compare with generic matrix exponential"]
        

Recommended libraries for this lesson include:

• Python: NumPy for matrices, SciPy for scipy.linalg.expm, Matplotlib for plotting, and python-control for state-space workflows in later design lessons.
• C++: Eigen or Armadillo for general matrix computation. The implementation below is written from scratch for a size-three Jordan block.
• Java: EJML or Apache Commons Math for numerical linear algebra. The implementation below is written from scratch.
• MATLAB/Simulink: MATLAB expm, Control System Toolbox ss and initial, and Simulink State-Space blocks.
• Wolfram Mathematica: MatrixExp, JordanDecomposition, symbolic summation, and exact plotting.

Chapter18_Lesson3.py computes the Jordan-block exponential using the nilpotent finite series and optionally compares it with scipy.linalg.expm.

# Chapter18_Lesson3.py
# Dynamics associated with Jordan chains: polynomial-exponential terms
#
# Required libraries:
#   pip install numpy matplotlib
# Optional comparison:
#   pip install scipy

import math
import numpy as np
import matplotlib.pyplot as plt


def nilpotent_superdiagonal(n: int) -> np.ndarray:
    """Return N with ones on the first superdiagonal, so N^n = 0."""
    if n <= 0:
        raise ValueError("n must be positive.")
    N = np.zeros((n, n), dtype=float)
    for i in range(n - 1):
        N[i, i + 1] = 1.0
    return N


def jordan_exponential(lam: float, n: int, t: float) -> np.ndarray:
    """
    Compute exp((lam I + N)t) from the finite nilpotent series:
        exp(Jt) = exp(lam t) * sum_{k=0}^{n-1} (t^k / k!) N^k.
    """
    N = nilpotent_superdiagonal(n)
    result = np.eye(n)
    power = np.eye(n)
    for k in range(1, n):
        power = power @ N
        result += (t ** k / math.factorial(k)) * power
    return math.exp(lam * t) * result


def trajectory(lam: float, n: int, z0: np.ndarray, times: np.ndarray) -> np.ndarray:
    """Return rows z(t_i)^T for the Jordan-coordinate system zdot = Jz."""
    z0 = np.asarray(z0, dtype=float).reshape(n)
    return np.vstack([jordan_exponential(lam, n, float(t)) @ z0 for t in times])


def compare_with_scipy(lam: float, n: int, t: float) -> None:
    """Compare the closed-form nilpotent formula with scipy.linalg.expm if SciPy exists."""
    try:
        from scipy.linalg import expm
    except ImportError:
        print("SciPy is not installed; skipping expm comparison.")
        return

    N = nilpotent_superdiagonal(n)
    J = lam * np.eye(n) + N
    err = np.linalg.norm(jordan_exponential(lam, n, t) - expm(J * t), ord=np.inf)
    print(f"Infinity-norm error versus scipy.linalg.expm at t={t}: {err:.3e}")


def main() -> None:
    lam = -0.40
    n = 3
    z0 = np.array([1.0, -0.5, 2.0])
    times = np.linspace(0.0, 12.0, 400)

    Z = trajectory(lam, n, z0, times)

    print("Jordan block size:", n)
    print("lambda:", lam)
    print("Initial Jordan coordinates z0:", z0)
    print("exp(Jt) at t = 2:")
    print(jordan_exponential(lam, n, 2.0))
    compare_with_scipy(lam, n, 2.0)

    plt.figure()
    for i in range(n):
        plt.plot(times, Z[:, i], label=f"z{i + 1}(t)")
    plt.xlabel("time t")
    plt.ylabel("Jordan-coordinate state")
    plt.title("Jordan-chain dynamics: polynomial-exponential terms")
    plt.grid(True)
    plt.legend()
    plt.tight_layout()
    plt.show()


if __name__ == "__main__":
    main()

The C++ and Java programs implement the size-three formula directly. This makes the causal structure of the Jordan chain visible without relying on external numerical packages.

Chapter18_Lesson3.cpp

// Chapter18_Lesson3.cpp
// Dynamics associated with a size-3 Jordan block.
//
// Compile:
//   g++ -std=c++17 Chapter18_Lesson3.cpp -o Chapter18_Lesson3
//
// Run:
//   ./Chapter18_Lesson3

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

using Matrix3 = std::array<std::array<double, 3>, 3>;
using Vector3 = std::array<double, 3>;

Matrix3 jordan_exponential(double lambda, double t) {
    // J = lambda I + N, where N has ones on the first superdiagonal.
    // exp(Jt) = exp(lambda t) * [[1, t, t^2/2], [0, 1, t], [0, 0, 1]].
    const double e = std::exp(lambda * t);
    Matrix3 E { {
        { {e, e * t, e * t * t / 2.0} },
        { {0.0, e, e * t} },
        { {0.0, 0.0, e} }
    } };
    return E;
}

Vector3 matvec(const Matrix3& A, const Vector3& x) {
    Vector3 y { {0.0, 0.0, 0.0} };
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            y[i] += A[i][j] * x[j];
        }
    }
    return y;
}

void print_matrix(const Matrix3& A) {
    for (const auto& row : A) {
        for (double value : row) {
            std::cout << std::setw(14) << std::setprecision(7) << value << " ";
        }
        std::cout << "\n";
    }
}

void print_vector(const Vector3& x) {
    std::cout << "[";
    for (int i = 0; i < 3; ++i) {
        std::cout << std::setprecision(7) << x[i];
        if (i < 2) {
            std::cout << ", ";
        }
    }
    std::cout << "]";
}

int main() {
    const double lambda = -0.40;
    const Vector3 z0 { {1.0, -0.5, 2.0} };

    std::cout << "Dynamics for zdot = Jz, J = lambda I + N\n";
    std::cout << "lambda = " << lambda << "\n\n";

    for (double t : {0.0, 1.0, 2.0, 4.0, 8.0}) {
        Matrix3 E = jordan_exponential(lambda, t);
        Vector3 z = matvec(E, z0);

        std::cout << "t = " << t << "\n";
        std::cout << "exp(Jt) =\n";
        print_matrix(E);
        std::cout << "z(t) = ";
        print_vector(z);
        std::cout << "\n\n";
    }

    return 0;
}

Chapter18_Lesson3.java

// Chapter18_Lesson3.java
// Dynamics associated with a size-3 Jordan block.
//
// Compile:
//   javac Chapter18_Lesson3.java
//
// Run:
//   java Chapter18_Lesson3

public class Chapter18_Lesson3 {
    static double[][] jordanExponential(double lambda, double t) {
        // J = lambda I + N, where N has ones on the first superdiagonal.
        // exp(Jt) = exp(lambda t) * [[1, t, t^2/2], [0, 1, t], [0, 0, 1]].
        double e = Math.exp(lambda * t);
        return new double[][] {
            {e, e * t, e * t * t / 2.0},
            {0.0, e, e * t},
            {0.0, 0.0, e}
        };
    }

    static double[] matVec(double[][] A, double[] x) {
        double[] y = new double[x.length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < x.length; j++) {
                y[i] += A[i][j] * x[j];
            }
        }
        return y;
    }

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

    static void printVector(double[] x) {
        System.out.print("[");
        for (int i = 0; i < x.length; i++) {
            System.out.printf("%.7f", x[i]);
            if (i < x.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.print("]");
    }

    public static void main(String[] args) {
        double lambda = -0.40;
        double[] z0 = {1.0, -0.5, 2.0};
        double[] times = {0.0, 1.0, 2.0, 4.0, 8.0};

        System.out.println("Dynamics for zdot = Jz, J = lambda I + N");
        System.out.println("lambda = " + lambda + "\n");

        for (double t : times) {
            double[][] E = jordanExponential(lambda, t);
            double[] z = matVec(E, z0);

            System.out.println("t = " + t);
            System.out.println("exp(Jt) =");
            printMatrix(E);
            System.out.print("z(t) = ");
            printVector(z);
            System.out.println("\n");
        }
    }
}

The MATLAB script computes the finite nilpotent series, compares it with expm, plots the response, and includes an optional function that creates a Simulink model with a State-Space block.

Chapter18_Lesson3.m

% Chapter18_Lesson3.m
% Dynamics associated with Jordan chains: polynomial-exponential terms.
%
% This script computes exp(Jt) from the nilpotent formula and compares it
% with MATLAB expm. It also optionally creates a Simulink model containing a
% State-Space block for the same Jordan block.

clear; clc; close all;

lambda = -0.40;
n = 3;
N = diag(ones(1, n - 1), 1);
J = lambda * eye(n) + N;
z0 = [1.0; -0.5; 2.0];

t = linspace(0, 12, 400);
Z = zeros(numel(t), n);

for k = 1:numel(t)
    E = jordanExponential(lambda, N, t(k));
    Z(k, :) = (E * z0).';
end

disp('Jordan block J = lambda I + N:');
disp(J);

disp('exp(Jt) from nilpotent formula at t = 2:');
E_formula = jordanExponential(lambda, N, 2.0);
disp(E_formula);

disp('Infinity-norm error versus expm(J*2):');
disp(norm(E_formula - expm(J * 2.0), inf));

figure;
plot(t, Z(:, 1), 'LineWidth', 1.5); hold on;
plot(t, Z(:, 2), 'LineWidth', 1.5);
plot(t, Z(:, 3), 'LineWidth', 1.5);
grid on;
xlabel('time t');
ylabel('Jordan-coordinate state');
title('Jordan-chain dynamics: polynomial-exponential terms');
legend('z1(t)', 'z2(t)', 'z3(t)', 'Location', 'best');

% Optional: create a Simulink model with a State-Space block.
% Uncomment the next line if Simulink is installed and licensed.
% createJordanChainSimulinkModel(lambda);

function E = jordanExponential(lambda, N, t)
    n = size(N, 1);
    S = eye(n);
    P = eye(n);
    for ell = 1:(n - 1)
        P = P * N;
        S = S + (t^ell / factorial(ell)) * P;
    end
    E = exp(lambda * t) * S;
end

function createJordanChainSimulinkModel(lambda)
    if ~license('test', 'Simulink')
        warning('Simulink license is not available.');
        return;
    end

    n = 3;
    N = diag(ones(1, n - 1), 1);
    J = lambda * eye(n) + N;
    B = zeros(n, 1);
    C = eye(n);
    D = zeros(n, 1);

    model = 'Chapter18_Lesson3_JordanChain';
    if bdIsLoaded(model)
        close_system(model, 0);
    end

    new_system(model);
    open_system(model);

    add_block('simulink/Continuous/State-Space', [model '/Jordan Chain State-Space']);
    set_param([model '/Jordan Chain State-Space'], ...
        'A', mat2str(J), ...
        'B', mat2str(B), ...
        'C', mat2str(C), ...
        'D', mat2str(D), ...
        'X0', '[1; -0.5; 2]');

    add_block('simulink/Sinks/Scope', [model '/Scope']);
    add_line(model, 'Jordan Chain State-Space/1', 'Scope/1');
    set_param(model, 'StopTime', '12');
    save_system(model);
end

The Mathematica notebook uses symbolic finite sums and compares the result with MatrixExp.

Chapter18_Lesson3.nb

Notebook[{
  Cell["Chapter18_Lesson3.nb", "Title"],
  Cell["Dynamics Associated with Jordan Chains", "Section"],
  Cell["This notebook computes exp((lambda I + N)t) using the finite nilpotent series and plots the Jordan-coordinate response.", "Text"],
  Cell[BoxData @ ToBoxes[
    Module[
      {lambda = -0.40, n = 3, N, J, z0, eJt, z, t},
      N = DiagonalMatrix[ConstantArray[1, n - 1], 1];
      J = lambda IdentityMatrix[n] + N;
      z0 = {1.0, -0.5, 2.0};

      eJt[tt_] := Exp[lambda tt] Sum[(tt^k/Factorial[k]) MatrixPower[N, k], {k, 0, n - 1}];
      z[tt_] := eJt[tt].z0;

      Print["Jordan block J ="];
      Print[MatrixForm[J]];

      Print["exp(Jt) from nilpotent formula at t = 2:"];
      Print[MatrixForm[eJt[2.0]]];

      Print["Difference from MatrixExp[J*2]:"];
      Print[Norm[eJt[2.0] - MatrixExp[J*2.0], Infinity]];

      Plot[
        Evaluate[Table[z[t][[i]], {i, 1, n}]],
        {t, 0, 12},
        PlotLegends -> {"z1(t)", "z2(t)", "z3(t)"},
        AxesLabel -> {"time t", "Jordan-coordinate state"},
        PlotLabel -> "Jordan-chain dynamics: polynomial-exponential terms"
      ]
    ]
  ], "Input"]
}]

Problem 1: Let \(\mathbf{J}_2(\lambda)=\begin{bmatrix}\lambda & 1\\0 & \lambda\end{bmatrix}\). Derive \(e^{\mathbf{J}_2(\lambda)t}\).

Solution:

Write \(\mathbf{J}_2(\lambda)=\lambda\mathbf{I}_2+\mathbf{N}_2\), where \(\mathbf{N}_2=\begin{bmatrix}0 & 1\\0 & 0\end{bmatrix}\). Since \(\mathbf{N}_2^2=\mathbf{0}\),

\[ e^{\mathbf{J}_2(\lambda)t} = e^{\lambda t} \left(\mathbf{I}_2+t\mathbf{N}_2\right) = e^{\lambda t} \begin{bmatrix} 1 & t\\ 0 & 1 \end{bmatrix}. \]

The off-diagonal term is exactly \(t e^{\lambda t}\).

Problem 2: For \(\dot{\mathbf{z} }=\mathbf{J}_3(-1)\mathbf{z}\) with \(\mathbf{z}(0)=\begin{bmatrix}1 & 0 & 3\end{bmatrix}^T\), compute \(\mathbf{z}(t)\).

Solution:

\[ e^{\mathbf{J}_3(-1)t} = e^{-t} \begin{bmatrix} 1 & t & \frac{t^2}{2}\\ 0 & 1 & t\\ 0 & 0 & 1 \end{bmatrix}. \]

\[ \mathbf{z}(t) = e^{-t} \begin{bmatrix} 1 & t & \frac{t^2}{2}\\ 0 & 1 & t\\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1\\0\\3 \end{bmatrix} = e^{-t} \begin{bmatrix} 1+\frac{3}{2}t^2\\ 3t\\ 3 \end{bmatrix}. \]

The second coordinate contains \(t e^{-t}\), and the first coordinate contains \(t^2 e^{-t}\).

Problem 3: Show that if \(\operatorname{Re}(\lambda)<0\), then \(t^q e^{\lambda t}\to 0\) for every nonnegative integer \(q\).

Solution:

Let \(\alpha=-\operatorname{Re}(\lambda)\), so \(\alpha>0\). Then

\[ |t^q e^{\lambda t}| = t^q e^{\operatorname{Re}(\lambda)t} = t^q e^{-\alpha t}. \]

Exponential decay dominates polynomial growth. Therefore,

\[ \lim_{t\to\infty} t^q e^{-\alpha t}=0. \]

Hence every finite polynomial-exponential Jordan term decays when the associated eigenvalue lies strictly in the open left half-plane.

Problem 4: Explain why a Jordan block \(\mathbf{J}_2(0)\) is not asymptotically stable.

Solution:

For \(\lambda=0\),

\[ e^{\mathbf{J}_2(0)t} = \begin{bmatrix} 1 & t\\ 0 & 1 \end{bmatrix}. \]

The term \(t\) grows without bound. Therefore, even though the eigenvalue is on the imaginary axis, the nontrivial Jordan block creates unbounded state growth for some initial conditions. The system is not Lyapunov stable and is not asymptotically stable.

Problem 5: Let a real system have \(\mathbf{A}=\mathbf{T}\mathbf{J}\mathbf{T}^{-1}\). If one block of \(\mathbf{J}\) is \(\mathbf{J}_m(\lambda)\), show how the corresponding contribution appears in the physical state \(\mathbf{x}(t)\).

Solution:

Write the modal state as \(\mathbf{z}(t)=\mathbf{T}^{-1}\mathbf{x}(t)\). The Jordan block contribution is

\[ \mathbf{z}_J(t) = e^{\lambda t} \left( \sum_{\ell=0}^{m-1}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell \right) \mathbf{z}_J(0). \]

Multiplication by the corresponding columns of \(\mathbf{T}\) maps this chain contribution back to the physical coordinates:

\[ \mathbf{x}_J(t) = \mathbf{T}_J e^{\lambda t} \left( \sum_{\ell=0}^{m-1}\frac{t^\ell}{\ell!}\mathbf{N}_m^\ell \right) \mathbf{z}_J(0). \]

Therefore, the physical response is a linear combination of generalized eigenvectors multiplied by polynomial-exponential functions.

A Jordan chain introduces nilpotent coupling among generalized modal coordinates. Because the nilpotent matrix has a finite exponential series, a Jordan block of size \(m\) produces \(e^{\lambda t}\) multiplied by polynomials of degree up to \(m-1\). These terms explain the appearance of \(t e^{\lambda t}\) and higher-order polynomial-exponential responses in non-diagonalizable systems.

For stability, the eigenvalue location still determines asymptotic decay when \(\operatorname{Re}(\lambda)<0\), but nontrivial Jordan blocks can produce significant transient behavior. When eigenvalues lie on the imaginary axis, nontrivial Jordan blocks lead to polynomial growth and instability in the Lyapunov sense.