Inversion de matrices

Objectifs d'apprentissage

À la fin de cette leçon, vous serez en mesure de :

Calculer l'inverse d'une matrice par la méthode de Gauss-Jordan
Utiliser la factorisation LU pour calculer l'inverse
Savoir quand utiliser l'inversion de matrice (et quand l'éviter)
Comprendre les propriétés de l'inverse

Prérequis

Factorisation LU
Rang et singularité

Définition de l'inverse

Définition

Pour une matrice carrée $A$ de taille $n \times n$ , l'inverse $A^{-1}$ est la matrice telle que :

A \cdot A^{-1} = A^{-1} \cdot A = I

où $I$ est la matrice identité.

🚨

Existence de l'inverse

L'inverse $A^{-1}$ existe si et seulement si $A$ est non singulière, c'est-à-dire $\det(A) \neq 0$ .

Interprétation géométrique

Une matrice $A$ peut être vue comme une transformation géométrique : elle déforme, étire ou fait pivoter des formes dans l'espace. L'inverse $A^{-1}$ est la transformation qui annule cet effet et ramène la forme à son état original.

La visualisation ci-dessous illustre ce concept avec un carré unité :

Le carré original (bleu) a des sommets en $(0,0), (1,0), (1,1), (0,1)$
La matrice $A$ transforme ce carré en parallélogramme (rouge)
Appliquer $A^{-1}$ au parallélogramme redonne exactement le carré original

Propriétés de l'inverse

Propriété	Formule
Inverse de l'inverse	$(A^{-1})^{-1} = A$
Inverse d'un produit	$(A \cdot B)^{-1} = B^{-1} \cdot A^{-1}$
Inverse de la transposée	$(A^T)^{-1} = (A^{-1})^T$
Inverse d'un scalaire	$(\lambda A)^{-1} = \frac{1}{\lambda} A^{-1}$

Formule pour les matrices 2×2

\begin{pmatrix} a & b \\ c & d \end{pmatrix}^{-1} = \frac{1}{ad-bc} \begin{pmatrix} d & -b \\ -c & a \end{pmatrix}

Calcul par Gauss-Jordan

Principe

On forme la matrice augmentée $[A | I]$ et on la transforme en $[I | A^{-1}]$ par opérations élémentaires.

Algorithme

inverse_gauss_jordan.pypython

import numpy as np

def inverse_gauss_jordan(A):
  """
  Calcule l'inverse de A par la méthode de Gauss-Jordan.
  """
  n = len(A)
  # Matrice augmentée [A | I]
  Aug = np.column_stack([A.astype(float), np.eye(n)])

  for k in range(n):
      # Pivotage partiel
      max_idx = k + np.argmax(np.abs(Aug[k:, k]))
      if abs(Aug[max_idx, k]) < 1e-12:
          raise ValueError("Matrice singulière")
      Aug[[k, max_idx]] = Aug[[max_idx, k]]

      # Normaliser la ligne pivot
      Aug[k] = Aug[k] / Aug[k, k]

      # Éliminer dans toutes les autres lignes
      for i in range(n):
          if i != k:
              Aug[i] -= Aug[i, k] * Aug[k]

  # Extraire l'inverse (partie droite)
  return Aug[:, n:]

# Exemple
A = np.array([[2, 1, 1],
            [4, 3, 3],
            [8, 7, 9]], dtype=float)

A_inv = inverse_gauss_jordan(A)
print("A^(-1) =")
print(A_inv)
print("\nVérification A · A^(-1) =")
print(A @ A_inv)

Calcul par factorisation LU

Principe

Si $A = L \cdot U$ , alors :

A^{-1} = U^{-1} \cdot L^{-1}

En pratique, on résout $n$ systèmes $A \cdot x_j = e_j$ où $e_j$ est le $j$ -ème vecteur de base. Chaque solution $x_j$ est la $j$ -ème colonne de $A^{-1}$ .

inverse_lu.pypython

import numpy as np

def inverse_lu(A):
  """
  Calcule l'inverse de A en utilisant la factorisation LU.
  """
  n = len(A)

  # Factorisation LU avec pivotage
  LU = A.astype(float).copy()
  perm = list(range(n))

  for k in range(n - 1):
      max_idx = k + np.argmax(np.abs(LU[k:, k]))
      if max_idx != k:
          LU[[k, max_idx]] = LU[[max_idx, k]]
          perm[k], perm[max_idx] = perm[max_idx], perm[k]

      for i in range(k + 1, n):
          LU[i, k] /= LU[k, k]
          LU[i, k+1:] -= LU[i, k] * LU[k, k+1:]

  # Résoudre A * x_j = e_j pour chaque j
  A_inv = np.zeros((n, n))
  for j in range(n):
      # Vecteur e_j
      e_j = np.zeros(n)
      e_j[j] = 1.0

      # Appliquer la permutation
      b = np.array([e_j[perm[i]] for i in range(n)])

      # Substitution avant (Ly = b)
      for i in range(1, n):
          b[i] -= np.dot(LU[i, :i], b[:i])

      # Substitution arrière (Ux = y)
      for i in range(n - 1, -1, -1):
          b[i] = (b[i] - np.dot(LU[i, i+1:], b[i+1:])) / LU[i, i]

      A_inv[:, j] = b

  return A_inv

Résolution par l'inverse : quand l'utiliser ?

Méthode

Pour résoudre $A \cdot x = b$ , on pourrait calculer :

x = A^{-1} \cdot b

Comparaison des coûts

Méthode	1 système	k systèmes
LU + résolution	$n^3/3 + n^2$	$n^3/3 + k \cdot n^2$
Inverse + multiplication	$2n^3 + n^2$	$2n^3 + k \cdot n^2$

⚠️

Recommandation

N'utilisez pas l'inversion de matrice pour résoudre des systèmes linéaires !

La méthode LU est :

6× plus rapide pour un seul système
Plus stable numériquement
Suffisante même pour plusieurs seconds membres

Quand calculer l'inverse ?

Besoin explicite de $A^{-1}$ (rare)
Très nombreux systèmes (des centaines)
Analyse théorique
Matrices spéciales (orthogonales, etc.)

Exemple : matrice 3×3

Calculons l'inverse de :

A = \begin{pmatrix} 1 & 2 & 1 \\ 2 & 5 & 3 \\ 1 & 3 & 3 \end{pmatrix}

Par Gauss-Jordan :

\begin{pmatrix} 1 & 2 & 1 & | & 1 & 0 & 0 \\ 2 & 5 & 3 & | & 0 & 1 & 0 \\ 1 & 3 & 3 & | & 0 & 0 & 1 \end{pmatrix}

Après transformations :

A^{-1} = \begin{pmatrix} 6 & -3 & 1 \\ -3 & 2 & -1 \\ 1 & -1 & 1 \end{pmatrix}

Vérification :

A \cdot A^{-1} = \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} = I \quad \checkmark

Résumé

L'inverse d'une matrice $A$ satisfait $A \cdot A^{-1} = I$ et existe ssi $\det(A) \neq 0$ .

Méthodes de calcul :

Gauss-Jordan : transformer $[A|I]$ en $[I|A^{-1}]$
Factorisation LU : résoudre $n$ systèmes avec les vecteurs de base

Règle d'or : Pour résoudre $A \cdot x = b$ , utilisez LU, pas l'inverse !

Situation	Méthode recommandée
Résoudre $Ax = b$	Factorisation LU
Besoin de $A^{-1}$ explicitement	Gauss-Jordan ou LU
Matrice 2×2	Formule directe

Pour aller plus loin

La prochaine leçon introduira les normes vectorielles et matricielles, des outils essentiels pour mesurer les erreurs et analyser la stabilité des algorithmes.