企业官网建设流程全解析

1. 为什么 Jordan 块的“个数”和“阶数”值得单独拿出来讲

很多人第一次接触Jordan 标准形，记住的是那句结论：任意复方阵都相似于一个 Jordan 形矩阵。但真正做题、做工程计算、写代码的时候，卡住人的往往不是这个结论，而是一个更细的问题——给定矩阵里，某个特征值到底对应几个 Jordan 块，每个块又是几阶的？

这个问题的分量其实很重。举个工程场景：解线性常微分方程组 dx/dt = Ax，解里会出现 t^k e^{λt} 这种项，其中的 k 直接由 λ 对应的最大 Jordan 块阶数决定；再比如算矩阵幂 A^n 或者矩阵函数 f(A)，收敛性和增长阶也依赖块结构。如果只知道特征值和代数重数，你连解里会不会冒出 t 的一次项都判断不了。

我带过几轮习题课，发现学生的典型错误高度集中：把几何重数当成 Jordan 块总数之后就收手，以为万事大吉；或者把最小多项式里 (x-λ) 的重数误当成某种“块数”。这两种理解都只抓住了问题的一半。代数重数 m 告诉你这个特征值“占多大地方”，几何重数 s 告诉你“分成几块”，但“每块多大”这个信息，两者联手都给不出来。

真正能把结构钉死的，是一个看起来很朴素的量：rank((A-λI)^j) 随 j 的变化序列。只要把这个序列算出来，块的阶数和个数就是一次简单差分的产物，几乎不需要动脑子。下面我按“为什么这样想—公式怎么来—手算怎么做—代码怎么验—坑在哪”的顺序，把这套东西完整拆一遍，配合两个能直接抄的例子和一个可运行的 Python 脚本。无论你是正在备考、还是要在程序里自动判定块结构，看完都能直接上手。

2. 把问题拆开：决定 Jordan 块结构的三个层次

2.1 代数重数 m 能告诉你什么，不能告诉你什么

特征多项式 det(xI - A) 在复数域上一定能分解成

det(xI - A) = (x - λ₁)^{m₁} (x - λ₂)^{m₂} … (x - λ_t)^{m_t}

指数 mᵢ 就是 λᵢ 的代数重数，含义是“λᵢ 这个特征值一共占据多少个计数单位”，同时它等于所有属于 λᵢ 的 Jordan 块的阶数之和。这句话很关键：

m = Σ (λ 对应各 Jordan 块的阶数)

也就是说，如果 λ 对应两个块，一个 3 阶一个 1 阶，那 m = 4；如果是两个 2 阶块，m 还是 4。代数重数只约束总和，不约束分配方式。这就是为什么单靠特征多项式永远定不出结构：同样是 m = 4，可能的分配有 4、3+1、2+2、2+1+1、1+1+1+1，一共五种，每一种对应完全不同的矩阵。

顺带说一句，代数重数还有一个等价刻画：它是 λ 的“广义特征子空间” N((A-λI)^k) 在 k 足够大时的维数。这个刻画后面会反复用到，因为它把 m 和“幂次核空间”直接绑在了一起，而不是只挂在特征多项式上。

2.2 几何重数 s 给出块的“总个数”，但只到这一步

几何重数是特征空间的维数：

s = dim ker(A - λI) = n - rank(A - λI)

它的物理意义非常直白：属于 λ 的线性无关特征向量有几个。而每一个 Jordan 块在“最顶端”恰好贡献一个特征向量，块与块之间不会共享特征向量，于是

s = λ 对应的 Jordan 块个数

这个结论是“个数”这一半问题的答案。但麻烦在于，几何重数只数“有几条链”，不告诉你“每条链有多长”。回到刚才 m = 4 的例子：s = 2 时，可能是 3 阶加 1 阶，也可能是两个 2 阶。两种情况的 Jordan 标准形长得完全不一样，一个最小多项式是 (x-λ)³，另一个是 (x-λ)²，解微分方程时一个会出现 t²e^{λt}，另一个最高只到 te^{λt}。差别是实质性的。

所以真实流程一定是：先用特征多项式定 m，再用一次求秩定 s（也就是块数），如果发现 s < m，说明存在高阶块，此时必须再往下算一层。往下算什么？就是下一节的主角。

2.3 真正的主角：d_j = dim ker((A - λI)^j)

定义

d_j = dim ker((A - λI)^j)，j = 0, 1, 2, …

约定 d₀ = 0。这个序列有几个一眼可见的性质，全部来自“幂次核空间随幂次单调膨胀”这一事实：N(B) ⊆ N(B²) ⊆ N(B³) ⊆ …，其中 B = A - λI。所以 d₀ ≤ d₁ ≤ d₂ ≤ …，而且一旦不再增长，后面就永远不变了（因为稳定之后 ker(B^{j+1}) = ker(B^j)）。

这个序列的妙处在于，它把“块的长度分布”编码成了一串单调不减的整数。你可以把它想成一段阶梯：每上一级台阶，就说明有若干条链“长到了这个高度”。最终 d_∞ 就等于代数重数 m，因为幂零部分在广义特征子空间上最终会彻底归零。

用秩写会更方便数值计算：

d_j = n - rank((A - λI)^j)

算秩比算零空间维数稳定得多，尤其在有浮点误差的时候。下面所有公式我都同时给出 d 版本和 rank 版本，你喜欢哪个用哪个。

3. 从 d_j 序列读出块结构的完整推导

3.1 先看单个 Jordan 块：J_k(0)^j 的秩是 k - j

拿单个 k 阶幂零 Jordan 块 J_k(0) 开刀。它的结构是次对角线上一排 1，其余全 0。它的 j 次幂就是把那排 1 整体“上移”j 格：当 j < k 时，J_k(0)^j 恰好有 k - j 个 1，且位置互不冲突，所以

rank(J_k(0)^j) = k - j（j < k），= 0（j ≥ k）

对应的核空间维数是

d_j = k - (k - j) = j（j < k），= k（j ≥ k）

也就是 d_j = min(j, k)。这个式子非常干净：一个 k 阶块，它的核维数序列就是 0, 1, 2, …, k, k, k, …，前 k 步每步涨 1，第 k 步之后彻底躺平。换个说法，d_j - d_{j-1} = 1 恰好成立 j = 1, 2, …, k 这 k 次，之后就一直是 0。也就是说，“d 序列每涨一格，就代表有一条链达到了这个高度”。

顺便解释一下为什么上面的推导对一般特征值 λ 也成立：因为 A - λI 作用在 λ 的广义特征子空间上就是幂零的，把它限制在这个子空间上就是一个幂零矩阵。至于 λ 之外的特征子空间，B 在其上是可逆的，核维数贡献为 0。所以下面所有讨论都可以“先按 λ 切开，再在各自子空间内讨论”，互不干扰。

3.2 直和叠加：d_j = Σ min(j, k_i)

现在有多个块。关键事实是：幂次核空间的维数在直和下是可加的。原因是 B^j 作用在整个空间上，把不同特征值的广义特征子空间互相映到自身；而在 λ 自己的子空间内，如果它分解成若干 Jordan 块，那么 B^j 就是各个块幂的直和，核空间维数直接相加。

于是设 λ 对应的块阶数为 k₁, k₂, …, k_s（共 s 个），得到

d_j = Σ_{i=1}^{s} min(j, k_i)

这一个公式就是全部理论的源头。两边做差分：

d_j - d_{j-1} = Σ_i [min(j, k_i) - min(j-1, k_i)] = Σ_i 1_{k_i ≥ j}

其中 1_{·} 是示性函数。所以

d_j - d_{j-1} = 阶数 ≥ j 的 Jordan 块个数

用大白话翻译：d 序列在第 j 步涨了多少，就等于“长度至少为 j 的链有几条”。这就是那把钥匙。有了它，剩下的都是记账。

3.3 两条等价公式：一阶差分定“至少 j 阶”，二阶差分定“恰好 j 阶”

从上面的关系立刻得到两组实用公式。

第一组，定义“阶数至少为 j 的块数”：

A_j := d_j - d_{j-1} = rank((A-λI)^{j-1}) - rank((A-λI)^j)

序列 A₁ ≥ A₂ ≥ A₃ ≥ … 单调不增，因为条件“k_i ≥ j”随着 j 增大只会越来越苛刻。而且 A₁ 就是几何重数 s。

第二组，我们要的是“恰好等于 j 阶”的块数，记为 N_j。显然

N_j = A_j - A_{j+1} = (d_j - d_{j-1}) - (d_{j+1} - d_j) = 2d_j - d_{j-1} - d_{j+1}

换成秩版本：

N_j = rank((A-λI)^{j-1}) - 2·rank((A-λI)^j) + rank((A-λI)^{j+1})

这条公式我习惯叫它“二阶差分公式”，因为右边就是秩序列的离散二阶导数取负号。它的几何解释也很直观：块长分布就是秩随幂次下降速度的“减速”位置——每减速一次，就说明有一条链到头了。

两个现成的校验条件，做题时强烈建议逐条对一遍，能拦住绝大多数计算失误：

• Σ_j N_j = s = 几何重数（块的总数对）
• Σ_j j·N_j = m = 代数重数（阶数加权和对）

如果这两个和不等于预期值，别急着往下算，先回头检查哪一步秩算错了。

3.4 最大块阶数与最小多项式的关系

还有一个特别容易和“块数”搞混的量：最大块阶数。它是满足 d_k = m 的最小 k，也就是序列彻底躺平的位置，通常叫 λ 处的幂零指数。它等于最小多项式中 (x - λ) 的幂次：

m_A(x) = Π_i (x - λ_i)^{k_max,i}

所以想快速判断“最大块几阶”，只要看最小多项式的重根重数就行，不需要算全部秩。但要注意，最大块阶数只是分布中的最大值，它一个数替代不了整个分布。比如 J₃ ⊕ J₁ 和 J₃ ⊕ J₃ ⊕ J₁ 的最大块阶数都是 3，但块的个数一个 2 一个 3，代数重数一个 4 一个 7。所以“看最小多项式”是快速估算，不是完整答案。

顺带一个常见结论：A 可对角化 ⟺ 每个特征值的几何重数等于代数重数 ⟺ 所有 Jordan 块都是 1 阶 ⟺ 最小多项式没有重根。这四个说法完全等价，串在一起记效率最高。

4. 手算实战：从矩阵出发一步步把块结构钉死

4.1 第一步，定特征值与代数重数

拿一个 3 阶上三角矩阵当靶子：

A = [[3, 1, -1], [0, 2, 1], [0, 0, 2]]

上三角矩阵的特征值就在对角线上：λ = 3（重数 1），λ = 2（重数 2）。于是 m(3) = 1，m(2) = 2。这里要提醒一句，只有三角矩阵和已知谱的矩阵能这样直接读，一般矩阵老老实实算 det(xI - A) 然后用因式分解或数值求根。

对 λ = 3，代数重数 1，意味着它只能对应一个 1 阶块，没有第二种可能，所以结构直接定为 J₁(3)，不用再算秩。这也是一个省时间的经验：代数重数为 1 的特征值不需要任何进一步分析。

真正要花功夫的是 λ = 2，m = 2。可能的分配只有两种：一个 2 阶块，或者两个 1 阶块。接下来一步就能区分。

4.2 第二步，逐次求秩，把 d 和 rank 序列都列出来

先算 B = A - 2I：

B = [[1, 1, -1], [0, 0, 1], [0, 0, 0]]

三行里第一行 (1,1,-1)、第二行 (0,0,1) 显然不共线，第三行是零行，所以 rank(B) = 2，d₁ = 3 - 2 = 1。这一步已经给出结论：λ = 2 只有1 个Jordan 块。因为代数重数是 2 而块数只有 1，那这个块必然是 2 阶的，问题其实已经解决。

但为了把流程完整演示一遍（也为了展示公式怎么用），继续算 B²：

B² = [[1, 1, 0], [0, 0, 0], [0, 0, 0]]

只有第一行非零，rank(B²) = 1，d₂ = 3 - 1 = 2。再算 B³ = B²·B，还是 [[1,1,0],[0,0,0],[0,0,0]]，rank = 1，d₃ = 2。此后不再变化。

整理成表：

4.3 第三步，套公式算 N_j，并做两道校验

用 N_j = 2d_j - d_{j-1} - d_{j+1}：

• N₁ = 2×1 - 0 - 2 = 0
• N₂ = 2×2 - 1 - 2 = 1
• N₃ = 2×2 - 2 - 2 = 0

所以 λ = 2 对应一个 2 阶块，没有 1 阶块。合并 λ = 3 的结果，整个矩阵的 Jordan 标准形是

J = diag( J₁(3), J₂(2) ) = [[3, 0, 0], [0, 2, 1], [0, 0, 2]]

校验一下：Σ N = 1 + 1 = 2 = 几何重数之和，Σ jN = 1×1 + 2×1 = 3 = n。都过。

顺便说一个替代做法：既然已经知道 s = 1 而 m = 2，其实直接用“最大块阶数 = min{k : d_k = m}”就够了，d₁ = 1 < 2，d₂ = 2 = m，所以最大块阶数是 2；块数又只有 1，结论自然唯一。这说明当 s 和 m 的差距很小时，不需要把全部 N_j 都算出来，抓住最大块阶数和块数两个量就能反推结构。

4.4 完整 Python 实现，精确版和数值版都给你

手工算小矩阵没问题，真到 10 阶以上就得上代码。下面是精确版，用 sympy 的秩，适合验证习题答案：

import sympy as sp def jordan_structure_exact(A, lam): n = A.shape[0] B = A - lam * sp.eye(n) M = sp.eye(n) d = [0] while True: M = M * B nullity = n - M.rank() if nullity == d[-1]: # 序列稳定，停 break d.append(nullity) # d[j] = dim ker B^j，用二阶差分求各阶块数 N = {} for k in range(1, len(d) - 1): cnt = 2 * d[k] - d[k - 1] - d[k + 1] if cnt > 0: N[k] = cnt return d, N A = sp.Matrix([[3, 1, -1], [0, 2, 1], [0, 0, 2]]) print(jordan_structure_exact(A, sp.Integer(2))) # 输出：d = [0, 1, 2, 2]，N = {2: 1}

数值版要处理浮点秩判定，这里用奇异值的相对阈值，比直接比大小靠谱：

import numpy as np def jordan_structure_num(A, lam, rel_tol=1e-9): n = A.shape[0] B = A - lam * np.eye(n) M = np.eye(n) d = [0] while True: M = M @ B s = np.linalg.svd(M, compute_uv=False) tol = rel_tol * max(s[0], 1.0) # 相对阈值 rank = int(np.sum(s > tol)) nullity = n - rank if nullity == d[-1]: break d.append(nullity) N = {} for k in range(1, len(d) - 1): cnt = 2 * d[k] - d[k - 1] - d[k + 1] if cnt > 0: N[k] = cnt return d, N A = np.array([[3., 1., -1.], [0., 2., 1.], [0., 0., 2.]]) print(jordan_structure_num(A, 2.0)) # 输出：d = [0, 1, 2, 2]，N = {2: 1}

注意：数值版里rel_tol不能设得太小。矩阵幂次一高，B^k 的元素会迅速衰减甚至溢出，用绝对阈值判定几乎必然出错。用“相对最大奇异值”的阈值是工程上的常规做法。

5. 一个帮你区分“同 m 同 s”两种结构的判别例子

理论讲完了，来一个专门用来打脸的对比。假设 n = 4，某个 λ 的代数重数 m = 4，你算出几何重数 s = 2。此时有两种可能：J₃ ⊕ J₁ 或者 J₂ ⊕ J₂。两者的 d₁ 都是 2，光靠前两步区分不了，必须往下一步看。

算 d₂ = dim ker(B²)：

• 若是 J₃ ⊕ J₁：J₃ 贡献 min(2,3) = 2，J₁ 贡献 min(2,1) = 1，合计 d₂ = 3。
• 若是 J₂ ⊕ J₂：两个块各贡献 min(2,2) = 2，合计 d₂ = 4。

差别就出来了：d₂ = 3 对应 3+1，d₂ = 4 对应 2+2。继续算 d₃ 可以进一步区分 3+1 和更高阶的情况，但在这里已经足够了。

对应的秩序列也顺手列一下，方便你对着表读数：

再给一个更完整的抽象例子练手。某 6 阶矩阵在 λ 处满足 rank(B) = 4，rank(B²) = 2，rank(B³) = 1，rank(B⁴) = 0，rank(B⁵) = 0。那么 d = [0, 2, 4, 5, 6, 6]。逐层差分：

• d₁ - d₀ = 2 → 2 个块
• d₂ - d₁ = 2 → 阶数 ≥ 2 的块 2 个
• d₃ - d₂ = 1 → 阶数 ≥ 3 的块 1 个
• d₄ - d₃ = 1 → 阶数 ≥ 4 的块 1 个
• d₅ - d₄ = 0 → 没有更高阶的块

于是 N₁ = 2 - 2 = 0，N₂ = 2 - 1 = 1，N₃ = 1 - 1 = 0，N₄ = 1 - 0 = 1。结构是 J₄(λ) ⊕ J₂(λ)。校验：块数 2 = d₁，总阶数 4 + 2 = 6 = n。都吻合。注意这个例子里 rank(B³) = 1 和 rank(B⁴) = 0 这两步很容易抄错一位，一旦错一位，N₃ 就会虚报成 1，整个结构就崩了。

6. 常见坑与排查技巧实录

6.1 坑一：把几何重数当成块的总数就收工

这是出现频率最高的错误，前面已经反复强调。判断标准很简单：只要 s < m，就一定有高阶块，必须继续求 rank(B²)。我一般建议的流程是固定的三步——定 m、定 s、未确定则继续求幂次秩——照着走不会漏。

6.2 坑二：数值计算里秩判定失准

浮点环境下 rank(B) 的判定太依赖阈值。B 的特征值里如果本来就有接近零的（说明 λ 只是近似特征值），B 几乎是奇异的，奇异值会呈现“一小撮接近 1e-3、另一小撮接近 1e-12”的分布，这时候阈值放哪儿都别扭。

处理办法有两个。一是先把特征值精修一遍：用 2×2 或 3×3 的幂零结构做牛顿迭代，把 λ 收敛到机器精度再算 B 的秩。二是改用符号计算或高精度，比如 sympy 或 mpmath，教学和验证场景下这是最省心的。若矩阵是精确整数矩阵，sympy 的rank()会给出严格答案，不用纠结阈值。

还有一个实用技巧：不要直接累乘 B^k，而是每次做一次秩判定后保留矩阵，并用np.linalg.svd的相对阈值。累乘会让数值误差累积放大，到第 4、5 次幂时误差已经能污染秩判定。

6.3 坑三：代数重数算错导致满盘皆输

如果特征多项式没分解对，后面算出来的 d 序列永远对不上 m，Σ N 和 Σ jN 两道校验会立刻报警。所以我把这两道校验放在流程里强制检查。一旦 Σ jN ≠ m，九成是 m 错了，剩下一成是秩算错。养成本能，见到数字不匹配就回头查，比盲算下去效率高得多。

6.4 坑四：对复特征值的处理

实矩阵的特征值可能是复的，这时 Jordan 块成共轭对出现。注意复特征值的代数重数要按复重数算，不要强行在实数域上讨论标准形——实数域上并不总有 Jordan 标准形，只能得到实 Jordan 形（把共轭的两个块拼成一个实块）。编程时 A 直接转成复数类型，秩判定用复数奇异值，逻辑完全一样。

6.5 排查速查表

6.6 几个能省时间的经验技巧

第一，先处理代数重数为 1 的特征值，它们直接就是 1 阶块，不占计算量。第二，对每个 λ 独立计算，不同特征值之间的秩互不影响，可以并行。第三，一旦 d_j 达到 m，立刻停止该特征值的计算，不必继续求更高次幂。第四，如果只是想知道最大块阶数，直接算最小多项式更快；只有需要完整的块分布时，才值得把秩序列全部算出来。第五，编程时用“幂次 + 秩 + 核维数 + 差分”四列一起打表输出，人眼扫一遍就能发现问题，比只看最终结果可靠得多。

7. 换一个视角：初等因子和行列式因子怎么和这套方法对上

如果你翻过更偏代数的教材，会发现另一套语言——不变因子、初等因子、行列式因子。它们和这里的秩方法是同一件事的两种说法，理解二者的对应关系，做题时会多一条退路。

思路是这样的：设 D_k(x) 为矩阵 xI - A 的所有 k 阶子式的最大公因式，叫 k 阶行列式因子，规定 D₀ = 1。再令 d_k(x) = D_k(x) / D_{k-1}(x)，称为不变因子。这些不变因子满足整除链 d₁ | d₂ | … | d_n，且乘积为特征多项式。把每个不变因子在复数域上彻底分解，得到的那些形如 (x - λ)^e 的因子，就叫初等因子。

关键结论是：初等因子和 Jordan 块一一对应，一个 (x - λ)^e 就对应一个 e 阶的 Jordan 块。所以“λ 对应几个块、各几阶”，在这套语言里就是“在 xI - A 的初等因子里，(x - λ) 出现了几次、每次的指数是多少”。指数组合就是块阶数的多重集。

举个小例子核对一下。若特征多项式是 (x-2)⁴，不变因子是 d₃ = (x-2)²，d₄ = (x-2)²，那么初等因子是两个 (x-2)²，对应 J₂(2) ⊕ J₂(2)。用秩方法检验：B = A - 2I，d₁ = 2，d₂ = 4，d₃ = 4，N₂ = 2×4 - 2 - 4 = 2，其余为 0。完全一致。

两种方法的取舍很清楚：初等因子在理论上更完整，能一次性给出全部信息（包括相似判定的充要条件——两个矩阵相似当且仅当它们的初等因子完全相同），但手工计算量大，要算一堆子式的最大公因式；秩方法计算量小、适合编程和手算，但要一个特征值一个特征值地处理。我的习惯是用秩方法做实际计算，用初等因子做理论证明和结果核对，两条腿走路最稳。

最后补一句关于应用的话。Jordan 块的阶数分布之所以重要，是因为它决定了矩阵幂 A^k 的增长行为和幂零部分的作用深度。工程上做线性系统分析时，如果发现某个特征值的最大块阶数达到 3，就意味着解里会出现 t² 量级的项，做数值离散时必须加密时间步，否则精度会崩。这也是我一直坚持把 d 序列算完整、而不是只记个结论的原因——分布里藏着的正是这些实际影响。

我个人在写教学脚本时的体会是，把秩序列和差分序列并排打印出来，比只输出最终的 N 字典有用得多。前者能让你看到“推理过程”，后者只是一行结果；一旦不对，光看结果根本不知道错在哪一步。要是你想再往下扩展，可以试着把这段逻辑接到符号计算上，对含参数 a 的矩阵做块结构分类，看参数取什么值时结构发生跃变——那正好是工程里最需要小心的临界点。