Forum de mathématiques - Bibm@th.net

voila ce que j'appelle un masque pour cribler celui ci-dessous
correspond à pi =13 , le programme positionne fam 2 les 8 j dans leur famille et on duplique toutes les 13 lignes [Eratosthène mod 30]
si tu veux voir ce que cela donne sur une feuille excel , je t'envoie le lien...

151  , 67  , 11  , 193  , 137  , 109  , 53  , 179     pi = 7
[151, 217, 41, 283, 107, 19, 173, 239]         pi = 11
361, 127, 101, 283, 257, 49, 23, 179]         pi = 13

..........................................................................
.                        0   
.                    0       
.                           
.        0                   
.    0                       
.                            0
.                           
.                           
.                0           
.            0               
.   
                       
.                           
0                           
.
..............................................................................

Non le maximum tu l'as fait..!  Il marche à merveille..je ne sais pas ce que tu en penses. de ce crible de Goldbach..
je trouve dommage que personne ne l'ai découvert , par conséquent étudié..
peut être que parmi tous les visiteurs cela donnera une idée
sur la répartition des nombres premiers de n à 2n...à quelqu'un.....

En plus il est très simple de modifier l'ordre des familles pour n'en cribler qu'une ou trois..et vérifier Goldbach pour les n = 30k + P8
Où les décomposants de Goldbach  ne sollicite que 3 familles pour vérifier p+q = 2n.. etc etc...

Au moins sur ton site tu peux proposer le crible..si les visiteurs ne ce sont pas déjà servis ....

Il y a longtemps que tu m'as convaincu et rassuré... j'ai compris ta modif..

Est ce que le criblage selon le principe d'Eratosthène que je t'ai expliqué plus Haut t'as convaincu...et son fonctionnement ..
il est clair qu'aucun Matheux, n'ayant étudié ce crible de Goldbach , car je l'ai découvert il y a une dizaine d'année, lorsque je m'intéressais à cette conjecture ..j'étais plus penché sur le crible Eratosthène que j'avais aussi construit mod 30 selon ce même principe en 2002...

je voudrai quand même que tu arrives à comprendre le fonctionnement du crible une fois que les j de pfam et positionné dans p8 = Dico= les 8
familles . avec pfam (0) et les 8 famille 30k +1 ou P[7;29]

ligne (0): c'est celle de 1 et des 7 premiers  soit :
Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7} qui sont remplacé par des [1]

Tu as pi=7 ; R = 4  pour :n = 1500 , . Chaque ligne augmente de 30.ok Ce qui va te donner les 8 j pour la pfam n° 0

ta pfam(0)=:
[151  , 67  , 11  , 193  , 137  , 109  , 53  , 179]
peux tu placer tes 8j dans les 8familles... et cribler modulo 7 par pas de 7 "ce qui correspond à modulo 210 c'est à dire par pas de 210 entre deux valeurs d'une même famille ou même colonne"

je place la première valeur de j 151 dans sa famille 1[30] et je crible mod 7 (par pas de 7) une seule fois...je n'oublie pas de changer le 1 en 0., (c'est ce que fait l'algorithme de Goldbach, ("Eratosthène modulo 30"), mais dans les congruences '"ou dans les multiples de P avec l'autre crible Ératosthène.").)

[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1] équivalent à [1 . 7 . 11 . 13 . 17 . 19 . 23 . 29] 8 colonnes = 8 fam [30]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1] <..............>[31.37. 41 . 43 . 47 . 49 . 53 . 59]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[0 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[0 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1]

à toi pour les 7 autres j dans leur famille modulo 30 c'est à dire tu vas cribler par pas de 7 en partant de la valeur de j relatif à cette pfam (0), dans chacune des 8 familles.
En fonction de l'ordre de Dico = {1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}

le pas tu entends bien criblage modulo pi*30 par famille ..?

extraits pour cribleG7y_mod30 et cribleG6:

RESTART: E:\Documents\conjecture de Goldbach\cribleG7y_modulo30 avec D_C - Copie.py
Donnez la valeur de n = 30k : 15240000000
Phase d'initialisation: 74.63053107261658 seconds ---
Famille de chaque Pi: : 4.882808446884155 secondes ---
Criblage des 8 familles: 74.19473052024841 seconds ---
Extraction des premiers n à 2*n : 29.75025248527527 seconds ---

**  79936681 nombres trouvés en 183.4583225250244 secondes **
je reviens

tu as modifié ce bloc, par rapport à G6 , qui te fait perdre du temps , car en principe la phase criblage est très rapide car
tu marques les cellule modulo pi donc plus Pi est grand, plus le programme accélère :
marquer par famille toutes les pi=7 cellules est plus long que de les marquer toutes les pi=15491.... donc attention lorsque tu modifie le criblage....tu as 8 000 000 de cellules par familles, à cribler....

voila une méthode en exemple : que je faisais  pour une pfam: n=1500,Pi==7;  2n%pi = 4

4+7 = 11 puis modulo 7*30 ....<= 1500 famille 11 criblée.
11 +2*7 = 25 =5m pas bon incr +14 = 39 = 3m, +incr 53 %9 == 8 ok + 210....<1500 famille 23 criblée.
53 +14 = 67, %9 == 4 ok +210.....<1500 famille 7 criblée
67 +14 = 81 = 3m pas bon,+ incr = 95 =5m pas bon  +incr =109 %9==1 ok + 210 ...< 1500 famille 19 criblée
109 +14 = 123 = 3m. +incr = 137 %9 ==2 ok +210 ...<1500 famille 17 criblée
.
.etc.etc famille 11 et 29...ok

179 + 14 = 193 %9 = 4 ok  +210...<=1500 dernière famille ==13, Criblée..

retour à Pi == 11, 3000%11 ==8; on réitere ("modulo 330")

8 +11 = 19 %9 ==1, ok +330 ....<=1500 famille 19 criblée
19+2*11 = 41%9==5 ok +330 ...<1500 famille 11criblée
41 + 22 = 3m +22 = 85 +22 = 107 %9 ==5 ok + 330....< 1500 fam 17 criblée
107 + ...etc..etc.
.
.
239 +22 =....etc 283 % 9==4 ok +330...<1500 dernière fam 13 criblée

retour à Pi suivant...etc ...fin du criblage pour n =1500

comptes des valeurs ("congrues à 3000 [Pi]") SANS LES DOUBLONS ce qui pose problème car il faut trier.... pour le bon résultat ... Il ne faut pas oublier, qu'un entier peu être congru de façon unique à l(ordre près de ses facteurs...! ce qui veut dire qu'un congruent aura plusieurs facteur P ....comme un produit...

Mais si tu positionnes les pfam dans le tableau des 8 famille puis à partir de leur position tu crible modulo Pi*30 additivement, et bien tu repassera sur des valeurs qui sont déjà en place donc écrasées ; et dans ce cas plus de Doublons ..c'est pour cela que j'utilise les [1] et [0] moins de place pas d'erreur...et aussi rapide,  car c'est du comptage modulo P_i , selon le principe d'Eratosthène...

En définitive c'est aussi simple qu'Eratosthène, mais en utilisant les congruences...
@+

c'est trivial est nul besoins de démonstration, car cela revient à dire que si c'était faux il en serait de même du crible d'Eratosthène de 1 à n et si tu veux de 7 à N dans les 8 familles de nos cribles..
ces cribles sont de moi , je les ai construit sur le principe d'Eratoshène
Eratosthène rappel : Pi <= sqrt de n ;   je part de 2, je marque les mulitples de 2 tous les deux nombres puis 3, n'est pas marqué donc premier, je barre les mulitples de 3, tous les trois nombres...5 n'est pas marqué, donc premiers , je marque les 5m tous les 5 nombres...etc jusqu' sqrt de n

Et tu me demandes si j'ai bien barré tous les multiples de Pi, et si les nombres barrés sont bien des nombres premiers...tu connais la réponse en bon Matheux sans avoir besoin de démonstration depuis + de 2000ans

je peux le faire dans les 8 suites arithmétique modulo30, de premier terme P8[1.7.11.13.17.19.23.29] crible que j'ai construit [nbpremier win] il y a deux méthodes celle que j'utilise dans le cribleG6 ou Eratosthène mod30, par famille..!

cribleG_(n) de 1 à n; principe d'Eratosthène ...idem: Pi <= sqrt de 2n, je part de R  qui est les reste de 2n% Pi Pi[2,3,5,7...sqrt 2n]
j'ai la liste des R  et leurs Pi R(0) et Pi(0) ; R(1) et Pi(1)....

je part du premier reste R(0) que j'ai positionné dans la liste des entier de 1 à n , et la peux importe que R soit pair ou impair...
n=1500 R(0) ==0 Pi(0) ==2 je part donc de 2 et je barre tous les congruents à 2, tous les deux nombre ....> n ("comme Ri= 0, cela revient à barrer les multiples de 2 qui seront tous congrus à 2n modulo 2...!")

R(1) == 0 et Pi(1)==3, idem je part de 3 et je barre tous les cogruent à 3 tous les trois nombres, qui sont les mutiples de 3 ...> n.

R(2) ==0 et Pi(2) ==5 idem tu connais Eratosthène.....> n tu vas me demander si j'ai bien barré les entiers congrus à 2,2 et 5 jusqu'à n.?? où Eratosthène est faux..?

R(3) == 4; et Pi(3) == 7 et bin je part de 4 et je marque tous les congruents à 4 modulo 7,  tous les 7 nombres....>n ("pour faire simple j'appelle ces entiers congruents de Pi==7")

R(4) == 8; et Pi() == 11 et bin je part de 8 et je marque tous les congruents de 11,  tous les 11 nombres....>n

tu as compris ou je continue jusqu'à 53...Je pense que c'est inutile et que l'évidence n'a aucun besoin de démonstration à moins de dire que Eratosthène est faux depuis >2000ans...

Donc tu me demandes en bon matheux, si les [1] qui ne sont donc pas barrés, ("car les barré sont les [0]") sont bien et ce quelque soit n choisi, constitus les nombres premiers q de n à 2n ; tel que 3000 -[1] == q premier pour cet exmple et bien entendu quelque soit n, comme Eratosthène qui donnera tous les entiers qui ne seront pas barré [1] les nombres premiers >1 jusqu'à n quelque soit n ....> vers l'infini...!

Ou Alors tu penses que dans tous tes pfam, en fonction de leurs P_i , il y en aurait : qui ne sont pas congrus à R (modulo Pi)...Je peux te garantir que tous tes pfam son bien congrus à 3000 [Pi] preuve ci-dessus...!

Tu as quand même remarqué, que dans le crible G(n) on utilise 1 car si 1 est marqué [0] 2n - 1 ne peut être un nombre premier...

Comme tout ce qui touche au crible d'Eratosthène et qui ont été prouvé, il en est de Même du CribleG , autrement dit:
la fonction du TNP qui dit que [tex]\pi{(n)}[/tex] vaut (n / ln n) lorsque n....> vers + l'infini , ce qui caractérise le crible d'Eratosthène;

Il en serra de même du cribleG, mais étant donné que l'on utilise les [tex]P_i\leqslant\sqrt{2n}[/tex] la fonction [tex]\pi{(n)}[/tex] devient [tex]\pi{(g)}[/tex] et le corollaire du TNP devient :[tex]\pi{(g)}[/tex] vaut (n / ln 2n) lorsque n....> vers + l'infini , ce qui caractérise le cribleG_(n) en réfèrence à Goldbach..... et le postulat de Bertrand ....je leur laisse, car inutile...!

Cher Yoshi sur ce, bonne nuit @+ demain il fera beau...et on verra la suite de ton algo ...

Ok : J'ai chargé l'ensemble des Pi que j'allais utilisrr : tous ⩽√2n.
1) n<nb<2n ok nb = 30k+b et tu vas tous les tester avec P_i ce que j'ai bien suivi...

2)

Ca veut dire que tu prends le nombres premier P_i suivant,  exemple: le 1er =7, suivant = 11 [......P_i ⩽√2n]

a) Qu'est-ce que Pi ? Ce que moi j'ai noté pi soit p['i] dans ton prog ? le même premier que toi, ci-dessus...(7 ,11....P_i ⩽√2n

b)

R_i c'est le reste R tel que  R=[nn%pi for pi in p] , qui ensuite est augmenté de P_i  si R est pair;  il devient j = R_i , Si R est impair augmenté de 2*P_i il devient donc aussi j = R_ij..

c)

oui   dans une des 8 Familles arithmétique de raison 30 , de premier Terme: 1 ou P_i[7;29] soit : dans le programme P8 [1,7,11,13,17,19,23,29] ou dans ton Dico = {1:0,...,29:7}

on positionne ce j = Ri pour indiquer la position de départ du crible avec  son P_i par famille et pour les 8 Familles ...
puis on passera au couple P_i et R suivant soit p=11 et R=8, et la liste des (j = r['i]) <= f.
.

pour n = 1500 p= [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53] ok

  pour n = 1500  :r (ou R ?) =[4, 8, 10, 8, 17, 10, 13, 24, 3, 7, 33, 39, 32] ok
qui ensuite vont être utilisés ; sont augmenté de P_i si pair ou 2P_i si impair, les fameux j 

Oui

oui. et non , car j est incrémenté de 2*P_i jusqu'à  la limite f qui vaut j+ P_i*29 ; c'est à dire le premier j tel que R +P_i bien sûr afin de les positionner dans P8[...]

ci dessous : j += incr et incr = 2*P_i

cela te donnera 16 j <= f au maximum et pour chaqueP_i.

Ce qui répond à ta question ci-dessous :

dans l'ordre R = 4  et non j je corrige  pour que R + 7 , devienne le 1er j = 11 pour ce Pi =7 , que je vais incrémenter
de 2Pi jusqu'à  f = 11 + 7*29 = 214...
mais pourquoi ? pourquoi pas une autre valeur multiple de 7 ? Mais pour Positionner le départ de 7 dans chacune des 8 Famille de P8...! car c'est 7 qui va cribler pas j , J donne la position de départ de 7 dans chaque famille..

tu passes j de 11 (ou autre) à 11 + incr, Pourquoi augmenter de cette valeur précisément ?
car il te faut bien les 8 positions de départ de 7 , dans les 8 familles , donc il te faut les 8 j que tu obtiens par incrémentation < 214 = f   (" et ce  pour chaque P_i qui criblera")

Puis tu testes 11 : ni congru à 0 mod 3 ni mod 5... Tu traites.. je testes car il faut bien que j=11, soit placé dans sa bonne Famille = 11 ('"modulo 30 additivement")  et ("selon cette fonction ci de-dessous en principe:")
ceci correspond dans l'algorithme à :
(11 - 11) // 30 == 0 d'où position de 7 cellule n° 0, famille 11 car le quotient == 0 ; ou si j = 11%30 == 0 soit dans Dico={11:2} la 3ème famille , quotient ==0, position de 7 nbcell n° 0 cette cellule =[1] se transforme en [0];
P_i  = 7...va donc cribler cette famille , en marquant toutes les 7 cellules [1] en [0] criblage modulo 7 additivement....
on passe au j suivant , que l'on teste...etc.
une fois les 8 familles criblées on passe à P_i =11 qui est le suivant et on réitère tout {" le R les 16j les 8 criblage des 8 familles...) la

(" je crois que j'ai détaillé à la page 3, la progression de j , il positionne 7, et 7 part cribler "sans oublier de transformer les [1] en [0] ")

_{b) Prenons "au pif" un reste R =1 et son Pi =7....  Pour quelle valeur de n ?}
Peu importe, c'est un exemple, qui montre comment on traite les j , à qu'elle famille ils seront affecté, pour : en fonction du quotient où "autre méthode" indiquer la position de P_i dans les 8 familles afin que P_i crible ses 8 familles , puis passer au P_i suivant...

tu n'as pas tout lu !!! la forme 3k-1, sont les 4 familles {11,17,23,29} qui modulo 9 auront pour reste {2,5 ou 8) ou plus simple additionne les chiffres d'un nombres jusqu'à sa dernière D_c, ex: 29 = 2+9 = 11 ,1+1 = 2,
ou chaque fois que tu obtient 9 soit 0%9  tu annules le 9; d'où 29 = D_c == 2. donc famille 29 [30] car il se termine par 9 si cela avait eu pour reste {1,4 ou 7} et bien cela aurait été la famille 19[30] (principe de la preuve par 9 ..
{"Oubliée depuis des lustres. que j'utilise toujours de tête"}

je te répond pour la fin de ton post @+

Ben on dirait que tu testes comme Eratosthène modulo P et non modulo P*30 car dans range "range" "il y a une limite de K qui va augmenter"
ligne 8:  K=[k*30 for k in range(k_min,k_max)] tu fais l'inverse, c'est à dire que tu prends le nombre de K, qui ensuite seront de la forme nb=30k+ajout , et qu'en fonction  de ta liste de Pi, tu va tester ces nb  un par un par les P qui ont été énuméré ; à savoir si il sont congru à 2n modulo P si oui (" je suppose flag == 0 donc ce i est transformer en 0, sinon flag == 1 , puis tu continues ta boucle avec i +=1 donc le suivant... et à la fin break tu sorts..") donc tu progresses modulo P...non???

dans notre crible, lorsque P crible, en partant de sa position dans chacune des 8 familles il crible modulo P*30 (additivement), car il compte les cellules donc les [1] par famille...exemple famille 30k+7 je représente sur une ligne :

n= 480. énumération de  P = [7;11;13;17;19;23; et 29]

1 ,1 ,1,1,0,1,1,1,1,1,1,0,1,1,1,1,max =15*30 + 7
7 +k*30................................ max= 457

premier test avec P = 7 et son reste R = 1  J = Ri, je progresse j + 2*p ..qui va donner 127. je n'ai fait que des additions  sauf pour le calcul du reste R....

Je place 127 = cellule n°4 la 5ème, et à partir de cette position, je compte 7 cellules, je marque la marque d'un 0, terminé pour cette famille avec p =7 .
j'ai bien criblé modulo 210 par addition...! sans faire de division.....!

toi dans cette famille tu testes 16 nombres pour savoir ce qui sont congrus à 2n modulo pi , avec chacun des Pi de ta liste énuméré P énuméré......?
donc 16 divisions dans cette famille....

alors que p= 17.19.23. et 29  ("même 13, dont le reste = 11 sa position serra 11+26=37; donc, position n° 1 et 1+13 marquera la cellule n° 14 point barre , Pi suivant et son R.. sans faire de division...")

les autres ne peuvent en faire aucune puisqu'il n'y a que 16 cellules....! C'est à dire 16 nombres = 30k +7 soit : [7.37.67.97.......457.]

Mais surtout je pense que même en criblant par  par Famille ça n'apportera rien...

la ligne   

dans le crible G et une grand importance avec la ligne Dico ={} ou P8 =[]...

Tout ça , sous réserve que j'ai bien interprété le fonctionnement de ton programme....Mais dis moi si tu crible modulo Pi *30....par famille
car si tu cribles les nombres30k + ajout , alors tu ne peux pas cribler modulo Pi*30....!
dort bien....
@+++

j'avais oublié :

Donnez la valeur de n = 30k : 1500000
CribleG6 mod30 : Initialisation: 0.04680013656616211 seconds ---
CribleG6 mod30 : Famille de chaque couple R et Pi: 0.0 seconds ---
CribleG6 mod30 : Criblage des 8 familles: 0.04680013656616211 seconds ---
CribleG6 mod30 : Extraction des premiers n à 2*n : 0.04680013656616211 seconds ---
On a 102661 nombres premiers

0+0+0+0 '' = 0'',1 10ème . Va à 23 mds ...LoLLLL

et pour la famille 30k+7 :

Donnez la valeur de n = 30k : 1500000
CribleG1_mod30 : Initialisation: 0.0 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 0.015599966049194336 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 0.031200170516967773 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 0.0 seconds ---
On a 12827 nombres premiers

c'est presque le temps faut à G1 pour 23 000 000 000....Loll
regarde : je pense que la limite se situe sur mon pc à 24 000 000 000:

il y a beaucoup d'enseignement à en tirer ...Déjà le postulat de Bertrand il y a au moins un nombre premier entre n et 2n, rime à rien...autant dire qu'il y a une goute d'eau dans l'océan...

tu vois que le criblage est linéaire et ce, quelque soit la famille choisie...

pourquoi ce crible est si rapide, déjà il ne travaille que dans des suites arithmétique de raison 30 donc il progresse modulo Pi*30 car si tu regarde le cribleG_(n) qui lui , comme Eratosthène classique, travaille dans l'ensemble des entiers naturels à partir de 1...il progresse modulo Pi...soit 30 fois moins vite...lorsque Pi = 500 000, et ben il fait des sauts de 15 000 000 ...

est que tu positionnes ta limite  j < f où f = Pi*29
ton calcul des reste R 2n%Pi à quel moment tu le fais dans le crible...car ça conditionne le temps de criblage .

tu dois : Etape A)
1) limite n ,
2) avoir la liste des Pi < sqrt de 2n ("eratosthène") ou répertoire de donné que le programme va aller chercher en fonction de sqrt de 2n,
3_) ensuite tu as dans l'ordre soit tu établi tes j = ri comme tu l'as fait dans G1 ..mais en prenant au fur et à mesure chaque Pi, puis calule du reste R , calcul des 15j à partir de R +Pi si pair ou R+2Pi si impair..
ensuite teste , position dans sa famille , criblage , retour au j suivant,  réitère : teste position criblage...les 8 familles criblées avec ce Pi.
retour au Pi suivant et tu réitères...à la fin comptabilite des [1]

ou:
Etape B)
tu calcules  après l'étape 1) et 2)
tous les restes R ce que tu as fait au début dans G1 ...pourquoi ? il te faut à chaque fin de criblage des 8 famille avec Pi aller chercher à nouveau le Pi suivant, et le R suivant....le reste ensuite ne changera pas ..
preuve: regarde les temps linéaires du criblage..

ensuite la vrai raison tu as été bon et tu as bien compris ce que mon crible devait faire et deux têtes pensantes peuvent donner de très bon résultats....preuve ci dessous...

tu as G1, si cela t'amuse dans l'étape A) fait le cacule des R après avoir été chercher Pi, au fur et à mesure du criblage des 8 familles et compare les temps en plus avec G1 tu sélectionne le criblage que d'une famille...

==== RESTART: E:\Documents\conjecture de Goldbach\cribleG1_par Famille.py ====
Donnez la valeur de n = 30k : 23400000000
CribleG1_mod30 : Initialisation: 198.29194831848145 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 15.92762804031372 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 180.46111679077148 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 59.264504194259644 seconds ---
On a 120565878 nombres premiers
>>>
==== RESTART: E:\Documents\conjecture de Goldbach\cribleG1_par Famille.py ====
Donnez la valeur de n = 30k : 23700000000
CribleG1_mod30 : Initialisation: 205.35876083374023 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 17.59683084487915 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 182.567120552063 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 63.66371178627014 seconds ---
On a 122046948 nombres premiers
>>>
==== RESTART: E:\Documents\conjecture de Goldbach\cribleG1_par Famille.py ====
Donnez la valeur de n = 30k : 23910000000
CribleG1_mod30 : Initialisation: 299.7545266151428 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 24.13324236869812 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 184.96952486038208 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 71.94732642173767 seconds ---
On a 123083742 nombres premiers
>>>

Re Yoshi , le Mr c'est pour te saluer et remercier sur le travail que tu as fait dans ce crible...

et pourtant c'est là qu'il y a une partie de la solution , afin de cribler la famille 30k + 1 ou P[7;29] que l'on désir cribler, afin d'obtenir les nombres premiers q de la même forme, de n à 2n .

je veux "on veut" cribler les nombres premier q = 30k + 19 de 300 à 600.

on doit donc cribler la famille 30k+11 de 11 à 300

1) il faut donc changer l'ordre de Dico={1:0....,29:7}

car le crible, va cribler dans l'ordre des famille qui lui ont été établi avec p8[1,7.....29]

l'ordre de Dico, devient: Dico={11:0,1:1.....,29:7} peut importe l'ordre de la suite après 11:0...il ne va cribler qu'une famille 30k + n [1;29]

2) il faut donc changer range(8) en (1) de partout où il est sollicité. en commençant par l'initialisation, la ligne:

résultat:
Donnez la valeur de n = 30k : 600
CribleG1_mod30 : Initialisation: 0.0 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 0.0 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 0.0 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 0.0 seconds ---
[[0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0]]
On a 8 nombres premiers q, de 300 à 600, tel que 600 -[1] = 30k+19

Tu peux vérifier:
la 4ème cellule  la n°3, = 11 + 90 =101 suite arithmétique de raison 30, de premier terme 11....! Et:
600 -101 = 499 ,

"soit 600 se décompose en somme de deux premiers...LoLLL"

C'était vraiment bête....depuis que je cherche .....

regarde ce que donne le crible maintenant pour 9 000 000 000:

Donnez la valeur de n = 30k : 9000000000
CribleG1_mod30 : Initialisation: 14.227225065231323 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 1.0920019149780273 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 64.38131284713745 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 22.3392391204834 seconds ---

On a 48272991 nombres premiers--- 30k+19, de 9000000000 à 18000000000.

il est simple à partir de ce crible de vérifier et prouver que la densité de premiers entre n et 2n et en moyenne générale la même est infinie...!
car tout simplement le crible, crible de façon uniforme et identique dans les 8 familles,  suivant le principe d'Eratosthène , avec les nombres premiers [tex]P_i\leqslant\sqrt{2n}[/tex]

Donnez la valeur de n = 30k : 12000000000
CribleG1_mod30 : Initialisation: 20.280035495758057 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 1.6224026679992676 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 88.09335470199585 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 29.671252250671387 seconds ---
On a 63579183 nombres premiers...30k+19, de 12000000000 à 24000000000 de la forme 3k+1

Et un dernier pour te Saluer: famille 30k+7 pour les nombres premiers q = 30k+23  de la forme 3k-1

Donnez la valeur de n = 30k : 12000000000
CribleG1_mod30 : Initialisation: 19.063233613967896 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 1.6536030769348145 seconds ---
CribleG1 mod30 : Criblage des 8 familles: 89.10735654830933 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 29.686851978302002 seconds ---
On a 63579248 nombres premiers

Tu peux même utiliser le compteur de temps pour la densité  du nombre de premiers par famille...et faire breveté le principe.....Lolll
la fonction [tex]\pi{(G)}[/tex] qui compte les entiers de 7 à n, non congrus à 2n modulo Pi , vaut lorsque n tend vers + l'infini :[tex]\frac{n}{Ln 2n}[/tex]...

je l'ai fait sur excel pas à pas  avec mon petit fils je lui montrai au fur et à mesure ce que je faisais mais ensuite le traduire en langage python ou autre pour que le pc le comprenne ça fait deux et de plus tu me l'a fait remarquer un peu plus dans tes posts ça dépend du programmeur...comment veux que je comprenne exactement ce que fait le programme pas à pas ...je sais ce qu'il doit faire...dans l'ordre..mais ça et le langage du programme: c'est un indien qui parle avec les signes à un polonais...

tu vois bien le travail que tu as fait par rapport au crible de départ.. tu as utilisé le dico pour transcrire l'ordre des 8 famille de P8, tu ne t'ai pas planté sinon le résultat du nombre de nombres premier de n à 2n serait faux...tu as même remarqué qu'il était faux pour de petites valeurs...lorsque j'ai trouvé la solution, cela n'avait rien à voir avec ce que je faisais pas à pas et pourtant...quel rapport entre prendre j jusqu'à f et j jusqu'à n..ça va moins vite et faux ...et bien le résultat sur le crible était pas évident...lorsque je prend que la famille congrue à 11 [30] dans excel je crible la 3ème, dans le programme  dico= [  ,11:2 ,  ] quelqu'un qui comme moi ne comprend pas du la programmation , tu me le demande je te dis : et ben c'est 11 divisé par 2 ...

comment veux tu que maintenant je lui demande de ne prendre que la famille 1 et 11 modulo 30, par exemple :
j'écris dico = [1:0,11:2]
dans p8 je met p8 = [1 ,11]  et bien à la fin de la nuit je tourne en rond...
là miracle... il ne sort qu'une famille et pas dans l'ordre bien sûr  et par ce que j'ai supprimé [dico] de partout...car même pas il m'ouvrait la fenêtre... Tout ça pour te dire , mon petit fils qui me disait c'est pas grave si je ne comprend pas le fonctionnement du crible...tu parles...!

pour que le programme aille cribler que deux familles 1 et 11, je ne pense pas qu'il faut mettre p8= [7,13] et dico= [1:0,11:1] parce que peut être que dans  la famille 1 modulo 30, les j seront bien positionné, avec les bonnes valeurs et son Pi criblera bien,  mais je doute fort que la famille 11(mod 30) soit juste...et si on vérifie,  en remettant la valeur des [1]  et ensuite 300 - [1] , ça m'étonnerait que l'on sorte un nombre premier q congru à 19[30]...heureusement qu'on en a pas besoin car inutile   mais les nbcelle[1] qui représente les entiers, doivent être bien marquées .
c'est pareil si avec Eratosthène je crible les multiples de 7, avec pi = 11 , en partant de 7 ....jusqu'à n = 150...

Passe une bonne nuit ...Merci Yoshi....

voila un exemple de la famille 1 [30] le travail et le temps sont exact mais pas le résultat final ...On peut cribler plus loin...

Donnez la valeur de n = 30k : 9000000000
CribleG1_mod30 : Initialisation: 13.400423526763916 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 0.5772008895874023 seconds ---
CribleG1 mod30 : Criblage de la familles: 66.90951776504517 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 24.726043224334717 seconds ---
On a 65668177 nombres premiers (# nombre faux car mal paramétré )
Appuyez sur une touche pour continuer...

voila ce qu'il faisait avant que tu décrasses tout...
là, il vérifier les deux familles 1 et 11 mod 30 , puis, 7 et 17 ; 13 et 23 et19 et29

maintenant je ne veux que  la famille 1 ou 11 peut importe même que la 7 , mais une seule , donc actuellement il me fait la famille 1, exemple post ci dessus , mais je n'arrive pas à le paramétrer...