Forum de mathématiques - Bibm@th.net

Bonjour @Yoshi

Ben.... tu viens de répondre à mes questions, je n'étais pas sûr que les j été traités un après l'autre et qu'ils étaient en mémoire cache d'après cette  ligne :

,
pour ensuite être rangé  Dico[j%30]dans fam..afin de calculer l'index de départ puis criblage par pas de pi...dans liste nbcell pour remplacer les 1 par des 0 .

je travail avec ta dernière version par famille uniquement... ce qui fait qu'effectivement pour chaque pi je ne travail qu'avec un j%30==1 que je range Dico[1] dans fam...

ce qui m'a fait posé cette question, c'est que lorsque j'édite les j, il m'édite le dernier j relatif au dernier pi

par exemple si je tape n=2400000
avec print (j) à la fin de # FAMILLES POUR CHAQUE Pi

il me donne :
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4Y_modulo30.py =====
Donnez la valeur de n = 30k : 2400000
Phase d'initialisation: 0.0 seconds ---
65033
Bloc S2_s3 : 0.015600204467773438 seconds ---
Extraction des premiers n à 2*n : 0.0 seconds ---

**  19933 nombres trouvés en 0.015600204467773438 secondes **
>>>

Ce qui me fait penser qu'il traite les 15j  relatif à la boucle :

, Ce qui est normal puisqu'il travaille dans les 8 famille...

alors que ne travaillant que dans une seule  famille , je n'ai besoins que d'un j%30==1 que je range Dico[1] dans fam...
Donc je cherchai le moyen d'arrêter la boucle dès que j%30==1 était trouvé, sans aller jusqu'à fin = min(1+r+pi*29,nn)..

Ceci dit.... je ne pense pas que cela changerai grand chose....
@+

Bonjour
j'ai laissé tourner un peu le cribleG4Y pour n = 29 970 000 000 , car je pensais qu'il "beuguait" et ben non:

Donnez la valeur de n = 30k : 29 970 000 000
Phase d'initialisation: 3.6816067695617676 seconds ---
Bloc S2_s3 : 5224.839176654816 seconds ---
Extraction des premiers n à 2*n : 31.137654781341553 seconds ---

**  152859833 nombres trouvés en 5259.658438205719 secondes **
Appuyez sur une touche pour continuer...

******************************
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4Y_modulo30.py =====
Donnez la valeur de n = 30k : 29 100 000 000
Phase d'initialisation: 4.321207523345947 seconds ---
Bloc S2_s3 : 173.519104719162 seconds ---
Extraction des premiers n à 2*n : 7.363212823867798 seconds ---

**  148600698 nombres trouvés en 185.20352506637573 secondes **

c'est quand même curieux la différence de temps qu'il y a pour n = 29 100 000 000 pour une différence relativement faible

sqrt de 2*29970000000 et sqrt de 2*29100000000 :  ce qui représente environ un écart de 300 nombres premiers p_i en plus, qui vont cribler très peu de nombres...

De ce que j'ai pu comprendre ça ne criblerait pas; du fait que pour (fin,) j'ai mis (j+pi*(1-j%2))%30==1, en croyant que des l'instant où il y a j%30==1 cela terminait le processus des j , donc inutile d'aller jusqu'à pi*30.... et que l'on passerait à la phase criblage....

Je vais essayer ta modif pour la fam=Dico [1]

moi j'ai tester 36 000 000 000, mais pour une famille soit : 1 200 000 000 octets....voila pourquoi il faut cribler uniquement par famille, il en est de même pour Eratosthène modulo 30 ...où je vais jusqu'à 15 000 000 000 octets par famille...

Par contre tu dis que 255 ou 1, ne prend qu'un octet.. donc un entier n compris entre 7 et n/30 , quelque soit cet entier il ne prendrait qu'un octet....? car si c'est le cas on a pas besoins du tableau de 1 pour une famille ....mais cela m'étonnerait...!

Dans cette hypothèse il suffit de cribler modulo pi*30 en partant de R = j tel que j est le reste de nn%pi

exemple n= 3600 soit, 3600/30 = 120 [1] ok...

donc :nn =7200 ; pi = 7 on veut cribler la fam, Dico={1:0} donc : fam=Dico[1]

j = 7200%7 == 4
on cherche j < 7*30 , congru a 1 modulo 30

  il faut que cette ligne soit modifiée 

afin de ne s'occuper que de j%30==1
exemple :
4+7 = 11 qui correspond à j+pi*(1-r%2), 11 != 1%30 , on incrémente 11+14 = 25 ; 39 ; 53;  67; 81 != 1%30 ;95; 109; 123;137 ;
151 = 1%30 on passe à la phase criblage modulo pi*30 = 210

d'où :
151 +210+ 210 +210.....etc +210  jusqu'à <=3600 ce qui donne le nombre de [0] 16 +1 = 17 [0]   fin pour pi =7
et on stock les valeurs pour connaître les doublons afin de ne pas supprimer des [1] qui seraient marquer plusieurs fois ....autrement dit les valeurs sont les [0], une valeur qui apparaît plusieurs fois, ne vaut qu'un [0]
ce qui donne :
{151,361,571,781,991,1201,1411,1621,1831,2041,2251,2461,2671,2881,3091    ,3301,3511}
************************************
on passe à pi =11 on réitère 7200%11 == 6
6+11=17 on incrémente jusqu'à j%30==1 ; 17+22, +22 = 61 et 61%30 == 1 ok, on passe au criblage modulo pi*30 = 330

61 + 330 ....etc <= 3600

ce qui donne 10 [0] car il y a un doublon en rouge :

61,391,721    1051    1381    1711    2041    2371    2701    3031    3361  fin pour pi = 11
****************************************
on passe à pi =13 on réitère 7200%13 == 11
11+26 on incrémente jusqu'à j%30==1 ; 37+26, +26+26+26+26+26+26+26+26 = 271 et 271%30 == 1 ok, on passe au criblage modulo pi*30 = 390

271 ,661,1051,1441,1831,2221,2611,3001,3391
ce qui donne 7 [0] car il y a 2 doublons en rouge :
***************************************

etc....etc  jusqu'à pi = 83  il est clair que les derniers pi, ne vont pas marquer grand chose à part des doublons...

ensuite, à la fin comme tu l'as dit, on retranche le nombre de [0] de la somme des [1] = 120...

Est ce plus simple et plus rapide pour de grandes valeurs de n.....? est ce que l'on va à n = 30 mds....? car il faut trier les doublons....je doute que cela soit plus efficace....que de modifier cette partie , afin de chercher j=1%30 , et passer à la phase criblage , pour chaque pi:

j'ai remplacer le r par j, et on aurait pas besoins d'aller jusqu'à pi*30 pour une majorité des pi , puisque la fin est ordonnée par j%30==1

il suffit ensuite de changer j%30==p8;  par l'une des 8 familles que l'on veut cribler...

Bonjour.

["Pour la conjecture de Goldbach , je me suis peut être mal exprimé.
Ma question porte uniquement sur une famille, parmi les 8 familles de premiers.
Si par exemple je prend la famille d'entier n = 30k + 7 soit 2n = (2*30k) + 14 ; est ce qu'il existe 2* (30k + 7) qui ne satisferait pas la conjecture , on sait avec le crible que la densité de nombres premiers q [30k ; 2*30k +14] vaut $0,375 *\frac{30k + 7}{Ln (2*(30k+7))}$
on sait que pour $n\leqslant210$ la conjecture est vraie en règle générale, mais par exemple uniquement pour la famille 30k+1 on sait que 2n = 152 n'est pas somme de deux premiers (p,q )appartenant uniquement à cette famille. C'est d'ailleurs la seule, ce qui s'explique aisément avec l'écart entre les premiers < 150 dans cette famille..."]

Effectivement le crible permet de montrer la densité de nombres premiers [n ; 2n] , par famille ou pour les 8 familles. Ce qui après étude, permettra peut être de revoir la conjecture sous un autre angle et peut être ensuite de la résoudre...C'est pour cela, que je disait prenons l'un des 8 familles  30k + n, n[2;28]. Pour faire simple, la famille arithmétique 30k+7 , existe t'il un 2n = 2*(30k+7) qui n'est pas la somme de deux premiers (p,q) appartenant à cette famille...? Plus généralement avec les 3 familles arithmétiques de raison 30, de premier terme {7, 1,  13}...C'est pour les matheux....

Pour en revenir au crible: Pour une seule Fam.

....? Là, tu vas vite...Car comment tu cribles les 1 par pas de P_i en partant de son index....???

Tu peux toujours dire,  Exemple P_i = 7 j'ai n= 240, soit 240/30 = 8 , donc 8/7 = 1 il te faut soustraire 1 deux fois...ok..?
comment tu fais pour les autres Pi = 11,13,17,19 bien sûr connaissant l'index, compris entre 0 et 7 tu sauras que si l'index est compris de 0 à 7 , cela te donnera le nombre de 1 à soustraire...par contre tu ne sauras jamais si il y a des doublons dans la liste des 1, pour n= 3000 par exemple , d'où impossible de cribler sans erreur...! Et pour les 8 familles encore plus compliqué..!

On a pas le choix ..on est obligé d'initialiser la liste de 1 de 0 à n/30, justement pour cribler par pas de P_i, marquer les doublons, et on ne sait pas où ils se trouvent.
(" sauf bien entendu si on écrivait les valeurs de [1]..Et dans ce cas là , on en revient à une perte de temps et de mémoire car il faudrait écrire les entiers en progression arithmétique de raison 30, de Pi = {7,11,13,17,19,23,29,31} à n/30 ...").

Par contre on peut gagner en temps et en mémoire, si et uniquement par Famille : Exemple la famille j%30 == 1

1) On édite les P_i avec : Primes_init = eratostene(n)..... Cà on a pas le choix..

2) c'est dans cette partie du programme que cela se passe..[" ce que je n'ai pas réussi à faire"]

A mon avis: on calcule pour chaque P_i, au fur et à mesure,  le  r=nn%pi , puis les j jusqu'à j%30 == 1 
des qu'il est trouvé, stop ou fin.

ce qui fait modifier cette ligne : debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2 . Là , on ne stock rien...ok
on a le j%30==1 on passe de suite à la partie suivante pour cribler:

3)

une fois que P_i à criblé, on passe au P_i suivant, on réitère : calcul de   r=nn%pi , calcul du J%30==1
puis re criblage...etc...

Donc tu vois on va gagner un peu,  on évite de stocker tous les r=nn%pi , pour les rappeler ensuite , on ne stock pas les j...que l'on va ensuite classer dans leur famille, car il nous en faut qu'un seul celui qui est = à j%30==1; de plus, on sait qu'il se trouve entre r et pi*29 . On a plus besoins de Pfam...

Voila ce que l'on peut gagner...
Ensuite augmenter la ram comme tu dis...ce n'est pas le plus important...

De toutes les façons on serra limité...à environ n /30 = 15 000 000 000.
c'est ce que fait Eratosthène modulo 30 par Famille et il est plus simple; car on n'utilise que 8 P_i, les autres sont extraits au fur et à mesure, ils criblent et sorte du programme...
On a donc en mémoire la liste des 15 000 000 000 de [1], que l'on marquera par des [0].
Mais on est obligé aussi de les écrire...il est beaucoup plus rapide car on ne fait que compter par pas de P_i;
c'est le groupe multiplicatif des 8 premiers, qui avance comme un rouleau....qui extrait les P_i > 31 , afin qu'ils aillent cribler....etc...etc.

Tu avais raison, mais ce n'est peut être pas un pouième de pouième

===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4_modulo30.py =====
Donnez la valeur de n = 30k : 24000000000
Phase d'initialisation: 2.8548049926757812 seconds ---
Bloc S2_s3 : 119.7614107131958 seconds ---
Extraction des premiers n à 2*n : 6.0996105670928955 seconds ---

**  123530551 nombres trouvés en 128.71582627296448 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 2.5740044116973877 seconds ---
Bloc S2_s3 : 138.06024265289307 seconds ---
Extraction des premiers n à 2*n : 6.8328118324279785 seconds ---

**  138301355 nombres trouvés en 147.46705889701843 secondes **
>>>

===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4_modulo30.py =====
Donnez la valeur de n = 30k : 29100000000
Phase d'initialisation: 3.104405403137207 seconds ---
Bloc S2_s3 : 150.4622642993927 seconds ---
Extraction des premiers n à 2*n : 7.378813028335571 seconds ---

**  148600698 nombres trouvés en 160.94548273086548 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4_modulo30.py =====
Donnez la valeur de n = 30k : 29400000000
Phase d'initialisation: 3.744006395339966 seconds ---
Bloc S2_s3 : 166.06229162216187 seconds ---
Extraction des premiers n à 2*n : 7.628413438796997 seconds ---

**  150069716 nombres trouvés en 177.43471145629883 secondes **
>>>

il ne me reste plus qu'à vérifier si il passe à 30 mds....

la modif des 5 lignes est relatif au criblage par famille :

Et malgrès cela , le chilmiliblic n'avance guerre plus vite , un peu plus de capacité mémoire...on est presque à 30mds....

Voila ....Yoshi , Mais c'est un très bon crible avec un bon programme...Je t'en remercie ....

Pour la conjecture de Goldbach, on sait que l'on a suffisamment de nombre premiers q, pour satisfaire la conjecture ...
On peut même calculer la densité des trois familles P8 = [1,7,13] relatif à 2n = 30k + 14, où : uniquement ces trois familles peuvent  satisfaire Goldbach .

La densité est d'environ : ((15k + 7) / Ln (30k + 14)) * 0,375
Pour n = 3 000 007 , on a 73509 premiers q [n ; 2n] , pour une estimation de la fonction ((15k + 7) / Ln (30k + 14)) * 0,375  = 72081

Pour 29 850 000 000 il met 319 secondes , mais pas d'amélioration sur la limite < 29 910 000 000...ce qui n'a pas d'importance
@+

Là, tu arrives au bout du bout...LoLLLL

je pense que c'est la même programmation qu'Eratosthène modulo 30 , il faut cribler uniquement par famille, les j au fur et à mesure, pour ne pas utiliser trop de mémoire. et en une seule opération avec q, reste=divmod(j/30)

voila actuellement ce que cela donne pour la famille Dico={1:0}

je me suis un peu embêter pour trouver le bon paramètre
toujours pareil pour ,  for i in range(1): au lieu de (8)

Mais ensuite il faut modifier la ligne  if j%3!=0 and j%5!=0:  , comme ceci,   if j%30==1:
ce qui est logique puisque l'on ne va traiter que les j se terminant 1 , donc congrus à 1 [30].

résultat avec V.6.2 pour n = 24 300 000 000
>>>
=== RESTART: E:\Documents\conjecture de Goldbach\cribleG2Y_par Famille.py ===
Donnez la valeur de n = 30k : 24300000000
Phase d'initialisation: 2.3400042057037354 seconds ---
Bloc S2_s3 : 122.60061550140381 seconds ---
Extraction des premiers n à 2*n : 6.162010908126831 seconds ---

**  125009260 nombres trouvés en 131.10263061523438 secondes **
>>>

ta dernière modifiée
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3_modulo30.py =====
Donnez la valeur de n = 30k : 24300000000
Phase d'initialisation: 2.324404001235962 seconds ---
Bloc S2_s3 : 122.42901492118835 seconds ---
Extraction des premiers n à 2*n : 6.146410703659058 seconds ---

** 125009260 nombres trouvés en 130.89982962608337 secondes **  3/10éme
>>>

la limite maxi est de 29 850 000 000 en 772 "

Eratostène modulo 30 par famille, met pour n 60 000 000 000 , 300" mais cela n'à rien à voir avec Goldbach,  le criblage n'a pas de divisions , de plus ce n'est pas la même raison...ni la même fonction G(n) ...etc...

vuC'est ce que je pense : peut être que tu n'aurais pas fais attention à l'ordre des étapes du programme..

La première étape est bien dans l'ordre du programme, des j :

puis :

une fois traité par fam= Dico[j%30] ...!
C'est cette fonction qui classe dans l'ordre la vraie Fam....!

et ensuite traité par le bloc s3 début index pour criblage

c'est comme cela qu'à été écris le programme depuis le début...

comment veux tu traiter les j dans l'ordre de stockage, sans passer par fam= Dico[j%30]....?

Si ce n'était pas le cas, effectivement tu pourrais avoir les début d'index faux, ce qui n'est pas le cas et tu ne pourrais rien faire, pour faire fonctionner le programme, preuve il marche...! mais avec la fonction

que tu pensais inutile...

je t'ai indiqué l'ordre de fonctionnement du crible
1_) initialisation des [1] par rapport à n fixé = 240, ton exe...
2_) récupération des P_i d'Eratosthène
3_) calcul des reste R,  2n%P_i

4_) édition des j < = pi*29 : [11, 53, 67, 109, 137, 151, 179, 193], pour P_i ==7
etc etc tous les [j.........] pour P_i==11

[j.........] pour P_i==13
[j.........] pour P_i==17
[j.........] pour P_i==19

5_) traitement des vraie Fam pour les mettre dans l'ordre de Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}

donc ton exemple:  [151, 67, 11, 193, 137, 109, 53, 179]
et comme tu as 5 P_i, appartenant à [7;19]
tu auras 5 Fam [....................]

6_)ensuite début index et criblage bloc s3 ce qui donne pour la Fam ci dessus, [5,2,0,6,4,3,1,5] il y  a bien 8 début d'index; où est ce que c'est , ou que cela pourrait être faux...?
où est ce que tu as vue qu'ils étaient archi faux...? tous les programmes que tu as modifiés fonctionnent....

Mais ils y a deux blocs 2,3 qui font un travail, qui pourrait être réduit à un seul suivant, l'explication de mon dernier #post

à partir du point 4_)...c'est ce que je faisais avec excel ...ou autre ..

est ce que tu as vu le programme: def crible_G(n) du début  premières page  post #1 ("tu verrais en gros le principe...")

Bonjour @Yoshi

En résumé :

Pour n = 600 ; le dernier Pi = 31 et son reste R = 22 .
soit : R + Pi = j = 53

calcul des {15 j} ≤ f ,  f =31*29 = 899
{53, 115,177,239,301,363,425,487,549,611,673,735,797,859,921}

Traitement des j dans Fam,cpt[0,0,0,0,0,0,0,0,],-1
Fam =[301,487, 611, 673, 797, 859, 53, 239] pour le  dernier Pi = 31 et son R =22
Par  le boc s2:

Ce qui veut dire que le programme garde en stock et en mémoire virtuelle tous les J et les Fam,cpt[0,...,0],-1;
pour les traiter par le dernier bloc s3

Criblage de P8, des 8 fam jusqu’à n /30 ; par le bloc s3 avec la fonction :

Si cette fonction est enlevée, le criblage ne se fait pas de façon correcte.
Ce qui s’est traduit par une erreur du nombre de premiers # V .6.0. #

L’idéal, serait de traiter au fur et à mesure la liste des {15 j} ≤ f , au fur et à mesure avec une seule fonction :
q,reste=divmod(j,30) : ou avec,  fam ,Dico[j%30]= divmod(j,30)
en passant peut être directement au bloc s3, si on peut récupérer l’index lors de la phase :  fam =Dico[j%30].

Pour info voila ce que donne cette version, équivalente à l'avant dernière G1Y: pour la famille Dico = {7:0}

V=== RESTART: E:\Documents\conjecture de Goldbach\cribleG2Y_par Famille.py ===
Donnez la valeur de n = 30k : 29400000000
Extraction des premiers n à 2*n : 7.48801326751709 seconds ---

**  150067287 nombres trouvés en 168.4178957939148 secondes ** premier q [n ;2n]; Fam = 23 modulo 30
>>>
=== RESTART: E:\Documents\conjecture de Goldbach\cribleG2Y_par Famille.py ===
Donnez la valeur de n = 30k : 29550000000
Extraction des premiers n à 2*n : 7.534813404083252 seconds ---

**  150801281 nombres trouvés en 174.2055060863495 secondes **
>>>
=== RESTART: E:\Documents\conjecture de Goldbach\cribleG2Y_par Famille.py ===
Donnez la valeur de n = 30k : 29700000000
Extraction des premiers n à 2*n : 7.628413438796997 seconds ---

**  151535675 nombres trouvés en 424.33634519577026 secondes **

Bonkour @Yoshi

for index in range(debut_index, nbcell,pi): je ne vois pas pourquoi l'erreur viendrait de cette ligne , car il n'y a vraiment aucune raison....

Par contre cette ligne : debut_index=Fam[cpt]//10//3 est toujours génératrice d'erreur , mais surtout je ne comprend pas pourquoi  tu calcules le début index avec Fam[cpt]....??  est ce que Fam[cpt] représente les j....?

la marge d'erreur à l'ai exponentielle .. Et il n'est pas sûr que l'on ai un gain de temps...regardes le résultat :

cette version avec n= 300 000 000Extraction des premiers n à 2*n : 0.639601469039917 seconds ---

**  16825025 nombres trouvés en 9.952817678451538 secondes **
Appuyez sur une touche pour continuer...

avec G9Y
Donnez la valeur de n = 30k : 300000000
Phase d'initialisation: 0.28080058097839355 seconds ---
Famille de chaque Pi: : 0.28080058097839355 secondes ---
Criblage des 8 familles: 9.07921576499939 seconds ---
Extraction des premiers n à 2*n : 0.6240010261535645 seconds ---

**  15072378 nombres trouvés en 10.264817953109741 secondes **
Appuyez sur une touche pour continuer...

debut_index=Fam[cpt]//10//3 je viens d'essayer avec:  debut_index=Fam[fam]//10//3  et avec debut_index=j//10//3

toujours une erreur, moins importante ...

Extraction des premiers n à 2*n : 0.6708011627197266 seconds ---

**  16654488 nombres trouvés en 10.311618089675903 secondes **
Appuyez sur une touche pour continuer...

Ce qui apparait donc au niveau du crible, c'est une augmentation du nombre de nombres premiers , par exemple pour n = 3 000 000 000
gain de temps 1,5 seconde;  mais une erreur de 16 000 000  de premiers en plus...

Ce qui veut dire que le paramétrage est erroné d'où certain j sont mal indexés et ou mal positionnés , ou encore que des doublons ont été supprimés;

de ce fait les P_i ne font pas leur travail et ne marquent pas des [0] donc plus de [1]....!

voila le paramétrage et criblage correcte, ie; si il y a la bonne position des index  au départ de chaque P_i.

On a 87  Premiers P [600 ; 1200] ; pour n = 600

f1  : [0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0]<...>[0,0,0,1109,0,1049,1019,0,0,929,0,0,839,809,0,0,719,0,659,0]
f7  : [1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0]<..>[1193,1163,0,1103,0,0,1013,983,953,0,0,863,0,0,773,743,0,683,653,0]
f11: [0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1]
f13: [1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1]
f17: [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1]
f19: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
f23: [0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1]
f29: [1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1]

ce qui n'est pas du tout le cas avec la nouvelle version
en mettant la fonction print(nombres)

Bonjour @Yoshi
Tu disais, que la difficulté post#254 ci-dessus était:

je pense que l'on peut la résoudre assez facilement.

étant donné que jusqu'à ce bloc s2,3. on peut traiter par famille..en modifiant dans initialisation

   et en dessous Pfam=j; 

    #au lieu de (8)

Ainsi que dans dans

.
il suffit de choisir la première famille que l'on veut cribler par exemple la famille p8=7 , je modifie:

je passe la famille 7 en position 0, et 1 en position 1...

il suffit de modifier la partie s2 comme ceci on ne vérifie que si j%30==7, sinon au passe à j suivant:

ce qui devrait donner:

Est ce qu'il faut supprimer des lignes en amont , qui ne sont plus utiles, afin de traiter que les j <= f au fur et à mesure ,et pour chaque P_i ....? ou est ce que l'on peut laisser comme tel ....?

ce qui éviterait d'utiliser Pfam, et même Dico={1:0,.....29:7}
On ne stockerait, que pour chaque P_i que sa  la liste de j <= f ; au fur et à mesure que cahque P_i crible la famille p8 = 7 ou autre ....

Non...?

{"par contre je ne sais pas comment il faut réécrire les lignes ou en supprimer.... ..."}

voila ce que j'ai essayé et modifié  :

Mais comme tu peux le voir,  cela crée une erreur et sans gain de temps...alors qu'il y a moins de division en principe:

G9Y le bon code
Donnez la valeur de n = 30k : 3 000 000 000
Phase d'initialisation: 0.32760071754455566 seconds ---
Famille de chaque Pi: : 0.390000581741333 secondes ---
Criblage des 8 familles: 12.480021953582764 seconds ---
Extraction des premiers n à 2*n : 0.7644011974334717 seconds ---

**  16887073 nombres trouvés en 13.962024450302124 secondes **
Appuyez sur une touche pour continuer...

G1Y code modifié:
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 0.3120005130767822 seconds ---
Famille de chaque Pi: : 12.870022773742676 secondes ---
Extraction des premiers n à 2*n : 0.8268013000488281 seconds ---

**  23137528 nombres trouvés en 14.008824586868286 secondes **
Appuyez sur une touche pour continuer...

***************************************************************************
Par contre en modifiant uniquement la ligne :

par :

ce qui permet de ne prendre que les j de la famille p8 = 7 et de sauter les autres..
Bien entendu en modifiant Dico={7:0.......etc 29:7} on met donc la famille p8 = 7 à l'indice 0 dans Dico.

On à le bon résultat dans les deux cribles G1 et G9, mais on ne gagne rien en temps..

Bonjour@Yoshi
hier j'ai oublié de te répondre à cette question:

Bien sûr..C'est identique à Eratosthène modulo30...
les nombres premiers P_i repasserons plusieurs fois sur un même nombre n < n=30k, qui dans 2n se factorise par 2,3,4 ou plusieurs facteurs P_i, ils marqueront [0] alors que ce [0] est déjà marqué ...

Prend un simple exemple:
pour n = 30k = 4770; 2n = 9540

prends j = 41 famille p8 = 11, il serra marqué [0] à partir de l'index 1, par 7, 23 et 59; car 9499 se décompose en facteurs premiers {7,23,59} et: 7, 23, 59 vont commencer à cribler à partir de ce début d'index = 1

Ensuite : prend maintenant 2n + 30 = 9570

et bien tu vas trouver 41+30 = 71 trois fois, car 9499 est toujours divisible par 7,23,59 donc 71 est congru à 9570 modulo 7,23,59 

7%9570 = 1 = j et j+5*14 = 71
23%9570 = 2 , +23 = 25 =  j, et + 46 = 71
59%9570 = 12 et + 59 = j = 71

Ce qui implique que : 7 , 23 et 59 vont marquer [0] dans la famille p8 = 11, mais: à l'index 2...soit : (71-11) / 30 = 2.

A partir de cet index = 2 , les trois P_i vont cribler la fam = 11, supposons que tu écartes les doublons, il n'y aura que le premier P_i = 7 qui va cribler , les deux autres :23 et 59 seront écartés d'où, le crible est faux et cela se traduit par une augmentation de [1] donc plus de nombres premiers de n à 2n...

C'est pour cela que je te disais, ce crible n'est que la réplique d'Eratosthène , mais dans les congruences et d'où ce n'est qu'un corollaire du TNP, du TFA et du théorème de Chebotarev sur la densité de premiers dans des suites arithmétique de raison 30...

[ Pour la petite histoire: C'est élémentaire mais pas étudié ...Dommage... Au moins grâce à ton programme on peut étudier plus loin ...la répartition des nombres premiers de n à 2n...Car cet outil arithmétique permet de prouver de façon incontestable ces trois corollaires...!]