In Lesson 3 we learned that a matrix \( A \) is diagonalizable if it has a basis of eigenvectors. In Lesson 4 we learned that similarity \( A = PBP^{-1} \) represents the same linear map in different coordinates. The Jordan canonical form answers a natural question: when diagonalization fails, what is the simplest matrix similar to \(A\)?

The answer is the Jordan form \( J \), a block-diagonal matrix whose blocks are “almost diagonal.” It exists over \( \mathbb{C} \) for every square matrix, and its block sizes precisely quantify the obstruction to diagonalization.

flowchart TD
  A["Given matrix A (linear map)"] --> B["Compute eigenvalues (with multiplicities)"]
  B --> C["If enough eigenvectors exist"]
  C -->|yes| D["Diagonalize: A = P D P^{-1}"]
  C -->|no| E["Build generalized eigenvectors"]
  E --> F["Assemble Jordan blocks"]
  F --> G["Jordan form: A = P J P^{-1} (J block diagonal)"]
        

Throughout, we use only tools introduced so far: eigenvalues/eigenvectors, similarity, null spaces, and coordinate changes.

A Jordan block of size \( m \) associated with eigenvalue \( \lambda \in \mathbb{C} \) is

\[ J_m(\lambda) \;=\; \begin{bmatrix} \lambda & 1 & 0 & \cdots & 0 \\ 0 & \lambda & 1 & \cdots & 0 \\ \vdots & \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & \cdots & \lambda & 1 \\ 0 & 0 & \cdots & 0 & \lambda \end{bmatrix} \;=\; \lambda I_m + N_m, \]

where \( N_m \) is the nilpotent matrix with ones on the superdiagonal and zeros elsewhere. Note that \( N_m^m = 0 \) but \( N_m^{m-1} \neq 0 \).

A matrix \( J \) is in Jordan canonical form if it is block diagonal:

\[ J \;=\; \operatorname{diag}\!\big(J_{m_1}(\lambda_1),\; J_{m_2}(\lambda_2),\; \dots,\; J_{m_s}(\lambda_s)\big). \]

The key theorem is that every square matrix over \( \mathbb{C} \) is similar to such a \( J \).

For an eigenvalue \( \lambda \), the ordinary eigenspace is \( \ker(A-\lambda I) \). When diagonalization fails, we enlarge it to the generalized eigenspace:

\[ \mathcal{G}_{\lambda}(A) \;=\; \bigcup_{k \ge 1}\ker\!\big((A-\lambda I)^k\big). \]

A nonzero vector \( v \) is a generalized eigenvector of rank \( k \) if \( (A-\lambda I)^k v = 0 \) but \( (A-\lambda I)^{k-1} v \neq 0 \).

A Jordan chain (also called a generalized eigenvector chain) of length \( m \) for eigenvalue \( \lambda \) is a sequence \( v_1, v_2, \dots, v_m \) such that:

\[ (A-\lambda I)v_1 = 0,\quad (A-\lambda I)v_2 = v_1,\quad \dots,\quad (A-\lambda I)v_m = v_{m-1}. \]

In the basis \( \{v_1,\dots,v_m\} \), the restriction of \( A \) to the span of the chain is represented by \( J_m(\lambda) \).

We present the central structure theorem in a form consistent with the tools already introduced.

Theorem 1 (Stabilization of kernels). For fixed \( \lambda \), define

\[ d_k(\lambda) \;=\; \dim\ker\!\big((A-\lambda I)^k\big),\quad k=1,2,\dots \]

Then \( d_k(\lambda) \) is nondecreasing and stabilizes: there exists \( K \) such that \( d_{K}(\lambda)=d_{K+1}(\lambda)=\cdots \). Moreover, the stabilized subspace equals the generalized eigenspace: \( \mathcal{G}_{\lambda}(A)=\ker((A-\lambda I)^K) \).

Proof.

Because \( \ker((A-\lambda I)^k) \subseteq \ker((A-\lambda I)^{k+1}) \), dimensions are nondecreasing. Since dimensions are integers bounded above by \( n \), the sequence stabilizes. Let \( K \) be an index where it stabilizes. Then for all \( k \ge K \), \( \ker((A-\lambda I)^k)=\ker((A-\lambda I)^K) \), hence the union over all \( k \ge 1 \) equals \( \ker((A-\lambda I)^K) \). ■

Theorem 2 (Primary decomposition over distinct eigenvalues).

Suppose \( A \in \mathbb{C}^{n\times n} \) has distinct eigenvalues \( \lambda_1,\dots,\lambda_r \). Then the generalized eigenspaces form a direct sum decomposition:

\[ \mathbb{C}^n \;=\; \mathcal{G}_{\lambda_1}(A) \oplus \cdots \oplus \mathcal{G}_{\lambda_r}(A), \quad A\,\mathcal{G}_{\lambda_i}(A) \subseteq \mathcal{G}_{\lambda_i}(A). \]

Proof (outline with explicit polynomial projectors).

Let \( K_i \) satisfy \( \mathcal{G}_{\lambda_i}(A)=\ker((A-\lambda_i I)^{K_i}) \), and define the polynomial \( q_i(t)=\prod_{j\neq i}(t-\lambda_j)^{K_j} \). The polynomials \( q_i \) are pairwise coprime (distinct roots). By Bézout’s identity for coprime polynomials, there exist polynomials \( p_i(t) \) such that

\[ \sum_{i=1}^r p_i(t)\,q_i(t) \;=\; 1. \]

Substitute \( t=A \) to obtain \( \sum_{i=1}^r p_i(A)\,q_i(A)=I \). Each operator \( p_i(A)q_i(A) \) maps into \( \mathcal{G}_{\lambda_i}(A) \) because \( q_i(A) \) contains factors \( (A-\lambda_j I)^{K_j} \) for all \( j\neq i \), annihilating generalized eigenspaces of other eigenvalues. This yields a decomposition of any vector as a sum of components in each generalized eigenspace, and the coprimeness ensures the sum is direct. ■

Theorem 3 (Jordan canonical form over \( \mathbb{C} \)).

For every \( A \in \mathbb{C}^{n\times n} \), there exists an invertible \( P \) such that \( A = PJP^{-1} \) where \( J \) is in Jordan canonical form. The multiset of Jordan block sizes for each eigenvalue is unique up to permutation of blocks.

Interpretation of uniqueness. Similarity can reorder blocks, but cannot change how many blocks there are of each size for a given eigenvalue. These counts are similarity invariants.

Let \( \lambda \) be an eigenvalue of \( A \). The algebraic multiplicity \( a_\lambda \) is its multiplicity as a root of the characteristic polynomial. The geometric multiplicity \( g_\lambda \) is

\[ g_\lambda \;=\; \dim\ker(A-\lambda I). \]

In Jordan form, \( a_\lambda \) equals the total size (sum of sizes) of all Jordan blocks for \( \lambda \), while \( g_\lambda \) equals the number of Jordan blocks for \( \lambda \).

Theorem 4 (Diagonalizability criterion).

A matrix \( A \) is diagonalizable over \( \mathbb{C} \) if and only if, for every eigenvalue \( \lambda \), all Jordan blocks for \( \lambda \) have size \( 1 \). Equivalently, \( A \) is diagonalizable if and only if \( a_\lambda = g_\lambda \) for every eigenvalue \( \lambda \).

Proof.

If \( A \) is diagonalizable, then \( A = PDP^{-1} \) with diagonal \( D \), so its Jordan form has only \(1\times 1\) blocks. Conversely, if the Jordan form has only \(1\times 1\) blocks, then the Jordan form is diagonal, hence \(A\) is similar to a diagonal matrix and is diagonalizable. Finally, for a fixed \(\lambda\), each Jordan block contributes exactly one basis vector to \(\ker(A-\lambda I)\), so \(g_\lambda\) equals the number of blocks, while \(a_\lambda\) equals the sum of their sizes; equality holds iff every size is \(1\). ■

A highly practical invariant-based method determines Jordan block sizes without explicitly computing generalized eigenvectors first. Fix an eigenvalue \( \lambda \) and define \( d_k(\lambda)=\dim\ker((A-\lambda I)^k) \).

Theorem 5 (Block counts from nullities). Define increments

\[ b_k(\lambda) \;=\; d_k(\lambda) - d_{k-1}(\lambda),\quad d_0(\lambda)=0. \]

Then \( b_k(\lambda) \) equals the number of Jordan blocks for eigenvalue \( \lambda \) of size at least \( k \). Consequently, the number of blocks of size exactly \( k \) is \( b_k(\lambda) - b_{k+1}(\lambda) \).

Proof (idea via one Jordan block).

Consider a single Jordan block \( J_m(\lambda)=\lambda I + N_m \). Then \( (J_m(\lambda)-\lambda I)^k = N_m^k \). The nullity of \( N_m^k \) is \( \min(k,m) \) because \(N_m\) shifts basis vectors “down the chain” and kills the first \(k\) coordinates after \(k\) shifts. Thus, each block contributes \(1\) additional dimension to \( \ker((A-\lambda I)^k) \) for each \(k\) up to its size. Summing contributions over blocks gives that \(b_k\) counts how many blocks still contribute at step \(k\), i.e., blocks of size at least \(k\). ■

flowchart TD
  S["Fix eigenvalue lambda"] --> K1["Compute d1 = dim ker(A - lambda I)"]
  K1 --> K2["Compute d2 = dim ker((A - lambda I)^2)"]
  K2 --> K3["Continue until dk stabilizes"]
  K3 --> B1["bk = dk - d(k-1)"]
  B1 --> C1["bk = # blocks with size >= k"]
  C1 --> C2["# blocks of size exactly k = bk - b(k+1)"]
  C2 --> J["Assemble Jordan block sizes for lambda"]
        

Each Jordan block is a sum of a scalar multiple of the identity plus a nilpotent matrix: \( J_m(\lambda) = \lambda I_m + N_m \). This separates “pure scaling/rotation” from “chain coupling.”

Action on the chain basis. Let the standard basis in a Jordan block be \(e_1,\dots,e_m\). Then:

\[ J_m(\lambda)e_1 = \lambda e_1,\quad J_m(\lambda)e_i = \lambda e_i + e_{i-1}\;\; (i=2,\dots,m). \]

The extra \( e_{i-1} \) term is exactly what prevents diagonalization: coordinates within a block are not independent under the linear map; they “feed” into each other along the chain.

Polynomial functions of a Jordan block. Since \(I_m\) and \(N_m\) commute, we can expand powers:

\[ J_m(\lambda)^k \;=\; (\lambda I_m + N_m)^k \;=\; \sum_{i=0}^{m-1} \binom{k}{i}\lambda^{\,k-i}N_m^{\,i}, \quad k \ge 0, \]

because \(N_m^m=0\) truncates the binomial expansion. This formula is a purely linear-algebraic preview of why repeated eigenvalues with nontrivial Jordan blocks introduce polynomial factors when evaluating matrix functions (a theme revisited later when computing analytic expressions for matrix exponentials).

Minimal polynomial from Jordan structure. The minimal polynomial of \(A\) is invariant under similarity and can be read directly from Jordan block sizes:

\[ m_A(t) \;=\; \prod_{\lambda \in \sigma(A)} (t-\lambda)^{s_\lambda}, \]

where \(s_\lambda\) is the size of the largest Jordan block associated with \(\lambda\), and \(\sigma(A)\) denotes the spectrum (set of eigenvalues). In particular, \(A\) is diagonalizable iff \(s_\lambda=1\) for all \(\lambda\).

Similarity corresponds to changing bases: if \(A\) represents a linear transformation \(T\) in one basis, then \(J\) represents the same transformation in a “Jordan basis.” Concretely:

\[ A = PJP^{-1} \quad \Longleftrightarrow \quad J = P^{-1}AP, \]

where columns of \(P\) are the Jordan chain vectors grouped by eigenvalue. In the Jordan coordinates \( z = P^{-1}x \), the linear map becomes the simplest possible within its similarity class: block-diagonal, with each block “as diagonal as possible.”

From a control-engineering mathematical viewpoint, this is valuable because many properties depend only on the similarity class of matrices (i.e., properties invariant under coordinate changes). Jordan form packages these invariants into an interpretable normal form.

Exact Jordan decomposition is fundamentally algebraic (requires exact eigenvalues and exact null spaces of powers of \(A-\lambda I\)). Therefore, it is naturally supported in symbolic systems (SymPy, MATLAB Symbolic, Mathematica).

In floating-point arithmetic, Jordan structure is highly sensitive: tiny perturbations can split repeated eigenvalues or change block sizes. As a result, robust numeric software usually prefers the Schur form or real canonical forms for computation. In this course, we use Jordan form primarily as a theoretical tool and as a symbolic computation tool when exact matrices are given.

We demonstrate a consistent workflow on a small matrix with a nontrivial Jordan block:

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

This matrix has eigenvalues \(2\) (algebraic multiplicity \(2\)) and \(3\) (algebraic multiplicity \(1\)). For \(\lambda=2\), the eigenspace is one-dimensional, so \(A\) is not diagonalizable; its Jordan form has a \(2\times2\) Jordan block at \(\lambda=2\).

10.1 Python (SymPy + NumPy)

Recommended libraries for control-oriented linear algebra pipelines: NumPy/SciPy (numeric linear algebra), SymPy (symbolic exact decompositions), and (later) python-control for control-specific modeling.

import sympy as sp

A = sp.Matrix([[2, 1, 0],
               [0, 2, 0],
               [0, 0, 3]])

# Exact Jordan decomposition: A = P*J*P^{-1}
P, J = A.jordan_form()   # SymPy returns (P, J) with J Jordan, columns of P a Jordan basis

print("J =")
sp.pprint(J)
print("\nCheck A == P*J*P^{-1}:", A == P*J*P.inv())

# Inspect generalized eigenspace dimensions for lambda=2
lam = sp.Integer(2)
d1 = (A - lam*sp.eye(3)).nullspace()
d2 = ((A - lam*sp.eye(3))**2).nullspace()
print("\nnullity k=1:", len(d1), "nullity k=2:", len(d2))

# Demonstrate the power formula for the Jordan block J2(2)
J2 = sp.Matrix([[2, 1],
                [0, 2]])
k = sp.Symbol('k', integer=True, nonnegative=True)
# Closed form for J2^k: [[2^k, k*2^(k-1)], [0, 2^k]]
J2k = sp.Matrix([[2**k, k*2**(k-1)],
                 [0, 2**k]])
print("\nJ2^k formula verified for k=5:", (J2**5) == J2k.subs(k, 5))

10.2 C++ (Eigen) — Building a Jordan Chain by Solving Linear Systems

In C++ control stacks, Eigen is the dominant linear algebra library. It does not provide a Jordan decomposition routine, but you can still build Jordan chains for small exact/structured cases by solving the chain equations \((A-\lambda I)v_1=0\), \((A-\lambda I)v_2=v_1\), etc.

#include <iostream>
#include <Eigen/Dense>

int main() {
  Eigen::Matrix3d A;
  A << 2, 1, 0,
       0, 2, 0,
       0, 0, 3;

  const double lambda = 2.0;
  Eigen::Matrix3d M = A - lambda * Eigen::Matrix3d::Identity();

  // Step 1: find an eigenvector v1 in ker(M).
  // For this simple triangular example, we can pick v1 = [1,0,0]^T (check M*v1 = 0).
  Eigen::Vector3d v1(1, 0, 0);
  std::cout << "M*v1 = " << (M*v1).transpose() << std::endl;

  // Step 2: find a generalized eigenvector v2 solving M*v2 = v1.
  // Solve linear system in least squares / exact solve when consistent.
  Eigen::Vector3d v2 = M.fullPivLu().solve(v1);
  std::cout << "v2 = " << v2.transpose() << std::endl;
  std::cout << "M*v2 = " << (M*v2).transpose() << " (should equal v1)" << std::endl;

  // For the eigenvalue 3, an eigenvector is e3 = [0,0,1]^T.
  Eigen::Vector3d w(0, 0, 1);

  // Assemble P = [v1 v2 w] and compute J = P^{-1} A P
  Eigen::Matrix3d P;
  P.col(0) = v1;
  P.col(1) = v2;
  P.col(2) = w;

  Eigen::Matrix3d J = P.inverse() * A * P;
  std::cout << "\nJ = \n" << J << std::endl;

  return 0;
}

Note: in floating-point arithmetic, the computed \(J\) may have small numerical noise. The conceptual goal is to illustrate the chain construction and the similarity transform \(J=P^{-1}AP\).

10.3 Java (EJML) — Eigenvalues and Chain Solve

In Java, EJML is a common scientific linear algebra library. Like Eigen, it does not provide a Jordan form function, but you can solve the chain equations when you know \(\lambda\) and the structure is simple.

import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;
import org.ejml.dense.row.linsol.LinearSolverFactory_DDRM;
import org.ejml.interfaces.linsol.LinearSolverDense;

public class JordanChainDemo {
  public static void main(String[] args) {
    DMatrixRMaj A = new DMatrixRMaj(new double[][]{
      {2, 1, 0},
      {0, 2, 0},
      {0, 0, 3}
    });

    double lambda = 2.0;

    DMatrixRMaj I = CommonOps_DDRM.identity(3);
    DMatrixRMaj M = new DMatrixRMaj(3,3);
    CommonOps_DDRM.scale(lambda, I, M);
    CommonOps_DDRM.subtract(A, M, M); // M = A - lambda I

    // v1 = [1,0,0]^T is an eigenvector for lambda=2 in this example
    DMatrixRMaj v1 = new DMatrixRMaj(new double[][]{ {1},{0},{0} });

    // Solve M v2 = v1
    DMatrixRMaj v2 = new DMatrixRMaj(3,1);
    LinearSolverDense<DMatrixRMaj> solver = LinearSolverFactory_DDRM.lu(3);
    solver.setA(M);
    solver.solve(v1, v2);

    // w = [0,0,1]^T eigenvector for lambda=3
    DMatrixRMaj w = new DMatrixRMaj(new double[][]{ {0},{0},{1} });

    // P = [v1 v2 w]
    DMatrixRMaj P = new DMatrixRMaj(3,3);
    P.set(0,0, v1.get(0,0)); P.set(1,0, v1.get(1,0)); P.set(2,0, v1.get(2,0));
    P.set(0,1, v2.get(0,0)); P.set(1,1, v2.get(1,0)); P.set(2,1, v2.get(2,0));
    P.set(0,2, w.get(0,0));  P.set(1,2, w.get(1,0));  P.set(2,2, w.get(2,0));

    // J = P^{-1} A P
    DMatrixRMaj Pinv = new DMatrixRMaj(3,3);
    CommonOps_DDRM.invert(P, Pinv);

    DMatrixRMaj AP = new DMatrixRMaj(3,3);
    CommonOps_DDRM.mult(A, P, AP);

    DMatrixRMaj J = new DMatrixRMaj(3,3);
    CommonOps_DDRM.mult(Pinv, AP, J);

    System.out.println("J = ");
    J.print();
  }
}

Practical note: the generic type angle brackets in the EJML solver interface appear inside the code block and are HTML-escaped to preserve correct rendering on your site.

10.4 MATLAB (Symbolic) and Simulink Coordinate-Change Skeleton

MATLAB’s Symbolic Math Toolbox supports Jordan decomposition directly. This is the recommended approach for exact Jordan structure.

A = sym([2 1 0;
         0 2 0;
         0 0 3]);

% Jordan decomposition: A = P*J*inv(P)
[P,J] = jordan(A);

disp('J ='); disp(J);
disp('Check A == P*J*inv(P):'); disp(isequal(A, P*J*inv(P)));

% Kernel-dimension method for lambda=2
lam = sym(2);
d1 = null(A - lam*eye(3));          % basis for ker(A-lam I)
d2 = null((A - lam*eye(3))^2);      % basis for ker((A-lam I)^2)
fprintf('nullity k=1: %d\n', size(d1,2));
fprintf('nullity k=2: %d\n', size(d2,2));

Simulink (conceptual coordinate-change wiring). To represent a similarity transform in block diagrams (without invoking state-space models yet), you can implement \(z=P^{-1}x\) and \(x=Pz\) using two “Matrix Gain” blocks and a signal line between them:

• Block 1 (Matrix Gain): gain = \(P^{-1}\), input \(x\), output \(z\).
• Block 2 (Matrix Gain): gain = \(P\), input \(z\), output \(\hat{x}\).
• Verify \(\hat{x}=x\) for test signals (numerically) when \(P\) is invertible.

This provides a practical mental model: Jordan form is simply the matrix representation of the same linear map in a carefully chosen coordinate system.

10.5 Wolfram Mathematica (Exact Jordan Decomposition)

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

{P, J} = JordanDecomposition[A];

Print["J = "];
Print[J];

Print["Check A == P.J.Inverse[P]: "];
Print[A == Simplify[P.J.Inverse[P]]];

(* Kernel dimensions for lambda = 2 *)
lam = 2;
M = A - lam IdentityMatrix[3];
d1 = NullSpace[M];
d2 = NullSpace[MatrixPower[M, 2]];
Print["nullity k=1: ", Length[d1]];
Print["nullity k=2: ", Length[d2]];

The problems below are designed to reinforce (i) identification of Jordan structure via kernels, (ii) construction of chains, and (iii) interpreting Jordan blocks via the nilpotent part.

Problem 1 (Jordan form from a triangular matrix). Let

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

(a) Find the eigenvalues and their algebraic multiplicities.
(b) Compute \(g_\lambda=\dim\ker(A-\lambda I)\) for each eigenvalue.
(c) Determine the Jordan block sizes for each eigenvalue.

Solution.

(a) Since \(A\) is upper triangular, eigenvalues are diagonal entries: \(4\) (twice) and \(1\) (once). Thus \(a_4=2\), \(a_1=1\).
(b) For \(\lambda=4\),

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

Solving \((A-4I)x=0\) gives \(x_2=0\) and \(x_3=0\), with \(x_1\) free, so \(g_4=1\). For \(\lambda=1\), \(A-I\) has rank \(2\) and \(\ker(A-I)\) is one-dimensional, so \(g_1=1\).
(c) For \(\lambda=4\), algebraic multiplicity \(2\) but geometric multiplicity \(1\) implies one Jordan block of size \(2\): \(J_2(4)\). For \(\lambda=1\), a single \(1\times1\) block. Hence \(J=\operatorname{diag}(J_2(4),[1])\).

Problem 2 (Kernel-dimension method). Suppose for eigenvalue \(\lambda\) you compute \(d_1(\lambda)=2\), \(d_2(\lambda)=4\), \(d_3(\lambda)=5\), and stabilization occurs at \(d_3\). Determine the multiset of Jordan block sizes for \(\lambda\).

Solution.

Compute increments: \(b_1=d_1-d_0=2\), \(b_2=d_2-d_1=2\), \(b_3=d_3-d_2=1\), and \(b_4=0\) after stabilization. Thus:

• \(b_1=2\): there are 2 blocks of size at least 1 (total number of blocks is 2).
• \(b_2=2\): there are 2 blocks of size at least 2 (so both blocks have size at least 2).
• \(b_3=1\): there is 1 block of size at least 3 (exactly one block reaches size 3).

Therefore, block sizes are \(3\) and \(2\) (sum \(=5=d_3\), matching the generalized eigenspace dimension).

Problem 3 (Diagonalizability test via multiplicities). Prove: if an eigenvalue \(\lambda\) of \(A\) satisfies \(g_\lambda=a_\lambda\), then all Jordan blocks associated with \(\lambda\) have size \(1\).

Solution.

In Jordan form, \(a_\lambda\) equals the sum of sizes of the Jordan blocks for \(\lambda\), while \(g_\lambda\) equals the number of those blocks. For positive integers \(m_1,\dots,m_s\) (block sizes), we have \(\sum_{i=1}^s m_i \ge s\), with equality iff every \(m_i=1\). If \(g_\lambda=a_\lambda\), then \(s=\sum_i m_i\), so equality forces every block size \(m_i=1\). ■

Problem 4 (Power of a Jordan block). Let \(J_3(\lambda)=\lambda I_3 + N_3\). Show that

\[ J_3(\lambda)^k = \lambda^k I_3 + k\lambda^{k-1}N_3 + \binom{k}{2}\lambda^{k-2}N_3^2, \quad k \ge 0. \]

Solution.

Since \(I_3\) and \(N_3\) commute, use the binomial theorem: \((\lambda I_3+N_3)^k=\sum_{i=0}^k \binom{k}{i}\lambda^{k-i}N_3^i\). But \(N_3^3=0\), so all terms with \(i \ge 3\) vanish, leaving exactly \(i=0,1,2\) terms as stated. ■

Problem 5 (Minimal polynomial from Jordan sizes). Suppose \(A\) has eigenvalues \(\lambda_1,\lambda_2\). For \(\lambda_1\), the largest Jordan block has size \(4\); for \(\lambda_2\), the largest block has size \(2\). Determine \(m_A(t)\) and justify.

Solution.

In Jordan form, a block \(J_m(\lambda)\) satisfies \((J_m(\lambda)-\lambda I)^m=0\) but not for smaller powers. Hence, to annihilate all blocks for \(\lambda_1\), the exponent must be at least \(4\), and similarly exponent at least \(2\) for \(\lambda_2\). The minimal polynomial is the least-degree monic polynomial that annihilates the whole Jordan form, so:

\[ m_A(t) = (t-\lambda_1)^4 (t-\lambda_2)^2. \]

Similarity invariance ensures the same minimal polynomial applies to \(A\). ■

We defined Jordan blocks and generalized eigenvectors, proved the stabilization and decomposition properties of generalized eigenspaces, and stated the Jordan canonical form theorem over \( \mathbb{C} \). We connected Jordan structure to algebraic/geometric multiplicities, derived how block sizes are recovered from kernel dimensions of \((A-\lambda I)^k\), and interpreted each block as \(\lambda I + N\) with a nilpotent coupling matrix. Computationally, we emphasized symbolic tools for exact Jordan form and demonstrated chain construction and similarity transforms across Python, C++, Java, MATLAB/Simulink, and Mathematica.