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 de taille , l'inverse est la matrice telle que :

où est la matrice identité.

Interprétation géométrique

Une matrice peut être vue comme une transformation géométrique : elle déforme, étire ou fait pivoter des formes dans l'espace. L'inverse 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é :

1. Le carré original (bleu) a des sommets en
2. La matrice transforme ce carré en parallélogramme (rouge)
3. Appliquer au parallélogramme redonne exactement le carré original

Propriétés de l'inverse

Formule pour les matrices 2×2

Calcul par Gauss-Jordan

Principe

On forme la matrice augmentée et on la transforme en par opérations élémentaires.

Algorithme

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 , alors :

En pratique, on résout systèmes où est le -ème vecteur de base. Chaque solution est la -ème colonne de .

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 , on pourrait calculer :

Comparaison des coûts

Quand calculer l'inverse ?

• Besoin explicite de (rare)
• Très nombreux systèmes (des centaines)
• Analyse théorique
• Matrices spéciales (orthogonales, etc.)

Exemple : matrice 3×3

Calculons l'inverse de :

Par Gauss-Jordan :

Après transformations :

Vérification :

Résumé

L'inverse d'une matrice satisfait et existe ssi .

Méthodes de calcul :

• Gauss-Jordan : transformer en
• Factorisation LU : résoudre systèmes avec les vecteurs de base

Règle d'or : Pour résoudre , utilisez LU, pas l'inverse !

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.