CAMA : ma04 Vectors propres

Cours du 30 / 03

Soit A une matrice qui représente une application linéaire quelconque. Que se passe-t-il si on l'applique

$n$ fois ?

array([[ 0.707,  0.966,  0.966,  0.707,  0.259, -0.259, -0.707, -1.061, -1.414, -1.061, -0.707, -0.   ,  0.707],
       [-0.707, -0.259,  0.259,  0.707,  0.966,  0.966,  0.707,  0.354,  0.   , -0.354, -0.707, -0.707, -0.707]])

# on prend une matrice de transformation au hasard (donc probablement pas orthoganale)
A = np.array([[3,2], [1,2]])

as1 = np.dot(A, mouse)
as2 = 3 * A @ mouse # souris 3 fois plus grande

La transformation n'est pas une isométrie donc la matrice n'est pas orthogonale.

La souris 3x plus grande est isométrique car

$A$ est une application linéaire.

aas1 = A @ A @ mouse
aaas1 = A @ A @ A @ mouse

La figure s'étire suivant le vecteur

$(2,1)$

Si

$A\mathbf{x}$ fait tourner la souris d'environ 25°, appliquer 2 ou 3 fois

$A$ ne fait plus tourner la figure.

Vecteurs propres et valeurs propres

Les valeurs et vecteurs propres respectent cette priopriété :

$$A{\mathbf{v}}_{\mathbf{i}}={\lambda }_i{\mathbf{v}}_{\mathbf{i}}$$

• $({\lambda }_i,{\mathbf{v}}_{\mathbf{i}})$ : couple valeur / vecteur propres

val_propre, vec_propre = lin.eig(A)

Valeurs propres de A : [4.+0.j 1.+0.j] 

Vecteurs propres de A (chaque vecteur propre est écrit verticalement):
 [[ 0.894 -0.707]
 [ 0.447  0.707]]

Les vecteurs propres sont des attracteurs qui capturent tous les points si on fait un nombre infini de multiplications par

$A$.
Les points s'alignent sur l'un des deux vecteurs propres.

N = 100
cercle = np.array([[np.cos(i * 2*np.pi/N), np.sin(i * 2*np.pi/N)] for i in range(N)]).T
a10c = np.array([x for x in (A10 @ cercle).T]).T
a10cn = np.array([x/lin.norm(x) for x in a10c.T]).T  # a10c normé
nb1 = np.sum([lin.norm(a10cn[:,i] - vec_propre[:,0]) < 0.01 for i in range(N)])   \
      + np.sum([lin.norm(a10cn[:,i] + vec_propre[:,0]) < 0.01 for i in range(N)])
nb2 = np.sum([lin.norm(a10cn[:,i] - vec_propre[:,1]) < 0.01 for i in range(N)])   \
      + np.sum([lin.norm(a10cn[:,i] + vec_propre[:,1]) < 0.01 for i in range(N)])

Nombre de points proche du 1er vecteur propre :  100
Nombre de points proche du 2e  vecteur propre :  0

Seuls les points colinéaires au second vecteur propre le resteront, les autres rejoignent le premier vecteur propre.

Le cas des matrices de rotation

Quels sont les vecteurs propres d'une matrice de rotation ?

def Rot(θ):
    return np.array([[np.cos(θ), -np.sin(θ)], [np.sin(θ), np.cos(θ)]])

R = Rot(2*np.pi/10)

R_valp, R_vecp = lin.eig(R)

Valeurs propres de R : [0.809+0.588j 0.809-0.588j] 

Vecteurs propres de R :
 [[0.707+0.j    0.707-0.j   ]
 [0.   -0.707j 0.   +0.707j]]

# regardons un autre angle
R = Rot(2*np.pi/3)

R_valp, R_vecp = lin.eig(R)

Valeurs propres de R : [-0.5+0.866j -0.5-0.866j] 

Vecteurs propres de R :
 [[ 0.-0.707j  0.+0.707j]
 [-0.707+0.j    -0.707-0.j]]

• Les valeurs et vecteurs propres sont des complexes
• Les valeurs propres ont la même norme

Symétrie axiale horizontale

$$Sx=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right]$$

Sx = np.array([[1, 0], [0, -1]])

Sx_valp, Sx_vecp = lin.eig(Sx)

Valeurs propres de Sx : [ 1.+0.j -1.+0.j] 

Vecteurs propres de Sx :
 [[1. 0.]
 [0. 1.]]

• Une matrice diagonale modifie que la i-ième coordonnéee de
  $\mathbf{x}$ par la i-ième valeur de sa diagonale.
• Ses vecteurs propres sont ceux de la base d'origine :

D = np.diag(np.random.randint(10,size=5))
D_valp, D_vecp = lin.eig(D)

Valeurs propres de D : [8.+0.j 8.+0.j 4.+0.j 7.+0.j 1.+0.j] 

Vecteurs propres de D :
 [[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

Diagonalisation d'une matrice

En changeant de repère, on peut représenter une application linéaire par une matrice diagonale contenant ses valeurs propres.

$$\mathrm{\exists }P/A=P\mathrm{\Lambda }{P}^{-1}$$

• avec
  $\mathrm{\Lambda }$ la matrice diagonale des valeurs propres
  ${\lambda }_i$
• P matrice de passage : vecteurs propres

A
vec_propre @ np.diag(val_propre) @ lin.inv(vec_propre)

A :
 [[3 2]
 [1 2]] 

𝑃 Λ inv(𝑃) :
 [[3.+0.j 2.+0.j]
 [1.+0.j 2.+0.j]

• Matrice inversible : si une des valeurs propre est nulle alors
  $\mathrm{\Lambda }$ n'est pas inversible et donc A n'est pas inversible
• Matrice non diagonalisable : si l'ensemble des vecteurs propres ne genere pas un espace de meme dimension que d'origine, alors on ne peut pas diagonaliser la matrice