Матричные исчисления в SymPy

1. Цели урока

• Понять, что такое матрица размера \(m\times n\) и как устроена адресация элементов \(a_{ij}\).
• Разобраться в основных видах матриц: прямоугольные, квадратные, строка, столбец, треугольные, диагональные, нулевая и единичная.
• Освоить базовые операции: сложение, умножение на число, матричное произведение, транспонирование.
• Понять идею элементарных преобразований строк и приведения матрицы к ступенчатому виду.
• Научиться вычислять численные характеристики квадратных матриц: след и определитель, а также понимать, когда существует обратная матрица.
• Научиться делать эти операции в Python с помощью SymPy (sympy.Matrix).

2. Что такое матрица и чем она отличается от «просто списка»

Матрицей размера \(m\times n\) называют прямоугольную таблицу чисел, в которой \(m\) строк и \(n\) столбцов. Обычно матрицу обозначают буквой \(A\), а её элементы — \(a_{ij}\), где \(i\) — номер строки, \(j\) — номер столбца:

\[ A = (a_{ij}) = \begin{pmatrix} a_{11} & a_{12} & \dots & a_{1n}\\ a_{21} & a_{22} & \dots & a_{2n}\\ \vdots & \vdots & \ddots & \vdots\\ a_{m1} & a_{m2} & \dots & a_{mn} \end{pmatrix}. \]

Каждый элемент матрицы имеет “адрес”: индексы \(i\) и \(j\). Например, элемент на пересечении \(i\)-й строки и \(j\)-го столбца — это \(a_{ij}\).

В программировании мы уже встречали похожие структуры: двумерные списки или двумерные массивы. По способу доступа к элементам они действительно похожи на матрицы. Но различие принципиальное:

• список/массив — это структура хранения данных;
• матрица — это математический объект, над которым определены специфические математические операции.

import sympy as sp

A = sp.Matrix([[1, 2, 3],
               [4, 5, 6]])
print(A)          # матрица 2x3
print(A[0, 1])    # элемент (1-я строка, 2-й столбец) в 0-индексации Python => 2

Частая путаница: хранение vs математика

3. Виды матриц

3.1. Прямоугольная матрица, строка, столбец, квадратная

Самое простое разделение матриц — по форме, то есть по количеству строк и столбцов. Обычно выделяют несколько распространённых видов:

• Прямоугольная матрица — самый общий случай, когда нет требования \(m=n\). Например, матрица \(2\times 3\): \[ \begin{pmatrix} 5 & 8 & 2\\ 3 & 9 & 7 \end{pmatrix}. \]
• Матричная строка — матрица, где \(m=1\) (одна строка). Её также называют вектор-строкой: \[ \begin{pmatrix} 4 & 2 & 6 \end{pmatrix}. \]
• Матричный столбец — матрица, где \(n=1\) (один столбец), иначе — вектор-столбец: \[ \begin{pmatrix} 3\\ 7\\ 1 \end{pmatrix}. \]
• Квадратная матрица — матрица, где \(m=n\). Число \(n\) называют порядком матрицы. Например, матрица 3-го порядка: \[ \begin{pmatrix} 4 & 2 & 6\\ 8 & 5 & 9\\ 3 & 1 & 7 \end{pmatrix}. \]

3.2. Главная и побочная диагонали

Для квадратных матриц особенно важны диагонали. Главная диагональ — это элементы, у которых совпадают индексы строки и столбца: \(a_{11}, a_{22}, \dots, a_{nn}\). То есть “идём” из левого верхнего угла в правый нижний.

Побочная диагональ — это элементы, идущие из правого верхнего угла в левый нижний. В матрице \(n\times n\) это элементы вида \(a_{1n}, a_{2,n-1}, \dots, a_{n1}\).

3.3. Треугольные, диагональные, нулевая и единичная матрица

Относительно главной диагонали выделяют важные специальные формы:

• Верхнетреугольная матрица — все элементы ниже главной диагонали равны нулю: \[ \begin{pmatrix} a_{11} & a_{12} & a_{13} & a_{14}\\ 0 & a_{22} & a_{23} & a_{24}\\ 0 & 0 & a_{33} & a_{34}\\ 0 & 0 & 0 & a_{44} \end{pmatrix}. \]
• Нижнетреугольная матрица — все элементы выше главной диагонали равны нулю: \[ \begin{pmatrix} a_{11} & 0 & 0 & 0\\ a_{21} & a_{22} & 0 & 0\\ a_{31} & a_{32} & a_{33} & 0\\ a_{41} & a_{42} & a_{43} & a_{44} \end{pmatrix}. \]
• Диагональная матрица — нули вне главной диагонали (она одновременно верхне- и нижнетреугольная): \[ \begin{pmatrix} a_{11} & 0 & 0 & 0\\ 0 & a_{22} & 0 & 0\\ 0 & 0 & a_{33} & 0\\ 0 & 0 & 0 & a_{44} \end{pmatrix}. \]
• Нулевая матрица — матрица любой размерности, все элементы равны нулю: \[ \begin{pmatrix} 0 & 0 & \dots & 0\\ 0 & 0 & \dots & 0\\ \vdots & \vdots & \ddots & \vdots\\ 0 & 0 & \dots & 0 \end{pmatrix}. \]
• Единичная матрица — квадратная диагональная матрица, где на главной диагонали стоят единицы: \[ I_n= \begin{pmatrix} 1 & 0 & \dots & 0\\ 0 & 1 & \dots & 0\\ \vdots & \vdots & \ddots & \vdots\\ 0 & 0 & \dots & 1 \end{pmatrix}. \]

import sympy as sp

Z = sp.zeros(3, 4)     # нулевая 3x4
I = sp.eye(4)          # единичная 4x4

print(Z)
print(I)

3.4. Типичные ошибки

4. Операции с матрицами: сложение, умножение на число, вычитание

4.1. Сложение матриц

Пусть даны две матрицы \(A\) и \(B\) одинакового размера. Их суммой называют матрицу \(C\) того же размера, где каждый элемент получается сложением соответствующих элементов:

\[ C = A + B,\qquad c_{ij}=a_{ij}+b_{ij}. \]

import sympy as sp

A = sp.Matrix([[1, 2],
               [3, 4]])
B = sp.Matrix([[10, 20],
               [30, 40]])

print(A + B)

4.2. Умножение на число и вычитание матриц

Умножение матрицы на число \(\lambda\) тоже делается покомпонентно:

\[ \lambda A = (\lambda a_{ij}). \]

Благодаря этому удобно понимать вычитание: \[ A - B = A + (-1)\cdot B. \]

import sympy as sp

A = sp.Matrix([[2, -1],
               [0,  5]])
B = sp.Matrix([[1,  3],
               [4, -2]])

print("2*A:")
print(2*A)

print("A - B:")
print(A - B)

4.3. Типичные ошибки

5. Произведение матриц и транспонирование

5.1. Матричное произведение: формула и правило «строка на столбец»

Умножение матриц устроено не так, как умножение чисел и не так, как покомпонентное умножение. Пусть \(A\) имеет размер \(m\times n\), а \(B\) — размер \(n\times k\). Тогда их произведение \(C=AB\) — матрица размера \(m\times k\), а элементы вычисляются по формуле:

\[ c_{ij}=\sum_{\ell=1}^{n} a_{i\ell}\,b_{\ell j}. \]

Это удобно запоминать как правило «строка на столбец»: чтобы получить \(c_{ij}\), берём \(i\)-ю строку матрицы \(A\) и \(j\)-й столбец матрицы \(B\), перемножаем соответствующие элементы и складываем результаты.

import sympy as sp

A = sp.Matrix([[1, 2, 4],
               [2, 0, 3]])     # 2x3

B = sp.Matrix([[2, 5],
               [1, 3],
               [1, 1]])        # 3x2

C = A * B                      # 2x2
print(C)

5.2. Два ключевых свойства: размерности и некоммутативность

У матричного произведения есть две особенности, которые важно выучить сразу:

• Не любые матрицы можно перемножить. Чтобы \(AB\) было определено, число столбцов \(A\) должно равняться числу строк \(B.\)
• Умножение матриц, как правило, некоммутативно. То есть обычно \(AB \neq BA\) (а иногда \(BA\) вообще не определено по размерности).

import sympy as sp

A = sp.Matrix([[1, 2],
               [3, 4]])
B = sp.Matrix([[0, 1],
               [1, 0]])

print("A*B:")
print(A*B)

print("B*A:")
print(B*A)

5.3. Транспонирование

Транспонирование — операция, которая “меняет местами” строки и столбцы. Транспонированную матрицу обозначают \(A^T\). Если \(A\) имеет размер \(m\times n\), то \(A^T\) имеет размер \(n\times m\), а элементы связаны так:

\[ (A^T)_{ij} = a_{ji}. \]

Это можно представлять как отражение относительно главной диагонали: то, что было в столбце, становится в строке, и наоборот.

import sympy as sp

A = sp.Matrix([[1, 2, 3],
               [4, 5, 6]])  # 2x3

print("A:")
print(A)

print("A.T:")
print(A.T)                 # 3x2

5.4. Типичные ошибки

6. Ступенчатый вид и элементарные преобразования строк

6.1. Что такое ступенчатый вид и зачем он нужен

Приведение матрицы к ступенчатому виду — это преобразование матрицы к форме, в которой удобно решать системы линейных уравнений, исследовать ранг, а также упрощать вычисления некоторых характеристик.

Идея (в простом описании): мы хотим с помощью преобразований строк получить много нулей “внизу слева”, чтобы матрица стала похожа на треугольную. В результате появляется структура, где в каждой следующей строке ведущий (первый ненулевой) элемент стоит правее, чем в предыдущей.

6.2. Элементарные преобразования строк

Чтобы привести матрицу к ступенчатому виду, используют элементарные преобразования строк. Обычно выделяют три базовых операции:

1. Поменять местами две строки.
2. Умножить строку на ненулевое число.
3. Прибавить к одной строке другую строку, предварительно умноженную на число.

Эти операции не “ломают” смысл многих задач, например при решении системы линейных уравнений они сохраняют множество решений.

6.3. Как приводить матрицу к ступенчатому виду в SymPy

В SymPy есть методы, которые выполняют приведение к ступенчатым формам автоматически. Часто используются:

• echelon_form() — ступенчатая форма;
• rref() — приведённая ступенчатая форма (reduced row echelon form), вместе с информацией о ведущих столбцах.

import sympy as sp

A = sp.Matrix([[2,  4, -2],
               [4,  9, -3],
               [-2, -3,  7]])

print("A:")
print(A)

print("Echelon form:")
print(A.echelon_form())

rref_matrix, pivots = A.rref()
print("RREF:")
print(rref_matrix)
print("Pivot columns:", pivots)

A:
Matrix([[2, 4, -2], [4, 9, -3], [-2, -3, 7]])
Echelon form:
Matrix([[2, 4, -2], [0, 2, 2], [0, 0, 16]])
RREF:
Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
Pivot columns: (0, 1, 2)

6.4. Типичные ошибки

7. Практика: типовые задачи (с решениями)

Блок 1: виды и создание матриц

import sympy as sp

A = sp.Matrix([[1, 2, 3],
               [4, 5, 6],
               [7, 8, 9]])

# В Python индексация с 0:
print(A[1, 2])  # 6

import sympy as sp

Z = sp.zeros(2, 5)
I = sp.eye(4)

print(Z)
print(I)

Блок 2: операции

import sympy as sp

A = sp.Matrix([[2, 1],
               [0, 3]])
B = sp.Matrix([[5, -2],
               [7,  4]])

print("A + B:")
print(A + B)

print("A - B:")
print(A - B)

import sympy as sp

A = sp.Matrix([[1, 2, 3],
               [0, 1, 4]])
B = sp.Matrix([[2, 0],
               [1, 3],
               [0, 1]])

C = A * B
print("C:")
print(C)

print("C.T:")
print(C.T)

Блок 3: след, определитель, обратная, решение AX=B

import sympy as sp

A = sp.Matrix([[4, 2, 6],
               [8, 5, 9],
               [3, 1, 7]])

print(A.trace())  # 4 + 5 + 7 = 16

import sympy as sp

T = sp.Matrix([[2,  5, -1,  3],
               [0,  1,  4,  2],
               [0,  0,  8, -6],
               [0,  0,  0, 10]])

print("det(T):", T.det())
print("diag product:", 2*1*8*10)

det(T): 160
diag product: 160

import sympy as sp

A = sp.Matrix([[3, 4],
               [5, 7]])

A_inv = A.inv()
print("A_inv:")
print(A_inv)

print("A * A_inv:")
print(A * A_inv)  # должно быть I

A_inv:
Matrix([[7, -4], [-5, 3]])
A * A_inv:
Matrix([[1, 0], [0, 1]])

import sympy as sp

A = sp.Matrix([[1, 3, -5],
               [0, 12, 0],
               [0, 0, 1]])

B = sp.Matrix([[1, 2],
               [3, 4],
               [5, 6]])

# В SymPy удобнее решать так:
X = A.LUsolve(B)
print(X)

# Проверка:
print(A*X == B)

Matrix([[101/4, 31], [1/4, 1/3], [5, 6]])
True

8. Чек‑лист самопроверки знаний

Отметьте пункты, которые вы действительно понимаете и можете применить без подсказок.