Counting Jordan Blocks from Kernel Growth

What Kernel Growth Records

For a nilpotent operator, taking higher powers can only enlarge the kernel: a vector killed by \(N^r\) is also killed by \(N^{r+1}\). The amount by which the kernel grows from one power to the next contains more information than just the total dimension of the space. When \(N\) is represented in a basis by nilpotent Jordan blocks, each increase counts how many blocks are still growing at that stage. Taking differences of those counts then reveals the number of blocks of each exact size.

Throughout, let \(V\) be a finite-dimensional vector space over \(\mathbb{R}\), and let \(N:V\to V\) be nilpotent. This means that \(N^m=\mathbf{0}\), the zero map, for some positive integer \(m\). Assume that a basis has been chosen in which the matrix of \(N\) is a direct sum of nilpotent Jordan blocks. This tutorial explains how to count the blocks from the dimensions of the kernels; it does not establish that such a basis exists.

In a single block of size \(s\), the kernel of the \(r\)th power has dimension \(\min(r,s)\). Intuitively, each application of the block moves vectors one position along its Jordan chain, and at most \(r\) positions are killed by the \(r\)th power. This single-block calculation is the key input. The result below explains how to combine it across all the blocks.

The First Difference Counts Blocks That Reach a Level

Proof. Let the block sizes be \(s_1,\dots,s_k\). In the coordinates of the Jordan basis, a vector is a list of one component from each block. Its image under \(N^r\) is zero exactly when each block component belongs to the kernel of the \(r\)th power of that block. Therefore the kernel is the direct sum of the block kernels, and its dimension is the sum of their dimensions. Using the single-block formula gives $$ d_r=\sum_{j=1}^{k}\min(r,s_j) \quad\text{and}\quad d_{r-1}=\sum_{j=1}^{k}\min(r-1,s_j). $$ For a particular block of size \(s_j\), the difference \(\min(r,s_j)-\min(r-1,s_j)\) is \(1\) if \(s_j\geq r\), and \(0\) if \(s_j<r\). Subtracting the two sums thus adds one for each block of size at least \(r\), and adds zero for every smaller block. This proves the formula. \(\square

Write \(b_r=d_r-d_{r-1}\). The theorem says that \(b_r\) counts blocks that are at least \(r\) entries long, not blocks of size exactly \(r\). As \(r\) increases, fewer blocks can reach that level, so the sequence \(b_1,b_2,\dots\) cannot increase. The number of blocks that stop at size \(r\) is the number that reach level \(r\) minus the number that also reach level \(r+1\).

Proof. Every block of size exactly \(r\) is counted among the blocks of size at least \(r\), but not among those of size at least \(r+1\). Subtracting those two counts leaves precisely the blocks of size \(r\). Substituting \(b_r=d_r-d_{r-1}\) and \(b_{r+1}=d_{r+1}-d_r\), then collecting terms, gives the displayed expression. \(\square

If the largest block has size \(m\), then there are no blocks of size at least \(m+1\), so \(b_{m+1}=0\). In calculations, this makes the count of size \(m\) simply \(b_m\). The dimensions also stop increasing after \(d_m\): every block kernel has reached the entire block by that power.

Reading the Counts from Known Blocks

Recovering Block Sizes from Kernel Dimensions

The same formulas work in reverse. If a table gives \(d_0,d_1,\dots\), first subtract adjacent entries to find how many blocks reach each level. Then subtract adjacent results to find how many end at each level. A block-size count obtained this way must be a nonnegative integer, and the counts \(b_r\) must be nonincreasing: a block reaching level \(r+1\) necessarily reaches level \(r\) as well.

Consistency Checks and a Common Mistake

Kernel-growth data impose useful checks before any block sizes are interpreted. The first differences \(b_r\) must be nonnegative integers, because they count blocks. They must also be nonincreasing. The second differences \(b_r-b_{r+1}\), which count exact sizes, must be nonnegative integers too. Finally, the sum of all block sizes must equal \(\dim V\); equivalently, the kernel dimension must eventually reach \(\dim V\). These checks are necessary for data to come from a nilpotent Jordan block representation.

Common mistake: treating \(d_r-d_{r-1}\) as the number of blocks of size exactly \(r\). For the block sizes \(4,2,2,1\) above, the first difference at \(r=1\) is \(4\). It is wrong to conclude that there are four blocks of size \(1\): only one block has that exact size. The other three blocks have size at least \(2\). The correction is to subtract the next first difference: the exact size-\(1\) count is \(b_1-b_2=4-3=1\). In general, the first difference counts blocks that reach level \(r\), and the second difference counts those that stop there.

There is also a useful way to read the pattern without naming every block. If \(b_r=b_{r+1}\), no block has size exactly \(r\), since the number reaching level \(r\) is the same as the number reaching level \(r+1\). If \(b_r>b_{r+1}\), the difference is exactly the number that end at size \(r\). These statements follow directly from the counting formula, so they apply whether block sizes repeat or not.