18.06 第 34 讲：期末复习

最后一讲没有新内容，Strang 的做法是翻出老试卷，把题一道一道念出来，让全班一起想。我把每道题都交给 NumPy 过了一遍：一个 3 × 2 矩阵同时满足“一个右端项无解、另一个恰好一个解”， $\det(A^\mathsf{T}A) = 1$ 而 $\det(AA^\mathsf{T}) = 0$ ；Markov 矩阵从 $(0, 10, 0)$ 出发迭代 10 步，离稳态 $(3, 3, 4)$ 只剩 $7.24 \times 10^{-7}$ 。

本讲速览

视频：Lecture 34: Final course review（OCW 页面与字幕）教材：《Introduction to Linear Algebra》第 6 版全书第 1 到 8 章前置：第 33 讲：左逆、右逆与伪逆一句话：期末题考的几乎都是同一件事：看到 $m$ 、 $n$ 、 $r$ 就想到四个子空间，看到解的个数就想到零空间。

配合视频

开头几句是考试安排，可以跳过。第一道题（3 × $n$ 矩阵，一个右端项无解、一个有唯一解）值得认真看，他一步步把 $m$ 、 $n$ 、 $r$ 的关系推出来。
求 Markov 矩阵稳态向量的那一段，他在黑板上猜 $(3, 3, 4)$ ，猜之前冷了一会儿场，可以倍速。“总人数不变所以 $c_2 = 1$ ”这一句要听。
2 × 2 矩阵的快问快答和最后的最小二乘，本篇都已经算过，倍速即可。
结尾他向全班道谢。这是整门课的最后几句话，我觉得值得原速看完。

一个矩阵，三个数#

他的第一道题： 一个 $3 \times n$ 矩阵 $A$ ，已知 $A\mathbf{x} = (1, 0, 0)$ 无解， $A\mathbf{x} = (0, 1, 0)$ 恰好有一个解。 $m$ 、 $n$ 、 $r$ 能说什么？

推理只有两步。有的右端项无解，说明不是每一行都有主元，所以 $r < m$ ，而 $m$ 本来就是 3。有解时只有一个解，说明零空间里只有零向量，所以 $r = n$ ，列无关。合起来是 $r = n < m = 3$ 。

他要一个例子。我猜他心里想的是最省事的那个：只有一列 $(0, 1, 0)$ 。他也允许加第二列，我取 $(0, 0, 1)$ ，这样 $A^\mathsf{T}A$ 恰好是单位阵，后面的判断题好查：

A = \begin{bmatrix} 0 & 0 \\ 1 & 0 \\ 0 & 1 \end{bmatrix}

接着是三道判断题： $\det(A^\mathsf{T}A) = \det(AA^\mathsf{T})$ ； $A^\mathsf{T}A$ 可逆； $AA^\mathsf{T}$ 正定。最后他还要求证明 $A^\mathsf{T}\mathbf{y} = \mathbf{c}$ 对每个 $\mathbf{c}$ 都有解，而且有无穷多个解。下面一次全算：

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    # 3 x 2 的例子：列空间里有 (0, 1, 0) 和 (0, 0, 1)，没有 (1, 0, 0)
7
    A = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]])
8
    e1 = np.array([1.0, 0.0, 0.0])
9
    e2 = np.array([0.0, 1.0, 0.0])
10

11
    m, n = A.shape
12
    r = np.linalg.matrix_rank(A)
13
    print("m, n, r =", m, n, r)
14

15
    # Ax = (1, 0, 0) 没有解：最小二乘的残差不为 0
16
    for name, rhs in [("(1, 0, 0)", e1), ("(0, 1, 0)", e2)]:
17
        x, *_ = np.linalg.lstsq(A, rhs, rcond=None)
18
        print(
19
            f"Ax = {name}：x = {x}，残差 = {np.linalg.norm(A @ x - rhs):.4f}"
20
        )
21

22
    # 三个判断题
23
    AtA = A.T @ A
24
    AAt = A @ A.T
25
    print("AtA =")
26
    print(AtA)
27
    print("det(AtA) =", np.linalg.det(AtA), "，det(AAt) =", np.linalg.det(AAt))
28
    print("AAt 的特征值：", np.linalg.eigvalsh(AAt))
29
    print("AAt 的秩：", np.linalg.matrix_rank(AAt))
30

31
    # A^T y = c 对每个 c 有解，而且解不唯一：左零空间的维数是 m - r
32
    c = np.array([2.0, -5.0])
33
    y, *_ = np.linalg.lstsq(A.T, c, rcond=None)
34
    print("A^T y = c 的一个解 y =", y, "，残差 =", np.linalg.norm(A.T @ y - c))
35
    print("左零空间的维数 m - r =", m - r)
36
    y_other = y + 7.0 * e1
37
    print(
38
        "加上左零空间里的 7 * (1, 0, 0) 之后仍然是解：",
39
        np.allclose(A.T @ y_other, c),
40
    )
41

42

43
if __name__ == "__main__":
44
    main()

1
m, n, r = 3 2 2
2
Ax = (1, 0, 0)：x = [0. 0.]，残差 = 1.0000
3
Ax = (0, 1, 0)：x = [1. 0.]，残差 = 0.0000
4
AtA =
5
[[1. 0.]
6
 [0. 1.]]
7
det(AtA) = 1.0 ，det(AAt) = 0.0
8
AAt 的特征值： [0. 1. 1.]
9
AAt 的秩： 2
10
A^T y = c 的一个解 y = [ 0.  2. -5.] ，残差 = 0.0
11
左零空间的维数 m - r = 1
12
加上左零空间里的 7 * (1, 0, 0) 之后仍然是解： True

输出对着题目一条条读。

$r = n = 2 < m = 3$ ，和推理一致； $(1, 0, 0)$ 的最小二乘残差是 1.0000，没有精确解， $(0, 1, 0)$ 的残差是 0.0000。
$A^\mathsf{T}A$ 是单位阵，可逆（列无关），为真。
$\det(A^\mathsf{T}A) = 1.0$ ， $\det(AA^\mathsf{T}) = 0.0$ ，所以第一条为假。陷阱在于 $\det(AB) = \det(BA)$ 只对两个方阵成立： $A$ 是 3 × 2 时， $AA^\mathsf{T}$ 是 3 × 3、秩只有 2。
$AA^\mathsf{T}$ 的特征值是 $0, 1, 1$ ，有 0，所以不是正定，只是半正定。他说的“第一行一定全是 0”在这个例子里就是特征值 0 的来源。
$A^\mathsf{T}$ 是 $n \times m$ ，行无关（ $r = n$ ），所以 $A^\mathsf{T}\mathbf{y} = \mathbf{c}$ 总有解；左零空间的维数是 $m - r = 1 > 0$ ，所以解有无穷多个。代码里给解加上 $7(1, 0, 0)$ ，仍然满足方程。

整道题没有一步用到消元，全靠 $r$ 、 $m$ 、 $n$ 和四个子空间的维数（这套账 $r$ 、 $n - r$ 、 $r$ 、 $m - r$ 在第 10 讲里算过）。

三个列向量能说明什么#

第二道题： $A$ 有三列 $\mathbf{v}_1, \mathbf{v}_2, \mathbf{v}_3$ 。(a) 解 $A\mathbf{x} = \mathbf{v}_1 - \mathbf{v}_2 + \mathbf{v}_3$ ；(b) 如果这个组合等于零，解唯一吗；(c) 如果三个向量标准正交， $\mathbf{v}_1$ 与 $\mathbf{v}_2$ 的哪个组合最接近 $\mathbf{v}_3$ 。

(a) 是第一讲的“按列乘”， $\mathbf{x} = (1, -1, 1)$ 。(b) 组合为零，说明这个 $\mathbf{x}$ 在零空间里，解永远不唯一，因为总能把它加到任何解上。(c) 想象 $\mathbf{v}_1, \mathbf{v}_2, \mathbf{v}_3$ 是 $x$ 、 $y$ 、 $z$ 轴， $z$ 轴到 $xy$ 平面的最近点就是原点，答案是 0 份和 0 份。

我用固定种子的随机向量验证三问，(c) 用 np.linalg.qr 造一组标准正交的列：

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    rng = np.random.default_rng(1806)
7

8
    # (a) A x = v1 - v2 + v3，按列乘
9
    V = rng.standard_normal((4, 3))
10
    x = np.array([1.0, -1.0, 1.0])
11
    print(
12
        "(a) A @ x 等于 v1 - v2 + v3：",
13
        np.allclose(V @ x, V[:, 0] - V[:, 1] + V[:, 2]),
14
    )
15

16
    # (b) 如果 v1 - v2 + v3 = 0，则 (1, -1, 1) 在零空间里，解不唯一
17
    W = V.copy()
18
    W[:, 2] = W[:, 1] - W[:, 0]
19
    print("(b) W @ x =", W @ x)
20
    print("    W 的秩：", np.linalg.matrix_rank(W), "< 3，零空间不只有 0")
21

22
    # (c) 如果 v1, v2, v3 标准正交，v3 在 v1, v2 平面上的最近点是 0
23
    Q, _ = np.linalg.qr(rng.standard_normal((5, 3)))
24
    coef, *_ = np.linalg.lstsq(Q[:, :2], Q[:, 2], rcond=None)
25
    print(
26
        "(c) Q^T Q 与单位阵的距离：",
27
        f"{np.linalg.norm(Q.T @ Q - np.eye(3)):.1e}",
28
    )
29
    print(
30
        "    最近组合的系数 =",
31
        np.round(coef, 6) + 0.0,
32
        "，误差 =",
33
        f"{np.linalg.norm(Q[:, :2] @ coef - Q[:, 2]):.4f}",
34
    )
35

36

37
if __name__ == "__main__":
38
    main()

1
(a) A @ x 等于 v1 - v2 + v3： True
2
(b) W @ x = [0. 0. 0. 0.]
3
    W 的秩： 2 < 3，零空间不只有 0
4
(c) Q^T Q 与单位阵的距离： 3.3e-16
5
    最近组合的系数 = [0. 0.] ，误差 = 1.0000

(b) 里 $W\mathbf{x}$ 是零向量，秩是 2，小于 3。(c) 里 $Q^\mathsf{T}Q$ 离单位阵只差 $3.3 \times 10^{-16}$ ，最近组合的系数是两个 0，误差 1.0000，恰好是 $\mathbf{v}_3$ 自己的长度。标准正交的好处就在这里：投影时各个方向互不干扰，不用解正规方程。

Markov 矩阵与稳态#

第三道题： 给一个 Markov 矩阵，问特征值，再问从 $\mathbf{u}_0 = (0, 10, 0)$ 出发， $A^k\mathbf{u}_0$ 趋向哪里。

字幕是语音转写，矩阵的数字被听写得一团糟。我按他念的性质还原：每列和为 1、第一列加第二列等于两倍第三列、迹是 0.8、 $(3, 3, 4)$ 是 $\lambda = 1$ 的特征向量，得到

A = \begin{bmatrix} 0.2 & 0.4 & 0.3 \\ 0.4 & 0.2 & 0.3 \\ 0.4 & 0.4 & 0.4 \end{bmatrix}

这个矩阵同时满足上面全部四条，我认为就是黑板上的那个，不过这是还原，不是抄录。他的推理顺序是：列有线性关系，所以奇异，有一个特征值 0；Markov 矩阵必有特征值 1；迹是 0.8，所以第三个是 $0.8 - 0 - 1 = -0.2$ 。稳态只剩 $c_2\mathbf{x}_2$ ， $\mathbf{x}_2$ 是 $\lambda = 1$ 的特征向量， $c_2$ 靠“总人数不变”：起点总共 10 人，所以 $c_2 = 1$ ， $\mathbf{u}_\infty = (3, 3, 4)$ 。

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    A = np.array([[0.2, 0.4, 0.3], [0.4, 0.2, 0.3], [0.4, 0.4, 0.4]])
7
    u0 = np.array([0.0, 10.0, 0.0])
8

9
    print("列和：", A.sum(axis=0))
10
    print(
11
        "第一列加第二列等于两倍第三列：",
12
        np.allclose(A[:, 0] + A[:, 1], 2 * A[:, 2]),
13
    )
14
    print("迹：", np.trace(A), "，det：", f"{np.linalg.det(A):.1e}")
15
    print("特征值：", np.sort(np.linalg.eigvals(A).real))
16

17
    # 稳态：lambda = 1 的特征向量，按总人数 10 缩放
18
    lam, S = np.linalg.eig(A)
19
    x = S[:, np.argmin(np.abs(lam - 1.0))].real
20
    steady = 10.0 * x / x.sum()
21
    print(
22
        "稳态 u_inf =",
23
        steady,
24
        "，A @ u_inf 不变：",
25
        np.allclose(A @ steady, steady),
26
    )
27

28
    # 误差按 (-0.2)^k 衰减
29
    u = u0.copy()
30
    for k in range(1, 11):
31
        u = A @ u
32
        if k in (1, 2, 5, 10):
33
            print(
34
                f"k = {k:2d}：u = {u}，到稳态的距离 =",
35
                f"{np.linalg.norm(u - steady):.2e}",
36
            )
37

38

39
if __name__ == "__main__":
40
    main()

1
列和： [1. 1. 1.]
2
第一列加第二列等于两倍第三列： True
3
迹： 0.8 ，det： -6.7e-18
4
特征值： [-0.2  0.   1. ]
5
稳态 u_inf = [3. 3. 4.] ，A @ u_inf 不变： True
6
k =  1：u = [4. 2. 4.]，到稳态的距离 = 1.41e+00
7
k =  2：u = [2.8 3.2 4. ]，到稳态的距离 = 2.83e-01
8
k =  5：u = [3.0016 2.9984 4.    ]，到稳态的距离 = 2.26e-03
9
k = 10：u = [3. 3. 4.]，到稳态的距离 = 7.24e-07

特征值是 $-0.2, 0, 1$ ，稳态正好是 $(3, 3, 4)$ ，每一步误差大约缩小到原来的 $0.2$ 倍： $k = 5$ 时离稳态 $2.26 \times 10^{-3}$ ， $k = 10$ 时 $7.24 \times 10^{-7}$ ，从第 1 步到第 10 步缩小了约 $2 \times 10^6$ 倍。行列式打印出 $-6.7 \times 10^{-18}$ ，那是浮点误差，真值是 0。

2 × 2 快问快答#

第四组： 他念性质，全班给 2 × 2 的例子，没有就说没有。

投影到过 $\mathbf{a} = (4, -3)$ 的直线： $P = \mathbf{a}\mathbf{a}^\mathsf{T} / \mathbf{a}^\mathsf{T}\mathbf{a}$ ，分母是个数，直接除。
特征值 0 和 3，特征向量 $(1, 2)$ 和 $(2, 1)$ ： $A = S\Lambda S^{-1}$ 。
不能写成 $B^\mathsf{T}B$ 的实矩阵： $B^\mathsf{T}B$ 总是对称的，所以任意一个不对称矩阵都行。
特征向量正交但不对称：反对称矩阵或正交（旋转）矩阵，特征向量是复的，但在复内积下正交。

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6

7
    # 1. 投影到过 a = (4, -3) 的直线
8
    a = np.array([[4.0], [-3.0]])
9
    P = a @ a.T / (a.T @ a)
10
    print("P =")
11
    print(P)
12
    print(
13
        "P @ P == P：",
14
        np.allclose(P @ P, P),
15
        "，P.T == P：",
16
        np.allclose(P.T, P),
17
    )
18

19
    # 2. 特征值 0 与 3，特征向量 (1, 2) 与 (2, 1)
20
    S = np.array([[1.0, 2.0], [2.0, 1.0]])
21
    Lam = np.diag([0.0, 3.0])
22
    A = S @ Lam @ np.linalg.inv(S)
23
    print("A = S Lam S^-1 =")
24
    print(A)
25
    print("特征值：", np.sort(np.linalg.eigvals(A).real))
26

27
    # 3. 不对称的矩阵不可能写成 B^T B
28
    N = np.array([[1.0, 2.0], [0.0, 1.0]])
29
    print("N 对称吗：", np.allclose(N, N.T))
30

31
    # 4. 反对称与正交矩阵：特征向量复正交，但矩阵不对称
32
    theta = 0.7
33
    K = np.array([[0.0, 1.0], [-1.0, 0.0]])
34
    Q = np.array(
35
        [[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]]
36
    )
37
    for name, M in [("反对称 K", K), ("旋转 Q", Q)]:
38
        lam, V = np.linalg.eig(M)
39
        inner = np.vdot(V[:, 0], V[:, 1])
40
        print(
41
            name,
42
            "：特征值",
43
            lam,
44
            "，复内积 =",
45
            f"{abs(inner):.1e}",
46
            "，对称：",
47
            np.allclose(M, M.T),
48
        )
49

50

51
if __name__ == "__main__":
52
    main()

1
P =
2
[[ 0.64 -0.48]
3
 [-0.48  0.36]]
4
P @ P == P： True ，P.T == P： True
5
A = S Lam S^-1 =
6
[[ 4. -2.]
7
 [ 2. -1.]]
8
特征值： [0. 3.]
9
N 对称吗： False
10
反对称 K ：特征值 [0.+1.j 0.-1.j] ，复内积 = 0.0e+00 ，对称： False
11
旋转 Q ：特征值 [0.7648+0.6442j 0.7648-0.6442j] ，复内积 = 0.0e+00 ，对称： False

$P$ 满足 $P^2 = P$ 与 $P^\mathsf{T} = P$ 。 $S\Lambda S^{-1}$ 给出 $\begin{bmatrix} 4 & -2 \\ 2 & -1 \end{bmatrix}$ ，特征值回到 0 和 3。最后一条里，反对称矩阵的特征值是 $\pm i$ ，旋转 0.7 弧度的矩阵是 $\cos 0.7 \pm i \sin 0.7$ ，两者的特征向量复内积都是 0，矩阵却都不对称。复内积我用 np.vdot 算，它会自动取共轭，这是第 26 讲的内容。

最小二乘：给答案，找问题#

最后一道： 他说像 Jeopardy 节目，先给答案再问问题。系统是

\begin{bmatrix} 1 & 0 \\ 1 & 1 \\ 1 & 2 \end{bmatrix} \begin{bmatrix} C \\ D \end{bmatrix} = \begin{bmatrix} 3 \\ 4 \\ 1 \end{bmatrix}

最小二乘解是 $(\hat{C}, \hat{D}) = (11/3, -1)$ 。问题有三个： $\mathbf{b}$ 在列空间上的投影 $\mathbf{p}$ 是什么；对应的直线拟合问题画出来是什么样；再找一个不全为零的 $\mathbf{b}$ ，让最小二乘解变成零。

答案依次是： $\mathbf{p} = \frac{11}{3}\,\text{列一} - \text{列二}$ ，最小二乘找的就是“列的最近组合”；直线在 $t = 0, 1, 2$ 处拟合高度 $3, 4, 1$ ，截距 $11/3$ 、斜率 $-1$ ；最后， $\mathbf{b}$ 要和两列都正交，比如 $(1, -2, 1)$ 。

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    A = np.array([[1.0, 0.0], [1.0, 1.0], [1.0, 2.0]])
7
    b = np.array([3.0, 4.0, 1.0])
8

9
    # 正规方程与 lstsq
10
    x_hat = np.linalg.solve(A.T @ A, A.T @ b)
11
    x_lstsq, *_ = np.linalg.lstsq(A, b, rcond=None)
12
    print("x_hat =", x_hat, "，11/3 =", 11 / 3)
13
    print("两种解法一致：", np.allclose(x_hat, x_lstsq))
14

15
    # 投影 p = A x_hat：11/3 倍列一，减一倍列二
16
    p = A @ x_hat
17
    print("p =", p)
18
    print(
19
        "p = 11/3 * 列一 - 列二：", np.allclose(p, 11 / 3 * A[:, 0] - A[:, 1])
20
    )
21
    print("误差 b - p 与两列正交：", np.allclose(A.T @ (b - p), 0))
22
    print(
23
        "||b|| =",
24
        f"{np.linalg.norm(b):.4f}",
25
        "，||p|| =",
26
        f"{np.linalg.norm(p):.4f}",
27
        "，||b - p|| =",
28
        f"{np.linalg.norm(b - p):.4f}",
29
    )
30

31
    # 最小二乘解是 0 的 b：与两列都正交，比如 (1, -2, 1)
32
    b0 = np.array([1.0, -2.0, 1.0])
33
    print("A^T b0 =", A.T @ b0)
34
    x0, *_ = np.linalg.lstsq(A, b0, rcond=None)
35
    print("b0 的最小二乘解 =", x0 + 0.0)
36

37

38
if __name__ == "__main__":
39
    main()

1
x_hat = [ 3.6667 -1.    ] ，11/3 = 3.6666666666666665
2
两种解法一致： True
3
p = [3.6667 2.6667 1.6667]
4
p = 11/3 * 列一 - 列二： True
5
误差 b - p 与两列正交： True
6
||b|| = 5.0990 ，||p|| = 4.8305 ，||b - p|| = 1.6330
7
A^T b0 = [0. 0.]
8
b0 的最小二乘解 = [0. 0.]

$\mathbf{p} = (3.6667, 2.6667, 1.6667)$ 。勾股定理在这里看得很清楚： $\|\mathbf{b}\| = 5.0990$ ，投影 $\|\mathbf{p}\| = 4.8305$ ，误差 $\|\mathbf{b} - \mathbf{p}\| = 1.6330$ ， $4.8305^2 + 1.6330^2 = 26.00 = 5.0990^2$ 。 $A^\mathsf{T}\mathbf{b}_0 = (0, 0)$ ，所以 $\mathbf{b}_0 = (1, -2, 1)$ 的最小二乘解是零。

他念完这道题就收了，说一个小时只能做这么多，考试有三个小时。

如果你是从第 1 讲一路跟下来的，到这里 35 篇就结束了。接下来可以去看 Strang 的另一门课 18.065（Matrix Methods in Data Analysis, Signal Processing, and Machine Learning），它默认你已经学过 18.06，SVD、低秩近似和优化会用得更多。以前我看到 $A\mathbf{x} = \mathbf{b}$ 只会想到“解”，现在想到的是“列的组合”，这个变化，大概是这个系列最大的收获。

音乐

音乐