🔢 mathematics

GoldbachGPU: An Open Source GPU-Accelerated Framework for Verification of Goldbach's Conjecture

Le papier présente GoldbachGPU, un cadre open-source accéléré par GPU qui surmonte les limites de mémoire antérieures grâce à une représentation compacte des nombres premiers et une conception segmentée, permettant de vérifier exhaustivement la conjecture de Goldbach jusqu'à 10^12 sur une carte grand public et jusqu'à 10^10000 via des vérifications arbitraires, tout en assurant une scalabilité multi-GPU et une reproductibilité complète.

Auteurs originaux : Isaac Llorente-Saguer

Publié 2026-03-04

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Isaac Llorente-Saguer

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

🌟 Le Défi : La Devinette de Goldbach

Imaginez que vous avez une immense collection de nombres pairs (4, 6, 8, 10, etc.). La conjecture de Goldbach, posée il y a près de 300 ans, dit une chose très simple :

"Chaque nombre pair peut être obtenu en additionnant deux nombres premiers (des nombres qui ne sont divisibles que par 1 et eux-mêmes, comme 2, 3, 5, 7, 11...)."

Par exemple :

4 = 2 + 2
10 = 3 + 7
100 = 47 + 53

Le problème ? Personne n'a jamais pu prouver mathématiquement que c'est vrai pour tous les nombres, même les plus gigantesques. Les mathématiciens utilisent donc des ordinateurs pour vérifier un par un, comme on vérifierait chaque pièce d'un puzzle géant pour s'assurer qu'aucune ne manque.

🚀 La Solution : GoldbachGPU

L'auteur de l'article, Isaac Llorente-Saguer, a créé un outil appelé GoldbachGPU. C'est un programme gratuit (open-source) qui utilise la puissance des cartes graphiques (les GPU, comme celles des cartes vidéo de jeux vidéo) pour vérifier cette conjecture beaucoup plus vite que les ordinateurs classiques.

Mais il y avait un gros obstacle : la mémoire.

🧱 Le Problème du "Mur de Mémoire"

Imaginez que vous voulez vérifier tous les nombres jusqu'à un milliard. Pour faire cela, votre ordinateur doit garder une liste de tous les nombres premiers en mémoire vive (la RAM).

Avec les anciennes méthodes, cette liste était comme un livre géant écrit sur des pages entières. Pour les très grands nombres, ce livre devenait si gros qu'il ne tenait plus dans la mémoire de l'ordinateur (la "VRAM" de la carte graphique). C'était comme essayer de ranger une bibliothèque entière dans une boîte à chaussures.
Résultat : Les vérificateurs précédents s'arrêtaient net vers $10^{11}$ (100 milliards) parce qu'ils manquaient de place.

💡 L'Innovation : Le "Tetris" Numérique

L'auteur a eu deux idées brillantes pour résoudre ce problème :

Le "Packaging" Dense (La compression) :
Au lieu d'écrire chaque nombre premier sur une page entière (ce qui prend beaucoup de place), il a inventé une méthode pour les écrire en bits (des 0 et des 1 très compacts).
- L'analogie : Imaginez que vous devez ranger 16 chaises. La méthode ancienne prend 16 mètres carrés. La méthode GoldbachGPU prend juste 1 mètre carré en empilant les chaises les unes sur les autres. Cela réduit la taille de la mémoire nécessaire par 16 fois !
L'Approche "Segmentée" (Le convoyeur) :
Au lieu d'essayer de charger tous les nombres premiers d'un coup (ce qui est impossible pour les très grands nombres), le programme découpe le travail en petits morceaux.
- L'analogie : Imaginez un convoyeur de bagages dans un aéroport. Au lieu d'essayer de mettre tous les bagages du monde sur le tapis en même temps, on les met par petits lots. Le programme vérifie un petit lot de nombres, vide la mémoire, charge le lot suivant, et ainsi de suite.
- Grâce à cette astuce, la mémoire utilisée reste constante (comme une petite boîte de 14 Mo), peu importe si on vérifie jusqu'à 100 milliards ou 1 000 milliards.

⚡ Les Résultats : Une Vitesse Éclair

Grâce à ces astuces, l'auteur a pu faire tourner son programme sur une simple carte graphique de gamer (une NVIDIA RTX 3070, qu'on peut acheter dans le commerce) et vérifier tous les nombres pairs jusqu'à 1 000 000 000 000 (1 billion).

Le verdict : Aucun contre-exemple n'a été trouvé. La conjecture est toujours vraie !
La vitesse : Le programme est environ 16 fois plus rapide qu'un ordinateur classique pour les grandes tailles.
La sécurité : Le programme a un "plan B" (un vérificateur sur le processeur principal) pour s'assurer que rien n'a été raté, mais ce plan B n'a jamais eu besoin d'être utilisé.

🧮 Et pour les nombres gigantesques ?

L'article mentionne aussi un outil spécial pour vérifier des nombres individuels incroyablement grands (avec des milliers de chiffres, bien au-delà de ce que l'ordinateur peut compter normalement). C'est comme vérifier une seule pièce d'un puzzle qui mesure plusieurs kilomètres de long. L'outil a réussi à vérifier des nombres avec 10 000 chiffres en quelques minutes.

🏁 Conclusion Simple

En résumé, GoldbachGPU a prouvé que le "mur de mémoire" qui bloquait les vérifications précédentes n'était pas une limite fondamentale de la physique, mais juste une mauvaise organisation des données.

En réorganisant intelligemment la façon dont les nombres sont stockés et vérifiés, un simple ordinateur de bureau peut maintenant faire le travail de supercalculateurs complexes. C'est une victoire de l'ingéniosité logicielle : pas besoin d'avoir le plus gros ordinateur du monde, il suffit d'avoir la meilleure méthode.

Et tant que la conjecture de Goldbach résiste, elle continue de défier les mathématiciens, mais grâce à ce travail, nous savons qu'elle est vraie jusqu'à un chiffre qui dépasse l'entendement humain !

1. Problématique

La conjecture de Goldbach, énoncée en 1742, postule que tout entier pair supérieur à 2 peut s'écrire comme la somme de deux nombres premiers. Bien que théoriquement non prouvée, elle a été vérifiée par ordinateur jusqu'à $4 \times 10^{18}$ grâce à des calculs distribués massifs (Oliveira e Silva et al.).

Cependant, la vérification sur du matériel grand public (commodity hardware) reste limitée. Les approches précédentes basées sur les GPU (GPGPU) se heurtaient à un plafond mémoire VRAM (mémoire vidéo) strict, généralement autour de $10^{11}$ . La nécessité de stocker une table de nombres premiers monolithique en VRAM rendait l'extension au-delà de cette limite impossible sur des cartes graphiques grand public (ex: 8 Go de VRAM), en raison de l'épuisement de la mémoire et de la divergence des threads.

2. Méthodologie

L'auteur, Isaac Llorente-Saguer, propose GoldbachGPU, un framework open-source conçu pour surmonter ces limitations architecturales. La solution repose sur cinq outils de vérification complémentaires, allant d'une base CPU à une vérification de précision arbitraire :

A. Représentation Dense (Bitset)

Pour réduire l'empreinte mémoire, l'article utilise une représentation compacte des nombres premiers.

Technique : Les entiers pairs (sauf 2) sont exclus. Pour les entiers impairs, un bit par nombre est utilisé dans un tableau de mots de 64 bits.
Gain : Cela permet une réduction de la mémoire d'un facteur 16 par rapport à une représentation par tableau d'octets.
Impact : Une table jusqu'à $10^{11}$ ne nécessite que ~6 Go de VRAM (faisable sur une RTX 3070), contre ~95 Go pour une approche par octets.

B. Architecture à Double Tamis Segmenté (Segmented Double-Sieve)

C'est la contribution centrale pour dépasser la limite de VRAM. Au lieu de stocker une table globale, le système découpe le problème en segments.

Inversion de la boucle : Inspiré de la méthode d'Oliveira e Silva, au lieu d'itérer sur les nombres pairs $n$ pour trouver un premier $p$ , le système itère sur les candidats premiers $p$ et marque les nombres pairs $n = p + q$ où $q$ est premier.
Oracles de primalité à trois niveaux : Pour vérifier si $q = n - p$ $q = n - p$ est premier, le noyau GPU utilise une hiérarchie de priorité :
1. Petits premiers ( $q \le P_{SMALL}$ ) : Recherche dans un petit bitset permanent (~122 Ko) résidant en L2 Cache.
2. Segment actuel ( $q \in [A, B]$ ) : Recherche dans le bitset du segment courant (~14 Mo) chargé en VRAM.
3. Zone de transition ( $P_{SMALL} < q < A$ ) : Test de primalité déterministe de Miller-Rabin (64 bits).
Complexité : Cette approche maintient l'utilisation de la VRAM constante ( $O(1)$ ) quel que soit $N$ , tandis que le temps d'exécution reste linéaire ( $O(N)$ ).

C. Vérification de Précision Arbitraire (Arbitrary Precision)

Pour les nombres au-delà de la limite 64 bits, un outil (big check) utilise la bibliothèque GMP (GNU Multiple Precision) avec une stratégie de recherche par lots synchronisée (batch-search) pour éviter les déséquilibres de charge entre les threads OpenMP.

3. Contributions Clés

Élimination du plafond VRAM : L'architecture segmentée permet une vérification exhaustive jusqu'à $10^{12}$ sur une seule carte graphique grand public (NVIDIA RTX 3070, 8 Go), là où les approches précédentes échouaient vers $10^{11}$ .
Réduction mémoire 16x : L'utilisation d'un bitset dense rend possible le stockage de tables de premiers jusqu'à $10^{11}$ en VRAM.
Garantie de correction mathématique : Un mécanisme de repli (fallback) rigoureux sur CPU est intégré. Bien qu'il n'ait jamais été invoqué dans les expériences, il garantit la complétude mathématique si le nombre minimal de Goldbach dépassait les prédictions théoriques.
Vérification à très haute précision : Extension de la vérification de nombres individuels jusqu'à $10^{10\,000}$ (10 001 chiffres).
Implémentation Open Source : Le code est documenté, reproductible et fonctionne sur du matériel grand public et des infrastructures de centres de données.

4. Résultats Expérimentaux

Les tests ont été réalisés sur un Intel i7-12700H et une NVIDIA RTX 3070 (8 Go).

Vérification jusqu'à $10^{12}$ :
- Le framework goldbach_gpu3 a vérifié exhaustivement tous les entiers pairs jusqu'à $10^{12}$ en ~41 minutes.
- Aucun contre-exemple n'a été trouvé.
- Le taux de succès de la "Phase 1" (GPU seul) était de 100 %, confirmant empiriquement que le plus petit premier de Goldbach $p_{min}(n)$ est inférieur à $2 \times 10^6$ pour tout $n \le 10^{12}$ , ce qui est cohérent avec les prédictions théoriques ( $H(10^{12}) \approx 2000$ ).
Performance et Échelle :
- Accélération : Par rapport à la base CPU, une accélération de 16x est observée à $10^9$ et 12x à $10^{10}$ .
- Mise à l'échelle Multi-GPU : Sur un système de 6x RTX 3090, l'efficacité de parallélisation atteint 91 % à 4 GPU. Sur des GPU de centre de données (H100), les temps sont comparables aux RTX 3090 pour $N=10^{10}$ (car la partie CPU est le goulot d'étranglement), mais montrent un avantage pour $N \ge 10^{11}$ .
- Précision Arbitraire : La vérification d'un nombre de 10 001 chiffres ( $10^{10\,000}$ ) a été réalisée en 182 secondes sur 20 threads.

5. Signification et Perspectives

Ce travail démontre que la limitation de la vérification de Goldbach sur GPU n'est pas fondamentale, mais architecturale. En passant d'une allocation monolithique à une approche segmentée et dense, il est possible d'exploiter pleinement la puissance des GPU grand public pour des calculs mathématiques à grande échelle.

Impact : Cela rend la vérification de conjectures mathématiques complexes accessible sans infrastructure de supercalculateur distribuée.
Limites actuelles : Le goulot d'étranglement principal reste la génération de la table de nombres premiers sur le CPU (tamis segmenté) avant le transfert vers le GPU.
Travaux futurs : L'auteur suggère d'adapter la méthode de "marquage par lots" (bitwise bulk-marking) d'Oliveira e Silva directement sur GPU pour atteindre une complexité $O(N \log \log N)$ et éliminer les tests de Miller-Rabin, ce qui pourrait permettre d'atteindre $10^{15}$ sur un seul GPU.

En conclusion, GoldbachGPU établit un nouvel état de l'art pour la vérification de la conjecture de Goldbach sur du matériel grand public, prouvant l'efficacité des architectures GPU segmentées pour les problèmes de théorie des nombres.