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).

#1 Re : Programmation » Comment "aller vers" en Python » Hier 07:52:24

LEG

Bonjour
@Freddy : et si tu parts du principe de jouer un seul numéro, tu as 5000€ à perdre , tu attends 20 tours de roulette avant de jouer ton n° plein , qui n'est pas encore sortie, par exemple le 11.
Ensuite tu commences à miser 1€ , et  à chaque tour tu rajoutes un € : 1,2,3, 4.....> soit : (n*(n+1)) / 2 = 5000€ .
Est-ce que tu vas sortir gagnant, ou tu auras perdu tes 5000€ .... Autrement dit, plus tu perds plus tu risque de gagner plus ....?

#2 Re : Programmation » Comment "aller vers" en Python » 15-05-2020 10:27:46

LEG

Tu es sûr que ce n'est pas le Bon, la Brute et le Covid.....

#3 Re : Programmation » crible en python » 21-03-2020 13:25:50

LEG

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/JDukrK2NVBP

#4 Re : Programmation » crible en python » 21-03-2020 10:17:51

LEG

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é.

@+

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

#5 Re : Programmation » Fusion de deux cribles » 18-03-2020 09:48:16

LEG

Bonjour
@Yoshi : je vois qu'hier j'ai oublié de répondre à ta question  (il faut que je récupère de mon retour du Québec ...encore dans le brouillard)

les deux programmes qui ont été retranscrit en C++ sont brut je suppose que c'est le code source car je les ouvre avec Code:bloc.pour les lancer...
je te les ai fait parvenir hier soir par Mail ...ainsi que ma résolution de la conjecture.

Il y a quand même des fonctions intéressantes au sujet de cet Algorithme de Goldbach ou du dernier programme EG que tu as fais et qui est excellent

par exemple prenons la limite n = 3 000 000 000 avec sa Fam(i) = 7[30] , et la Fam(i) complémentaire = 23[30] le nombre de couple P'+q = 2n de ces deux familles =
Nombres P' non congruent  à un élément de $P_{2n}\leqslant\sqrt{2n}$ de 1 à 3000000000 famille 7, ou couple p+q=2n : 2 860 259 -

$\pi(n) = 7[30]$ vaut pour n = 3 000 000 000 : 18 056 145 nombres premiers $P'$

et $\pi(n) = 23[30]$ vaut de n = 3 000 000 000 à 6 000 000 000 : 16 887 276 nombres premiers q

Or la fonction asymptotique du nombre de $P'$ criblé par EG serra toujours inférieur au réel  et qui vaut environ : $\frac{\pi(n)}{log\;\pi(n)}$ soit pour ce cas : 1 080 624 couples P'+q = 6 000 000 000 , qui serra bien inférieur au réel , car on ne tient compte dans ce cas précis uniquement des nombres premiers
$P'\in{[7 ; n]}$ qui seront criblé par EG

Alors que le décalage des congruences et par conséquent l'algorithme de Goldbach, tient compte des entiers A de 7 à n, en progression arithmétique de raison 30 qui ne sont pas des nombres premiers , mais qui précèdent des $A$ premiers P' , non congruents à $P\in{P_{2n}}$ ; c'est à dire $2n\not\equiv{A}[P]$

Dont le nombre de $A$ dans cette $fam(7)$ qui vont être criblés vaut : (3000 000 000 /3,75) / 8 = 100 000 000. le résultat de la fonction asymptotique , qui est une conséquence directe du TNP, donne : $\frac {100000000}{Ln\:200000000} = 5 231 814$ de $A$ non congruent à $P$ donc bien supérieur au résultat réel du nombre de couples $P' + q = 2n$ et supérieur bien sûr à la fonction $\frac{\pi(n)}{log\;\pi(n)}$ qui en donne une estimation.

on s'en fou du nombre de nombres premiers $q$ de n à 2n de la Fam(i) = 23[30] puisque l'algorithme indique les $A$ non congruents à $P$ donc $P$ $\in $ $P_{2n}\leqslant\sqrt{2n}$ ne divise pas la différence $2n - A$, qui est donc un nombre premier q suivant la propriété des congruences utilisée par cet algorithme ...
Ou encore par la propriété du crible d'Ératosthène, qui permet d'affirmer que si un nombre B tel que $2n - A = B$ n'est pas divisible par $P\leqslant\sqrt{2n}$
et ben il est premiers q  et il est bien dans l'intervalle $[n ; 2n]$ ou je me trompe ?

Mais qui plus est, on put utiliser qu'une seule fam(i) pour trouver le nombre de A = P', non congruent à $P$ qui permet de vérifier la conjecture pour un nombre de couples minimum, $P' + q$ qui décomposent $2n$ en somme de deux premiers ; sans avoir à s'occuper des nombres premiers $q\in{[n ; 2n]}$.

@+

Il y a un autre intérêt avec cet algorithme, c'est de connaître de grands nombres premiers de 500 à 1000 chiffres en criblant les entiers A non congruents modulo $P\leqslant\sqrt{2n}$ cela peu être plus rapide qu'Ératosthène ....peut être....
l'idée on utilise une fam(i) et une limite n=30k pour utiliser n'importe laquelle des 8 fam(i)
par exemple fam(11) ..
on vérifie si $11$ est non congruent modulo P...mais tu vas me dire il y a un paquet de nombres premiers P à vérifier, donc aussi long qu'avec Ératosthène , mais en partant de 11, modulo 30avec un algorithme probabiliste cela va aussi vite voir plus vite qu'avec les nombres de Mersenne car il y a beaucoup plus de couples de nombres premiers P' + q qui vérifie 2n.
je l'ai fait sur le site d'Alpertron en prenant de petit A, non congruents à P que j'ai additionné à $2n = 10^{25} * 30$avec A = 247 on peut aussi soustraire
tel que $2n = 10^{200} * 30 - 247$, puis descendre modulo 30...il ne faut pas attendre longtemps pour trouver de grands nombres premiers...
@+

#6 Re : Programmation » Fusion de deux cribles » 17-03-2020 13:34:00

LEG

ok tu as raison, j'étais avec l'idée de voir le nombre de couples P+q = 2n aux alentour de 400 000 000 000 faire 5 à 6 tests en augmentant la limite n par itération de 15, afin de regarder le comportement et la variation du nombre de couples
Mais effectivement cela ne changera pas grand chose si je le fais à partir de 27 000 000 000  sur trois fam(i) différente en augmentant de 15 sur 6 tests différents

quant à la démonstration elle utilise la récurrence du crible et l'absurde
paragraphe au point 6a et la suite..que je peux t'envoyer...

#7 Re : Programmation » Fusion de deux cribles » 17-03-2020 11:47:27

LEG

Bonjour
@Yoshi
de ce que m'avait dit Parisse , la mémoire Python sature à partir d'une limite > 30 000 000 000 , et , effectivement concernant les 2 programmes que tu as fais  optimisé au maximum , qu'il a retranscrit en C++ , il n'y avait pas photos...

Mais en plus il les a repris pour utiliser des tableau (slices) qui les a rendu encore plus performant , puisque pour une famille criblée par Ératosthène ou Goldbach je fixe la limite n = 7 550 000 000 000 , tu vois un peu la différence avec Python ou je ne dépasse pas les 30  000 000 000 , et la rapidité qui va avec ...
Même mon ancien crible Ératosthène modulo 30 en c++, fait il y a plus de 20 ans il rame à côté de ces deux C++.

en regardant sur le lien que tu as indiqué avec Cython je doute que l'on arrive à aller aussi vite et aussi loin que l'un des deux programme fait en C++ ...Mais comme tu dis il faut voir...

à titre d'indication avec cet ancien programme je vais pour une Fam(i) et limite jusqu'à n = 450 000 000 000 en 2 heurres 1/2
Ceux de Parisse mettent 1 minute 40 secondes.....

est ce que tu veux que je te les fasse parvenir par mail ou tu les as déjà ?

deuxième question , je peux aussi mettre la résolution que j'ai terminée, sur le Forum , par un lien de cjoint . com il y a tous les programmes en fin de document
Python C++ et le dernier celui qu'il faudrait retranscrire en C++ , à moins de fusionner les deux C++ ...
Et si Fredy peut y jeter un regard...avec toi

@+

#8 Re : Programmation » Fusion de deux cribles » 12-03-2020 15:55:08

LEG

Bonjour:
Il y aurait t'il une âme charitable qui pourrait Retranscrire le programme Python EG, en C++ et en utilisant les slices ...? ou fusionner les deux programme C++ des deux algorithmes en utilisant les slices (rapidité et mémoire) que j'ai à disposition..?
Ils sont dans le forum ci dessous (crible en python par LEG [ 1 2 3 … 16 ]... mais je peux les remettre . Cordialement .

#9 Re : Programmation » Fusion de deux cribles » 11-03-2020 13:33:43

LEG

Bonjour à tous

@Yoshi

J'ai repris dans le post ci-dessus les définitions des éléments de l'algorithmes qui interviennent dans les deux cribles que tu as programmé.

Seul la démonstration récurrente de L'algorithme de Goldbach , n'est pas tout à fait indiquée mais simple à trouver avec les illustrations qui suivent en fin du post ci-dessus ! il s'agit d'une propriété récurrente des congruences très élémentaire .
@+

#10 Re : Programmation » Fusion de deux cribles » 15-02-2020 20:00:36

LEG

je t'imaginai et ....je rigolai tout seul...Allez passe une bonne soirée j'attends ton mail, j'ai fais la demande à B Parisse et je lui ai envoyé la version Criblage_EG...

..................................................................................................................................................

[("On peut néanmoins se rendre compte que ces $8 Fam(i)$ définies ci-dessous représentent 26,666...% des entiers naturels non nuls , par conséquent si on prend une limite $n$, le nombre d'entiers de ces $8 fam(i)$ s'obtient simplement par la division de $n$ par $3,75$ c'est à dire que pour $n=30$, on a: $30 /3,75 = 8$ ce qui donne les 8 débuts $(i)$ = 1,7,11,13,17,19,23,29 des 8 suites arithmétiques de raison 30, excluant par conséquent les multiples de 2,3 et 5"

Pour tout nombre 2n modulo 30 $\geqslant{300}$ , il y a donc un couple de nombre $P'+ q =30k + 2(i)$ appartenant à ces $Fam(i)$ qui vérifie la Conjecture de Goldbach. "note : 1 n'étant pas un nombre premier, il ne peut être utilisé pour vérifier 2n[30]; mais on l'utilisera dans l'algorithme par exemple, pour dénombrer le nombre de nombres Premiers $q\in{[n;2n]}$..ou pour indexer le départ des nombres $P$ qui criblent jusqu'à la limite $n = 15k + i$.

Pour fixer la $Fam(i)$ en fonction de la forme de $n=15k + (i)\geqslant{150}$ il suffit de procéder par soustraction avec $2n[30]$, tel que :

$(30k+2)$ - Fan(1) = Fam(1) modulo 30 bien sûr; ou encore:(30k+2) - Fan(13) = Fam(19) , L'Algorithme de Goldbach AG, donnera un couple
$P'+q =(30k+2)$, en utilisant les congruences.

$(30k+4)$ - Fan(11) = Fam(23) ; ou encore:(30k+4) - Fan(17) = Fam(17) , L'AG donnera un couple $P'+q$ vérifiant $(30k+4)$

ou encore: $(30k+6)$ - Fan(7) = Fam(29) ; ou:(30k+6) - Fan(13) = Fam(23) , ou: (30k+6) - Fan(17) = Fam(19);

L'AG donnera un couple $P'+q$ vérifiant $(30k+6)$ ...etc etc.

Il est clair, que deux éléments de ces Fam(i) peuvent appartenir à une seule Famille ou à deux distinctes, en fonction de n")]
Sans perte de généralité on peut n'utiliser qu'une seule $Fam(i)$ pour vérifier la conjecture pour toute limite $n = 15k + i$ fixée à partir de $n\geqslant{150}$
....................................................................................................................................................

(1-)

On va introduire les éléments entrant dans le crible d’Ératosthène ainsi que dans l'algorithme de Goldbach:

Le crible d'Ératosthène vise à marquer les multiples de $p\in{P_n}\leqslant\sqrt{n}$ de $1$ à $n$.

Ou avec $P\in{P_{2n}}\leqslant\sqrt{2n}$ de $7$ à $n$ utilisé par l'algorithme de Goldbach qui vise à marquer les entiers congruents à $P$

On peut se restreindre aux entiers naturels impairs non nul, excluant les multiples de 2, 3 et 5 définis ci-après :

on défini l'ensemble des entiers naturels $A_n$ impairs, non nuls excluant les multiples de (2;3 et 5):  appartenant à $[1 ; n]$ en progression arithmétique de raison 30.
Avec $A\in{A_n}$; $A$ est par définition soit multiples de $p$ soit un nombre premiers $P'\in{P'_p}$ de $7\;à\;n$, défini ci-dessous.

on défini l'ensemble des nombres premiers $P_n\leqslant\sqrt{n}$  appartenant à $[7 ; n]$ ; avec $p\in{P_n}$

on défini l'ensemble des nombres premiers appartenant à $[7 ; n]$ : $P'_p\leqslant{n}$  avec $P'\in{P'_p}$ et tel que : $p\leqslant{P}\leqslant{P'}\leqslant{n}$

on défini $A_n$ en progression arithmétique de raison $30$ appartenant à une des 8 famille $Fam(i)$
$Fam(i)$ est l’ensemble des nombres $A\in{A_n}$ entrant dans la progression arithmétique de raison $30$ et de début $i$.

Soit $B_{2n}$ l’ensemble des nombres en progression arithmétique de raison 30, qui appartiennent à une des 8 famille $Fam(i)$, $\in{[n, 2n]}$ ils sont soit multiples d’un élément de $P_2n\leqslant\sqrt{2n}$, ou pas.

D'où par définition, pour tout $B\in{B_{2n}}$ , $B$ est soit un nombre premier $q$ soit un nombre $C$ multiple d'un élément de $P_{2n}$  les nombres $B\in{B_{2n}}$ sont par conséquent complémentaires aux nombres $A$ $\in{A_n}$ après le passage de l'algorithme de Goldbach vérifiant la conjecture.


(2_)
on va introduire la notion de Famille $Fam(i)$
$Fam(i)$ est donc l’ensemble des nombres entrant dans la progression arithmétique de raison 30 et de début i, défini ci-dessus.

Nous allons nous intéresser aux familles $Fam(1)$, $Fam(7)$, $Fam(11)$, $Fam(13)$, $Fam(17)$, $Fam(19)$, $Fam(23)$, $Fam(29)$.
("on peut montrer que tout nombre premier $P'$ supérieur à 30 appartient à l’une de ces 8 $fam(i)$, mais ce n'est pas le but")


Donnez N = 15k = 27 000 000 000
Nombres $P'$ tel que $2n\not\equiv{P'}[P]$ de 1 à 27000000000 famille 7, ou couple $P'+q = 2n$: 21 192 447 ----- 700.09

Par curiosité , je me suis demandé, combien de nombres premiers P' = 7 [30] sont congruents à $P$ soit :$2n\equiv{P'}[P]$ en utilisant les deux cribles fusionnés, que l'on verra ci après ces 4 criblages de nombres premiers. Avec $P'$ appartenant à $[7 ; n]$ et $P\leqslant\sqrt{2n}$

sachant :
1_) que pour $n = 15(k+1)$ = 27 000 000 015
2_) ce nombre de premiers P' ne peut varier tout au plus que de + 4 à - 4 .avec Ératosthène.
3_) et il en serra de même entre $n$ et $2n$ avec Goldbach, la quantité de premiers $q$ = 23 [30] ne peut varier que de façon négligeable, car les densités de premiers sont en moyenne générale la même par Famille, du fait qu'il s'agit du même Algorithme qui crible.

On crible le nombre de nombres premiers P', avec Ératosthène:
4_) Donnez N: 27000000000 Nombre premiers P' criblés, famille 7 : 146922404 --en 151,47 secondes
5_) Donnez N: 27000000015 Nombre premiers P' criblés, famille 7 : 146922404 --- pas de surprise ..identique

Inversement Criblons la fam 23[30] qui sera sa complémentaire dans Goldbach, pour la même limite $n$

6_) Donnez N: 27000000000 Nombre premiers q criblés, famille 23 : 146925057 ----- 152,59"
7_) Donnez N: 27000000015 Nombre premiers q criblés, famille 23 : 146925057 --- idem ..identique

la densité est oscillatoire soit en fonction de la limite $n$ criblée et la position de départ des index qui varie ; ce qui peut occasionner soit plus de premiers $P'$ d'une Famille par rapport à une autre, ou moins...! mais de façon négligeable. Exemple:

Pour la même limite n, on crible le nombre de nombres d'entiers A congruents à P, avec Goldbach :
4_bis) Donnez N: 27000000000 Nombre premiers q de n à 2n criblés par G, Fam 7 : 138298148 ....2,481
5_bis) Donnez N: 27000000015 Nombre premiers q de n à 2n criblés par G, fam 7 : 138298148 ---

pas de surprise et on crible les entiers $A$ de $1$ à $n$, tel que : $2n\equiv {A}[P]$  Ce qui implique les nombres premiers q ; on est quand même loin du postulat de Bertrand , qui ne veut plus rien dire sur la répartition du nombre de nombres premiers q de $n\; à \; 2n$ ....

De ce constat , déjà on peut se demander comment cette conjecture de Goldbach a pu passer à travers...?

car selon le même processus, il suffit donc de cribler les nombres premiers de la Fam 7 pour les mêmes limites et tant qu'on y est, son inverse qui est la Fam complémentaire 23[30] et de vérifier les nombres premiers P' congruents à P; connaissant le nombre de P' non congruents à P, qui donnent le nombre de couples P' + q ; ci-dessous en utilisant l'algorithme fusionné.

8_)Nombres $P'$ non congruents à $P$ ou $2n\not\equiv{P'}[P]$de 1 à 27000000000 famille 7, ou couple P'+q=2n: 21192447 ----- 700.09
9_)Nombres $P'$ non congruents à $P$ de 1 à 27000000015 famille 7, ou couple $P'+q=2n$: 22882964 .. ça augmente pour $15(k+1)$ , donc : si on avait supposé la conjecture fausse pour $n=15(k+1)$, ceci est impossible...!

Car il faudrait que tous les $A$ soient congruents à $P$, avec les restes R précédents et les nouveaux R, relatif à la limite $n$ augmenté de 15 mais avec les mêmes premiers $P$...
Voyons avec sa Fam(i) inverse: la Fam 23...

8_bis)Nombres $P'$ non congruents à $P$ de 1 à 27000000000 famille 23, ou couple $P'+q=2n$: 21191454 ----- 818.31
9_bis)Nombres $P'$ non congruents [P] de 1 à 27000000015 famille 23, ou couple $P'+q=2n$: 22887641 ...

Et bien là aussi, le même processus donne le même résultat en moyenne ..! ça augmente pour $15(k+1)$ mais cela aurait pu diminuer légèrement , donc :

si on avait supposé la conjecture fausse pour $n=15(k+1)$ et bien impossible...Car la propriété récurrente de l'algorithme dans les congruences ne fait que répliquer une image décalée d'un rang, ayant vérifiée la conjecture précédemment; où le seul inconnu est le premier terme dans Goldbach et le dernier dans Ératosthène; mais aussi du fait que les restes R de 2n par $P$ changent pour chaque nouvelle limite $n +15$ .!

Ce décalage d'un rang des entiers non congruents et valable tout autant pour les multiples de $P$. Ce que le processus de fonctionnement montre parfaitement, illustré ci-dessous :

Les congruences de la liste G se décalant d'un rang, implique les entiers marqués en rouge par les congruences , ou les $0$ marqués en noir donc, non congruents à $P$ dans la liste E  au dessus, en criblant à nouveau n=15(k+1); simple à vérifier avec les illustrations ci après . ....etc.

Alors la question , ne serait plus de se demander est ce que la C de Goldbach est fausse ...?

Car le processus de cet algorithme de Goldbach dans les congruences, a la particularité d'indiquer et de montrer que :

10_) Quelque soit la Fam(i) fixée par rapport à la forme de $n\geqslant {150}$, quelque soit la limite $n=15k$, il vient que pour $n =15(k+1)$ on ne ferra que constater le décalage des congruences d'un rang, qui ont vérifiées ou pas la conjecture...!

Ce qui explique en autre, cette même densité de nombres premiers $q$ de $n\: à\: 2n$.

On obtient donc, suivant la propriété du Crible G: (« Si un entier A de 7 à n, qui est non congruent [P]et si il précède un nombre premier $P'$, la conjecture sera alors vérifiée pour :  $n = 15(k + 1)$. »). Ce qui se vérifie élémentairement:

11_)C'est à dire , si la conjecture est vérifiée pour :
$n=15k$ elle le serra tout autant pour $n=15(k+1)$ suite à ce processus de fonctionnement impliquant le décalage d'un rang des congruences, aussi bien pour les nombres premiers q de n à 2n que pour les couples de nombres premiers P'+q = 2N...!

Il suffit de le mettre en forme Mathématiquement, un peu mieux que je ne le fait...bien entendu, avec l'illustration qui montre le processus de fonctionnement et sa propriété récurrente, impliquant cette récurrence et le raisonnement qui s'ensuit.

Note : le résultat final de l'algorithme EG, permet uniquement d'en tirer des fonctions et d'analyser les courbes de 1 à N et par famille, sans s'occuper de 2N....

Illustration Fam 7, avec 15k = 1200; où il suffira de superposer les listes G sur la liste E
liste E: on va marque en rouge les entiers correspondant aux 0 de liste G les indices indiquent le décalage des congruences de Elorsque n augmente de 15.

En supposant que seulement un élément vérifie la conjecture, par exemple l’indice 13 = (13*30 + 7) = P et donc on peut admettre qu’elle sera fausse pour N = 15(k+1) et en effet, l’indice 12 suite au décalage des congruences, invalidera la conjecture car : P = (397) d’indice 13 d’Ératosthène, serra marqué en rouge d’indice 12 !

Mais, l’indice 8 = 0 qui ne vérifiait pas la conjecture car $A\not= \:P$, il permettra de valider la conjecture car: (9*30+7) = 277 = P serra non congruent à P, elle sera donc : validée pour N = 15k+1… etc ...etc et même pour N = 15(k+4) car 2N = 2520 et suite au décalage de 4 rangs :
(247 + 120) = $2n\not\equiv{P'}[P]$
On n'a donc nul besoin de savoir si 2N - P' = q dépend ou pas de $P'$ de 1 a N, car c'est son antécédent ; dans cet exemple suite à la fonction G, et/ou EG....!

Donnez N: 1200
crible: [10, 1, 1, 1, 1, 1, 0, 0, 08, 1, 1, 1, 112, 113, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1,1, 1, 0, 0, 1, 1, 0, 0]
crible: [1, 10, 1, 1, 1, 1, 0, 0, 0, 18.9, 1, 1, 1, 112.13, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0]
listes G:
crible: [10, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1]
N=15(k+1) décalage d'un rang , donc à partir du 2ème élément on réitère la liste ci-dessus..
crible: [1, 10, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0]
N=15(k+2) ....idem décalage de 2 rangs par rapport à la liste G0
crible: [0, 1, 10, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0]
N=15(k+3) ....idem décalage de 3 rangs par rapport à la liste G0
crible: [0, 0, 1, 10, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1]

liste du crible EG, pour N =15k ; que l'on peut superposer sur Liste E
crible: [10, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0]

N=15(k+1) à superposer sur Liste E afin de vérifier là aussi le décalage du résultat précédent et sur liste EG
crible: [1, 10, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]

N=15(k+2)
crible: [0, 1, 10, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0]

Question : Peut on  vérifier plus loin la conjecture ...par exemple $ k = 10^{25}$ Ce qui donne $N = ((10^{25})\: *\: 15) + 1200$ En partant de la valeur de l'index  8 de la liste E, et tant qu'à faire avec la valeur de l'index 14....? sachant que ces deux index ne vérifient pas la conjecture pour N = 1200.
Bon amusement .

Pour info : Sachant que la conjecture a été vérifiée en 2014 par 4 Mathématiciens avec un "calculateur" pour tout nombre pair : Jusqu'à $4.10^{18}$.

Donc  : elle est vérifiée pour $2N = 4.10^{18} - 10$ !
Alors, suivant notre algorithme et en prenant simplement la Fam 7; il faut quelque seconde pour la vérifier pour $N = 15(k+1)$ ...! simplement à partir de l'index $16 = 16*30+7 = 487$ . On peut toujours dire que c'est du bol.....
Mais maintenant, elle est vérifiée pour $2N = 4.10^{18} + 2 ; + 4 ; ou + 20$ .

A+

Gilbert

#11 Re : Programmation » Fusion de deux cribles » 15-02-2020 19:40:04

LEG

non je rigolllllle   il indique bien 73 pour n=3000, soit 2n=6000

#12 Re : Programmation » Fusion de deux cribles » 15-02-2020 19:32:15

LEG

non il m'a mis 77 pour n=3000, donc 2n=12000
je colle les deux def.
ok c'est bon.....il m'a mis 124,73

par contre je n'arrive pas à calculer le temps dans ta première version d'hier pour :


def E_Crible(premiers, n, fam):
    # On génère un tableau de N/30 cases rempli de 1
    lencrible = n//30
    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        
    return crible,lencrible

pour ensuite avoir le temps total de E et G afin de voir avec la dernière version....
 

#13 Re : Programmation » Fusion de deux cribles » 15-02-2020 19:12:58

LEG

la blague vient de comment j'imprime :  # print(prime_E,prime_EG)   ça ne doit pas être bon....§ je vais l'enlever....

#14 Re : Programmation » Fusion de deux cribles » 15-02-2020 18:45:15

LEG

pour N = 3000
sqrtde 12000 = 77,....

N= 7335
sqrt 14760 = 121,...

en définitive il prend la dernière valeur impaire et entière de la racine carrée de 2N.
mais si entre le dernier premier est la valeur entière impaire de la sqrt de 2N il y a d'autres impairs non premiers il ne les prend pas ...dans l'exemple au dessus il y a 119 qui n'est pas premier , il ne l'a pas pris heureusement...il s'est arrêté à 113
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83] [89, 97, 101, 103, 107, 109, 113, 121]

je pense que cela vient du fait que l'on travaille modulo 30...Car dans un crible P[30] que j'ai , il arrive souvent que le dernier nombre avant la limite n fixé est un composé...! c'est exactement pareil que dans un des cribles que tu as programmé le dernier nombre premier se trouve en double....!
aucune importance c'est un bug, sans incidence...

pour les temps bien entendu c'est ce que j'ai comparé...au début , la je compare le temps de des deux cribles que tu viens de programmer et GCrible_2N met 8 seconde de moins pour N = 12 000 000 000 avec un chrono car il ne m'indique pas le temps pour la partie E , je n'ai pas réussi à le faire.....

voila pour era_gty , crible E
Nombre premiers criblés famille 7 : 67695482 ----- 62.32
--- Temps total: 63.03 sec ---
>>>
voila pour g_t_y , crible G
Nombres non congru 2n[pi] 1 à 12000000000 famille 7 premiers de 12000000000 à 24000000000: 63579248 ----- 63.27
--- Temps total: 64.03 sec ---

#15 Re : Programmation » Fusion de deux cribles » 15-02-2020 17:10:54

LEG

n'ouble pas le tiret du 8 à Premiers_E:(PremiersE,Suite_E, n, fam)

il y a un nombre en plus dans cette double liste : prime_E,prime_EG=[2,3],[]

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53] [59, 61, 67, 71, 73, 77] 77 ne devrait pas y être...à priori il prend le dernier entier de la racine carrée de 2N , pour 2n =12000, il affiche aussi 109 là ok car 109 est premier

je pense pas que cela pose problème dans le processus , puisqu'un nombre composé ne peut rien marquer, qui ne serait marqué par ses facteur P....

premier résultat pour 6mds avec GCrible _2N

Nombres non congru 2n[pi] ou couple p+q = 2N, de 7 à 6000000000 famille 7 : 5370017 ----- 30.13 *2 environ

deuxième résultat pour 6 mds avec Crible _EG

Nombres non congru 2n[pi] 1 à 6000000000 famille 7 premiers de 6000000000 à 12000000000: 5370017 ----- 66.53

donc il fonctionne parfaitement...et c'est marrant car même avec moins de nombres premiers qui criblent liste E il ne va pas plus vite...
je viens de revérifier il gagne 12 secondes sur n =12 mds donc ça m'étonnez qu'il n'aille pas plus vite ..

maintenant je vais voir en C++..si je peut le faire retranscrire   et si oui je le publie sur le forum ...mais déjà cela ferait un bon exécutable sur vvotre site car ce programme et algorithme est totalement inconnu....

MON CHER AMI je te suis redevable tu ne veux pas aller au resto....? j(attend ton mail)....

#16 Re : Programmation » Fusion de deux cribles » 15-02-2020 16:32:52

LEG

ça y est , je regardai le Biathlon.

donc je vais tester :  je vois que tu as modifié la def eratostene , afin de partager les listes de premiers

une erreur:
Criblage_EG(PremiersE,Suite_E, n, fam)
NameError: name 'Criblage_EG' is not defined
>>>

cette ligne: Crible_EG(Premiers_E,Suite_E, n, fam) comporte deux erreur Criblage_EG au lieu de Crible_EG et il manque le tiret du 8 à PremierE

résultat pour n= 300 :Donnez N: 300
crible: [1, 1, 0, 1, 0, 1, 0, 0, 0, 0]

avec GCrible_2N
crible: [1, 1, 0, 1, 0, 1, 0, 0, 0, 0] ; identique donc ok

je pousse N à 6000 Crible_EG
Donnez N: 6000
crible: [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0]
Nombres non congru 2n[pi] 1 à 6000 famille 7 premiers de 6000 à 12000: 46 ----- 0.03 on perd 2 dixièmes
GCrible_2N
Donnez N: 6000
crible: [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0]
Nombres non congru 2n[pi] ou couple p+q = 2N, de 7 à 6000 famille 7 : 46 ----- 0.01

résultat identique et valeurs bonnent

il ne reste que cette ligne à modifier car elle induit une erreur :
##print(f"Nombres non congru 2n[pi] {1} à {n} famille {fam} premiers de {n} à {n2}: {total} ----- {int((time()-start_crible)*100)/100}")

print(f"Nombres non congru 2n[pi] {1} à {n} famille {fam} premiers de {n} à {n2}: {total} ----- {int((time()-start_crible)*100)/100}")
NameError: name 'start_crible' is not defined

C'est fait , c'est sous la fonction def tu as mis : start_time au lieu de star_crible = time

je fais un test sur 6 000 000 000 on verra l'écart de temps ok.

#17 Re : Programmation » Fusion de deux cribles » 15-02-2020 14:15:36

LEG

Alors la, c'est deux restau.. que je te dois...l'idée est excellente ...

Si j'ai bien compris, pour un n donné
- le E_crible tourne avec les premiers ⩽√n ## oui ##
- le G_crible, lui, doit impérativement tourner avec les premiers ⩽√2n ? ## ou i##

* une de $3 \:à \:√n$ qui servira à la première partie, ce qui était le crible E ## exact ##

* le complément de $√n$ à  $√2n$, qui lorsque la partie E aura terminé de cribler, sera ajouté à la suite de la première liste.
     Ainsi, elle contiendra donc les premiers de $3\: à \:√2n$ ce qui permettra d'enchaîner sur la partie G. ## et ça ne gênera en rien le ralentissement de GCrible_2N, c'est impec...###

J'ai passé la matinée sur cette problématique, mais la première liste est bonne c'est la deuxième qui coince et je ne trouve pas pourquoi.
Tant que je démarre candidate curr=5, ok
Mais dès que je modifie le point de départ comme étant le dernier de la première liste, ou même à 7 je n'ai plus de nombres premiers...
C'est vraiment un mystère. ### tu veux parler de liste E et des  $8\: b¤ premiers de GM ..? ###

Tu ne te souviens plus qu'on en avait parlé, et je t'avais suggéré si on inversé , c'est à dire que c'est à $b$ de GM de parcourir les $a$ de premiers  "eratostene" et tu m'avais dit que cela ne changerait pas le nombre d'opérations....Et tu avais raison... en principe...

Car supposons que l'on ai 2000 $P_i$ "eratostene"  ok
je part avec $b_1 = 7$ qui parcourt les $a_1, a_2 ....a_n $ dès que $(j = b_i*a_i)$ %30 == fam, stop , index $a_i$ part cribler de l'index...>n//30 ; sort du crible, et $b_i$ continu de parcourir les $a_i$ puis à nouveau %30==fam ce $a_i \:+\:_n$ part cribler ....etc... lorsque $b_1 = 7$ a fini de pracourir tous les $a_i$ "eratostene" et bien on réitère avec $b_2 = 11$ ....etc on arrive au dernier $b_8 = 31$ qui fini sa boucle jusqu'au dernier $a_i$ et fin du crible liste E...tu es d'accord...?

Mais le nombre d'opérations serra quand même 8*2000 calculs , vérification du modulo30==fam ..à l'inverse
dans l'autre sens qui est celui actuel et ben on a : 2000 * 8.... sauf si effectivement on pouvait faire partir le $a_i$ dés que  $j\:=\:b_i\:*\:a_i$ %30==fam

alors que c'est vrai , pourquoi le calcul de l'index de ce $a_i$ ne se fait pas dés que j%30==fam...??? alors que tu le faisais dans le crible G4y

extrait du programme :


 for i,pi in enumerate(Primes_init):      
       j=nn%pi
       debut,fin,pas=j+pi*(1-j%2),min(pi*30,n),pi*2  ### là, dès que (j + pi)%30== fam on part calculer l'index de j pour qu'il crible par pas de pi  ###
       temoin=0
       for j in range(debut,fin,pas):
           if j%30==1:
             fam=P8[1]  # modifier la valeur de la fam à cribler [1,7,11,....,29]
             if not ((1<<fam)&temoin):
                temoin=(1<<fam)|temoin
                debut_index=j//30
                Nombres_fam=nombres[fam]
                for index in range(debut_index, nbcell,pi):
                   Nombres_fam[index]=0
 

d'ailleurs on avait imprimé tous les j pour être sûr que les opérations d'additions s'arrêtaient avant la limite bornée par (pi*30,n) dès que j%30==fam
et on avait en moyenne au grand maxi  si cela allait au bout de la limite: 16 additions et donc 16 contrôles modulo 30==fam...

cela vient peut être des deux fonctions for... qui ne peuvent être interrompues par while par exemple...il faudrait une instruction dans la processus de calcul de $b_i$...
j'ai même essayé en mettant dans la fonction for fin = j%30==fam


 for a in premiers:
        fin = j%30==fam
        for b in GM(fin):
 

nada qu'il m'a dit, retourne apprendre python tu as 00:
1, in E_Crible
    fin = j%30==fam
UnboundLocalError: local variable 'j' referenced before assignment

#18 Re : Programmation » Fusion de deux cribles » 14-02-2020 21:41:39

LEG

Bien entendu @Yoshi
mais le problème c'est que si on

return prime_list[3:int(n**0.5)]

ça ne marchera que pour E_crible et faussera le résultat de GCrible _2n

donc c'est à l'appelle de

def E_Crible(premiers, n, fam):

c'est ici qu'il faut appeler les premiers $\leqslant\sqrt{n}$ d'ératosthène il faudra dans main() par exemple rentrer : prime = eratosthène(n**0.5) et appeler dans la fonction ci-dessus :  prime,n,fam):

mais ça ne marche pas je viens d'essayer, j'ai remplacé premiers par prime, de partout où def de la liste E était utilisait... Par ce que je fais des erreurs dans python...

il faut que j'aille manger un bout ...bonne nuit A demain
Merci de ton dévouement.....
@+

Même si l'idée ne te bottait pas plus que ça, je le ferai quand même pour ma satisfaction personnelle...non , je pense que je me suis mal exprimé si tu le fais ce ne serra que mieux...et plus rapide...déjà si on évite pour liste E d'utiliser les primes "eratostene" $\geqslant\sqrt{n}$

actuellement pour n = 6000 000 000 il met 61 secondes ; alors que séparé , les deux fonction E et G mettent au total 59,64 secondes donc tu vois 1 seconde d'écart....Ce qui est logique, car le temps de chaque criblage ne peut pas diminuer du seul fait de la fusion des deux listes...

j'ai quand même fait une vérife : pour N = 7*1012 avec 2N = 14*1012 dans la liste E il y aura plus de 1 100 000 nombres premiers $P_i$ qui calculeront pour rien....Donc...si on peut épurer ce cas....

#19 Re : Programmation » Fusion de deux cribles » 14-02-2020 20:55:50

LEG

Ok : mais d'abord un résultat de ta version qui fonctionne parfaitement et qui est juste..!

== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ couple p+q_mod30.py ==
Donnez N: 6 000 000 000
Nombres non congru 2n[pi] ou nombre de couple p+q = 2n, 7 à 6000000000 famille 7 : 5370017 ----- 29.48 ce temps il faut le multiplier par 2 ..bref on s'en fou
>>>

tout au début on a besoin des nombres premiers d'Ératosthène pour le crible E et pour le crible G donc comme pour la fonction GCrible il nous faut impérativement les nombres premiers $\leqslant\sqrt{2n}$ alors que pour la fonction Ecrible on a besoins que des nombres premiers $\leqslant\sqrt{n}$

J'ai donc vérifié, si cela ralentissait la fonction Ecrible si on rentrait n = in((2*n)**.5)  ce qui ne gène en rien ..et comme ça on rentrait directement tous les premiers d'Ératosthène que l'on va avoir besoins pour la fonction GCrible sans que cela gène Ecrible....OK

Alors tu vas me dire que les nombres premiers $\geqslant\sqrt{n}$ ils ne servent à rien dans la fonction Ecrible et ils tournent inutilement...oui ! mais coûtent très peu en temps ....j'avais penser te le demander, de ne retourner dans la première partie que les nombres premiers

 return prime_list[3:] et  ⩽√n

mais comme ça risquait de compliquer le programme j'ai donc opté pour la solution la plus simple en ne rentrant qu'une fois  n = in((2*n)**.5) pour les deux fonctions E et G.

Or lorsque l'on demande n = 1200 dans ta question:
on a besoin au maximum pour "eratostene" uniquement de rentrer n = int((2*n)**0.5) afin qu'il retourne les nombres premiers que l'on aura besoins dans les deux cas  donc le maximum .... pour la fonction G
(n'oublie pas qu'au tout début des programmes dans "eratostene" on calculait tous les nombres premiers pour rien, car on avait au maximum: besoin que des premiers $\leqslant\sqrt{2n}$)

il ne faut pas confondre cette première partie "eratostene" avec les deux autres E et G qui n'ont rien à voir, si ce n'est qu'il leur faut cette première partie pour fonctionner...!

Bien évidemment que tu vas appeler pour E les premiers d'Ératosthène pour cribler la liste E  et alors ...ça ne gène en rien d'en avoir un peu plus car ça ne peut en aucun cas changer le résultat de E...donc la liste E. Tu peux essayer avec les programme de E tout seul en entrant n=in((2*n)**0.5)

G , à besoin des premiers "eratostene" $\leqslant\sqrt{2n}$ pour cribler les éléments de la liste E criblée  qui ne sont pas les même éléments que "eratostene ...c'est ce qui t'embrouille...

sinon le crible serait faux il ne fonctionnerait pas.

Je ne vois pas de solution dans ces conditions, puisque E et G ne se servent pas du même n, pour que le 2e utilise le crible du 1er... si mais c'est deux choses différentes le $n$ rentré au début permet d'écrire deux tableaux identiques de cellules [1] n//30 , ok  mais ils utiliseront donc les mêmes nombres premiers $\leqslant\sqrt{2n}$ d'eratostene extraient dans les deux cas, pour cribler. Si ce n'est que les nombres premiers $P_i >\sqrt{n}$ dans E ne serviront à rien...ok...!

d'ailleurs voila un extrait de GCrible _2N, pour n= 3000

== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ couple p+q_mod30.py ==
Donnez N: 3000

[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73] nombres premiers extrait par eratosthène

résultat du nombre de couples p+q=6000

Nombres non congru 2n[pi] ou nombre de couple p+q = 2n, 7 à 3000 famille 7 : 18 ----- 0.0
>>>
pour E ça ne gène en rien mais par contre si je rentrer n=in(n**0.5) il est clair que le résultat serait faux !!! car il manquerait pour G les nombres premiers d'eratostene[ 59, 61, 67, 71, 73] car $\sqrt{3000}= 54$ alors qu'il me faut les $P_i\leqslant\sqrt{6000}= 77$

Et fonction G fausse : résultat :
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
résultat faux
Extrait : Nombres non congru 2n[pi] ou nombre de couple p+q = 2n, 7 à 3000 famille 7 : 21 ----- 0.0seconde . Ce qui est faux, puisqu'il me manque des nombres premiers pour cribler, donc résultat en hausse....OK

Une dernière pour te rassurer:

== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ couple p+q_mod30.py ==

Donnez N: 9000

[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131] premiers "eratostene"

Gcrible_2N: [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Nombres non congrus 2n[pi] ou couples p+q = 2N 7 à 9000 famille 7 : 48 ----- 0.03 * 2
>>>
Résultat par la fonction d'estimation $\frac{\pi(n)} {ln\:2*\pi(n)}$
où $\pi(n)$ dans cette famille 7[30] et pour n= 9000 : Nombre de premiers liste E criblés : 141 , ce qui donne :

$\frac{141}{ln\:282}=24$ < 48 .

#20 Re : Programmation » Fusion de deux cribles » 14-02-2020 19:10:57

LEG

J'ai une inconnue sur le fonctionnement, cette ligne :
n = int(n**0.5)  #(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.

Tout à fait je l'ai directement passé dans E , au début d'Ératosthène à  n=int((2n)**0.5) cela ne prends pas plus de temps pour E, j'ai vérifié sur 3 000 000 000
avec n = int(n**0.5) ou n = int((2*n)**0.5)
mais il le faut pour G

je viens de tester , c'est impeccable , avec n = int((2*n)**0.5)
résultat:
Donnez N: 3000
crible: [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
Nombres non congru 2n[pi] 1 à 3000 famille 7 couple p+q = 2N: 18 ----- 0.01 il va pratiquement aussi vite que E tout seul ou G tout seul..

voici les données des deux fonctions E et G séparées on a bien 18 couples et les 1 du cribles GCrible_2N sont bien en correspondance avec les 1 de E et les 0 correspondent bien aux 0 de E ou de G .
j'ai mis en rouge je début des entiers de la liste E.... ce qui te permet de voir que les 0 de E qui sont marqué en noir ce sont des entiers non congrus à 2N [Pi] qui se décaleront d'un rang et si  il précède un 1 marqué en rouge, et bien ce 1 ne serra plus congru pour n=15(k+1) et donc vérifiera la conjecture car ce serra un couple p+q = 2N ....etc etc..C'est pour cela que ces 0 marqué en noir donc non congru ont tout autant d'importance que les 1 premiers non congrus...Mais ça , aucune analyse mathématique ou complexe ne pouvait le prévoir sans ces deux fonctions...car inconnues !

1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0

0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1
N = 3000 ; (18couples) ; fonction : (55/ln110) = 11,94.

superposé on doit garder que les 1 correspondant aux 1 tous les autres restent marqué 0

Ce qui te donne bien ton résultat :

0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0

Ce qui serait encore mieux, quand cette version tournera, ce serait de fusionner les deux def E et G (en une seule) l'une après l'autre, ce qui éviterait de récupérer les données de E pour les les passer à G, puisqu'elles auraient fusionné (= les deux enchaînées l'un après l'autre avec des ajustements mineurs et cosmétiques...

Ca c'est toi le chef de cette partie et tu as parfaitement raison ; rassure toi ça fonctionne et ça tourne bien...Il faut que je te paye le restau chez toi....

@+ je vais vérifier 3 000 000 000 . et je pourrai ensuite demander à B Parisse si il veut bien avoir la gentillesse de le retranscrire en C++ , comme il l'a fait pour les deux cribles...
sur un grand ordinateur on pourra allègrement repousser les limites où la "conjecture" à été testé , sans compter que l'on a besoin que d'une famille ....La je pense que personne ne pouvait l'imaginer...!

#21 Re : Programmation » Fusion de deux cribles » 14-02-2020 17:03:06

LEG

Ok :
donc je vais commencer par cette question, qui effectivement ne devrait pas se produire , mais là je ne sais pas pourquoi , Car tu as raison l'instruction devrait être des-que J=(a*b ) et que j%30 ==fam, la fonction doit passer au calcul de l'index puis a part cribler..... est ce à ce niveau que ça tourne jusqu'à la fin des b de GM

je ne vois toujours pas pourquoi la boucle Pour idx ne démarre pas à chaque fois que le test if j%30== fam mais seulement quand tu as épuisé tous les b...Mais je crois que tu avais regardé et dans la version que de E_crible que j'ai mise, il calcule tous les b et ne prend que  j%30== fam avant de calculer l'index puis part cribler

il faut peut être que tu utilises la fonction que tu avais utilisé :

début, fin = a*b , j*%30==fam
for j in range(debut,fin):
    calcul de l'index index = j//30

puis :

Toi :
Pour chaque a de premiers
       Pour chaque b de GM:
            les deux progs calculent j=a*b
            Si j%30==fam:
                  calcul de l'index index = j//30
            Pour idx de index à finboucle, pas =a je suis d'accord que l'indentation n'est pas bonne, mais ça vient d'un ancien programme car je ne l'ai plus cette indentation ...ni l'utilisation de:

Nombres_fam = nombres[fam]
                for index in range(debut_index, nbcell,pi):
                    Nombres_fam[index] = 0

Il fallait me dire que les 2 séparés fonctionnaient correctement et m'expliquer pourquoi cette indentation différente pas me dire que ce ne pouvait qu'être correct parce que c'était mon œuvre ce qui n'est pas exact. Ok il y a erreur ...je pensais que tu le savais

Bon maintenant, j'ai sous la main et fonctionnelles deux prog où schématiquement :
main() versionE
      - appelle Erato
      - puis passe le résultat à E
      - qui crible et retourne la liste crible

Tout à fait

main() versionG
      - appelle Erato
      - puis passe le résultat à G
      - qui crible et retourne la liste crible

Tout à fait

*****************************************
que veux-tu ?
Une version où main()
      - appelle Erato
      - puis passe le résultat à E
      - qui crible et retourne la liste crible
      - liste récupérée par main() qui la passe à G qui recrible ???   ### c'est Exactement ça.. ###

en exemple la liste crible de E retourné et récupérée par main() pour la passer à G, cela va permette à G de ne pas  effectué le tableau de n//30 *[1]
et de cribler directement cette liste E criblée = tableau.

Donc pour résumer :
Exemple que cela devrait donner pour la liste E_crible, récuperé par main()pour la passer à GCrible_2N:
  pour N = 900 ; et fam = 7; (7couples (p+q))

1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1 ## liste E ##

résultat de GCrible_2N """ principe de base : il ne marque que les 1, de E_crible corespondant au 1 de GCrible"""
0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 

les deux cribles fonctionnels E_crible et GCrible permettront de vérifier que GCrible_2N à bien exécuté son programme de criblage identique à GCrible qui est le même bien entendu....

#22 Re : Programmation » Fusion de deux cribles » 14-02-2020 12:45:34

LEG

Re @Yoshi
Mais c'est les deux programmes que tu as fait...donc ? l'indentation est bonne..
mais le programme que j'ai mis c'est uniquement Ératosthène . je vais les reposer à la suite :
1-) Ératosthène  = E_Crible


from itertools import product
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(n**0.5)  #(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
    prime_list =[2,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[3:])
    return prime_list[3:]  


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


def E_Crible(premiers, n, fam):
    start_crible = time()
 
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)
    GM = [7,11,13,17,19,23,29,31]
    # On calcule les produits: j = a * b
   
    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
        #print(index)
           
    total = sum(crible)  ##fonction qui sera inutile et remplacé par : return "crible:", crible ##
    print("crible:", crible)  
    print(f"Nombre premiers criblés famille {fam} : {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 7 à √N
    premiers = eratostene(n)
    #print(f"nombres premiers entre 7 et n: {len(premiers)}")

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


main()
system("pause")
 

2-) Goldbach = GCrible


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 = [2, 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[3:])
    return prime_list[3:]


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


def GCrible(premiers, n, fam):
    start_crible = time()
    crible = n//30*[1]     # # Ou: on rappelle le tableau de E_crible,  criblé ##
    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 % 30 != fam on fait ri += 2pi
        if reste % 2 == 0:
            reste += premier
        pi2 = 2*premier
        while reste % 30 != fam:
            reste += pi2
        # Ensuite on divise ri par 30 pour obtenir l'indexe
        reste //= 30
        # 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 entre 7 et √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers entre 7 et {int((2*n)**0.5)}: {len(premiers)}")

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


main()
system("pause")
 

et Maintenant  voila les deux fusionné  mais qui ne fonctionne que sous le principe de Golbach , il ne prend pas le tableau d'Ératosthène criblé , parce que effectivement je ne sais pas comment il faut l'appeler ..... au niveau de la fonction :

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

**********************************************************************

3-) crible couple P+Q = GCrible_2N; celui que l'on doit modifier


from itertools import product
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)  #(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
    prime_list =[2,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[3:])
    return prime_list[3:]  


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


def E_Crible(premiers, n, fam):
    start_crible = time()
 
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)
    GM = [7,11,13,17,19,23,29,31]
    # On calcule les produits: j = a * b
   
    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
        #print(index)
           
    #total = sum(crible)  ### cette fonction devient inutile ###
    print("crible:", crible)  
    #print(f"Nombre premiers criblés famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")
    return "crible:", crible
 ################################# il faudrait fusionner à partir de là ########
def main():
    # On demande N a l'utilisateur
    n = demander_N()

    # On récupère les premiers de 7 à √N
    premiers = eratostene(n)
    #print(f"nombres premiers entre 7 et n: {len(premiers)}")

    start_time = time()
    # On crible
    E_Crible(premiers, n, 7)
    temps = time()-start_time
    print(f"--- Temps total: {int(temps*100)/100} sec ---")
   
 ############### Goldbach. GCrible ##########
   
def GCrible_2N(premiers, n, fam):
    start_crible = time()
    crible = n//30*[1]     # Ou: on rapelle le tableau Ératosthène criblé de N/30 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 % 30 != fam on fait ri += 2pi
        if reste % 2 == 0:
            reste += premier
        pi2 = 2*premier
        while reste % 30 != fam:
            reste += pi2
        # Ensuite on divise ri par 30 pour obtenir l'indexe
        reste //= 30
        # 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 entre 7 et √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers entre 7 et {int((2*n)**0.5)}: {len(premiers)}")

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


main()
system("pause")
 

Dans ce crible il n'y a que la fonction Goldbach qui crible , sans utiliser le tableau criblé de E_crible...

ensuite on pourra discuter des questions que tu as posé .., concernant E_crible , où si besoins est ....

citation: et réponses

Commentaire : fam a été passé en paramètre (7 dans ton exemple) depuis la fonction main().
    Questions : l'utilisateur doit choisir la famille à étudier en modifiant ce 7 et en rentrant dans le programme ? oui
                     Tu ne passes donc pas en revue une famille après l'autre automatiquement...pas du tout on travaille que par famille
                     Alors, pourquoi lui demander de rentrer n et pas également fam ? Bien sûr, mais on avait dit que c'était tout aussi facile de rentrer la fam avant de lancer le programme

par famille = gain de temps et de mémoire...!

citation: et réponses

Et donc tu boucles de 1015 à finboucle par pas de 983, soit les nombres
1015, 1998, 2981, 3964, 4947, 5930... jusqu'à finboucle ...# pas tout à fais , car 1015 est l'index et non un entier de la fam
Normal ? ..Bien sûr, ce sont les a = 983 dans ton exemple qui crible c'est à dire: on crible en partant de l'index modulo (a*30) puisque la fam est en progression arithmétique de raison 30
Moi je pensais qu'on ne rentrait dans la boucle que si j%30 == fam...
Non pas du tout chaque (a) vérifie que le produit j est bien égal à j%30==fam, puis on calcule son index et (a) part cribler; ensuite on réitère avec le (a) suivant

mais je pense que c'est par ce que tu ne t'en souviens plus, car c'est bien toi qui avais modifié le programme de mon petit fils pour l'optimiser  d'ailleurs tu pourrais revoir le sujet aide en python...mais inutile...

par exemple dans ta question pour a = 983, ok, l'index est 1015 ,ok cela correspond au nombre 1015*30 + 23 = 30473 = 31 × 983 les nombres seront donc :
en partant de 30473 ayant pour index 1015 dans la fam 23; 30473 +29490 +29490 +29490 ... etc ....> fin de boucle limite N//30  c'est bon...?

Exemple que cela devrait donner pour le criblage de E_crible par GCrible :
  pour N = 900 ; et fam = 7; (7couples) ; fonction : (20/ln40) = 5,42

1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1
0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0
résultat de GCrible_2N il ne marque que les 1, de E_crible corespondant au 1 de GCrible
0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0

#23 Programmation » Fusion de deux cribles » 14-02-2020 09:26:05

LEG
Réponses : 33

Bonjour
@Yoshi
suite à notre discussion sur ce projet , je pense que l'on peut le poser sur le forum...?

Donc voila la première partie du crible Ératosthène , un peu épuré des fonctions inutiles ; qui va servir de base pour utiliser le tableau d'Ératosthène criblé , dans ce programme , je pense qu'il est alors inutile de calculer 

 total= sum(crible)

mais on aura besoin de retourner le tableau criblé je suppose que la fonction serra :

 return "crible:",crible

qui va être utiliser par Goldbach dans la fonction :


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

j'ai bien essayé mais Nada....

je viens de supprimer cette première partie , afin d'éviter une erreur, car j'ai remis les crible post# ci-dessou suite à tes questions



attention :
la partie que tu as modifiée ralenti le programme
résultat:
avec tes 3 premières lignes modifiées:


def E_Crible(premiers, n, fam):
    # On génère un tableau de n//30 cases rempli de 1
    lencrible = n//30
    crible = [1 for _  in range(lencrible)]    
 

=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ Era_gty_mod30.py ===
Donnez N: 3000000000
nombre premier criblé de 7 à n pour la Fam = 18056145
--- Temps total: 18.9 sec ---

>>>
au lieu de


def E_Crible(premiers, n, fam):
    start_crible = time()
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)
 

=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ Era_gty_mod30.py ===
Donnez N: 3000000000
Nombre premiers criblés famille 7 : 18056145 ----- 14.35
--- Temps total: 14.53 sec ---
>>>

@+

#24 Re : Café mathématique » nouneau crible pour nombres premiers » 13-02-2020 16:06:54

LEG

Bon, je vois qu'on a perdu du temps à essayer de t'expliquer gentiment, que tu n'avais que réinventer le fil à couper le beurre.
Mais en plus tu n'as pas l'air de bien comprendre le crible d'Ératosthène simplifié ...!

Le tableau que je t'ai indiqué prouve là aussi que tu n'as pas l'air de comprendre grand chose à ce qu'ai un crible d'Ératosthène très simple.

Depuis quand il s'agit d'un tableau de nombres premiers ..?

Si tu prenais seulement la peine de continuer, tu verrais apparaître en plus de 49 = 7*7 , puis 7*11; 7*13, 11*11...etc etc ... Donc des multiples de P > à 5 et non pas un tableau de nombres premiers...Il n'y a pas pire aveugle que celui qui ferme les yeux et qui se bouche les oreilles ...

sujet inutile ...!

#25 Re : Café mathématique » nouneau crible pour nombres premiers » 13-02-2020 12:23:58

LEG

Bonjour

@Yoshi
Comme cela lui a été dit, c'est Ératosthène pur et dur..! En effet ce qui change,  au lieu d'écrire l'ensemble des entiers naturels impairs >0 dans un tableau de 10 colonnes et n lignes par exemple; et bien lui il le fait avec une ligne horizontale et une colonne verticale ...c'est quand même plus simple !
Puis il marque les nombres de la colonne , par pas de P premier car non marqué par ses prédécesseur....Mais c'est vraiment  différent de la simple méthode d'Ératosthène que tu viens de lui indiquer..en partant d'un nombre non marqué par ses prédécesseurs , donc P , puis on marque ses multiples par pas de P jusqu'à la limite N fixée...bien entendu avec $P\leqslant\sqrt{n}$. Ce qu'il a oublié de faire....

Pour rendre un peu plus long son "crible" je suppose...Car visiblement il n'a pas compris ta méthode d'Ératosthène....???

Heureusement qu'Ératosthène l'a devancé il y a + de 2000 ans , car cela aurait été une grosse découverte...

Mais: cher ami @Lachkar : essais donc un peu pour gagner du temps en simplicité et en rapidité d'utiliser ta méthode par pas de P (" P un nombre premier non marqué") dans ton tableau:

sans les multiples de 2,3 et 5... ok , donc encore plus simple....

.7.11.13.17.19.23.29.31.37.41.43.47.49.53.59.61.67 ... etc ...> N; en suivant le cycle d'intervalle et en partant de 7:{4,2,4,2,4,6,2,6}... d'accord .
11
13
17
19
23
29
31
37
41
43
47
49
53
59
61
67

ou un tableau de 8 colonnes en progression arithmétique de raison 30 plus simple à écrire...

. 7.11.13.17.19.23.29.31.
37.41.43.47.49.53.59.61

@+

Pied de page des forums