Algorithms on kenji.blog

Algorithmes de graphes fréquents en programmation compétitive : Le guide complet

Sat, 12 Sep 2026 05:00:00 +0900

En programmation compétitive (CP), la théorie des graphes et ses algorithmes constituent l’un des thèmes les plus importants et incontournables. De nombreux problèmes posés lors de concours sur AtCoder, Codeforces ou TopCoder possèdent une structure de graphe en arrière-plan. Que ce soit pour trouver le chemin le plus court dans un réseau routier, minimiser les coûts de communication d’un réseau ou résoudre les dépendances entre tâches, ils constituent une arme puissante pour abstraire et résoudre des problèmes du monde réel.

Dans cet article, nous couvrirons de manière exhaustive les principaux algorithmes de graphes fréquemment rencontrés en programmation compétitive (tri topologique, algorithme de Dijkstra, algorithme de Bellman-Ford, algorithme de Floyd-Warshall, algorithme de Kruskal, algorithme de Prim et décomposition en composantes fortement connexes). Nous aborderons leur contexte théorique, l’évaluation de leur complexité à l’aide de formules mathématiques, ainsi que des exemples d’implémentation hautement optimisés en C++ moderne (C++17/20). Il s’agit d’un véritable guide “complet” que nous vous proposons.

1. Les bases et les contraintes des algorithmes de graphes

Avant d’étudier les algorithmes, il est important de comprendre les contraintes générales et les ordres de grandeur de la complexité temporelle pour les problèmes de graphes en programmation compétitive. Un graphe est représenté par son nombre de sommets $V$ (Vertices) et son nombre d’arêtes $E$ (Edges).

$O(V + E)$ : Complexité requise pour des problèmes où $V, E \le 10^5 \sim 10^6$. Cela correspond au parcours en profondeur (DFS) et au parcours en largeur (BFS).
$O((V + E) \log V)$ : Fréquent pour des problèmes où $V, E \le 10^5 \sim 2 \cdot 10^5$. C’est la complexité de l’algorithme de Dijkstra ou de Prim lorsqu’une file de priorité est utilisée.
$O(V^2)$ : Acceptable pour des graphes denses ($E \approx V^2$) où $V \le 2000 \sim 3000$.
$O(V^3)$ : Pour des problèmes où $V \le 400 \sim 500$. L’algorithme de Floyd-Warshall en est un exemple représentatif.

En programmation compétitive, il est courant d’utiliser une liste d’adjacence (Adjacency List) pour représenter un graphe. Comme la matrice d’adjacence consomme $O(V^2)$ en mémoire, elle entraînera un dépassement de la limite de mémoire (Memory Limit Exceeded) pour les problèmes comportant un grand nombre de sommets.

2. Exploration et ordonnancement des graphes

Tri topologique (Topological Sort)

Le tri topologique est un algorithme qui aligne les sommets d’un graphe orienté acyclique (DAG : Directed Acyclic Graph) de sorte que chaque arête orientée aille d’un sommet précédent vers un sommet suivant. Il est utilisé pour résoudre les dépendances entre les tâches (par exemple : la tâche B ne peut commencer que lorsque la tâche A est terminée) ou pour déterminer l’ordre de calcul de la programmation dynamique (DP) sur un DAG.

La complexité est de $O(V + E)$. Il existe deux implémentations : l’algorithme de Kahn (basé sur le parcours en largeur BFS en utilisant les degrés entrants) et celui basé sur le parcours en profondeur DFS avec post-ordre. Nous présenterons ici l’algorithme de Kahn, qui permet également de trouver facilement l’ordre topologique lexicographique minimal.

graph LR A["Tâche A"] --> B["Tâche B"] A["Tâche A"] --> C["Tâche C"] B["Tâche B"] --> D["Tâche D"] C["Tâche C"] --> D["Tâche D"] E["Tâche E"] --> C["Tâche C"]

Exemple d’implémentation en C++ (Algorithme de Kahn)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

// Fonction pour effectuer le tri topologique
// Renvoie un tableau vide si un cycle existe
vector<int> topological_sort(int V, const vector<vector<int>>& graph) {
 vector<int> in_degree(V, 0);
 // Calcul des degrés entrants
 for (int u = 0; u < V; ++u) {
 for (int v : graph[u]) {
 in_degree[v]++;
 }
 }

 // Ajout des sommets de degré entrant 0 à la file (utiliser priority_queue<int, vector<int>, greater<int>> pour un ordre lexicographique minimal)
 queue<int> q;
 for (int i = 0; i < V; ++i) {
 if (in_degree[i] == 0) {
 q.push(i);
 }
 }

 vector<int> res;
 while (!q.empty()) {
 int u = q.front();
 q.pop();
 res.push_back(u);

 // Décrémenter le degré entrant des sommets adjacents
 for (int v : graph[u]) {
 in_degree[v]--;
 if (in_degree[v] == 0) {
 q.push(v);
 }
 }
 }

 // Vérifier si le graphe contient un cycle
 if (res.size() != V) {
 return {}; // Cycle présent
 }
 return res;
}

3. Problème du plus court chemin à source unique (SSSP : Single Source Shortest Path)

Il s’agit du problème consistant à trouver le chemin le plus court depuis un sommet source vers tous les autres sommets. L’algorithme applicable diffère selon que les poids des arêtes sont tous positifs ou s’il existe des poids négatifs.

Algorithme de Dijkstra

L’algorithme de Dijkstra est un algorithme rapide de plus court chemin applicable lorsque tous les poids des arêtes sont non négatifs. Il est basé sur une approche gloutonne : « figer le sommet pour lequel la distance la plus courte est actuellement connue, et mettre à jour (relâcher) la distance vers les sommets adjacents à partir de ce sommet ».

Formule de relâchement (Relaxation)

Soit $s$ le sommet source, $d[u]$ la distance la plus courte jusqu’au sommet $u$, et $w(u, v)$ le poids de l’arête $(u, v)$. La formule de mise à jour est la suivante :

$$ d[v] = \min(d[v], d[u] + w(u, v)) $$

En utilisant une file de priorité (std::priority_queue), le sommet non visité avec la distance minimale peut être extrait en $O(\log V)$, donnant une complexité temporelle globale de $O((V + E) \log V)$. La complexité spatiale est de $O(V + E)$.

graph TD S["Source S(0)"] -- "2" --> A["Sommet A(2)"] S["Source S(0)"] -- "5" --> B["Sommet B(5)"] A["Sommet A(2)"] -- "1" --> B["Sommet B(3)"] A["Sommet A(2)"] -- "4" --> C["Sommet C(6)"] B["Sommet B(3)"] -- "1" --> C["Sommet C(4)"]

Comme illustré ci-dessus, le coût pour aller directement de S à B est de 5, mais en passant par A, on peut l’atteindre avec un coût de 3. L’algorithme de Dijkstra effectue cette optimisation.

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const long long INF = 1e18; // Valeur suffisamment grande

struct Edge {
 int to;
 long long weight;
};

// Algorithme de Dijkstra
// Renvoie un tableau des distances les plus courtes de la source s vers chaque sommet
vector<long long> dijkstra(int V, const vector<vector<Edge>>& graph, int s) {
 vector<long long> dist(V, INF);
 dist[s] = 0;

 // File de priorité pour gérer {distance, sommet} (dans l'ordre croissant des distances)
 using P = pair<long long, int>;
 priority_queue<P, vector<P>, greater<P>> pq;
 pq.push({0, s});

 while (!pq.empty()) {
 auto [d, u] = pq.top();
 pq.pop();

 // Ignorer si un chemin plus court a déjà été trouvé (suppression des informations obsolètes)
 if (dist[u] < d) continue;

 // Processus de relâchement
 for (const auto& edge : graph[u]) {
 int v = edge.to;
 long long cost = edge.weight;
 if (dist[v] > dist[u] + cost) {
 dist[v] = dist[u] + cost;
 pq.push({dist[v], v});
 }
 }
 }
 return dist;
}

L’instruction if (dist[u] < d) continue; est très importante. Dans l’algorithme de Dijkstra, le même sommet peut être inséré plusieurs fois dans la file, mais cette vérification permet d’élaguer les recherches inutiles.

Algorithme de Bellman-Ford

Si les poids des arêtes incluent des valeurs négatives, l’algorithme de Dijkstra ne peut pas déduire la bonne réponse. C’est là qu’intervient l’algorithme de Bellman-Ford. En répétant le processus de relâchement pour toutes les arêtes $V - 1$ fois, il calcule correctement le chemin le plus court même s’il y a des poids négatifs.

Si une mise à jour se produit lors de la $V$-ème itération, cela signifie qu’il existe un cycle négatif (Negative Cycle). En programmation compétitive, le problème “Détecter un cycle négatif” est très fréquent, et l’algorithme de Bellman-Ford est excellent pour cela.

La complexité temporelle est de $O(V \times E)$, ce qui est plus lent que l’algorithme de Dijkstra. Notez qu’il ne peut être appliqué que sous des contraintes telles que $V \le 2000, E \le 5000$.

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <iostream>
#include <vector>

using namespace std;

const long long INF = 1e18;

struct Edge {
 int from;
 int to;
 long long weight;
};

// Algorithme de Bellman-Ford
// Valeur de retour : {tableau des distances les plus courtes, booléen indiquant la présence d'un cycle négatif}
pair<vector<long long>, bool> bellman_ford(int V, const vector<Edge>& edges, int s) {
 vector<long long> dist(V, INF);
 dist[s] = 0;
 bool negative_cycle = false;

 // Boucle exécutée V fois
 for (int i = 0; i < V; ++i) {
 bool updated = false;
 for (const auto& edge : edges) {
 if (dist[edge.from] != INF && dist[edge.to] > dist[edge.from] + edge.weight) {
 dist[edge.to] = dist[edge.from] + edge.weight;
 updated = true;
 // Si une mise à jour survient à la V-ème itération, un cycle négatif existe
 if (i == V - 1) {
 negative_cycle = true;
 }
 }
 }
 // Arrêt anticipé s'il n'y a pas eu de mise à jour (optimisation)
 if (!updated) break;
 }

 return {dist, negative_cycle};
}

4. Problème du plus court chemin entre toutes paires de sommets (APSP : All-Pairs Shortest Path)

Algorithme de Floyd-Warshall

Il s’agit d’un algorithme permettant de trouver la plus courte distance entre toutes les paires de sommets d’un graphe. Il est basé sur la programmation dynamique (DP). Son attrait réside dans le fait qu’il est très concis et extrêmement facile à implémenter.

L’équation de transition d’état est la suivante. On choisit le plus court entre le chemin qui passe par le sommet $k$ et celui qui n’y passe pas :

$$ d[i][j] = \min(d[i][j], d[i][k] + d[k][j]) $$

Puisqu’il exécute une triple boucle, la complexité temporelle est de $O(V^3)$ et la complexité spatiale est de $O(V^2)$. Si le nombre de sommets est de $V \le 400$ environ, cela respectera la limite de temps d’exécution (généralement 2 secondes).

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const long long INF = 1e18;

// Algorithme de Floyd-Warshall
// dist[i][j] est initialement le poids de l'arête de i vers j (INF s'il n'y a pas d'arête, 0 si i==j)
void floyd_warshall(int V, vector<vector<long long>>& dist) {
 // Sommet intermédiaire k
 for (int k = 0; k < V; ++k) {
 // Sommet de départ i
 for (int i = 0; i < V; ++i) {
 // Sommet d'arrivée j
 for (int j = 0; j < V; ++j) {
 // Vérifier la présence de INF pour éviter tout débordement
 if (dist[i][k] != INF && dist[k][j] != INF) {
 dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
 }
 }
 }
 }
}

L’algorithme de Floyd-Warshall peut également détecter les cycles négatifs. Après la boucle, s’il existe au moins un sommet i pour lequel dist[i][i] < 0, alors le graphe contient un cycle négatif.

5. Arbre couvrant de poids minimum (MST : Minimum Spanning Tree)

Dans un graphe non orienté connexe, on appelle arbre couvrant de poids minimum (MST) un arbre (sous-graphe sans cycle) reliant tous les sommets tel que la somme des poids de ses arêtes est minimale. Il est souvent demandé directement dans des problèmes de minimisation des coûts de construction de réseaux.

Algorithme de Kruskal

Il s’agit d’une approche gloutonne où toutes les arêtes sont triées par ordre croissant de poids, puis sélectionnées une par une sans former de cycle. La détection de cycle peut être traitée rapidement à l’aide d’une structure de données d’ensembles disjoints (Union-Find, Disjoint Set).

La complexité temporelle est dominée par le tri des arêtes, atteignant $O(E \log E)$. C’est l’algorithme de construction de MST le plus fréquemment utilisé en programmation compétitive.

graph TD A["Sommet A"] -- "1 (Accepté)" --- B["Sommet B"] B["Sommet B"] -- "2 (Accepté)" --- C["Sommet C"] C["Sommet C"] -- "3 (Accepté)" --- D["Sommet D"] A["Sommet A"] -- "4 (Rejeté : Cycle)" --- D["Sommet D"]

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// Union-Find (Structure de données d'ensembles disjoints)
struct UnionFind {
 vector<int> parent, rank, size;
 UnionFind(int n) : parent(n), rank(n, 0), size(n, 1) {
 for (int i = 0; i < n; i++) parent[i] = i;
 }
 int find(int x) {
 if (parent[x] == x) return x;
 // Compression de chemin
 return parent[x] = find(parent[x]);
 }
 bool unite(int x, int y) {
 int root_x = find(x);
 int root_y = find(y);
 if (root_x == root_y) return false;

 // Fusion par rang
 if (rank[root_x] < rank[root_y]) swap(root_x, root_y);
 parent[root_y] = root_x;
 if (rank[root_x] == rank[root_y]) rank[root_x]++;
 size[root_x] += size[root_y];
 return true;
 }
 bool same(int x, int y) { return find(x) == find(y); }
};

struct Edge {
 int u, v;
 long long weight;
 // Fonction de comparaison pour le tri
 bool operator<(const Edge& other) const {
 return weight < other.weight;
 }
};

// Algorithme de Kruskal
long long kruskal(int V, vector<Edge>& edges) {
 // Trier les arêtes par ordre croissant de poids
 sort(edges.begin(), edges.end());

 UnionFind uf(V);
 long long mst_cost = 0;
 int edge_count = 0;

 for (const auto& edge : edges) {
 if (uf.unite(edge.u, edge.v)) {
 mst_cost += edge.weight;
 edge_count++;
 // S'arrêter si V-1 arêtes ont été choisies (optimisation)
 if (edge_count == V - 1) break;
 }
 }
 return mst_cost;
}

Algorithme de Prim

L’approche est très similaire à celle de l’algorithme de Dijkstra. En partant d’un sommet donné, on fait croître l’arbre en choisissant successivement l’arête de plus faible poids connectée directement à l’arbre déjà formé.

La complexité est de $O((V + E) \log V)$ lorsqu’une file de priorité est utilisée. Pour les graphes denses (avec beaucoup d’arêtes), l’implémentation de Prim basée sur des tableaux en $O(V^2)$ peut être plus rapide que l’algorithme de Kruskal.

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Edge {
 int to;
 long long weight;
};

// Algorithme de Prim
long long prim(int V, const vector<vector<Edge>>& graph) {
 vector<bool> used(V, false);
 // {poids, sommet}
 using P = pair<long long, int>;
 priority_queue<P, vector<P>, greater<P>> pq;

 long long mst_cost = 0;
 // Prendre le sommet 0 comme origine
 pq.push({0, 0});

 while (!pq.empty()) {
 auto [cost, u] = pq.top();
 pq.pop();

 if (used[u]) continue;
 used[u] = true;
 mst_cost += cost;

 for (const auto& edge : graph[u]) {
 if (!used[edge.to]) {
 pq.push({edge.weight, edge.to});
 }
 }
 }
 return mst_cost;
}

6. Avancé : Décomposition en composantes fortement connexes (SCC : Strongly Connected Components)

Dans un graphe orienté, un ensemble de sommets qui peuvent s’atteindre mutuellement est appelé composante fortement connexe (SCC). Si l’on regroupe chaque composante fortement connexe d’un graphe orienté quelconque, l’ensemble devient toujours un DAG (graphe orienté acyclique). C’est ce qu’on appelle la décomposition en composantes fortement connexes. Il s’agit d’un prétraitement très important pour simplifier la structure du graphe et faciliter la résolution de problèmes.

En programmation compétitive, cette méthode est souvent utilisée pour résoudre le problème 2-SAT ou pour contracter des graphes contenant des cycles en DAG afin d’appliquer la programmation dynamique (DP).

Algorithme de Kosaraju

L’algorithme de Kosaraju est une méthode élégante et efficace qui permet de construire des SCC en n’effectuant que deux parcours en profondeur (DFS). Il fonctionne en temps linéaire avec une complexité de $O(V + E)$.

Étapes de l’algorithme :

Effectuer un DFS sur le graphe d’origine et enregistrer les sommets dans un tableau dans l’ordre de post-visite (post-order).
Créer un graphe inversé en inversant la direction de toutes les arêtes.
En parcourant le tableau enregistré à l’étape 1 de l’arrière vers l’avant (ordre de post-visite décroissant), effectuer un DFS sur le graphe inversé depuis les sommets non visités. L’ensemble des sommets atteints lors de ce seul DFS forme une SCC.

graph TD subgraph "SCC 1" A["Sommet A"] --> B["Sommet B"] B["Sommet B"] --> A["Sommet A"] end subgraph "SCC 2" C["Sommet C"] --> D["Sommet D"] D["Sommet D"] --> C["Sommet C"] end B["Sommet B"] --> C["Sommet C"]

Exemple d’implémentation en C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct SCC {
 int V;
 vector<vector<int>> graph, rev_graph;
 vector<int> order, comp;
 vector<bool> used;

 SCC(int n) : V(n), graph(n), rev_graph(n), comp(n, -1), used(n, false) {}

 void add_edge(int from, int to) {
 graph[from].push_back(to);
 rev_graph[to].push_back(from);
 }

 // 1er DFS (Enregistrement du post-ordre)
 void dfs1(int u) {
 used[u] = true;
 for (int v : graph[u]) {
 if (!used[v]) dfs1(v);
 }
 order.push_back(u);
 }

 // 2ème DFS (Exploration du graphe inversé)
 void dfs2(int u, int id) {
 used[u] = true;
 comp[u] = id;
 for (int v : rev_graph[u]) {
 if (!used[v]) dfs2(v, id);
 }
 }

 // Processus de construction des SCC. La valeur de retour est le nombre de groupes SCC
 int build() {
 // 1er DFS
 for (int i = 0; i < V; ++i) {
 if (!used[i]) dfs1(i);
 }

 fill(used.begin(), used.end(), false);
 int group_id = 0;

 // 2ème DFS (dans l'ordre inverse de "order")
 for (int i = V - 1; i >= 0; --i) {
 int u = order[i];
 if (!used[u]) {
 dfs2(u, group_id++);
 }
 }
 return group_id;
 }
};

Le tableau comp stocke l’ID de la SCC à laquelle appartient chaque sommet. Cet ID possède en réalité une propriété très pratique : il est attribué dans l’ordre du tri topologique. Ainsi, en regardant les valeurs de comp, on peut déterminer immédiatement les dépendances après contraction en DAG.

7. Conclusion et conseils d’apprentissage

Dans cet article, nous avons passé en revue les algorithmes de graphes fréquemment rencontrés en programmation compétitive. Les clés pour s’améliorer sur les problèmes de graphes sont : « implémenter l’algorithme à plusieurs reprises jusqu’à ce que cela devienne un réflexe » et « s’entraîner à réfléchir à quel type de graphe un problème peut être réduit (que représentent les sommets, que représentent les arêtes) ».

Tout d’abord, soyez capable d’écrire rapidement et sans erreur les algorithmes DFS / BFS.
Ensuite, apprenez à coder de mémoire l’algorithme de Dijkstra et l’algorithme de Kruskal (indispensable pour les rangs marron-vert sur AtCoder).
Enfin, élargissez vos connaissances avec Bellman-Ford, Floyd-Warshall, le tri topologique et les SCC (ce qui constituera une arme pour les rangs cyan-bleu sur AtCoder).

Nous vous recommandons fortement de les ajouter sous forme de snippets dans votre propre bibliothèque (en utilisant des outils de snippets ou en les sauvegardant sur votre dépôt GitHub) afin d’être prêt à les utiliser sans hésitation lors des compétitions réelles.

Les algorithmes de graphes en programmation compétitive constituent le domaine où l’on ressent le plus la beauté et la puissance de l’algorithmique. N’hésitez pas à recopier le code de cet article et à vous mesurer à d’anciens problèmes sur les juges en ligne (Online Judges) !

Avis aux passionnés de mathématiques ! 10 superbes formules mathématiques utiles pour la programmation

Sat, 12 Sep 2026 01:00:00 +0900

Avis aux passionnés de mathématiques ! 10 superbes formules mathématiques utiles pour la programmation

La programmation et les mathématiques peuvent sembler à première vue être des domaines totalement différents. La programmation est le processus d’écriture de code logique et concret, tandis que les mathématiques sont la poursuite de vérités abstraites et universelles. Cependant, les mathématiques sont toujours au cœur de l’informatique. Derrière l’optimisation des algorithmes, la science des données, l’apprentissage automatique, l’infographie et même les applications quotidiennes, de belles formules mathématiques travaillent silencieusement et puissamment.

Dans cet article, nous avons soigneusement sélectionné 10 formules qui ne sont pas seulement belles mathématiquement, mais qui jouent également un rôle extrêmement pratique et important dans le contexte de la programmation et des algorithmes. Nous approfondirons le contexte mathématique de chaque formule et expliquerons en détail comment elle est appliquée dans la pratique de la programmation, avec des extraits de code concrets en Python et C++.

Bienvenue dans un monde où la beauté des mathématiques croise l’aspect pratique de la programmation.

1. Identité d’Euler (Euler’s Identity)

Beauté de la formule et aperçu

Voici l’identité d’Euler, souvent qualifiée de “trésor de l’humanité” ou de “la plus belle équation du monde”. Les cinq constantes les plus importantes en mathématiques (le nombre de Néper $e$, l’unité imaginaire $i$, le nombre pi $\pi$, l’élément neutre de la multiplication $1$ et l’élément neutre de l’addition $0$) sont intégrées dans une seule formule simple.

$$ e^{i\pi} + 1 = 0 $$

Cette équation est dérivée de la formule d’Euler plus générale $e^{i\theta} = \cos\theta + i\sin\theta$ en y substituant $\theta = \pi$.

Applications en programmation

En programmation, notamment dans l’infographie et le développement de jeux, la formule d’Euler devient un outil extrêmement puissant pour gérer les “rotations”. La rotation d’un point dans un espace bidimensionnel peut être effectuée à l’aide de calculs matriciels, mais l’utilisation de nombres complexes rend le calcul extrêmement simple et intuitif. La rotation sur un plan complexe peut être réalisée en multipliant simplement par $e^{i\theta}$, ce qui rend le code très concis.

Exemple d’implémentation (C++)

Voici un programme qui fait pivoter un point sur des coordonnées 2D d’un angle spécifié (en radians) à l’aide de la bibliothèque standard C++ <complex>.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <iostream>
#include <complex>
#include <cmath>

// Alias de type pour traiter les coordonnées 2D comme des nombres complexes
using Point2D = std::complex<double>;

// Fonction pour faire pivoter un point autour de l'origine d'un angle theta (en radians)
Point2D rotatePoint(const Point2D& point, double theta) {
 // Créer le nombre complexe pour la rotation e^{i*theta} selon la formule d'Euler
 // En interne, cela correspond à cos(theta) + i*sin(theta)
 Point2D rotation(std::cos(theta), std::sin(theta));

 // Appliquer la rotation via la multiplication de nombres complexes
 return point * rotation;
}

int main() {
 // Coordonnées initiales (x=1.0, y=0.0)
 Point2D p(1.0, 0.0);

 // Rotation de 90 degrés (π/2 radians)
 double theta = M_PI / 2.0;
 Point2D rotated_p = rotatePoint(p, theta);

 std::cout << "Original Point: (" << p.real() << ", " << p.imag() << ")\n";
 // La sortie attendue est d'environ (0, 1)
 std::cout << "Rotated Point: (" << rotated_p.real() << ", " << rotated_p.imag() << ")\n";

 return 0;
}

Explication détaillée : L’avantage de cette approche est que le calcul de la matrice de rotation (4 multiplications et 2 additions) peut être encapsulé sous forme d’opération sur les nombres complexes. De plus, dans l’espace tridimensionnel, on utilise les “quaternions”, qui sont une extension de ce concept. L’utilisation des quaternions permet d’éviter le problème fatal du “blocage de cardan” (Gimbal Lock) qui se produit avec les angles d’Euler, et d’obtenir une interpolation linéaire sphérique fluide (Slerp).

2. Développement de Taylor (Taylor Series)

Beauté de la formule et aperçu

Le développement de Taylor est une méthode mathématique qui exprime des fonctions complexes (telles que les fonctions trigonométriques et exponentielles) sous la forme d’une somme infinie de polynômes. Le développement de Taylor d’une fonction $f(x)$ autour d’un point $a$ est défini comme suit :

$$ f(x) = \sum_{n=0}^\infty \frac{f^{(n)}(a)}{n!}(x-a)^n $$

En particulier, le cas où $a=0$ est appelé “développement de Maclaurin”.

Applications en programmation

Les ordinateurs (CPU ou FPU) ne peuvent fondamentalement exécuter que des opérations arithmétiques basiques : addition, soustraction, multiplication et division. Alors, comment sont calculés sin(x) ou exp(x) ? Dans les processeurs modernes, l’algorithme CORDIC ou l’approximation de Tchebychev sont souvent utilisés, mais lorsque l’on implémente des fonctions mathématiques au niveau logiciel, ou que l’on crée ses propres fonctions d’approximation rapides en sacrifiant un peu de précision pour les performances, le développement de Taylor (ou ses variantes) est directement utile.

Exemple d’implémentation (Python)

Voici un code Python qui calcule approximativement la fonction sinus à l’aide du développement de Maclaurin.

$$ \sin(x) \approx x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \dots $$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


import math

def taylor_sin(x, terms=10):
 """
 Calcule une approximation de sin(x) en utilisant le développement de Taylor (développement de Maclaurin).

 :param x: Angle (en radians)
 :param terms: Nombre de termes à calculer (plus il y en a, plus la précision est élevée)
 :return: Valeur approximative de sin(x)
 """
 # Normaliser x dans la plage de -π à π en utilisant la périodicité (pour améliorer la précision)
 x = (x + math.pi) % (2 * math.pi) - math.pi

 result = 0.0
 for n in range(terms):
 # Utiliser uniquement les termes impairs : 2n + 1
 power = 2 * n + 1

 # Le signe est inversé pour chaque terme : (-1)^n
 sign = (-1) ** n

 # Calcul de la factorielle
 fact = math.factorial(power)

 # Évaluation de la formule et addition
 term = sign * (x ** power) / fact
 result += term

 return result

# Test
angle = math.radians(45) # 45 degrés = π/4
print(f"Math library sin: {math.sin(angle)}")
print(f"Taylor series sin: {taylor_sin(angle, terms=5)}")

Explication détaillée : Dans le code ci-dessus, la valeur d’entrée x est normalisée dans la plage $[-\pi, \pi]$. C’est parce que le développement de Taylor a la propriété de voir son erreur augmenter rapidement à mesure que l’on s’éloigne du centre du développement (ici 0) (erreur de troncature). Comme les calculs infinis sont impossibles en programmation, nous tronquons le calcul à un nombre fini de terms, mais la gestion du compromis entre l’“erreur d’arrondi” et l’“erreur de troncature” qui en résulte est la clé de la programmation de calculs numériques.

3. Théorème de Bayes (Bayes’ Theorem)

Beauté de la formule et aperçu

Le théorème de Bayes est un théorème permettant de mettre à jour la probabilité d’un événement (probabilité a posteriori) sur la base de connaissances préalables (probabilité a priori) liées à cet événement. C’est l’une des formules les plus importantes en théorie des probabilités et en statistiques.

$$ P(A|B) = \frac{P(B|A)P(A)}{P(B)} $$

Ici, $P(A|B)$ représente la probabilité que l’événement A se produise sous la condition que l’événement B s’est produit (probabilité a posteriori).

Applications en programmation

Il est largement utilisé dans les domaines de l’apprentissage automatique et de la science des données sous le nom de “classificateur naïf de Bayes” (Naive Bayes Classifier). Un exemple typique d’application est le filtrage des courriers indésirables (spam). Le calcul de “Quelle est la probabilité que cet e-mail soit un spam s’il contient le mot ‘gratuit’ ?” est effectué dynamiquement sur la base de données passées.

graph TD Email["E-mail entrant"] --> Extract["Extraire les mots"] Extract --> W1["Mot : 'Gratuit'"] Extract --> W2["Mot : 'Argent'"] Extract --> Wn["Mot : 'Réunion'"] W1 --> Prob["Calculer P(Spam | Mots)"] W2 --> Prob Wn --> Prob Prob --> Bayes["Appliquer le théorème de Bayes"] Bayes --> Class{"P(Spam) > 0.9 ?"} Class -- "Oui" --> Spam["Déplacer vers le dossier Spam"] Class -- "Non" --> Ham["Livrer à la boîte de réception"]

Exemple d’implémentation (Python)

Voici un code illustrant la logique de base d’un filtre anti-spam.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


def calculate_spam_probability(
 prob_spam,
 prob_word_given_spam,
 prob_word_given_ham
):
 """
 Calcule la probabilité qu'un e-mail contenant un certain mot soit un spam en utilisant le théorème de Bayes.

 :param prob_spam: P(Spam) - Probabilité a priori que l'e-mail soit un spam
 :param prob_word_given_spam: P(Word|Spam) - Probabilité que le mot soit inclus dans un spam
 :param prob_word_given_ham: P(Word|Ham) - Probabilité que le mot soit inclus dans un e-mail normal
 :return: P(Spam|Word) - Probabilité qu'il s'agisse d'un spam si le mot est inclus
 """
 # Probabilité a priori d'un e-mail normal P(Ham) = 1 - P(Spam)
 prob_ham = 1.0 - prob_spam

 # Probabilité d'apparition de ce mot dans tous les e-mails P(Word) = P(Word|Spam)P(Spam) + P(Word|Ham)P(Ham)
 # Ceci est dû au théorème des probabilités totales
 prob_word = (prob_word_given_spam * prob_spam) + (prob_word_given_ham * prob_ham)

 # Théorème de Bayes P(Spam|Word) = P(Word|Spam) * P(Spam) / P(Word)
 if prob_word == 0:
 return 0.0 # Évitement de la division par zéro

 prob_spam_given_word = (prob_word_given_spam * prob_spam) / prob_word
 return prob_spam_given_word

# Exemple : Probabilité avec le mot "gagnant"
# Données passées : 20% de tous les e-mails sont des spams
p_spam = 0.2
# 80% des spams contiennent le mot "gagnant"
p_win_given_spam = 0.8
# 1% des e-mails normaux contiennent le mot "gagnant"
p_win_given_ham = 0.01

result = calculate_spam_probability(p_spam, p_win_given_spam, p_win_given_ham)
print(f"Probabilité qu'un e-mail contenant le mot 'gagnant' soit un spam : {result:.2%}")

Explication détaillée : Dans une implémentation réelle (classificateur naïf de Bayes), les probabilités de plusieurs mots sont multipliées ensemble. Cependant, si l’on multiplie des probabilités (valeurs entre 0 et 1) des milliers de fois, la valeur devient nulle en raison des limites de la représentation en virgule flottante des ordinateurs (sous-dépassement ou underflow). Par conséquent, dans la programmation réelle, la technique consistant à convertir le produit des probabilités en “somme de logarithmes” (log(a * b) = log(a) + log(b)) est une technique essentielle.

4. Entropie de Shannon (Shannon Entropy)

Beauté de la formule et aperçu

Définie par Claude Shannon, le père de la théorie de l’information, l’“entropie” est une formule qui quantifie l’“incertitude”, le “désordre” ou la “quantité moyenne d’information” possédée par une source d’information.

$$ H(X) = - \sum_{i=1}^n P(x_i) \log_2 P(x_i) $$

Applications en programmation

L’entropie est indispensable dans la compression des données de fichiers (le codage de Huffman et les limites théoriques de l’algorithme de compression ZIP), l’évaluation de la force des nombres aléatoires en cryptographie, et les algorithmes d’“arbres de décision” (Decision Trees, tels que ID3 ou C4.5) en apprentissage automatique. Lors de la construction d’un arbre de décision, l’algorithme cherche à trouver la caractéristique qui maximise la réduction de l’entropie (gain d’information) lors de la division des données.

Exemple d’implémentation (Python)

Voici une fonction qui calcule l’entropie d’une chaîne de caractères (jeu de données) et évalue sa quantité d’information.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


import math
from collections import Counter

def calculate_entropy(data):
 """
 Calcule l'entropie de Shannon de l'ensemble de données donné (chaîne de caractères ou liste).
 """
 if not data:
 return 0.0

 # Compter le nombre d'occurrences de chaque élément
 counts = Counter(data)
 total_len = len(data)

 entropy = 0.0
 for element, count in counts.items():
 # Probabilité d'occurrence P(x_i)
 probability = count / total_len

 # - P(x_i) * log2(P(x_i))
 entropy -= probability * math.log2(probability)

 return entropy

# Tests
# Si tous les caractères sont les mêmes, l'incertitude est de 0
data_deterministic = "AAAAAAAAAA"
# Pour des caractères aléatoires, l'incertitude est élevée
data_random = "ABACBCBACB"

print(f"Entropy of '{data_deterministic}': {calculate_entropy(data_deterministic)}")
print(f"Entropy of '{data_random}': {calculate_entropy(data_random)}")

Explication détaillée : L’unité de l’entropie est le “bit” (bits). Si l’entropie est de 1.5, cela signifie qu’en moyenne un minimum de 1,5 bits par élément est nécessaire pour représenter ces données. Dans le domaine de la programmation, elle est calculée quotidiennement comme repère pour mesurer l’efficacité des algorithmes de compression et comme indicateur clé dans la sélection des caractéristiques des modèles d’apprentissage automatique.

5. Transformée de Fourier rapide (Fast Fourier Transform - FFT)

Beauté de la formule et aperçu

La transformée de Fourier discrète (DFT) convertit un signal du domaine temporel en un signal du domaine fréquentiel. Sa formule mathématique est la suivante :

$$ X_k = \sum_{n=0}^{N-1} x_n e^{-i 2\pi k n / N} $$

Si vous calculez cette DFT de manière naïve, la complexité temporelle sera de $O(N^2)$, et à mesure que la quantité de données augmente, le calcul deviendra de plus en plus lent de façon exponentielle. L’algorithme qui accélère considérablement cela jusqu’à $O(N \log N)$ grâce à l’approche diviser pour régner est la “Transformée de Fourier rapide” (FFT). Il est classé parmi les 10 algorithmes les plus importants du 20ème siècle.

graph TD A["Tableau d'entrée de taille N"] --> B["Diviser en indices pairs et impairs"] B --> C["Indices pairs (N/2)"] B --> D["Indices impairs (N/2)"] C --> E["FFT récursive sur les pairs"] D --> F["FFT récursive sur les impairs"] E --> G["Combiner à l'aide des facteurs de rotation"] F --> G G --> H["Spectre de fréquence de sortie"]

Applications en programmation

La FFT est une technologie indispensable qui soutient la société moderne. Elle fonctionne partout : reconnaissance vocale (Siri, Alexa), compression de données MP3 et JPEG/MPEG, communications numériques comme la 4G/LTE et le Wi-Fi, et même la multiplication d’entiers extrêmement grands (algorithme de Schönhage-Strassen).

Exemple d’implémentation (Python)

Voici un exemple simple d’implémentation de l’algorithme récursif de type Cooley-Tukey. (En pratique, on utilise des bibliothèques hautement optimisées en C ou en assembleur comme FFTW ou numpy.fft)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


import cmath

def fft(x):
 """
 Calcule la Transformée de Fourier Rapide (FFT) 1D (méthode de Cooley-Tukey).
 La longueur N de la liste d'entrée doit être une puissance de 2.
 """
 N = len(x)

 # Cas de base
 if N <= 1:
 return x

 # Division en éléments d'indices pairs et impairs (Divide)
 even = fft(x[0::2])
 odd = fft(x[1::2])

 # Combinaison des résultats (Conquer)
 T = [cmath.exp(-2j * cmath.pi * k / N) * odd[k] for k in range(N // 2)]

 # Réduction de la complexité des calculs grâce à la symétrie
 return [even[k] + T[k] for k in range(N // 2)] + \
 [even[k] - T[k] for k in range(N // 2)]

# Test : signal simple
signal = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
spectrum = fft(signal)

print("Frequency Spectrum (Magnitude):")
for k, val in enumerate(spectrum):
 # Calcul de la valeur absolue (amplitude)
 print(f"Freq {k}: {abs(val):.3f}")

Explication détaillée : La clé de cet algorithme est qu’il exploite la symétrie et la périodicité des nombres complexes appelés “facteurs de rotation” (Twiddle factors). Cela évite les redondances dans les calculs et réduit le nombre d’opérations de $1 048 576$ à seulement environ $10 240$ pour $N=1024$. On peut dire que c’est véritablement un miracle né de la fusion des mathématiques et des algorithmes.

6. Formule de la haversine (Haversine Formula)

Beauté de la formule et aperçu

C’est une formule pour calculer la distance la plus courte (distance du grand cercle) entre deux points sur une surface sphérique telle que la surface de la Terre.

$$ a = \sin^2\left(\frac{\Delta\phi}{2}\right) + \cos\phi_1 \cos\phi_2 \sin^2\left(\frac{\Delta\lambda}{2}\right) $$ $$ c = 2\cdot \text{atan2}\left(\sqrt{a}, \sqrt{1-a}\right) $$ $$ d = R \cdot c $$

(Ici, $\phi$ est la latitude, $\lambda$ est la longitude, et $R$ est le rayon de la Terre)

Applications en programmation

Dans les applications de suivi GPS ou les services basés sur la localisation comme Uber ou Pokémon GO, cette équation est indispensable pour calculer la distance entre deux coordonnées de latitude et longitude. Le calcul de la distance en ligne droite à l’aide du théorème de Pythagore produit de grandes erreurs sur les longues distances car il ne tient pas compte de la courbure de la Terre.

Exemple d’implémentation (Python)

Voici une fonction qui prend deux coordonnées (latitude et longitude) et renvoie la distance (en kilomètres) entre elles.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


import math

def haversine_distance(lat1, lon1, lat2, lon2):
 """
 Calcule la distance du grand cercle entre deux points en utilisant la formule de la haversine.
 """
 # Rayon moyen de la Terre (en kilomètres)
 R = 6371.0

 # Conversion de la latitude et de la longitude des degrés aux radians
 phi1, phi2 = math.radians(lat1), math.radians(lat2)
 delta_phi = math.radians(lat2 - lat1)
 delta_lambda = math.radians(lon2 - lon1)

 # Calcul de la haversine
 a = math.sin(delta_phi / 2.0)**2 + \
 math.cos(phi1) * math.cos(phi2) * \
 math.sin(delta_lambda / 2.0)**2

 c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

 # Calcul de la distance
 distance = R * c
 return distance

# Distance entre la Tour de Tokyo (35.6586, 139.7454) et la Statue de la Liberté (40.6892, -74.0445)
tokyo = (35.6586, 139.7454)
ny = (40.6892, -74.0445)

dist = haversine_distance(tokyo[0], tokyo[1], ny[0], ny[1])
print(f"Distance de la Tour de Tokyo à la Statue de la Liberté : environ {dist:.2f} km")

Explication détaillée : Il existe également une méthode utilisant la loi des cosinus de la trigonométrie sphérique, mais lorsque la distance entre deux points est très courte (par exemple de l’ordre de quelques mètres), une “annulation catastrophique” (Catastrophic cancellation) dans la précision des calculs en virgule flottante a tendance à se produire. L’avantage majeur de la formule de la haversine en programmation est qu’elle utilise sin^2, ce qui permet d’obtenir des calculs numériquement stables même pour de très petites distances. Si une précision encore plus grande est requise, les formules de Vincenty (Vincenty’s formulae), qui traitent la Terre comme un ellipsoïde, sont utilisées.

7. Méthode de Newton-Raphson (Newton-Raphson Method)

Beauté de la formule et aperçu

C’est un algorithme de recherche de racines très puissant qui trouve de manière itérative la solution (racine) de l’équation $f(x) = 0$ en utilisant des tangentes.

$$ x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)} $$

À l’aide de la valeur de la fonction $f(x_n)$ et de sa pente (dérivée) $f'(x_n)$ à la position actuelle $x_n$, l’algorithme devine la position suivante, plus précise, $x_{n+1}$ à explorer.

flowchart LR Start["Début : Deviner le x0 initial"] --> Eval["Évaluer f(xn) et f'(xn)"] Eval --> Check{"f(xn) ≈ 0 ?"} Check -- "Oui" --> Done["Renvoyer xn comme racine"] Check -- "Non" --> Update["xn+1 = xn - f(xn) / f'(xn)"] Update --> Eval

Applications en programmation

Elle est utilisée dans le rendu des moteurs graphiques, la détection des collisions dans les simulations physiques, les problèmes d’optimisation, etc. Fait remarquable, le célèbre “Fast Inverse Square Root” (calcul rapide de l’inverse de la racine carrée) intégré dans le code source du légendaire jeu FPS “Quake III Arena” était un hack qui appliquait la méthode de Newton une seule fois pour calculer $1/\sqrt{x}$ à une vitesse fulgurante, ce qui était essentiel pour la normalisation des vecteurs.

Exemple d’implémentation (C++)

Voici un exemple clair qui calcule la racine carrée standard $\sqrt{N}$ (c’est-à-dire la solution de $x^2 - N = 0$) à l’aide de la méthode de Newton. Nous avons $f(x) = x^2 - N$ et $f'(x) = 2x$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <iostream>
#include <cmath>

double newton_sqrt(double N, double tolerance = 1e-7) {
 if (N < 0) return NAN; // La racine carrée d'un nombre négatif est NaN
 if (N == 0) return 0;

 // Estimation initiale (on commence avec N lui-même)
 double x = N;

 while (true) {
 // Calcul de l'estimation suivante : x_new = x - (x^2 - N) / (2x) = (x + N/x) / 2
 double x_new = 0.5 * (x + N / x);

 // Si le changement est inférieur à la marge d'erreur (tolerance), on considère qu'il a convergé
 if (std::abs(x - x_new) < tolerance) {
 break;
 }
 x = x_new;
 }

 return x;
}

int main() {
 double number = 612.0;
 std::cout << "Square root of " << number << " is: " << newton_sqrt(number) << "\n";
 return 0;
}

Explication détaillée : Le plus grand attrait de la méthode de Newton est que, si les conditions sont réunies, elle présente une “convergence quadratique” (Quadratic convergence). Cela signifie une vitesse de convergence phénoménale où le nombre de chiffres corrects double approximativement à chaque itération. Si l’on considère que la recherche binaire (dichotomie) a une convergence linéaire, on se rend compte de la puissance de l’utilisation de l’information de la dérivée (faible pente). Le hack de “Quake III” utilisait un nombre magique d’opérations bit à bit 0x5f3759df pour pirater la structure du nombre à virgule flottante IEEE 754 afin d’obtenir la valeur initiale de la méthode de Newton avec une précision stupéfiante.

8. Courbes de Bézier (Bézier Curves)

Beauté de la formule et aperçu

C’est une équation paramétrique qui définit une courbe lisse à l’aide de plusieurs points de contrôle (Control Points). La courbe de Bézier cubique (Cubic Bézier Curve) la plus couramment utilisée possède quatre points $P_0, P_1, P_2, P_3$ et détermine les coordonnées $B(t)$ sur la courbe en fonction du paramètre $t \ (0 \le t \le 1)$.

$$ B(t) = (1-t)^3 P_0 + 3(1-t)^2 t P_1 + 3(1-t) t^2 P_2 + t^3 P_3 $$

Applications en programmation

Les courbes de Bézier sont le fondement de l’infographie. Elles sont utilisées chaque fois que vous souhaitez dessiner des “mouvements ou des formes lisses” par programme, comme dans les outils de dessin vectoriel comme Adobe Illustrator, le rendu de polices (TrueType ou OpenType), les fonctions d’assouplissement (easing) des transitions et animations CSS (cubic-bezier()), et le contrôle de la trajectoire de la caméra dans les jeux.

Exemple d’implémentation (Python)

Voici un code qui génère un groupe de points sur une courbe de Bézier cubique à partir de quatre points de contrôle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


def cubic_bezier(p0, p1, p2, p3, steps=10):
 """
 Génère une liste de coordonnées sur une courbe de Bézier cubique.
 p0, p1, p2, p3 sont des tuples (x, y).
 steps indique en combien de segments la courbe doit être divisée.
 """
 curve_points = []

 for i in range(steps + 1):
 # Le paramètre t varie de 0.0 à 1.0
 t = i / steps

 # Calcul des coefficients composant la formule
 u = 1 - t
 tt = t * t
 uu = u * u
 uuu = uu * u
 ttt = tt * t

 # Calcul des coordonnées x et y pour chaque point
 x = (uuu * p0[0]) + \
 (3 * uu * t * p1[0]) + \
 (3 * u * tt * p2[0]) + \
 (ttt * p3[0])

 y = (uuu * p0[1]) + \
 (3 * uu * t * p1[1]) + \
 (3 * u * tt * p2[1]) + \
 (ttt * p3[1])

 curve_points.append((x, y))

 return curve_points

# Point de départ, point de contrôle 1, point de contrôle 2, point d'arrivée
p0 = (0, 0)
p1 = (5, 10)
p2 = (15, 10)
p3 = (20, 0)

points = cubic_bezier(p0, p1, p2, p3, steps=5)
for i, pt in enumerate(points):
 print(f"t={i/5:.1f} -> Point({pt[0]:.2f}, {pt[1]:.2f})")

Explication détaillée : Cette formule est un développement de l’“algorithme de De Casteljau” (De Casteljau’s algorithm), qui applique récursivement l’interpolation linéaire (Lerp: Linear Interpolation). Elle calcule la solution directement à l’aide de polynômes (polynômes de Bernstein). En programmation, une courbe est dessinée approximativement comme un ensemble d’innombrables “lignes droites minuscules”. Par conséquent, en ajustant la résolution de $t$ (steps), on contrôle l’équilibre entre les performances et la qualité du rendu.

9. Fonction sigmoïde (Sigmoid Function)

Beauté de la formule et aperçu

C’est une fonction lisse en forme de S qui compresse toujours toute entrée de nombre réel $x \ ( -\infty < x < \infty )$ en une valeur comprise entre $0$ et $1$.

$$ \sigma(x) = \frac{1}{1 + e^{-x}} $$

Applications en programmation

Elle a joué un rôle historiquement très important dans la régression logistique et comme “fonction d’activation” (Activation Function) dans les réseaux de neurones (Deep Learning). Son plus grand avantage est que la sortie est comprise entre 0 et 1, ce qui permet d’interpréter le résultat comme une “probabilité”.

graph LR X1["Entrée x1"] -->|Poids w1| Sum["Somme : Σ(wi*xi) + b"] X2["Entrée x2"] -->|Poids w2| Sum Sum --> Act["Fonction sigmoïde : σ(x)"] Act --> Out["Probabilité de sortie (0 à 1)"]

Exemple d’implémentation (Python)

Voici un code qui applique la fonction sigmoïde à un tableau (tenseur) en entrée.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


import math

def sigmoid(x):
 """Calcul de la sigmoïde pour une seule valeur"""
 # On limite souvent la valeur d'entrée pour éviter que math.exp(-x) ne produise un dépassement (overflow)
 # Implémentation standard simplifiée
 if x >= 0:
 return 1.0 / (1.0 + math.exp(-x))
 else:
 # Mesure contre le dépassement lorsque x est une grande valeur négative
 return math.exp(x) / (1.0 + math.exp(x))

def apply_sigmoid(array):
 """Applique la fonction sigmoïde à tous les éléments d'un tableau"""
 return [sigmoid(x) for x in array]

# Données brutes de la couche de sortie du réseau de neurones (logits)
logits = [-5.0, -1.0, 0.0, 1.0, 5.0]
probabilities = apply_sigmoid(logits)

for val, prob in zip(logits, probabilities):
 print(f"Input: {val:4.1f} -> Probability: {prob:.4f}")

Explication détaillée : La ramification conditionnelle avec x >= 0 et le reste dans le code ci-dessus est pour éviter un problème spécifique à la programmation appelé “dépassement de capacité” (overflow). Si $x = -1000$ par exemple, c’est une technique de calcul numérique pour empêcher le programme de planter (ou de renvoyer Inf) en essayant de calculer $e^{1000}$. Actuellement, dans les couches intermédiaires du Deep Learning, ReLU ($f(x) = \max(0, x)$) est devenu dominant du point de vue de la vitesse de calcul et du problème de disparition du gradient, mais pour la couche de sortie de la classification binaire, la fonction sigmoïde conserve toujours une position inébranlable.

10. Distance euclidienne et théorème de Pythagore (Euclidean Distance & Pythagorean Theorem)

Beauté de la formule et aperçu

C’est le fondement de la géométrie hérité de la Grèce antique, et une équation qui définit la distance en ligne droite entre deux points dans un espace à $n$ dimensions. Dans l’espace bidimensionnel, il s’agit du théorème de Pythagore ($a^2 + b^2 = c^2$) lui-même.

La distance euclidienne $d$ entre un point $P(x_1, y_1, z_1)$ et $Q(x_2, y_2, z_2)$ dans un espace tridimensionnel s’exprime comme suit :

$$ d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2 + (z_2-z_1)^2} $$

Applications en programmation

C’est le calcul au cœur du développement de tous les jeux, des moteurs physiques et des algorithmes d’apprentissage automatique tels que la méthode des “K plus proches voisins” (K-Nearest Neighbors) ou le regroupement (K-Means). Dans les jeux, il est calculé des millions de fois à chaque image pour la détection de collisions entre personnages (Bounding Circle / Sphere Collision).

Exemple d’implémentation (C++)

Voici un code optimisé pour déterminer si deux cercles (ou sphères) sont en collision.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <cmath>

struct Circle {
 double x, y; // Coordonnées du centre
 double radius; // Rayon
};

// Fonction pour déterminer si deux cercles entrent en collision
bool isColliding(const Circle& a, const Circle& b) {
 // Différence des coordonnées x et y (delta)
 double dx = b.x - a.x;
 double dy = b.y - a.y;

 // Calculer le "carré" de la distance
 double distanceSquared = (dx * dx) + (dy * dy);

 // Calculer le "carré" de la somme des rayons
 double radiiSum = a.radius + b.radius;
 double radiiSumSquared = radiiSum * radiiSum;

 // Comparer le carré de la distance avec le carré de la somme des rayons
 return distanceSquared <= radiiSumSquared;
}

int main() {
 Circle player = {0.0, 0.0, 5.0};
 Circle enemy1 = {8.0, 0.0, 4.0}; // Distance de 8, somme des rayons de 9 -> Collision
 Circle enemy2 = {10.0, 10.0, 2.0}; // Distance d'environ 14.1, somme des rayons de 7 -> Pas de collision

 std::cout << "Collision with enemy1: " << (isColliding(player, enemy1) ? "Yes" : "No") << "\n";
 std::cout << "Collision with enemy2: " << (isColliding(player, enemy2) ? "Yes" : "No") << "\n";

 return 0;
}

Explication détaillée : Si vous calculez exactement selon la formule mathématique, vous devez prendre la racine carrée $\sqrt{\cdot}$ à la fin, mais en programmation, l’appel à la fonction sqrt() est un processus très lourd pour le CPU (qui consomme de nombreux cycles d’horloge). Par conséquent, s’il s’agit uniquement de comparer des distances, les comparer en gardant les deux côtés au carré (distanceSquared <= radiiSumSquared) est une pratique courante dans la programmation de jeux. Ainsi, l’optimisation visant à réduire la charge de calcul en utilisant les propriétés des équations et des inégalités mathématiques est le véritable plaisir de la conception d’algorithmes.

Conclusion

Qu’en pensez-vous ? De l’identité d’Euler au théorème de Pythagore, ces 10 formules ne sont pas simplement des concepts théoriques que l’on trouve dans les manuels. Elles battent comme le “cœur” derrière le code que nous écrivons habituellement, pour compresser des données, faire des prédictions à l’aide de modèles d’apprentissage automatique, dessiner des animations fluides et permettre des recherches rapides.

Comprendre le contexte mathématique est essentiel pour passer du statut de codeur qui se contente d’appeler des bibliothèques existantes (math.sin ou numpy.fft) à celui d’ingénieur capable d’en comprendre la structure interne et d’en repousser les limites. La prochaine fois que vous écrirez du code, essayez d’imaginer un instant quelles magnifiques formules mathématiques opèrent en arrière-plan.

Happy Coding and Math!

Limites de la factorisation en nombres premiers et explication de la notation Grand O (O)

Fri, 11 Sep 2026 23:00:00 +0900

Introduction : Pourquoi la factorisation en nombres premiers est-elle « difficile » ?

Dans la société Internet moderne, si nous pouvons faire des achats en ligne en toute tranquillité et échanger des informations confidentielles, c’est grâce à l’existence de la « cryptographie ». Et la sécurité de cette cryptographie (en particulier le chiffrement RSA, largement utilisé) repose sur un fait mathématique : « la factorisation de très grands nombres entiers en nombres premiers est extrêmement difficile ».

À première vue, la factorisation en nombres premiers peut sembler être une tâche simple consistant « juste à décomposer un nombre en produits de nombres premiers ». Cependant, lorsque le nombre de chiffres devient important, cela se transforme en un problème tellement complexe que même les superordinateurs les plus rapides du monde, fonctionnant pendant des décennies ou des siècles, ne pourraient le résoudre. La factorisation que nous apprenons à l’école est au mieux une tâche simple consistant à diviser par $2$, $3$ ou $5$, mais face au produit de deux nombres premiers inconnus de plusieurs centaines de chiffres, cette approche simpliste s’effondre complètement.

Dans cet article, en partant du concept de « complexité algorithmique (notation Grand O : $\mathcal{O}$) », qui est la base de l’informatique, nous expliquerons en détail et mathématiquement combien de temps de calcul nécessitent divers algorithmes de factorisation (méthode des divisions successives, algorithme $\rho$ de Pollard, crible du corps de nombres généralisé, etc.). Ensuite, nous analyserons pourquoi la factorisation de nombres géants est pratiquement impossible sur des ordinateurs classiques, comment cela protège nos informations et notre vie privée, et enfin, comment les ordinateurs quantiques pourraient bouleverser ce paradigme.

Définition rigoureuse de la complexité algorithmique et de la notation Grand O ($\mathcal{O}$)

Lors de l’évaluation des performances ou de l’efficacité d’un algorithme, il ne suffit pas de mesurer simplement le « temps d’exécution (en secondes) » du programme. En effet, le temps d’exécution dépend fortement des performances de l’ordinateur utilisé (fréquence d’horloge du processeur, vitesse de la mémoire, etc.), du langage de programmation et des optimisations du compilateur.

Par conséquent, l’indicateur d’évaluation universel indépendant du matériel et de l’environnement est la complexité temporelle (Time Complexity), et la notation utilisée pour l’exprimer est la notation Grand O (Big-O Notation). La notation Grand O est une écriture mathématique qui décrit comment le temps d’exécution (ou le nombre d’étapes d’exécution) d’un algorithme augmente par rapport à la taille des données d’entrée $N$ lorsque celle-ci devient très grande (taux de croissance asymptotique).

Définition mathématique de la notation asymptotique

En informatique, pour les fonctions $f(n)$ et $g(n)$, l’expression $f(n) = \mathcal{O}(g(n))$ est définie mathématiquement comme suit :

$$ \exists c > 0, \exists n_0 > 0 \text{ s.t. } \forall n \ge n_0, 0 \le f(n) \le c \cdot g(n) $$

Cela signifie que « lorsque la taille de l’entrée $n$ est suffisamment grande ($n \ge n_0$), la croissance de la fonction $f(n)$ est bornée supérieurement par $g(n)$ multipliée par une constante ». En d’autres termes, cela indique une « borne supérieure (Upper Bound) », garantissant que même dans le pire des cas, le temps de traitement de l’algorithme restera dans une constante multipliée par $g(n)$.

De même, il existe la notation $\Omega$ (Grand Oméga) pour indiquer une borne inférieure, et $\Theta$ (Grand Thêta) lorsque les bornes supérieure et inférieure coïncident. Cependant, la notation $\mathcal{O}$ est la plus fréquemment utilisée pour discuter de la complexité dans le pire des cas d’un algorithme.

Classes de complexité représentatives

Il existe plusieurs classes représentatives de complexité algorithmique. Examinons-les dans l’ordre, du temps d’exécution le plus court (le plus efficace) au plus long.

$\mathcal{O}(1)$ : Temps constant (Constant time) Un algorithme dont le temps d’exécution ne change pas, quelle que soit la taille de l’entrée $N$. Par exemple, l’accès à une valeur en spécifiant l’index d’un tableau, ou la recherche dans une table de hachage (dans le cas idéal).
$\mathcal{O}(\log N)$ : Temps logarithmique (Logarithmic time) Un algorithme très efficace où même si la taille de l’entrée double, le temps d’exécution n’augmente que d’une constante. La « recherche dichotomique (Binary Search) », qui recherche une valeur cible dans un tableau trié, en est un exemple typique. Même avec un milliard de données, il suffit d’environ 30 comparaisons pour trouver la donnée souhaitée.
$\mathcal{O}(N)$ : Temps linéaire (Linear time) Le temps d’exécution augmente proportionnellement à la taille de l’entrée. Si les données sont multipliées par 10, le temps sera également multiplié par 10. La « recherche linéaire », qui vérifie tous les éléments d’un tableau dans l’ordre, correspond à ce cas.
$\mathcal{O}(N \log N)$ : Temps quasi-linéaire (Linearithmic time) Un peu plus lent que $\mathcal{O}(N)$, mais toujours considéré comme efficace. De nombreux algorithmes de tri rapide pratiques, tels que le tri fusion (Merge Sort) et le tri rapide (Quick Sort, complexité moyenne), ont cette complexité.
$\mathcal{O}(N^2)$ : Temps polynomial / Temps quadratique (Quadratic time) Lorsque la taille de l’entrée double, le temps d’exécution quadruple ; si elle est multipliée par 10, il est multiplié par 100. Les traitements simples utilisant des boucles imbriquées, le tri à bulles ou le tri par insertion en font partie. Si la quantité de données dépasse plusieurs dizaines de milliers, le traitement commence à prendre beaucoup de temps. Ces complexités exprimées sous la forme $\mathcal{O}(N^k)$ sont collectivement appelées temps polynomial (Polynomial time).
$\mathcal{O}(2^N)$ : Temps exponentiel (Exponential time) Il suffit que la taille de l’entrée augmente de 1 pour que le temps d’exécution double. C’est extrêmement inefficace : dès que $N$ atteint 40 ou 50, même les ordinateurs de pointe ne peuvent plus terminer le calcul dans un temps réaliste. La recherche exhaustive du problème du sac à dos, ou la solution naïve du problème du voyageur de commerce en sont des exemples.
$\mathcal{O}(N!)$ : Temps factoriel (Factorial time) Il augmente encore plus rapidement que $\mathcal{O}(2^N)$. C’est le cas d’un algorithme qui testerait toutes les permutations possibles pour le problème du voyageur de commerce.

Le diagramme Mermaid ci-dessous est une comparaison schématique du taux d’augmentation du temps d’exécution (nombre d’étapes) pour chaque classe de complexité par rapport à l’augmentation de $N$.

graph TD classDef poly fill:#a8e6cf,stroke:#333,stroke-width:2px; classDef subexp fill:#ffd3b6,stroke:#333,stroke-width:2px; classDef exp fill:#ffaaa5,stroke:#333,stroke-width:2px; Poly["Temps Polynomial O(n^k)"]:::poly SubExp["Temps Sous-exponentiel L_n"]:::subexp Exp["Temps Exponentiel O(2^n)"]:::exp GNFS["Crible du Corps de Nombres Généralisé (GNFS)"]:::subexp Pollard["Algorithme rho de Pollard"]:::exp Trial["Méthode des Divisions Successives"]:::exp Easy["Réalisable (Faisable)"]:::poly Hard["Intraitable (Difficile)"]:::exp Poly --- Easy Exp --- Hard Trial --> Exp Pollard --> Exp GNFS --> SubExp Poly -.-> SubExp SubExp -.-> Exp

Vous comprenez désormais à quel point la différence de complexité est cruciale dans le choix d’un algorithme. En cryptographie, la sécurité est garantie en utilisant intentionnellement des problèmes qui nécessitent un « temps exponentiel » ou une « complexité proche » (c’est-à-dire des problèmes qui ne peuvent pas être résolus facilement).

Mécanisme du chiffrement RSA et le problème de la factorisation en nombres premiers

Pour comprendre pourquoi la factorisation en nombres premiers est importante, rappelons brièvement le fonctionnement du chiffrement RSA. Le chiffrement RSA est un système de cryptographie à clé publique développé en 1977 par Ronald Rivest, Adi Shamir et Leonard Adleman.

Étapes de génération des clés

Deux très grands nombres premiers $p$ et $q$ sont choisis au hasard (par exemple, chacun d’une longueur de 1024 bits).
Ils sont multipliés pour calculer $N = p \times q$. Ce $N$ est publié dans le monde entier comme faisant partie de la clé publique (il aura une longueur de 2048 bits).
L’indicatrice d’Euler $\phi(N) = (p-1)(q-1)$ est calculée.
Un entier $e$ premier avec $\phi(N)$ est choisi et devient également une partie de la clé publique.
Une clé privée $d$ est calculée de sorte que $e \times d \equiv 1 \pmod{\phi(N)}$.

Le point crucial ici est le fait que « pour déchiffrer le message, la clé privée $d$ est nécessaire ; pour calculer $d$, $\phi(N)$ est nécessaire ; et pour calculer $\phi(N)$, il faut factoriser $N$ en $p$ et $q$ ».

La multiplication de très grands nombres premiers $p \times q$ se fait en un instant, mais retrouver les $p$ et $q$ d’origine à partir du résultat $N$ (factorisation en nombres premiers) est désespérément difficile. Cette nature de « fonction à sens unique (One-way function) » est le cœur même du chiffrement RSA.

Il y a un point très important à noter ici. La « taille de l’entrée $n$ » dans le problème de la factorisation n’est pas la grandeur du nombre $N$ lui-même, mais le « nombre de bits nécessaires pour représenter le nombre $N$ ». Si $n$ est le nombre de chiffres lors de la représentation de l’entier $N$ en binaire, alors $n \approx \log_2 N$. En d’autres termes, la complexité de l’algorithme doit être évaluée par rapport à $n = \log_2 N$ (ou $\ln N$), et non à $N$.

Histoire des algorithmes de factorisation en nombres premiers et leur complexité

À partir d’ici, nous expliquerons en détail le fonctionnement et la complexité des divers algorithmes utilisés pour décomposer un nombre composé donné $N$ en produit de nombres premiers. C’est aussi l’histoire de la façon dont l’humanité a défié les limites de la factorisation.

1. Méthode des divisions successives (Trial Division)

L’algorithme le plus intuitif et primitif est la « méthode des divisions successives ». Il consiste à essayer de diviser $N$ par des nombres premiers dans l’ordre, à partir de $2$.

Aperçu de l’algorithme

Il tire parti de la propriété selon laquelle les facteurs premiers de $N$ ne dépasseront jamais $\sqrt{N}$ (puisque $\sqrt{N} \times \sqrt{N} = N$, s’il existait un facteur premier plus grand, il serait nécessairement associé à un facteur premier inférieur ou égal à $\sqrt{N}$). Par conséquent, on vérifie si $N$ est divisible par tous les nombres (ou nombres premiers) jusqu’à $\lfloor\sqrt{N}\rfloor$ : $2, 3, 5, 7, \dots$.

Évaluation de la complexité

Dans le pire des cas (par exemple, si $N$ est le produit de deux très grands nombres premiers), il faut effectuer des divisions jusqu’à $\sqrt{N}$. Comme mentionné précédemment, la taille de l’entrée $n$ est $n = \log_2 N$, on peut donc exprimer $N = 2^n$. Ainsi, le nombre maximal d’étapes de calcul est proportionnel à :

$$ \sqrt{N} = \sqrt{2^n} = (2^n)^{1/2} = 2^{n/2} $$

Cela signifie que pour une longueur de bit $n$, la complexité est $\mathcal{O}(2^{n/2})$. Autrement dit, la méthode des divisions successives est un algorithme à « temps exponentiel pur (Exponential time) » par rapport à $n$. Chaque fois que le nombre de bits augmente de 1 (le nombre double), le temps de calcul est multiplié par environ $\sqrt{2} \approx 1,414$. Si $N$ est un nombre dépassant 1024 bits (environ 300 chiffres en décimal), même en y consacrant un temps égal à l’âge de l’univers, le calcul ne s’achèverait pas.

2. Méthode de factorisation de Fermat (Fermat’s Factorization Method)

Il s’agit d’une méthode inventée par le mathématicien du 17ème siècle, Pierre de Fermat. Étant donné un nombre composé impair $N$, on tente de représenter $N$ comme la différence de deux carrés.

$$ N = x^2 - y^2 = (x - y)(x + y) $$

Si l’on trouve de tels $x$ et $y$, alors $a = x - y$ et $b = x + y$ seront les facteurs de $N$. Dans l’algorithme, on augmente $x$ progressivement à partir de $\lceil \sqrt{N} \rceil$ et on vérifie si $x^2 - N$ est un carré parfait (le carré d’un entier $y$). Cette méthode fonctionne de manière extrêmement rapide lorsque les deux facteurs premiers $p$ et $q$ sont très proches en valeur. Cependant, dans le cas général (où $p$ et $q$ ont des valeurs aléatoirement distantes), elle nécessite finalement un temps exponentiel similaire à celui de la méthode des divisions successives.

3. Algorithme $\rho$ de Pollard (Pollard’s rho algorithm)

L’un des algorithmes conçus pour dépasser les limites de la méthode des divisions successives est « l’algorithme $\rho$ (rho) de Pollard », publié par John Pollard en 1975.

Aperçu de l’algorithme

Cette méthode applique un concept probabiliste appelé « paradoxe des anniversaires (Birthday Paradox) » et la périodicité des suites pseudo-aléatoires (qui ressemble à la forme de la lettre grecque $\rho$, d’où son nom).

En utilisant une certaine fonction génératrice de nombres pseudo-aléatoires $f(x) = (x^2 + 1) \pmod N$, on génère une suite et on cherche deux valeurs dans la suite telles que $x_i \equiv x_j \pmod p$ (où $p$ est un facteur premier inconnu de $N$). À ce stade, comme $x_i - x_j$ est un multiple de $p$, on peut extraire $p$ (c’est-à-dire un facteur premier de $N$) avec une forte probabilité en calculant le plus grand commun diviseur $\gcd(|x_i - x_j|, N)$. En combinant cela avec l’algorithme de détection de cycle de Robert Floyd (algorithme du lièvre et de la tortue), le calcul se fait efficacement tout en maintenant l’utilisation de la mémoire à $\mathcal{O}(1)$.

Évaluation de la complexité

Il est connu que le nombre d’étapes nécessaires pour que l’algorithme $\rho$ de Pollard trouve un facteur premier $p$ est d’environ $\mathcal{O}(\sqrt{p})$. Dans le pire des cas (lorsque $N$ est le produit de deux nombres premiers $p, q$ de même taille, tel que $p \approx \sqrt{N}$), la complexité est de $\mathcal{O}(N^{1/4})$.

Exprimé avec la taille d’entrée $n = \log_2 N$ :

$$ N^{1/4} = (2^n)^{1/4} = 2^{n/4} $$

Par conséquent, la complexité est $\mathcal{O}(2^{n/4})$. Par rapport au $\mathcal{O}(2^{n/2})$ de la méthode des divisions successives, l’accélération est spectaculaire, et elle est très puissante en pratique pour factoriser des nombres de taille moyenne (plusieurs dizaines de chiffres). Cependant, elle ne parvient toujours pas à franchir la barrière du « temps exponentiel » par rapport à la longueur de bit $n$, la rendant impuissante face aux nombres gigantesques de 2048 bits (environ 600 chiffres décimaux) utilisés dans le chiffrement RSA.

4. Crible Quadratique à Polys Multiples (MPQS: Multiple Polynomial Quadratic Sieve)

Au début des années 1980, Carl Pomerance a inventé le « crible quadratique (Quadratic Sieve : QS) ». C’est une extension du concept de la « différence de carrés » de Fermat. Alors que la méthode de Fermat cherchait directement $x^2 - y^2 = N$, le crible quadratique recherche une condition beaucoup plus souple.

$$ x^2 \equiv y^2 \pmod N $$

$$ x \not\equiv \pm y \pmod N $$

Si l’on peut trouver une telle paire $x, y$, alors $x^2 - y^2 = (x - y)(x + y)$ est un multiple de $N$. Par conséquent, en calculant $\gcd(x - y, N)$ ou $\gcd(x + y, N)$, on peut obtenir un facteur premier non trivial de $N$.

Dans le crible quadratique, on trouve un grand nombre de $x$ tels que $x^2 \pmod N$ donne un « nombre n’ayant que de petits facteurs premiers (ce qu’on appelle un nombre $B$-friable) », et on dispose le résultat de leurs factorisations sous forme de matrice (un système d’équations linéaires sur le corps fini $\mathbb{F}_2$). Ensuite, on utilise l’élimination de Gauss ou des méthodes similaires pour multiplier plusieurs relations entre elles, afin d’ajuster le côté droit pour qu’il devienne un carré parfait (les exposants de chaque facteur premier deviennent pairs), construisant ainsi $x^2 \equiv y^2 \pmod N$.

Le crible quadratique fut l’algorithme le plus rapide au monde jusqu’à l’apparition du crible du corps de nombres généralisé, et il est toujours considéré comme le plus rapide pour factoriser des nombres de moins de 100 chiffres.

5. Examen approfondi du Crible du Corps de Nombres Généralisé (General Number Field Sieve : GNFS)

Actuellement, l’algorithme réputé « le plus rapide au monde » pour la factorisation de nombres entiers géants dépassant 100 chiffres est le crible du corps de nombres généralisé (GNFS). Conçu à la fin des années 1980, il s’agit d’un algorithme très sophistiqué qui prolonge le crible quadratique en utilisant des résultats profonds de la théorie algébrique des nombres (corps de nombres).

Dans les attaques contre le chiffrement RSA (factorisation à partir de la clé publique), c’est toujours ce GNFS qui bat les records mondiaux. En 2020, on a signalé le succès de la factorisation d’un nombre composé de 829 bits (250 chiffres) (RSA-250), mais cela a nécessité l’exécution en parallèle de milliers d’ordinateurs sur une longue période.

Structure mathématique de l’algorithme

Le GNFS est extrêmement complexe, mais il se déroule grossièrement selon les étapes suivantes.

Sélection du polynôme (Polynomial Selection): Pour $N$, on choisit un entier $m$ et un polynôme irréductible $f(X)$ avec de petits coefficients tel que $f(m) \equiv 0 \pmod N$. Cela définit l’anneau des entiers $\mathbb{Z}[\alpha]$ du corps algébrique (corps de nombres) obtenu en ajoutant la racine $\alpha$ de $f(X)$.
Criblage (Sieving): On recherche des nombres friables (Smooth) simultanément dans « deux mondes différents » : l’anneau des entiers rationnels $\mathbb{Z}$ et l’anneau des entiers algébriques $\mathbb{Z}[\alpha]$. Concrètement, on trouve un grand nombre de paires $(a, b)$ telles que la norme de l’entier rationnel $a - bm$ et de l’entier algébrique $a - b\alpha$ se factorisent complètement sur un ensemble de petits nombres premiers prédéfini (la base de facteurs : Factor Base).
Réduction de matrice (Matrix Reduction): On représente l’énorme quantité de paires friables trouvées sous forme de matrice (une gigantesque matrice creuse). On recherche l’espace des solutions sur le corps fini $\mathbb{F}_2$ à l’aide de l’algorithme de Lanczos (comme la méthode de Lanczos par blocs). Il n’est pas rare que cette matrice atteigne des millions de lignes sur des millions de colonnes.
Calcul de la racine carrée (Square Root): À partir de la solution de la matrice, on crée un carré parfait géant dans chacun des « deux mondes différents », pour finalement dériver la relation $X^2 \equiv Y^2 \pmod N$. Ensuite, on calcule $\gcd(X-Y, N)$ pour obtenir les facteurs premiers.

Complexité du crible du corps de nombres généralisé : Temps sous-exponentiel (Sub-exponential time)

La plus grande réalisation du GNFS est d’avoir réduit la complexité de la factorisation du « temps exponentiel pur » au « temps sous-exponentiel (Sub-exponential time) ». La complexité temporelle asymptotique du GNFS s’exprime à l’aide d’une notation spéciale appelée notation L (L-notation) :

$$ L_N[\gamma, c] = \exp\left( (c + o(1)) (\ln N)^\gamma (\ln \ln N)^{1-\gamma} \right) $$

Où $N$ est le nombre à factoriser et $\ln$ est le logarithme népérien. $\gamma$ est un paramètre compris entre $0 \le \gamma \le 1$ qui indique le « degré » de complexité de l’algorithme.

Lorsque $\gamma = 0$, $L_N[0, c]$ devient $(\ln N)^c$, ce qui signifie un temps polynomial $\mathcal{O}(n^c)$. (Efficace)
Lorsque $\gamma = 1$, $L_N[1, c]$ devient $e^{c \ln N} = N^c$, ce qui signifie un temps exponentiel $\mathcal{O}(2^{cn})$. (Inefficace)

Dans le cas du GNFS, ce paramètre est le suivant :

$$ L_N\left[\frac{1}{3}, \left(\frac{64}{9}\right)^{1/3}\right] = e^{\left(\sqrt[3]{\frac{64}{9}} + o(1)\right) (\ln N)^{1/3} (\ln \ln N)^{2/3}} $$

Dans cette équation, la constante $c = (64/9)^{1/3} \approx 1,923$. Si on la réécrit avec la taille de l’entrée $n \approx \ln N$ (proportionnelle à la longueur des bits), la complexité se comporte approximativement comme suit :

$$ \mathcal{O}\left( \exp\left( 1,923 \cdot n^{1/3} (\ln n)^{2/3} \right) \right) $$

On constate que la partie exponentielle ne dépend pas de $n$ à la puissance 1, mais de $n^{1/3}$ (la racine cubique de $n$). Alors que l’algorithme $\rho$ de Pollard était en $\mathcal{O}(2^{n/4})$, c’est-à-dire $\mathcal{O}(\exp(c \cdot n^1))$, le GNFS a fait chuter le degré de $n$ à $1/3$. Cela signifie que bien qu’on n’atteigne pas le temps polynomial ($\gamma=0$), la complexité croît beaucoup plus lentement que pour un temps exponentiel pur ($\gamma=1$). C’est la raison pour laquelle on l’appelle « temps sous-exponentiel ».

Limites de la cryptographie moderne et ordinateurs quantiques

Comme nous l’avons vu, l’humanité a mobilisé la sagesse mathématique pour repousser les limites de la factorisation en faisant évoluer les algorithmes, de la méthode des divisions successives au GNFS. Cependant, même avec le GNFS, la factorisation n’a toujours pas pu être résolue en « temps polynomial » sur des ordinateurs classiques.

Le problème P vs NP et la position de la factorisation en nombres premiers

L’un des plus grands problèmes non résolus de l’informatique est la « conjecture P = NP ». Le problème de la factorisation appartient à NP (la classe des problèmes dont la solution, si elle est donnée, peut être vérifiée en temps polynomial), mais il n’a pas été prouvé qu’il soit NP-complet (la classe des problèmes les plus difficiles dans NP). De plus, il n’est pas encore prouvé s’il appartient à P (la classe des problèmes solvables en temps polynomial), c’est-à-dire s’il existe un algorithme en temps polynomial pour le résoudre.

De nombreux chercheurs supposent que la factorisation appartient à une classe intermédiaire entre P et NP-complet (NP-intermédiaire). Si un algorithme résolvant la factorisation en temps polynomial sur un ordinateur classique (par exemple, $\mathcal{O}(n^3)$) venait à être découvert, ce serait un événement majeur qui ferait s’effondrer les systèmes cryptographiques du monde entier ; cependant, jusqu’à présent, aucun algorithme de ce type n’a été trouvé. Il est estimé que le déchiffrement d’une clé RSA de 2048 bits prendrait plus de temps que la durée de vie de l’univers, même si les performances des ordinateurs classiques continuaient à s’améliorer selon la loi de Moore.

L’ordinateur quantique, un « changeur de donne (Game Changer) » : l’algorithme de Shor

Alors que le chiffrement RSA est robuste face aux ordinateurs classiques, la situation changera radicalement avec la mise en pratique des « ordinateurs quantiques », qui fonctionnent sur des principes totalement différents. Publié en 1994 par Peter Shor, l’« algorithme de Shor (Shor’s algorithm) » est un algorithme capable de résoudre la factorisation en nombres premiers en temps polynomial $\mathcal{O}(n^3)$ (ou plus précisément, environ $\mathcal{O}(n^2 \log n \log \log n)$ en termes de portes quantiques), de manière stupéfiante, grâce à la transformée de Fourier quantique.

Voyons la différence de complexité entre les algorithmes classiques et quantiques dans le diagramme Mermaid suivant.

graph LR classDef classical fill:#f9f871,stroke:#333,stroke-width:2px; classDef quantum fill:#00c9a7,stroke:#333,stroke-width:2px; subgraph "Ordinateurs Classiques" C1["Divisions Successives : O(2^(n/2))"]:::classical C2["GNFS : Sous-exponentiel L_n(1/3)"]:::classical end subgraph "Ordinateurs Quantiques" Q1["Algorithme de Shor : O(n^3) Polynomial"]:::quantum end C1 --> C2 C2 -. "Limite de la Physique Classique" .-> Q1

Dans l’algorithme de Shor, le processus de « recherche de période », qui constituait un goulot d’étranglement dans les algorithmes classiques, est calculé en parallèle et en un instant grâce à l’intrication et à la superposition quantiques utilisant la « transformée de Fourier quantique (QFT) ». S’il devient possible de l’exécuter sur un ordinateur quantique de taille pratique (avec peu de bruit et un nombre suffisant de qubits logiques), la clé RSA de 2048 bits, actuellement considérée comme sûre, pourrait être complètement déchiffrée en quelques heures à quelques jours.

Pour se prémunir contre cette menace, les cryptographes du monde entier et le NIST (Institut national des normes et de la technologie aux États-Unis) accélèrent actuellement les travaux de normalisation pour la transition vers la « Cryptographie post-quantique (Post-Quantum Cryptography : PQC) », qui reste difficile à déchiffrer même pour les ordinateurs quantiques. La cryptographie fondée sur les réseaux euclidiens (Lattice-based cryptography) en est un exemple représentatif, sa sécurité reposant sur une difficulté mathématique totalement différente de celle de la factorisation (par exemple, le problème du vecteur le plus court).

Conclusion

Dans cet article, en partant des bases de la complexité algorithmique (notation Grand O), nous avons exploré en profondeur l’évolution des algorithmes de factorisation et leurs limites mathématiques.

La notation Grand O ($\mathcal{O}$) est un indicateur clé montrant le taux de croissance du nombre d’étapes de calcul par rapport à l’augmentation de la taille d’entrée $n$, et il existe un fossé infranchissable en pratique entre le temps polynomial et le temps exponentiel.
La méthode des divisions successives et l’algorithme $\rho$ de Pollard sont de purs algorithmes en « temps exponentiel », impuissants face aux nombres gigantesques.
Le crible du corps de nombres généralisé (GNFS), actuellement le plus rapide des algorithmes classiques, a atteint un temps « sous-exponentiel » en exploitant une théorie algébrique des nombres avancée, mais n’atteint toujours pas un temps polynomial, et la factorisation de nombres énormes prendrait un temps astronomique.
Le fait « qu’il n’existe pas (ou qu’on suppose fortement qu’il n’existe pas) d’algorithme classique résolvant ce problème en temps polynomial » est exactement ce qui garantit la sécurité du chiffrement RSA et soutient notre société numérique moderne.
Cependant, avec l’avènement de l’ordinateur quantique et de l’algorithme de Shor, la factorisation en temps polynomial devient théoriquement possible, et la technologie cryptographique s’apprête à entrer dans une nouvelle ère (la cryptographie post-quantique).

Le fait qu’un concept aussi abstrait que la complexité d’un algorithme soit directement lié à la sécurité de notre quotidien est l’un des aspects les plus fascinants et palpitants de l’informatique et des mathématiques. Nous vous invitons à rester attentifs aux futurs développements technologiques, en particulier à l’évolution des ordinateurs quantiques et aux transitions de la technologie cryptographique.