はじめに

　『スタンフォード　ベクトル・行列からはじめる最適化数学』の学習ノートです。
　「数式の行間埋め」や「Pythonを使っての再現」によって理解を目指します。本と一緒に読んでください。

　この記事は6.1節「行列」から6.3節「転置, 和, ノルム」の内容です。
　行列の定義を確認して、性質を導出します。また、NumPyライブラリでの扱い方を確認します。

【前の内容】

www.anarchive-beta.com

【他の内容】

www.anarchive-beta.com

【今回の内容】

はじめに
6.1.0 行列の定義
- 行列
6.2.0 行列の例
参考書籍
おわりに

6.1.0 行列の定義

　行列(matrix)の基本的な定義を数式とプログラム(NumPyライブラリ)で確認します。

　利用するライブラリを読み込みます。

# 利用ライブラリ
import numpy as np

行列

　行列は、要素(成分)を縦横に並べて次のように表されます。

　 $m$ 行 $n$ 列の行列を $m \times n$ 行列と呼び、 $i$ 行 $j$ 列目の要素を $a_{i,j}$ で表します。

　2次元配列を作成します。

# 行列(2次元配列)を作成
A = np.array(
    [[0.0, 1.0, -2.3, 0.1], 
     [1.2, 4.0, -0.1, 0.0], 
     [4.1, -1.0, 0.0, 1.7]]
)
print(A)

[[ 0.   1.  -2.3  0.1]
 [ 1.2  4.  -0.1  0. ]
 [ 4.1 -1.   0.   1.7]]

　多次元配列は、入れ子にしたリストを np.array() に渡して作成できます。

　次の $3 \times 4$ 行列 $\mathbf{A}$ を2次元配列 A とします。

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{0,0} & a_{0,1} & a_{0,2} & a_{0,3} \\ a_{1,0} & a_{1,1} & a_{1,2} & a_{1,3} \\ a_{2,0} & a_{2,1} & a_{2,2} & a_{2,3} \end{bmatrix} = \begin{bmatrix} 0 & 1 & -2.3 & 0.1 \\ 1.2 & 4 & -0.1 & 0 \\ 4.1 & -1 & 0 & 1.7 \end{bmatrix}$

　ただし、Pythonのインデックスが0から割り当てられるのに合わせた添字(インデックス)で表記しています。

　配列の形状を確認します。

# 次元数を確認
print(A.ndim)

# 形状を確認
print(A.shape)

# 要素数を確認
print(A.size)

2
(3, 4)
12

　NumPy配列の ndim メソッドで次元数、shape メソッドで次元ごとの要素数、size メソッドで全ての要素数を返します。

　A は $3 \times 4$ の行列(2次元配列)だと分かります。

　インデックスを指定して、配列から要素を抽出します。

# 行・列インデックスを指定
i = 2
j = 1

# 要素を抽出
a_ij = A[i, j]
print(a_ij)

-1.0

　添字を使って 2次元配列[行番号, 列番号] で要素を取り出せます。ただし、数式 $a_{i,j}$ とプログラム A[i, j] でインデックスの割り当て方が異なる場合に注意が必要です。

　行列 $\mathbf{A}$ の $j$ 列目の全ての要素を列ベクトル(column vector)と呼びます。

$\displaystyle \mathbf{a}_j = \begin{bmatrix} a_{1,j} \\ a_{2,j} \\ \vdots \\ a_{m,j} \end{bmatrix}$

　 $m$ 次元縦ベクトルを $m \times 1$ 行列として扱います。
　または、 $i$ 行目の全ての要素を行ベクトル(row vector)と呼びます。

$\displaystyle \mathbf{a}_i = \begin{bmatrix} a_{i,1} & a_{i,2} & \cdots & a_{i,n} \end{bmatrix}$

　 $n$ 次元横ベクトルを $1 \times n$ 行列として扱います。

　ベクトル $\mathbf{x}$ を縦ベクトル・横ベクトルのどちらで扱うのかはその記事等の定義によります。 $\mathbf{x}$ を縦ベクトルとする場合は $\mathbf{x}^{\top}$ で横ベクトル、 $\mathbf{x}$ を横ベクトルとする場合は $\mathbf{x}^{\top}$ で縦ベクトルを表わせます。
　また、 $1 \times 1$ 行列はスカラとして扱います。

　行インデックスを指定して、配列から行を取り出します。

# 行インデックスを指定
i = 2

# 行ベクトルを抽出
a_i = A[i]
print(a_i)

[ 4.1 -1.   0.   1.7]

　2次元配列[行番号] で行を取り出せます。

　列インデックスを指定して、配列から列を取り出します。

# 列インデックスを指定
j = 1

# 列ベクトルを抽出
a_j = A[:, j]
print(a_j)

[ 1.  4. -1.]

　2次元配列[:, 列番号] で列を取り出せます。: は全ての要素を表します。

　NumPyの1次元配列には縦横の区別がなく、転置できません。

# 転置を確認
print(a_j.T)

[ 1.  4. -1.]

　転置については「転置行列」を参照してください。

　行数と列数の大小関係により呼び方が変わります。

# 行・列数を取得
m = A.shape[0]
n = A.shape[1]
print(m)
print(n)

# 行列の形を確認
if m == n:
    print('square matrix')
elif m > n:
    print('tail matrix')
elif m < n:
    print('wide matrix')

3
4
wide matrix

　行数と列数が同じ( $m = n$ の)行列を正方行列(square matrix)と呼びます。

$\displaystyle \mathbf{X} = \begin{bmatrix} a_{1,1} & x_{1,2} & \cdots & x_{1,n} \\ x_{2,1} & x_{2,2} & \cdots & x_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ x_{n,1} & x_{n,2} & \cdots & x_{n,n} \end{bmatrix}$

6.2.0 行列の例

　ここまでは、行列の基本的な定義を確認しました。ここからは、個別に名前の付いた(それぞれ特徴を持つ)行列を確認していきます。

ブロック行列と部分行列

　次の行列を部分行列(submatrix)とします。

$\displaystyle \begin{aligned} &\mathbf{B} = \begin{bmatrix} b_{1,1} & \cdots & b_{1,n} \\ \vdots & \ddots & \vdots \\ b_{m,1} & \cdots & b_{m,n} \end{bmatrix} ,\ &\mathbf{C} = \begin{bmatrix} c_{1,1} & \cdots & c_{1,p} \\ \vdots & \ddots & \vdots \\ c_{m,1} & \cdots & c_{m,p} \end{bmatrix} \\ &\mathbf{D} = \begin{bmatrix} d_{1,1} & \cdots & d_{1,n} \\ \vdots & \ddots & \vdots \\ d_{o,1} & \cdots & d_{o,n} \end{bmatrix} ,\ &\mathbf{E} = \begin{bmatrix} e_{1,1} & \cdots & e_{1,p} \\ \vdots & \ddots & \vdots \\ e_{o,1} & \cdots & e_{o,p} \end{bmatrix} \end{aligned}$

　横方向に結合する行列の行数、縦方向に結合する行列の列数がそれぞれ一致する必要があります。
　複数の行列によって構成される行列をブロック行列(block matrix)と呼びます。また、ブロック行列を構成する行列を部分行列と呼びます。

$\displaystyle \begin{aligned} \mathbf{A} &= \begin{bmatrix} \mathbf{B} & \mathbf{C} \\ \mathbf{D} & \mathbf{E} \end{bmatrix} \\ &= \begin{bmatrix} b_{1,1} & \cdots & b_{1,n} & c_{1,1} & \cdots & c_{1,p} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ b_{m,1} & \cdots & b_{m,n} & c_{m,1} & \cdots & c_{m,p} \\ d_{1,1} & \cdots & d_{1,n} & e_{1,1} & \cdots & e_{1,p} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ d_{o,1} & \cdots & d_{o,n} & e_{o,1} & \cdots & e_{o,p} \end{bmatrix} \\ &= \begin{bmatrix} a_{1,1} & \cdots & a_{1,n} & a_{1,n+1} & \cdots & a_{1,n+p} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{m,1} & \cdots & a_{m,n} & a_{m,n+1} & \cdots & a_{m,n+p} \\ a_{m+1,1} & \cdots & a_{m+1,n} & a_{m+1,n+1} & \cdots & a_{m+1,n+p} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{m+o,1} & \cdots & a_{m+o,n} & a_{m+o,n+1} & \cdots & a_{m+o,n+p} \end{bmatrix} \end{aligned}$

　複数の2次元配列を作成します。

# (部分)行列を作成
B = np.array(
    [[0.0, 1.0], 
     [2.0, 3.0]]
)
C = np.array(
    [[0.0, 1.0, 2.0], 
     [3.0, 4.0, 5.0]]
)
D = np.array(
    [[0.0, 1.0], 
     [2.0, 3.0], 
     [4.0, 5.0]]
)
E = np.array(
    [[0.0, 1.0, 2.0], 
     [3.0, 4.0, 5.0], 
     [6.0, 7.0, 8.0]]
)
print(B)
print(C)
print(D)
print(E)

[[0. 1.]
 [2. 3.]]
[[0. 1. 2.]
 [3. 4. 5.]]
[[0. 1.]
 [2. 3.]
 [4. 5.]]
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

　B, C、D, E の行数、B, D、C, E の列数がそれぞれ同じになるように行列を作成して、部分行列とします。

　複数の配列を結合します。

# (ブロック)行列を作成
A = np.block(
    [[B, C], 
     [D, E]]
)
print(A)
print(A.shape)

[[0. 1. 0. 1. 2.]
 [2. 3. 3. 4. 5.]
 [0. 1. 0. 1. 2.]
 [2. 3. 3. 4. 5.]
 [4. 5. 6. 7. 8.]]
(5, 5)

　np.block() で複数の行列を結合して、ブロック行列を作成できます。

　スカラや1次元配列を含む場合も同様に処理できます。

# 1次元配列を作成
B = np.array([0.0, 2.0, 3.0])
print(B)

# スカラを作成
C = -1.0
print(C)

# 2次元配列を作成
D = np.array(
    [[2.0, 2.0, 1.0], 
     [1.0, 3.0, 5.0]]
)
print(D)

# 2次元配列を作成
E = np.array(
    [[4.0], 
     [4.0]]
)
print(E)

# (ブロック)行列を作成
A = np.block(
    [[B, C], 
     [D, E]]
)
print(A)
print(A.shape)

[0. 2. 3.]
-1.0
[[2. 2. 1.]
 [1. 3. 5.]]
[[4.]
 [4.]]
[[ 0.  2.  3. -1.]
 [ 2.  2.  1.  4.]
 [ 1.  3.  5.  4.]]
(3, 4)

　スカラを $1 \times 1$ の行列、ベクトル(1次元配列)を $1 \times n$ または $n \times 1$ の行列として扱い、対応する行数・列数が一致する必要があります。

　行インデックスについて $1 \leq p \leq q \leq m$ 、列インデックスについて $1 \leq r \leq s \leq n$ として、 $m \times n$ 行列を $\mathbf{A}$ とします。

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{1,1} & \cdots & a_{1,r} & \cdots & a_{1,s} & \cdots & a_{1,n} \\ \vdots & \ddots & \vdots & \ddots & \vdots & \ddots & \vdots \\ a_{p,1} & \cdots & a_{p,r} & \cdots & a_{p,s} & \cdots & a_{p,n} \\ \vdots & \ddots & \vdots & \ddots & \vdots & \ddots & \vdots \\ a_{q,1} & \cdots & a_{q,r} & \cdots & a_{q,s} & \cdots & a_{q,n} \\ \vdots & \ddots & \vdots & \ddots & \vdots & \ddots & \vdots \\ a_{m,1} & \cdots & a_{m,r} & \cdots & a_{m,s} & \cdots & a_{m,n} \end{bmatrix}$

　 $\mathbf{A}$ の「行 $p$ から行 $q$ まで」と「列 $r$ から列 $s$ まで」の全ての要素を $\mathbf{A}_{p:q,r:s}$ で表します。

$\displaystyle \mathbf{A}_{p:q,r:s} = \begin{bmatrix} a_{p,r} & a_{p,r+1} & \cdots & a_{p,s} \\ a_{p+1,r} & a_{p+1,r+1} & \cdots & a_{p+1,s} \\ \vdots & \vdots & \ddots & \vdots \\ a_{q,r} & a_{q,r+1} & \cdots & a_{q,s} \end{bmatrix}$

　部分行列 $\mathbf{A}_{p:q,r:s}$ は、 $(q - p + 1) \times (s - r + 1)$ 行列になります。
　 $\mathbf{A}$ は次のブロック行列で表わせます。

$\displaystyle \mathbf{A} = \begin{bmatrix} \mathbf{A}_{1:p-1,1:r-1} & \mathbf{A}_{1:p-1,r:s} & \mathbf{A}_{1:p-1,s+1:n} \\ \mathbf{A}_{p:q,1:r-1} & \mathbf{A}_{p:q,r:s} & \mathbf{A}_{p:q,s+1:n} \\ \mathbf{A}_{q+1:m,1:r-1} & \mathbf{A}_{q+1:m,r:s} & \mathbf{A}_{q+1:m,s+1:n} \end{bmatrix}$

　インデックスの範囲を指定して、配列から配列を抽出します。

# 行・列インデックスの範囲を指定
p, q = 1, 2
r, s = 2, 3

# 部分行列を抽出
A_sub = A[p:(q+1), r:(s+1)]
print(A_sub)
print(A_sub.shape)

[[1. 4.]
 [5. 4.]]
(2, 2)

　2次元配列[複数の行番号, 複数の列番号] で配列を取り出せます。

　 $\mathbf{a}_j = (a_{1,j}, \cdots, a_{m,j})^{\top}$ を列ベクトルとすると、 $\mathbf{A}$ を次のブロック行列で表わせます。

$\displaystyle \mathbf{A} = \begin{bmatrix} \mathbf{a}_1 & \mathbf{a}_2 & \cdots & \mathbf{a}_n \end{bmatrix}$

　 $m$ 次元の列ベクトルを横に $n$ 個並べて $m \times n$ 行列になります。
　また、 $\mathbf{a}_i = (a_{i,1}, \cdots, a_{i,n})$ を行ベクトルとすると、次のように表わせます。

$\displaystyle \mathbf{A} = \begin{bmatrix} \mathbf{a}_1 \\ \mathbf{a}_2 \\ \vdots \\ \mathbf{a}_m \end{bmatrix}$

　 $n$ 次元の行ベクトルを縦に $m$ 個並べて $m \times n$ 行列になります。

　ちなみに、行方向の結合を連結(concatenatiton)、列方向の結合をスタック(stack)と呼ぶとありますが、np.np.concatenate() と np.stack() とは挙動がことなります。

ゼロ行列

　全ての要素が0の行列をゼロ行列(zero matrix)と呼びます。

$\displaystyle \mathbf{O} = \begin{bmatrix} O_{1,1} & O_{1,2} & \cdots & O_{1,n} \\ O_{2,1} & O_{2,2} & \cdots & O_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ O_{m,1} & O_{m,2} & \cdots & O_{m,n} \end{bmatrix} = \begin{bmatrix} 0 & 0 & \cdots & 0 \\ 0 & 0 & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \cdots & 0 \end{bmatrix}$

　全てのインデックスで $O_{i,j} = 0$ です。 $m \times n$ のゼロ行列を $\mathbf{O}_{m \times n}$ で表すこともあります。

　行数と列数を指定して、全ての要素が 0 の配列を作成します。

# 行・列数を指定
m = 5
n = 6

# ゼロ行列を作成
O = np.zeros((m, n))
print(O)
print(O.shape)

[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]
(5, 6)

　np.zeros() でゼロ行列を作成できます。

単位行列

　インデックス $i, j$ が同じ要素を対角要素(diagonal element)、 $i, j$ が異なる要素を非対角要素(off-diagonal element)と呼びます。
　対角要素が1でそれ以外の要素が0の正方行列を単位行列(identity matrix)と呼びます。

$\displaystyle \mathbf{I} = \begin{bmatrix} I_{1,1} & I_{1,2} & \cdots & I_{1,n} \\ I_{2,1} & I_{2,2} & \cdots & I_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ I_{n,1} & I_{n,2} & \cdots & I_{n,n} \end{bmatrix} = \begin{bmatrix} 1 & 0 & \cdots & 0 \\ 0 & 1 & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \cdots & 1 \end{bmatrix}$

　対角要素(値が1の要素)と非対角要素(値が0の要素)をまとめて次の式で表わせます。

$\displaystyle I_{i,j} = \begin{cases} 1 \quad (i = j) \\ 0 \quad (i \neq j) \end{cases}$

　 $n \times n$ の単位行列を $\mathbf{I}_{n \times n}$ や $\mathbf{I}_n$ で表すこともあります。

　行数を指定して、対角要素が 1 で非対角要素が 0 の配列を作成します。

# 行数を指定
n = 4

# 単位行列を作成
I = np.identity(n)
print(I)
print(I.shape)

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]
(4, 4)

　np.identity() で単位行列を作成できます。

　インデックスを指定して、対角要素や非対角要素を抽出します。

# 行・列インデックスを指定
i = 3
j = 2

# 対角要素を抽出
I_ii = I[i, i]
print(I_ii)

# 非対角要素を抽出
I_ij = I[i, j]
print(I_ij)

1.0
0.0

　標準単位ベクトルを縦ベクトル

$\displaystyle \mathbf{e}_i = \begin{bmatrix} e_1 \\ \vdots \\ e_i \\ \vdots \\ e_n \end{bmatrix} = \begin{bmatrix} 0 \\ \vdots \\ 1 \\ \vdots \\ 0 \end{bmatrix}$

とすると、単位行列は次のブロック行列で表わせます。

$\displaystyle \mathbf{I} = \begin{bmatrix} \mathbf{e}_1 & \mathbf{e}_2 & \cdots & \mathbf{e}_n \end{bmatrix}$

　また、標準単位ベクトルを横ベクトル

$\displaystyle \begin{aligned} \mathbf{e}_j &= \begin{bmatrix} e_1 & \cdots & e_j & \cdots & e_n \end{bmatrix} \\ &= \begin{bmatrix} 0 & \cdots & 1 & \cdots & 0 \end{bmatrix} \end{aligned}$

とすると、次のブロック行列で表わせます。

$\displaystyle \mathbf{I} = \begin{bmatrix} \mathbf{e}_1 \\ \mathbf{e}_2 \\ \vdots \\ \mathbf{e}_n \end{bmatrix}$

　 $n$ 次元の縦または行ベクトルを $n$ 個並べて $n \times n$ 行列になります。
　標準単位ベクトルについては「【Python】1.3：標準単位ベクトルの線形結合の可視化【『スタンフォード線形代数入門』のノート】 - からっぽのしょこ」を参照してください。

対角行列

　非対角要素が0の正方行列を対角行列(diagonal matrix)と呼びます。

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n,1} & a_{n,2} & \cdots & a_{n,n} \end{bmatrix} = \begin{bmatrix} a_{1,1} & 0 & \cdots & 0 \\ 0 & a_{2,2} & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \cdots & a_{n,n} \end{bmatrix}$

　 $a_{i,j} = 0\ (i \neq j)$ です。対角要素が0の場合もあります。
　ゼロ行列と単位行列も対角行列です。

　 $n$ 個の対角要素を $\mathbf{a} = (a_1, a_2, \cdots, a_n)$ として、 $\mathrm{diag}(\mathbf{x})$ で対角行列を表すこともあります。

$\displaystyle \mathbf{A} = \mathrm{diag}(\mathbf{a}) = \begin{bmatrix} a_1 & 0 & \cdots & 0 \\ 0 & a_2 & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \cdots & a_n \end{bmatrix}$

　さらに、 $n \times n$ の正方行列を $\mathbf{A} = (a_{1,1}, \cdots, a_{n,n})$ として、 $\mathrm{diag}(\mathbf{X})$ で対角要素のベクトルを表すこともあります。

$\displaystyle \mathbf{a} = \mathrm{diag}(\mathbf{A}) = \begin{bmatrix} a_{1,1} \\ a_{2,2} \\ \vdots \\ a_{n,n} \end{bmatrix}$

　1次元配列を指定して、指定した値を対角要素とする配列を作成します。

# ベクトルを作成
a = np.array([0.2, -3.0, 1.2])
print(a)
print(a.shape)

# 対角行列を作成
A = np.diag(a)
print(A)
print(A.shape)

[ 0.2 -3.   1.2]
(3,)
[[ 0.2  0.   0. ]
 [ 0.  -3.   0. ]
 [ 0.   0.   1.2]]
(3, 3)

　1次元配列を np.diag() に渡すと、対角要素が入力した値、非対角要素が 0 の2次元配列を返します。

　対角要素を抽出します。

# 対角要素を抽出
b = np.diag(A)
print(b)
print(b.shape)

[ 0.2 -3.   1.2]
(3,)

　2次元配列を np.diag() に渡すと、対角要素を取り出して1次元配列として返します。

　ゼロ行列や単位行列も対角行列なので、np.diag() を使って作成できます。

　対角要素として、全ての要素が 0 の1次元配列を指定します。

# 行数を指定
n = 4

# ゼロ行列を作成
O = np.diag(np.zeros(n))
print(O)
print(O.shape)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
(4, 4)

　対角要素が 0 で非対角要素も 0 になるので、ゼロ行列を作成できます。

　対角要素として、全ての要素が 1 の1次元配列を指定します。

# 行数を指定
n = 4

# 単位行列を作成
I = np.diag(np.ones(n))
print(I)
print(I.shape)

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]
(4, 4)

　対角要素が 1 で非対角要素も 0 になるので、単位行列を作成できます。

三角行列

　 $i \gt j$ の要素が $a_{i,j} = 0$ である正方行列を上三角行列(upper triangular matrix)と呼びます。

$\displaystyle \begin{aligned} \mathbf{A} &= \begin{bmatrix} a_{1,1} & a_{1,2} & a_{1,3} & \cdots & a_{1,n-1} & a_{1,n} \\ a_{2,1} & a_{2,2} & a_{2,3} & \cdots & a_{2,n-1} & a_{2,n} \\ a_{3,1} & a_{3,2} & a_{3,3} & \cdots & a_{3,n-1} & a_{3,n} \\ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\ a_{n-1,1} & a_{n-1,2} & a_{n-1,3} & \cdots & a_{n-1,n-1} & a_{n-1,n} \\ a_{n,1} & a_{n,2} & a_{n,3} & \cdots & a_{n,n-1} & a_{n,n} \end{bmatrix} \\ &= \begin{bmatrix} a_{1,1} & a_{1,2} & a_{1,3} & \cdots & a_{1,n-1} & a_{1,n} \\ 0 & a_{2,2} & a_{2,3} & \cdots & a_{2,n-1} & a_{2,n} \\ 0 & 0 & a_{3,3} & \cdots & a_{3,n-1} & a_{3,n} \\ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\ 0 & 0 & 0 & \cdots & a_{n-1,n-1} & a_{n-1,n} \\ 0 & 0 & 0 & \cdots & 0 & a_{n,n} \end{bmatrix} \end{aligned}$

　左下の要素が全て0です。
　また、 $i \lt j$ の要素が $a_{i,j} = 0$ である正方行列を下三角行列(lower triangular matrix)と呼びます。

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{1,1} & 0 & 0 & \cdots & 0 & 0 \\ a_{2,1} & a_{2,2} & 0 & \cdots & 0 & 0 \\ a_{3,1} & a_{3,2} & a_{3,3} & \cdots & 0 & 0 \\ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\ a_{n-1,1} & a_{n-1,2} & a_{n-1,3} & \cdots & a_{n-1,n-1} & 0 \\ a_{n,1} & a_{n,2} & a_{n,3} & \cdots & a_{n,n-1} & a_{n,n} \end{bmatrix}$

　右上の要素が全て0です。
　上三角行列と下三角行列をまとめて三角行列(triangular matrix)と呼びます。対角行列は上三角行列であり下三角行列でもあります。

　2次元配列を指定して、左下の要素を 0 にします。

# 行列を作成
A = np.array(
    [[1.0, -1.0, 0.7], 
     [-0.6, 1.2, -1.1], 
     [-0.3, 3.5, 3.2]]
)
print(A)
print(A.shape)

# 上三角行列を作成
B = np.triu(A)
print(B)
print(B.shape)

[[ 1.  -1.   0.7]
 [-0.6  1.2 -1.1]
 [-0.3  3.5  3.2]]
(3, 3)
[[ 1.  -1.   0.7]
 [ 0.   1.2 -1.1]
 [ 0.   0.   3.2]]
(3, 3)

　2次元配列を np.triu() に渡すと、 $i \gt j$ の要素を 0 に置き換えた配列を返します。言い換えると、 $i \leq j$ の要素を取り出して上三角行列を作成します。

　2次元配列を指定して、左下の要素を 0 にします。

# 行列を作成
A = np.array(
    [[-0.6, 1.2], 
     [-0.3, 3.5]]
)
print(A)
print(A.shape)

# 下三角行列を作成
B = np.tril(A)
print(B)
print(B.shape)

[[-0.6  1.2]
 [-0.3  3.5]]
(2, 2)
[[-0.6  0. ]
 [-0.3  3.5]]
(2, 2)

　2次元配列を np.tril() に渡すと、 $i \lt j$ の要素を 0 に置き換えた配列を返します。言い換えると、 $i \geq j$ の要素を取り出して下三角行列を作成します。

疎行列

　多くの要素が0である(少数の要素が0ではない値である)行列を疎行列(sparse matrix)と呼びます。
　ゼロ行列や単位行列も疎行列です。

　0でない値とインデックスを指定して、他の要素が全て 0 の配列を作成します。

# 行・列数を指定
m = 3
n = 4

# 非ゼロの値を指定
a = np.array([1.0, 2.0, 3.0, 4.0])

# 非ゼロの行・列インデックスを指定
row_idx = np.array([0, 0, 1, 1])
col_idx = np.array([1, 2, 2, 3])

# 疎行列を作成
A = np.zeros((m, n))
A[row_idx, col_idx] = a
print(A)
print(A.shape)

[[0. 1. 2. 0.]
 [0. 0. 3. 4.]
 [0. 0. 0. 0.]]
(3, 4)

　非ゼロの要素の値とインデックスを指定します。
　np.zero() で全ての要素が 0 の配列を作成して、指定したインデックスに値を代入して、疎行列を作成します。

　 $2 \times 3$ 行列

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{0,0} & a_{0,1} & a_{0,2} & a_{0,3} \\ a_{1,0} & a_{1,1} & a_{1,2} & a_{1,3} \\ a_{1,0} & a_{1,1} & a_{1,2} & a_{1,3} \end{bmatrix} = \begin{bmatrix} 0 & 1 & 2 & 0 \\ 0 & 0 & 3 & 4 \\ 0 & 0 & 0 & 0 \end{bmatrix}$

を作成します。ただし、Pythonのインデックスが0から割り当てられるのに合わせた添字(インデックス)で表記しています。

　2次元配列を指定して、多くの要素が 0 の配列を作成します。

# 行列を作成
A = np.array(
    [[1.0, 2.0, 3.0], 
     [4.0, 5.0, 6.0]]
)
print(A)
print(A.shape)

# 行列の形状を取得
m = A.shape[0]
n = A.shape[1]

# ゼロ行列を作成
O_nm = np.zeros((n, m))

# 単位行列を作成
I_m = np.identity(m)
I_n = np.identity(n)

# 行列を作成
B = np.block(
    [[I_m, A], 
     [O_nm, I_n]]
)
print(B)
print(B.shape)

[[1. 2. 3.]
 [4. 5. 6.]]
(2, 3)
[[1. 0. 1. 2. 3.]
 [0. 1. 4. 5. 6.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
(5, 5)

　 $2 \times 3$ 行列

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{0,0} & a_{0,1} & a_{0,2} \\ a_{1,0} & a_{1,1} & a_{1,2} \end{bmatrix} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}$

を用いて、疎行列な上三角行列

$\displaystyle \begin{aligned} \mathbf{B} &= \begin{bmatrix} \mathbf{I}_2 & \mathbf{A} \\ \mathbf{O}_{3,2} & \mathbf{I}_3 \end{bmatrix} \\ &= \begin{bmatrix} I_{0,0} & I_{0,1} & a_{0,0} & a_{0,1} & a_{0,2} \\ I_{1,0} & I_{1,1} & a_{1,0} & a_{1,1} & a_{1,2} \\ O_{0,0} & O_{0,1} & I_{0,0} & I_{0,1} & I_{0,2} \\ O_{1,0} & O_{1,1} & I_{1,0} & I_{1,1} & I_{1,2} \\ O_{2,0} & O_{2,1} & I_{2,0} & I_{2,1} & I_{2,2} \end{bmatrix} \\ &= \begin{bmatrix} 1 & 0 & 1 & 2 & 3 \\ 0 & 1 & 4 & 5 & 6 \\ 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 1 \end{bmatrix} \\ &= \begin{bmatrix} b_{0,0} & b_{0,1} & b_{0,2} & b_{0,3} & b_{0,4} \\ b_{1,0} & b_{1,1} & b_{1,2} & b_{1,3} & b_{1,4} \\ b_{2,0} & b_{2,1} & b_{2,2} & b_{2,3} & b_{2,4} \\ b_{3,0} & b_{3,1} & b_{3,2} & b_{3,3} & b_{3,4} \\ b_{4,0} & b_{4,1} & b_{4,2} & b_{4,3} & b_{4,4} \end{bmatrix} \end{aligned}$

を作成します。

転置行列

　行列の行と列を入れ替えることを転置(transpose)と呼び、行列 $\mathbf{A}$ の転置行列を $\mathbf{A}^{\top}$ で表します。

$\displaystyle \mathbf{A} = \begin{bmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m,1} & a_{m,2} & \cdots & a_{m,n} \end{bmatrix} ,\ \mathbf{A}^{\top} = \begin{bmatrix} a_{1,1} & a_{2,1} & \cdots & a_{m,1} \\ a_{1,2} & a_{2,2} & \cdots & a_{m,2} \\ \vdots & \vdots & \ddots & \vdots \\ a_{1,n} & a_{2,n} & \cdots & a_{m,n} \end{bmatrix}$

　 $m \times n$ 行列の転置行列は $n \times m$ 行列になります。また、 $\mathbf{A}$ の $i$ 行 $j$ 列目の要素と $\mathbf{A}^{\top}$ の $j$ 行 $i$ 列目の要素が一致します。
　転置行列 $\mathbf{A}^{\top}$ の転置行列 $(\mathbf{A}^{\top})^{\top}$ は元の行列 $(\mathbf{A}^{\top})^{\top} = \mathbf{A}$ になります。

　2次元配列を指定して、転置した配列を作成します。

# 行列を作成
A = np.array(
    [[0.0, 4.0], 
     [7.0, 0.0], 
     [3.0, 1.0]]
)
print(A)
print(A.shape)

# 転置行列を作成
At = A.T
print(At)
print(At.shape)

[[0. 4.]
 [7. 0.]
 [3. 1.]]
(3, 2)
[[0. 7. 3.]
 [4. 0. 1.]]
(2, 3)

　NumPy配列の T メソッドで転置できます。

　元の配列と転置した配列の要素を確認します。

# 行・列インデックスを指定
i, j = 1, 0

# 行・列を入れ替えた要素を確認
print(A[i, j] == At[j, i])

True

　行インデックスと列インデックスを入れ替えた要素が同じ値なのを確認できます。

　更に転置すると元の配列になります。

# 転置行列の転置を確認
print(A == At.T)

[[ True  True]
 [ True  True]
 [ True  True]]

　それぞれの要素が同じ値なのを確認できます。

　次の行列を部分行列とします。

$\displaystyle \begin{aligned} &\mathbf{B} = \begin{bmatrix} b_{1,1} & \cdots & b_{1,n} \\ \vdots & \ddots & \vdots \\ b_{m,1} & \cdots & b_{m,n} \end{bmatrix} ,\ &\mathbf{C} = \begin{bmatrix} c_{1,1} & \cdots & c_{1,n} \\ \vdots & \ddots & \vdots \\ c_{m,1} & \cdots & c_{m,n} \end{bmatrix} \\ &\mathbf{D} = \begin{bmatrix} d_{1,1} & \cdots & d_{1,n} \\ \vdots & \ddots & \vdots \\ d_{m,1} & \cdots & d_{m,n} \end{bmatrix} ,\ &\mathbf{E} = \begin{bmatrix} e_{1,1} & \cdots & e_{1,n} \\ \vdots & \ddots & \vdots \\ e_{m,1} & \cdots & e_{m,n} \end{bmatrix} \end{aligned}$

　転置してもブロック行列が成り立つには、全ての部分行列の形状が一致している必要があります。
　この4つの行列によるブロック行列を $\mathbf{A}$ とします。

$\displaystyle \begin{aligned} \mathbf{A} &= \begin{bmatrix} \mathbf{B} & \mathbf{C} \\ \mathbf{D} & \mathbf{E} \end{bmatrix} \\ &= \begin{bmatrix} b_{1,1} & \cdots & b_{1,n} & c_{1,1} & \cdots & c_{1,n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ b_{m,1} & \cdots & b_{m,n} & c_{m,1} & \cdots & c_{m,n} \\ d_{1,1} & \cdots & d_{1,n} & e_{1,1} & \cdots & e_{1,n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ d_{m,1} & \cdots & d_{m,n} & e_{m,1} & \cdots & e_{m,n} \end{bmatrix} \\ &= \begin{bmatrix} a_{1,1} & \cdots & a_{1,n} & a_{1,n+1} & \cdots & a_{1,2n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{m,1} & \cdots & a_{m,n} & a_{m,n+1} & \cdots & a_{m,2n} \\ a_{m+1,1} & \cdots & a_{m+1,n} & a_{m+1,n+1} & \cdots & a_{m+1,2n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{2m,1} & \cdots & a_{2m,n} & a_{2m,n+1} & \cdots & a_{2m,2n} \end{bmatrix} \end{aligned}$

　それぞれ転置した行列によるブロック行列は $\mathbf{A}^{\top}$ になります。

$\displaystyle \begin{aligned} \mathbf{A}^{\top} &= \begin{bmatrix} \mathbf{B}^{\top} & \mathbf{D}^{\top} \\ \mathbf{C}^{\top} & \mathbf{E}^{\top} \end{bmatrix} \\ &= \begin{bmatrix} b_{1,1} & \cdots & b_{m,1} & d_{1,1} & \cdots & d_{1,n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ b_{1,n} & \cdots & b_{m,n} & d_{1,n} & \cdots & d_{m,n} \\ c_{1,1} & \cdots & c_{m,1} & e_{1,1} & \cdots & e_{1,n} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ c_{1,n} & \cdots & c_{m,n} & e_{1,n} & \cdots & e_{m,n} \end{bmatrix} \\ &= \begin{bmatrix} a_{1,1} & \cdots & a_{m,1} & a_{m+1,1} & \cdots & a_{2m,1} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{1,n} & \cdots & a_{m,n} & a_{m+1,n} & \cdots & a_{2m,n} \\ a_{1,n+1} & \cdots & a_{m,n+1} & a_{m+1,n+1} & \cdots & a_{2m,n+1} \\ \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\ a_{1,2n} & \cdots & a_{m,2n} & a_{m+1,2n} & \cdots & a_{2m,2n} \end{bmatrix} \end{aligned}$

　同じ形状の複数の2次元配列を作成します。

# (部分)行列を作成
B = np.array(
    [[0.0, 0.1, 0.2], 
     [0.3, 0.4, 0.5]]
)
C = np.array(
    [[1.0, 1.1, 1.2], 
     [1.3, 1.4, 1.5]]
)
D = np.array(
    [[2.0, 2.1, 2.2], 
     [2.3, 2.4, 2.5]]
)
E = np.array(
    [[3.0, 3.1, 3.2], 
     [3.3, 3.4, 3.5]]
)
print(B)
print(C)
print(D)
print(E)

[[0.  0.1 0.2]
 [0.3 0.4 0.5]]
[[1.  1.1 1.2]
 [1.3 1.4 1.5]]
[[2.  2.1 2.2]
 [2.3 2.4 2.5]]
[[3.  3.1 3.2]
 [3.3 3.4 3.5]]

　複数の配列を結合します。

# (ブロック)行列を結合
A = np.block(
    [[B, C], 
     [D, E]]
)
print(A)
print(A.shape)

[[0.  0.1 0.2 1.  1.1 1.2]
 [0.3 0.4 0.5 1.3 1.4 1.5]
 [2.  2.1 2.2 3.  3.1 3.2]
 [2.3 2.4 2.5 3.3 3.4 3.5]]
(4, 6)

　同様に、転置した配列を結合します。

# 転置した(ブロック)行列を結合
At = np.block(
    [[B.T, D.T], 
     [C.T, E.T]]
)
print(At)
print(At.shape)

[[0.  0.3 2.  2.3]
 [0.1 0.4 2.1 2.4]
 [0.2 0.5 2.2 2.5]
 [1.  1.3 3.  3.3]
 [1.1 1.4 3.1 3.4]
 [1.2 1.5 3.2 3.5]]
(6, 4)

　元の配列と転置した配列の要素を確認します。

# 行・列インデックスを指定
i, j = 1, 3

# 行・列を入れ替えた要素を確認
print(A[i, j] == At[j, i])

# 転置行列の転置を確認
print(A == At.T)

True
[[ True  True  True  True  True  True]
 [ True  True  True  True  True  True]
 [ True  True  True  True  True  True]
 [ True  True  True  True  True  True]]

　それぞれの要素が同じ値なのを確認できます。

　この記事では、基本的な行列の定義と性質を確認しました。次の記事では、グラフで確認します。

参考書籍

Stephen Boyd・Lieven Vandenberghe(著),玉木徹(訳)『スタンフォード　ベクトル・行列からはじめる最適化数学』講談社サイエンティク,2021年.

おわりに

　ベクトル編が終わって3か月ほど三角関数を進めていました。
　この章はさすがに分かるので飛ばそうかとも思ったのですが、行列計算とかPythonやNumPyの使い方とかLaTeXコマンドで行列を書く手間とか諸々のリハビリとして書きました。

　この記事を読むのは初学者・初心者の方だと思います。
　このブログでは、コードと数式が対応するように表現することを心がけています。プログラムで分かるのであれば同じように数式でも分かるよってことが伝われば幸いです。
　また、あえて数式を多めに書くことにしています。数式が大量に登場するとドン引きます(私もそうでしたあるいは今も)が、初心者であればこそ数式を丁寧に見た方が分かりやすいと思います。
　どちらもあくまで私の経験上の話ですが。とはいえ全部をじっくり追っていたら進まないので、必要に応じて読んでください。

　2023年7月12日は、エビ中の元メンバーである柏木ひなたさんのソロでの1st EPのリリース日です！

kashiwagihinata.lnk.to

　わーい、いっぱい聴くぞー。間違ってないYo～♪

【次の内容】

からっぽのしょこ

読んだら書く！書いたら読む！同じ事は二度調べ(たく)ない

6.1-3：行列の定義と例【『スタンフォード線形代数入門』のノート】