Bonjour à tous,
Je vous remercie pour l’intérêt que vous portez à ce sujet.
Comme promis, je mets à disposition les deux versions modifiées des deux programmes Goldbach (Python et C++) du crible modulo 30 que j’ai construit en 2010 pour étudier la conjecture de Goldbach.
Puis en 2018 avec l'aide de notre bienfaiteur et modérateur Yoshi , qui m'a refait les programmes python , qui m'ont permis de les retranscrire en c++ ; dont je met la dernière version ci-dessous modifié et optimisé par chatGPT ce jour .
Ce crible permet d’analyser les entiers premiers dans une classe modulo 30 (1, 7, 11, 13, 17, 19, 23, 29), et de déterminer pour chaque valeur paire $2n$ si elle peut être exprimée comme une somme $p' + q$ où $p'$ et $q$ sont des nombres premiers dans une même famille modulo 30, , ou deux ; car $q$ le complémentaire de $p' \leqslant {n}$ par rapport à $2n$ , n'est pas obligatoirement de la même famille que $p'$ ; mais, où $p'$ n’est pas congru à $2n$ modulo 30, ce qui garantie , que son complémentaire $q$ est un nombre premier compris entre $n$ et $2n$
le choix de la famille , dépend de la valeur $n$ début un exemple ci dessous , qui est aussi expliqué dans le fichier joins par le lien suivant
à durée limité jusqu'au 20.06.2025.
pour la valeur n = N de début :
N= 15k+1; Fam =(1,13,19); ⇒ 2n = 30k + 2 ⇒ 32 – 19 = 13 , ou 32 – 1 = 31 ⇒ la Fam complémentaire
N = 15k+2; Fam =(11,17,23); ⇒ 2n = 30k + 4 ⇒ 34 – 11 = 23 , ou 34 – 17 = 17
N = 15k+3; Fam =(7,29,13,23,17,19); 2n = 30k + 6
N = 15k+4; Fam =(1,7,19); 2n = 30k + 8
N = 15k+5; Fam =(1,7,13,19); 2n = 30k + 10
N = 15k+6; Fam =(1,11,13,19,23,29); 2n = 30k + 12
N = 15k+7; Fam =(1,7,13); 2n = 30k + 14
N = 15k+8; Fam =(17,23,29); 2n = 30k + 16
N = 15k+ 9; Fam =(1,7,11,17,19,29); 2n = 30k + 18
N = 15k+10; Fam =(11,29,17,23); 2n = 30k + 20
N = 15k+11; Fam =(11,23,29); 2n = 30k + 22
N = 15k+ 12; Fam =(1,7,11,13,17,23); 2n = 30k + 24
N = 15k+ 13; Fam =(7,13,19); 2n = 30k + 26
N = 15k+ 14; Fam =(11,17,29); 2n = 30k + 28
Je reste bien entendu à disposition si un mathématicien souhaite analyser ce fonctionnement ou l’approfondir. pour de grande valeur de
début n > 3*10¹⁹
j'ai testé 2n > 3*10²² , que l'on peut incrémenté modulo 15 en saisissant :valeur début n et fin =valeur début +300 , l'algorithme effectuera le nombre de décomposition de $2n$successivement modulo 15 , ""ou par pas de 15"" , par famille choisit en conséquence .
Merci encore à la communauté BiBmath pour son aide précieuse.
voici le nouveau programme en c++
#include <cstdint>
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef unsigned long long ulonglong;
void fill_crible(vector<unsigned> &crible, unsigned p)
{
crible.resize((p - 1) / 64 + 1);
unsigned cs = crible.size();
unsigned lastnum = 64 * cs;
unsigned lastsieve = int(std::sqrt(double(lastnum)));
unsigned primesieved = 1;
crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
for (unsigned i = 1; i < cs; ++i)
crible[i] = 0xffffffff;
for (; primesieved <= lastsieve; primesieved += 2)
{
// find next prime
unsigned pos = primesieved / 2;
for (; pos < cs; pos++)
{
if (crible[pos / 32] & (1 << (pos % 32)))
break;
}
// set mutiples of (2*pos+1) to false
primesieved = 2 * pos + 1;
unsigned n = 3 * primesieved;
for (; n < lastnum; n += 2 * primesieved)
{
pos = (n - 1) / 2;
crible[(pos / 32)] &= ~(1 << (pos % 32));
}
}
}
unsigned nextprime(vector<unsigned> &crible, unsigned p)
{
// assumes crible has been filled
++p;
if (p % 2 == 0)
++p;
unsigned pos = (p - 1) / 2, cs = crible.size() * 32;
if (2 * cs + 1 <= p)
return -1;
for (; pos < cs; ++pos)
{
if (crible[pos / 32] & (1 << (pos % 32)))
{
pos = 2 * pos + 1;
// if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
return pos;
}
}
return -1;
}
size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau d'entier A modulo 30 représenté par des 1 et rappeler les premiers p
int cl = clock();
// size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
//vector<bool> crible(lencrible, true); // on rappelle les nombres premiers p d'Eratotene ci dessus
// ulonglong n2=2*n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong produit;
int GM[] = {7, 11, 13, 17, 19, 23, 29, 31}; // on va calculer le produit de p par un element du groupe GM
for (size_t j = 0; j < sizeof(GM) / sizeof(int); j++)
{
produit = p * GM[j]; // calcul du produit, jusqu'a ce que le produit soit égale à fam modulo 30
if (produit % 30 == fam)
{
produit /= 30; // puis on va va calculer l'indice, afin de commencer à cribler de l'indice à n/30 et on réitère
break;
}
}
indices[i] = produit;
}
ulonglong nslices = lencrible / 30000000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += crible[index]; // (0 ou 1)
cout << " Nbr p' criblés Fam " << fam << " < à sqrt " << n << " : " << total << " time " << double(clock() - cl) / CLOCKS_PER_SEC
<< endl;
return total; // à la fin du crible on return le résultat est le temps mis
}
size_t GCrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{
int cl = clock();
//size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on utilise le tableau des A mod 30 représenter par des 1, criblé par Ératosthène ci dessus
//vector<bool> crible(lencrible, true); //on rappelle le tableau criblés d'Eratotene ci dessus avec ses nombres premiers p
ulonglong n2 = 2 * n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong reste = n2 % p; // on calcule le reste r de 2n par p
if (reste % 2 == 0)
reste += p;
ulonglong pi2 = 2 * p;
while (reste % 30 != fam) // tant que le reste += p n'est pas = à Fam % 30 on rajoute 2*p
reste += pi2;
reste /= 30; // ensuite on va calculer l'indice pour commencer à cribler le tableau de 1.1.1.... avec p, de l'indice à n/30
indices[i] = reste;
}
ulonglong nslices = lencrible / 30000000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]); // le criblage du tableau de 1 modulo 30 jusqu'a n/30 (1.1.1.1...etc) est fini on va retourner le résultat
cout << " ; Nbr p' = criblés =(couple p+q=2n) Fam " << fam << " : " << total << " time " << double(clock() - cl) / CLOCKS_PER_SEC
<< endl;
return total;
}
int main(int argc, char **argv)
{
//if (limite > 9220000000000000000ULL) { ; cout << "WARNING: this program uses uint64_t arithmetic.\n";
//cout << "For n > 9.22e18, the computation of 2*n overflows and results are invalid.\n";
vector<unsigned> temp; //on entre le début de lalimite n à cribler et la fin augmenté de 15 ,pour cribler jusqu'à la limite n ou sa SQRT ligne 186
ulonglong debut = 9000000000000000000ULL;
ulonglong fin = 9000000000000000015ULL;
vector<int> familles;
//familles.push_back(1);
//familles.push_back(7);
//familles.push_back(11);
//familles.push_back(13);
familles.push_back(17);
//familles.push_back(19);
//familles.push_back(23);
//familles.push_back(29);
for (int i = 0; i < familles.size(); i++)
{
int fam = familles[i];
for (ulonglong limite = debut; limite < fin; limite += 15){
cout << "--> limite : " << limite << endl;
double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
fill_crible(temp, sqrt2N);
vector<ulonglong> premiers;
for (ulonglong p = 7; p <= sqrt2N;)
{
premiers.push_back(p);
p = nextprime(temp, p);
if (p == unsigned(-1))
break;
//cout << p << endl;
}
size_t lencrible = (sqrt(sqrt(limite))) / 30; // attention on crible les p'non congrus 2N[P] < ou = sqrt(sqrt(limite))/30 ; ou jusqu'à
//size_t lencrible = sqrt(limite)/30; // ou simplement size t lencrible = limite/30 pour cribler tous les p' de Ecrible par famille
vector<bool> crible(lencrible, true);
ECrible(premiers, limite, fam, crible, lencrible);
GCrible(premiers, limite, fam, crible, lencrible);
}
}
}
en c++ dans le programme on sélectionne toujours la famille modulo 30 compatible avec la valeur $n$ début , tel que 2n - fam i ne soit pas un multiple de 3 ou de 5.
exemple , pour n multiple de 30 les 8 famille sont compatibles mais si n = 30 001 , donc 2n = 60 002 seul 3 familles 1 sont compatibles, la famille i =1 ,13 ou 19.... etc ...cela est expliqué dans le pdf joint plus haut
------------------------
le nouveau programme en Python
import math
import time
from time import perf_counter
# Étape 1 : Génération des nombres premiers jusqu'à sqrt(2n)
def candidats(n):
n1 = 2 * n
limit = int(math.isqrt(n1))
length = limit // 3
if n % 3 == 0 or (n % 3 == 1 and n % 6 != 1):
length -= 1
flags = [True] * length
number = 1
addition = 4
toggle = 6
for indexe in range(length):
number += addition
addition = toggle - addition
if not flags[indexe]:
continue
start = (number * number * 2 - 5) // 6
if start >= length:
break
step = 2 * number
flags[start::step] = [False] * ((length - start + step - 1) // step)
advance = (indexe + 2) // 2
start += number - 2 * advance + (indexe % 2) * 4 * advance
flags[start::step] = [False] * ((length - start + step - 1) // step)
print(f"{sum(flags)-1} nombres premiers P >5 dans l'intervalle [1, sqrt{2*n}")
premiers = [2, 3] + [i // 2 * 6 + 5 + i % 2 * 2 for i in range(length) if flags[i]]
return premiers[3:] # On exclut 2, 3 et 5 pour se limiter aux familles mod 30
# Étape 2 : Criblage selon la famille modulo 30 (Eratosthène)
def E_Crible(premiers, n, fam):
n1 = math.isqrt(n)
n2 = math.isqrt(n1)
lencrible = n2 // 30
crible = bytearray(b"\x01") * lencrible
GM = [7, 11, 13, 17, 19, 23, 29, 31] # comme ton code
# mapping résidu -> valeur GM correspondante
resid_to_b = { (b % 30): b for b in GM } # 31%30 -> 1
for a in premiers:
am = a % 30
inv = pow(am, -1, 30) # inverse mod 30 (a>5)
bm = (fam * inv) % 30 # résidu requis pour b mod 30
b = resid_to_b.get(bm)
if b is None:
continue
j = a * b
index = j // 30
if index >= lencrible:
continue
for idx in range(index, lencrible, a):
crible[idx] = 0
total = sum(crible)
print(f"[E] Nombre de p' éligibles dans [1,(√(n))//30] famille {fam} : {total}")
return crible, lencrible
# Étape 3 : Criblage Goldbach sur les p' à l'aide des r = 2n mod P
def GCrible_2n(premiers, crible, lencrible, n, fam):
n2 = 2 * n
for p in premiers:
reste = n2 % p
if reste % 2 == 0:
reste += p
p2 = 2 * p
while reste % 30 != fam:
reste += p2
index = reste // 30
if index >= lencrible:
continue
# ✅ optimisation: marquage rapide au lieu de boucle Python
count = ((lencrible - 1 - index) // p) + 1
if count <= 32: # seuil à tester (16/32/64)
for idx in range(index, lencrible, p):
crible[idx] = 0
else:
crible[index::p] = b"\x00" * count
total = sum(crible)
print(f"[G] Nombre de p' non congrus à 2n mod P : {total} → couples p'+q = 2n")
# Interface utilisateur
def demander_valeurs():
n = int(input("Donnez n: ").strip())
while True:
try:
fam = int(input("Choisissez la famille mod 30 (1, 7, 11, 13, 17, 19, 23, 29): ").strip())
if fam in {1, 7, 11, 13, 17, 19, 23, 29}:
break
else:
print("❌ Famille invalide. Choisissez une valeur dans {1,7,11,13,17,19,23,29}.")
except ValueError:
print("❌ Entrez un entier valide.")
return n, fam
def main():
n, fam = demander_valeurs()
t0 = perf_counter()
premiers = candidats(n)
#print(f"[1] Premiers dans [1, √(2n)] : {len(premiers)}")
crible, lencrible = E_Crible(premiers, n, fam)
GCrible_2n(premiers, crible, lencrible, n, fam)
print(f"⏱️ Temps total : {round(perf_counter() - t0, 3)} secondes")
if __name__ == "__main__":
main()
Proposition (Stabilité des solutions de Goldbach dans une famille modulo 30 lorsque la limite du crible progresse modulo 15 par Famille fixée, on définit $A\leq{n}$ , un entier naturel positif premiers p' ou pas, que l'on va cribler...d'abord par Ecrible qui élimine les $A\neq{p'}$ et ensuite par Gcrible , qui élimine les $p'\equiv{2nk}[p]$.)
Soit une famille fixée $Ff={p′∈N∣p′≡f\,mod30}$, où $f∈{1,7,11,13,17,19,23,29}$ est un résidu premier $modulo\; 30$.
On fixe un entier $n0$ assez grand et on considère les entiers pairs successifs de la forme
$2nk=2n0+30k$,avec $k∈N$.
On définit $Sf(nk)$ comme le nombre de décompositions de $2nk$ en une somme
$2nk=p′+q$,
avec $p′∈Ff $ et $q$ premier, sous réserve que $p′≤nk$ et que $p′$ et $q=2nk−p′ $ soient tous deux premiers, ce qui implique par conséquent $p'\not\equiv{2nk}[p]$
Alors, le crible appliqué à $Ff$ (d'abord par élimination des multiples de petits premiers $p≤2n0$ , puis par exclusion des $p′$ tels que $2nk≡p′modp)$ garantit la propriété suivante:
Si $Sf(n0)>0$, alors $Sf(nk)≥Sf(n0)$ pour tout $k≥1$.
Autrement dit, le nombre de solutions dans une famille modulo 30 ne peut pas décroître jusqu'à zéro , quand on fait croître $2n$ de $30$ en $30$ dans cette famille pour toute famille fixée et pour une limite $n\geq{150}$.
Cette propriété repose sur un fait crucial du crible : le décalage congruent $2nk↦2nk+1$ entraîne un simple décalage cyclique d'un rang des positions exclues $(modulo p)$, mais ne détruit pas d’informations afin de conserver l'égalité récurrente (2n – A) ⇔ (2n +30) – (A + 30) ,
équivalent à (A+30)$\not\equiv$(2N+30) [P] — les entiers non éliminés à l’étape précédente sont "réinjectés" aux mêmes intervalles.
? Conséquence heuristique forte :
Cette récurrence implicite induite par la structure du crible permet d’affirmer que pour toute famille valide $\;modulo\; 30$ et tout $n0$ fixé avec $Sf(n0)>0$, on a :
$v$ la conjecture de Goldbach.$∀k≥0,2nk=2n0+30k$ vérifie la conjecture de Goldbach.
Et donc, il devient impossible de rencontrer un entier pair $2n$ sans décomposition, dans la progression $2n0+30k$, pour une famille fixée.
Par conséquent, on peut affirmer : que $p'$ et $q$ premiers ne sont pas indépendant l'un de l'autre , car $q$ dépend de la congruence de $p'$ ainsi , la probabilité que :
$p'\not\equiv{2n}[P]$ ce qui implique $2n = p' + q$ vaut environ $\frac{1}{Ln\,n \,* \,Ln\,2n}$ ; d'où le nombre minimum de couples $(p' + q)$ par famille , vaut environ au minimum : ($\frac{n}{Ln\,n\,*\,Ln\,2n}$) / 8.
Car dans le cas contraire , cela implique qu'aucun entier $A\not\equiv{2nk}[p]$ ne précédait aucun $p'$ au rang $n-1; n-2; n-3 ...n-k$ lors des limites précédente $ n-1 ; n-2 ; n-3 ...n-k$ ce qui est contraire aux limites $n$ vérifiées précédemment , par l'algorithme de Goldbach.
Ce qui rend impossible la supposition que $2n + 2$ ou $2n + 30$ ne se décomposerait pas en une somme de deux nombres premiers.
Dernière version utilisant les _uint128_t pouvant tester des limites n = ou > 9*10¹⁸, en limitant les $p'<\sqrt{n}$ du crible Ératosthène , en peu de temps; avec le concourt aimable de l’équipe [chatGPT]
#include <iostream>
#include <vector>
#include <cmath>
#include <thread>
#include <cstdlib>
#include <mutex>
#include <ctime>
using namespace std;
typedef __uint128_t u128;
typedef unsigned long long u64;
mutex output_mutex;
void fill_crible(vector<unsigned> &crible, unsigned pmax) {
crible.resize((pmax - 1) / 64 + 1, 0xffffffff);
crible[0] &= ~1;
unsigned limit = sqrt(pmax);
for (unsigned i = 3; i <= limit; i += 2) {
if (crible[i / 64] & (1 << ((i / 2) % 32))) {
for (unsigned j = i * i; j < pmax; j += 2 * i) {
crible[j / 64] &= ~(1 << ((j / 2) % 32));
}
}
}
}
unsigned nextprime(const vector<unsigned> &crible, unsigned p) {
if (p <= 2) return 3;
for (unsigned i = p + 2; i < crible.size() * 64 * 2; i += 2) {
if (crible[i / 64] & (1 << ((i / 2) % 32))) return i;
}
return -1;
}
size_t ECrible(const vector<u64> &premiers, u128 n, int fam, vector<uint8_t> &crible) {
size_t len = crible.size();
vector<u64> indices(premiers.size());
int GM[] = {7, 11, 13, 17, 19, 23, 29, 31};
for (size_t i = 0; i < premiers.size(); ++i) {
u64 p = premiers[i];
for (int g : GM) {
u64 prod = p * g;
if (prod % 30 == static_cast<u64>(fam)) {
indices[i] = prod / 30;
break;
}
}
}
for (size_t i = 0; i < premiers.size(); ++i) {
u64 p = premiers[i];
for (size_t j = indices[i]; j < len; j += p) {
crible[j] = 0;
}
}
size_t total = 0;
for (uint8_t c : crible) total += c;
return total;
}
size_t GCrible(const vector<u64> &premiers, u128 n, int fam, vector<uint8_t> &crible) {
size_t len = crible.size();
u128 n2 = 2 * n;
vector<u64> indices(premiers.size());
for (size_t i = 0; i < premiers.size(); ++i) {
u64 p = premiers[i];
u64 r = static_cast<u64>(n2 % p);
if (r % 2 == 0) r += p;
u64 pi2 = 2 * p;
while (r % 30 != static_cast<u64>(fam)) r += pi2;
indices[i] = r / 30;
}
for (size_t i = 0; i < premiers.size(); ++i) {
u64 p = premiers[i];
for (size_t j = indices[i]; j < len; j += p) {
crible[j] = 0;
}
}
size_t total = 0;
for (uint8_t c : crible) total += c;
return total;
}
void traiter_famille(u128 n, int fam, const vector<u64> &premiers) {
clock_t start = clock();
cout << "Durée : " << (clock() - start) * 1e-6 << " s" << endl;
size_t lencrible = static_cast<size_t>(sqrt((long double)n)) / 30;
vector<uint8_t> crible(lencrible, 1);
ECrible(premiers, n, fam, crible);
size_t total = GCrible(premiers, n, fam, crible);
lock_guard<mutex> lock(output_mutex);
cout << "Famille " << fam << " pour n = ";
cout << (u64)(n / 1000000000000000000ULL) << "e18 : ";
cout << total << " p′ vérifiant conject (temps = " << (clock() - start) * 1e-6 << " s)" << endl;
}
int main() {
u128 debut = 1000000000000000020ULL;
u128 fin = debut + 45; // augmente la limite n par pas de 15
for (u128 n = debut; n < fin; n += 15) {
cout << "\n=== n = " << (u64)(n / 1000000000000000000ULL) << "e18 ===\n";
double sqrt2N = sqrt((long double)(2 * n));
vector<unsigned> temp;
fill_crible(temp, static_cast<unsigned>(sqrt2N));
vector<u64> premiers;
for (unsigned p = 7; p <= static_cast<unsigned>(sqrt2N); ) {
premiers.push_back(p);
p = nextprime(temp, p);
if (p == static_cast<unsigned>(-1)) break;
}
vector<thread> threads;
for (int fam : {7,1,13,19}) {
threads.emplace_back(traiter_famille, n, fam, cref(premiers));
}
for (auto &t : threads) t.join();
}
return 0;
}
programme C++ et python légèrement modifié , pour ne cribler que les nombres premiers p' < (sqrt (sqrt N)) / 30
pour une limite N = 3* 10¹⁹ pour python et 9*10
18 pour C++
https://www.dropbox.com/scl/fi/rmxz9boda1t60dptkhjjn/goldbach_reformulation.3.pdf?rlkey=xidyeh12wbd1rsjlr8ashhz84&st=4tcu797o&dl=0
https://www.dropbox.com/scl/fi/vrvgkov1o8jfwgm9z02y7/simulation-780.pdf?rlkey=cav1li7ob3z3gjretnbov8po1&st=kipdd27e&dl=0
Bien cordialement,
Gilbert