Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Le calcul des variations est une branche des mathématiques qui généralise le calcul différentiel à des espaces de fonctions. Au lieu de trouver un scalaire $x$ qui minimise $f(x)$, on cherche une fonction $y(x)$ qui minimise une fonctionnelle $J[y]$. Cette discipline est au cœur de nombreux problèmes d'IA et de robotique :
Optimisation de trajectoires : trouver le chemin optimal d'un bras robotique ou d'un drone avec contraintes énergétiques.
Apprentissage par renforcement : les équations de Hamilton-Jacobi-Bellman sont issues du calcul variationnel.
Régularisation de modèles : les pénalités de lissage (Sobolev, TV) sont des fonctionnelles.
Contrôle optimal : minimiser une fonction de coût sur un horizon temporel.
Systèmes multi-agents : coordination et formation optimale de groupes d'agents.
Cette compétence fournit les fondements théoriques, les implémentations numériques et les patrons de résolution pour appliquer le calcul variationnel dans des contextes d'IA.
Quand l'utiliser
Situation
Exemple
Optimiser une trajectoire sous contrainte
Chemin d'un drone avec budget énergétique limité
Résoudre un problème de contrôle optimal
Commande d'un bras robotique avec coût quadratique
Régulariser un modèle d'apprentissage
Contrainte de lissage sur une fonction de potentiel
Planifier un mouvement multi-agents
Formation optimale d'un essaim de robots
Résoudre un problème isopérimétrique
Maximiser l'aire sous une contrainte de périmètre
1. Fondements Théoriques
1.1 Fonctionnelle et Première Variation
Une fonctionnelle est une application d'un espace de fonctions vers $\mathbb{R}$ :
$$
J[y] = \int_a^b L(x, y(x), y'(x)) , dx
$$
La première variation $\delta J[y, \eta]$ généralise la dérivée directionnelle :
Comme $\eta$ est arbitraire (sauf aux bornes où $\eta(a) = \eta(b) = 0$ pour des conditions fixes), le terme intégral doit être nul, d'où Euler-Lagrange.
1.3 Contraintes Isopérimétriques
Une contrainte de la forme :
$$
\int_a^b G(x, y, y') , dx = C
$$
est traitée avec un multiplicateur de Lagrange $\lambda$ :
$$
\tilde{J}[y] = \int_a^b \big( L(x, y, y') + \lambda G(x, y, y') \big) , dx
$$
Minimiser l'aire de révolution engendrée par une courbe $y(x)$ entre deux points, avec une longueur d'arc fixée $L$ :
$$
J[y] = 2\pi \int_a^b y \sqrt{1 + y'^2} , dx, \quad
\int_a^b \sqrt{1 + y'^2} , dx = L
La solution est une **caténaire** $y(x) = c \cosh((x - x_0)/c)$.
### 2.4 Contrôle Optimal Linéaire-Quadratique (LQR)
Pour un système dynamique $\dot{x} = Ax + Bu$ avec coût :
\[
J = \int_0^T (x^T Q x + u^T R u) \, dt + x(T)^T S x(T)
$$
L'équation d'Euler-Lagrange sur le Hamiltonien $H = x^T Q x + u^T R u + p^T(Ax + Bu)$ donne :
$$
\dot{p} = -\frac{\partial H}{\partial x} = -2Qx - A^T p, \quad
\frac{\partial H}{\partial u} = 2Ru + B^T p = 0
$$
Soit la loi de commande optimale $u^* = -\frac{1}{2}R^{-1}B^T p$.
---
## 3. Implémentation Numérique
### 3.1 Discrétisation par Différences Finies
La méthode la plus simple consiste à discrétiser la fonction $y(x)$ sur une grille et à utiliser `scipy.optimize` :
```python
import numpy as np
from scipy.optimize import minimize
from scipy.integrate import quad
def solve_covariation(L_func, a, b, n=100, constraints=None):
"""Résout un problème variationnel par discrétisation.
Args:
L_func: Fonction L(x, y, dy) représentant le lagrangien.
a, b: Bornes de l'intervalle.
n: Nombre de points de discrétisation.
constraints: Liste de contraintes isopérimétriques optionnelles.
Returns:
tuple: (x_grille, y_optimale)
"""
x = np.linspace(a, b, n)
dx = x[1] - x[0]
def objective(y):
dy = np.gradient(y, dx)
integrand = np.array([L_func(x[i], y[i], dy[i]) for i in range(n)])
return np.trapz(integrand, x)
# Conditions aux limites fixes
bounds = [(None, None)] * n
# Contrainte isopérimétrique optionnelle
cons = []
if constraints is not None:
for G_func, C_val in constraints:
def constraint(y, G=G_func, C=C_val):
dy = np.gradient(y, dx)
vals = np.array([G(x[i], y[i], dy[i]) for i in range(n)])
return np.trapz(vals, x) - C
cons.append({'type': 'eq', 'fun': constraint})
y0 = np.ones(n) # Devine initiale
result = minimize(objective, y0, method='SLSQP',
bounds=bounds, constraints=cons,
options={'maxiter': 1000, 'ftol': 1e-8})
return x, result.x
# Exemple : minimiser J = ∫(½y'² - f(x)y)dx sous contrainte ∫y'²dx = C
def lagrangian(x, y, dy):
f = np.cos(x)
return 0.5 * dy**2 - f * y
x_opt, y_opt = solve_covariation(
lagrangian, 0, 10, n=100,
constraints=[(lambda x, y, dy: dy**2, 1.0)]
)
print(f"Solution optimale : {y_opt[:5]}...")
3.2 Méthode de Tir (Shooting) pour Conditions aux Limites
Pour les problèmes avec conditions aux limites aux deux extrémités :
from scipy.integrate import solve_ivp
from scipy.optimize import fsolve
defshooting_method(euler_lagrange_ode, a, b, ya, yb, guess, n=100):
"""Méthode de tir pour résoudre l'équation d'Euler-Lagrange.
Args:
euler_lagrange_ode: Fonction f(x, y, y') pour l'ODE du second ordre.
a, b: Bornes.
ya, yb: Valeurs aux limites.
guess: Estimation initiale de y'(a).
n: Nombre de points.
Returns:
tuple: (x, y)
"""defode_system(x, state):
y, dy = state
ddy = euler_lagrange_ode(x, y, dy)
return [dy, ddy]
defboundary_residual(dy_a):
sol = solve_ivp(ode_system, (a, b), [ya, dy_a[0]],
t_eval=np.linspace(a, b, n))
return [sol.y[0, -1] - yb]
dy_a_opt = fsolve(boundary_residual, [guess])
sol = solve_ivp(ode_system, (a, b), [ya, dy_a_opt[0]],
t_eval=np.linspace(a, b, n))
return sol.t, sol.y[0]
3.3 Méthode Symbolique avec SymPy
Pour les cas où une solution analytique est accessible :
import sympy as sp
defeuler_lagrange_symbolic(L_expr, y_sym, x_sym):
"""Calcule l'équation d'Euler-Lagrange de manière symbolique.
Args:
L_expr: Expression sympy du lagrangien L(x, y, y').
y_sym: Fonction symbole y(x).
x_sym: Variable indépendante x.
Returns:
Expression sympy de l'équation d'Euler-Lagrange.
"""
yp = sp.diff(y_sym, x_sym)
dL_dy = sp.diff(L_expr, y_sym)
dL_dyp = sp.diff(L_expr, yp)
euler_eq = sp.simplify(dL_dy - sp.diff(dL_dyp, x_sym))
return sp.Eq(euler_eq, 0)
# Exemple : brachistochrone
x = sp.symbols('x')
y = sp.Function('y')
g = sp.symbols('g', positive=True)
L = sp.sqrt((1 + sp.diff(y(x), x)**2) / (2 * g * y(x)))
eq = euler_lagrange_symbolic(L, y(x), x)
sp.pprint(eq)
3.4 Optimisation de Trajectoire avec Contrôle Optimal Direct
Pour des problèmes de robotique avec commande $u(t)$ :
import numpy as np
from scipy.optimize import minimize
deftrajectory_optimization(dynamics, cost_func, x0, xf, T, n_steps=50):
"""Optimise une trajectoire avec commande.
Args:
dynamics: Fonction f(x, u) → dx/dt.
cost_func: Fonction de coût instantané L(x, u).
x0, xf: États initial et final.
T: Horizon temporel.
n_steps: Nombre de pas de temps.
Returns:
tuple: (temps, états optimaux, commandes optimales)
"""
dt = T / n_steps
n_states = len(x0)
n_controls = 2# Exemple : acceleration angulaire, forcedefobjective(z):
states = z[:n_states * n_steps].reshape(n_steps, n_states)
controls = z[n_states * n_steps:].reshape(n_steps, n_controls)
# Coût terminal (atteindre xf)
terminal_cost = 1000 * np.sum((states[-1] - xf)**2)
# Coût instantané
running_cost = sum(
cost_func(states[i], controls[i]) * dt
for i inrange(n_steps)
)
return terminal_cost + running_cost
defconstraint(z):
states = z[:n_states * n_steps].reshape(n_steps, n_states)
controls = z[n_states * n_steps:].reshape(n_steps, n_controls)
# Dynamique : x_{k+1} = x_k + f(x_k, u_k) * dt
cons = []
for i inrange(1, n_steps):
dx = dynamics(states[i-1], controls[i-1])
cons.extend(states[i] - states[i-1] - dx * dt)
return np.array(cons)
# Devine initiale : interpolation linéaire
guess_states = np.linspace(x0, xf, n_steps).flatten()
guess_controls = np.zeros(n_steps * n_controls)
z0 = np.concatenate([guess_states, guess_controls])
# Contrainte de dynamique
cons = [{'type': 'eq', 'fun': constraint,
'jac': '2-point'}]
result = minimize(objective, z0, method='SLSQP',
constraints=cons,
options={'maxiter': 5000, 'ftol': 1e-6})
t = np.linspace(0, T, n_steps)
states_opt = result.x[:n_states * n_steps].reshape(n_steps, n_states)
controls_opt = result.x[n_states * n_steps:].reshape(n_steps, n_controls)
return t, states_opt, controls_opt
4. Applications en IA et Robotique
4.1 Apprentissage par Renforcement et HJB
L'équation de Hamilton-Jacobi-Bellman en RL continu est une extension directe :
où $V$ est la fonction de valeur et $f$ la dynamique. La condition de minimum donne la loi de commande optimale, exactement comme la condition de stationnarité en calcul variationnel.
### 4.2 Régularisation par Variation Totale
En traitement d'images et en IA générative, la régularisation TV (Total Variation) s'écrit :
\[
J[u] = \int_\Omega |\nabla u| \, dx + \frac{\lambda}{2} \int_\Omega (u - f)^2 \, dx
$$
L'équation d'Euler-Lagrange correspondante donne le flot de diffusion :
$$
-\nabla \cdot \left( \frac{\nabla u}{|\nabla u|} \right) + \lambda (u - f) = 0
4.3 Systèmes Multi-Agents et Formation Optimale
Pour $N$ agents avec positions $p_i(t)$, la formation optimale minimise :
