Wolfram Language & System Documentation Center

JordanDecomposition

yields the Jordan decomposition of a square matrix m. The result is a list {s,j} where s is a similarity matrix and j is the Jordan canonical form of m.

Details

The original matrix m is equal to s.j.Inverse[s]. »
The matrix m can be either numerical or symbolic.
The j matrix is called the Jordan normal form or Jordan canonical form.
The Jordan normal form of a matrix is block diagonal with eigenvalues appearing by multiplicity on the main diagonal. The first superdiagonal can contain ones where there are nontrivial Jordan blocks from multiple eigenvalues. All other elements are zero.
Each eigenvalue determines a block, and eigenvalues with multiplicity always appear together in the same block. They may be split into subblocks. A new subblock is indicated by not having a one above the eigenvalue, that is, in the position of the superdiagonal.
The length of a block is the algebraic multiplicity of the eigenvalue. The number of subblocks is the geometric multiplicity and is the same as the dimension of the subspace spanned by linearly independent eigenvectors for that eigenvalue. This subspace is called the eigenspace for its eigenvalue.
Each subblock is associated to a distinct eigenvector v from the eigenspace; taken together, these span that space. Subsequent vectors associated to a subblock are called generalized eigenvectors. For a matrix m and eigenvalue λ, the j^th such vector v_j is related to the true eigenvector of the subblock by the equation (m-λ imat)^j.v_j=v. Here imat is the identity matrix of the same size as m, and the exponent denotes the matrix power.
The Jordan normal form is unique up to ordering of blocks and ordering of subblocks within blocks. Reorderings correspond to changes in the similarity matrices.
When all eigenvalues have multiplicity 1, the Jordan normal form is the same up to ordering as the diagonal matrix comprised of those eigenvalues. This holds more generally when there are no ones on the superdiagonal, even if some eigenvalues have nontrivial multiplicity. In such cases, the similarity transformation is simply the transpose of the corresponding matrix of eigenvectors.
Square matrices m₁ and m₂ with the same dimensions are said to be similar if there is an invertible matrix s of the same dimension such that m₂=s.m₁.Inverse[s]. Similar matrices have the same Jordan normal form.

Examples

open all close all

Basic Examples (1)

Find the Jordan decomposition of a 3×3 matrix:

Wolfram Language code: JordanDecomposition[{{27, 48, 81}, {-6, 0, 0}, {1, 0, 3}}]

Format the results:

Wolfram Language code: Map[MatrixForm, %]

Scope (10)

Basic Uses (6)

Jordan decomposition of a machine-precision matrix:

Wolfram Language code: JordanDecomposition[{{-1.2, 2.7, 3.8}, {4.2, 4.4, 5.3}, {3.5, 7.6, 6.8}}]

Format the results:

Wolfram Language code: MatrixForm /@ %

Jordan decomposition of a complex matrix:

Wolfram Language code: {s, j} = JordanDecomposition[{{π, .3}, {I, 1 + 1.5 I}}];

Wolfram Language code: {s//MatrixForm, j//MatrixForm}

Jordan decomposition of an exact matrix with a deficient eigenspace:

Wolfram Language code:

m = {{-103, -191, -255}, {110, 190, 222}, {9, 9, 33}};
{s, j} = JordanDecomposition[m];

Wolfram Language code: MatrixForm /@ {s, j}

The one in the third column of indicates that the eigenspace corresponding to 48 is deficient:

Wolfram Language code: Eigensystem[m]

The third column of is therefore a generalized eigenvector where gives rather than :

Wolfram Language code: (m - 48 IdentityMatrix[3]).s[[All, 3]]

Check that the decomposition correctly recovers the input matrix:

Wolfram Language code: s.j.Inverse[s] - m

Jordan decomposition of an arbitrary-precision matrix:

Wolfram Language code: JordanDecomposition[RandomReal[4, {3, 3}, WorkingPrecision -> 20]]

Jordan decomposition of a symbolic matrix:

Wolfram Language code:

JordanDecomposition[(|       |       |
| :---- | :---- |
| a1, 1 | a1, 2 |
| a2, 1 | a2, 2 |⁠)]

The Jordan decomposition of large numerical matrices is computed efficiently:

Wolfram Language code: m = RandomReal[{0, 5}, {100, 100}];

Wolfram Language code: JordanDecomposition[m] ;//Timing

Special Matrices (4)

Jordan decomposition of sparse matrices:

Wolfram Language code: SparseArray[{{1, 1} -> 3.1, {1, 2} -> 2, {2, 3} -> 5, {3, 1} -> 3.9}, {3, 3}]

Wolfram Language code: MatrixForm /@ JordanDecomposition[%]

Wolfram Language code: SparseArray[Band[{1, 1}, {-1, -1}] -> {{{1, 2}, {2, 1}}}, {4, 4}]

Wolfram Language code: MatrixForm /@ JordanDecomposition[%]

Jordan decompositions of structured matrices:

Wolfram Language code: SymmetrizedArray[{{1, 1} -> 2.2, {1, 2} -> 1.1, {3, 2} -> 5.7}, {3, 3}, Symmetric[All]]

Wolfram Language code: MatrixForm /@ JordanDecomposition[%]

IdentityMatrix is a Jordan canonical form:

Wolfram Language code:

id = IdentityMatrix[4];
{s, j} = JordanDecomposition[id];

Wolfram Language code: j == id

The associated similarity matrix is a square root of the identity:

Wolfram Language code: s//MatrixForm

Wolfram Language code: s.s == id

Jordan decomposition of a HilbertMatrix:

Wolfram Language code: Map[MatrixForm, JordanDecomposition[HilbertMatrix[2]]]

Applications (13)

Generalized Eigenvectors and Diagonalizability (4)

For the matrix , interpret the columns of the matrix of the Jordan decomposition in terms of true eigenvectors and generalized eigenvectors:

Wolfram Language code:

m = (|   |   |    |    |
| - | - | -- | -- |
| 2 | 4 | -6 | 0  |
| 4 | 6 | -3 | -4 |
| 0 | 0 | 4  | 0  |
| 0 | 4 | -6 | 2  |);

Compute the Jordan decomposition:

Wolfram Language code:

{s, j} = JordanDecomposition[m];
MatrixForm  /@ {s, j}

Columns of for which there is no above the diagonal in the corresponding of —columns 1, 3 and 4—are true eigenvectors for which :

Wolfram Language code: Table[(m - Subscript[j, [[i, i]]]IdentityMatrix[4]).Subscript[s, [[All, i]]] == {0, 0, 0, 0}, {i, {1, 3, 4}}]

The remaining column is a generalized eigenvector for which :

Wolfram Language code: (m - Subscript[j, [[2, 2]]]IdentityMatrix[4]).Subscript[s, [[All, 2]]] == Subscript[s, [[All, 1]]]

Show that the following matrix only has a single eigenvector, but it has a complete chain of generalized eigenvectors that form a basis for $TemplateBox[{}, Reals]^4$ :

Wolfram Language code:

m = (⁠|      |     |      |     |
| ---- | --- | ---- | --- |
| -223 | 602 | -145 | 215 |
| -75  | 218 | -25  | 51  |
| 13   | -66 | 99   | 19  |
| -186 | 368 | -110 | 242 |⁠);

Eigensystem shows 84 is an eigenvalue of multiplicity 4 that has just one independent eigenvector:

Wolfram Language code: Eigensystem[m]

The first column of the matrix of JordanDecomposition is the one eigenvector found:

Wolfram Language code:

{s, j} = JordanDecomposition[m];
MatrixForm  /@ {s, j}

The remaining columns are a chain for which :

Wolfram Language code: Table[(m - 84IdentityMatrix[4]).Subscript[s, [[All, i]]] == Subscript[s, [[All, i - 1]]], {i, 2, 4}]

Since has an empty NullSpace, its columns form a basis for $TemplateBox[{}, Reals]^4$ :

Wolfram Language code: NullSpace[s]

A square matrix has a complete set of eigenvectors, and thus is diagonalizable, iff its matrix is diagonal:

Wolfram Language code:

DiagonalizableQ[m_ ? MatrixQ /; Apply[Equal, Dimensions[m]]] := Module[{s, j}, 
	{s, j} = JordanDecomposition[m];
	DiagonalMatrixQ[j]
	];

Test if a particular matrix is diagonalizable:

Wolfram Language code: DiagonalizableQ[{{0, 1}, {0, 0}}]

Confirm using DiagonalizableMatrixQ:

Wolfram Language code: DiagonalizableMatrixQ[{{0, 1}, {0, 0}}]

Estimate the probability that a 4×4 matrix of ones and zeros will be diagonalizable:

Wolfram Language code:

Block[{trials = 100, count = 0}, 
	Do[If[DiagonalizableQ[RandomInteger[1, {4, 4}]], count++], {trials}];
	N[count / trials]
	]

An × matrix is nilpotent if for some :

Wolfram Language code:

q = {{0, 1}, {0, 0}};
MatrixPower[q, 2]

Consider a non-diagonalizable matrix :

Wolfram Language code: m = {{2, 4, -6, 0}, {4, 6, -3, -4}, {0, 0, 4, 0}, {0, 4, -6, 2}};

Wolfram Language code: DiagonalizableMatrixQ[m]

can be written as a sum of a diagonalizable matrix and a nilpotent matrix using JordanDecomposition:

Wolfram Language code: {s, j} = JordanDecomposition[m]

Let be the matrix formed from and the diagonal part of :

Wolfram Language code: d = s.DiagonalMatrix[Diagonal[j]].Inverse[s]

Let be the matrix formed from and the superdiagonal part of :

Wolfram Language code: q = s.DiagonalMatrix[Diagonal[j, 1], 1].Inverse[s]

Then is the sum of and :

Wolfram Language code: m == d + q

The matrix is diagonalizable:

Wolfram Language code: DiagonalizableMatrixQ[d]

The matrix is nilpotent:

Wolfram Language code: With[{n = Length[q]}, MatrixPower[q, n] == ConstantArray[0, {n, n}]]

Moreover, the matrices and commute:

Wolfram Language code: d.q == q.d

Similar Matrices (5)

A matrix m₁ and a random invertible matrix s give a similar matrix m₂:

Wolfram Language code:

SeedRandom[1234];
m1 = {{9, -7, 3}, {12, -10, 3}, {16, -16, 1}};
s = RandomInteger[{-2, 2}, {3, 3}];
m2 = s.m1.Inverse[s];
MatrixForm /@ {m1, m2}

The Jordan decomposition of m₁:

Wolfram Language code: {s1, j1} = JordanDecomposition[m1]

The Jordan decomposition of m₂:

Wolfram Language code: {s2, j2} = JordanDecomposition[m2]

Similar matrices share their Jordan form:

Wolfram Language code: j1 == j2

Find the eigenvectors of m₁:

Wolfram Language code: vecs = Eigenvectors[m1]

Since the eigenvalues are all distinct, the eigenvectors agree with the transpose of the similarity transform up to ordering and multiplication by constants:

Wolfram Language code: Transpose[s1]

For a diagonalizable matrix, the Jordan decomposition directly gives a diagonalization as . Apply this to diagonalize the matrix :

Wolfram Language code: m = {{9, -7, 3}, {12, -10, 3}, {16, -16, 1}};

Compute the Jordan decomposition:

Wolfram Language code:

{s, j} = JordanDecomposition[m];
MatrixForm /@ {s, j}

Confirm the diagonalization:

Wolfram Language code: m == s.j.Inverse[s]

Let be the linear transformation whose standard matrix is given by the matrix . Find a basis for $TemplateBox[{}, Reals]^4$ with the property that the representation of in that basis is diagonal:

Wolfram Language code:

a = (|    |    |   |   |
| -- | -- | - | - |
| -6 | 4  | 0 | 9 |
| -3 | 0  | 1 | 6 |
| -1 | -2 | 1 | 0 |
| -4 | 4  | 0 | 7 |);

Find the Jordan decomposition of :

Wolfram Language code: {s, j} = JordanDecomposition[a]

Let consist of the eigenvectors, i.e the columns of . As converts from -coordinates to standard coordinates, its inverse converts in the reverse direction:

Wolfram Language code: sInv = Inverse[s]

Thus is given by , which is diagonal:

Wolfram Language code: sInv . a .s//MatrixForm

Note that this is simply the diagonal matrix whose entries are the eigenvalues:

Wolfram Language code: % == DiagonalMatrix[Eigenvalues[a]]

A real-valued symmetric matrix is orthogonally diagonalizable as , with diagonal and real valued and orthogonal. Verify that the following matrix is symmetric and then diagonalize it:

Wolfram Language code: (h = {{1, 4, -2}, {4, 5, -3}, {-2, -3, 2}})//MatrixForm

Wolfram Language code: Transpose[h] == h

Compute the Jordan decomposition:

Wolfram Language code: {s, j} = JordanDecomposition[h];

Let equal :

Wolfram Language code: (d = j)//MatrixForm

Let equal after normalizing its columns:

Wolfram Language code: (o = Transpose[Normalize /@ Transpose[s]]//FullSimplify)//MatrixForm

Confirm that is indeed orthogonal:

Wolfram Language code: OrthogonalMatrixQ[o]

Verify that :

Wolfram Language code: h == o.d.Transpose[o]//FullSimplify

A matrix is called normal if . Normal matrices are the most general kind of matrix that can be diagonalized by a unitary transformation. All real symmetric matrices are normal because both sides of the equality are simply :

Wolfram Language code:

TensorExpand[ConjugateTranspose[h].h == h.ConjugateTranspose[h] == h.h, Assumptions -> h∈Matrices[{dim, dim}, Reals, Symmetric[{1, 2}]]]

Show that the following matrix is normal, then diagonalize it:

Wolfram Language code: (n = {{3, -1}, {1, 3}})//MatrixForm

Wolfram Language code: n.ConjugateTranspose[n] == ConjugateTranspose[n].n

Confirm using NormalMatrixQ:

Wolfram Language code: NormalMatrixQ[n]

Compute the Jordan decomposition:

Wolfram Language code: {s, j} = JordanDecomposition[n];

Unlike a real symmetric matrix, the diagonal matrix is complex valued:

Wolfram Language code: (d = j)//MatrixForm

Normalizing the columns of gives a unitary matrix:

Wolfram Language code: (u = Transpose[Normalize /@ Transpose[s]]//FullSimplify)//MatrixForm

Wolfram Language code: UnitaryMatrixQ[u]

Confirm the diagonalization :

Wolfram Language code: n == u.d.ConjugateTranspose[u]

Matrix Functions and Dynamical Systems (4)

Use the Jordan decomposition to compute and for the following matrix :

Wolfram Language code:

m = (⁠|   |   |    |    |
| - | - | -- | -- |
| 2 | 4 | -6 | 0  |
| 4 | 6 | -3 | -4 |
| 0 | 0 | 4  | 0  |
| 0 | 4 | -6 | 2  |⁠);

Compute the and matrices:

Wolfram Language code:

{s, j} = JordanDecomposition[m];
MatrixForm /@ {s, j}

Confirm the identity :

Wolfram Language code: m == s.j.Inverse[s]

Then $m^k=s.j.TemplateBox[{s}, Inverse].s.j.TemplateBox[{s}, Inverse].....s.j.TemplateBox[{s}, Inverse]=s.j^k.TemplateBox[{s}, Inverse]$ . Since is upper triangular and nearly diagonal, the diagonal entries are raised to the power , and the entry becomes :

Wolfram Language code: MatrixPower[j, k]//MatrixForm

Thus, the expression for is:

Wolfram Language code: s.%.Inverse[s]//FullSimplify//MatrixForm

Confirm with direct computation by MatrixPower:

Wolfram Language code: MatrixPower[m, k] == %//FullSimplify

Applying the power series for the exponential, the diagonal entries obviously become , and the off-diagonal term is merely a re-indexed exponential sum. Thus, it too becomes :

Wolfram Language code: Sum[(MatrixPower[j, k]/k!), {k, 0, ∞}]//MatrixForm

Thus, the expression for is:

Wolfram Language code: s.%.Inverse[s]//FullSimplify//MatrixForm

Confirm using a direction computation by MatrixExp:

Wolfram Language code: MatrixExp[m] == %

Confirm the formula for a Jordan matrix consisting of a single chain for the following matrix and the functions , and :

Wolfram Language code: (j = {{π / 3, 1, 0}, {0, π / 3, 1}, {0, 0, π / 3}})//MatrixForm

First compute the formula for :

Wolfram Language code: {{Sin[π / 3], Sin'[π / 3], Sin''[π / 3] / 2}, {0, Sin[π / 3], Sin'[π / 3]}, {0, 0, Sin[π / 3]}}//MatrixForm

Verify the computation using MatrixFunction:

Wolfram Language code: % == MatrixFunction[Sin, j]

The computation for is analogous:

Wolfram Language code: {{Log[π / 3], Log'[π / 3], Log''[π / 3] / 2}, {0, Log[π / 3], Log'[π / 3]}, {0, 0, Log[π / 3]}}//MatrixForm

MatrixFunction confirms the result:

Wolfram Language code: % == MatrixFunction[Log, j]

As has a parameter, it is necessary to use D instead of Derivative and substitute in :

Wolfram Language code:

{{Exp[t x], D[Exp[t x], x], (D[Exp[t x], {x, 2}]/2!)}, {0, Exp[t x], D[Exp[t x], x]}, {0, 0, Exp[t x]} } /. x -> π / 3//MatrixForm

Again, MatrixFunction confirms the result when is entered using Function:

Wolfram Language code: % == MatrixFunction[x |-> Exp[t x], j]

Solve the system of ODEs , , . First, construct the coefficient matrix for the right-hand side:

Wolfram Language code: (a = {{-5, -4, 6}, {3, 4, -3}, {-4, -2, 5}})//MatrixForm

Compute the Jordan decomposition of :

Wolfram Language code:

{s, j} = JordanDecomposition[a];
MatrixForm /@ {s, j}

Using the formula of the previous example, is given by:

Wolfram Language code: (exptj = {{Exp[t], t Exp[t], 0}, {0, Exp[t], 0}, {0, 0, Exp[2t]}})//MatrixForm

The general solution is $exp(ta).{c_1,c_2,c_3}=s.exp(tj).TemplateBox[{s}, Inverse].{TemplateBox[{1}, CTraditional],TemplateBox[{2}, CTraditional],TemplateBox[{3}, CTraditional]}$ , for three arbitrary starting values:

Wolfram Language code: s.exptj.Inverse[s] . {C[1], C[2], C[3]}//FullSimplify//MatrixForm

Verify the solution using DSolveValue:

Wolfram Language code:

Simplify[% == DSolveValue[{x'[t] == -5x[t] - 4y[t] + 6z[t], y'[t] == 3x[t] + 4y[t] - 3z[t], z'[t] == -4x[t] - 2y[t] + 5z[t]}, {x[t], y[t], z[t]}, t]]

Produce the general solution of the dynamical system when is the following stochastic matrix:

Wolfram Language code:

a = (⁠|         |         |         |
| ------- | ------- | ------- |
| (9/10)  | (1/100) | (9/100) |
| (1/100) | (9/10)  | (1/100) |
| (9/100) | (9/100) | (9/10)  |⁠);

Compute the Jordan decomposition of :

Wolfram Language code: {s, j} = JordanDecomposition[a]

Since the is diagonal, consists of merely raising the diagonal entries to the power :

Wolfram Language code: jk = MatrixPower[j, k]

The general solution is $A^k.{c_1,c_2.c_3}=s.j^k.TemplateBox[{s}, Inverse].{c_1,c_2.c_3}$ :

Wolfram Language code: x[k_] = s.jk.Inverse[s].Table[C[i], {i, 3}]//FullSimplify

Verify that satisfies the dynamical equation:

Wolfram Language code: x[k] == a.x[k - 1]//Simplify

Properties & Relations (11)

JordanDecomposition[m] gives a matrix factorization of m as s.j.Inverse[s]:

Wolfram Language code: m = {{2, 0, 0, 0}, {0, 1, 0, 0}, {1, -1, 1, 0}, {1, -1, 1, 1}};

Find the Jordan decomposition:

Wolfram Language code: {s, j} = JordanDecomposition[m]

Wolfram Language code: Map[MatrixForm, %]

m is equal to s.j.Inverse[s]:

Wolfram Language code: m == s.j.Inverse[s]

The eigenvalues of m are on the diagonal of j:

Wolfram Language code: Eigenvalues[m]

A matrix is diagonalizable iff the j matrix of its Jordan decomposition is diagonal:

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 0 | 0 |
| 1 | 1 | 0 |
| 0 | 0 | 1 |⁠);

Wolfram Language code: {DiagonalizableMatrixQ[m], DiagonalMatrixQ[Last[JordanDecomposition[m]]]}

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
| 0 | 1 | 1 |⁠);

Wolfram Language code: {DiagonalizableMatrixQ[m], DiagonalMatrixQ[Last[JordanDecomposition[m]]]}

EigenvalueDecomposition[m] exists if and only if m's Jordan matrix is diagonal:

Wolfram Language code:

nd = {{27, 48, 81}, {-6, 0, 0}, {1, 0, 3}}
EigenvalueDecomposition[nd]

The Jordan matrix of nd has a 1 above the diagonal:

Wolfram Language code: MatrixForm /@ JordanDecomposition[nd]

When the decomposition exists, it agrees with JordanDecomposition:

Wolfram Language code:

d = {{2, 1, 0}, {3, 7, 1}, {5, -1, -4}};
EigenvalueDecomposition[d] == JordanDecomposition[d]

As expected, the Jordan matrix is diagonal in this case:

Wolfram Language code: Last[JordanDecomposition[d]]//MatrixForm

For a diagonalizable matrix, JordanDecomposition reduces function application to application to eigenvalues:

Wolfram Language code:

m = N[{{0, 1, 0, -1}, {-1, 0, 1, 0}, {0, -1, 0, 1}, {1, 0, -1, 0}}];
{s, j} = JordanDecomposition[m];

Compute the matrix exponential using diagonalization, exponentiating only the diagonal entries:

Wolfram Language code: Chop[s.DiagonalMatrix[Exp[Diagonal[j]]].Inverse[s]]

Compute the matrix exponential using MatrixExp:

Wolfram Language code: MatrixExp[m]

Note that this is not simply the exponential of each entry:

Wolfram Language code: Exp[m]

For a non-diagonalizable matrix, the Jordan decomposition restricts function application to each generalized eigenvector chain:

Wolfram Language code: m = {{3, 7, -22, -6}, {7, 4, -20, -7}, {0, 0, -3, 0}, {6, 7, -21, -9}};

Wolfram Language code: {s, j} = JordanDecomposition[m];

The j matrix is not diagonal, so m is not diagonalizable:

Wolfram Language code: j//MatrixForm

The function application only extends above the diagonal for columns for which j had a 1 above the diagonal:

Wolfram Language code: MatrixExp[j]//MatrixForm

Confirm that :

Wolfram Language code: MatrixExp[m] == s.MatrixExp[j].Inverse[s]

For a real symmetric numerical matrix, the matrix is orthogonal:

Wolfram Language code:

h = {{1.5, .5, -.5}, {.5, 3.2, -1.7}, {-.5, -1.7, 2.2}};
SymmetricMatrixQ[h]

Wolfram Language code:

{s, j} = JordanDecomposition[h];
OrthogonalMatrixQ[s]

The matrix is diagonal and real valued:

Wolfram Language code: DiagonalMatrixQ[j] && j∈Reals

For a real antisymmetric numerical matrix, the matrix is unitary:

Wolfram Language code:

a = N[{{0, 4, -2}, {-4, 0, -3}, {2, 3, 0}}];
AntisymmetricMatrixQ[a]

Wolfram Language code: {s, j} = JordanDecomposition[a]

Wolfram Language code: UnitaryMatrixQ[s]

The matrix is diagonal with pure imaginary diagonal entries:

Wolfram Language code: DiagonalMatrixQ[j] && And @@ Thread[ Re[Diagonal[j]] == 0]

For a real unitary numerical matrix, the matrix is unitary:

Wolfram Language code:

u = N[{{1 / Sqrt[2], I / Sqrt[2]}, {I / Sqrt[2], 1 / Sqrt[2]}}];
UnitaryMatrixQ[u]

Wolfram Language code: {s, j} = JordanDecomposition[u]//Chop

Wolfram Language code: UnitaryMatrixQ[s]

The matrix is diagonal:

Wolfram Language code: DiagonalMatrixQ[j]

The diagonal entries lie on the unit circle:

Wolfram Language code: Norm /@ Diagonal[j]

For a normal numerical matrix, the matrix is unitary:

Wolfram Language code:

n = {{1., 3., -1.}, {-1., 1., 3.}, {3., -1., 1.}};
NormalMatrixQ[n]

Wolfram Language code:

{s, j} = JordanDecomposition[n];
UnitaryMatrixQ[s]

The matrix is diagonal:

Wolfram Language code: DiagonalMatrixQ[j]

Jordan form of an integer matrix:

Wolfram Language code:

m = {{3, 7, -22, -6}, {7, 4, -20, -7}, {0, 0, -3, 0}, {6, 7, -21, -9}};
JordanReduce[m]

In this case, the result agrees with the second matrix given by JordanDecomposition:

Wolfram Language code: JordanDecomposition[m][[2]]

However, the blocks may be ordered differently:

Wolfram Language code:

m = {{1, 1, 2, 1}, {6, 7, 1, 3}, {1, 6, 1, 8}, {5, 8, 4, 10}};
j1 = JordanReduce[m];j2 = Last@JordanDecomposition[m];
j1 == j2

Sort the diagonal elements to show the two reductions are equivalent:

Wolfram Language code: Sort[Diagonal[j1]] == Sort[Diagonal[j2]]

SchurDecomposition[n,RealBlockDiagonalFormFalse] for a numerical normal matrix :

Wolfram Language code:

n = {{1., 3., -1.}, {-1., 1., 3.}, {3., -1., 1.}};
NormalMatrixQ[n]

Wolfram Language code: {q, t} = SchurDecomposition[n, RealBlockDiagonalForm -> False]//Chop

Up to phase, this coincides with the Jordan decomposition:

Wolfram Language code: {s, j} = JordanDecomposition[n]//Chop

The t and j matrices are equal:

Wolfram Language code: t == j

To verify that q has eigenvectors as columns, set the first entry of each column to 1. to eliminate phase differences between q and s:

Wolfram Language code: ((#1/First[q])& /@ q) - ((#1/First[s])& /@ s)//Chop

Possible Issues (2)

m is a 4×4 matrix with some entries differing by a small amount:

Wolfram Language code: m = {{1, 0, 0, 0}, {0, 1, 0, 0}, {1, -1, 1 - 10^-16, 0}, {1, -1, 1, 1 + 10^-16}};

Find the Jordan decomposition using exact arithmetic:

Wolfram Language code: {s, j} = JordanDecomposition[m];

This shows that m is diagonalizable:

Wolfram Language code: Diagonal[j, 1]

Find the Jordan decomposition with machine‐number arithmetic:

Wolfram Language code: {sn, jn} = JordanDecomposition[N[m]]

Computation with machine-number arithmetic indicates that the matrix is not diagonalizable:

Wolfram Language code: Diagonal[jn, 1]

To machine precision, m is indistinguishable from a nearby non-diagonalizable matrix:

Wolfram Language code: N[m] - {{1, 0, 0, 0}, {0, 1, 0, 0}, {1, -1, 1, 0}, {1, -1, 1, 1}}

The matrix m has some machine-precision entries:

Wolfram Language code: m = {{2., 4, -6, 0}, {4, 6, -3, -4}, {0, 0, 4, 0}, {0, 4, -6, 2}};

Due to numerical rounding, the deficient eigenspace at 2. is split into two separate eigenspaces:

Wolfram Language code:

{sn, jn} = JordanDecomposition[m];
jn//MatrixForm

Perform the computation using exact arithmetic to determine if the matrix is diagonalizable:

Wolfram Language code:

{s, j} = JordanDecomposition[Rationalize[m]];
j//MatrixForm

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

JordanDecomposition

Details

Examples

Basic Examples (1)

Scope (10)

Basic Uses (6)

Special Matrices (4)

Applications (13)

Generalized Eigenvectors and Diagonalizability (4)

Similar Matrices (5)

Matrix Functions and Dynamical Systems (4)

Properties & Relations (11)

Possible Issues (2)

Text

CMS

APA

BibTeX

BibLaTeX

JordanDecomposition

Details

Examples

Basic Examples (1)

Scope (10)

Basic Uses (6)

Special Matrices (4)

Applications (13)

Generalized Eigenvectors and Diagonalizability (4)

Similar Matrices (5)

Matrix Functions and Dynamical Systems (4)

Properties & Relations (11)

Possible Issues (2)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX