2. 역행렬과 행렬식

 

 

 

 

 

In [1]:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d

 

3) 행렬식¶

(1) 행렬식은 부분공간의 선형변환에서의 부피 확대율이다.¶

In [9]:

# - 성질

print(np.identity(3)) 
print("행렬식 : ",np.linalg.det(np.identity(3)))

 

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
행렬식 :  1.0

 

• 성질1 : 단위행렬의 행렬식은 1이다.

In [16]:

A = np.matrix([[2,3],[4,1]])
B = np.matrix([[4,2],[3,1]])

print(np.linalg.det(np.dot(A,B)))
print(np.linalg.det(A) * np.linalg.det(B)) #행렬곱의 행렬식과, 각 행렬식의 곱은 동치이다. 물론, 알고리즘상 약간의 오차는 존재한다.

 

19.999999999999996
20.000000000000004

 

• 성질2 : det(AB) = det(A) * det(B)

In [19]:

A_1 = np.linalg.inv(A)

print(np.linalg.det(A_1))
print(1/np.linalg.det(A)) #역행렬의 행렬식은 해당 행렬의 행렬식의 역수와 같다. 물론, 알고리즘상 약간의 오차는 존재한다.

 

-0.10000000000000002
-0.09999999999999998

 

• 성질3 : det(A^-1) = 1/det(A)

In [80]:

print(" * 2열의 값을 10배 뻥튀기하여 1열에 결합")
print("")
A_1 = A[0] + 10*A[1]
A_2 = A[1]
print(np.vstack([A_1,A_2]))
print("")
print("행렬식 :",np.linalg.det(np.vstack([A_1,A_2])))
print("원래 행렬의 행렬식 : ",np.linalg.det(A))

 

 * 2열의 값을 10배 뻥튀기하여 1열에 결합

[[42 13]
 [ 4  1]]

행렬식 : -9.999999999999998
원래 행렬의 행렬식 :  -10.000000000000002

 

• 성질 4 : 어떤 행/열벡터를 임의의 값으로 뻥튀기한 후, 다른 열에 더해도 행렬식은 변하지 않는다. 이 성질은 행연산의 근거가 된다.

In [79]:

print(" * 2열을 10배 뻥튀기")
print("")
A_1 = A[0]
A_2 = A[1] * 10
print(np.vstack([A_1,A_2]))
print("")
print("행렬식 : ", np.linalg.det(np.vstack([A_1,A_2])), ",원래 행렬식의 10배이다.")
print("")
print(" * 1,2열 모두 10배 뻥튀기")
print("")
A_1 = A[0] * 10
A_2 = A[1] * 10
print(np.vstack([A_1,A_2]))
print("행렬식 : ", np.linalg.det(np.vstack([A_1,A_2])),",원래 행렬식의 100배이다.")

 

 * 2열을 10배 뻥튀기

[[ 2  3]
 [40 10]]

행렬식 :  -100.00000000000004 ,원래 행렬식의 10배이다.

 * 1,2열 모두 10배 뻥튀기

[[20 30]
 [40 10]]
행렬식 :  -999.9999999999998 ,원래 행렬식의 100배이다.

 

• 성질5 : 임의의 갯수의 행/열에 상수배를 하는 경우, 그 임의의 갯수 n만큼 행렬식은 det^(n)으로 늘어난다. 즉, 기하급수적으로 늘어난다.
• 각 열이 독립적으로 행렬식에 영향을 미치는 것을 다중선형성이라고 한다.

In [84]:

print("* 1열과 2열의 순서를 바꾸기")
print("")
A_1 = A[1]
A_2 = A[0]
print(np.vstack([A_1,A_2]))
print("")
print("순서가 바뀐 행렬의 행렬식 :",np.linalg.det(np.vstack([A_1,A_2])))
print("원래 행렬의 행렬식: ",np.linalg.det(A))
print("")

 

* 1열과 2열의 순서를 바꾸기

[[4 1]
 [2 3]]

순서가 바뀐 행렬의 행렬식 : 10.000000000000002
원래 행렬의 행렬식:  -10.000000000000002

 

• 성질6 : 행/열이 교환되는경우, 행렬식의 부호가 바뀐다.
• 이는 '행렬식은 부피 변화율'이란 개념 하에 접근할 때, 부분공간의 기저가 뒤바뀌는(즉, 거꾸로 뒤집어지는) 모양을 상상하면 쉽게 이해할 수 있다.

 

(2) 행렬식의 계산¶

 

3) 역행렬¶

 

(1) 가우스 - 요르단 소거법¶

 

정칙행렬이 되기 위해서는¶

(1) 행렬이 정방행렬(n * n)꼴이어야 하고¶

(2) 행렬이 Full-Rank여야 한다.(즉, 영공간의 차원은 0이어야 한다)¶

In [120]:

# - matrix와 상수만으로 이루어진 블록행렬 표기를 활용한다. 

A = np.matrix([[2,3,3],[3,4,2],[-2,-2,3]]) #행렬 A
n = np.matrix([9,9,2]) #방정식의 상수 벡터

An = np.hstack([A,n.T])
print(An)

 

[[ 2  3  3  9]
 [ 3  4  2  9]
 [-2 -2  3  2]]

 

변형의 조건은 다음과 같다.¶

• 어느 행에 c배를 한다.
• 위에서 c배한 행으로 다른 행을 더하거나 뺀다.
• 행렬이 단위행렬이 되면 연산을 종료한다.

In [121]:

# phase 1 : 1행을 1/2배 한다.

A_1 = (1/2) * An[0]
A_2 = An[1]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  4.5]
 [ 3.   4.   2.   9. ]
 [-2.  -2.   3.   2. ]]

In [122]:

# phase 2 : 1행을 3배하여 2행을 뺀다.

A_1 = An[0]
A_2 = An[1] - 3 * An[0]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  4.5]
 [ 0.  -0.5 -2.5 -4.5]
 [-2.  -2.   3.   2. ]]

In [123]:

# Phase 3 : 1행을 두배하여 3행에 더해준다.

A_1 = An[0]
A_2 = An[1]
A_3 = An[2] + 2 * An[0]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  4.5]
 [ 0.  -0.5 -2.5 -4.5]
 [ 0.   1.   6.  11. ]]

In [124]:

# Phase 4 : 1행에 2행을 3배 하여 더해준다.

A_1 = An[0] + 3 * An[1]
A_2 = An[1]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   0.  -6.  -9. ]
 [ 0.  -0.5 -2.5 -4.5]
 [ 0.   1.   6.  11. ]]

In [125]:

# Phase 5 : 2행을 두배하여 3행에 더해준다.

A_1 = An[0]
A_2 = An[1]
A_3 = An[2] + 2 * An[1]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   0.  -6.  -9. ]
 [ 0.  -0.5 -2.5 -4.5]
 [ 0.   0.   1.   2. ]]

In [126]:

# Phase 6 : 2행에 -2를 곱한다.

A_1 = An[0]
A_2 = An[1] * (-2)
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.  0. -6. -9.]
 [ 0.  1.  5.  9.]
 [ 0.  0.  1.  2.]]

In [127]:

# Phase 7 : 3행을 6배하여 1행에 더해준다.

A_1 = An[0] + 6*An[2]
A_2 = An[1] 
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[1. 0. 0. 3.]
 [0. 1. 5. 9.]
 [0. 0. 1. 2.]]

In [128]:

# Phase 8 : 3행을 5배하여 2행에서 빼준다.

A_1 = An[0] 
A_2 = An[1] - 5*An[2]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.  0.  0.  3.]
 [ 0.  1.  0. -1.]
 [ 0.  0.  1.  2.]]

 

행렬A는 3X3 단위행렬이 되었고, 이 때, 상수부는 [3,-1,2]이다. 이는 각각의 미지수 X1,X2,X3의 값과 같다.¶

 

(2) 가우스-요르단 소거법으로 역행렬 구하기¶

 

기본 원리는, AX = I가 되는 행렬 X를 구하는 것이다.¶

앞전 소거법에서는 상수항이 1차원의 벡터였지만, 이를 다차원의 단위행렬로 확장한다.¶

In [129]:

A = np.matrix([[2,3,3],[3,4,2],[-2,-2,3]]) #행렬 A
n = np.identity(3) #방정식의 상수 벡터

An = np.hstack([A,n.T])
print(An)

 

[[ 2.  3.  3.  1.  0.  0.]
 [ 3.  4.  2.  0.  1.  0.]
 [-2. -2.  3.  0.  0.  1.]]

 

변형의 조건은 다음과 같다.¶

• 어느 행에 c배를 한다.
• 위에서 c배한 행으로 다른 행을 더하거나 뺀다.
• 행렬이 단위행렬이 되면 연산을 종료한다.

In [130]:

# phase 1 : 1행을 1/2배 한다.

A_1 = (1/2) * An[0]
A_2 = An[1]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  0.5  0.   0. ]
 [ 3.   4.   2.   0.   1.   0. ]
 [-2.  -2.   3.   0.   0.   1. ]]

In [131]:

# phase 2 : 1행을 3배하여 2행을 뺀다.

A_1 = An[0]
A_2 = An[1] - 3 * An[0]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  0.5  0.   0. ]
 [ 0.  -0.5 -2.5 -1.5  1.   0. ]
 [-2.  -2.   3.   0.   0.   1. ]]

In [132]:

# Phase 3 : 1행을 두배하여 3행에 더해준다.

A_1 = An[0]
A_2 = An[1]
A_3 = An[2] + 2 * An[0]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   1.5  1.5  0.5  0.   0. ]
 [ 0.  -0.5 -2.5 -1.5  1.   0. ]
 [ 0.   1.   6.   1.   0.   1. ]]

In [133]:

# Phase 4 : 1행에 2행을 3배 하여 더해준다.

A_1 = An[0] + 3 * An[1]
A_2 = An[1]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   0.  -6.  -4.   3.   0. ]
 [ 0.  -0.5 -2.5 -1.5  1.   0. ]
 [ 0.   1.   6.   1.   0.   1. ]]

In [134]:

# Phase 5 : 2행을 두배하여 3행에 더해준다.

A_1 = An[0]
A_2 = An[1]
A_3 = An[2] + 2 * An[1]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.   0.  -6.  -4.   3.   0. ]
 [ 0.  -0.5 -2.5 -1.5  1.   0. ]
 [ 0.   0.   1.  -2.   2.   1. ]]

In [135]:

# Phase 6 : 2행에 -2를 곱한다.

A_1 = An[0]
A_2 = An[1] * (-2)
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[ 1.  0. -6. -4.  3.  0.]
 [ 0.  1.  5.  3. -2.  0.]
 [ 0.  0.  1. -2.  2.  1.]]

In [136]:

# Phase 7 : 3행을 6배하여 1행에 더해준다.

A_1 = An[0] + 6*An[2]
A_2 = An[1] 
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[  1.   0.   0. -16.  15.   6.]
 [  0.   1.   5.   3.  -2.   0.]
 [  0.   0.   1.  -2.   2.   1.]]

In [137]:

# Phase 8 : 3행을 5배하여 2행에서 빼준다.

A_1 = An[0] 
A_2 = An[1] - 5*An[2]
A_3 = An[2]
An = np.vstack([A_1,A_2,A_3])
print(An)

 

[[  1.   0.   0. -16.  15.   6.]
 [  0.   1.   0.  13. -12.  -5.]
 [  0.   0.   1.  -2.   2.   1.]]

 

A행렬 부분은 단위행렬로 변했고, I 행렬 부분은 어떤 다른 행렬로 바뀌었다.¶

이 때, I 행렬 부분이 바로 A행렬의 역행렬이다.¶

In [143]:

print("A행렬의 역행렬")
print("")
print(An.T[3:6].T)

 

A행렬의 역행렬

[[-16.  15.   6.]
 [ 13. -12.  -5.]
 [ -2.   2.   1.]]