In earlier lessons, diagonal modal form was introduced for matrices with enough linearly independent eigenvectors. The difficulty appears when an eigenvalue is repeated but does not provide enough independent eigenvectors. For a state matrix \( \mathbf{A}\in\mathbb{R}^{n\times n} \), an eigenvalue \( \lambda \) satisfies

\[ \det(\lambda\mathbf{I}-\mathbf{A})=0. \]

The ordinary eigenspace is \( \mathcal{N}(\mathbf{A}-\lambda\mathbf{I}) \). Its dimension is the geometric multiplicity:

\[ g_\lambda = \dim\mathcal{N}(\mathbf{A}-\lambda\mathbf{I}). \]

The algebraic multiplicity \( a_\lambda \) is the multiplicity of \( \lambda \) as a root of the characteristic polynomial. The fundamental obstruction to diagonalization is:

\[ \mathbf{A} \text{ is diagonalizable over } \mathbb{C} \quad\Longleftrightarrow\quad \sum_\lambda g_\lambda=n \quad\Longleftrightarrow\quad g_\lambda=a_\lambda \text{ for every } \lambda. \]

If \( g_\lambda<a_\lambda \), ordinary eigenvectors are insufficient. The missing basis vectors are supplied by generalized eigenvectors, which belong to higher null spaces of powers of \( \mathbf{A}-\lambda\mathbf{I} \).

flowchart TD
  A["Repeated eigenvalue lambda"] --> B["Compute eigenspace Ker of A-lambda I"]
  B --> C["Geometric multiplicity g_lambda"]
  C --> D{"Is g_lambda equal to \nalgebraic multiplicity \na_lambda?"}
  D -->|yes| E["Enough eigenvectors: \ndiagonal modal block"]
  D -->|no| F["Need generalized eigenvectors"]
  F --> G["Build chains using powers of A-lambda I"]
  G --> H["Jordan blocks"]
  

For an eigenvalue \( \lambda \), define \( \mathbf{N}_\lambda=\mathbf{A}-\lambda\mathbf{I} \). A nonzero vector \( \mathbf{v} \) is a generalized eigenvector of rank \( k \) if

\[ \mathbf{N}_\lambda^k\mathbf{v}=\mathbf{0}, \qquad \mathbf{N}_\lambda^{k-1}\mathbf{v}\ne\mathbf{0}. \]

The generalized eigenspace associated with \( \lambda \) is

\[ \mathcal{G}_\lambda = \mathcal{N}\left((\mathbf{A}-\lambda\mathbf{I})^{a_\lambda}\right). \]

Over \( \mathbb{C} \), the total space decomposes as a direct sum of generalized eigenspaces:

\[ \mathbb{C}^n = \bigoplus_\lambda \mathcal{G}_\lambda, \qquad \dim\mathcal{G}_\lambda=a_\lambda. \]

The sequence of nullities \( d_k=\dim\mathcal{N}(\mathbf{N}_\lambda^k) \) reveals the Jordan-block structure. The increment \( d_k-d_{k-1} \) equals the number of Jordan chains of length at least \( k \) associated with \( \lambda \).

\[ d_k-d_{k-1} = \#\left\{\text{Jordan blocks for }\lambda\text{ having size at least }k\right\}. \]

This formula is important in control because it shows that repeated poles are not fully described by their numerical location. The size of each chain affects the internal coordinate coupling inside the modal representation.

A Jordan block of size \( m \) associated with \( \lambda \) is

\[ \mathbf{J}_m(\lambda)= \begin{bmatrix} \lambda & 1 & 0 & \cdots & 0 \\ 0 & \lambda & 1 & \cdots & 0 \\ 0 & 0 & \lambda & \ddots & \vdots \\ \vdots & \vdots & \ddots & \ddots & 1 \\ 0 & 0 & \cdots & 0 & \lambda \end{bmatrix} = \lambda\mathbf{I}_m+\mathbf{S}_m. \]

The shift matrix \( \mathbf{S}_m \) is nilpotent:

\[ \mathbf{S}_m^m=\mathbf{0}, \qquad \mathbf{S}_m^q\ne\mathbf{0}\quad\text{for}\quad 0\le q<m. \]

The nilpotent part encodes the coupling among generalized modal coordinates. A diagonal block is the special case \( m=1 \), where no generalized eigenvectors beyond the eigenvector are needed.

For a full Jordan matrix,

\[ \mathbf{J} = \operatorname{diag} \left(\mathbf{J}_{m_1}(\lambda_1), \mathbf{J}_{m_2}(\lambda_2),\dots, \mathbf{J}_{m_s}(\lambda_s)\right). \]

If a nonsingular matrix \( \mathbf{T} \) is formed from a complete set of Jordan chains, then

\[ \mathbf{A}\mathbf{T}=\mathbf{T}\mathbf{J}, \qquad \mathbf{J}=\mathbf{T}^{-1}\mathbf{A}\mathbf{T}. \]

A Jordan chain of length \( m \) for eigenvalue \( \lambda \) is an ordered set \( \mathbf{v}_1,\mathbf{v}_2,\dots,\mathbf{v}_m \) satisfying

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

Equivalently,

\[ \mathbf{A}\mathbf{v}_1=\lambda\mathbf{v}_1, \qquad \mathbf{A}\mathbf{v}_i=\lambda\mathbf{v}_i+\mathbf{v}_{i-1}, \quad i=2,\dots,m. \]

Let \( \mathbf{T}_\lambda = [\mathbf{v}_1\ \mathbf{v}_2\ \cdots\ \mathbf{v}_m] \). Multiplying \( \mathbf{A} \) by these columns gives

\[ \mathbf{A}\mathbf{T}_\lambda = [\lambda\mathbf{v}_1\ \lambda\mathbf{v}_2+\mathbf{v}_1\ \cdots\ \lambda\mathbf{v}_m+\mathbf{v}_{m-1}] = \mathbf{T}_\lambda\mathbf{J}_m(\lambda). \]

This proves that a Jordan chain produces a Jordan block in the transformed coordinates. If chains for all eigenvalues are concatenated into \( \mathbf{T} \), then the same identity holds blockwise: \( \mathbf{A}\mathbf{T}=\mathbf{T}\mathbf{J} \).

Linear independence of a chain. Suppose

\[ \alpha_1\mathbf{v}_1+\alpha_2\mathbf{v}_2+\cdots+ \alpha_m\mathbf{v}_m=\mathbf{0}. \]

Apply \( \mathbf{N}_\lambda^{m-1} \). Since \( \mathbf{N}_\lambda^{m-1}\mathbf{v}_m=\mathbf{v}_1 \) and lower chain vectors are annihilated, we get \( \alpha_m\mathbf{v}_1=\mathbf{0} \), hence \( \alpha_m=0 \). Repeating with decreasing powers of \( \mathbf{N}_\lambda \) gives \( \alpha_{m-1}=\cdots=\alpha_1=0 \). Therefore, every Jordan chain is linearly independent.

In exact symbolic work, the Jordan structure for a fixed eigenvalue \( \lambda \) can be inferred from the nested spaces

\[ \mathcal{N}(\mathbf{N}_\lambda) \subseteq \mathcal{N}(\mathbf{N}_\lambda^2) \subseteq \cdots \subseteq \mathcal{N}(\mathbf{N}_\lambda^{a_\lambda}). \]

Vectors that enter the null space only at higher powers become the tail vectors of Jordan chains. If \( \mathbf{v}_m\in\mathcal{N}(\mathbf{N}_\lambda^m) \) but \( \mathbf{v}_m\notin\mathcal{N}(\mathbf{N}_\lambda^{m-1}) \), then define

\[ \mathbf{v}_{m-1}=\mathbf{N}_\lambda\mathbf{v}_m, \quad \mathbf{v}_{m-2}=\mathbf{N}_\lambda^2\mathbf{v}_m, \quad \dots, \quad \mathbf{v}_1=\mathbf{N}_\lambda^{m-1}\mathbf{v}_m. \]

In numerical control computations, explicit Jordan form is usually avoided for ill-conditioned matrices. Repeated or nearly repeated eigenvalues make Jordan chains highly sensitive. For theoretical analysis, however, Jordan chains are indispensable because they explain the exact internal structure of repeated modes.

flowchart TD
  A["Choose eigenvalue lambda"] --> B["Set N = A - lambda I"]
  B --> C["Compute nullities of N, N^2, ..., N^a"]
  C --> D["Infer number and sizes of chains"]
  D --> E["Choose tail vectors in higher null spaces"]
  E --> F["Generate chain by repeated multiplication by N"]
  F --> G["Assemble T from all chains"]
  G --> H["Compute J = T^-1 A T"]
        

For the homogeneous LTI state equation \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x} \), introduce modal coordinates \( \mathbf{x}=\mathbf{T}\mathbf{z} \). If \( \mathbf{J}=\mathbf{T}^{-1}\mathbf{A}\mathbf{T} \), then

\[ \dot{\mathbf{z}}=\mathbf{J}\mathbf{z}, \qquad \mathbf{z}(t)=e^{\mathbf{J}t}\mathbf{z}(0). \]

For one Jordan block, \( \mathbf{J}_m(\lambda)=\lambda\mathbf{I}_m+\mathbf{S}_m \). Because \( \lambda\mathbf{I}_m \) commutes with \( \mathbf{S}_m \),

\[ e^{\mathbf{J}_m(\lambda)t} = e^{\lambda t}e^{\mathbf{S}_m t} = e^{\lambda t} \sum_{q=0}^{m-1}\frac{t^q}{q!}\mathbf{S}_m^q. \]

Thus a nontrivial Jordan block produces polynomial factors multiplying the exponential mode. For \( m=3 \),

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

Stability for continuous-time LTI systems still depends on the real parts of eigenvalues, but Jordan block size matters on the imaginary axis. If \( \operatorname{Re}(\lambda)<0 \), the polynomial factor is dominated by exponential decay. If \( \operatorname{Re}(\lambda)=0 \) and \( m>1 \), polynomial growth prevents bounded internal motion.

Consider

\[ \mathbf{A}= \begin{bmatrix} 2 & 1 & 0 & 0 \\ 0 & 2 & 1 & 0 \\ 0 & 0 & 2 & 0 \\ 0 & 0 & 0 & -1 \end{bmatrix}. \]

For \( \lambda=2 \),

\[ \mathbf{N}=\mathbf{A}-2\mathbf{I}= \begin{bmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & -3 \end{bmatrix}. \]

The nullities are

\[ \dim\mathcal{N}(\mathbf{N})=1,\quad \dim\mathcal{N}(\mathbf{N}^2)=2,\quad \dim\mathcal{N}(\mathbf{N}^3)=3. \]

Therefore, there is one Jordan chain of length three for \( \lambda=2 \). Choose

\[ \mathbf{v}_3= \begin{bmatrix}0\\0\\1\\0\end{bmatrix}, \quad \mathbf{v}_2=\mathbf{N}\mathbf{v}_3= \begin{bmatrix}0\\1\\0\\0\end{bmatrix}, \quad \mathbf{v}_1=\mathbf{N}\mathbf{v}_2= \begin{bmatrix}1\\0\\0\\0\end{bmatrix}. \]

Then

\[ \mathbf{N}\mathbf{v}_1=\mathbf{0},\qquad \mathbf{N}\mathbf{v}_2=\mathbf{v}_1,\qquad \mathbf{N}\mathbf{v}_3=\mathbf{v}_2. \]

Adding the eigenvector \( \mathbf{w}=[0\ 0\ 0\ 1]^T \) for \( \lambda=-1 \) gives \( \mathbf{T}=[\mathbf{v}_1\ \mathbf{v}_2\ \mathbf{v}_3\ \mathbf{w}] \), and here \( \mathbf{T}=\mathbf{I} \). Hence the displayed matrix is already in Jordan form.

The following implementations use the same matrix from the worked example. They verify the Jordan-chain equations and show how the generalized eigenspace grows through powers of \( \mathbf{A}-\lambda\mathbf{I} \).

8.1 Python Implementation

File: Chapter18_Lesson1.py

Python libraries: SymPy is used for exact symbolic linear algebra; NumPy is included as the standard numerical array library for extensions. In control courses, students often combine these with scipy.linalg and python-control.

# Chapter18_Lesson1.py
# Jordan blocks and generalized eigenvectors for a state-space matrix.
# Required libraries:
#   sympy  : exact symbolic linear algebra
#   numpy  : numerical arrays if students want to extend the example
#
# Install:
#   pip install sympy numpy

import sympy as sp


def nullity(M: sp.Matrix) -> int:
    """Return dim Ker(M)."""
    return M.shape[1] - M.rank()


def print_vector(name: str, v: sp.Matrix) -> None:
    print(f"{name} =")
    sp.print_latex(v)
    print(v)


def main() -> None:
    # A contains one Jordan block of size 3 at lambda=2 and one scalar block at lambda=-1.
    A = sp.Matrix([
        [2, 1, 0, 0],
        [0, 2, 1, 0],
        [0, 0, 2, 0],
        [0, 0, 0, -1],
    ])

    lam = sp.Integer(2)
    n = A.rows
    I = sp.eye(n)
    N = A - lam * I

    print("A =")
    sp.pprint(A)
    print("\nN = A - lambda I =")
    sp.pprint(N)

    print("\nGrowth of generalized eigenspaces Ker((A-lambda I)^k):")
    for k in range(1, 5):
        Nk = N**k
        print(f"k={k}: rank={Nk.rank()}, nullity={nullity(Nk)}")

    # A Jordan chain of length 3 for lambda=2:
    # (A-lambda I)v1 = 0
    # (A-lambda I)v2 = v1
    # (A-lambda I)v3 = v2
    v3 = sp.Matrix([0, 0, 1, 0])
    v2 = N * v3
    v1 = N * v2

    print("\nJordan chain for lambda=2:")
    print_vector("v1", v1)
    print_vector("v2", v2)
    print_vector("v3", v3)

    print("\nChain verification:")
    print("N*v1 =", N * v1)
    print("N*v2 =", N * v2)
    print("N*v3 =", N * v3)

    # Add eigenvector for lambda=-1 to obtain a complete basis.
    w = sp.Matrix([0, 0, 0, 1])
    T = sp.Matrix.hstack(v1, v2, v3, w)
    J = T.inv() * A * T

    print("\nTransformation matrix T = [v1 v2 v3 w]:")
    sp.pprint(T)
    print("\nJ = T^{-1} A T:")
    sp.pprint(J)

    # Exponential of the 3x3 Jordan block J3 = lambda I + S, where S^3=0.
    t = sp.symbols("t", real=True)
    S = sp.Matrix([
        [0, 1, 0],
        [0, 0, 1],
        [0, 0, 0],
    ])
    exp_J3 = sp.exp(lam * t) * (sp.eye(3) + t * S + (t**2 / 2) * (S**2))

    print("\nexp(J3*t) for the size-3 Jordan block:")
    sp.pprint(exp_J3)


if __name__ == "__main__":
    main()

      

8.2 C++ Implementation

File: Chapter18_Lesson1.cpp

The C++ version is written from scratch to emphasize the chain equations. For larger control applications, common linear-algebra libraries include Eigen, Armadillo, Blaze, and LAPACK bindings.

// Chapter18_Lesson1.cpp
// Scratch verification of a Jordan chain for a 4x4 state matrix.
// Compile:
//   g++ -std=c++17 Chapter18_Lesson1.cpp -o Chapter18_Lesson1
// Run:
//   ./Chapter18_Lesson1

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

using Vector = std::vector<double>;
using Matrix = std::vector<std::vector<double>>;

Vector matVec(const Matrix& A, const Vector& x) {
    const int n = static_cast<int>(A.size());
    Vector y(n, 0.0);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < static_cast<int>(x.size()); ++j) {
            y[i] += A[i][j] * x[j];
        }
    }
    return y;
}

Matrix subtractLambdaI(Matrix A, double lambda) {
    for (int i = 0; i < static_cast<int>(A.size()); ++i) {
        A[i][i] -= lambda;
    }
    return A;
}

double norm2(const Vector& x) {
    double s = 0.0;
    for (double xi : x) {
        s += xi * xi;
    }
    return std::sqrt(s);
}

Vector subtract(const Vector& a, const Vector& b) {
    Vector c(a.size(), 0.0);
    for (int i = 0; i < static_cast<int>(a.size()); ++i) {
        c[i] = a[i] - b[i];
    }
    return c;
}

void printVector(const std::string& name, const Vector& x) {
    std::cout << name << " = [";
    for (int i = 0; i < static_cast<int>(x.size()); ++i) {
        std::cout << std::setw(8) << x[i];
        if (i + 1 < static_cast<int>(x.size())) {
            std::cout << ", ";
        }
    }
    std::cout << "]^T\n";
}

int main() {
    Matrix A = {
        {2, 1, 0, 0},
        {0, 2, 1, 0},
        {0, 0, 2, 0},
        {0, 0, 0, -1}
    };

    const double lambda = 2.0;
    Matrix N = subtractLambdaI(A, lambda);

    // Choose the highest vector in the length-3 chain.
    Vector v3 = {0, 0, 1, 0};
    Vector v2 = matVec(N, v3);
    Vector v1 = matVec(N, v2);

    std::cout << "Jordan chain for lambda = 2\n";
    printVector("v1", v1);
    printVector("v2", v2);
    printVector("v3", v3);

    Vector Nv1 = matVec(N, v1);
    Vector Nv2 = matVec(N, v2);
    Vector Nv3 = matVec(N, v3);

    std::cout << "\nVerification:\n";
    printVector("N*v1", Nv1);
    printVector("N*v2", Nv2);
    printVector("N*v3", Nv3);

    std::cout << "\nResidual norms:\n";
    std::cout << "||N*v1||_2       = " << norm2(Nv1) << "\n";
    std::cout << "||N*v2 - v1||_2  = " << norm2(subtract(Nv2, v1)) << "\n";
    std::cout << "||N*v3 - v2||_2  = " << norm2(subtract(Nv3, v2)) << "\n";

    std::cout << "\nInterpretation: columns [v1 v2 v3] generate one Jordan block of size 3.\n";
    return 0;
}

      

8.3 Java Implementation

File: Chapter18_Lesson1.java

The Java version also verifies the chain equations from scratch. For larger numerical control projects, EJML and Apache Commons Math are common matrix libraries.

// Chapter18_Lesson1.java
// Scratch verification of generalized eigenvectors for a Jordan chain.
// Compile:
//   javac Chapter18_Lesson1.java
// Run:
//   java Chapter18_Lesson1

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

    static double[][] subtractLambdaI(double[][] A, double lambda) {
        int n = A.length;
        double[][] N = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                N[i][j] = A[i][j];
            }
            N[i][i] -= lambda;
        }
        return N;
    }

    static double norm2(double[] x) {
        double s = 0.0;
        for (double xi : x) {
            s += xi * xi;
        }
        return Math.sqrt(s);
    }

    static double[] subtract(double[] a, double[] b) {
        double[] c = new double[a.length];
        for (int i = 0; i < a.length; i++) {
            c[i] = a[i] - b[i];
        }
        return c;
    }

    static void printVector(String name, double[] x) {
        System.out.print(name + " = [");
        for (int i = 0; i < x.length; i++) {
            System.out.printf("%8.4f", x[i]);
            if (i + 1 < x.length) {
                System.out.print(", ");
            }
        }
        System.out.println("]^T");
    }

    public static void main(String[] args) {
        double[][] A = {
            {2, 1, 0, 0},
            {0, 2, 1, 0},
            {0, 0, 2, 0},
            {0, 0, 0, -1}
        };

        double lambda = 2.0;
        double[][] N = subtractLambdaI(A, lambda);

        double[] v3 = {0, 0, 1, 0};
        double[] v2 = matVec(N, v3);
        double[] v1 = matVec(N, v2);

        System.out.println("Jordan chain for lambda = 2");
        printVector("v1", v1);
        printVector("v2", v2);
        printVector("v3", v3);

        double[] Nv1 = matVec(N, v1);
        double[] Nv2 = matVec(N, v2);
        double[] Nv3 = matVec(N, v3);

        System.out.println("\nVerification:");
        printVector("N*v1", Nv1);
        printVector("N*v2", Nv2);
        printVector("N*v3", Nv3);

        System.out.println("\nResidual norms:");
        System.out.printf("||N*v1||_2      = %.6e%n", norm2(Nv1));
        System.out.printf("||N*v2 - v1||_2 = %.6e%n", norm2(subtract(Nv2, v1)));
        System.out.printf("||N*v3 - v2||_2 = %.6e%n", norm2(subtract(Nv3, v2)));
    }
}

      

8.4 MATLAB / Simulink Implementation

File: Chapter18_Lesson1.m

MATLAB has direct support for state-space models through ss(A,B,C,D). Symbolic Math Toolbox can compute exact Jordan forms, while Simulink can represent the same internal matrix using a State-Space block.

% Chapter18_Lesson1.m
% Jordan blocks and generalized eigenvectors for a state-space matrix.
% Toolboxes:
%   Symbolic Math Toolbox is useful for exact Jordan forms.
%   Control System Toolbox uses the same A-matrix in ss(A,B,C,D) models.

clear; clc;

A = [2 1 0 0;
     0 2 1 0;
     0 0 2 0;
     0 0 0 -1];

lambda = 2;
N = A - lambda * eye(4);

fprintf('Growth of generalized eigenspaces Ker((A-lambda I)^k):\n');
for k = 1:4
    Nk = N^k;
    fprintf('k=%d: rank=%d, nullity=%d\n', k, rank(Nk), size(A,1)-rank(Nk));
end

% Jordan chain:
% N*v1 = 0, N*v2 = v1, N*v3 = v2.
v3 = [0;0;1;0];
v2 = N*v3;
v1 = N*v2;

disp('Jordan chain for lambda=2:');
disp('v1 ='); disp(v1);
disp('v2 ='); disp(v2);
disp('v3 ='); disp(v3);

disp('Chain verification:');
disp('N*v1 ='); disp(N*v1);
disp('N*v2 ='); disp(N*v2);
disp('N*v3 ='); disp(N*v3);

w = [0;0;0;1];
T = [v1 v2 v3 w];
J = inv(T)*A*T;

disp('J = inv(T)*A*T:');
disp(J);

% Symbolic exponential of the size-3 Jordan block.
syms t
S = [0 1 0; 0 0 1; 0 0 0];
ExpJ3 = exp(lambda*t) * (eye(3) + t*S + (t^2/2)*S^2);
disp('exp(J3*t) =');
disp(ExpJ3);

% Simulink note:
% A state-space model with this internal matrix can be inserted using
% a State-Space block with A = A, B = chosen input matrix, C = chosen output
% matrix, and D = feedthrough matrix. The repeated pole at lambda=2 appears
% as a chain of integrator-like modal coordinates after x = T*z.

      

8.5 Wolfram Mathematica Implementation

File: Chapter18_Lesson1.nb

Mathematica can compute null spaces, ranks, matrix powers, and symbolic Jordan decompositions directly. The following code is also included in the downloadable notebook file.

(* Chapter18_Lesson1.nb *)
(* Wolfram Mathematica / Wolfram Language code for Jordan blocks and generalized eigenvectors. *)

ClearAll[lambda, t, A, Nmat, v1, v2, v3, w, Tmat, Jmat, S, ExpJ3];

A = {
  {2, 1, 0, 0},
  {0, 2, 1, 0},
  {0, 0, 2, 0},
  {0, 0, 0, -1}
};

lambda = 2;
Nmat = A - lambda IdentityMatrix[4];

Table[
  {"k" -> k, "Rank" -> MatrixRank[MatrixPower[Nmat, k]],
   "Nullity" -> 4 - MatrixRank[MatrixPower[Nmat, k]]},
  {k, 1, 4}
]

v3 = {0, 0, 1, 0};
v2 = Nmat.v3;
v1 = Nmat.v2;

{"v1" -> v1, "v2" -> v2, "v3" -> v3}

{"N.v1" -> Nmat.v1, "N.v2" -> Nmat.v2, "N.v3" -> Nmat.v3}

w = {0, 0, 0, 1};
Tmat = Transpose[{v1, v2, v3, w}];
Jmat = Inverse[Tmat].A.Tmat;
MatrixForm[Jmat]

S = {
  {0, 1, 0},
  {0, 0, 1},
  {0, 0, 0}
};

ExpJ3 = Exp[lambda t] (IdentityMatrix[3] + t S + (t^2/2) MatrixPower[S, 2]);
MatrixForm[ExpJ3]

(* Mathematica also provides JordanDecomposition[A] for symbolic matrices. *)
JordanDecomposition[A]

      

Problem 1 (Diagonalizability Test): Let \( \mathbf{A}\in\mathbb{C}^{n\times n} \) have eigenvalues \( \lambda_1,\dots,\lambda_s \). Prove that if \( \sum_{i=1}^s\dim\mathcal{N}(\mathbf{A}-\lambda_i\mathbf{I})=n \), then \( \mathbf{A} \) is diagonalizable.

Solution: For distinct eigenvalues, eigenvectors from different eigenspaces are linearly independent. Therefore, if the sum of eigenspace dimensions is \( n \), one can choose \( n \) linearly independent eigenvectors. Placing them as columns of \( \mathbf{T} \) gives \( \mathbf{A}\mathbf{T}=\mathbf{T}\mathbf{D} \), where \( \mathbf{D} \) is diagonal. Since \( \mathbf{T} \) is nonsingular, \( \mathbf{T}^{-1}\mathbf{A}\mathbf{T}=\mathbf{D} \).

Problem 2 (Nullity Increments): Suppose a repeated eigenvalue \( \lambda \) has Jordan block sizes \( 4,2,1 \). Compute \( d_k=\dim\mathcal{N}((\mathbf{A}-\lambda\mathbf{I})^k) \) for \( k=1,2,3,4 \).

Solution: A block of size \( m \) contributes \( \min(k,m) \) to \( d_k \). Therefore,

\[ d_1=1+1+1=3,\qquad d_2=2+2+1=5,\qquad d_3=3+2+1=6,\qquad d_4=4+2+1=7. \]

The increments are \( 3,2,1,1 \), meaning there are three chains of length at least one, two chains of length at least two, one chain of length at least three, and one chain of length at least four.

Problem 3 (Constructing a Chain): Let \( \mathbf{N}=\mathbf{A}-\lambda\mathbf{I} \) and suppose \( \mathbf{N}^3\mathbf{v}=\mathbf{0} \) but \( \mathbf{N}^2\mathbf{v}\ne\mathbf{0} \). Construct a Jordan chain and prove it has length three.

Solution: Define

\[ \mathbf{v}_3=\mathbf{v},\qquad \mathbf{v}_2=\mathbf{N}\mathbf{v},\qquad \mathbf{v}_1=\mathbf{N}^2\mathbf{v}. \]

Then \( \mathbf{v}_1\ne\mathbf{0} \) and \( \mathbf{N}\mathbf{v}_1=\mathbf{N}^3\mathbf{v}=\mathbf{0} \). Also \( \mathbf{N}\mathbf{v}_2=\mathbf{v}_1 \) and \( \mathbf{N}\mathbf{v}_3=\mathbf{v}_2 \). Hence \( \mathbf{v}_1,\mathbf{v}_2,\mathbf{v}_3 \) is a Jordan chain of length three.

Problem 4 (Exponential of a Jordan Block): Derive \( e^{\mathbf{J}_2(\lambda)t} \) for a size-two Jordan block.

Solution: Write \( \mathbf{J}_2(\lambda)=\lambda\mathbf{I}+\mathbf{S} \), where \( \mathbf{S}=\begin{bmatrix}0&1\\0&0\end{bmatrix} \) and \( \mathbf{S}^2=\mathbf{0} \). Therefore,

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

The term \( t e^{\lambda t} \) is the first polynomial-exponential term caused by a nontrivial Jordan block.

Problem 5 (Stability Implication): Consider \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x} \) with an eigenvalue \( \lambda=j\omega \) on the imaginary axis. Explain why a Jordan block of size \( m>1 \) prevents Lyapunov stability.

Solution: For \( \operatorname{Re}(\lambda)=0 \), the exponential factor \( e^{\lambda t} \) has constant magnitude. If the Jordan block has \( m>1 \), the exponential contains polynomial factors such as \( t \), \( t^2/2 \), and higher terms. These terms can grow without bound for initial conditions with components along higher generalized eigenvectors. Therefore the origin is not Lyapunov stable.

Jordan blocks arise when repeated eigenvalues do not provide enough ordinary eigenvectors. Generalized eigenvectors form chains that satisfy \( (\mathbf{A}-\lambda\mathbf{I})\mathbf{v}_i=\mathbf{v}_{i-1} \), and each chain produces one Jordan block. The nilpotent part of the block creates polynomial-exponential terms in \( e^{\mathbf{A}t} \), which is why Jordan block size has direct consequences for modal dynamics and stability analysis.