第11章：矩阵对角化理论

Haiyue

October 7, 2025

24min

第11章：矩阵对角化理论

学习目标

理解矩阵对角化的条件
掌握矩阵对角化的方法
理解相似矩阵的性质
掌握Jordan标准形的基本概念
理解对角化的几何意义

矩阵对角化的基本概念

定义

对于 $n \times n$ 矩阵 $A$ ，如果存在可逆矩阵 $P$ 和对角矩阵 $D$ ，使得： $P^{-1}AP = D$

则称矩阵 $A$ 可对角化， $P$ 称为对角化矩阵。

对角化的等价条件

矩阵 $A$ 可对角化当且仅当：

$A$ 有 $n$ 个线性无关的特征向量
对于每个特征值，其几何重数等于代数重数
$A$ 与某个对角矩阵相似

import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import eig, inv
import matplotlib.patches as patches

def diagonalization_demo():
    """演示矩阵对角化过程"""

    # 可对角化矩阵示例
    A = np.array([[4, 1],
                  [2, 3]], dtype=float)

    print("原矩阵 A:")
    print(A)

    # 计算特征值和特征向量
    eigenvals, eigenvecs = eig(A)

    print(f"\n特征值: {eigenvals}")
    print(f"特征向量矩阵 P:\n{eigenvecs}")

    # 构造对角矩阵
    D = np.diag(eigenvals)
    P = eigenvecs
    P_inv = inv(P)

    print(f"\n对角矩阵 D:\n{D}")

    # 验证对角化
    result = P_inv @ A @ P
    print(f"\nP^(-1)AP =\n{result}")
    print(f"是否等于D: {np.allclose(result, D)}")

    # 验证逆变换
    reconstructed_A = P @ D @ P_inv
    print(f"\nPDP^(-1) =\n{reconstructed_A}")
    print(f"是否等于原矩阵A: {np.allclose(reconstructed_A, A)}")

    return A, P, D

A, P, D = diagonalization_demo()

相似矩阵的性质

相似矩阵的定义

如果存在可逆矩阵 $P$ 使得 $B = P^{-1}AP$ ，则称矩阵 $A$ 和 $B$ 相似，记作 $A \sim B$ 。

相似矩阵的重要性质

相似矩阵具有相同的：

特征值
行列式
迹（对角元素之和）
秩
特征多项式

def similarity_properties_demo():
    """演示相似矩阵的性质"""

    # 原矩阵
    A = np.array([[2, 1, 0],
                  [1, 2, 1],
                  [0, 1, 2]], dtype=float)

    # 随机可逆变换矩阵
    np.random.seed(42)
    P = np.random.randn(3, 3)
    while np.abs(np.linalg.det(P)) < 0.1:  # 确保P可逆
        P = np.random.randn(3, 3)

    P_inv = inv(P)

    # 计算相似矩阵
    B = P_inv @ A @ P

    print("原矩阵 A:")
    print(A)
    print(f"\n变换矩阵 P:\n{P}")
    print(f"\n相似矩阵 B = P^(-1)AP:\n{B}")

    # 验证相似矩阵的性质
    properties = {
        "特征值": (np.sort(eig(A)[0]), np.sort(eig(B)[0])),
        "行列式": (np.linalg.det(A), np.linalg.det(B)),
        "迹": (np.trace(A), np.trace(B)),
        "秩": (np.linalg.matrix_rank(A), np.linalg.matrix_rank(B))
    }

    print(f"\n相似矩阵性质验证:")
    print("=" * 50)
    for prop_name, (val_A, val_B) in properties.items():
        if prop_name == "特征值":
            equal = np.allclose(val_A, val_B)
            print(f"{prop_name}:")
            print(f"  A: {val_A}")
            print(f"  B: {val_B}")
        else:
            equal = np.isclose(val_A, val_B)
            print(f"{prop_name}: A={val_A:.4f}, B={val_B:.4f}")
        print(f"  相等: {equal}")
        print("-" * 30)

similarity_properties_demo()

对角化算法

标准对角化步骤

计算特征值：求解 $\det(A - \lambda I) = 0$
对每个特征值，求对应的特征向量
检查是否有足够的线性无关特征向量
构造矩阵 $P = [v_1, v_2, \ldots, v_n]$
验证 $P^{-1}AP = D$

def diagonalization_algorithm():
    """完整的矩阵对角化算法"""

    def diagonalize_matrix(A):
        """
        矩阵对角化算法
        返回: (is_diagonalizable, P, D)
        """
        n = A.shape[0]

        # 步骤1: 计算特征值和特征向量
        eigenvals, eigenvecs = eig(A)

        # 步骤2: 检查特征向量的线性无关性
        rank_eigenvecs = np.linalg.matrix_rank(eigenvecs)

        if rank_eigenvecs == n:
            # 可对角化
            P = eigenvecs
            D = np.diag(eigenvals)
            return True, P, D
        else:
            # 不可对角化
            return False, None, None

    # 测试矩阵1: 可对角化矩阵
    print("测试矩阵1: 可对角化矩阵")
    A1 = np.array([[3, 1],
                   [0, 2]], dtype=float)

    print(f"矩阵 A1:\n{A1}")

    is_diag1, P1, D1 = diagonalize_matrix(A1)

    if is_diag1:
        print("矩阵可对角化!")
        print(f"对角化矩阵 P:\n{P1}")
        print(f"对角矩阵 D:\n{D1}")

        # 验证
        verification = inv(P1) @ A1 @ P1
        print(f"验证 P^(-1)AP:\n{verification}")
        print(f"误差: {np.linalg.norm(verification - D1):.2e}")
    else:
        print("矩阵不可对角化")

    print("\n" + "="*50 + "\n")

    # 测试矩阵2: 不可对角化矩阵（有重特征值但几何重数不足）
    print("测试矩阵2: 不可对角化矩阵")
    A2 = np.array([[2, 1],
                   [0, 2]], dtype=float)

    print(f"矩阵 A2:\n{A2}")

    is_diag2, P2, D2 = diagonalize_matrix(A2)

    if is_diag2:
        print("矩阵可对角化!")
        print(f"对角化矩阵 P:\n{P2}")
        print(f"对角矩阵 D:\n{D2}")
    else:
        print("矩阵不可对角化")

        # 分析原因
        eigenvals2, eigenvecs2 = eig(A2)
        print(f"特征值: {eigenvals2}")
        print(f"特征向量矩阵的秩: {np.linalg.matrix_rank(eigenvecs2)}")
        print("原因: 重特征值的几何重数小于代数重数")

    print("\n" + "="*50 + "\n")

    # 测试矩阵3: 对称矩阵（总是可对角化）
    print("测试矩阵3: 对称矩阵")
    A3 = np.array([[1, 2, 3],
                   [2, 4, 5],
                   [3, 5, 6]], dtype=float)

    print(f"矩阵 A3:\n{A3}")
    print(f"是否对称: {np.allclose(A3, A3.T)}")

    is_diag3, P3, D3 = diagonalize_matrix(A3)

    if is_diag3:
        print("对称矩阵可对角化!")
        print(f"特征值: {np.diag(D3)}")

        # 验证特征向量的正交性（对于对称矩阵）
        dot_products = []
        for i in range(3):
            for j in range(i+1, 3):
                dot_prod = np.dot(P3[:, i], P3[:, j])
                dot_products.append(dot_prod)
                print(f"v{i+1} · v{j+1} = {dot_prod:.2e}")

        print(f"特征向量正交: {np.allclose(dot_products, 0, atol=1e-10)}")

diagonalization_algorithm()

对角化的几何意义

坐标变换视角

对角化本质上是找到一组特征向量基，在这组基下，线性变换表现为简单的坐标缩放。

def geometric_interpretation():
    """对角化的几何解释"""

    # 定义可对角化矩阵
    A = np.array([[3, 1],
                  [1, 2]], dtype=float)

    # 对角化
    eigenvals, eigenvecs = eig(A)
    P = eigenvecs
    D = np.diag(eigenvals)

    print("原矩阵 A:")
    print(A)
    print(f"特征值: {eigenvals}")

    # 创建测试向量
    test_vectors = np.array([[1, 0, 1, 1],
                            [0, 1, 1, -1]])

    fig, axes = plt.subplots(2, 3, figsize=(15, 10))

    # 第一行：标准基下的变换
    ax1, ax2, ax3 = axes[0]

    # 原始向量（标准基）
    for i in range(test_vectors.shape[1]):
        ax1.arrow(0, 0, test_vectors[0, i], test_vectors[1, i],
                 head_width=0.1, head_length=0.1, fc='blue', ec='blue',
                 alpha=0.7, label=f'v{i+1}' if i < 2 else None)

    # 绘制标准基
    ax1.arrow(0, 0, 1, 0, head_width=0.05, head_length=0.05,
             fc='red', ec='red', linewidth=2, label='e1')
    ax1.arrow(0, 0, 0, 1, head_width=0.05, head_length=0.05,
             fc='green', ec='green', linewidth=2, label='e2')

    ax1.set_xlim(-1.5, 2)
    ax1.set_ylim(-1.5, 2)
    ax1.grid(True, alpha=0.3)
    ax1.set_aspect('equal')
    ax1.legend()
    ax1.set_title('原始向量（标准基）')

    # 变换后的向量（标准基）
    transformed_vectors = A @ test_vectors

    for i in range(test_vectors.shape[1]):
        ax2.arrow(0, 0, test_vectors[0, i], test_vectors[1, i],
                 head_width=0.1, head_length=0.1, fc='blue', ec='blue',
                 alpha=0.3, linestyle='--')
        ax2.arrow(0, 0, transformed_vectors[0, i], transformed_vectors[1, i],
                 head_width=0.1, head_length=0.1, fc='red', ec='red',
                 alpha=0.7)

    # 绘制特征向量
    for i, (val, vec) in enumerate(zip(eigenvals, eigenvecs.T)):
        length = 1.5
        ax2.arrow(0, 0, vec[0]*length, vec[1]*length,
                 head_width=0.1, head_length=0.1, fc=f'C{i+2}', ec=f'C{i+2}',
                 linewidth=3, label=f'特征向量{i+1}')

    ax2.set_xlim(-1, 4)
    ax2.set_ylim(-1, 3)
    ax2.grid(True, alpha=0.3)
    ax2.set_aspect('equal')
    ax2.legend()
    ax2.set_title('变换后（标准基）')

    # 特征向量基下的表示
    P_inv = inv(P)
    coords_in_eigenbasis = P_inv @ test_vectors

    for i in range(test_vectors.shape[1]):
        ax3.arrow(0, 0, coords_in_eigenbasis[0, i], coords_in_eigenbasis[1, i],
                 head_width=0.1, head_length=0.1, fc='blue', ec='blue',
                 alpha=0.7)

    # 绘制特征向量基（在特征向量坐标系下为单位向量）
    ax3.arrow(0, 0, 1, 0, head_width=0.05, head_length=0.05,
             fc='purple', ec='purple', linewidth=2, label='特征基1')
    ax3.arrow(0, 0, 0, 1, head_width=0.05, head_length=0.05,
             fc='orange', ec='orange', linewidth=2, label='特征基2')

    ax3.set_xlim(-2, 2)
    ax3.set_ylim(-2, 2)
    ax3.grid(True, alpha=0.3)
    ax3.set_aspect('equal')
    ax3.legend()
    ax3.set_title('特征向量坐标系')

    # 第二行：特征向量基下的变换
    ax4, ax5, ax6 = axes[1]

    # 特征向量基下的变换（对角矩阵作用）
    transformed_coords = D @ coords_in_eigenbasis

    for i in range(test_vectors.shape[1]):
        ax4.arrow(0, 0, coords_in_eigenbasis[0, i], coords_in_eigenbasis[1, i],
                 head_width=0.1, head_length=0.1, fc='blue', ec='blue',
                 alpha=0.3, linestyle='--')
        ax4.arrow(0, 0, transformed_coords[0, i], transformed_coords[1, i],
                 head_width=0.1, head_length=0.1, fc='red', ec='red',
                 alpha=0.7)

    ax4.arrow(0, 0, 1, 0, head_width=0.05, head_length=0.05,
             fc='purple', ec='purple', linewidth=2)
    ax4.arrow(0, 0, 0, 1, head_width=0.05, head_length=0.05,
             fc='orange', ec='orange', linewidth=2)

    ax4.set_xlim(-2, 4)
    ax4.set_ylim(-2, 3)
    ax4.grid(True, alpha=0.3)
    ax4.set_aspect('equal')
    ax4.set_title(f'特征基下变换\\nD = diag({eigenvals[0]:.2f}, {eigenvals[1]:.2f})')

    # 显示对角化分解
    ax5.text(0.1, 0.8, r'$A = PDP^{-1}$', fontsize=16, transform=ax5.transAxes)
    ax5.text(0.1, 0.6, r'$P = $ 特征向量矩阵', fontsize=12, transform=ax5.transAxes)
    ax5.text(0.1, 0.4, r'$D = $ 对角矩阵', fontsize=12, transform=ax5.transAxes)
    ax5.text(0.1, 0.2, r'$P^{-1} = $ 坐标变换', fontsize=12, transform=ax5.transAxes)

    ax5.text(0.1, 0.1, f'P = \n{P}', fontsize=10, transform=ax5.transAxes,
             fontfamily='monospace')

    ax5.set_xlim(0, 1)
    ax5.set_ylim(0, 1)
    ax5.axis('off')
    ax5.set_title('对角化分解')

    # 变换过程示意图
    ax6.text(0.5, 0.9, '对角化的三步过程:', fontsize=14, ha='center',
             transform=ax6.transAxes, weight='bold')

    steps = [
        '1. 标准基 → 特征基',
        '   (乘以 P⁻¹)',
        '2. 特征基下缩放',
        '   (乘以 D)',
        '3. 特征基 → 标准基',
        '   (乘以 P)'
    ]

    for i, step in enumerate(steps):
        y_pos = 0.75 - i * 0.1
        color = 'blue' if i % 2 == 0 else 'gray'
        weight = 'bold' if i % 2 == 0 else 'normal'
        ax6.text(0.1, y_pos, step, fontsize=11, transform=ax6.transAxes,
                color=color, weight=weight)

    ax6.set_xlim(0, 1)
    ax6.set_ylim(0, 1)
    ax6.axis('off')
    ax6.set_title('变换步骤')

    plt.tight_layout()
    plt.show()

geometric_interpretation()

对角化的应用：矩阵幂

快速计算矩阵幂

如果 $A = PDP^{-1}$ ，则： $A^n = PD^nP^{-1}$

这大大简化了矩阵幂的计算。

def matrix_power_application():
    """矩阵对角化在计算矩阵幂中的应用"""

    # 定义矩阵
    A = np.array([[2, 1],
                  [1, 2]], dtype=float)

    print("原矩阵 A:")
    print(A)

    # 对角化
    eigenvals, eigenvecs = eig(A)
    P = eigenvecs
    P_inv = inv(P)
    D = np.diag(eigenvals)

    print(f"\n对角化: A = PDP^(-1)")
    print(f"P = \n{P}")
    print(f"D = \n{D}")

    # 计算不同次幂
    powers = [2, 5, 10, 20]

    print(f"\n矩阵幂计算比较:")
    print("="*60)

    for n in powers:
        # 方法1: 直接计算（低效）
        A_power_direct = np.linalg.matrix_power(A, n)

        # 方法2: 使用对角化（高效）
        D_power = np.diag(eigenvals**n)
        A_power_diag = P @ D_power @ P_inv

        print(f"\nA^{n}:")
        print("直接计算:")
        print(A_power_direct)
        print("对角化计算:")
        print(A_power_diag)
        print(f"误差: {np.linalg.norm(A_power_direct - A_power_diag):.2e}")

    # 可视化特征值的幂次增长
    n_values = np.arange(1, 11)
    eigenval_powers = np.array([eigenvals**n for n in n_values])

    plt.figure(figsize=(12, 5))

    plt.subplot(1, 2, 1)
    for i, eigenval in enumerate(eigenvals):
        plt.plot(n_values, eigenval_powers[:, i], 'o-',
                label=f'λ{i+1} = {eigenval:.2f}', linewidth=2)

    plt.xlabel('n')
    plt.ylabel('λⁿ')
    plt.title('特征值的幂次')
    plt.legend()
    plt.grid(True, alpha=0.3)

    plt.subplot(1, 2, 2)
    for i, eigenval in enumerate(eigenvals):
        plt.semilogy(n_values, eigenval_powers[:, i], 'o-',
                    label=f'λ{i+1} = {eigenval:.2f}', linewidth=2)

    plt.xlabel('n')
    plt.ylabel('λⁿ (对数尺度)')
    plt.title('特征值幂次（对数尺度）')
    plt.legend()
    plt.grid(True, alpha=0.3)

    plt.tight_layout()
    plt.show()

    # 斐波那契数列应用
    print(f"\n应用案例：斐波那契数列")
    print("斐波那契递推关系可以写成矩阵形式:")
    print("[ F(n+1) ]   [ 1  1 ] [ F(n)   ]")
    print("[ F(n)   ] = [ 1  0 ] [ F(n-1) ]")

    fib_matrix = np.array([[1, 1],
                          [1, 0]], dtype=float)

    # 对角化斐波那契矩阵
    fib_eigenvals, fib_eigenvecs = eig(fib_matrix)
    fib_P = fib_eigenvecs
    fib_P_inv = inv(fib_P)

    print(f"\n斐波那契矩阵的特征值: {fib_eigenvals}")
    print("这些是黄金比例φ和-1/φ!")

    phi = (1 + np.sqrt(5)) / 2
    print(f"黄金比例 φ = {phi:.6f}")
    print(f"特征值1 = {fib_eigenvals[0]:.6f}")
    print(f"特征值2 = {fib_eigenvals[1]:.6f}")

    # 计算第n个斐波那契数
    def fibonacci_formula(n):
        """使用特征值公式计算斐波那契数"""
        phi = (1 + np.sqrt(5)) / 2
        psi = (1 - np.sqrt(5)) / 2
        return int((phi**n - psi**n) / np.sqrt(5))

    print(f"\n前15个斐波那契数:")
    for i in range(1, 16):
        fib_n = fibonacci_formula(i)
        print(f"F({i}) = {fib_n}")

matrix_power_application()

Jordan标准形简介

不可对角化矩阵的标准形

不是所有矩阵都可对角化，但每个矩阵都相似于一个Jordan标准形矩阵。

Jordan块的结构

Jordan块是形如下面的矩阵：

Apache Airflow 3.x

Chapter 1: Introduction to Apache Airflow 3.x

Chapter 2: Core Concepts and Architecture

Chapter 3: Writing Your First DAG

Chapter 4: Built-in Operators and Sensors

Apache Airflow 3.x

Chapter 1: Introduction to Apache Airflow 3.x

Chapter 2: Core Concepts and Architecture

Chapter 3: Writing Your First DAG

Chapter 4: Built-in Operators and Sensors

第11章：矩阵对角化理论

第11章：矩阵对角化理论

矩阵对角化的基本概念

定义

对角化的等价条件

相似矩阵的性质

相似矩阵的定义

相似矩阵的重要性质

对角化算法

标准对角化步骤

对角化的几何意义

坐标变换视角

对角化的应用：矩阵幂

快速计算矩阵幂

Jordan标准形简介

不可对角化矩阵的标准形

Jordan块的结构