线性方程组的求解

高斯消去法

高斯消去法（Gaussian elimination）是求解线性方程组的一种常用方法。它的基本思想是通过一系列的行变换将增广矩阵（包含系数矩阵和常数矩阵）化为阶梯形矩阵，然后通过回代求解未知量。以下是高斯消去法的实现步骤：

设线性方程组为 $Ax=b$，其中 $A$ 为 $n\times n$ 的系数矩阵，$b$ 为 $n\times 1$ 的常数矩阵。

将增广矩阵 $[A|b]$ 写成增广矩阵形式。

对矩阵 $A$ 进行初等行变换，消元为主要步骤，步骤如下：

①. 将第一行首个非零元素作为主元素，用主元素消掉第一列中下面所有元素；

②. 将第二行首个非零元素作为主元素，用主元素消掉第二列中下面所有元素；

③. 重复此步骤，直至所有行变成上三角矩阵，即矩阵 $U$。

对 $U$ 进行回带求解，步骤如下：
①. 对最后一个未知量 $x_n$ 进行求解；

②. 对第 $k$ 个未知量 $x_k$ 进行求解，其中 $k=n-1,n-2,...,1$。

高斯消去法的公式式如下：

初等行变换：

用第 $i$ 行的第一个非零元素将第 $j$ 行消元：$R_j\leftarrow R_j-\frac{a_{ji}}{a_{ii}}{R}_i$。

回代求解：

$x_n=\frac{b_n}{a_{nn}}$，$x_k=\frac{1}{a_{kk}}(b_k-{\sum }_{i=k+1}^n{a}_{ki}{x}_i)$。

通过这种方法可以求得线性方程组的解。

例如，求解如下线性方程组的解：

$$\{\begin{array}{l}{x}_1+x_2+x_3=6,\\ 2x_1+3x_2+4x_3=17,\\ 5x_1+6x_2+8x_3=33.\end{array}$$

应用高斯消去法，有如下步骤：

（1）写成增广矩阵形式：

$$\left[\begin{array}{ccccc}1& 1& 1& |& 6\\ 2& 3& 4& |& 17\\ 5& 6& 8& |& 33\end{array}\right]$$

（2）初等行变换：

$$\left[\begin{array}{ccccc}1& 1& 1& |& 6\\ 0& 1& 2& |& 5\\ 0& 0& 3& |& 3\end{array}\right]$$

（3）回代求解:

$$x_3=1,x_2=1,x_1=4$$

因此，该线性方程组的解为：$x_1=4,x_2=1,x_3=1$。

以下是高斯消去法的Python代码实现：

import numpy as np

def gaussian_elimination(A, b):
    """
    A: 系数矩阵
    b: 常数矩阵
    """
    n = len(b)  # 线性方程组的未知数的数量
    # 拼接增广矩阵
    Ab = np.concatenate((A, b.reshape(n, 1)), axis=1)
    # 初等行变换，将Ab变为上三角矩阵
    for i in range(n-1):
        # 将第i+1行到第n行的第(i+1)列消成0
        for j in range(i+1, n):
            Ab[j] -= Ab[i] * Ab[j][i] / Ab[i][i]
    # 回代求解
    x = np.zeros(n)
    for i in range(n-1, -1, -1):
        x[i] = (Ab[i][-1] - np.dot(Ab[i][i+1:n], x[i+1:n])) / Ab[i][i]
    return x

这段代码是在做矩阵运算中的高斯消元算法，具体实现的是将矩阵中第i列的元素通过与第j列的运算，将第j列第i行位置的元素变为0。其中Ab表示增广矩阵，Ab[j][i]为第j行第i列元素，Ab[i][i]为第i行第i列元素，Ab[j][i] / Ab[i][i]表示第j行第i列元素除以第i行第i列元素， Ab[j] -= Ab[i] * Ab[j][i] / Ab[i][i] 则为第j行的各个元素分别减去第i行的各个元素乘以Ab[j][i] / Ab[i][i]的结果。

“Ab[i][i+1:n]”这一行代码的作用是截取了矩阵Ab中第i行的一部分，即从第i+1个元素到第n-1个元素的切片，用来进行高斯消元的计算（通常用于计算矩阵消元中对角线下方的元素）。在矩阵计算中，切片操作十分常见，可以快速地提取所需数据并进行针对性的运算处理。

---

高斯列主元消去法

高斯列主元消去法（Gaussian Elimination with Partial Pivoting）是一种用于解线性方程组的数值方法，它通过将系数矩阵变换为上三角矩阵，然后回代求解出未知数的值。

以下是该方法的公式、实现步骤和代码实现：

公式：

假设有一个n阶线性方程组 $Ax=b$，其中 $A$ 是一个可逆矩阵，$x$ 和 $b$ 是列向量。将 $A$ 变换为上三角矩阵 $U$ 的过程可以表示为以下一系列高斯消去步骤：

$$\left[\begin{array}{ccccc}{a}_{11}& a_{12}& a_{13}& \cdots & a_{1n}\\ a_{21}& a_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]\left[\begin{array}{c}{b}_1\\ b_2\\ ⋮\\ b_n\end{array}\right]$$

Step 1:

对于第1列 $A$，找到绝对值最大的元素 $a_{i1}$，即

$$i=\arg \underset{j=1}{\overset{n}{\max }}|a_{j1}|$$

如果 $i=1$，则继续下一步；否则交换第1行和第 $i$ 行，即

$$\left[\begin{array}{ccccc}{a}_{11}& a_{12}& a_{13}& \cdots & a_{1n}\\ a_{21}& a_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right]\sim \left[\begin{array}{ccccc}{a}_{i1}& a_{i2}& a_{i3}& \cdots & a_{in}\\ a_{21}& a_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right]$$

Step 2:

对于第1列 $A$，将第 $2\sim n$ 行乘以一个系数 $m_{i1}=-\frac{a_{i1}}{a_{11}}$ 并加上第1行，即

$$\left[\begin{array}{ccccc}{a}_{11}& a_{12}& a_{13}& \cdots & a_{1n}\\ a_{21}& a_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right]\sim \left[\begin{array}{ccccc}{a}_{11}& a_{12}& a_{13}& \cdots & a_{1n}\\ 0& a_{22}^{(1)}& a_{23}^{(1)}& \cdots & a_{2n}^{(1)}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& a_{n2}^{(1)}& a_{n3}^{(1)}& \cdots & a_{nn}^{(1)}\end{array}\right]$$

其中 $a_{ij}^{(1)}=a_{ij}-m_{i1}{a}_{1j}$。

Step 3:

重复执行Step 1和Step 2，将矩阵 $A$ 变换为上三角矩阵 $U$，即

$$\left[\begin{array}{ccccc}{a}_{11}& a_{12}& a_{13}& \cdots & a_{1n}\\ 0& a_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& 0& 0& \cdots & a_{nn}\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]\left[\begin{array}{c}{b}_1\\ b_2\\ ⋮\\ b_n\end{array}\right]$$

回代求解：

从后往前依次求解未知数 $x_i$，具体步骤如下：

初始化 $x_n=\frac{b_n}{a_{nn}}$。
对于 $i=n-1,n-2,\cdots ,1$，计算
$$x_i=\frac{1}{a_{ii}}\left(b_i-\sum _{j=i+1}^n{a}_{ij}{x}_j\right)$$
代码实现：

下面是使用Python实现高斯列主元消去法的示例代码。其中，函数gauss_elimination_with_partial_pivoting实现了高斯列主元消去法的核心算法，函数solve_linear_system则是调用该函数并输出解向量的代码。

import numpy as np

def Gaussian_row_elimination(A, b):
    n = len(A)
    for k in range(n):
        # 找主元
        max_row = k
        for i in range(k+1, n):
            if abs(A[i][k]) > abs(A[max_row][k]):
                max_row = i
        # 行列交换
        A[k], A[max_row] = A[max_row], A[k]
        b[k], b[max_row] = b[max_row], b[k]
        # 消去变量
        for i in range(k+1, n):
            factor = A[i][k] / A[k][k]
            for j in range(k+1, n):
                A[i][j] -= factor * A[k][j]
            b[i] -= factor * b[k]
    # 回代
    x = [0] * n
    for i in range(n-1, -1, -1):
        x[i] = (b[i] - sum(A[i][j] * x[j] for j in range(i+1, n))) / A[i][i]
    return x

其中，A为线性方程组的系数矩阵，b为常数矩阵，n为方程组的阶数，x是一个用于存储方程组解的一维数组。在该代码中，我们首先使用列主元素法将系数矩阵进行了局部缩放和单位主元化，然后通过反向代回求解该方程组。在使用该代码时，请注意处理可能的奇异矩阵情况。

奇异矩阵：
在线性代数中，如果一个矩阵的行列式为零，则该矩阵被称为奇异矩阵，否则被称为非奇异矩阵。奇异矩阵的一个重要特点是它们的逆矩阵不存在。这是因为，如果一个矩阵的行列式为零，它的伴随矩阵也将具有非零的行列式，从而无法表示成系数矩阵的逆矩阵的形式。

在解线性方程组时，奇异矩阵会导致使用高斯消元法、LU分解等方法失败，因为这些方法需要求解矩阵的逆矩阵。如果一个线性方程组的系数矩阵是奇异的，这意味着该方程组的解可能不存在，或者存在无穷多个解。因此，我们需要在解线性方程组之前检查矩阵是否是奇异的，以便及时识别出无法求解的情况。

---

高斯全主元消去法

高斯全主元消元法是一种线性代数中求解线性方程组的一种算法，相较于其他消元方法，通过适当的选取主元素可以有效防止算法过程中数值误差的积累，提高求解结果的准确性。

算法步骤如下：

设线性方程组为 $Ax=b$，其中 $A$ 为 $n\times n$ 的系数矩阵，$b$ 为 $n\times 1$ 的常数向量。

对矩阵 $A$ 进行行列变换，选取 $A$ 的主元素，消元过程中将主元素所在行列的其他元素全部归零。
对向量 $b$ 进行相同的行变换。
重复步骤 1.2 直到 $A$ 被归一为对角矩阵。
依次回代求解方程组。
算法公式如下：

1.一般的矩阵消元公式：

$$m_{ij}=\frac{a_{ij}^{(k)}}{a_{kk}^{(k)}},i=k+1,...,n;j=k+1,...,n$$
$$a_{ij}^{(k+1)}=a_{ij}^{(k)}-m_{ij}{a}_{kj}^{(k)},i=k+1,...,n;j=k+1,...,n$$
$$b_i^{(k+1)}=b_i^{(k)}-m_{ik}{b}_k^{(k)},i=k+1,...,n$$

2.全主元消元公式：

$$k=\underset{k\le i\le n}{\mathrm{argmax}}|a_{ik}|$$
$$l=\underset{k\le j\le n}{\mathrm{argmax}}|a_{lj}|$$
$$m_{ij}=\frac{a_{ij}}{a_{kl}},i=k+1,...,n;j=l+1,...,n$$
$$a_{ij}=a_{ij}-m_{ij}{a}_{kj},i=k+1,...,n;j=l+1,...,n$$
$$b_i=b_i-m_{ik}{b}_k,i=k+1,...,n$$
其中 $m_{ij}$ 为消元矩阵，k 和 l 分别为当前消元所在的行和列的主元素。

实现中需要注意，若主元素为 $0$，则需要进行行/列变换选取非零主元素，同时若方程组无解、有无穷多解的情况也需要进行处理。

以下是高斯全主元消元法的Python代码实现：

import numpy as np

def gauss_full_pivoting(A,B):
    n = len(A)
    # 转换为增广矩阵
    AB = np.hstack([A, B.reshape(-1,1)])

	# 记录列交换的情况
    col_swaps = np.arange(n)
    
    for i in range(n-1):
        # 在子矩阵中寻找主元（最大元素）的索引
        maxindex = np.argmax(np.abs(AB[i:, i:-1]))
        # 将索引转换为行列表达式
        k, j = divmod(maxindex, n-i-1)
        # 将子矩阵的行列还原为原矩阵的行列
        k += i
        j += i

        # 行列交换
        AB[[i, k], :] = AB[[k, i], :]
        AB[:, [i, j]] = AB[:, [j, i]]
        col_swaps[[i, j]] = col_swaps[[j, i]]

        # 消去过程
        for m in range(i+1, n):
            r = AB[m,i]/AB[i,i]
            AB[m,i:-1] -= r*AB[i,i:-1]
            AB[m,-1] -= r*AB[i,-1]
    
    # 回代过程
    x = np.zeros(n)
    for i in range(n-1, -1, -1):
        x[i] = (AB[i,-1] - AB[i,i+1:-1].dot(x[i+1:])) / AB[i,i]
    
    # 还原解
    for i in range(n-1, -1, -1):
        if col_swaps[i] != i:
            x[i], x[col_swaps[i]] = x[col_swaps[i]], x[i]
    return x

为什么需要解的复原？

1.高斯全主元消元法是一种通过行变换和列变换将线性方程组转化为行阶梯形矩阵的方法。在得到行阶梯形矩阵之后，可以通过回代的方式求出方程组的解。

然而，由于进行了行变换和列变换，得到的行阶梯形矩阵并不是原始矩阵的简化形式，其中可能包含了一些额外的信息。因此，需要进行还原操作，将行阶梯形矩阵转化为原始矩阵的简化形式，以方便对原始方程组的分析。

具体来说，高斯全主元消元法中的还原操作包括两个方面：

行还原：将行阶梯形矩阵中的主元位置（即每一列第一个非零元素所在的行）上方的元素全部清零，从而得到一个上三角矩阵。

列还原：将列变换的信息还原，即通过列变换将上三角矩阵中每一列的主元移动到对角线上。

通过行还原和列还原操作，可以得到一个简化的矩阵，它的对角线上是原始方程组的系数矩阵的行阶梯形式，从而方便进行求解。

2.高斯列主元消元法是一种通过列变换和行变换将线性方程组转化为列阶梯形矩阵的方法。在得到列阶梯形矩阵之后，可以通过回代的方式求出方程组的解。

与高斯全主元消元法不同的是，高斯列主元消元法在进行列变换的时候，总是选择主元所在列的绝对值最大的元素作为主元。这样，列变换过程中主元所在的列不会发生变化，从而不需要进行列还原操作。

因此，在高斯列主元消元法中，只需要进行行还原操作，将列阶梯形矩阵中的主元位置（即每一行第一个非零元素所在的列）左侧的元素全部清零，从而得到一个左上角到右下角的对角线为主元的上三角矩阵。这个上三角矩阵即为原始方程组的简化形式，可以直接进行回代求解。

因此，高斯列主元消元法不需要解的还原，是由于在进行列变换时，选择主元的方式保证了主元所在列不会发生变化，从而省去了列还原操作。

高斯约当消去法

高斯约当消去法（Gauss-Jordan elimination）是用于求解线性方程组的一种算法，它通过一系列列变换将系数矩阵变为单位矩阵，从而得到方程组的解。以下是该算法的公式和步骤。

假设有一个 $n$ 元线性方程组：
$$\begin{array}{rl}{a}_{1,1}{x}_1+a_{1,2}{x}_2+\cdots +a_{1,n}{x}_n& =b_1\\ a_{2,1}{x}_1+a_{2,2}{x}_2+\cdots +a_{2,n}{x}_n& =b_2\\ ⋮& \\ a_{n,1}{x}_1+a_{n,2}{x}_2+\cdots +a_{n,n}{x}_n& =b_n\end{array}$$

其中 $a_{i,j}$ 和 $b_i$ 都是已知的常数。

步骤：

1. 构建增广矩阵，将系数矩阵和常数向量组成一个 $(n\times n+1)$ 的矩阵 A：

$$A=\left[\begin{array}{cccccc}{a}_{1,1}& a_{1,2}& \dots & a_{1,n}& |& b_1\\ a_{2,1}& a_{2,2}& \dots & a_{2,n}& |& b_2\\ ⋮& ⋮& \ddots & ⋮& |& ⋮\\ a_{n,1}& a_{n,2}& \dots & a_{n,n}& |& b_n\end{array}\right]$$

2. 对 $A$ 进行行变换，将矩阵 $A$ 变为阶梯形矩阵（echelon form）。

• 选取最左边非零的列，将此列上方所有元素变为 $0$。
• 重复以上步骤，直到 $A$ 变为阶梯形矩阵。

3. 对 $A$ 进行列变换，将阶梯形矩阵 $A$ 变为行简化阶梯形矩阵（reduced row echelon form）。

• 每一行第一个非零元素为 $1$。
• 每个 $1$ 下面都是 $0$。
• 每个 $1$ 所在列的其他元素也都是 $0$。

4. 对于行简化阶梯形矩阵 $A$ 中的每个未知数，可以通过其它已知解求出。

• 为每个未知数选择适当的数值。
• 对于已知的符号不同的元素，我们选择不同的数值，例如对于 $x_i$ 的值 $|x_i|>|x_{i+1}|$ 时，我们选择 $x_i$ 的值为正值。
  以下是消元的数学公式：

假设我们需要将矩阵 $A$ 变为阶梯形矩阵。即将第 $r$ 行以下所有行的第 $k$ 个元素都变成 $0$，其中 $k\le r$，则可以使用以下公式：
$$A_{i,j}^{{}^{\prime }}=A_{i,j}-\frac{A_{r,j}}{A_{r,r}}{A}_{i,r}$$

而对于行简化阶梯形矩阵 $A$，则可以使用以下公式将每个未知数表示为其他已知解的线性组合：
$$x_k=\frac{{\sum }_{j=k+1}^n(-A_{k,j}{x}_j)+b_k}{A_{k,k}}$$

高斯约旦消去法是线性方程组求解中的一种常用方法，其代码实现如下：

import numpy as np

def GaussJordan(A, b):
    n = len(b)
    for k in range(n):
        # 找到该列中绝对值最大的元素及其行数
        max_val = abs(A[k][k])
        max_row = k
        for i in range(k+1, n):
            if abs(A[i][k]) > max_val:
                max_val = abs(A[i][k])
                max_row = i
                
        # 如果对角线元素为0，则无法继续运算
        if A[max_row][k] == 0:
            raise ValueError("此矩阵为奇异矩阵，无法进行消去")
              
        # 交换当前行和绝对值最大的行，确保对角线元素最大
        A[k], A[max_row] = A[max_row], A[k]
        b[k], b[max_row] = b[max_row], b[k]
              
        # 将当前行消成对角线元素为1
        for i in range(k+1, n):
            factor = A[i][k]/A[k][k]
            for j in range(k+1, n):
                A[i][j] -= factor * A[k][j]
            b[i] -= factor * b[k]
              
        # 将剩余行消成对角线为0
        for i in range(n):
            if i != k:
                factor = A[i][k]/A[k][k]
                for j in range(k+1, n):
                    A[i][j] -= factor * A[k][j]
                b[i] -= factor * b[k]
              
        # 将对角线元素变为1
        scale = A[k][k]
        for i in range(k, n):
            A[k][i] /= scale
        b[k] /= scale
              
    return b

其中，我们使用了numpy包来进行矩阵运算，函数的输入为矩阵$A$和列向量$b$。函数的输出是高斯约当列主元消去法运算后的解向量。

---

Doolittle分解法

Doolittle分解法是一种矩阵分解方法，将一个$n$阶方阵$A$分解成一个下三角矩阵$L$和一个上三角矩阵$U$的乘积：$A=LU$。

给定线性方程组 Ax = b (其中 A 是一个 n×n 的矩阵，x 和 b 都是 n×1 的向量)，Doolittle分解法将矩阵 A 分解为下三角矩阵 L 和上三角矩阵 U 的乘积，即 A = LU。

则可以使用以下公式来解线性方程组：

1. 首先，将 A 分解成 L 和 U，其中 L 是一个下三角矩阵，U 是一个上三角矩阵，且有 A = LU。
   实现步骤：

   a. 将$L$和$U$的对角线元素初始化为1。
   b. 针对$A$的第一列，计算$U$的第一行元素，以及$L$的第2到$n$行第一列元素
   c. 针对$A$的第二列到第$n$列，每列都计算出$U$的对应行和$L$的对应列。
   d. 在每一列的计算中，$U$中每个元素都需要借助$L$中的相应元素计算。例如，$U_{ij}$是由$L_{ik}$和$U_{kj}$计算得出的，其中$k$可以是$1$到$j-1$的任何值。

   Doolittle分解的公式如下：
   L 和 U 的计算：

   U(i,k) = A(i,k) - ∑(j=1)^(k-1) L(i,j)*U(j,k)

   L(i,k) = (A(i,k) - ∑(j=1)^(k-1) L(i,j)*U(j,k)) / U(k,k)

   其中，1<=i,j<=n，1<=k<=n。

2. 然后令 Ly = b，使用前向替换求解 y；接着令 Ux = y，使用后向替换求解 x。

   具体公式为：

   y 的计算：

   $$\begin{array}{rlrl}{y}_1& =b_1/l_{11}& & \\ y_i& =\frac{1}{l_{ii}}(b_i-\sum _{j=1}^{i-1}{l}_{ij}{y}_j)& & (i=2,3,\cdots ,n)\end{array}$$

   x 的计算：

   $$\begin{array}{rlrl}{x}_n& =y_n/u_{nn}& & \\ x_i& =\frac{1}{u_{ii}}(y_i-\sum _{j=i+1}^n{u}_{ij}{x}_j)& & (i=n-1,n-2,\cdots ,1)\end{array}$$

   其中，l_ij 表示 L 矩阵的第 i 行第 j 列元素，u_ij 表示 U 矩阵的第 i 行第 j 列元素。

具体的Doolittle分解的实现代码示例如下：

import numpy as np

def Doolittle(A,b):
    # Doolittle分解
    n = A.shape[0]
    L = np.zeros((n, n))
    U = np.zeros((n, n))

    for k in range(n):
        U[k, k] = A[k, k] - np.sum(L[k, :k] * U[:k, k])
        L[k, k] = 1
        for i in range(k + 1, n):
            U[k, i] = A[k, i] - np.sum(L[k, :k] * U[:k, i])
            L[i, k] = (A[i, k] - np.sum(L[i, :k] * U[:k, k])) / U[k, k]

    # 求解Ly=b和Ux=y
    y = np.zeros(n)
    x = np.zeros(n)

    for i in range(n):
        y[i] = b[i] - np.sum(L[i, :i] * y[:i])
    for i in range(n - 1, -1, -1):
        x[i] = (y[i] - np.sum(U[i, i + 1:] * x[i + 1:])) / U[i, i]

    return x

---

向量、矩阵的范数

向量和矩阵的范数是用于测量它们的大小的数学概念。向量范数通常称为向量的长度或大小，矩阵范数类似于测量线性变换的大小。

下面是一些向量和矩阵的范数定义以及对应的公式：

向量范数：

1. $|x{|}_p={\left({\sum }_{i=1}^n|x_i{|}^p\right)}^{\frac{1}{p}}$

当$p=\infty$时，这个范数称为最大范数或$L_{\infty }$范数，表示向量中各个分量绝对值的最大值

矩阵范数：

1. 行和范数：
   $$\Vert \mathbf{A}{\Vert }_{\infty }=\underset{1\le i\le n}{\max }\sum _{j=1}^n\left|a_{ij}\right|$$

2. 列和范数：
   $$\Vert \mathbf{A}{\Vert }_1=\underset{1\le j\le n}{\max }\sum _{i=1}^n\left|a_{ij}\right|$$

3. 谱范数：
   $$\Vert \mathbf{A}{\Vert }_2=\sqrt{\rho \left(A^{\mathrm{T}}\mathbf{A}\right)}$$

满足的性质

向量范数和矩阵范数满足下列性质：

1. 非负性质：$\left|\mathbf{x}\right|\ge 0$，当且仅当 $\mathbf{x}=0$ 时等号成立。

2. 齐次性质：$\left|k\mathbf{x}\right|=|k|\left|\mathbf{x}\right|$ 对于所有 $\mathbf{x}\in {\mathbb{R}}^n,k\in \mathbb{R}$ 成立。

3. 三角不等式：$\left|\mathbf{x}+\mathbf{y}\right|\le \left|\mathbf{x}\right|+\left|\mathbf{y}\right|$ 对于所有 $\mathbf{x},\mathbf{y}\in {\mathbb{R}}^n$ 成立。

对于第三个性质：
向量范数具有三角不等式的性质，即对于任意的向量x和y，有以下不等式成立：

||x + y|| ≤ ||x|| + ||y||

这意味着向量的长度满足三角形中任意两条边之和大于第三边的性质。具体地，如果将x和y表示为空间中的两个向量，则x + y表示从x到y的直线段的长度，而||x||和||y||则分别表示x和y向量的长度，因此上述不等式表明从起点到终点的路径长度不能短于直接从起点到终点的长度。

矩阵范数满足的性质（包含上述向量范数的三个性质）：

1. $\left|\mathbf{AB}\right|\le \left|\mathbf{A}\right|\cdot \left|\mathbf{B}\right|$

谱范数又称矩阵2-范数，是一种衡量矩阵大小的方法，定义为矩阵的最大奇异值。谱范数在机器学习、数据分析、信号处理等领域中广泛应用。

数学公式：

$$|A|2=\sigma \max (A)$$

其中，$|A|2$表示矩阵A的谱范数，$\sigma \max (A)$表示矩阵A的最大奇异值。

实现步骤：

1.求出矩阵A的奇异值分解，得到矩阵U、V和对角矩阵$\Sigma$；

2.计算矩阵A的谱范数$|A|2=\sigma \max (A)={\max }_j({\sigma }_j)$，其中${\sigma }_j$表示矩阵A的第j个奇异值。

线性方程组的误差分析

设 A 非奇异，已知线性方程组：
$$A\vec{x}=\vec{b}$$

1. 设 $A$ 精确， $\vec{b}$ 有误差 $\delta \vec{b}$ ，得到的解为 $\vec{x}+\delta \vec{x}$ ，即：
   $$A(\vec{x}+\delta \vec{x})=\vec{b}+\delta \vec{b}$$
   有右端项误差估计表达式：

   $$\frac{\Vert \delta \vec{x}\Vert }{\Vert \vec{x}\Vert }\le \Vert A\Vert \cdot \Vert A^{-1}\Vert \cdot \frac{\Vert \delta \vec{b}\Vert }{\Vert \vec{b}\Vert }$$

2. 设 $\vec{b}$ 精确, $A$ 有误差 $\delta A$, 得到的解为 $\vec{x}+\delta \vec{x}$, 即：
   $$(A+\delta A)(\vec{x}+\delta \bar{x})=\vec{b}$$
   有误差估计表达式：
   $$\frac{\Vert \delta \dot{x}\Vert }{\Vert \vec{x}\Vert }\le \frac{\Vert A^{-1}\Vert \cdot \Vert \delta A\Vert }{1-\Vert A^{-1}\Vert \cdot \Vert \delta A\Vert }=\frac{\Vert A\Vert \cdot \Vert A^{-1}\Vert \cdot \frac{\Vert \delta A\Vert }{\Vert A\Vert }}{1-\Vert A\Vert \cdot \Vert A^{-1}\Vert \cdot \frac{\Vert \delta A\Vert }{\Vert A\Vert }}$$

3. 设 $A$ 有误差 $\delta A$, $\vec{b}$ 有误差 $\delta \vec{b}$ , 得到的解为 $\vec{x}+\delta \vec{x}$, 即：
   $$(A+\delta A)(\vec{x}+\delta \bar{x})=\vec{b}+\delta \vec{b}$$

   有误差估计表达式：

   $$\frac{\Vert \delta \vec{x}\Vert }{\Vert \vec{x}\Vert }\le \frac{\mathrm{cond}(A)}{1-\mathrm{cond}(A)\Vert \delta A\Vert /\Vert A\Vert }\left(\frac{\Vert \delta A\Vert }{\Vert A\Vert }+\frac{\Vert \delta \vec{b}\Vert }{\Vert \vec{b}\Vert }\right)$$

其中，$\Vert A\Vert \cdot \Vert A^{-1}\Vert$ 是关键的误差放大因子, 称为 $A$ 的条件数, 记为 cond $(A)$。越大则 $\mathbf{A}$ 越病态,难得准确解。

常用条件数：
$\mathrm{cond}(A{)}_1$、cond$(A{)}_{\infty }$、cond $(A{)}_2$

特别地，若A对称，则：
$$\mathrm{cond}(A{)}_2=\frac{\max |\lambda |}{\min |\lambda |}$$