Skip to main content

第6章：线性方程组理论

Haiyue10/7/25About 10 min线性代数

第6章：线性方程组理论

学习目标

  • 理解线性方程组的几何意义
  • 掌握高斯消元法的原理和步骤
  • 理解行阶梯形和行最简阶梯形
  • 掌握齐次和非齐次方程组的解的结构
  • 理解解空间的概念

线性方程组的基本概念

线性方程组的一般形式

线性方程组是由若干个线性方程构成的方程系统：

{a11x1+a12x2+⋯+a1nxn=b1a21x1+a22x2+⋯+a2nxn=b2⋮am1x1+am2x2+⋯+amnxn=bm\begin{cases} a_{11}x_1 + a_{12}x_2 + \cdots + a_{1n}x_n = b_1 \\ a_{21}x_1 + a_{22}x_2 + \cdots + a_{2n}x_n = b_2 \\ \vdots \\ a_{m1}x_1 + a_{m2}x_2 + \cdots + a_{mn}x_n = b_m \end{cases}

矩阵形式：

Ax=bA\mathbf{x} = \mathbf{b}

其中：

  • AA 是 m×nm \times n 系数矩阵
  • x\mathbf{x} 是 n×1n \times 1 未知向量
  • b\mathbf{b} 是 m×1m \times 1 常数向量
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import solve

# 示例：线性方程组
# 2x + 3y = 7
# x - y = 1

A = np.array([[2, 3],
              [1, -1]])
b = np.array([7, 1])

print("系数矩阵 A:")
print(A)
print("\n常数向量 b:")
print(b)

# 求解线性方程组
solution = solve(A, b)
print(f"\n解: x = {solution[0]:.2f}, y = {solution[1]:.2f}")

# 验证解
verification = A @ solution
print(f"验证: A @ x = {verification}")
print(f"原常数向量 b = {b}")

解的分类

线性方程组的解可能有三种情况：

  1. 唯一解：方程组有且仅有一个解
  2. 无穷多解：方程组有无穷多个解
  3. 无解：方程组不相容

解的存在性判定

  • 有解：当且仅当 rank(A)=rank([A∣b])\text{rank}(A) = \text rank([A|b])
  • 唯一解：当 rank(A)=rank([A∣b])=n\text{rank}(A) = \text{rank}([A|b]) = n（nn 为未知数个数）
  • 无穷多解：当 rank(A)=rank([A∣b])<n\text{rank}(A) = \text{rank}([A|b]) < n

几何意义

二维情况

在二维平面上，每个线性方程表示一条直线：

# 几何意义可视化
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# 情况1：唯一解（两直线相交）
x = np.linspace(-1, 5, 100)
y1 = (7 - 2*x) / 3  # 2x + 3y = 7
y2 = x - 1          # x - y = 1

axes[0].plot(x, y1, 'b-', label='2x + 3y = 7')
axes[0].plot(x, y2, 'r-', label='x - y = 1')
axes[0].plot(2.2, 0.2, 'go', markersize=8, label='交点 (2.2, 0.2)')
axes[0].grid(True, alpha=0.3)
axes[0].legend()
axes[0].set_title('唯一解：两直线相交')
axes[0].set_xlim(-1, 5)
axes[0].set_ylim(-2, 3)

# 情况2：无穷多解（两直线重合）
y3 = (6 - 2*x) / 3  # 2x + 3y = 6
y4 = (6 - 2*x) / 3  # 4x + 6y = 12 (等价方程)

axes[1].plot(x, y3, 'b-', linewidth=3, label='2x + 3y = 6')
axes[1].plot(x, y4, 'r--', linewidth=2, label='4x + 6y = 12')
axes[1].grid(True, alpha=0.3)
axes[1].legend()
axes[1].set_title('无穷多解：两直线重合')
axes[1].set_xlim(-1, 5)
axes[1].set_ylim(-1, 3)

# 情况3：无解（两直线平行）
y5 = (7 - 2*x) / 3  # 2x + 3y = 7
y6 = (1 - 2*x) / 3  # 2x + 3y = 1

axes[2].plot(x, y5, 'b-', label='2x + 3y = 7')
axes[2].plot(x, y6, 'r-', label='2x + 3y = 1')
axes[2].grid(True, alpha=0.3)
axes[2].legend()
axes[2].set_title('无解：两直线平行')
axes[2].set_xlim(-1, 5)
axes[2].set_ylim(-2, 3)

plt.tight_layout()
plt.show()

三维情况

在三维空间中，每个线性方程表示一个平面：

# 三维可视化示例
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(12, 4))

# 三个平面的交点
ax1 = fig.add_subplot(131, projection='3d')

# 创建网格
x = np.linspace(-2, 2, 20)
y = np.linspace(-2, 2, 20)
X, Y = np.meshgrid(x, y)

# 三个平面: x + y + z = 1, x - y + z = 0, 2x + y - z = 1
Z1 = 1 - X - Y      # x + y + z = 1
Z2 = X - Y          # x - y + z = 0
Z3 = 2*X + Y - 1    # 2x + y - z = 1

ax1.plot_surface(X, Y, Z1, alpha=0.3, color='blue', label='平面1')
ax1.plot_surface(X, Y, Z2, alpha=0.3, color='red', label='平面2')
ax1.plot_surface(X, Y, Z3, alpha=0.3, color='green', label='平面3')

# 计算交点
A_3d = np.array([[1, 1, 1],
                 [1, -1, 1],
                 [2, 1, -1]])
b_3d = np.array([1, 0, 1])
solution_3d = solve(A_3d, b_3d)

ax1.scatter(*solution_3d, color='black', s=100, label='交点')
ax1.set_title('三平面相交于一点')
ax1.set_xlabel('X')
ax1.set_ylabel('Y')
ax1.set_zlabel('Z')

plt.show()

高斯消元法

高斯消元法是求解线性方程组的基本方法，通过行变换将系数矩阵化为行阶梯形。

基本行变换

  1. 行交换：Ri↔RjR_i \leftrightarrow R_j
  2. 行数乘：Ri←kRiR_i \leftarrow kR_i （k≠0k \neq 0）
  3. 行相加：Ri←Ri+kRjR_i \leftarrow R_i + kR_j
def gaussian_elimination(A, b):
    """
    高斯消元法求解线性方程组 Ax = b
    """
    n = len(b)
    # 构造增广矩阵
    augmented = np.column_stack([A.astype(float), b.astype(float)])

    print("初始增广矩阵:")
    print(augmented)
    print()

    # 前向消元
    for i in range(n):
        # 寻找主元
        max_row = i
        for k in range(i+1, n):
            if abs(augmented[k, i]) > abs(augmented[max_row, i]):
                max_row = k

        # 交换行
        if max_row != i:
            augmented[i], augmented[max_row] = augmented[max_row].copy(), augmented[i].copy()
            print(f"交换第 {i+1} 行和第 {max_row+1} 行:")
            print(augmented)
            print()

        # 消元
        for k in range(i+1, n):
            if augmented[i, i] != 0:
                factor = augmented[k, i] / augmented[i, i]
                augmented[k] = augmented[k] - factor * augmented[i]
                print(f"第 {k+1} 行 <- 第 {k+1} 行 - {factor:.3f} * 第 {i+1} 行:")
                print(augmented)
                print()

    print("行阶梯形矩阵:")
    print(augmented)
    print()

    # 回代求解
    x = np.zeros(n)
    for i in range(n-1, -1, -1):
        x[i] = augmented[i, n]
        for j in range(i+1, n):
            x[i] -= augmented[i, j] * x[j]
        x[i] /= augmented[i, i]

    return x

# 示例
A_example = np.array([[2, 1, -1],
                      [-3, -1, 2],
                      [-2, 1, 2]])
b_example = np.array([8, -11, -3])

print("求解方程组:")
print("2x + y - z = 8")
print("-3x - y + 2z = -11")
print("-2x + y + 2z = -3")
print()

solution = gaussian_elimination(A_example, b_example)
print(f"解: x = {solution}")

行阶梯形和行最简阶梯形

**行阶梯形（Row Echelon Form, REF）**特征：

  1. 零行（如果有）位于矩阵底部
  2. 每一非零行的首个非零元素（主元）位于上一行主元的右边
  3. 主元下方的元素都是零

**行最简阶梯形（Reduced Row Echelon Form, RREF）**特征：

  1. 满足行阶梯形的所有条件
  2. 每个主元都是1
  3. 主元上方和下方的元素都是零
def rref(matrix):
    """
    将矩阵化为行最简阶梯形
    """
    A = matrix.astype(float).copy()
    rows, cols = A.shape

    current_row = 0
    for col in range(cols):
        # 寻找主元
        pivot_row = current_row
        while pivot_row < rows and A[pivot_row, col] == 0:
            pivot_row += 1

        if pivot_row == rows:
            continue

        # 交换行
        if pivot_row != current_row:
            A[current_row], A[pivot_row] = A[pivot_row].copy(), A[current_row].copy()

        # 将主元化为1
        A[current_row] = A[current_row] / A[current_row, col]

        # 消除该列的其他元素
        for row in range(rows):
            if row != current_row and A[row, col] != 0:
                A[row] = A[row] - A[row, col] * A[current_row]

        current_row += 1
        if current_row == rows:
            break

    return A

# 示例
matrix_example = np.array([[1, 2, -1, 3],
                          [2, 4, 1, 7],
                          [1, 2, 2, 6]])

print("原矩阵:")
print(matrix_example)
print("\n行最简阶梯形:")
rref_matrix = rref(matrix_example)
print(rref_matrix)

齐次方程组

齐次方程组的定义

齐次线性方程组的形式为：

Ax=0A\mathbf{x} = \mathbf{0}

重要性质：

  1. 齐次方程组总是有解（至少有零解）
  2. 如果 x1\mathbf{x}_1 和 x2\mathbf{x}_2 是解，则 c1x1+c2x2c_1\mathbf{x}_1 + c_2\mathbf{x}_2 也是解
  3. 解集构成向量空间（零空间或核空间）
def homogeneous_solution(A):
    """
    求齐次方程组 Ax = 0 的通解
    """
    print("齐次方程组 Ax = 0")
    print("系数矩阵 A:")
    print(A)

    # 化为行最简阶梯形
    rref_A = rref(A)
    print("\n行最简阶梯形:")
    print(rref_A)

    m, n = A.shape
    rank_A = np.linalg.matrix_rank(A)

    print(f"\n矩阵的秩: {rank_A}")
    print(f"自由变量个数: {n - rank_A}")

    if rank_A == n:
        print("只有零解")
        return np.zeros((n, 1))
    else:
        print("有非零解")
        # 这里简化处理，实际应用中需要更复杂的算法来找基础解系
        return None

# 示例
A_homogeneous = np.array([[1, 2, 3],
                         [2, 4, 6],
                         [1, 2, 3]])

homogeneous_solution(A_homogeneous)

非齐次方程组

解的结构定理

对于非齐次方程组 Ax=bA\mathbf{x} = \mathbf{b}：

如果方程组有解，则通解为：

x=xp+xh\mathbf{x} = \mathbf{x}_p + \mathbf{x}_h

其中：

  • xp\mathbf{x}_p 是特解（非齐次方程组的任一解）
  • xh\mathbf{x}_h 是对应齐次方程组 Ax=0A\mathbf{x} = \mathbf{0} 的通解
def analyze_system(A, b):
    """
    分析线性方程组的解的情况
    """
    m, n = A.shape

    # 计算系数矩阵的秩
    rank_A = np.linalg.matrix_rank(A)

    # 计算增广矩阵的秩
    augmented = np.column_stack([A, b])
    rank_Ab = np.linalg.matrix_rank(augmented)

    print(f"系数矩阵 A 的形状: {A.shape}")
    print(f"rank(A) = {rank_A}")
    print(f"rank([A|b]) = {rank_Ab}")
    print(f"未知数个数: {n}")
    print()

    if rank_A != rank_Ab:
        print("方程组无解（不相容）")
        return None
    elif rank_A == rank_Ab == n:
        print("方程组有唯一解")
        solution = solve(A, b)
        print(f"解: {solution}")
        return solution
    else:
        print(f"方程组有无穷多解")
        print(f"自由变量个数: {n - rank_A}")
        return "无穷多解"

# 测试不同情况的方程组
print("情况1：唯一解")
A1 = np.array([[1, 2], [3, 4]])
b1 = np.array([5, 6])
analyze_system(A1, b1)

print("\n" + "="*50 + "\n")

print("情况2：无解")
A2 = np.array([[1, 2], [2, 4]])
b2 = np.array([3, 7])
analyze_system(A2, b2)

print("\n" + "="*50 + "\n")

print("情况3：无穷多解")
A3 = np.array([[1, 2], [2, 4]])
b3 = np.array([3, 6])
analyze_system(A3, b3)

解空间的概念

零空间（Null Space）

矩阵 AA 的零空间是齐次方程组 Ax=0A\mathbf{x} = \mathbf{0} 的解集：

Null(A)={x∈Rn:Ax=0}\text{Null}(A) = \{\mathbf{x} \in \mathbb{R}^n : A\mathbf{x} = \mathbf{0}\}

性质：

  • 零空间是 Rn\mathbb{R}^n 的子空间
  • dim⁡(Null(A))=n−rank(A)\dim(\text{Null}(A)) = n - \text{rank}(A)（零化度定理）
def null_space_visualization():
    """
    可视化零空间的概念
    """
    # 二维情况：直线的零空间
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))

    # 情况1：rank = 1，零空间是一条直线
    # 方程: x + 2y = 0
    x = np.linspace(-3, 3, 100)
    y = -x / 2

    axes[0].plot(x, y, 'b-', linewidth=2, label='x + 2y = 0')
    axes[0].arrow(0, 0, 2, -1, head_width=0.1, head_length=0.1, fc='red', ec='red')
    axes[0].arrow(0, 0, -2, 1, head_width=0.1, head_length=0.1, fc='red', ec='red')
    axes[0].grid(True, alpha=0.3)
    axes[0].set_aspect('equal')
    axes[0].legend()
    axes[0].set_title('零空间：直线（一维子空间）')
    axes[0].set_xlim(-3, 3)
    axes[0].set_ylim(-3, 3)

    # 情况2：rank = 2，零空间只有原点
    axes[1].plot(0, 0, 'ro', markersize=8, label='零空间：{0}')
    axes[1].grid(True, alpha=0.3)
    axes[1].set_aspect('equal')
    axes[1].legend()
    axes[1].set_title('零空间：原点（零维子空间）')
    axes[1].set_xlim(-3, 3)
    axes[1].set_ylim(-3, 3)

    plt.tight_layout()
    plt.show()

null_space_visualization()

列空间（Column Space）

矩阵 AA 的列空间是 AA 的列向量的所有线性组合构成的集合：

Col(A)={b∈Rm:Ax=b 有解}\text{Col}(A) = \{\mathbf{b} \in \mathbb{R}^m : A\mathbf{x} = \mathbf{b} \text{ 有解}\} 

def visualize_column_space():
    """
    可视化列空间
    """
    fig = plt.figure(figsize=(10, 8))
    ax = fig.add_subplot(111, projection='3d')

    # 矩阵的两个列向量
    v1 = np.array([1, 0, 1])
    v2 = np.array([0, 1, 1])

    # 列空间是这两个向量张成的平面
    u = np.linspace(-2, 2, 20)
    v = np.linspace(-2, 2, 20)
    U, V = np.meshgrid(u, v)

    # 平面上的点
    X = U * v1[0] + V * v2[0]
    Y = U * v1[1] + V * v2[1]
    Z = U * v1[2] + V * v2[2]

    ax.plot_surface(X, Y, Z, alpha=0.3, color='lightblue')

    # 绘制基向量
    ax.quiver(0, 0, 0, v1[0], v1[1], v1[2], color='red',
              arrow_length_ratio=0.1, linewidth=3, label='v1')
    ax.quiver(0, 0, 0, v2[0], v2[1], v2[2], color='blue',
              arrow_length_ratio=0.1, linewidth=3, label='v2')

    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.set_zlabel('Z')
    ax.set_title('列空间：由两个向量张成的平面')
    ax.legend()

    plt.show()

visualize_column_space()

算法总结

实际应用示例

电路分析

# 电路网络分析示例
def circuit_analysis():
    """
    使用基尔霍夫定律分析电路
    """
    print("电路分析：基尔霍夫定律")
    print("节点电压法求解电路中的电流")

    # 示例电路的系数矩阵（基于基尔霍夫电流定律）
    # 3个回路，3个未知电流
    A_circuit = np.array([[10, -5,  0],    # 回路1
                         [-5, 15, -2],    # 回路2
                         [ 0, -2,  7]])   # 回路3

    b_circuit = np.array([12, 0, -5])     # 电压源

    print("系数矩阵（电阻矩阵）:")
    print(A_circuit)
    print("\n电压向量:")
    print(b_circuit)

    currents = solve(A_circuit, b_circuit)
    print(f"\n各支路电流: {currents}")
    print(f"I1 = {currents[0]:.3f} A")
    print(f"I2 = {currents[1]:.3f} A")
    print(f"I3 = {currents[2]:.3f} A")

circuit_analysis()

本章小结

概念定义重要性质
线性方程组Ax=bA\mathbf{x} = \mathbf{b}可能有唯一解、无穷多解或无解
高斯消元法行变换化简矩阵将矩阵化为行阶梯形
齐次方程组Ax=0A\mathbf{x} = \mathbf{0}解集构成向量空间
非齐次方程组Ax=bA\mathbf{x} = \mathbf{b}通解 = 特解 + 齐次解
零空间Null(A)\text{Null}(A)dim⁡=n−rank(A)\dim = n - \text{rank}(A)
列空间Col(A)\text{Col}(A)方程组有解的条件

注意事项

  • 数值计算中要注意舍入误差的影响
  • 主元选择对算法稳定性很重要
  • 解的结构理论是线性代数的核心内容

线性方程组理论将几何直观、代数运算和理论分析完美结合，为后续学习矩阵理论和线性变换奠定了坚实基础。

Last Updated
Contributors: Haiyue
Default footer
Copyright © 2025 Haiyue