JOVANA
Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

The Primary Decomposition and Jordan-Chevalley

Assemble the generalized eigenspaces into a full direct-sum decomposition of the space, then split every operator into a diagonalizable part plus a commuting nilpotent part — the canonical semisimple-plus-nilpotent picture.

Gluing the pieces into the whole space

The primary decomposition theorem is the harvest of the last guide. Over a field where the characteristic polynomial factors fully (always true over C), the space splits as V = G(lambda_1, T) (+) G(lambda_2, T) (+) ... (+) G(lambda_r, T), one generalized eigenspace per distinct eigenvalue, each one T-invariant.

This is the invariant direct-sum decomposition we wanted from the start of the track: V is broken into invariant blocks, and on each block T - lambda_i*I is nilpotent. The hard obstruction of Guide 2 — missing complements — is dodged because these particular complements always exist. The blocks may not be eigenlines, but they are honest invariant summands.

A = [ 3  1  0  0 ;
      0  3  0  0 ;
      0  0  3  0 ;
      0  0  0  7 ]      eigenvalues: 3 (mult 3),  7 (mult 1)

G(3, A) = span{ e1, e2, e3 }   (dim 3 = algebraic mult of 3)
G(7, A) = span{ e4 }           (dim 1 = algebraic mult of 7)

Primary decomposition:  R^4 = G(3,A) (+) G(7,A).
On G(3,A):  A - 3I is nilpotent.
On G(7,A):  A - 7I is zero (e4 is a genuine eigenvector).
Each eigenvalue contributes a generalized eigenspace whose dimension matches its multiplicity.

Splitting the operator: semisimple plus nilpotent

The decomposition of the space induces a decomposition of the operator. Define S to act on each block as multiplication by lambda_i, and let N = T - S. Then S is a semisimple operator (diagonalizable over C), N is nilpotent, and crucially S and N commute. This is the Jordan-Chevalley decomposition: T = S + N, uniquely.

  1. Run the primary decomposition to find each G(lambda_i, T) and its eigenvalue lambda_i.
  2. Define S = lambda_i * I on the block G(lambda_i, T); this is the semisimple part.
  3. Set N = T - S; on each block this is T - lambda_i*I, which is nilpotent there.
  4. Verify S N = N S — the commuting property that makes the split unique and useful.

What this buys you

Diagonalization is now revealed as the special case where N = 0 — where the operator is purely semisimple. Every other operator over C is semisimple-plus-a-genuine-nilpotent, and that nilpotent tail is precisely the obstruction we first met as the shear in Guide 2.