Systèmes d'équations non linéaires

Objectifs d'apprentissage

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

• Comprendre pourquoi on rencontre des systèmes non linéaires et leurs particularités
• Appliquer la méthode du point fixe à plusieurs variables
• Maîtriser la méthode de Newton multivariable
• Calculer et interpréter la matrice jacobienne
• Choisir une bonne estimation initiale et comprendre son importance

Prérequis

• Méthode de Newton pour une équation (Chapitre 2)
• Systèmes linéaires et factorisation LU (ce chapitre)
• Notion de dérivées partielles

Pourquoi des systèmes non linéaires ?

Le monde réel est rarement linéaire

Jusqu'ici, nous avons résolu des systèmes linéaires $Ax = b$. Mais dans de nombreuses applications, les équations ne sont pas linéaires :

Exemple 1 : Cinématique d'un robot

Un bras robotique à 2 articulations doit atteindre un point $(x, y)$ dans l'espace. Si les bras ont des longueurs $L_1$ et $L_2$, les angles $\theta_1$ et $\theta_2$ doivent satisfaire :

Ce sont des équations non linéaires en $\theta_1, \theta_2$ à cause des fonctions trigonométriques.

Exemple 2 : Équilibre chimique

Les concentrations à l'équilibre d'une réaction chimique satisfont des relations impliquant des produits de concentrations (loi d'action de masse).

Exemple 3 : Intersection de courbes

Trouver où un cercle intersecte une hyperbole :

Formulation générale

Un système de n équations non linéaires à n inconnues s'écrit :

où :

• $x = (x_1, x_2, \ldots, x_n)^T \in \mathbb{R}^n$ est le vecteur des inconnues
• $F : \mathbb{R}^n \to \mathbb{R}^n$ est une fonction vectorielle
• $F(x) = (f_1(x), f_2(x), \ldots, f_n(x))^T$

Chaque $f_i$ peut dépendre de toutes les variables $x_1, \ldots, x_n$ de manière non linéaire.

Différences fondamentales avec le cas linéaire

Illustration géométrique

Notre exemple $x^2 + y^2 = 4$ et $xy = 1$ a 4 solutions (les 4 points d'intersection du cercle et de l'hyperbole). Selon le point de départ, Newton convergera vers l'une ou l'autre.

La matrice jacobienne : généralisation de la dérivée

Rappel : Newton en 1D

Pour résoudre $f(x) = 0$ en une variable, Newton utilise la dérivée $f'(x)$ :

Qu'est-ce qui joue le rôle de $f'$ pour un système à plusieurs variables ?

La jacobienne : la "dérivée" d'une fonction vectorielle

Exemple concret

Pour notre système cercle-hyperbole :

La jacobienne est :

Au point $(1.5, 0.5)$ :

Interprétation géométrique

La jacobienne donne la meilleure approximation linéaire de $F$ autour d'un point :

C'est l'analogue multidimensionnel de $f(x + h) \approx f(x) + f'(x) h$.

Méthode de Newton multivariable

Principe : linéariser et résoudre

L'idée de Newton est simple : remplacer le problème non linéaire par une suite de problèmes linéaires.

À chaque itération :

1. Linéariser $F$ autour de $x^{(k)}$ : $F(x) \approx F(x^{(k)}) + J(x^{(k)})(x - x^{(k)})$
2. Résoudre l'équation linéarisée $F(x^{(k)}) + J(x^{(k)})(x - x^{(k)}) = 0$
3. Itérer avec la solution comme nouveau point

Formule de Newton

En posant $\Delta x = x^{(k+1)} - x^{(k)}$, on obtient le système linéaire :

puis :

Exemple pas à pas

Résolvons $x^2 + y^2 = 4$ et $xy = 1$ en partant de $(x^{(0)}, y^{(0)}) = (1.5, 0.5)$.

Itération 1 :

1. Évaluer $F$ :

2. Calculer la jacobienne :

3. Résoudre $J \cdot \Delta x = -F$ :

Par élimination de Gauss (ou substitution) : $\Delta x = 0.5$, $\Delta y = 0$

4. Mettre à jour :

Itération 2 :

Le résidu a déjà été divisé par six. Après quelques itérations supplémentaires, on converge vers $(1.9319, 0.5176)$.

Vérification : $1.9319^2 + 0.5176^2 = 4.000$ ✓ et $1.9319 \times 0.5176 = 1.000$ ✓

Visualisation interactive

Convergence de Newton

Théorème de convergence locale

Interprétation de la convergence quadratique

Quadratique signifie que le nombre de chiffres corrects double à chaque itération :

En 4-5 itérations, on atteint souvent la précision maximale possible.

Quand Newton échoue

La méthode peut échouer si :

1. Jacobienne singulière : $\det(J(x^{(k)})) = 0$ → division par zéro
2. Point de départ trop loin : on peut diverger ou osciller
3. Pas de solution : $F(x) = 0$ n'a pas de solution

Choix de l'estimation initiale

Le succès de Newton dépend fortement du point de départ $x^{(0)}$.

Stratégies pratiques

Exemple : trouver les 4 solutions

Pour notre système cercle-hyperbole, la contrainte $xy = 1 > 0$ impose que $x$ et $y$ soient de même signe : les 4 solutions se répartissent deux par deux dans les quadrants 1 et 3. En partant d'un point proche de chacune, on peut les trouver toutes :

Approximation numérique de la jacobienne

Quand les dérivées analytiques sont difficiles

Parfois, calculer les dérivées partielles analytiquement est :

• Fastidieux (formules complexes)
• Impossible (fonction définie par du code, pas une formule)

On peut alors approximer la jacobienne par différences finies.

Formule par différences finies

où $e_j = (0, \ldots, 0, 1, 0, \ldots, 0)^T$ est le j-ème vecteur de base.

Choix de h : typiquement $h \approx \sqrt{\varepsilon_{\text{machine}}} \approx 10^{-8}$ en double précision.

Coût computationnel

Pour une jacobienne $n \times n$ :

• Analytique : une évaluation de J
• Numérique : $n + 1$ évaluations de F (une pour F(x), une pour chaque colonne)

Pour de grands systèmes, l'approximation numérique peut être coûteuse !

Méthode du point fixe (alternative)

Principe

Comme pour une équation scalaire, on peut reformuler $F(x) = 0$ en :

et itérer $x^{(k+1)} = G(x^{(k)})$.

Exemple

Pour $x^2 + y^2 = 4$ et $xy = 1$, une reformulation :

Condition de convergence

Comparaison avec Newton

En pratique, Newton est généralement préféré pour sa convergence rapide.

Résumé

Points clés à retenir :

1. Systèmes non linéaires : peuvent avoir plusieurs solutions, pas de méthode directe
2. Jacobienne : matrice des dérivées partielles, généralise la dérivée
3. Newton : convergence quadratique, résout un système linéaire à chaque itération
4. Estimation initiale : cruciale — détermine vers quelle solution on converge
5. Jacobienne numérique : alternative quand les dérivées analytiques sont indisponibles

Implémentations Python

Méthode de Newton avec jacobienne analytique

import numpy as np

def newton_systeme(F, jacobian, x0, max_iter=50, tol=1e-10):
  """
  Méthode de Newton pour système F(x) = 0.

  Paramètres:
  -----------
  F : fonction qui retourne le vecteur F(x)
  jacobian : fonction qui retourne la matrice J(x)
  x0 : estimation initiale
  max_iter : nombre maximum d'itérations
  tol : tolérance pour ||F(x)||

  Retourne:
  ---------
  x : solution approchée
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      f = F(x)

      # Test de convergence sur ||F(x)||
      if np.linalg.norm(f) < tol:
          print(f"Convergence en {k+1} itérations")
          return x

      # Calculer la jacobienne
      J = jacobian(x)

      # Résoudre le système linéaire J · Δx = -F
      delta_x = np.linalg.solve(J, -f)

      # Mise à jour : x = x + Δx
      x = x + delta_x

  print(f"Non convergé après {max_iter} itérations")
  return x

Jacobienne par différences finies

def jacobienne_numerique(F, x, h=1e-8):
  """
  Calcule la matrice jacobienne par différences finies.

  Coût : n+1 évaluations de F pour une jacobienne n×n.
  """
  n = len(x)
  f0 = F(x)
  J = np.zeros((n, n))

  for j in range(n):
      x_perturb = x.copy()
      x_perturb[j] += h
      J[:, j] = (F(x_perturb) - f0) / h

  return J

def newton_numerique(F, x0, max_iter=50, tol=1e-10):
  """
  Newton avec jacobienne calculée numériquement.
  Utile quand les dérivées analytiques sont indisponibles.
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      f = F(x)

      if np.linalg.norm(f) < tol:
          print(f"Convergence en {k+1} itérations")
          return x

      J = jacobienne_numerique(F, x)
      delta_x = np.linalg.solve(J, -f)
      x = x + delta_x

  print(f"Non convergé après {max_iter} itérations")
  return x

Méthode du point fixe

def point_fixe_systeme(G, x0, max_iter=100, tol=1e-8):
  """
  Méthode du point fixe pour système x = G(x).

  Converge si le rayon spectral de ∂G/∂x < 1
  près de la solution.
  """
  x = np.array(x0, dtype=float)

  for k in range(max_iter):
      x_new = G(x)

      if np.linalg.norm(x_new - x) < tol:
          print(f"Convergence en {k+1} itérations")
          return x_new

      x = x_new

  print(f"Non convergé après {max_iter} itérations")
  return x

Exemple complet : cercle et hyperbole

import numpy as np

# Système : x² + y² = 4 et xy = 1
def F(x):
  return np.array([
      x[0]**2 + x[1]**2 - 4,
      x[0] * x[1] - 1
  ])

def J(x):
  return np.array([
      [2*x[0], 2*x[1]],
      [x[1], x[0]]
  ])

# Trouver les 4 solutions avec différents points de départ
print("=== Recherche des 4 solutions ===\n")

points_depart = [
  [1.5, 0.5],    # Quadrant 1
  [-1.5, -0.5],  # Quadrant 3
  [0.5, 1.5],    # Quadrant 1 (autre solution)
  [-0.5, -1.5]   # Quadrant 3 (autre solution)
]

for x0 in points_depart:
  sol = newton_systeme(F, J, x0)
  print(f"  Point de départ : {x0}")
  print(f"  Solution trouvée : ({sol[0]:.6f}, {sol[1]:.6f})")
  print(f"  Vérification : x² + y² = {sol[0]**2 + sol[1]**2:.6f}, xy = {sol[0]*sol[1]:.6f}")
  print()

Fin du chapitre

Ce chapitre a couvert les méthodes de résolution des systèmes d'équations linéaires et non linéaires. Les concepts clés sont :

1. Méthodes directes : Gauss, LU, pivotage — solution exacte en temps fini
2. Analyse : rang, déterminant, conditionnement — comprendre le système
3. Méthodes itératives : Jacobi, Gauss-Seidel, SOR — grands systèmes creux
4. Systèmes non linéaires : Newton multivariable — convergence quadratique locale

Ces outils sont fondamentaux pour de nombreuses applications en sciences, ingénierie, et informatique.