Возведение матрицы в степень — это умножение квадратной матрицы на саму себя n раз, где n — натуральный показатель. Запись A^n означает A * A * … * A (n множителей), и умножение здесь матричное (строка на столбец), а не поэлементное. Ниже я по шагам посчитаю A^2 и A^3 для конкретной матрицы 2×2, руками и с числами, потом проверю результат кодом на numpy и покажу, чем степень матрицы отличается от поэлементного возведения.
Содержание
Когда операция вообще определена
У возведения в степень есть жесткие границы применимости — без них запись A^n не имеет смысла.
- Только квадратная матрица. Число строк равно числу столбцов (2×2, 3×3 и так далее). Умножать матрицу на саму себя можно лишь тогда, когда число столбцов первого множителя совпадает с числом строк второго, а это верно только для квадратной.
- Показатель — натуральное число (1, 2, 3, …). Дробные и отрицательные степени — это отдельная тема (для отрицательных нужна обратная матрица, и она существует не всегда), в этой статье я их не трогаю.
- Граничные случаи: A^1 = A (сама матрица), A^0 = E (единичная матрица того же размера, у нее единицы на главной диагонали и нули вне ее). Это соглашение, аналог того, что любое число в нулевой степени равно 1.
Единичная матрица 2×2 выглядит так:
| 1 | 0 |
| 0 | 1 |
Возьмем конкретную матрицу
Дальше весь разбор идет на одной матрице A размера 2×2 — она будет сквозной через всю статью:
| 1 | 2 |
| 3 | 4 |
То есть A = [[1, 2], [3, 4]]: в первой строке 1 и 2, во второй 3 и 4.
Шаг 1. Считаем A^2 (квадрат матрицы) руками
A^2 = A * A. Правило матричного умножения: элемент результата в позиции (строка i, столбец j) — это сумма произведений элементов i-й строки первой матрицы на элементы j-го столбца второй матрицы. Проще говоря, «строка на столбец».
У нас обе матрицы одинаковые (A * A), поэтому берем строки левой A и столбцы правой A. Считаем все четыре элемента.
- Позиция (1, 1): 1-я строка (1, 2) на 1-й столбец (1, 3):
1*1 + 2*3 = 1 + 6 = 7. - Позиция (1, 2): 1-я строка (1, 2) на 2-й столбец (2, 4):
1*2 + 2*4 = 2 + 8 = 10. - Позиция (2, 1): 2-я строка (3, 4) на 1-й столбец (1, 3):
3*1 + 4*3 = 3 + 12 = 15. - Позиция (2, 2): 2-я строка (3, 4) на 2-й столбец (2, 4):
3*2 + 4*4 = 6 + 16 = 22.
Собираем результат:
| 7 | 10 |
| 15 | 22 |
Итого A^2 = [[7, 10], [15, 22]].
Шаг 2. Считаем A^3 = A^2 * A
Для третьей степени не нужно перемножать три матрицы сразу — достаточно взять уже посчитанную A^2 и умножить ее на A. Это ключевая идея: A^3 = A^2 * A, A^4 = A^3 * A и так далее, каждый раз домножаем предыдущий результат на A.
Берем строки A^2 = [[7, 10], [15, 22]] и столбцы A = [[1, 2], [3, 4]].
- Позиция (1, 1): (7, 10) на (1, 3):
7*1 + 10*3 = 7 + 30 = 37. - Позиция (1, 2): (7, 10) на (2, 4):
7*2 + 10*4 = 14 + 40 = 54. - Позиция (2, 1): (15, 22) на (1, 3):
15*1 + 22*3 = 15 + 66 = 81. - Позиция (2, 2): (15, 22) на (2, 4):
15*2 + 22*4 = 30 + 88 = 118.
Результат:
| 37 | 54 |
| 81 | 118 |
Итого A^3 = [[37, 54], [81, 118]].
Порядок множителей в общем случае важен (A * B не всегда равно B * A), но конкретно при возведении в степень мы умножаем матрицу на саму себя, поэтому A^2 * A и A * A^2 дадут одно и то же.
Степень матрицы — это не поэлементное возведение
Здесь чаще всего ошибаются. Возвести матрицу в степень и возвести в степень каждый ее элемент по отдельности — две разные операции с разными результатами.
Если бы мы просто возвели каждый элемент A в квадрат (поэлементно), получили бы [[1, 4], [9, 16]]: 1^2=1, 2^2=4, 3^2=9, 4^2=16. Сравните с настоящим A^2:
| Операция | Что делаем | Результат для нашей A |
|---|---|---|
| Степень матрицы (A^2) | Матричное умножение A на A (строка на столбец) | [[7, 10], [15, 22]] |
| Поэлементное возведение | Каждый элемент отдельно в квадрат | [[1, 4], [9, 16]] |
Числа не совпадают ни в одной клетке. Когда говорят «возвести матрицу в степень», по умолчанию имеют в виду именно матричное умножение, то есть первую строку таблицы. Поэлементная версия — это отдельная операция, в математической записи ее обычно обозначают отдельно (например, A с кружком-степенью), а в коде numpy она делается оператором **, о чем ниже.
Проверка кодом на numpy
Ручной счет удобно проверять и автоматизировать. В Python для настоящего возведения матрицы в степень есть готовая функция numpy.linalg.matrix_power — ее и стоит использовать, а не писать умножение вручную.
import numpy as np
A = np.array([[1, 2],
[3, 4]])
print(np.linalg.matrix_power(A, 2))
# Вывод:
# [[ 7 10]
# [15 22]]
print(np.linalg.matrix_power(A, 3))
# Вывод:
# [[ 37 54]
# [ 81 118]]
print(np.linalg.matrix_power(A, 0))
# Вывод (единичная матрица E):
# [[1 0]
# [0 1]]Числа совпали с тем, что я посчитал руками, — значит, арифметика верна. Обратите внимание на границу инструмента: matrix_power делает именно матричное умножение. А вот оператор ** в numpy работает поэлементно и даст совсем другое:
print(A ** 2)
# Вывод (поэлементно, НЕ степень матрицы):
# [[ 1 4]
# [ 9 16]]Это тот самый разнос из предыдущего раздела: matrix_power(A, 2) — степень матрицы, A ** 2 — поэлементный квадрат. Путать их — типичная ошибка новичка в numpy.
Коротко про большие степени
Для больших n (например, A в степени 1000) умножать матрицу на себя тысячу раз подряд неэффективно. Есть оптимизация — быстрое возведение в степень (бинарное): степень разбивают на квадраты, и число умножений растет как логарифм от n, а не линейно. Углубляться здесь не буду — для учебных примеров хватает последовательного умножения, а в реальном коде numpy.linalg.matrix_power уже использует эффективный алгоритм под капотом.
Выводы
- Возведение матрицы в степень A^n — это n-кратное матричное умножение матрицы на саму себя, а не возведение каждого элемента отдельно.
- Операция определена только для квадратных матриц и натурального показателя; по соглашению A^1 = A, A^0 = E (единичная матрица).
- Каждый элемент произведения считается по правилу «строка на столбец»: сумма попарных произведений элементов строки первой матрицы и столбца второй.
- Старшие степени удобно строить по цепочке: A^3 = A^2 * A, A^4 = A^3 * A, переиспользуя уже посчитанный результат.
- Для нашей A = [[1, 2], [3, 4]] получается A^2 = [[7, 10], [15, 22]] и A^3 = [[37, 54], [81, 118]] — и руками, и через numpy.
- В коде используйте
numpy.linalg.matrix_powerдля степени матрицы; оператор**возводит поэлементно и даст другой результат.
Где применяется / связь с практикой
Степени матриц — не абстрактное упражнение. На них держатся марковские цепи (матрица переходов в степени n дает вероятности состояний через n шагов), подсчет путей длины k в графе через степень матрицы смежности, а также многие рекуррентные вычисления, которые сводят к матричному виду и ускоряют быстрым возведением в степень. Прикладная математика и линейная алгебра — фундамент, на котором стоят машинное обучение, компьютерная графика и анализ данных.
Освойте тему на практике
Если хочется разобраться в этом системно, а не собирать по кускам, посмотрите курс Прикладная математика для Data Science в Otus — там линейная алгебра дается сразу под задачи анализа данных. Понять, подходит ли формат, можно бесплатно: у Otus регулярно проходят открытые уроки и вебинары, где темы разбирают вживую с преподавателем.
Смежные темы: Матрицы: основные операции, Матрицы и уравнения: что нужно знать для их решения.
FAQ
Можно ли возвести в степень неквадратную матрицу (например, 2×3)?
Нет. Чтобы умножить матрицу на саму себя, число ее столбцов должно совпадать с числом строк, а это выполнено только для квадратной. Для матрицы 2×3 запись A^2 не определена.
Что такое A в нулевой и первой степени?
A^1 — это сама матрица A, без изменений. A^0 по соглашению равна единичной матрице E того же размера (единицы на главной диагонали, нули вне ее) — по аналогии с тем, что число в нулевой степени равно 1.
Как быть с отрицательной степенью, например A^(-1)?
Отрицательная степень определяется через обратную матрицу: A^(-1) — это обратная к A, а A^(-2) = (A^(-1))^2. Но обратная матрица существует не для всякой квадратной матрицы (только если ее определитель не равен нулю), поэтому отрицательные степени — отдельный случай за рамками натурального показателя.
