In the previous lessons, we saw that a diagonal modal representation is possible when the state matrix has enough linearly independent eigenvectors. Repeated eigenvalues are the first major obstruction: repeated eigenvalues may still be harmless, but they may also produce a non-diagonalizable matrix. For an LTI state equation

\[ \dot{\mathbf{x} }(t)=\mathbf{A}\mathbf{x}(t),\qquad \mathbf{x}(0)=\mathbf{x}_0, \]

the diagonalizable case separates the response into independent modes. The non-diagonalizable case still has modal structure, but each defective repeated eigenvalue produces a Jordan chain and therefore terms such as \(t e^{\lambda t}\), \(t^2 e^{\lambda t}\), and higher polynomial factors.

flowchart TD
  A["Start with state matrix A"] --> B["Compute characteristic polynomial"]
  B --> C["Find repeated eigenvalues"]
  C --> D["For each repeated eigenvalue: compare algebraic and geometric multiplicity"]
  D --> E{"Enough eigenvectors?"}
  E -->|yes| F["Diagonalizable modal form"]
  E -->|no| G["Defective eigenvalue"]
  G --> H["Build generalized eigenvectors"]
  H --> I["Jordan chains"]
  I --> J["Polynomial times exponential response"]
        

The key message is that multiplicity of a root of the characteristic polynomial is not enough to determine modal behavior. One must also know the dimension of the corresponding eigenspace.

Let \(\mathbf{A}\in\mathbb{C}^{n\times n}\). Its characteristic polynomial is

\[ p_{\mathbf{A} }(s)=\det(s\mathbf{I}-\mathbf{A}) =\prod_{j=1}^{q}(s-\lambda_j)^{a_j}. \]

The exponent \(a_j\) is the algebraic multiplicity of \(\lambda_j\). The corresponding eigenspace is

\[ \mathcal{E}_{\lambda_j} =\ker(\mathbf{A}-\lambda_j\mathbf{I}), \qquad g_j=\dim\mathcal{E}_{\lambda_j} =n-\operatorname{rank}(\mathbf{A}-\lambda_j\mathbf{I}). \]

The integer \(g_j\) is the geometric multiplicity. It satisfies

\[ 1\le g_j\le a_j. \]

The eigenvalue \(\lambda_j\) is called defective when \(g_j<a_j\). The matrix \(\mathbf{A}\) is diagonalizable over \(\mathbb{C}\) if and only if

\[ \sum_{j=1}^{q}g_j=n, \qquad\text{equivalently}\qquad g_j=a_j\;\text{for every eigenvalue }\lambda_j. \]

Example 1: repeated but diagonalizable.

\[ \mathbf{A}_1= \begin{bmatrix} 2&0\\ 0&2 \end{bmatrix} =2\mathbf{I}, \qquad p_{\mathbf{A}_1}(s)=(s-2)^2. \]

Here \(a=2\) and \(g=\dim\ker(\mathbf{A}_1-2\mathbf{I})=2\). Although the eigenvalue is repeated, the matrix is diagonalizable.

Example 2: repeated and non-diagonalizable.

\[ \mathbf{A}_2= \begin{bmatrix} 2&1\\ 0&2 \end{bmatrix}, \qquad p_{\mathbf{A}_2}(s)=(s-2)^2. \]

However,

\[ \mathbf{A}_2-2\mathbf{I} = \begin{bmatrix} 0&1\\ 0&0 \end{bmatrix}, \qquad \ker(\mathbf{A}_2-2\mathbf{I}) = \operatorname{span} \left\{ \begin{bmatrix}1\\0\end{bmatrix} \right\}. \]

Thus \(a=2\) but \(g=1\). There is only one independent eigenvector, so the matrix cannot be diagonalized.

The following theorem is central in modal analysis.

Theorem. Suppose \(\mathbf{A}\in\mathbb{C}^{n\times n}\) has distinct eigenvalues \(\lambda_1,\dots,\lambda_q\), with algebraic multiplicities \(a_1,\dots,a_q\) and geometric multiplicities \(g_1,\dots,g_q\). Then \(\mathbf{A}\) is diagonalizable if and only if \(g_j=a_j\) for every \(j\).

Proof.

If \(\mathbf{A}\) is diagonalizable, there exists a basis of \(\mathbb{C}^n\) consisting only of eigenvectors of \(\mathbf{A}\). For a fixed eigenvalue \(\lambda_j\), the number of basis vectors belonging to its eigenspace must equal the size of its diagonal block in the diagonal representation. That size is exactly the algebraic multiplicity \(a_j\). Hence \(g_j=a_j\).

Conversely, suppose \(g_j=a_j\) for every eigenvalue. Eigenspaces associated with distinct eigenvalues are linearly independent. Therefore the total number of linearly independent eigenvectors is

\[ \sum_{j=1}^{q}g_j=\sum_{j=1}^{q}a_j=n. \]

Hence these eigenvectors form a basis of the state space. Taking them as columns of a nonsingular matrix \(\mathbf{T}\) gives

\[ \mathbf{T}^{-1}\mathbf{A}\mathbf{T} = \operatorname{diag}(\lambda_1,\dots,\lambda_n), \]

so \(\mathbf{A}\) is diagonalizable.

When \(g_\lambda<a_\lambda\), ordinary eigenvectors do not provide a complete coordinate system. We then introduce generalized eigenvectors. A nonzero vector \(\mathbf{v}\) is a generalized eigenvector of rank \(r\) associated with \(\lambda\) if

\[ (\mathbf{A}-\lambda\mathbf{I})^r\mathbf{v}=\mathbf{0}, \qquad (\mathbf{A}-\lambda\mathbf{I})^{r-1}\mathbf{v}\ne\mathbf{0}. \]

A Jordan chain of length \(m\) 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}_{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. If these vectors are placed in the order \(\mathbf{T}=[\mathbf{v}_1\;\mathbf{v}_2\;\cdots\;\mathbf{v}_m]\), then the corresponding block of \(\mathbf{T}^{-1}\mathbf{A}\mathbf{T}\) is

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

where \(\mathbf{N}_m\) is nilpotent:

\[ \mathbf{N}_m^m=\mathbf{0}, \qquad \mathbf{N}_m^{m-1}\ne\mathbf{0}. \]

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\),

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

Because \(\mathbf{N}_m^m=\mathbf{0}\), the exponential series terminates:

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

Therefore,

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

For a two-state defective block,

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

Thus if \(\mathbf{z}(0)=[z_1(0)\;z_2(0)]^T\), then

\[ \begin{aligned} z_2(t)&=e^{\lambda t}z_2(0),\\ z_1(t)&=e^{\lambda t}\left(z_1(0)+t z_2(0)\right). \end{aligned} \]

The second coordinate drives the first coordinate through the nilpotent coupling. This coupling is the source of the \(t e^{\lambda t}\) term.

flowchart TD
  Z3["z3 initial component"] -->|"multiplies t"| Z2["z2 response"]
  Z2 -->|"multiplies t"| Z1["z1 response"]
  L["same eigenvalue lambda"] --> Z1
  L --> Z2
  L --> Z3
  Z1 --> R["terms: exp(lambda t), t exp(lambda t), t^2 exp(lambda t)"]
  Z2 --> R
  Z3 --> R
        

Jordan blocks refine the eigenvalue stability test by showing what happens on the imaginary axis. For a continuous-time LTI system, polynomial factors cannot overcome exponential decay when the real part of the eigenvalue is strictly negative:

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

Hence any Jordan block associated with a strictly stable eigenvalue decays to zero. However, if \(\operatorname{Re}(\lambda)=0\) and the Jordan block has size greater than one, polynomial factors remain:

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

Choosing an initial condition with nonzero second component gives a term proportional to \(t e^{j\omega t}\), whose magnitude grows without bound. Therefore, a repeated imaginary-axis eigenvalue is not automatically unstable, but a defective Jordan block on the imaginary axis is unstable in the Lyapunov sense.

For continuous-time systems:

\[ \begin{cases} \operatorname{Re}(\lambda_j)<0 \text{ for all }j &\Rightarrow \text{asymptotically stable},\\ \operatorname{Re}(\lambda_j)\le 0 \text{ for all }j \text{ and imaginary-axis blocks are size }1 &\Rightarrow \begin{aligned}[t] &\text{stable but not}\\ &\text{asymptotically stable,} \end{aligned}\\ \text{some }\operatorname{Re}(\lambda_j)>0 \text{ or defective imaginary-axis block exists} &\Rightarrow \text{unstable}. \end{cases} \]

Suppose \(\mathbf{A}\) is similar to a Jordan matrix \(\mathbf{J}\):

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

Then the transformed dynamics are

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

In a diagonal modal form, each modal coordinate evolves independently. In Jordan form, coordinates within the same Jordan chain are coupled by the nilpotent superdiagonal entries. For a three-state 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}. \]

Therefore,

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

This is the precise mathematical source of generalized modal response. A longer Jordan chain produces a higher-degree polynomial multiplying the same exponential mode.

Exact Jordan form is valuable theoretically but often poor numerically. Repeated eigenvalues and defective eigenstructures are highly sensitive to perturbations. A tiny perturbation may split one repeated eigenvalue into several nearby distinct eigenvalues. Therefore, modern numerical software usually avoids computing exact Jordan form for floating-point matrices.

In practice:

• MATLAB uses robust algorithms for expm, and jordan is mainly symbolic.
• Python users typically rely on numpy.linalg, scipy.linalg.expm, and python-control for state-space analysis.
• C++ implementations commonly use Eigen, Armadillo, or custom small-matrix routines in embedded control applications.
• Java implementations can use Apache Commons Math, EJML, or custom routines for small state dimensions.
• Wolfram Mathematica can compute exact Jordan decompositions symbolically and matrix exponentials analytically.

For theoretical control analysis, Jordan form explains the structure of repeated modes. For numerical simulation and controller implementation, matrix exponential algorithms, Schur decompositions, and direct ODE solvers are usually more reliable.

The Python script below constructs a Jordan block, computes the exact Jordan-block exponential, estimates geometric multiplicity using the singular values of \(\mathbf{A}-\lambda\mathbf{I}\), and compares the closed form with scipy.linalg.expm when SciPy is available.

File: Chapter18_Lesson4.py

"""
Chapter18_Lesson4.py
Repeated eigenvalues and non-diagonalizable systems.

This script studies a 3 x 3 Jordan block
    J = lambda I + N,
where N has ones on the superdiagonal and N^3 = 0.
It compares the closed-form Jordan exponential with scipy.linalg.expm
when SciPy is available.
"""

from __future__ import annotations

import math
from typing import Iterable

import numpy as np


def nilpotent_shift(size: int) -> np.ndarray:
    """Return the nilpotent shift matrix with ones on the superdiagonal."""
    if size <= 0:
        raise ValueError("size must be positive")
    n_mat = np.zeros((size, size), dtype=float)
    for i in range(size - 1):
        n_mat[i, i + 1] = 1.0
    return n_mat


def jordan_block(lambda_value: float, size: int) -> np.ndarray:
    """Return J_size(lambda) = lambda I + N."""
    return lambda_value * np.eye(size) + nilpotent_shift(size)


def exp_jordan_block(lambda_value: float, size: int, t: float) -> np.ndarray:
    """
    Compute exp(J t) exactly for a Jordan block.

    exp((lambda I + N)t) = exp(lambda t) sum_{k=0}^{m-1} (t^k/k!) N^k.
    """
    n_mat = nilpotent_shift(size)
    result = np.eye(size)
    power = np.eye(size)
    for k in range(1, size):
        power = power @ n_mat
        result = result + (t ** k / math.factorial(k)) * power
    return math.exp(lambda_value * t) * result


def geometric_multiplicity(a_mat: np.ndarray, lambda_value: float, tol: float = 1e-10) -> int:
    """Estimate dim ker(A - lambda I) from singular values."""
    shifted = a_mat - lambda_value * np.eye(a_mat.shape[0])
    s_vals = np.linalg.svd(shifted, compute_uv=False)
    rank = int(np.sum(s_vals > tol))
    return a_mat.shape[0] - rank


def simulate(lambda_value: float = -0.4, size: int = 3, x0: Iterable[float] = (1.0, -2.0, 1.5)) -> None:
    """Print a response table and a diagnostic comparison with scipy.linalg.expm."""
    a_mat = jordan_block(lambda_value, size)
    x0_vec = np.asarray(list(x0), dtype=float)

    print("A =")
    print(a_mat)
    print(f"algebraic multiplicity of lambda={lambda_value}: {size}")
    print(f"estimated geometric multiplicity: {geometric_multiplicity(a_mat, lambda_value)}")
    print()

    try:
        from scipy.linalg import expm
    except Exception:
        expm = None

    print("t        x1(t)        x2(t)        x3(t)        max_abs_error_vs_expm")
    for t in np.linspace(0.0, 8.0, 9):
        phi_closed = exp_jordan_block(lambda_value, size, float(t))
        x_closed = phi_closed @ x0_vec

        if expm is not None:
            x_scipy = expm(a_mat * t) @ x0_vec
            err = np.max(np.abs(x_closed - x_scipy))
        else:
            err = float("nan")

        print(f"{t:4.1f}  {x_closed[0]:11.6f} {x_closed[1]:11.6f} {x_closed[2]:11.6f}   {err:12.3e}")


if __name__ == "__main__":
    simulate()
      

The C++ example is self-contained and uses the exact closed form for a three-state Jordan block. In larger control software, the same idea may be implemented using Eigen or Armadillo.

File: Chapter18_Lesson4.cpp

/*
Chapter18_Lesson4.cpp
Repeated eigenvalues and non-diagonalizable systems.

Self-contained computation for a 3 x 3 Jordan block
J = lambda I + N:
exp(J t) = exp(lambda t) [[1, t, t^2/2],
                          [0, 1, t    ],
                          [0, 0, 1    ]].
Compile:
    g++ -std=c++17 -O2 Chapter18_Lesson4.cpp -o Chapter18_Lesson4
*/

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

using Vec3 = std::array<double, 3>;
using Mat3 = std::array<std::array<double, 3>, 3>;

Mat3 expJordan3(double lambda, double t) {
    const double e = std::exp(lambda * t);
    return { {
        { {e, e * t, e * t * t / 2.0} },
        { {0.0, e, e * t} },
        { {0.0, 0.0, e} }
    } };
}

Vec3 multiply(const Mat3& a, const Vec3& x) {
    Vec3 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;
}

int main() {
    const double lambda = -0.4;
    const Vec3 x0{ {1.0, -2.0, 1.5} };

    std::cout << "Chapter 18 Lesson 4: Jordan response for a defective repeated eigenvalue\n";
    std::cout << "A = [[lambda,1,0],[0,lambda,1],[0,0,lambda]], lambda = "
              << lambda << "\n\n";

    std::cout << std::setw(6) << "t"
              << std::setw(14) << "x1(t)"
              << std::setw(14) << "x2(t)"
              << std::setw(14) << "x3(t)" << "\n";

    for (int k = 0; k <= 8; ++k) {
        const double t = static_cast<double>(k);
        Mat3 phi = expJordan3(lambda, t);
        Vec3 x = multiply(phi, x0);

        std::cout << std::fixed << std::setprecision(6)
                  << std::setw(6) << t
                  << std::setw(14) << x[0]
                  << std::setw(14) << x[1]
                  << std::setw(14) << x[2] << "\n";
    }

    return 0;
}
      

Java can use numerical libraries such as EJML or Apache Commons Math. For this lesson, the implementation is written from scratch so that the Jordan-block formula is explicit.

File: Chapter18_Lesson4.java

/*
Chapter18_Lesson4.java
Repeated eigenvalues and non-diagonalizable systems.

Self-contained computation for a 3 x 3 Jordan block.
Compile:
    javac Chapter18_Lesson4.java
Run:
    java Chapter18_Lesson4
*/

public class Chapter18_Lesson4 {
    static double[][] expJordan3(double lambda, double t) {
        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[] multiply(double[][] a, double[] x) {
        double[] y = new double[3];
        for (int i = 0; i < 3; i++) {
            y[i] = 0.0;
            for (int j = 0; j < 3; j++) {
                y[i] += a[i][j] * x[j];
            }
        }
        return y;
    }

    public static void main(String[] args) {
        double lambda = -0.4;
        double[] x0 = {1.0, -2.0, 1.5};

        System.out.println("Chapter 18 Lesson 4: Jordan response for a defective repeated eigenvalue");
        System.out.println("A = [[lambda,1,0],[0,lambda,1],[0,0,lambda]], lambda = " + lambda);
        System.out.println();
        System.out.printf("%6s%14s%14s%14s%n", "t", "x1(t)", "x2(t)", "x3(t)");

        for (int k = 0; k <= 8; k++) {
            double t = (double) k;
            double[][] phi = expJordan3(lambda, t);
            double[] x = multiply(phi, x0);
            System.out.printf("%6.1f%14.6f%14.6f%14.6f%n", t, x[0], x[1], x[2]);
        }
    }
}
      

MATLAB directly supports matrix exponentials with expm. The script below compares expm with the exact Jordan formula and optionally creates a Simulink state-space block if Simulink is available.

File: Chapter18_Lesson4.m

% Chapter18_Lesson4.m
% Repeated eigenvalues and non-diagonalizable systems.
% This script compares MATLAB expm with the exact Jordan-block expression.

clear; clc; close all;

lambda = -0.4;
A = [lambda 1 0;
     0 lambda 1;
     0 0 lambda];

x0 = [1; -2; 1.5];

% Algebraic multiplicity is 3. Geometric multiplicity is dim null(A-lambda I).
geom_mult = size(A,1) - rank(A - lambda * eye(3));
fprintf('Geometric multiplicity of lambda = %.2f is %d\n', lambda, geom_mult);

t_grid = linspace(0, 8, 200);
X_expm = zeros(3, numel(t_grid));
X_jordan = zeros(3, numel(t_grid));

for k = 1:numel(t_grid)
    t = t_grid(k);

    Phi_expm = expm(A * t);
    Phi_jordan = exp(lambda * t) * [1, t, t^2/2;
                                    0, 1, t;
                                    0, 0, 1];

    X_expm(:, k) = Phi_expm * x0;
    X_jordan(:, k) = Phi_jordan * x0;
end

fprintf('Maximum difference between expm and Jordan formula: %.3e\n', ...
    max(abs(X_expm(:) - X_jordan(:))));

figure;
plot(t_grid, X_jordan(1,:), 'LineWidth', 1.5); hold on;
plot(t_grid, X_jordan(2,:), 'LineWidth', 1.5);
plot(t_grid, X_jordan(3,:), 'LineWidth', 1.5);
grid on;
xlabel('t');
ylabel('state components');
title('Response of a 3 x 3 Jordan block');
legend('x_1(t)', 'x_2(t)', 'x_3(t)', 'Location', 'best');

% Optional Simulink model construction, if Simulink is available.
% This builds a continuous State-Space block with the defective A matrix.
if exist('new_system', 'file') == 2
    mdl = 'Chapter18_Lesson4_Simulink';
    if ~bdIsLoaded(mdl)
        new_system(mdl);
    end
    open_system(mdl);
    add_block('simulink/Continuous/State-Space', [mdl '/Jordan State Space'], ...
        'A', mat2str(A), ...
        'B', mat2str(eye(3)), ...
        'C', mat2str(eye(3)), ...
        'D', mat2str(zeros(3)), ...
        'Position', [150 100 320 180]);
    save_system(mdl);
    fprintf('Optional Simulink model saved as %s.slx\n', mdl);
end
      

Mathematica can verify the Jordan-block exponential symbolically. The downloadable notebook file contains the following Wolfram Language commands.

File: Chapter18_Lesson4.nb

lambda = -0.4;
A = { {lambda, 1, 0}, {0, lambda, 1}, {0, 0, lambda} };
x0 = {1, -2, 1.5};

geomMult = Length[A] - MatrixRank[A - lambda IdentityMatrix[3]];
geomMult

PhiJordan[t_] := Exp[lambda t] { {1, t, t^2/2}, {0, 1, t}, {0, 0, 1} };
FullSimplify[MatrixExp[A t] - PhiJordan[t]]

x[t_] := PhiJordan[t].x0;
Table[{t, x[t]}, {t, 0, 8, 1}]

Plot[
  Evaluate[x[t]],
  {t, 0, 8},
  PlotLegends -> {"x1", "x2", "x3"},
  GridLines -> Automatic,
  PlotLabel -> "Jordan-block state response"
]
      

Problem 1 (Algebraic vs Geometric Multiplicity): Consider

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

Find the algebraic and geometric multiplicities of \(\lambda=3\). Is \(\mathbf{A}\) diagonalizable?

Solution:

The characteristic polynomial is \((s-3)^3\), so the algebraic multiplicity is \(a=3\). Next,

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

The rank is one, so

\[ g=\dim\ker(\mathbf{A}-3\mathbf{I})=3-1=2. \]

Since \(g=2<3=a\), the matrix is defective and therefore non-diagonalizable.

Problem 2 (Constructing a Jordan Chain): For

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

find a Jordan chain associated with \(\lambda=2\).

Solution:

We need \(\mathbf{v}_1\) satisfying \((\mathbf{A}-2\mathbf{I})\mathbf{v}_1=\mathbf{0}\). Since

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

one eigenvector is \(\mathbf{v}_1=[1\;0]^T\). A generalized eigenvector \(\mathbf{v}_2\) must satisfy

\[ (\mathbf{A}-2\mathbf{I})\mathbf{v}_2=\mathbf{v}_1. \]

Taking \(\mathbf{v}_2=[0\;1]^T\) gives \((\mathbf{A}-2\mathbf{I})\mathbf{v}_2=[1\;0]^T\). Thus

\[ \mathbf{v}_1= \begin{bmatrix}1\\0\end{bmatrix}, \qquad \mathbf{v}_2= \begin{bmatrix}0\\1\end{bmatrix} \]

is a Jordan chain.

Problem 3 (Jordan-Block Exponential): Derive \(e^{\mathbf{J}_3(\lambda)t}\) for

\[ \mathbf{J}_3(\lambda)= \begin{bmatrix} \lambda&1&0\\ 0&\lambda&1\\ 0&0&\lambda \end{bmatrix}. \]

Solution:

Write \(\mathbf{J}_3(\lambda)=\lambda\mathbf{I}+\mathbf{N}\), where

\[ \mathbf{N}= \begin{bmatrix} 0&1&0\\ 0&0&1\\ 0&0&0 \end{bmatrix}, \qquad \mathbf{N}^2= \begin{bmatrix} 0&0&1\\ 0&0&0\\ 0&0&0 \end{bmatrix}, \qquad \mathbf{N}^3=\mathbf{0}. \]

Therefore,

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

Problem 4 (Stability of a Defective Imaginary-Axis Mode): Consider

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

All eigenvalues are zero. Is the system \(\dot{\mathbf{x} }=\mathbf{A}\mathbf{x}\) stable?

Solution:

The matrix is already a Jordan block with \(\lambda=0\). Its exponential is

\[ e^{\mathbf{A}t} = \begin{bmatrix} 1&t\\ 0&1 \end{bmatrix}. \]

For initial condition \(\mathbf{x}(0)=[0\;1]^T\),

\[ \mathbf{x}(t)= \begin{bmatrix} t\\ 1 \end{bmatrix}. \]

The state grows without bound. Therefore, the system is unstable even though its only eigenvalue lies on the imaginary axis.

Problem 5 (Diagonalizable Repeated Eigenvalue): Let

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

Does the repeated eigenvalue \(\lambda=1\) make the system non-diagonalizable?

Solution:

No. The eigenvalue \(\lambda=1\) has algebraic multiplicity two. Its eigenspace is

\[ \ker(\mathbf{A}-\mathbf{I}) = \operatorname{span} \left\{ \begin{bmatrix}1\\0\\0\end{bmatrix}, \begin{bmatrix}0\\1\\0\end{bmatrix} \right\}. \]

Hence its geometric multiplicity is also two. Since the third eigenvalue has its own eigenvector, the matrix has three independent eigenvectors and is diagonalizable.

Repeated eigenvalues do not automatically imply non-diagonalizability. The decisive comparison is between algebraic multiplicity and geometric multiplicity. If every repeated eigenvalue has enough independent eigenvectors, the matrix is diagonalizable. If not, generalized eigenvectors are required, Jordan chains appear, and the state response contains polynomial factors multiplying exponential modes. These terms are essential for correctly interpreting transient behavior and stability, especially for repeated eigenvalues on the imaginary axis.