Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

Répondre

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
soixante quinze moins trente huit
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Retour

Résumé de la discussion (messages les plus récents en premier)

LEG
27-11-2022 04:29:29

Bonjour @yoshi , je reviens sur ton message:

yoshi a écrit :

Il y a plus simple...
@+

Programme Python (fam 1 modulo 2 ) [Ératosthène et Goldbach unifié]:
Attention j’ai repris: l’algorithme par famille 30k + i ; modulo 30 pour le transformer en crible modulo 2 , afin de l’utiliser dans les entiers A impairs de premier terme 1 en progression arithmétique de raison 2 , uniquement pour les petite valeurs afin d’illustrer les commentaires ci-dessus.


 from time import time
from os import system

def candidate_range(n):
    cur = 5
    incr = 2
    while cur < n+1:
        yield cur
        cur += incr
        incr ^= 6  # or incr = 6-incr, or however

def eratostene(n):
    n = int((2*n)**0.5)  ##(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
    prime_E =[3]
    sieve_list = [True for _ in range(n+1)] ## c'est plus propre comme ça
    for each_number in candidate_range(n):
        if sieve_list[each_number]:
            prime_E.append(each_number)
            for multiple in range(each_number*each_number, n+1, each_number):
                sieve_list[multiple] = False
    print(prime_E[0:])
    return prime_E[0:]  

def E_Crible(premiers, n, fam):
    start_crible = time()
   
    # On génère un tableau de N/2 cases rempli de 1
    lencrible = ((n//2)*1)
    crible=[1 for _ in range(lencrible)] ## c'est plus propre comme ça
    GM = [3,5,7,11,13,17,19,23,29,31]   ## attention GM > 5 est utilisé pour l'algorithme modulo 30 par fam 30k + i
    # On calcule les produits :
    for a in premiers:
        for b in GM:
            j = a * b
            if j%2 == fam:
                index = j // 2  ## Je calcule l'index n° indice et On crible directement à partir du n° indice
                for idx in range(index, lencrible, a):  ## index qui est réutilisé ici...
                    crible[idx] = 0
                   
    total = sum(crible)-1
    print("crible Ératosthène :", crible)  ## pour éditer le tableau Ératosthène criblé
    print(f"Nombre premiers criblés >2, famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")
    return crible,lencrible
 
def GCrible_2N(premiers, crible, lencrible, n, fam):
    start_crible = time()
    # On calcule les restes: R = 2*n modulo P
    nbpremiers = len(premiers)
    n2 = 2*n
    for premier in premiers:
        reste = n2 % premier
        print(reste)
        if reste % 2 == 0:
            reste += premier
        pi2 = 2*premier
       ## tant que reste % 2 != fam on fait reste += pi2 , pi = P(int((2*n)**0.5))
        while reste % 2 != fam:
            reste += pi2
        ## Ensuite on divise reste par 2 pour obtenir l'index
        reste //= 2
        ## On crible directement à partir de l'index
        for index in range(reste, lencrible, premier):
            crible[index] = 0

    total = sum(crible)-1  ## car 1 n'est pas premier donc il n'est pas un couple p'+ q
    print("crible É ET G:", crible) ## éditer le tableau criblé É et G
    print(f"Nombres p' non congru 2n[P] ou couple P'+q = 2N, de (i) à {n} famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")

def demander_N():
    n = input("Donnez N: ")
    n = int(n.strip().replace(" ", ""))
    #n = int(30 * round(float(n)/30))
    return n

def main():
    ## On demande N a l'utilisateur
    n = demander_N()
    ## On récupère les premiers de 7 à √2N
    premiers = eratostene(n)
    start_time = time()
    ## On crible
    fam=1 ## ou (1, 7, 11, 13, 17, 19, 23, 29, utilisé par famille 30k + i au choix en fonction de n)
    crible,lencrible=E_Crible(premiers, n, fam)
    GCrible_2N(premiers, crible, lencrible, n, fam)
   
main()
system("pause")
 

La solution la plus simple :
j'ai modifié le programme modulo 30 pour l'adapter modulo 2 relatif aux entiers A naturels positif impair, de 1 à n.

En définitive , contrairement à ce que l'on supposer, le programme Goldbach calcule des rayons ou diagonales de congruence en partant de l'index du reste R de 2n par P, à savoir si 1 et congrus ouy pas à 2N (mod P) [1]
Chaque nombre A représenté par 1 dans l'algorithme, ce $1\equiv{2N}[P]$ ou  $1\not\equiv{2N}[P]$ initialise une diagonale de congruences , de l'axe des ordonnées , venant croiser, l'axe des abscisses d'Ératosthène criblé, ou plus précisément les abscisses des entiers A impairs de 1 à N fixé.

Or pour les deux algorithmes les indexes de départ des nombres premiers P qui criblent, sont totalement incompatibles et indépendants l'un de l'autre.
Le contraire est clairement faux , voir les programmes de ces deux algorithmes , quand bien même le principe de fonctionnement est identique et utilisent le principe de fonctionnement d'Ératosthène qui est bien connu.

Ce qui nous assure, qu'il est impossible d'infirmer cette conjecture de Goldbach .!

Pour tout A ⩽ N, entiers naturel positif impair , qui progresse modulo 2 de 1 à N , fixons la limite $N$, qui va vérifier le nombre de décompositions de $2N=p'+q$ donc la conjecture.

$2N$ progresse modulo 2, nous utiliserons les nombres premiers pi = P premiers d'Ératosthène, tel que P⩽ √2N, pour calculer ces congruences de 1 à N ; ie, les restes $R$ de la division Euclidienne de $2N\:par\:P$.(voir programme de l'algorithme)

L’algorithme de Goldbach, va donc utiliser  les congruences et construire sur l'axe des ordonnées dans le sens ↓: de l’amont vers l’avale chaque foi que N augmente de 1, les congruences (les restes) vont donc changer et se décaler d'un rang lors de la limite N+1 suivante qui serra criblée : soit ce nombre précédent marqué [1,] eétait congrus à (2N mod P), soit il ne l'était pas ; d'où avec ce décalage d'un rang des congruences pour cette limite N+1, permet de vérifier le nombre de décompositions de cet entier pair suivant, $2N+2= p'+ q$ en somme de deux nombres premiers. (avec $p'$ nombre premier de 1 à N, et $q$ nombre premier de N à 2N)

On va donc pour tout entier A, de $1\;à\;N$ limite fixée, calculer leur reste de $2N$ par $P$ afin de vérifier si [,1] est congru ou pas à 2N modulo $P$, ainis que l'index de départ pour le nombre P qui va cribler en partant de cet index, qui bien entendu , est clairement différent de l'index de départ pour l'algorithme Ératosthène (voir programme de  ces deux algorithmes unifiés qui utilise le même principe de fonctionnement. Ce qui rend impossible l'infirmation de cette conjecture.

Pour chaque limite N fixée, chaque entier [,1,] congru à $2N$ modulo $P$ ou pas, initialisera une diagonale de congruences, congrues à $2N$ modulo $P$ sur l’axe des ordonnées dans ce sens ↓ et seront marquées $0$, Chaque diagonale va par conséquent parcourir les entiers $A$,de 1 à N; voir illustration ci-dessous dans le pdf joint.

Inversement : si [,1,] est non congru à $2N$ modulo $P$, il initialisera une diagonale de congruences non congrue à $2N$ modulo $P$,  qui seront marquées $1$. Chaque diagonale parcourt l’ensemble des entiers impairs de $1\: à \:N$, pour toutes limites $N$ fixée , ces diagonales viendront croiser l’axe des abscisses criblé d’Ératosthène, de $1 \:à \:N$ ; donnant ainsi le nombre de solutions qui décomposent $2N$ en somme de deux nombres premiers.

Note : Quelque soit l’entier $2N$ qui vérifie la conjecture, tel que $2N = p’ + q$ ; la conjecture sera aussi vérifiée pour la ou les limites suivantes, $2N+2$; propriété récurrente de l'algorithme dû à l'utilisation des congruences.

Il existe pour chaque suite $N$ qui a été criblée ayant donnée le nombre de décompositions $p’+ q = 2N$, (" relatif aux entiers A ≢2N[P] avec $A$ premier ou pas,") la solution suivante des entiers A ≢2N[P] qui précèdent un nombre premiers $A+2=p'$ qui par conséquent, donneront le nombre de décompositions p'+q pour la limite N+1 suivante , c'est à dire pour l'entier suivant 2N + 2 = p'+q .

D'où de part la propriété récurrente de l'algorithme :  lorsque cette limite $N$ va augmenter de 1 et qu'elle serra criblée, il s’ensuit par obligation un décalage d’un rang des congruences, afin de correspondre à l'égalité suivante : (2N – A) ⇔ (2N +2) – (A + 2).

Par conséquent pour la limite $N+1$ suivante , cela donnera le nombre de solutions pour l'entier 2N+2 suivant,  ie ; le nombre de décompositions, de $2N + 2$, à une unité près.

Conclusion : Le nombre de décompositions d’un entier $2N$ est toujours vérifié, lors de la limite $N-1$ criblée précédemment, ce qui interdit de supposer que pour chaque limite $N$ criblée, donc vérifiée, que $2N+2$ ne se décomposerait pas en somme de deux nombres premiers , pour toute limite N vérifiée; voir même le nombre de décompositions finies de N +2 ; +4 ; +6 ...à +X.

Explications et illustrations dans le pdf joins , ainsi que les deux programmes unifiés avec leurs indexes de départ totalement différent donc incompatible, entre Ératosthène et Goldbach.

On peut considérer la conjecture de Goldbach comme un algorithme de décomposition d'un nombre pair > 6 en somme de deux nombres premiers,
Tel que : 2N = p'+q

Dossiers Modifiés le 20/12/2023 : avec programmes en C++ et en Python en fin de document , par famille 30K+ i , dans le dossier ci-dessous.

https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

LEG
23-11-2022 10:00:25

Bon tout marche bien :

C'était : pour faire une simulation sur les entiers impairs de 1 à n donc modulo 2 au lieu de faire par famille modulo 30 ,

Ce que je fais actuellement en supposant la conjecture Fausse à un point $X = 2n +2$ qui ne peur pas s'écrire comme la somme de deux nombres premiers $p+q $ qui abouti à trois contradictions .

Un simulateur est beaucoup plus efficace que des discours inutiles...
Comme personne ne l'a fait, qu'il est impossible de calculer ce point $X$, ni d'entrevoir les dégâts que cela occasionnerait sur la répartition des nombres premiers, mais pas seulement de $n\: à\: 2n$
On part d'un entier $K = 2n, et on simule
le programme en lui même ne fera pas la simulation qui est chia.... à programmer, alors que c'est simple manuellement car il est inutile de prendre un grand entier, pour vérifier l'impossibilité de supposer la conjecture fausse

Mon petit fils verra l'année prochaine dans le laboratoire d'I A  où il bosse pour me faire ce simulateur complet. qui utilisera la propriété récurrente de l'algorithme de Goldbach en sens inverse..

je joins le pdf de ce que le programme permet de voir et les raison d'un conjecture fausse impossible ...

Préambule :

Pour tout A⩽N, entiers naturel positif impair , qui progresse modulo2 de 1 à N et fixons l'entier 2N=18 qui va vérifier la conjecture , qui lui aussi progresse modulo 2, prenons P⩽√2N, un nombre premier , que l'on va utiliser dans ces congruences.

Prenons une suite Un , initialisons U0 = 3≡2N[P] , on vérifie , P=3 , divise 2N−A=15;

vérifions que l'on a bien la même égalité au rang U1= (3+2)≡(2N+2)[P] , on vérifie que P = 3 , divise toujours cette différence, qui est la même 15

vérifions qu'il en est de même au rang Un+1 =A=5+2 =7et 2N +2 =22  avec 22−7=15 donc par hérédité et par les congruences, on a bien (3+2+2)≡(2N+2+2)[P]

on vérifie c'est toujours la même différence 15 qui est bien toujours divisible par P =3.

Si on a 2 nombre premiers P, puis 3 puis 4 etc, on aura donc toujours la même propriété récurrente, où : l’un des nombres premiers P, divisera cette différence, 15 dans cet exemple. Le contraire serait absurde , c'est une égalité des congruences, si A et 2N sont congrus modulo P ; P divise la différence !

Est inversement si A et 2N ne sont pas congrus modulo P; que l'on peut écrire pour ce cas 3 ≠ 2N[P] alors P ne divise pas cette différence qui serra toujours la même, lorsque A et 2N augmente de 2, ("le contraire serait idiot")... c'est un nombres premiers q∈[N,2N].

il s'agit donc de deux suites arithmétiques de raison 2 , qui tendent vers l'infinie et dont leur différence est un multiple de P ou un nombre premier q.
C’est cette propriété par récurrence qui donne à l’algorithme de Goldbach sa propriété récurrente.

C'est donc cette propriété et égalité récurrente de l'algorithme de Goldbach, que l'on va utiliser avec son théorème, pour trouver une contradiction à cette conjecture :  qu'il est impossible de supposer une conjecture Fausse, car cette propriété des deux algorithme fera ressortir plusieurs contradictions.

Dont une par évidence : Il faudrait que les indexes de départ des deux algorithmes soient compatible , c'est à dire identique , ce qui clairement est faux.
En effet l'index de départ pour Ératosthène part de $p'\leqslant{N}$. qui est un nombre premier donc qui n'est p&s barré , ou de son carré qui est barré ou encore du produit de P*p' qui est barré , conformément au programme de l'algorithme; et ensuite on barre tous leurs produits modulo $P\leqslant\sqrt{N}$. suivant le principe connu d'Ératosthène.

Alors que les indexes de départ pour Goldbach sont différent de ceux d'Ératosthène et où $P$ part de l'index du reste $R$ de $2N$ par $P\leqslant\sqrt{2N}$. qui ne peut pas être systématiquement un nombre premiers $p'\leqslant{N}$ , qui serait barré ainsi que tous ses suivants modulo P, suivant le même principe d'Ératosthène, identique dans les deux algorithmes . Le contraire serait absurde , car clairement faux .!

notamment , qu'en ayant vérifier que pour tout 2N qui se décompose en somme de deux premier (p'+q) il est impossible de supposer que 2N+2 ne se décomposerait pas en somme de deux nombres premiers p’+q, ce qui constitue le premier cas de cette conjecture.

Nous montrerons ensuite que si il existe un entier X=2N+2 qui ne se décompose pas en somme de deux nombre premiers , alors il existe une entier :

k=2N à partir duquel le nombre de solutions va diminuer pour atteindre le point X qui ne se décompose pas en la somme de deux nombres premiers p′+q .

Cette supposition implique par conséquent que tous les nombres premiers p′⩽N sont congrus à 2n modulo P , d'où leur complémentaire par rapport à X=2N+2 n'est pas un nombres premier q .

Ce qui va soulever une contradiction ou plus, prouvant que l'incompatibilité des deux algorithmes que cette supposition assure par conséquent que la conjecture est vraie.

@+
G

modifié le 20/12/2023 :

https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

LEG
23-11-2022 09:56:31

ok programme pour la famille modulo 2k , en partant de fam = 1 , 3, 5...etc ; si le reste ri de 2n par pi est pair on le rajoute à pi et on part de cet index .
exemple : N = 40, le reste ri de 2N = 80 par 3 = 2 , l'index de départ serra donc 2+3 = 5 soit le troisième nombre [1,] que l'on remplace par [0,] etc etc par pas de 3. si ri est impair on part donc du reste par pas de pi ...etc

from time import time
from os import system
import math

def candidate_range(n):
    cur = 5
    incr = 2
    while cur < n+1:
        yield cur
        cur += incr
        incr ^= 6  # or incr = 6-incr, or however


def eratostene(n):
    n = int((2*n)**0.5)
    prime_list = [3]
    sieve_list = [True] * (n+1)
    for each_number in candidate_range(n):
        if sieve_list[each_number]:
            prime_list.append(each_number)
            for multiple in range(each_number*each_number, n+1, each_number):
                sieve_list[multiple] = False
    print(prime_list)
    return prime_list[0:]


def demander_N():
    n = input("Donnez N: ")
    n = int(n.strip().replace(" ", ""))
   
    return n


def GCrible(premiers, n, fam):
    start_crible = time()
    crible = (n//2)*[1]     # Ou : on rappel le tableau Ératosthène criblé de N/2 cases
    lencrible = len(crible)

    # On calcule les restes: ri = 2*n/pi , pi est un nombre premier Ératosthène < racine de 2*n
    nbpremiers = len(premiers)
    n2 = 2*n
 
    for i, premier in enumerate(premiers):
        reste = n2 % premier
        print(reste)
  # tant que ri % 2 != fam on fait ri += 2pi
        if reste % 2 == 0:
            reste += premier
        pi2 = 2*premier
        while reste % 2 != fam:
            reste += pi2
        # Ensuite on divise ri par 2 pour obtenir l'indexe
        reste //= 2
        # On crible directement en partant de l'index impair par pas de pi en remplaçant le 1, par 0,
        for index in range(reste, lencrible, premier):
            crible[index] = 0

    total = sum(crible)  
    print("crible:", crible)
    print(f"Nombres non congru 2n[pi] {1} à {n} famille {fam} premiers de {n} à {n2}: {total} ----- {int((time()-start_crible)*100)/100}")


def main():
    # On demande N a l'utilisateur
    n = demander_N()

    # On récupère les premiers pi de 3 à √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers de 3 à {int((2*n)**0.5)}: {len(premiers)}")

    start_time = time()
    # On crible
    GCrible(premiers, n, 1)    ## 1 désigne la fam 1 , famille 1 des impairs
    temps = time()-start_time
    print(f"--- Temps total: {int(temps*100)/100} sec ---")


main()
system("pause")    
 

résultat :
Donnez N: 40
[3, 5, 7]
2
0
3
c
rible: [1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1]
Nombres non congru 2n[pi] 1 à 40 famille 1 premiers de 40 à 80: 10 ----- 0.0
--- Temps total: 0.0 sec ---

yoshi
23-11-2022 07:59:11

Re,

Il y a plus simple...
ancienne boucle :
for i in range(1,n):
à modifier avec cet ajout du pas de 2 :
for i in range(1,n,2):
en partant de 1 et en allant de 2 en 2, on ne criblera que 1,3,5,7,9... les impairs !

Si, toi, tu ne sais pas à quel endroit de ton prog tu cribles tous les nombres de 1 à n sans exception, alors je vais avoir du pain sur la planche...

@+

LEG
23-11-2022 07:26:36

Bonjour@Yoshi

OKok

problème résolu

j'ai transformer l'algorithme GCrible modulo 30 en modulo 2

impec

Merci et excuse moi  du dérangement , mais tes idées on remis les miennes en places
@+
Gilbert.

yoshi
22-11-2022 17:57:14

Bonsoir,

Si je comprends ce que tu voudrais exactement, si j'arrive à savoir où intervenir, je veux bien essayer...
Parce que, vois-tu, toi tu es immergé là-dedans, c'est ton truc", donc c'est clair pour toi mais moi, il faut que je replonge pour ré-appréhender   Ça, par exemple :
qui démarre d'une cellule [0] je ne comprends pas (plus ?) ce que cella signifie...
ou
modifier le tableau des du crible en entiers uniquement impairs en partant de 1 à n j'en déduis qu'avant tu criblais les nombres pairs ?
Et où crible-t-on indistinctement les nombres pairs et impairs ?
Etant donné un indice i quelconque, en criblant de i=1 à i=n, chaque nombre criblé devant être de la forme 2i+1, ton dernier nombre impair criblé sera 2n+1...
Pour limiter les impairs à la valeur n incluse, il faut prendre comme limite de boucle non plus n mais (n-1)//2+1
Exemples
n=3000
(n-1)//2 +1--> 1500 donc Python criblera de i =1 à i =1499 inclus, donc ton dernier impair criblé serait 1499*2+1=2999

n=3001
(n-1)//2 +1--> 1501 et Python criblera de i =1 à i =1500 inclus, donc ton dernier impair criblé serait 1500*2+1=3001
Cela te poserait-il un  pb ?

2. je ne comprends pas pourquoi le criblage donne directement les nombres premiers q par soustraction...2N−A=q
C'est pourtant bien toi, le concepteur ?  Que veux-tu voudrais que je fasse là-dessus et où ?

@+

LEG
21-11-2022 17:35:21

Bonjour @Yoshi
serait il possible  de modifier le tableau des du crible en entiers uniquement impairs en partant de 1 à n. et de $P\leqslant\sqrt{2n}$

on me demande des illustrations du décalage d'un rang des congruences pour de petits nombres.

Ok mon ami

j'ai trouvé: transformer l'algorithme mod 30 en mod 2


from time import time
from os import system
import math

def candidate_range(n):
    cur = 5
    incr = 2
    while cur < n+1:
        yield cur
        cur += incr
        incr ^= 6  # or incr = 6-incr, or however


def eratostene(n):
    n = int((2*n)**0.5)
    prime_list = [3]
    sieve_list = [True] * (n+1)
    for each_number in candidate_range(n):
        if sieve_list[each_number]:
            prime_list.append(each_number)
            for multiple in range(each_number*each_number, n+1, each_number):
                sieve_list[multiple] = False
    print(prime_list)
    return prime_list[0:]


def demander_N():
    n = input("Donnez N: ")
    n = int(n.strip().replace(" ", ""))

    return n


def GCrible(premiers, n, fam):
    start_crible = time()
    crible = (n//2)*[1]     # Ou: on rapelle le tableau Ératosthène criblé de N/2 cases
    lencrible = len(crible)

    # On calcule les restes: ri = 2*n/pi
    nbpremiers = len(premiers)
    n2 = 2*n
 
    for i, premier in enumerate(premiers):
        reste = n2 % premier
        print(reste)
  # tant que ri % 2 != fam on fait ri += 2pi
        if reste % 2 == 0:
            reste += premier
        pi2 = 2*premier
        while reste % 2 != fam:
            reste += pi2
        # Ensuite on divise ri par 2 pour obtenir l'indexe
        reste //= 2
        # On crible directement avec l'index
        for index in range(reste, lencrible, premier):
            crible[index] = 0

    total = sum(crible)  
    print("crible:", crible)
    print(f"Nombres non congru 2n[pi] {1} à {n} famille {fam} premiers de {n} à {n2}: {total} ----- {int((time()-start_crible)*100)/100}")


def main():
    # On demande N a l'utilisateur
    n = demander_N()

    # On récupère les premiers de 3 à √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers de 3 à {int((2*n)**0.5)}: {len(premiers)}")

    start_time = time()
    # On crible
    GCrible(premiers, n, 1)
    temps = time()-start_time
    print(f"--- Temps total: {int(temps*100)/100} sec ---")


main()
system("pause")    
 

ça fonctionne impec.


Merci..bien sûr amitiés G .

LEG
31-10-2022 12:04:28

Bonjour à tous

Du nouveau sur cet algorithme et sur l'impossibilité d'infirmer la conjecture de Goldbach :


Pourquoi on ne peut infirmer cette conjecture et son corollaire : la conjecture de Lemoine-Levy.

Ainsi que pourquoi le nombre de solutions $p’+q = 2n$ augmentent lorsque $n → ∞$

Pour vérifier le phénomène et le comprendre , il faut cribler avec l'algorithme G de Goldbach mod 30 et celui d'Ératosthène É par famille de la forme $30k+(i)$ , avec $i\in(1.7.11.13.17.19.23.29)$
8 suites arithmétique de raison 30.

Il suffit de cribler jusqu'à la limite $n$ et non $2n$ pour connaître le nombre de solutions qui vérifient $2n = p+q$.
L’algorithme ferra ressortir la Fam (i) complémentaire par rapport à $2n$

On crible les entiers $A$  positifs, appartenant à une des 8 Fam(i) de 1 à n ; en utilisant les congruences : le crible G  avec en parallèle , le crible É Ératosthène qui crible les nombres premiers $p'$ de la même famille pour la même limite $n$.

À chaque fois que la limite la limite $n$ augmente de $15$ , donc $2n$ augmente de 30 , il se passe une égalité récurrente : les congruences se décalent obligatoirement d'un rang sur leur successeur $A +30$. (simple à démontrer) et seul  le premier élément $A$ apparaît indécidable ie , congrus ou pas à 2n (mod P) ;  avec $P\leqslant\sqrt 2n$.

Exemple :
Avec ce petit extrait  des 2 cribles ;

Limite n= 300//30 et la Fam i = 7. Où les 1 et 0 représentent les entiers A
Si A est non congru à P = 1 , sinon = 0

Donnez N = 300 ; [7,37,67,97.…etc]

Gcrible: [1, 1, 0, 1, 0, 1, 0, 1, 1, 0], 1] Nombres $A\not\equiv 2n[P]$ de 1 à 300 famille 7, total 7 qui implique les nombres  premiers $q$ de 300 à 600:  de la Fam i = 23 , d'où inutile de chercher la Fam (i) complémentaire par rapport à $2n$, l’algorithme là fait ressortir.

Donnez N =300

Écrible: [1, 1, 1, 1, 1, 1, 0, 0, (0), 1] Ératosthène [ 7,37,67,97,… 247,277] où (0) = 247 ≢2n [P] et 247 n’est pas un nombres premiers = 0 , mais il précède un nombre premier 1.
Nombre premiers criblés famille 7 : 7 , dont 4 premiers $p'\not\equiv 2n[P]  4 solutions pour $2n=600$

Si on augmente n de 15 , soit $15(k+1)$ les congruences vont se décaler d’un rang dans le crible G.
Dans Ératosthène rien ne bouge , on aura toujours les 7 nombre premier

Donnez N =315

Gcrible: [0,[ 1, 1 0, 1, 0, 1, 0, 1, 1,] 0] seul le premier élément 0 serait indécidable (il est congru ou pas)

Écrible: [1, [1, 1, 1, 1, 1, 0, 0, 0, 1] on retrouve les p’ non congrus , mais où les congruences ce sont décaler d’un rang sur leurs successeur $A+30$.

il est simple de vérifier que la non congruence de $A = 247$ qui n'est pas un nombre premier, s'est décalée sur $A = 277 = p'$ , qui devient non congru à P ... alors que pour $n=300$ , il était congru ! Il vérifiera donc la conjecture $277 + q = 630$.

Car : $A = 247$ qui était non congru pour $n = 300$ , l'égalité $2n – A = 353 = q$ premier, reste identique pour la limite suivante $n = 315$ ;
c’est à dire pour $2n = 630$ et tel que $(2n +30) – (A+30) = q = 353$

Dû à l'égalité et propriété récurrente de l’algorithme, qui permet de prendre en compte tous les entiers A ≢2n[P] , premiers ou pas, qui précèdent un $A’= P’ $
Le contraire serait absurde , car contraire au TFA .!

Pour infirmer la conjecture il faudrait utiliser les restes R des limites précédentes n = 15(k-1 , -2 , -3 … -x) . Ce qui est clairement impossible , à chaque limite $n+15$ les Restes $R$ de la division de $2n$ par $P$ changent, le contraire serait absurde…

Conséquence : il faudrait utiliser tous les restes $R$ des limites précédentes afin que tous les entiers $A$ soient congrus à 2n + 30 mod P pour cette nouvelle limite $n=15(k+1)$ « et ce quelque soit la Famille (i) utilisée.»

Or on aurait pas assez de nombres premiers $P$ qui criblent (car limité par la $\sqrt 2n$ qui limite le nombres de A congrus à P) de plus on contredirait l'égalité récurrente de l'algorithme de Goldbach et les conséquences sur la répartition des nombres premiers si la conjecture était fausse.

Mais surtout, cela veut dire, suite à cette propriété récurrente de l’algorithme G , que pour les limites précédentes [n = 15(k-1 , -2 , -3 … -x)  où la conjecture a été vérifiée donc vraie , elle serait fausse …?

Car il n’y aurait que des entiers A congrus à (2n – 30k)  [modulo P] qui précèdent un entier $A’=p’$ premier .

De façon générale il faudrait une descente infinie de $A\equiv 2n[P]$ lors des limites précédentes dans le sens inverse.

Cela conduirait immanquablement vers un nombre fini de nombres premiers $q$ lorsque $n$ tends vers l’infini ; Alors que pour les limites précédentes n = 15(k-1;-2;-3 ...etc ) il y en avait $\frac{n}{log\; 2n}$ .
Alors qu’au contraire, le nombre de solutions $p’+ q = 2n$ augmentent lorsque n tends vers l'infini

Cela est absurde et contraire au TFA ainsi qu’au TNP .

Je laisse imaginer, les conséquences qu'auraient sur la répartition des nombres premiers si cette conjecture avait été fausse . On peut faire une simulation avec l'algorithme de Goldbach, ainsi que les tableaux dans le fichier joint.

Ce fichier joint explique le fonctionnement des deux (cribles/algorithmes) jumeaux et sa propriété récurrente , lorsque $n =15(k+1)$ augmente , quelque soit une des 8 Fam(i) choisie .

Principe de base:

https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

LEG
29-11-2021 11:11:21

Bonjour à tous
@Yoshi
Pour continuer avec ce programme relatif à la conjecture de Goldbach , j'ai modifié les deux programmes : 1 en python que tu as fait et  l'autre, retranscrit en C++ relatif à cette conjecture pour les adapter à la conjecture de Lemoine-Lévy  qui énonce tout nombre impair$N\geqslant{11}$ est somme de deux nombres premiers tel que pour P premier et q premier 2N+1 = 2P + q,

Il s'agit de deux conjectures équivalentes pour une limite $N\geqslant{150}$  fixée et par famille en progression arithmétique de raison 30 et de premier terme $i$ avec $i\in{1,7,11,13,17,19,23,29}$

D'après la preuve d'Harald Helfgott en 2013, on sait que tout nombre impair $N\geqslant{9}$ est somme de trois nombres premier pas forcément distinct...

(" Ce qui n'implique pas forcément la conjecture de Lemoine - Lévy et donc ni la conjecture de Goldbach.  Alors que la conjecture de Goldbach implique Lemoine - Lévy ou inversement. En effet, il s'agit du même algorithme qui donne le nombre de solutions par famille pour une limite $N\geqslant{150}$ fixée.")

Programme de la conjecture de Goldbach en python, modifié pour la conjecture de Lemoine /Lévy qui donne le nombre de solutions pour une limite fixée $N\geqslant{150}$ tel que  $2n+1 = 2p' + q$  avec $p'\in[7 ; N]$ ; avec p' un nombre premier > 5 et inférieur à la limite N fixée.


from time import time
from os import system

def candidate_range(n):
    cur = 5
    incr = 2
    while cur < n+1:
        yield cur
        cur += incr
        incr ^= 6  # or incr = 6-incr, or however

def eratostene(n):
    n = int((2*n+1)**0.5)  ##(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
    prime_E =[2,3]
    sieve_list = [True for _ in range(n+1)] ## c'est plus propre comme ça
    for each_number in candidate_range(n):
        if sieve_list[each_number]:
            prime_E.append(each_number)
            for multiple in range(each_number*each_number, n+1, each_number):
                sieve_list[multiple] = False
    #print(prime_E[3:])
    return prime_E[3:]  

def E_Crible(premiers, n, fam):
    start_crible = time()
   
    # On génère un tableau de N/30 cases rempli de 1
    lencrible = ((n//30)+1)
    crible=[1 for _ in range(lencrible)] ## c'est plus propre comme ça
    GM = [7,11,13,17,19,23,29,31]
    # On calcule les produits :
    for a in premiers:
        for b in GM:
            j = a * b
            if j%30 == fam:
                index = j // 30  ## Je calcule l'index et On crible directement à partir de l'index
                for idx in range(index, lencrible, a):  ## index qui est réutilisé ici...
                    crible[idx] = 0
                   
    total = sum(crible)
    print(f"Nombre premiers criblés famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")
    return crible,lencrible
 
def GCrible_2N(premiers, crible, lencrible, n, fam):
    start_crible = time()
    # On calcule les restes: ri = (2*n+1)/P premier
    nbpremiers = len(premiers)
    n2 = 2*n+1
    for premier in premiers:
        reste = n2 % premier
        #print(reste)
        if reste % 2 == 1:
            reste += premier
        pi2 = 2*premier
       ## tant que reste % 60 != 2*fam on fait reste += pi2
        while reste % 60 != 2*fam:
            reste += pi2
        ## Ensuite on divise reste par 60 pour obtenir l'index
        reste //= 60
        ## On crible directement avec P à partir de l'index par pas de P
        for index in range(reste, lencrible, premier):
            crible[index] = 0

    total = sum(crible)  
    #print("crible:", crible)
    print(f"Nombres 2P' non congru 2n+1[P] ou couple 2P'+q = 2N+1, de (i) à {n} famille {2*fam} : {total} ----- {int((time()-start_crible)*100)/100}")

def demander_N():
    n = input("Donnez N: ")
    n = int(n.strip().replace(" ", ""))
    #n = int(30 * round(float(n)/30))
    return n

def main():
    ## On demande N a l'utilisateur
    n = demander_N()
    ## On récupère les premiers P de 7 à √N
    premiers = eratostene(n)
    start_time = time()
    ## On crible
    fam=7    ## ou 1, 7, 11, 13, 17, 19, 23, 29, au choix en fonction de la forme de N
    crible,lencrible=E_Crible(premiers, n, fam)
    GCrible_2N(premiers, crible, lencrible, n, fam)
   
main()
system("pause")
 

Ci-dessous, même programme mais en C++  qui permet d'aller assez loin et très rapide pour tester jusqu'à plus de 6 billions par famille...(" il n'y a pas la fonction qui permet d'éditer le tableau criblé , comme celui de dessus en python pour de petite limite N < 60 000), car au dessus cela n'a aucun intérêt...")

J'utilise [Code::block]

Pour fixer la limite du départ du crible qui progressera de raison 15 pour une famille, à la demande fam = 7 ou 1 ou 11 ou $i$ :

On change les deux valeurs ligne 156 début et 157 fin
Par exemple ligne 156: ulonglong debut = 60000 et  ligne 157:  ulonglong fin = 60075;
On  va cribler pour les limites fixées N de raison 15 de 60000 à 60075, la fam 7


// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
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;
}

typedef unsigned long long ulonglong;

size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau de 1 modulo 30 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 / 1500000, 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]);
  cout << " Nbr p' criblés Fam " << fam << " < à " << n << ": " << total << " time " << (clock() - cl) * 1e-6 << 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 de 1 mod 30 criblé par Ératosthène ci dessus
  //vector<bool> crible(lencrible, true);  // on rappelle les nombres premiers p d'Eratotene ci dessus
  ulonglong n2 = (2*n+1);
  vector<ulonglong> indices(nbpremiers);
  for (size_t i = 0; i < nbpremiers; ++i)
  {
    ulonglong p = premiers[i];
    ulonglong reste = n2 % p; // on calcule le reste de 2n+1 par p
    if (reste % 2 == 1)
      reste += p;
    ulonglong pi2 = 2 * p;
    while (reste % 60 != 2*fam) // tant que le reste += pi2 n'est pas = à 2fam % 60 on rajoute 2*p
      reste += pi2;
    reste /= 60; // on ensuite on va calculer l'indice pour commencer à cribler modulo p le tableau de [1.1.1....n//30] , a partir de l'indice.
    indices[i] = reste;
  }
  ulonglong nslices = lencrible / 1500000, 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 couple 2p+q criblés Fam " << 2*fam <<  " : " << total << " time " << (clock() - cl) * 1e-6 << endl;
  return total;
}

int main(int argc, char **argv)
{
  vector<unsigned> temp;
  ulonglong debut = 60000;
  ulonglong fin = 60075;

  int fam = 1;    // en fonction de la forme de limite=N on rentre la fann [1.7.11.13.17.19.23.29].
  if (argc > 1)
  {
    fam = atoi(argv[1]);
  }
  else
  {
    cout << "Syntaxe " << argv[0] << " fam. Donnez fam: ";
    cin >> fam;
  }

  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;
    }

    size_t lencrible = limite/30;
    vector<bool> crible(lencrible, true);
    ECrible(premiers, limite, fam, crible, lencrible);
    GCrible(premiers, limite, fam, crible, lencrible);
  }
}
 

Bonne lecture; avec cet algorithme modulo 30 par Famille, on peut prouver que ces deux conjectures sont de même complexité avec une même densité de solution en moyenne générale pour une limite N fixée >= 150 .
Elles peuvent se prouver de façon élémentaire à l'aide d'une seule des 8 familles à partir de la limite N = 150, grâce au principe de fonctionnement de l'algorithme de Goldbach et sa propriété récurrente, qui rend impossible son infirmation pour toute limite suivante = N +15  et sa Fam 30k +i , qui a été définie... etc à voir...

résumé crible algo.G.E et - EG2

modifié le 20.12.2023 :
https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

LEG
30-03-2021 11:39:28

Bonjour à tous

Je joins ci dessous le programme unifié des deux algorithmes Ératosthène et Goldbach en C++ ; qui donne directement le nombre de couples p+q qui décomposent 2N en somme de deux nombres premiers , avec le nombre de nombres premiers < N qui sont criblés, pour une limite N fixée. Le deuxième document joint donne l'explication sur la conjecture de Goldbach , le fonctionnement de l'algorithme et pourquoi cette conjecture ne peut être infirmée quelque soit une des 8 Fam(i) fixée par rapport à la forme de la  limite $N\geqslant{150}$ fixée

Il est paramétré ligne 156 et 157 :
ulonglong debut = 45000000000;   // début du crible par fam(i) le crible progresse de raison 15 pour chaque famille (i) en fonction de la forme de N
  ulonglong fin = 4500000330;
        // fin

pour définir les limite $N$ de début et de fin on change la valeur de début et de fin suivant la limite N que l'on veut vérifier par pas de 15 ou de raison 15 suivant le principe d'une suite arithmétique de raison 15, d'où on obtiendra le nombre de $A\not\equiv{2n}[P]$ ce qui implique le nombre de couples $P'+q = 2N$

Sachant que l'on connaît les fam (i) à utiliser en fonction de la forme de $N$ ceci implique la vérification de $2N$ en somme de deux nombres premiers (p+q) l'algorithme en déduit directement la Fam(i) q complémentaire, conséquence des congruences utilisées par l'algorithme de Goldbach modulo 30.

Exemple: limite début $30001$, la  limite fin serra $30001 + 15k$ par exemple $15k =165$ ce qui donnera comme limite fin : $30166$ on vérifiera le nombre de couples solutions de 2N de $60002\: à\: 60332$, avec une limite N + 15k criblée par famille, (la limite N progresse de raison 15 de 30001 à 30166)

il n'y a que la ou les fam(i) à activer ou à désactiver les autres, par deux barres slach // de la ligne 160 à 168.

Pour cet exemple $2N = 30k + 2$ on a que trois possibilités fam 1, fam13 ou fam 19. et on désactive les 5 autres Fam par 2 // devant chaque Fam(i)
car $1+31 = 30k+2$ et $13+19 = 30k+2$ et les 5 autres fam(i) ne peuvent décomposer en somme de deux nombres premiers 30k + 2, car leur complémentaire q ne serait pas un nombre premier, mais un multiple de 3 ou de 5...("ex : 32 -7=25 ; 32-29 = 3 ; 32-11 =21...etc")

Ces documents joints  :
résumé:
modifie le 20/12/2023 :
https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

il vous indique en fin de document la fam (i) où $î\in(1,7,11,13,17,19,23,29)$ à utiliser en fonction d'une des 15 formes de $N$
Il prouve aussi avec les illustrations,  pourquoi on en déduit, que cette conjecture ne peut être infirmée grâce aux propriétés de l'algorithme de Goldbach utilisant les congruences . Avec les documents joints des post précédents.

Pour le fonctionnement du programme c++ , j'utilise (Code::Block).

J'ai rajouté dans le programme les 8 familles ligne 160 à 168 que l'on actives ou désactives avec les 2 // en fonction de la forme de N , si N différent de 15k , par exemple pour début N = 15k +8  = 3 000 008 et fin N = 15(k+7) + 8 = 3 000 113 on active les trois familles (i) = 17, 23 et 29 ; on désactive les 5 autres avec //


// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
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;
}

typedef unsigned long long ulonglong;

size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau de 1 modulo 30 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 / 1500000, 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]);
  //cout << "Nombre premiers criblés famille " << fam << " plus petits que " << n << ": " << total << " time " << (clock() - cl) * 1e-6 << 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 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'Eratothene ci dessus
  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 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; // on 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 / 1500000, 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 << "Nombre couples p+q=2N criblés famille " << fam << " : " <<total << " time " << (clock() - cl) * 1e-6 << endl;
  return total;
}

int main(int argc, char **argv)
{
  vector<unsigned> temp;
  ulonglong debut = 4500000000;
  ulonglong fin = 4500000060;

  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 << "famille : " << fam << " 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;
      }

      size_t lencrible = limite / 30;
      vector<bool> crible(lencrible, true);
      ECrible(premiers, limite, fam, crible, lencrible);
      GCrible(premiers, limite, fam, crible, lencrible);
    }
  }
}
 

LEG
21-03-2020 13:25:50

Désolé je n'en savais rien , je pensai qu'en fichier W , pour corriger c'était plus simple..aucun souci voici le lien en PDF et je supprime l'autre

https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

yoshi
21-03-2020 11:50:43

Bonjour,

Moi, je suis un adepte des logiciels libres, j'utilise Apache OpenOffice ou LibrOffice dont n'importe qui peut savoir ce qu'il cache ou pas puisque le code source est disponible en Libre accès.

Toi, tu utilises un logiciel fermé propriétaire dont le code n'est pas accessible.
Donc la lecture des fichiers Word avec l'un des deux est très aléatoire : en général, on perd au moins 50% de la mise en page...

LEG
21-03-2020 10:17:51

Bonjour
@Yoshi
Je met le dernier fichier sur la résolution de la conjecture de Goldbach; qui utilise le principe de récurrence de l'algorithme de Goldbach dans les congruences avec un raisonnement par l'absurde qui contredit la possibilité d'une conjecture fausse.

En résumé, quelque soit la limite $2n = 30k +2i$ vérifiée, tel que $2n = P' + q$ alors elle serra vérifiée pour $2n = 30(k+1) + 2i$ par le crible de Goldbach avec une variation négligeable du nombres de couples $P' + q = 2n\geqslant{300}$. "La conjecture étant vérifiée jusqu'à 2n = 300 "

On crible et on vérifie la conjecture avec une seule $Fam(i)$ pour une limite $n = 15k + i\geqslant{150}$ sans perte de généralité.

@+
mise à jours des fichiers :

https://www.cjoint.com/c/MLwhYgOjWGB

 https://www.cjoint.com/c/MLuk2kVYYv7

 https://www.cjoint.com/c/MLukYASZgK7

LEG
10-09-2019 13:32:59

Salut @Yoshi
lorsque tu pourras te remettre sur la résolution de cette conjecture, tu verras que j'ai apporté des explications complémentaire sur les deux post# 376 et 378, en raison de ta demande du post# 377....Ce qui je pense te permettra de reprendre le principe de fonctionnement de ce crible G sur le crible E...
Avec la contradiction du post# 382 sur l'impossibilité d'un conjecture fausse, comme conséquence ....
Cordialement
@Lg

yoshi
07-05-2019 12:41:40

Ok,

Nouvel essai d'envoi.

@+

[EDIT]
Nouveau refus

Pied de page des forums