矩阵的数学定义

上次更新于 2024年6月23日

1 矩阵类型

1.1 m×n 阶矩阵

由 m×n 个数 a_ij 排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。
记作：

$$\mathbf{A}=\begin{bmatrix}a_{11}&a_{12}&\cdots&a_{1n}\\a_{21}&a_{22}&\cdots&a_{2n}\\a_{31}&a_{32}&\cdots&a_{3n}\\vdots&\vdots&\ddots&\vdots\\a_{m1}&a_{m2}&\cdots&a_{mn} \end{bmatrix}$$

这 m×n 个数称为矩阵 A 的元素，简称为元；

数 a_ij 位于矩阵 A 的第 i 行第 j 列，称为矩阵 A 的 (i,j) 元；

以数 a_ij 为 (i,j) 元的矩阵可记为 (a_ij) 或 (a_ij)_m×n；

m×n 矩阵 A 也记作 A_mn；

1.2 方阵（n阶矩阵）

行数和列数相等的矩阵，称为方阵；
行数与列数都等于 n 的矩阵称为 n 阶矩阵 或 n 阶方阵。
记作：

$$\mathbf{A}=\begin{bmatrix}a_{11} & a_{12} & \cdots & a_{1n} \\a_{21} & a_{22} & \cdots & a_{2n} \\a_{31} & a_{32} & \cdots & a_{3n} \\vdots & \vdots & \ddots & \vdots \\a_{n1} & a_{n2} & \cdots & a_{nn}\end{bmatrix}$$

1.3 零矩阵

所有元素都为零的矩阵，称为零矩阵。
即：

$$\mathbf{A}=\begin{bmatrix}0&0&\cdots&0\\ 0&0&\cdots&0\\ \vdots&\vdots&\ddots&\vdots\\ 0&0&\cdots&0\end{bmatrix}$$

1.4 单位矩阵

n 阶方阵，且对角元素为 1，其他元素为 0的矩阵。
记作：

$$\mathbf{I_n}=\begin{bmatrix}1&0&\cdots&0&0\\ 0&1&\cdots&0&0\\ \vdots&\vdots&\ddots&\vdots&\vdots\\ 0&0&\cdots&1&0\\ 0&0&\cdots&0&1 \end{bmatrix}$$

1.5 对角矩阵

除了主对角线之外的元素都为 0 的方阵，称为 对角矩阵。
即：

$$\mathbf{A}=\begin{bmatrix}a&0&\cdots&0\\0&b&\cdots&0\\ \vdots&\vdots&\ddots&\vdots\\0&0&\cdots&c\end{bmatrix}$$

1.6 上三角和下三角矩阵

矩阵的上半部分或下半部分（除对角线外）的元素为 0。

1.7 稀疏矩阵

大部分元素为 0 的矩阵。

1.8 对称矩阵

矩阵等于其转置矩阵。

1.9 实矩阵与复矩阵

元素是实数的矩阵称为 实矩阵，元素是复数的矩阵称为 复矩阵。

2 矩阵的基本运算

矩阵的基本运算包括矩阵的加法，减法，数乘，乘法，转置，共轭和 共轭转置。在游戏中的转换运用，用的基本都是乘法的性质。

矩阵的 加减法 和矩阵的数乘合称 矩阵的线性运算 。

2.1 加法

矩阵的加法满足下列运算律 (A，B，C 必须都是 同型矩阵 )：

$$A+B = B+A \quad$$ $$(A+B)+C=A+(B+C)$$

具体如下：

$$\begin{bmatrix}i_0&j_0&k_0\\l_0&m_0&n_0\end{bmatrix}+\begin{bmatrix}i_1&j_1&k_1\\l_1&m_1&n_1\end{bmatrix}=\begin{bmatrix}i_0+i_1&j_0+j_1&k_0+k_1\\l_0+l_1&m_0+m_1&n_0+n_1\end{bmatrix}$$

import numpy as np
# 创建2个3x3的方阵
A = np.eye(3)
B = np.eye(3)
print(f"A:\n{A}")
print(f"B:\n{B}")
print(f"A+B:\n{A+B}")

A:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
B:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
A + B:
[[2. 0. 0.]
 [0. 2. 0.]
 [0. 0. 2.]]

2.2 减法

同矩阵的加法一样，满足以下运算规律 (A，B，C 必须都是 同型矩阵 )：

$$A-B = -B+A \quad$$ $$(A-B)+C=A+(C-B)$$

具体如下：

$$\begin{bmatrix}i_0+i_1 & j_0+j_1 & k_0+k_1 \\l_0+l_1 & m_0+m_1 & n_0+n_1\end{bmatrix}-\begin{bmatrix}i_1 & j_1 & k_1 \\l_1 & m_1 & n_1\end{bmatrix}=\begin{bmatrix}i_0 & j_0 & k_0 \\l_0 & m_0 & n_0 \end{bmatrix}$$

import numpy as np
# 创建2个3x3的方阵
A = np.eye(3)
B = np.eye(3)
print(f"A:\n{A}")
print(f"B:\n{B}")
print(f"A - B:\n{A-B}")

A:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
B:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
A - B:
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

2.3 数乘（与实数相乘）

矩阵的数乘满足以下规律：

$$(\gamma\mu)\mathbf{A} = \gamma(\mu\mathbf{A})$$ $$(\gamma+\mu)\mathbf{A}=\gamma\mathbf{A}+\mu\mathbf{A}$$ $$\gamma(\mathbf{A}+\mathbf{B})=\gamma\mathbf{A}+\gamma\mathbf{B}$$ $$k\mathbf{A}=\begin{bmatrix}ka_{11} & ka_{12} & \cdots & ka_{1n} \\ka_{21} & ka_{22} & \cdots & ka_{2n} \\ka_{31} & ka_{32} & \cdots & ka_{3n} \\ \vdots & \vdots & \ddots & \vdots \\ ka_{m1} & ka_{m2} & \cdots & ka_{mn} \end{bmatrix}$$

import numpy as np
# 创建1个3x3的方阵
A = np.eye(3)
print(f"A:\n{A}")
print(f"A * 3:\n{A*3}")

A:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
A * 3:
[[3. 0. 0.]
 [0. 3. 0.]
 [0. 0. 3.]]

2.4 矩阵乘法（与矩阵相乘）

矩阵乘法是线性代数中的一个基本操作，两个矩阵仅当左边矩阵 $A_{mp}$ 的列数 p 和右边矩阵 $B_{pn}$ 的行数 p 相等时，才能进行乘法运算，其乘积 C 是一个 m×n 矩阵。

结果矩阵的元素 $C_{ij}$ 是通过将矩阵 A 的第 i 行与矩阵 B 的第 j 列对应元素相乘然后求和得到的。
结果矩阵的维度由左矩阵的行数和右矩阵的列数决定。

$$\mathbf{C}=(c_{ij})_{m×n}=\mathbf{A}_{m×p}\mathbf{B}_{p×n}$$$$\mathbf{c}_{ij}=\sum_{l=1}^n\mathbf{a}_{il}\mathbf{b}_{lj}$$

其满足 结合律 和 分配律；

$$(\mathbf{AB})\mathbf{C}=\mathbf{A}(\mathbf{BC})$$ $$(\mathbf{A+B})\mathbf{C}=\mathbf{AC+BC}$$ $$\mathbf{C}(\mathbf{A+B})=\mathbf{CA+CB}$$

例如：一个 2×3 矩阵与 3×2 矩阵相乘，如下

$$\begin{bmatrix}1&0&2\\ -1&3&1 \end{bmatrix} \times \begin{bmatrix}3&1\\ 2&1\\ 1&0 \end{bmatrix} =$$ $$ \begin{bmatrix}(1×3+0×2+2×1)&(1×1+0×1+2×0)\\ (-1×3+3×2+1×1) &(-1×1+3×1+1×0)\end{bmatrix} =$$ $$\begin{bmatrix}5&1\\ 4&2 \end{bmatrix}$$

矩阵的乘法不满足交换律，即 AB ≠ BA ；

对于任何矩阵$A$，与单位矩阵$I$相乘，结果仍然是$A$ ，即 $AI = IA = A$ ；

两个矩阵乘积的转置等于各自转置的乘积的转置，即 $(AB)^T = B^T A^T$ ；

如果矩阵 A 有逆矩阵$A^{-1}$，则 A 与$A^{-1}$的乘积是单位矩阵，即 $AA^{-1} = A^{-1}A = I$ ；

与零矩阵相乘的结果是零矩阵；

import numpy as np
# 创建1个3x2的矩阵
A = np.mat([
    [ 1, 0, 2],
    [-1, 3, 1]])
#创建1个2*3的矩阵
B = np.mat([
    [3, 1],
    [2, 1],
    [1, 0]])
print(f"A:\n{A}")
print(f"B:\n{B}")
print(f"A * B:\n{A*B}")

A:
[[ 1  0  2]
 [-1  3  1]]
B:
[[3 1]
 [2 1]
 [1 0]]
A * B:
[[5 1]
 [4 2]]

2.5 转置（Transposition）

把矩阵A的行和列互相交换所产生的矩阵称为A的转置矩阵，这一过程称为矩阵的转置；
即：

$$\text{A}=\begin{bmatrix}a & b & c \\ d & e & f \end{bmatrix}$$ $$\text{A}^T=\begin{bmatrix}a & d \\b & e \\c & f \end{bmatrix}$$ $$a_{ij}=a^T_{ji}$$

矩阵的转置满足以下运算律：

$$(\mathbf{A}^T)^T=\mathbf{A}$$ $$(\gamma\mathbf{A})^T=\gamma\mathbf{A}^T$$ $$(\mathbf{A}\mathbf{B})^T=\mathbf{B}^T\mathbf{A}^T$$ $$(\mathbf{A+B})^T=\mathbf{A}^T+\mathbf{B}^T$$

如果一个矩阵 A 满足 $A=A^T$ ，则该矩阵 A 被称为 对称矩阵 ；

import numpy as np
# 创建1个3x3的方阵
A = np.mat([
    [1, 2, 3],
    [4, 5, 6]])
print(f"A:\n{A}")
print(f"A transpose:\n{np.transpose(A)}")

A:
[[1 2 3]
 [4 5 6]]
A transpose:
[[1 4]
 [2 5]
 [3 6]]

2.6 共轭（Conjugate）

矩阵的共轭包括取它的每个元素的复共轭。这主要适用于复数矩阵。
矩阵 A 的共轭定义为：

$$\overline{\mathbf{A}}$$

例如：一个 2X2 的复数矩阵，其共轭方式如下

$$\mathbf{A}=\begin{bmatrix}3+i & 5 \\2-2i & i\end{bmatrix}$$ $$\overline{\mathbf{A}}=\begin{bmatrix}3-i & 5 \\2+2i & -i\end{bmatrix}$$

import numpy as np
# 创建1个2x2的方阵
A = np.mat([
    [3+1j, 5],
    [2-2j, 1j]])
print(f"A:\n{A}")
print(f"A conjugate:\n{np.conjugate(A)}")

A:
[[3.+1.j 5.+0.j]
 [2.-2.j 0.+1.j]]
A conjugate:
[[3.-1.j 5.-0.j]
 [2.+2.j 0.-1.j]]

2.7 共轭转置（Hermitian Transpose）

矩阵的共轭转置是矩阵的转置然后求每个元素的复共轭，它也被称为厄米转置。
矩阵 A 的共轭转置定义为：

$$(A^H) \text{或} (A^*)$$

也可以写成：

$$\mathbf{A}^*=(\overline{\mathbf{A}})^T=\overline{\mathbf{A}^T}$$

例如：一个 2X2 的复数矩，其共轭转置方式如下

$$\mathbf{A}=\begin{bmatrix}3+i & 5 \\2-2i & i \end{bmatrix}$$ $$\mathbf{A}^*=\begin{bmatrix}3-i & 2+2i \\5 & -i \end{bmatrix}$$

import numpy as np
# 创建1个2x2的方阵
A = np.mat([
    [3+1j, 5],
    [2-2j, 1j]])
print(f"A:\n{A}")
print(f"A hermitian transpose:\n{np.transpose(np.conjugate(A))}")

A:
[[3.+1.j 5.+0.j]
 [2.-2.j 0.+1.j]]
A hermitian transpose:
[[3.-1.j 2.+2.j]
 [5.-0.j 0.-1.j]]

3 矩阵分解

3.1 LU 分解（LU Decomposition）

3.1.1 LU 分解的定义

将一个矩阵分解为两个矩阵乘积的方法，其中一个是下三角矩阵$L$，另一个是上三角矩阵$U$。具体来说，对于一个给定的方阵 $A$，LU 分解将其表示为：
$$A = LU$$

其中：

$L$ 是一个下三角矩阵（Lower triangular matrix），其对角线元素为 1。
$U$ 是一个上三角矩阵（Upper triangular matrix）。

有时，LU 分解还包括一个置换矩阵 $P$，用于处理矩阵的行交换，以提高数值稳定性。这种情况下，分解形式为：

$$PA = LU$$

其中：

$P$ 是一个置换矩阵（Permutation matrix），用于表示行交换。

3.1.2 LU 分解的步骤

初始化：开始时，矩阵 $L$ 初始化为单位矩阵，矩阵 $U$ 初始化为零矩阵。
分解过程：
- 对于每一列，选择一个主元（pivot），通常是当前列中绝对值最大的元素。
- 通过行交换将主元移动到对角线位置（如果使用置换矩阵 $P$，则记录行交换）。
- 使用高斯消去法，将当前列下方的元素消为零，并更新 $L$ 和 $U$ 矩阵。

import numpy as np

def lu_decomposition(matrix):
    n = matrix.shape[0]
    L = np.zeros((n, n))
    U = np.zeros((n, n))
    for i in range(n):
        # Upper Triangular
        for k in range(i, n):
            sum = 0
            for j in range(i):
                sum += (L[i][j] * U[j][k])
            U[i][k] = matrix[i,k] - sum
        # Lower Triangular
        for k in range(i, n):
            if i == k:
                L[i][i] = 1  # Diagonal as 1
            else:
                sum = 0
                for j in range(i):
                    sum += (L[k][j] * U[j][i])
                L[k][i] = (matrix[k,i] - sum) / U[i][i]
    return L, U

# 示例矩阵
A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]],
    dtype=float)

L, U = lu_decomposition(A)
print(f"矩阵A:\n{A}\n")
print(f"矩阵A的下三角矩阵 L:\n{L}\n")
print(f"矩阵A的上三角矩阵 U:\n{U}")

矩阵A:
[[1. 1. 2.]
 [1. 3. 4.]
 [1. 1. 1.]]

矩阵A的下三角矩阵 L:
[[1. 0. 0.]
 [1. 1. 0.]
 [1. 0. 1.]]

矩阵A的上三角矩阵 U:
[[ 1.  1.  2.]
 [ 0.  2.  2.]
 [ 0.  0. -1.]]

3.1.3 LU 分解的应用

LU 分解在许多数值计算中有广泛的应用，包括：

求解线性方程组：通过将方程组 $Ax = b$ 转化为两个三角方程组 $Ly = b$ 和 $Ux = y$ 来求解。
计算矩阵的逆：通过求解多个线性方程组来计算矩阵的逆。
计算行列式：矩阵 $A$ 的行列式可以通过 $U$ 矩阵的对角线元素的乘积来计算。

3.2 QR 分解（QR Decomposition）

将一个矩阵分解为一个正交矩阵和一个上三角矩阵的乘积。

3.3 奇异值分解（SVD）

将一个矩阵分解为三个特殊矩阵的乘积，广泛应用于信号处理和统计学。

4 特殊矩阵及运算

4.1 矩阵的行列式（Determinant）

4.1.1 定义

矩阵的行列式是一个标量值，它是一个方阵（即行数和列数相等的矩阵）的属性，表示矩阵的一种特征值，可以从矩阵的元素按照特定的算术规则计算得出。

4.1.2 计算方法

一个 n×n 的正方矩阵 A 的 行列式 记为 det(A) 或者 |A| ，其计算方法依赖于矩阵的大小。

2x2矩阵：

$$\text{det}(A)=\mathbf{\text{det}\begin{pmatrix}a & b \\c & d \end{pmatrix}}=(a)(d)-(b)(c)$$

import numpy as np

def determinant2x2(matrix):
    a = matrix[0,0]
    b = matrix[0,1]
    c = matrix[1,0]
    d = matrix[1,1]
    return a*d - b*c

# 创建1个2x2的方阵
A = np.mat([
    [1, 2],
    [3, 4]])
print(f"A:\n{A}")
print(f"det(A): {round(determinant2x2(A))}")

A:
[[1 2]
 [3 4]]
det(A): -2

3×3矩阵：

$$\text{det}(A)=\mathbf{\text{det}\begin{pmatrix}a & b & c \\d & e & f \\g & h & i \end{pmatrix}}$$ $$= a(ei-fh) - b(di-fg) + c(dh-eg)$$ $$=aei+bfg+cdh-afh-bdih-ceg$$

import numpy as np
# 创建1个3x3的方阵
A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])
print(f"A:\n{A}")
print(f"det(A): {round(np.linalg.det(A))}")

A:
[[1 1 2]
 [1 3 4]
 [1 1 1]]
det(A): -2

高斯消元法：

通过将矩阵的化为上三角矩阵，再计算对角元素的乘积。

LU 分解：

通过 LU 分解 将矩阵分为下三角矩阵（L）和上三角矩阵（U），行列式为

$$\text{det}(A) = \text{det}(L) \cdot \text{det}(U)$$

import numpy as np

# 创建1个3x3的方阵
A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])

L, U = lu_decomposition(A)
print(f"A:\n{A}")
detA = np.linalg.det(L) * np.linalg.det(U)
print(f"det(A): {round(detA)}")

A:
[[1 1 2]
 [1 3 4]
 [1 1 1]]
det(A): -2

递归展开：

通过 Laplace展开公式递归计算行列式。

$$\text{det}(A) = \left|\mathbf{A}\right| = \sum_{j=1}^{n} (-1)^{i+j} a_{ij} \text{det}(M_{ij})$$

$M_{ij}$ 是矩阵 A 的 (i,j) 元素的 余子矩阵；

$(-1)^{i+j} \text{det}(M_{ij})$ 为矩阵 A 的 (i,j) 元素的 代数余子式；

import numpy as np

def minor_matrix(matrix, i, j):
    # 删除第i行和第j列
    minor = np.delete(np.delete(matrix, i, axis=0), j, axis=1)
    return minor

def determinant(matrix):
    if matrix.shape == (2,2):
        return determinant2x2(matrix)
    sum,i = 0,0
    for j in range(matrix.shape[1]):
        sign = ((-1) ** (i+j))
        elem = matrix[i,j]
        det = determinant(minor_matrix(matrix,i,j))
        sum += sign * elem * det
    return sum

A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])

print(f"A:\n{A}")
print(f"det(A): {round(determinant(A))}")

A:
[[1 1 2]
 [1 3 4]
 [1 1 1]]
det(A): -2

4.1.3 性质

行列交换：交换矩阵的两行（或两列），行列式的符号会改变。

行列倍加：矩阵的一行（或一列）乘以一个常数 ( k )，行列式也乘以 ( k )。

行列相加：矩阵的一行（或一列）加上另一行（或一列）的倍数，行列式不变。

对角矩阵：对角矩阵的行列式等于对角线上所有元素的乘积。

三角矩阵：上三角矩阵或下三角矩阵的行列式等于对角线上所有元素的乘积。

单位矩阵：单位矩阵的行列式为1。

行列式的乘法性质：对于两个 $n \times n$ 矩阵 $A$ 和 $B$，有 $\text{det}(AB) = \text{det}(A) \cdot \text{det}(B)$。

4.1.4 应用

行列式有许多重要的数学和物理意义，其中包括：

线性变换的缩放因子 ：在几何上，一个矩阵可以表示一个线性变换，该变换可以是旋转、缩放、倾斜等。行列式的绝对值表示这个线性变换改变空间体积的比例。如果行列式为正，表示保持了空间的定向（如旋转），如果为负，则表示反转了空间的定向（如镜像）；

矩阵是否可逆 ：如果一个方阵的行列式不为零，则该矩阵是可逆的，也就是说存在一个逆矩阵。如果行列式为零，则矩阵不可逆，称为奇异矩阵；

解线性方程组 ：在使用克莱姆法则解线性方程组时，行列式扮演着关键角色。如果方程组的系数矩阵的行列式不为零，则该方程组有唯一解；

特征值问题 ：行列式用于求解矩阵的特征值，特征值是矩阵 $A$ 的行列式 $\text{det}(A - \lambda I) = 0$ 的解。

4.2 余子矩阵（Minor Matrix）

4.2.1 定义

给定一个 n 阶方阵 $A_n$ ，删除矩阵 A 中第 i 行和第 j 列后剩下的矩阵称为 A 的 (i, j) 元素的余子矩阵，记作 ($M_{ij}$)。

4.2.2 计算方法

步骤：

选择矩阵 $A$ 的一个元素 $a_{ij}$。
删除该元素所在的第 $i$ 行和第 $j$ 列。
剩下的矩阵即为 $a_{ij}$ 的余子矩阵 $M_{ij}$。

import numpy as np

def minor_matrix(matrix, i, j):
    # 删除第i行和第j列
    minor = np.delete(np.delete(matrix, i, axis=0), j, axis=1)
    return minor

A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])

i,j = 1,1
print(f"A:\n{A}\n")
print(f"其元素({i+1},{j+1})的余子矩阵:\n{minor_matrix(A,i,j)}")

A:
[[1 1 2]
 [1 3 4]
 [1 1 1]]

其元素(2,2)的余子矩阵:
[[1 2]
 [1 1]]

4.2.3 代数余子式（Cofactor）

代数余子式在计算 矩阵的逆 以及 行列式 时非常重要，与余子矩阵 ($M_{ij}$) 相对应的代数余子式定义为：

$$C_{ij} = (-1)^{i+j} \text{det}(M_{ij})$$

$\text{det}(M_{ij})$ 是余子矩阵的行列式。

import numpy as np

def cofactor(matrix, i, j):
    # 删除第i行和第j列
    minor = minor_matrix(matrix,i,j)
    # 计算余子式的行列式
    minor_det = determinant(minor)
    # 应用符号
    sign = (-1) ** (i + j)
    return sign * minor_det

# 示例矩阵
A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])

# 计算矩阵中元素(i,j)的代数余子式
i, j = 1, 1
print(f"矩阵:\n{A}\n")
print(f"元素({i+1},{j+1})的代数余子式: {cofactor(A, i, j)}")

矩阵:
[[1 1 2]
 [1 3 4]
 [1 1 1]]

元素(2,2)的代数余子式: -1

4.2.4 性质

性质1：如果矩阵 $A$ 是一个 $n \times n$ 的方阵，那么它的每个余子矩阵 $M_{ij}$ 是一个 $(n-1) \times (n-1)$ 的方阵。

性质2：余子矩阵用于计算行列式的展开式（Laplace 展开），即行列式可以通过其余子矩阵的行列式来表示。

4.2.5 应用

行列式的计算：
通过 余子矩阵 和 代数余子式，可以递归地计算高阶矩阵的行列式，通过其任一行（或列）的元素及其对应的余子矩阵的行列式的乘积之和来计算。

$$\text{det}(A) = \sum_{j=1}^{n} (-1)^{i+j} a_{ij} \text{det}(M_{ij})$$

$a_{ij}$ 是矩阵 A 的 (i,j) 元素；

$M_{ij}$ 是矩阵 A 的 (i,j) 元素的余子矩阵；

$\text{det}(M_{ij})$ 是余子矩阵 $M_{ij}$ 的行列式；

矩阵的逆：
通过伴随矩阵和行列式，可以计算矩阵的逆。对于 n 阶方阵 $A_n$ （其行列式不为0），其 逆矩阵 可以通过其 代数余子式矩阵（也称 伴随矩阵 ）除以 $A_n$ 的行列式来计算，即：

$$A^{-1} = \frac{1}{\text{det}(A)} \text{adj}(A)$$

$\text{adj}(A)$ 是 A 的 伴随矩阵 ，即由 A 的所有 代数余子式 组成的矩阵的转置；

线性方程组：
在求解线性方程组时，余子矩阵和伴随矩阵也起到重要作用。

4.3 伴随矩阵（Adjoint Matrix）

4.3.1 定义

伴随矩阵（Adjoint matrix） 在数学中（特别是线性代数中）是与给定的方阵相关的另一个方阵。
对于任何一个 n 阶方阵 $A_n$ （其行列式不为0），其 伴随矩阵 是通过取原矩阵的每个元素的 代数余子式（Cofactor） 并将其 转置（Transpose） 得到的，记作 $\text{adj}(A)$。

4.3.2 计算方法

计算伴随矩阵的步骤如下：

计算代数余子式：对于矩阵 $A$ 的每个元素 $a_{ij}$，计算其代数余子式 $C_{ij}$，即 $A$ 删除第 $i$ 行和第 $j$ 列后得到的子矩阵的行列式，再乘以 $(-1)^{i+j}$。
构造余子式矩阵：将所有代数余子式 $C_{ij}$ 组成一个矩阵，这个矩阵称为余子式矩阵（Cofactor Matrix）。
转置：将余子式矩阵转置，得到伴随矩阵 $\text{adj}(A)$。

def adjoint_matrix(matrix):
    # 计算矩阵的行列式
    matrix_det = determinant(matrix)
    # 如果行列式为0，矩阵不可逆，伴随矩阵不存在
    if matrix_det == 0:
        raise ValueError("Matrix is singular and cannot have an adjoint.")
    # 取原矩阵的每个元素的代数余子式
    adj_matrix = np.mat([
        [cofactor(matrix,0,0),cofactor(matrix,0,1),cofactor(matrix,0,2)],
        [cofactor(matrix,1,0),cofactor(matrix,1,1),cofactor(matrix,1,2)],
        [cofactor(matrix,2,0),cofactor(matrix,2,1),cofactor(matrix,2,2)]])
    # 将其转置
    adj_matrix = np.transpose(adj_matrix)
    return adj_matrix

# 示例矩阵
A = np.mat([
    [1, 1, 2],
    [1, 3, 4],
    [1, 1, 1]])

# 计算伴随矩阵
adjA = adjoint_matrix(A)
print(f"矩阵 A:\n{A}\n")
print(f"矩阵A的伴随矩阵 adj(A):\n{adjA}")

矩阵 A:
[[1 1 2]
 [1 3 4]
 [1 1 1]]

矩阵A的伴随矩阵 adj(A):
[[-1  1 -2]
 [ 3 -1 -2]
 [-2  0  2]]

4.3.3 性质

性质1：如果矩阵 ( A ) 是可逆的，那么 ( A ) 的逆矩阵可以表示为：

$$A^{-1} = \frac{1}{\det(A)} \text{adj}(A)$$

其中 $\det(A)$ 是矩阵 $A$ 的行列式

性质2：对于两个 $n \times n$ 矩阵 $A$ 和 $B$，其行列式的乘积有如下关系：

$$\text{adj}(AB) = \text{adj}(B) \text{adj}(A)$$

性质3：矩阵 A 与 伴随矩阵 的乘积等于 A 的行列式乘以单位矩阵，即：

$$A \times \text{adj}(A) = \text{adj}(A) \times A = \det(A) \times I$$

# 矩阵 A 与 伴随矩阵 的乘积 等于 A 的行列式乘以单位矩阵
print(f"A * adj(A):\n{np.round(A @ adjA)}\n")
print(f"adj(A) * A:\n{np.round(adjA @ A)}\n")
print(f"det(A) * I:\n{np.round(determinant(A) * np.eye(3))}")

A * adj(A):
[[-2  0  0]
 [ 0 -2  0]
 [ 0  0 -2]]

adj(A) * A:
[[-2  0  0]
 [ 0 -2  0]
 [ 0  0 -2]]

det(A) * I:
[[-2. -0. -0.]
 [-0. -2. -0.]
 [-0. -0. -2.]]

性质4：如果 $A$ 是对角矩阵，那么 $\text{adj}(A)$ 也是对角矩阵，其对角元素是 $A$ 对角元素的代数余子式。

4.4 逆矩阵（Inverse Matrix）

4.4.1 定义

对于一个 n 阶矩阵 A，若存在一个 n 阶矩阵 B，使得 $AB=BA=I_n$ ，则称 B 是 A 的 逆矩阵，记为 $A^{-1}$ ；

4.4.2 计算方法

4.4.2.1 伴随矩阵法

对于 $( n \times n )$ 矩阵 ( A )，其逆矩阵可以通过伴随矩阵 $( \text{adj}(A) )$ 和行列式 $( \det(A) )$ 计算：