18.06 第 9 讲：线性无关、基与维数

这一讲 Strang 给四个词下了定义：线性无关、张成、基、维数。我把四个词都翻译成了同一个操作：把向量放进矩阵的列，算秩，找零空间。固定种子取 1000 个随机的 100 × 100 矩阵，1000 个全是满秩，也就是“随机向量几乎总是无关”；而在另一头，我人为造了一组只差 $10^{-12}$ 的相关向量，matrix_rank 判它们是秩 3，也就是“无关”。这两个数字合起来，就是这一讲的数学定义和浮点数之间的距离。

本讲速览

视频：Lecture 9: Independence, basis, and dimension（OCW 页面与字幕）教材：《Introduction to Linear Algebra》第 6 版 §3.4 Independence, Basis, and Dimension 前置：第 8 讲：解 Ax = b，行最简形 R 一句话：把向量放进矩阵的列，它们无关当且仅当零空间只有零向量；列空间的维数是秩 $r$ ，零空间的维数是 $n - r$ 。

配合视频

开头他先回顾“未知数比方程多，零空间里一定有非零向量”，这一段是整讲的伏笔，值得认真听。
讲无关的那一段（ $\mathbf{v}$ 和 $2\mathbf{v}$ 、含零向量、平面里的三个向量）很短，本篇第一节已经用代码算过，可以倍速。
他在黑板上反复追问“给我另一组基”，那一段看一遍就行，本篇第二、三节有对应的代码。
最后三分钟是零空间的维数，两个特解就是零空间的基，这是下一讲的预告，别漏。

线性无关：看零空间#

他先说了一条上一讲留下的事实： $A$ 是 $m \times n$ 的矩阵，如果 $n > m$ （未知数比方程多），那么 $A\mathbf{x} = \mathbf{0}$ 一定有非零解。理由是消元之后主元最多 $m$ 个，至少剩下 $n - m$ 个自由变量，自由变量可以随便取 1，再回代解出主变量。

线性无关是什么？ 一堆向量 $\mathbf{x}_1, \dots, \mathbf{x}_n$ ，如果

c_1 \mathbf{x}_1 + c_2 \mathbf{x}_2 + \cdots + c_n \mathbf{x}_n = \mathbf{0}

除了所有 $c_i$ 都是 0 之外别无解，它们就线性无关；若还有别的 $c$ 能凑出零向量，它们就线性相关。他特地强调：说的是“一堆向量”无关，不说“一个矩阵”无关。

接着他举了三个例子： $\mathbf{v}$ 和 $2\mathbf{v}$ （两份第一个减去第二个就是零，相关）、 $\mathbf{v}$ 和零向量（零向量那一份随便取几都行，“只要里面有零向量，无关就死了”）、平面里的三个向量（必然相关）。第三个例子里他是这样看的：把三个向量放进 $A$ 的三列， $A$ 是 $2 \times 3$ ，列比行多，零空间里一定有非零的 $\mathbf{c}$ ，这个 $\mathbf{c}$ 就是“往 $\mathbf{v}_1$ 走几步，往 $\mathbf{v}_2$ 走几步，再往 $\mathbf{v}_3$ 退几步，回到原点”。

这一下就把定义翻译成了矩阵语言：

列无关 $\iff$ $N(A) = \{\mathbf{0}\}$ $\iff$ 没有自由变量 $\iff$ 秩 $r = n$ 。
列相关 $\iff$ 零空间里有非零向量 $\iff$ 有自由变量 $\iff$ $r < n$ 。

我按字幕里他随手画的数取 $\mathbf{v}_1 = (2, 1)$ 、 $\mathbf{v}_2 = (1, 2)$ 、 $\mathbf{v}_3 = (2.5, -1)$ （字幕是语音转写，“two and a half, minus one”我就照字面取了，他自己也说没画准）。下面的脚本做三件事：判三个向量是否无关，找出那个凑出零的 $\mathbf{c}$ ，再把三种“一眼就相关”的情形跑一遍。零空间向量我用 SVD 的最后一个右奇异向量得到，这个办法后面几讲会解释，现在只当它是“零空间里的一个单位向量”：

1
import numpy as np
2

3

4
def null_vector(A: np.ndarray) -> np.ndarray:
5
    """返回 A 的零空间里的一个单位向量（A 的列相关时才有意义）。"""
6
    _, _, Vt = np.linalg.svd(A)
7
    return Vt[-1]
8

9

10
def main() -> None:
11
    np.set_printoptions(precision=4, suppress=True)
12

13
    # 平面里的三个向量：把它们放进 A 的三列，A 是 2 x 3
14
    v1 = np.array([2.0, 1.0])
15
    v2 = np.array([1.0, 2.0])
16
    v3 = np.array([2.5, -1.0])
17
    A = np.column_stack([v1, v2, v3])
18
    print("A 的形状：", A.shape, "，秩 =", np.linalg.matrix_rank(A))
19
    print("独立的条件是秩 = 列数 3：", np.linalg.matrix_rank(A) == 3)
20

21
    # 列比行多，零空间里一定有非零向量 c
22
    c = null_vector(A)
23
    print("零空间里的 c =", c)
24
    print("c1 v1 + c2 v2 + c3 v3 =", A @ c)
25

26
    # 只取前两个向量，秩 = 2 = 列数，独立
27
    print("v1, v2 的秩：", np.linalg.matrix_rank(A[:, :2]))
28

29
    # 三种一眼就相关的情形：v 与 2v，含零向量
30
    v = np.array([2.0, 1.0])
31
    pairs = {
32
        "v 与 2v": np.column_stack([v, 2 * v]),
33
        "v 与零向量": np.column_stack([v, np.zeros(2)]),
34
        "v1 与 v2": np.column_stack([v1, v2]),
35
    }
36
    for name, M in pairs.items():
37
        r = np.linalg.matrix_rank(M)
38
        print(f"{name}：秩 = {r}，列数 = {M.shape[1]}，独立：{r == 2}")
39

40

41
if __name__ == "__main__":
42
    main()

1
A 的形状： (2, 3) ，秩 = 2
2
独立的条件是秩 = 列数 3： False
3
零空间里的 c = [-0.7428  0.5571  0.3714]
4
c1 v1 + c2 v2 + c3 v3 = [ 0. -0.]
5
v1, v2 的秩： 2
6
v 与 2v：秩 = 1，列数 = 2，独立：False
7
v 与零向量：秩 = 1，列数 = 2，独立：False
8
v1 与 v2：秩 = 2，列数 = 2，独立：True

$2 \times 3$ 的矩阵秩最多是 2，所以三列不可能无关，这是“列比行多”的直接后果。c 的三个分量满足 $-0.7428\,\mathbf{v}_1 + 0.5571\,\mathbf{v}_2 + 0.3714\,\mathbf{v}_3 = \mathbf{0}$ ，右边打印出来的 [ 0. -0.] 就是验证（-0. 是浮点数的负零，不是错误）。把 $\mathbf{c}$ 同时除以 0.3714，得到 $(-2, 1.5, 1)$ ，你可以手算验一遍：第一个分量 $-4 + 1.5 + 2.5 = 0$ ，第二个 $-2 + 3 - 1 = 0$ 。

张成与基：不多不少#

张成是什么？ 一堆向量张成一个空间，意思是这个空间就是它们所有线性组合的集合。他说这个词其实早就用过了：矩阵的列张成列空间。他补了一句：这堆向量张成的空间是包含它们的最小空间，因为任何含有这些向量的空间都必须含有它们的所有组合。

单看张成不够，列可能有冗余；单看无关也不够，向量可能太少。基是什么？ 同时满足两条：无关，并且张成这个空间。他的说法是“刚刚好”：少一个张不满，多一个就相关。这有点像点菜，少一道吃不饱，多一道吃不完，只有刚好的那一桌才既不饿也不浪费。往后每次问到子空间，他都会问“给我一组基”，因为基就是对这个子空间的完整描述。

他的第一个例子是 $\mathbb{R}^3$ 。最先想到的基是 $x$ 、 $y$ 、 $z$ 轴方向的三个单位向量，也就是单位矩阵的三列，零空间只有零向量，所以无关。第二个例子，他从 $(1, 1, 2)$ 和 $(2, 2, 5)$ 开始：两个向量无关，但张不满 $\mathbb{R}^3$ 。要补第三个。补 $(3, 3, 7)$ 是个“失误”，因为它恰好是前两个之和，躺在同一个平面里。补 $(3, 3, 8)$ 呢？他说“希望这个行”，然后问：如果我挑的是别的数，比如 $(5, 7, -14)$ ，我怎么知道？答案是放进矩阵的列，做消元，看有没有自由变量；对方阵来说，等价于矩阵可逆。

我把这三个候选逐个交给 NumPy，结果和字幕里的猜测不太一样：

1
import numpy as np
2

3

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

7
    # R^3 的第一组基：单位矩阵的三列
8
    print("单位矩阵的秩：", np.linalg.matrix_rank(np.eye(3)))
9

10
    # 只有两个向量：独立，但张不满 R^3
11
    B2 = np.array([[1.0, 2.0], [1.0, 2.0], [2.0, 5.0]])
12
    print("(1,1,2) 与 (2,2,5) 的秩：", np.linalg.matrix_rank(B2))
13

14
    # 第三个向量逐个试：秩 = 3 才是基（方阵时等价于 det 非零）
15
    for third in ([3.0, 3.0, 7.0], [3.0, 3.0, 8.0], [5.0, 7.0, -14.0]):
16
        M = np.column_stack([B2, third])
17
        r = np.linalg.matrix_rank(M)
18
        print(f"补 {third}：秩 = {r}，det = {np.linalg.det(M):.4f}")
19

20
    # 前两个向量的第一、二个分量总相等，它们张成的平面是 x = y
21
    # (3, 3, 8) 也满足 x = y，所以它还在这个平面里
22
    print("B2 的两列满足 x = y：", np.allclose(B2[0], B2[1]))
23

24
    # 补 (5, 7, -14) 得到一组基：任意向量都有唯一的坐标
25
    good = np.column_stack([B2, [5.0, 7.0, -14.0]])
26
    x = np.array([1.0, -2.0, 3.0])
27
    coeff = np.linalg.solve(good, x)
28
    print("x 在这组基下的坐标：", coeff)
29
    print("坐标重新组合回 x：", np.allclose(good @ coeff, x))
30

31

32
if __name__ == "__main__":
33
    main()

1
单位矩阵的秩： 3
2
(1,1,2) 与 (2,2,5) 的秩： 2
3
补 [3.0, 3.0, 7.0]：秩 = 2，det = 0.0000
4
补 [3.0, 3.0, 8.0]：秩 = 2，det = 0.0000
5
补 [5.0, 7.0, -14.0]：秩 = 3，det = -2.0000
6
B2 的两列满足 x = y： True
7
x 在这组基下的坐标： [ 78.5 -35.   -1.5]
8
坐标重新组合回 x： True

$(3, 3, 8)$ 也是相关的：前两个向量的第一、第二个分量都相等，它们张成的平面就是 $x = y$ ，而 $(3, 3, 8)$ 的前两个分量也相等，所以它同样躺在这个平面里。这是 Strang 自己挑错了数字：他说“希望 3 3 8 可以”，课后有同学指出来，他在第 10 讲开头更正了。这个“挑数字挑错了”的插曲反而把他想说的事演示了：肉眼挑，十有八九会翻车，要用矩阵检验。（我这里再试一次运气， $(5, 7, -14)$ 通过，行列式是 $-2$ 。）

补上 $(5, 7, -14)$ 之后，方阵 good 可逆，任意 $\mathbf{x}$ 都能唯一地写成三列的组合。随手取的 $\mathbf{x} = (1, -2, 3)$ 在这组基下的坐标是 $(78.5, -35, -1.5)$ ，系数不小，我猜是因为这三个向量彼此并不“垂直”，拼一个普通的向量得靠大系数互相抵消（我没有算条件数去证实，这只是猜测）。基有好坏之分，后面讲正交基的时候会回来。

还有一个他强调了两次的事实：基不唯一。任何可逆的 $3 \times 3$ 矩阵的列都是 $\mathbb{R}^3$ 的一组基，有无穷多组。但所有的基有一个共同点：向量个数相同。

维数：基里有几个向量#

维数是什么？ 对一个空间，所有基含有的向量个数相同，这个数就是它的维数。 $\mathbb{R}^3$ 的每组基都有 3 个向量；某个子空间的一组基有 6 个向量，那它的所有基都是 6 个。他说这是“定义性”的：维数就是基的向量个数，它回答的是“这个空间有多大”。

这里有一个用词上的提醒，我觉得值得抄下来：

矩阵有秩，没有“维数”。
子空间有维数，没有“秩”。
秩是列空间的维数，所以说“列空间的维数”，不说“ $A$ 的维数”。

他说，用词对了，就说明概念对了。

他用的矩阵是一个 $3 \times 4$ 的例子：四列依次是 $(1, 1, 1)$ 、 $(2, 1, 2)$ 、 $(3, 2, 3)$ 、 $(1, 1, 1)$ 。第三列是前两列之和，第四列重复第一列。问题是：四列张成列空间，但是否是基？不是，因为 $-1$ 份第一列、 $-1$ 份第二列、 $1$ 份第三列、 $0$ 份第四列加起来是零向量，零空间里有非零向量。

他的回答是：自然的基是主列，也就是第一、第二列。从左往右扫，第一列可以放进基，第二列也可以，第三列不能（它是前两列的组合），第四列也不能。所以秩是 2，主列有 2 个，列空间的维数也是 2：秩、主列个数、列空间维数是同一个数。然后他让大家说“另一组基”：第一、三列，第二、三列，第二、四列都行，甚至不是 $A$ 的列的也行，比如 $(2, 2, 2)$ 和 $(7, 5, 7)$ （后者是四列之和）。

最后是一个我觉得很实用的小定理：如果你已经知道空间的维数是 $d$ ，并且手里有 $d$ 个无关的向量，它们自动就是基，张成是白送的。因为如果张不满，就还缺一个向量来补，那时候就会有 $d + 1$ 个无关向量，超过了维数。

这一节所有的断言，我用一个脚本一并验证。其中的“主列”和“特解”都是手写的（主列：从左到右，加入这一列使秩增加，它就是主列；特解：自由变量取 1，其余自由变量取 0，再解主变量），用 np.linalg.matrix_rank 对照：

1
import numpy as np
2

3

4
def pivot_columns(A: np.ndarray) -> list[int]:
5
    """从左到右：这一列让秩增加，就是主列。"""
6
    pivots: list[int] = []
7
    for j in range(A.shape[1]):
8
        if np.linalg.matrix_rank(A[:, pivots + [j]]) > len(pivots):
9
            pivots.append(j)
10
    return pivots
11

12

13
def special_solutions(A: np.ndarray, pivots: list[int]) -> np.ndarray:
14
    """每个自由列取 1、其余自由列取 0，再解出主变量。"""
15
    n = A.shape[1]
16
    free = [j for j in range(n) if j not in pivots]
17
    N = np.zeros((n, len(free)))
18
    for k, j in enumerate(free):
19
        N[j, k] = 1.0
20
        N[pivots, k], *_ = np.linalg.lstsq(A[:, pivots], -A[:, j], rcond=None)
21
    return N
22

23

24
def main() -> None:
25
    np.set_printoptions(precision=4, suppress=True)
26

27
    # Strang 的矩阵：四列依次是 (1,1,1)、(2,1,2)、(3,2,3)、(1,1,1)
28
    A = np.array(
29
        [
30
            [1.0, 2.0, 3.0, 1.0],
31
            [1.0, 1.0, 2.0, 1.0],
32
            [1.0, 2.0, 3.0, 1.0],
33
        ]
34
    )
35
    m, n = A.shape
36
    r = np.linalg.matrix_rank(A)
37
    print("A =")
38
    print(A)
39
    print(f"m = {m}, n = {n}, 秩 r = {r}")
40

41
    # 列空间：主列就是一组基，维数 = 秩
42
    pivots = pivot_columns(A)
43
    print("主列（从 0 数起）：", pivots, "，列空间的维数 =", len(pivots))
44

45
    # 零空间：特解就是一组基，维数 = n - r
46
    N = special_solutions(A, pivots)
47
    print("特解矩阵 N（每列一个特解）：")
48
    print(N)
49
    print("A @ N = 0：", np.allclose(A @ N, 0))
50
    print(
51
        "零空间的维数 n - r =", n - r, "，N 的秩 =", np.linalg.matrix_rank(N)
52
    )
53

54
    # 他说的第一个组合：-1 份第一列，-1 份第二列，1 份第三列，0 份第四列
55
    c = np.array([-1.0, -1.0, 1.0, 0.0])
56
    print("A @ (-1, -1, 1, 0) =", A @ c)
57

58
    # 另一组基：不是 A 的列，但在列空间里。7 5 7 是四列之和
59
    B = np.column_stack([[2, 2, 2], [7, 5, 7]]).astype(float)
60
    print("B 的秩：", np.linalg.matrix_rank(B))
61
    print(
62
        "B 的列都在列空间里：", np.linalg.matrix_rank(np.hstack([A, B])) == r
63
    )
64
    print("四列之和 =", A @ np.ones(4))
65

66

67
if __name__ == "__main__":
68
    main()

1
A =
2
[[1. 2. 3. 1.]
3
 [1. 1. 2. 1.]
4
 [1. 2. 3. 1.]]
5
m = 3, n = 4, 秩 r = 2
6
主列（从 0 数起）： [0, 1] ，列空间的维数 = 2
7
特解矩阵 N（每列一个特解）：
8
[[-1. -1.]
9
 [-1.  0.]
10
 [ 1.  0.]
11
 [ 0.  1.]]
12
A @ N = 0： True
13
零空间的维数 n - r = 2 ，N 的秩 = 2
14
A @ (-1, -1, 1, 0) = [0. 0. 0.]
15
B 的秩： 2
16
B 的列都在列空间里： True
17
四列之和 = [7. 5. 7.]

零空间的维数是 n - r#

最后几分钟他转向零空间。刚才那个非零向量 $(-1, -1, 1, 0)$ 只是零空间里的一个向量，零空间里还有别的。自然的选择是：第四列是自由列，令这个自由变量为 1、另一个自由变量（第三列）为 0，问第四列是不是主列的组合。是的，它就是第一列，所以 $(-1, 0, 0, 1)$ 在零空间里。这两个向量正是上一讲的特解：每个自由变量轮流取 1，其他自由变量取 0。

它们无关，而且张成整个零空间，所以是零空间的一组基，零空间的维数是 2。更一般地： $n$ 列里有 $r$ 个主列，剩下 $n - r$ 个自由列，每个自由列给一个特解，因此

\dim C(A) = r, \qquad \dim N(A) = n - r.

上面代码块的输出正对着这两个公式： $m = 3$ 、 $n = 4$ 、 $r = 2$ ，主列是第 0、1 列（从 0 数起），特解矩阵 N 的两列正是 $(-1, -1, 1, 0)$ 和 $(-1, 0, 0, 1)$ ，A @ N 全零， $N$ 的秩是 2。零空间里的向量就是“这些列相关的方式”：每一个特解告诉你，哪几列怎么组合能得零。

浮点数里的“几乎无关”#

定义是干净的：要么无关，要么相关。但 np.linalg.matrix_rank 判的是数值秩，它拿奇异值和一个阈值比（默认阈值约为 $\sigma_{\max} \cdot \max(m, n) \cdot \varepsilon$ ， $\varepsilon \approx 2.2 \times 10^{-16}$ ），低于阈值的奇异值当成 0。所以“相关”在浮点数里是有一个模糊带的。下面的脚本做两个实验。第一个：固定种子取随机向量，看它们是不是几乎总是无关（他在第 1 讲说过“MATLAB 的随机矩阵几乎一定可逆”）；并且验证 $n + 1$ 个 $n$ 维向量必相关。第二个：第三列取前两列之和，再加上噪声，看噪声多小时 matrix_rank 会被“骗过去”：

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
    # 随机取 n 个 n 维向量：几乎总是独立（秩 = n）
9
    for n in (3, 10, 100):
10
        trials = 1000
11
        full = sum(
12
            np.linalg.matrix_rank(rng.standard_normal((n, n))) == n
13
            for _ in range(trials)
14
        )
15
        print(f"n = {n:3d}：{trials} 次里有 {full} 次秩为 n")
16

17
    # 取 n + 1 个 n 维向量：必相关，零空间至少一维
18
    n = 5
19
    M = rng.standard_normal((n, n + 1))
20
    print("5 维里取 6 个向量，秩 =", np.linalg.matrix_rank(M))
21
    _, s, Vt = np.linalg.svd(M)
22
    c = Vt[-1]
23
    print("‖M c‖ =", f"{np.linalg.norm(M @ c):.2e}")
24

25
    # 浮点数里的“相关”：第三列 = 前两列之和，再加一点点噪声
26
    base = rng.standard_normal((4, 2))
27
    third = base[:, 0] + base[:, 1]
28
    for eps in (0.0, 1e-16, 1e-12, 1e-8, 1e-4):
29
        noise = eps * rng.standard_normal(4)
30
        M = np.column_stack([base, third + noise])
31
        s = np.linalg.svd(M, compute_uv=False)
32
        print(
33
            f"噪声 {eps:7.0e}：最小奇异值 = {s[-1]:.2e}，"
34
            f"秩 = {np.linalg.matrix_rank(M)}"
35
        )
36

37

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

1
n =   3：1000 次里有 1000 次秩为 n
2
n =  10：1000 次里有 1000 次秩为 n
3
n = 100：1000 次里有 1000 次秩为 n
4
5 维里取 6 个向量，秩 = 5
5
‖M c‖ = 4.79e-16
6
噪声   0e+00：最小奇异值 = 9.16e-17，秩 = 2
7
噪声   1e-16：最小奇异值 = 2.18e-16，秩 = 2
8
噪声   1e-12：最小奇异值 = 9.42e-13，秩 = 3
9
噪声   1e-08：最小奇异值 = 9.92e-09，秩 = 3
10
噪声   1e-04：最小奇异值 = 5.54e-05，秩 = 3

前三行：随机取向量，在 $n = 3, 10, 100$ 三种规模下各试 1000 次，每一次都是满秩，随机向量“几乎总是无关”不是夸张。第四、五行：5 维空间里的 6 个向量，秩最多 5，所以必相关，找到的 $\mathbf{c}$ 让 $\|M\mathbf{c}\| = 4.79 \times 10^{-16}$ ，也就是舍入误差的水平。

最后五行是我觉得最有意思的。第三列是前两列的精确之和时（噪声 0），最小奇异值是 $9.16 \times 10^{-17}$ ，判相关，对的。噪声只有 $10^{-16}$ 时最小奇异值是 $2.18 \times 10^{-16}$ ，还在阈值之下，判相关。可是噪声涨到 $10^{-12}$ ，最小奇异值 $9.42 \times 10^{-13}$ 已经高于阈值，matrix_rank 就判秩 3，也就是“无关”了。严格地说，这三列在数学上是无关的（噪声不为零），所以 NumPy 没有错。但如果这个噪声只是测量误差，那么它判的“无关”就没有意义。

我的结论是：数学里的无关是一个二选一，数值里的“秩”是一个带阈值的判断，阈值怎么取要看这个噪声是不是你关心的东西。后面讲 SVD 时，我会换一个角度处理这件事：奇异值是多少，比“秩是几”携带的信息多得多。（所以我在日常里更愿意看最小奇异值，而不是只看 matrix_rank 的那个整数。）

这一讲算是把前八讲反复出现的词都落了地：消元找主元，主元是几个，秩就是几；自由变量是几个，零空间就是几维。下一讲要把列空间、零空间再配上它们的两个“转置版本”，凑齐四个基本子空间，并把它们的维数 $r$ 、 $n - r$ 、 $r$ 、 $m - r$ 一次说完，见 18.06 第 10 讲：四个基本子空间。

音乐

音乐