18.06 第 33 讲：左逆、右逆与伪逆

矩阵一般没有逆，但几乎每个矩阵都有“最接近逆”的东西：满列秩的有左逆，满行秩的有右逆，什么秩都没有的还有伪逆。Strang 这一讲把它们放进同一幅四个子空间的图里讲清楚。我在一个秩 2 的 4 × 3 矩阵上试了一下，给它加 1e-12 的噪声，朴素的 $(A^\mathsf{T}A)^{-1}A^\mathsf{T}$ 算出来和真正的 $A^+$ 差 9.23e+02，而截掉小奇异值的伪逆只差 7.10e-13。差了十五个数量级，原因就藏在这一讲里。

本讲速览

视频：Lecture 33: Left and right inverses; pseudoinverse（OCW 页面与字幕）教材：《Introduction to Linear Algebra》第 6 版 §4.5 The Pseudoinverse of a Matrix 前置：第 32 讲：第三次测验复习一句话：一个 $m \times n$ 、秩为 $r$ 的矩阵，在行空间和列空间之间是一一对应的，把这个对应反过来、再把零空间的部分扔掉，就是伪逆 $A^+$ ；满列秩时它是左逆，满行秩时它是右逆。

配合视频

开头几分钟聊测验成绩和他的生日会议，可以跳过。
他在黑板上把 $r$ 、 $m$ 、 $n$ 的关系分四种情形过了一遍（两边可逆、只有左逆、只有右逆、什么都没有）。这是对整门课的复习，值得认真看，我在前三节里逐个用代码走了一遍。
他证明“行空间里的两个不同向量被 $A$ 映成两个不同向量”的那几句话很短，用的是零空间与行空间只交于零向量。这一段建议跟着他的思路听一遍，本篇第四节只做数值验证。
最后用 SVD 构造伪逆的部分，他讲得比教材还多。字幕里他说这个内容不会出现在期末考试里，但它是整门课的收束，别快进。

四种可逆性，一张图#

他开场就说这是一堂他从没用这种方式讲过的课。内容是对第一章到第四章的复习：对一个 $m \times n$ 、秩为 $r$ 的矩阵，四个基本子空间的维数分别是 $r$ 、 $n - r$ 、 $r$ 、 $m - r$ 。零空间要么不存在（只有零向量），要么存在，这决定了逆的样子。

$r = m = n$ ：方阵，满秩，两边都有逆。四个子空间里两个零空间都只剩零向量。
$r = n < m$ ：满列秩，零空间只有零向量。 $A\mathbf{x} = \mathbf{b}$ 要么无解要么只有一个解。有左逆。
$r = m < n$ ：满行秩，左零空间只有零向量。 $A\mathbf{x} = \mathbf{b}$ 永远有解，但有 $n - m$ 个自由变量，所以有无穷多解。有右逆。
$r < m$ 且 $r < n$ ：两个零空间都在，没有左逆也没有右逆，但有伪逆。

他还强调了一件事：矩形矩阵永远不会有两边都成立的逆。 $m \neq n$ 时 $A$ 或者 $A^\mathsf{T}$ 必然有一个非零的零空间，被这个空间打成零的向量，没有任何矩阵能把它“复活”。

左逆：满列秩， $(A^\mathsf{T}A)^{-1}A^\mathsf{T}$ #

先看满列秩。他的论证只有一步：列无关，零空间只有零向量，所以 $A^\mathsf{T}A$ （ $n \times n$ 对称矩阵）的零空间也只有零向量，因此可逆。于是

A^{-1}_\text{left} = (A^\mathsf{T}A)^{-1}A^\mathsf{T}, \qquad A^{-1}_\text{left}\, A = I_n

这正是最小二乘的正规方程 $A^\mathsf{T}A\hat{\mathbf{x}} = A^\mathsf{T}\mathbf{b}$ 的解 $\hat{\mathbf{x}} = A^{-1}_\text{left}\mathbf{b}$ 。第 16 讲里我们已经见过这个矩阵，这一讲他把它换了一个名字。

顺序反过来会怎样？他停下来问了一个问题： $A\,A^{-1}_\text{left}$ 是什么？全班答“ $P$ ”，投影矩阵：它想变成 $I_m$ ，可是 $A$ 只有 $n$ 列，能撑起的只有列空间，列空间之外它只能给出零。

我用一个 4 × 2 的矩阵验证（两列是常数列和 $0, 1, 2, 3$ ，也就是拟合直线的设计矩阵）：

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    # 满列秩的 4 x 2 矩阵：两列无关，行比列多
7
    A = np.array([[1.0, 0.0], [1.0, 1.0], [1.0, 2.0], [1.0, 3.0]])
8
    m, n = A.shape
9
    print("m, n, r =", m, n, np.linalg.matrix_rank(A))
10

11
    # 左逆 (A^T A)^{-1} A^T
12
    L = np.linalg.inv(A.T @ A) @ A.T
13
    print("L @ A =")
14
    print(L @ A)
15
    print("L @ A 等于单位阵：", np.allclose(L @ A, np.eye(n)))
16

17
    # 反过来乘：A @ L 不是单位阵，而是投影到列空间的 P
18
    P = A @ L
19
    print("A @ L 等于单位阵：", np.allclose(P, np.eye(m)))
20
    print("P @ P == P：", np.allclose(P @ P, P))
21
    print("P.T == P：", np.allclose(P.T, P))
22
    print("trace(P) =", round(float(np.trace(P)), 4), "（等于秩）")
23

24
    # 对 b 来说：在列空间里就恢复 x，不在就得到最小二乘解
25
    x_true = np.array([2.0, -1.0])
26
    b_in = A @ x_true
27
    b_out = b_in + np.array([1.0, -1.0, 1.0, -1.0])
28
    print("b 在列空间里，L @ b =", L @ b_in)
29
    print("b 在列空间外，L @ b =", L @ b_out)
30
    print("和 np.linalg.pinv 一致：", np.allclose(L, np.linalg.pinv(A)))
31

32

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

1
m, n, r = 4 2 2
2
L @ A =
3
[[ 1. -0.]
4
 [ 0.  1.]]
5
L @ A 等于单位阵： True
6
A @ L 等于单位阵： False
7
P @ P == P： True
8
P.T == P： True
9
trace(P) = 2.0 （等于秩）
10
b 在列空间里，L @ b = [ 2. -1.]
11
b 在列空间外，L @ b = [ 2.6 -1.4]
12
和 np.linalg.pinv 一致： True

L @ A 是单位阵（那个 -0. 是浮点的负零，不用理它），A @ L 不是；后者是个对称的幂等矩阵，迹等于秩 2，正是投影矩阵的特征。 $\mathbf{b}$ 在列空间里时左逆精确还原出 $\mathbf{x} = (2, -1)$ ；不在时（我加了一个不在列空间里的扰动 $(1, -1, 1, -1)$ ）它给出的是最小二乘解 $(2.6, -1.4)$ 。最后一行也说明，在满列秩的情形，np.linalg.pinv 给出的就是这个左逆，伪逆在这里没有多出任何新东西。

右逆：满行秩， $A^\mathsf{T}(AA^\mathsf{T})^{-1}$ #

镜像过来。满行秩时 $AA^\mathsf{T}$ （ $m \times m$ ）可逆，右逆是

A^{-1}_\text{right} = A^\mathsf{T}(AA^\mathsf{T})^{-1}, \qquad A\,A^{-1}_\text{right} = I_m

他说它和上面“完全平行”。顺序反过来， $A^{-1}_\text{right}A$ 是一个投影，这一次是投到行空间。

这里有个上面没有的现象：因为有自由变量， $A\mathbf{x} = \mathbf{b}$ 有无穷多个解。他说右逆是“我们最喜欢的那个”右逆，因为它给出的解 $\mathbf{x} = A^\mathsf{T}(AA^\mathsf{T})^{-1}\mathbf{b}$ 本身是 $A^\mathsf{T}$ 的列的组合，完全落在行空间里，没有零空间分量。零空间分量只会让解变长，所以这是所有解中最短的。字幕里他没有展开这一点，这个结论是教材和后面伪逆的内容，我用 2 × 4 的矩阵验证：

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    # 满行秩的 2 x 4 矩阵：两行无关，列比行多
7
    A = np.array([[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 2.0, 3.0]])
8
    m, n = A.shape
9
    print("m, n, r =", m, n, np.linalg.matrix_rank(A))
10

11
    # 右逆 A^T (A A^T)^{-1}
12
    R = A.T @ np.linalg.inv(A @ A.T)
13
    print("A @ R =")
14
    print(A @ R)
15
    print("A @ R 等于单位阵：", np.allclose(A @ R, np.eye(m)))
16

17
    # 反过来乘：R @ A 是投影到行空间的矩阵
18
    Q = R @ A
19
    print("R @ A 等于单位阵：", np.allclose(Q, np.eye(n)))
20
    print("Q @ Q == Q：", np.allclose(Q @ Q, Q))
21
    print("Q.T == Q：", np.allclose(Q.T, Q))
22

23
    # 任何 b 都有解，而且有无穷多个；R @ b 是其中最短的
24
    b = np.array([3.0, 5.0])
25
    x = R @ b
26
    print("x = R @ b =", x, "，A @ x == b：", np.allclose(A @ x, b))
27

28
    # 零空间里的两个基向量：加上它们，Ax 不变，x 变长
29
    N = np.array([[1.0, -2.0, 1.0, 0.0], [2.0, -3.0, 0.0, 1.0]]).T
30
    print("A @ N 等于零：", np.allclose(A @ N, 0.0))
31
    rng = np.random.default_rng(1806)
32
    norms = []
33
    for _ in range(1000):
34
        y = x + N @ rng.standard_normal(2)
35
        assert np.allclose(A @ y, b)
36
        norms.append(np.linalg.norm(y))
37
    print("‖x‖ =", round(float(np.linalg.norm(x)), 4))
38
    print("1000 个别的解里最短的 ‖y‖ =", round(min(norms), 4))
39
    print("x 和零空间正交：", np.allclose(N.T @ x, 0.0))
40

41

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

1
m, n, r = 2 4 2
2
A @ R =
3
[[ 1.  0.]
4
 [-0.  1.]]
5
A @ R 等于单位阵： True
6
R @ A 等于单位阵： False
7
Q @ Q == Q： True
8
Q.T == Q： True
9
x = R @ b = [0.6 0.7 0.8 0.9] ，A @ x == b： True
10
A @ N 等于零： True
11
‖x‖ = 1.5166
12
1000 个别的解里最短的 ‖y‖ = 1.5182
13
x 和零空间正交： True

$A\mathbf{x} = \mathbf{b}$ 有无穷多个解，我在零空间里随机抽了 1000 个方向，把它们加到 $\mathbf{x}$ 上（每个都仍然满足方程，代码里用 assert 保证），最短的也有 1.5182，比 $\mathbf{x} = R\mathbf{b}$ 的 1.5166 长。当然抽样不是证明，证明很短： $\mathbf{x}$ 和零空间正交（最后一行），所以 $\|\mathbf{x} + \mathbf{n}\|^2 = \|\mathbf{x}\|^2 + \|\mathbf{n}\|^2$ ，加任何非零的 $\mathbf{n}$ 都变长。

一般情形：A 是行空间到列空间的一座桥#

四种情形里最后一种才是他真正想讲的： $r < m$ 且 $r < n$ ，两个零空间都在， $A^\mathsf{T}A$ 和 $AA^\mathsf{T}$ 都不可逆，上面两个公式都失效。

他的图是这样的：行空间里的向量 $\mathbf{x}$ ，乘上 $A$ 以后落在列空间里。两个空间的维数都是 $r$ 。关键的事实是：如果 $\mathbf{x}$ 和 $\mathbf{y}$ 是行空间里两个不同的向量，那么 $A\mathbf{x} \neq A\mathbf{y}$ 。 他的证明很短：假设相等，则 $A(\mathbf{x} - \mathbf{y}) = \mathbf{0}$ ，所以 $\mathbf{x} - \mathbf{y}$ 在零空间里；但它同时是行空间里两个向量的差，也在行空间里。零空间和行空间只交于零向量，所以 $\mathbf{x} = \mathbf{y}$ 。

所以把定义域限制在行空间、值域限制在列空间， $A$ 是一座没有岔路的桥，两个方向都能走。往回走的那个方向就是伪逆 $A^+$ 。零空间是桥外的水域： $A$ 把水域里的东西都打成零， $A^+$ 对列空间之外的东西（左零空间）也同样不管，直接给零。

我用一个秩 2 的 4 × 3 矩阵走一遍：第三列等于前两列之和，第四行等于第一行。顺便按他最后讲的做法，手写一个基于 SVD 的伪逆，并和 np.linalg.pinv 对比。

SVD 的做法是： $A = U\Sigma V^\mathsf{T}$ ， $U$ 和 $V$ 是正交矩阵，它们的逆就是转置。 $\Sigma$ 是一个 $m \times n$ 的“对角”矩阵，对角线上有 $r$ 个非零的奇异值，其余都是零。它的伪逆 $\Sigma^+$ 是 $n \times m$ 的：非零的对角元取倒数，其余仍然是零。于是

A^+ = V\,\Sigma^+\,U^\mathsf{T}

他说了一句我很喜欢的话： $\Sigma^+$ 是“最小的”那个，因为你当然可以在零的位置塞上别的数，它们乘出来的还是零，但那只是平白变大。

1
import numpy as np
2

3

4
def pinv_svd(A: np.ndarray, tol: float = 1e-10) -> np.ndarray:
5
    """用 SVD 手写伪逆：把非零奇异值取倒数，零的留着零。"""
6
    U, s, Vt = np.linalg.svd(A)
7
    m, n = A.shape
8
    sigma_plus = np.zeros((n, m))
9
    for i, sigma in enumerate(s):
10
        if sigma > tol * s[0]:
11
            sigma_plus[i, i] = 1.0 / sigma
12
    return Vt.T @ sigma_plus @ U.T
13

14

15
def main() -> None:
16
    np.set_printoptions(precision=4, suppress=True)
17
    # 4 x 3，第三列等于前两列之和，第四行等于第一行：秩 2
18
    A = np.array(
19
        [
20
            [1.0, 0.0, 1.0],
21
            [1.0, 1.0, 2.0],
22
            [1.0, 2.0, 3.0],
23
            [1.0, 0.0, 1.0],
24
        ]
25
    )
26
    m, n = A.shape
27
    r = np.linalg.matrix_rank(A)
28
    print("m, n, r =", m, n, r)
29
    print("A^T A 的秩：", np.linalg.matrix_rank(A.T @ A), "，不可逆")
30
    print("A A^T 的秩：", np.linalg.matrix_rank(A @ A.T), "，也不可逆")
31

32
    U, s, Vt = np.linalg.svd(A)
33
    print("奇异值：", s)
34

35
    A_plus = pinv_svd(A)
36
    print("A^+ =")
37
    print(A_plus)
38
    print("和 np.linalg.pinv 一致：", np.allclose(A_plus, np.linalg.pinv(A)))
39

40
    # 两边都乘不出单位阵，得到的是投影
41
    P_col = A @ A_plus
42
    P_row = A_plus @ A
43
    print("A A^+ 是 4 x 4 投影，秩", np.linalg.matrix_rank(P_col))
44
    print("A^+ A 是 3 x 3 投影，秩", np.linalg.matrix_rank(P_row))
45
    print("A A^+ 是投影：", np.allclose(P_col @ P_col, P_col))
46
    print("A^+ A 是投影：", np.allclose(P_row @ P_row, P_row))
47
    print("A A^+ 对称：", np.allclose(P_col, P_col.T))
48
    print("A^+ A 对称：", np.allclose(P_row, P_row.T))
49

50
    # 行空间的基 V_r（Vt 的前 r 行）：A 在行空间上一对一
51
    V_r = Vt[:r].T
52
    rng = np.random.default_rng(1806)
53
    x = V_r @ rng.standard_normal(r)
54
    y = V_r @ rng.standard_normal(r)
55
    print("x、y 在行空间里，x != y：", not np.allclose(x, y))
56
    print("A @ x != A @ y：", not np.allclose(A @ x, A @ y))
57
    print("A^+ @ (A @ x) 把 x 找回来：", np.allclose(A_plus @ (A @ x), x))
58
    print("A @ V_r 的秩：", np.linalg.matrix_rank(A @ V_r))
59

60

61
if __name__ == "__main__":
62
    main()

1
m, n, r = 4 3 2
2
A^T A 的秩： 2 ，不可逆
3
A A^T 的秩： 2 ，也不可逆
4
奇异值： [4.7472 1.2101 0.    ]
5
A^+ =
6
[[ 0.3939  0.0909 -0.2121  0.3939]
7
 [-0.3333 -0.      0.3333 -0.3333]
8
 [ 0.0606  0.0909  0.1212  0.0606]]
9
和 np.linalg.pinv 一致： True
10
A A^+ 是 4 x 4 投影，秩 2
11
A^+ A 是 3 x 3 投影，秩 2
12
A A^+ 是投影： True
13
A^+ A 是投影： True
14
A A^+ 对称： True
15
A^+ A 对称： True
16
x、y 在行空间里，x != y： True
17
A @ x != A @ y： True
18
A^+ @ (A @ x) 把 x 找回来： True
19
A @ V_r 的秩： 2

几处和他说的一一对应：

三个奇异值里只有两个非零， $\Sigma^+$ 只对它们取倒数。pinv_svd 里的容差 tol * s[0] 就是在判断“零”：奇异值小于最大奇异值的 $10^{-10}$ 倍就当作零。
$A^\mathsf{T}A$ 和 $AA^\mathsf{T}$ 的秩都是 2，一个 3 × 3、一个 4 × 4，都不可逆，所以左逆右逆的公式在这里都不能用。
$AA^+$ （4 × 4）和 $A^+A$ （3 × 3）都是对称的幂等矩阵，秩都是 2：前者是投影到列空间，后者是投影到行空间。他的说法是：左乘右乘都得不到单位阵， $A^+$ 能做的是把向量带进行空间和列空间这两个“好空间”，再把零空间抹掉。
在行空间里随便取两个不同的向量， $A$ 映出来的也不同，而且 $A^+$ 能把它们找回来。 $A$ 作用在行空间的基 $V_r$ 上，结果仍然是秩 2，没有丢掉任何维度。

最小范数解：伪逆给出的那一个答案#

有了 $A^+$ ， $A\mathbf{x} = \mathbf{b}$ 不管秩是多少、有没有解，都可以写一个统一的答案： $\mathbf{x}^+ = A^+\mathbf{b}$ 。 $\mathbf{b}$ 在列空间里时它是方程组的解，不在时它是最小二乘解；解不唯一时（零空间非零）它是所有候选解里最短的那一个。

他在这一讲里特别提到了统计学家：做线性回归的人天天用最小二乘，但前提是 $A^\mathsf{T}A$ 可逆，也就是列无关。他开玩笑说，统计学家最怕的事就是“把同一个实验重复了几遍”，那样列就不无关了， $A^\mathsf{T}A$ 奇异，这时伪逆来得正是时候。

下面这个脚本用的是上一节同一个矩阵，第三列是前两列之和，相当于那个“重复的实验”，并故意给了一个不在列空间里的 $\mathbf{b}$ 。我看三件事： $A^+\mathbf{b}$ 和 np.linalg.lstsq 给的最小范数解是不是同一个；沿着零空间走，残差有没有变；再给 $A$ 加上 1e-12 量级的噪声，朴素左逆、pinv 的默认设置和带截断的 pinv 会怎么样：

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    # 同一个 4 x 3 的秩 2 矩阵：第三列等于前两列之和
7
    A = np.array(
8
        [
9
            [1.0, 0.0, 1.0],
10
            [1.0, 1.0, 2.0],
11
            [1.0, 2.0, 3.0],
12
            [1.0, 0.0, 1.0],
13
        ]
14
    )
15
    b = np.array([1.0, 2.0, 2.0, 3.0])
16
    A_plus = np.linalg.pinv(A)
17
    x_plus = A_plus @ b
18
    print("x^+ = A^+ b =", x_plus)
19

20
    # 正规方程 A^T A x = A^T b 有无穷多个解，x^+ 是其中最短的
21
    x_lstsq, _, rank, _ = np.linalg.lstsq(A, b, rcond=None)
22
    print("np.linalg.lstsq 的解：", x_lstsq, "，秩", rank)
23
    print("两者一致：", np.allclose(x_plus, x_lstsq))
24

25
    # 零空间：(1, 1, -1)；沿着它走，残差不变，长度变大
26
    z = np.array([1.0, 1.0, -1.0])
27
    print("A @ z 等于零：", np.allclose(A @ z, 0.0))
28
    print("x^+ 和 z 正交：", np.isclose(x_plus @ z, 0.0))
29
    for t in [0.0, 0.5, 1.0, 2.0]:
30
        x = x_plus + t * z
31
        print(
32
            f"t = {t}: 残差 {np.linalg.norm(A @ x - b):.4f}，"
33
            f"长度 {np.linalg.norm(x):.4f}"
34
        )
35

36
    # 数据里有 1e-12 量级的噪声时，“秩 2”就不是整数了
37
    rng = np.random.default_rng(1806)
38
    A_noisy = A + 1e-12 * rng.standard_normal(A.shape)
39
    naive = np.linalg.inv(A_noisy.T @ A_noisy) @ A_noisy.T
40
    default = np.linalg.pinv(A_noisy)
41
    cut = np.linalg.pinv(A_noisy, rcond=1e-8)
42
    for name, M in [
43
        ("朴素左逆", naive),
44
        ("pinv 默认", default),
45
        ("pinv 截断", cut),
46
    ]:
47
        print(f"{name}：和 A^+ 差 {np.linalg.norm(M - A_plus):.2e}")
48
    s = np.linalg.svd(A_noisy, compute_uv=False)
49
    print("加噪后最小的奇异值：", f"{s[-1]:.2e}")
50

51

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

1
x^+ = A^+ b = [ 1.3333 -0.6667  0.6667]
2
np.linalg.lstsq 的解： [ 1.3333 -0.6667  0.6667] ，秩 2
3
两者一致： True
4
A @ z 等于零： True
5
x^+ 和 z 正交： True
6
t = 0.0: 残差 1.4142，长度 1.6330
7
t = 0.5: 残差 1.4142，长度 1.8484
8
t = 1.0: 残差 1.4142，长度 2.3805
9
t = 2.0: 残差 1.4142，长度 3.8297
10
朴素左逆：和 A^+ 差 9.23e+02
11
pinv 默认：和 A^+ 差 1.83e+12
12
pinv 截断：和 A^+ 差 7.10e-13
13
加噪后最小的奇异值： 5.47e-13

前半段是他讲的东西： $A^+\mathbf{b} = (1.3333, -0.6667, 0.6667)$ ，和 np.linalg.lstsq 一致（后者对秩亏的问题返回的就是最小范数解）。零空间是 $(1, 1, -1)$ 的倍数，沿着它走，残差一直是 $\sqrt{2} = 1.4142$ ，不变；长度从 1.6330 一路涨到 3.8297， $t = 2$ 时是原来的 2.35 倍。 $\mathbf{x}^+$ 和零空间正交，所以它是最短的。

后半段是他没讲、但我觉得最值得知道的。加了 1e-12 的噪声之后， $A$ 在数值上其实已经是满秩的了：最小的奇异值是 5.47e-13，不是零。朴素的 $(A^\mathsf{T}A)^{-1}A^\mathsf{T}$ 要对 $A^\mathsf{T}A$ 求逆，而 $A^\mathsf{T}A$ 的最小特征值是这个奇异值的平方，量级在 $10^{-25}$ ，比双精度能分辨的下限小得多，结果和 $A^+$ 差了 9.23e+02。np.linalg.pinv 的默认截断很小（据我所知是 1e-15 乘最大奇异值），5.47e-13 比它大，所以它也认为这个方向是“有效”的，把它取倒数，差了 1.83e+12，比朴素左逆还糟。只有我自己把截断设成 rcond=1e-8，把小于最大奇异值 $10^{-8}$ 倍的都当作零，才得到 7.10e-13 的差：从 1.83e+12 降到 7.10e-13，差了约 24 个数量级。

这说明伪逆在数学上总是良定义的，在数值上却要你自己告诉它“多小算零”。这个阈值是一个判断，不是定理，SVD 只是把问题摆在了最容易判断的位置。（1e-8 是我随手挑的，它落在噪声 5e-13 和真正的奇异值 1.21 之间很宽的一段里，我没有试别的值。）

在控制里#

麦轮底盘有 4 个轮子、3 个自由度（前后、左右、转动），所以从“四个电机电流”到“车体受到的合力和力矩”的映射是一个 3 × 4 的矩阵 $B$ ，满行秩：给定想要的合力合力矩 $\mathbf{w}$ ， $B\mathbf{i} = \mathbf{w}$ 永远有解，而且有一个维数 $4 - 3 = 1$ 的零空间。这正是这一讲的第三种情形，用右逆 $B^\mathsf{T}(BB^\mathsf{T})^{-1}$ 分配电流。

下面的 $B$ 是我编的示意矩阵，只借了形状，不是某一台真车的标定值；真正的矩阵和推导在多变量：耦合、RGA、解耦与麦轮底盘里，那一篇把最小范数电流和 numpy.linalg.pinv 的结果对比，差 5.6e-17。

1
import numpy as np
2

3

4
def main() -> None:
5
    np.set_printoptions(precision=4, suppress=True)
6
    # 示意用的 3 x 4 分配矩阵：四个电流 -> (Fx, Fy, 力矩)
7
    # 不是某一台真车的标定值，只借它的形状：3 个自由度，4 个轮子
8
    B = np.array(
9
        [
10
            [1.0, 1.0, 1.0, 1.0],
11
            [-1.0, 1.0, -1.0, 1.0],
12
            [-1.0, 1.0, 1.0, -1.0],
13
        ]
14
    )
15
    print("B 的形状：", B.shape, "，秩", np.linalg.matrix_rank(B))
16

17
    # 右逆：给一个想要的合力与力矩，分配出四个电流
18
    w = np.array([2.0, 1.0, 0.5])
19
    R = B.T @ np.linalg.inv(B @ B.T)
20
    i_min = R @ w
21
    print("最小范数电流：", i_min, "，B @ i == w：", np.allclose(B @ i_min, w))
22
    print("和 pinv 一致：", np.allclose(R, np.linalg.pinv(B)))
23

24
    # 零空间方向：四个轮子互相较劲，合力合力矩都不变
25
    n = np.array([1.0, 1.0, -1.0, -1.0])
26
    print("B @ n =", B @ n)
27
    for t in [0.0, 1.0, 2.0]:
28
        i = i_min + t * n
29
        print(
30
            f"加 {t} 倍零空间电流：B @ i 不变 {np.allclose(B @ i, w)}，"
31
            f"sum(i^2) = {i @ i:.4f}"
32
        )
33

34

35
if __name__ == "__main__":
36
    main()

1
B 的形状： (3, 4) ，秩 3
2
最小范数电流： [0.125 0.875 0.375 0.625] ，B @ i == w： True
3
和 pinv 一致： True
4
B @ n = [0. 0. 0.]
5
加 0.0 倍零空间电流：B @ i 不变 True，sum(i^2) = 1.3125
6
加 1.0 倍零空间电流：B @ i 不变 True，sum(i^2) = 5.3125
7
加 2.0 倍零空间电流：B @ i 不变 True，sum(i^2) = 17.3125

零空间方向 $(1, 1, -1, -1)$ 是“两个轮子顺着推，另外两个逆着推”，合力和力矩互相抵消，只剩下发热。电机的发热正比于电流的平方，所以最小范数的分配（ $\sum i^2 = 1.3125$ ）就是同样的合力下最省电的分配：叠一倍零空间电流， $\sum i^2$ 涨到 5.3125，叠两倍涨到 17.3125，是最小值的 13.2 倍，而合力和力矩一点没变。我猜实际的底盘有时会故意利用这个零空间，比如某个轮子饱和了就往零空间里借一点，那是另一回事，这里只说默认的伪逆分配不会白白浪费电流。

下一讲#

他在这一讲结尾说，周三的最后一讲会尽可能把整门课过一遍。下一讲是期末复习：18.06 第 34 讲：期末复习。这一讲其实已经是预演了，四个子空间、投影、最小二乘、SVD 全都出现了一遍。

音乐

音乐

四种可逆性，一张图#

左逆：满列秩， $(A^\mathsf{T}A)^{-1}A^\mathsf{T}$ #

右逆：满行秩， $A^\mathsf{T}(AA^\mathsf{T})^{-1}$ #

一般情形：A 是行空间到列空间的一座桥#

最小范数解：伪逆给出的那一个答案#

在控制里#

下一讲#

支持与分享

评论区

音乐

18.06 第 33 讲：左逆、右逆与伪逆

四种可逆性，一张图#

左逆：满列秩，(ATA)−1AT(A^\mathsf{T}A)^{-1}A^\mathsf{T}(ATA)−1AT#

右逆：满行秩，AT(AAT)−1A^\mathsf{T}(AA^\mathsf{T})^{-1}AT(AAT)−1#

一般情形：A 是行空间到列空间的一座桥#

最小范数解：伪逆给出的那一个答案#

在控制里#

下一讲#

支持与分享

评论区

左逆：满列秩， $(A^\mathsf{T}A)^{-1}A^\mathsf{T}$ #

右逆：满行秩， $A^\mathsf{T}(AA^\mathsf{T})^{-1}$ #