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

#376 25-03-2019 10:50:04

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

@Yoshi : ça me va parfaitement

Petit rappel dans les entiers naturels positifs :

(« Propriété connue des congruences : pour $2n ≥ 30$ et $A ≤ n$ il existe $y,y’$ tels que $2n = P*y + R$ on dit que $2n$ est congru à $R$ modulo $P$ et $A = P*y’ + R $; $A$ est là aussi congru à $R$ modulo $P$; ce qui implique $2n\; – A = P*(y\; – y’)$ d’où $P$ divise $2n\; – A$, c’est à dire que $2n$ et $A$ partagent le même reste $R$ dans la division euclidienne par $P$ , on peut donc remplacer $R$ par $A$ dans l’algorithme de Goldbach sans perte de généralité ; par conséquent et à l’inverse si $A$ et $2n$ ne partagent pas le même reste $R$, tels que $A ≢2n [P]$, alors $P$ ne divise pas cette différence, d’où $2n\; – A = q$ premier $\in(n;2n)$, il est le complémentaire de $A$ par rapport à $2n$. On peut donc affirmer que $q$ et sa famille $30k +i$ avec $i\in(1,7,11,13,17,19,23,29)$ complémentaire, dépend de la non congruence de $A$ premier $P$ ou pas.

Ce qui permet d’affirmer que pour tout $A’= p’ ≢2n[P] ⇒ q$ et qu’il ne s’agit donc pas de deux événements indépendants l’un de l’autre, car $q$ dépendra de la non congruence de $p’$ pour cette conjecture et plus généralement des $A ≢2n [P]$.»)

1) : la fonction est le criblage , pour travailler uniquement par famille on prend $N =15k\geqslant{150}$ la conjecture de Goldbach étant vraie de 6 à 300.

J'ai pris l'exemple de la famille 7[30] ou $30k+7$ avec $i = 7$ et $15k + i = 907$ et la Fam = famille, que tu as en fin de document page 4 les deux premières lignes; criblage 1 et 2 puis à nouveau 1 superposé sur 2

2) : je crible les éléments A entiers non nuls de l'Ensemble EG avec le crible G, qui à sa fonction, c'est à dire avec les nombres premiers $P\leqslant\sqrt{2N}$; pour une même limite $N=15k + i$ fixée et pour une même famille d'éléments A fixés en progression arithmétique de raison 30

3) : j'obtiens ci-dessous l'image des éléments criblés: (" les éléments 0 ou 1 représentent les entiers naturels A > 0, en progression arithmétique de raison 30 et de premier terme 7 ")
n°1 :[0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] les 1 sont les entiers $A\not\equiv{2N}[P]$ qui impliquent les nombres premiers $q\in[N;2N]$

4) : Je crible les éléments de l'Ensemble Ep avec le crible E, avec les nombres premiers $p\leqslant\sqrt{N}$ donc les mêmes, avec la même fonction mais qui à un indice de départ pour les nombres $P$ , différent du crible EG ; pour une même limite N = 15k + i = 907 fixée et la même famille d'éléments fixés $30k +7$ soit 907 // 30 nous donnes 30 éléments pour cette Fam, que ci-dessus.

La seul différence entre ces deux fonctions c'est donc l'index de départ des nombres premiers $P$ ou $p$ qui criblent la même suite arithmétique pour la même limite $N = 15k + i $  : ("qui au départ , ne sont que les éléments $A$ représentés par des $1$ [1,1,1,1,1,1,1,1,1,1,1.............................................1,1,1,1,1,1,] 7,37,67,97, etc ; pour la lim N fixée.)" le crible G marque 0 les $A\equiv{2N}[P]$ alors que le crible E marque 0 les $A$ multiples de $p$ ; ie, représentés par $0$.

5) : j'obtiens "l'image" des éléments criblés, les 1 sont par conséquent les nombres premiers $p'\leqslant{N}$...:
n°1 :[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]

6) (Le programme va réutiliser le tableau d’Ératosthène criblé) afin de cribler à nouveau les éléments de l'ensemble Ep mais avec le crible G. ("Ce qui revient à superposer les [0] de l'image de EG sur Ep"); afin de marquer en rouge les éléments situé en face des [0] du crible EG et bien évidemment les [1] ne marquent rient, car ils indiqueront les $A\not\equiv{2N}[P]$ , par conséquent les $A=p'$ formeront les couples de nombres premiers $p'+q $ dans l'ensemble Ep, c'est à dire les $1=p'\not\equiv{2N}[P_i]$ ; d'où $p'+q = 2N$ par obligation, alors que les  $A = 0$ tel que $A\not\equiv{2N}[P]$  ont aussi leur importance :

Note : les $A = 0\not\equiv{2N}[P_i]$ sont important dans cette conjecture, grâce à la propriété de l'algorithme EG ; car lorsque la limite $N$ augmente de 15 ; il va s'ensuivre une récurrence , le décalage d'un rang des congruences sur leur successeur $A+30$ ...etc. ; d'où si $A+30$ est un nombre premier $p'$ qui est marqué [,1,] il est évident que la conjecture serra encore vérifiée pour cette limite suivante $N=(15k + 1) + i$ ...etc créant un effet boule de neige .

7 )  Il est clair, que les couples p'+q = 2N dépendent uniquement des $p'\not\equiv{2N}[P_i]$  inférieur ou égal à la limite N fixé, de l'ensemble Ep.

Il en ressort que les nombres premiers $p'\not\equiv{2N}[P_i]$ et $q$ ne peuvent pas être indépendant l'un de l'autre, car $q$ dépend obligatoirement de la non congruence de $p'$ et plus généralement des $A=0\not\equiv{2N}[P_i]$ et qui précèdent un nombre premier $p'$, ce qui permettra  de vérifier la limite suivante : $N=15(k+1) + i$ , relatif à cette conjecture, afin de rendre impossible son infirmation pour le nombre pair suivant $2N+2$ . !

Autrement dit, pour toute limite $N=15k+i$ on ne tient plus compte des nombres premiers $p'$ mais des $A\not\equiv{2N}[P_i]$ qui précèdent un nombre premier $p'$.,vérifiant la conjecture pour le nombre pair 2N+2 suivant.

Car il est évident que tout nombre $p'$ congru à $2N$ modulo $P$ lors de la limite précédente $N=15k$, ne peut plus l'être, pour cette limite suivante $N=15(k+1)+i$ , il se trouve ainsi libéré de sa congruence, puisque les restes $R$ vont changer ...

8)On obtient le résultat suivant en séparant les deux programmes( fonctions) : on reporte les 0 du crible Eg en rouge de n°1a sur les éléments du crible Ep criblés de Ep1b qui correspondent aux 0.

Tel que dans l'ensemble Ep les éléments marqués en rouge, sont les entiers A congrus à 2N modulo P et dont leur complémentaire, par rapport à 2N  ne peuvent pas être des nombres premiers $q$

n° 1a : [0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 
n°1b[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] 8 couples p+q = 1814.

Autrement dit : les éléments 0 de EG qui sont congrus à 2n[p] sont aussi congrus à 2n[p] dans Ep d'où l'image de EG est équivalente ou égale à celle de Ep après avoir été criblée par la fonction G...! il vient que si EG est vraie entraîne Ep vraie....ie :les éléments premiers de 907 à 1814 dépendent de la congruence des éléments de 7 à 907, criblés par la fonction G, ainsi que le nombre de couples p'+q = 1814 dans Ep.

Il est facile d'ailleurs de vérifier, que cela est vraie quelque soit 2n, ou 2n+2, en utilisant uniquement une  famille $30k+i$ fixée en fonction de la forme de $2N = 30k + a$ avec $a\in(2,4,6,8,.....24,28)$

Si par exemple j'augmente la limite précédente de 1, je prenais donc  2n + 2 =1814 + 2 = 30k +16 et bien je prendrai la famille relatif à n = 15k + 8 soit la famille 23[30] ou la famille 17[30] + la famille 29[30] qui sont complémentaires, c'est à dire 17(30] + 29[30] = p + q = 1816 et inversement ; de même que 23[30] + 23[30] = p+q = 30k +16 = 1816 =2n+2.

C'est pour cela que je parle de surjectivité des éléments de l'ensemble EG sur les éléments de l'ensemble Ep après le criblage en utilisant la fonction du premier crible G sur les éléments criblés de l'ensemble EP qui auront été marqué en rouge("criblés") car ils ont bien:
1): pour antécédent les éléments  de Ep,(congrus ou pas à 2n[P] et :
2): les éléments précédents  qui ont été criblés et où les congruences vont se décaler d'un rang sur leur successeur A'+30 pour la limite suivante, lorsque $n$ augmente de 15 , donc $2n$ augmente de 30 pour la même famille criblée.
Il en ressort que l'on a besoin uniquement d'une seule des 8 familles, pour vérifier la conjecture de façon générale, sans perte de généralité; puisque la fonction de l'algorithme est la même pour les 8 familles , à part l'indexe de départ des nombres P qui criblent , ce qui ne change rien à l'estimation du nombre de premier $q$ par famille...

[" le reste tu connais l'explication ....

Lorsque tu augmentes N de 15 , les congruences se reportent sur les éléments de EG = A+30 ce qui provoquent ce décalage d'un pas ("d'un rang") suite à la propriété des congruences, qui doivent donc se décaler d'un rang entre deux criblages successifs.
À fin de garder l'égalité : $2N - A$ est équivalent à $(2N+30) - (A+30)$.

Ce qui permet par conséquent de construire une contradiction récurrente à la conjecture de Goldbach; qui est indécelable sans le recourt au crible G, que nous avons programmé ("Alors que c'était pour une TOUTE autre raison ... démontrer une fonction asymptotique du nombre de nombres premiers $q\in(n\;,\;2n)$")

Or les pointures comme tu dits, qui se cassent les dents depuis 250 ans; ils n'avaient qu'a découvrir et construire ce crible G qui travaille dans les congruences....!
ils auraient même à l'époque de Goldbach, Euler..etc, trouvé sans difficulté la résolution de leur conjecture ...!

Car avec cette propriété récurrente, il est impossible d'infirmer la conjecture de Goldbach pour ler nombre $2N+2$ suivant ! 
On en déduit même une fonction asymptotique conséquence directe du TNP, sur le nombre de nombres premiers $q\in[N;2N]$  qui est :
$\frac{N}{log\:2N}$ caractérisé par cet algorithme G...

Comment veux tu marquer tous les [1]  de l'ensemble Ep, d'un [0] lors du criblage de la limite suivante 15 (k+1)+a avec le cribleG alors que les restes $R_i$ ont changés, et on ne dispose que des mêmes nombres premiers $P\leqslant\sqrt{2n}$ pour cribler le mêmes nombre d'éléments A. D'où il en ressortira une très faible variation, pour la limite suivante $15(k+1) +i$ environ le même nombre de A congrus ou pas à $2n+30$ modulo $P$.

Il vient par obligation , que seul le premier élément de la limite suivante N = 15(k+1)+i serra inconnu.!

Mais qui plus est : pour marquer d'un $0$, tous les $1= p'$ d'Ératosthène ,Tel que $2N$ ou $2N+2$ ne se décompose pas en somme de deux nombres premiers,  il faudrait que la répartition des nombres premiers P soit de raison P , de sorte qu'en partant de n'importe quel reste $R$ de $2N$ par $P$ tu marquerais tous les nombres premier $p'\leqslant{N}$ , ce qui est clairement faux , car il en serait de même dans le crible d'ÉRATOSTHÈNE , DONC QUI DEVIENDRAIT FAUX AUSSI !

Le reste c'est la même image qui a vérifiée la conjecture précédemment, mais décalée d'un rang, par conséquent avec le même nombre de 0 et de 1 non congruent à $P$ d'ou on connait obligatoirement le nombre de $A\not\equiv{2N}[P_i]$ qui précédaient un nombre premier $p'$ et qui par la propriété récurrente de l'algorithme, se décalera d'un rang sur ce $p'$; il deviendra alors non congru à $2N+30$  modulo $P_i$, il vérifiera donc la conjecture, pour ce nombre pair suivant  $2N+2$ ...etc....etc.

Constat : tu ne peux donc pas cribler cette limite N+1, en utilisant les restes Ri du criblage précédent soit de: $N = 15k+i$ pour cribler $n = 15(k+1)+i$  quelque soit une même limite $N$ fixée avec la même Famille en progression arithmétique de raison 30 fixée !

Ce qui rend impossible son infirmation, avec cette propriété récurrente du décalage d’un rang des congruences; $2N−A$ qui implique $(2N+30)−(A+30)$ car le contraire serait absurde...!

Ce n'était peut être pas évident à voir sans ce fameux cribleG...!

Si tu préfères, suivant la propriété de cet algorithme G:  si $A$ est congru à $B[P]$ il vient obligatoirement, que $A+30$ est encore congru à $(B+30)[P]$ avec le même nombre premier P ..! Car $A - B$ = $(A+30)-(B+30)$ puisque c'est la même différence, qui est divisible par le même nombre P. Il est donc impossible de supposer le contraire, car sinon le TFA serait contredit.

D'où il en résulte une propriété récurrente : on obtient par conséquent le décalage d'un rang des congruences sur leur successeur $A'+30$.... Le contraire est absurde. Propriété qui va s'étendre sur plusieurs limites successives lorsque N tend vers l'infini ; avec un effet boule de neige, ie : une augmentation du nombre de couples $(p'+q)$ qui décomposera $2n$ en la somme de deux nombres premiers, par famille $30k+i$ .

Autrement dit, en référence à la démonstration de Euclide sur l'infinité du nombre de nombres premiers, c'est comme si tu disais que le produit N de tous les nombres premiers $p_n$ < N est divisible par un nombre premier > N; ie, supérieur à $p_{n+1}$ ce qui est absurde.... etc...

C'est ces principes que tu vois dans le document avec les deux cribles , les congruences, les familles arithmétiques de raison 30. "]

""Alors, ils peuvent toujours chercher des fonctions de plus en plus complexes pour dire : il restera toujours 1 (couple p'+q=2n); quelque soit n qui tend vers l'infini et qui décomposera 2n ou 2n+2 en somme de deux nombres premiers... Car il y en aura de plus en plus  et sur plusieurs limites n successives , grâce à cette propriété récurrente de l'algorithme !

Je pense qu'il va falloir être un peu plus modeste et arrêter de dire: si c'était aussi simple ils auraient trouvés

Peut être effectivement ... Mais : ils n'ont pas  trouvé ni étudié ce crible G avec sa fonction et sa propriété récurrente...""

Dossier ci joint

dossier modifié le 20/12/2023

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

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

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

Dernière modification par LEG (23-03-2024 10:48:57)

Hors ligne

#377 25-03-2019 18:50:01

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Bonjour,

Au risque de te décevoir, mais cette fois, je suis décidé à comprendre ce que tu racontes...
Mais d'abord, si la conjecture de Goldbach dont tu parles, dans ton cas puisque tu ne travailles qu'avec des impairs c'est bien un impair est la somme d'au plus 3 premiers ?
Sinon, c'est quoi ?

Que contient Ec ? Ep ? Comment passes-tu de l'un à l'autre ? Dis-moi à partir de quel n° de post je dois reprendre, tu gagneras du temps... les documents que tu t'es échiné à produire me sont, hélas pour toi et pour moi inexploitables : trop de notions m'y sont inconnues pour l'instant !
Qu'est-ce que  "l'Ensemble EC" ?
Qu'est ce le crible G ?
J'ai l'impression d'avoir 3 trains des mois de circulation de trains de retard.
Moi j'en suis resté au prog où tu tries les premiers fournis par la def eratosthène (je planche en ce moment sur le crible d'Atkin qui, brut de décoffrage, est effrayant de lenteur : nécessité de l'optimiser) par familles de reste (uniquement premiers entre k et 60k et où tu comptes le nombre total de premiers entre 30k et 60k.
Je n'avais pas (et n'ai toujours pas) compris le rapport avec la conjecture de Goldbach...
Tu vois, je suis loin, très loin de toi...

Qu'appelles-tu image vraie ?
Ensuite, pour moi dire image truc surjective sur machin  n'a pas de sens mathématique, seule une fonction (au sens mathématique de relation entre les éléments de deux ensembles) peut être injective ou surjective . Les deux = bijective...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#378 26-03-2019 03:31:21

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

re @Yoshi
A) : on fait référence au post ci dessus #376  que j'ai repris dans les explications ; relatif au deux cribles G et E , que l'on a programmé avant: le 23 12 2018.
donc je vais remettre les deux programmes en fin de post, ça évitera de les rechercher 2 mois en arrière ; mais que tu as. Je reprends les deux versions utilisées dans le document....ok ils sont déjà paramétrés sur la fam 1;
l'exemple utilisé ci-dessus #post 376, est fait avec le paramétrage fam 7. (peut importe la fam = famille.) ok

le crible G est le crible de Goldbach. le crible E est le crible d'Ératosthène , modulo 30.

justement je ne travaille qu'avec les familles d'impairs en progression arithmétique, donc deux impairs (p+q)= pair =2n ;
i.e : la conjecture de Goldbach dit, que tout nombre pair 2n > 4 peut se décomposer en somme de deux nombres premiers p + q.

EG contient les entiers naturels en progression arithmétique de raison 30, de premiers terme 1, ou P premier appartenant à [7 ; 29], qui sont criblés par  la fonction du crible G représenté sous la forme de 1 ou de 0, : 1 est : un entier non congru à 2n[Pi] restituant un nombre premier q appartenant à [n ; 2n]
suivant : les étapes 2) et 3),

3) : n°1b est donc l'image des éléments de EG criblé , de 7 à n =907, par les $P_i\leqslant\sqrt {2n}$ où les ,1, représentent bien les nombres premiers q. de 907 à (2*907) : de n à 2n. c'est à dire que ce sont les complémentaires des éléments de Ep de 1 à n ou inversement.


4) n°11 sont les mêmes éléments dans Ep que ceux de EG, de 1 à n : Entiers en progression arithmétique de raison 30, et, de la même famille; de 7 à 907 dans cet exemple; criblé avec le crible Ératosthène :crible E mais avec les $p_i\leqslant\sqrt {n}$
soit : 1814 - 7 = 1807 = q ; le complémentaire de la fam 7[30]...ok
Ce qui représentent bien les deux mêmes Ensembles d'entiers naturels >0 EG et Ep... ok..

5): Est l'image de 4) Ep criblé, en  n°1 :de 7 à n =907, par les $p_i\leqslant\sqrt {n}$ où les ,1,, représente bien, les nombres premiers P'

comment on passe de l'un à l'autre, i.e : de 3) à 5)...?

Et bien c'est simple: tu repasses avec la fonction du crible G sur le criblage des élément de Ep donc par obligation, tu auras l'image criblée, qui n'est rient d'autre que l'image de EG et Ep confondu, OU IL NE RESTE QUE La représentation des COUPLES (p+q) représenté par les ,[1], qui resteront , donc qui ne seront pas représenté en rouge, afin de visualiser le criblage de G sur les éléments de Ep.

Car en définitive, si tu regardes l'image de n°1 et n°1b ci-dessous : tu as une double image, celle des entiers [,1,] de 7 à 907 criblés par la fonction G donc: $\not\equiv{1814}[P_i]$ par conséquent les entiers [,1,] : représenteront bien les nombres premier q de 907 à 1814.

6) : Sera donc bien l'image de Ep criblé représenté en exemple : n°1b crible G ; puis n°11 crible E ; d'où n°12 re-crible G sur Ep par superposition d'image n°1b sur n°11qui sera représenté par l'image du criblage : n°12;
où il suffit simplement de marquer en rouge les 1 de Ep qui correspondent aux 0 de EG, pour représenter le passage du crible G sur Ep :
c'est à dire que l'on marquera en rouge, les entiers d'Ératosthène qui sont $\equiv{1814}[P_i]$... Corespondant aux [,0,] en n°1b de Goldbach.

les ,1, rouge de l'image n° 1b représenteront les nombres premiers q de n à 2n ...ok;

donc ces ,1, ils sont bien $\not\equiv{1814}[P_i]$ et ne peuvent en aucun cas marquer 0 les 1 d'Ératosthène en n°12 ; ils deviennent par conséquent les complémentaires q = 2n - P ayant pour antécédent les [,1,] d'Ératosthène non congruent à $P_i$..!

("Comme tu peux le constater ce crible à plusieurs fonctions qui n'ont pas été étudiées...")

n° 1  : [0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] cribleG de 7, à n, qui donnera les:
n°1b : [0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] complémentaires q surjectifs, [n;2n]

n°11 : [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] cribleE de 7 à n
n°12 : [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] superposition 1b qui donne ,1,=(p+q)

les ,1, noir qui restent après criblageG en n°12 indiquent donc les couples (p+q)=2n=1814 de la fam 7[30]. .. ok
Alors que les [,0,] sont des multiples de $(p_i\leqslant{n})$ $\not\equiv{1814}[P_i]$, qui donneront lors de l'augmentation de n+15 soit 1814 + 30; après décalage des congruences d'un rang, si ils précèdent un entiers [A'+30] = [,1,] premier, congru ou pas ...
Cela n'a donc aucune importance, car le décalage d'un rang des congruences fera en sorte que ce [A'+30] = [,1,] deviendra non congruent à $P_i$ ce qui donnera des nouveaux entiers premiers [,1,] $\not\equiv{(1814+k30)}[P_i]$, facilement vérifiable.
Empêchant par conséquent, d'infirmer la conjecture pour la limite suivante $N=15(k+1)+a$, c'est à dire pour le nombre pair suivant  $2N+2$ ,(cqfd)

("On vient de construire par l'absurde la contradiction de l'infirmation de Goldbach...! En supposant que pour n+15 elle est fausse  !")
Car il y aura un décalage des congruences sur leurs successeurs modulo 30, à partir du 2ème rang qui sera illustrée par l'image du criblage de n+15 ce qui se vérifie facilement ...! Ce qui va créer un effet boule de neige sur le nombre de décompositions de 2N, 2N+2 au fur et à mesure que la limite N du crible augmente et tend vers l'infini...

pourquoi cette contradiction :

Comment pourrais tu marquer en rouge, tous les éléments de Ep en repassant avec cribleG sur le criblage suivant n°2,n°21 n°22  alors que les restes $R_i$ , qui indexent les $P_i$ du crible G ne sont plus les mêmes et avec le même nombre de $P_i$ qui criblent ; car n a augmenté de 15, donc les 0 = entiers A congrus à $P_i$, comme les 1 = entiers A non congrus à $P_i$, leur congruence se décale d'un rang, leur cardinal sera le même à une exception près !
Sinon le contraire infirmerait le TNP et le TFA; le cardinal des multiples de $p_i$ et des nombres premiers $q$ appartenant à [N;2N] ne peut varier lorsque N augmente de 15 ...etc,  ni la propriété des ces entiers $B\in[N;2N]$ premiers ou pas .

Or pour un nombre légèrement différent de $p_i$ ou  $P_i$  qui criblent dans les deux ensembles , la quantité d'entiers de 7 à $n = 15k$ ne peut pratiquement pas varier de plus d'un élément, pour $n = 15(k+1)$. D'où la quantité de couples $p+q = 2n$ ne variera que de façon négligeable, suite à ce décalage d'un rang pour $n = 15(k+1)$ et cela, quelque soit la limite $n$ fixée, car de toutes les façons lorsque la limite N=15k est vérifiée, tu as aussi le résultats des entiers $A\not\equiv{2N}[P]$, qui précédaient un nombre premiers [,1,] lors des limites précédentes : N=15(k-2) , N = 15(k-1) , N=15k qui vont te donner et vérifier le résultat pour N =15(k+1). , N =15(k+2). ...etc.
D'où il est impossible de supposer la conjecture fausse, pour toutes limites suivantes $N = 15(k+1) + a$

Et par évidence pour le crible G dans Ep: les Pi qui criblent ne partent pas du même index que les $p_i$ qui crible dans Ep d'Ératosthène.
Sinon l'image EG et Ep serait identique : cela se traduirait par autant de nombres q de n à 2n que de nombres P' de 7 à n dans cet exemple... Ce qui par évidence, serait absurde...!

On a pas besoins du postulat de (.......) qui ne donne aucun renseignement, pour calculer le nombre de nombres premiers q de n à 2n.
Puisque l'on obtient avec cet algorithme une conséquence directe du TNP qui donne le nombre de nombres premiers $q\in{[N;2N]}$ par la fonction $\frac{N}{Ln\;2N}$ équivalente à $\pi(2n) - \pi(n)$ lorsque $n$ tend vers l'infini....
On en déduit même aussi, une troisième fonction suite à la propriété de ces deux algorithmes, indiquant un minimum de couples (p+q) = 2n . Car elle utilisent les mêmes fonctions, pour une même limite N et la même Famille (i) criblée.

J'en reste là pour cette partie : je met les programme dans le #post suivant pour éviter d'encombrer  ce post ..ok

Dernière modification par LEG (23-03-2024 10:18:34)

Hors ligne

#379 26-03-2019 03:49:34

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

petit rappel:
voici le cribleG qui crible "dans les congruences ..." ie : les entiers congrus à 2n [Pi], ou si tu préfères les entiers qui partage le même reste R de 2n par $P_i$ inférieur à racine de 2n et : $7\leqslant{P_i}\leqslant\sqrt2n$; par famille arithmétique de raison 30 : fam = famille, Ri est le reste de la division Euclidienne de 2n par Pi qui indexera la position de départ de ces Piqui vont cribler ces entiers non nuls, par pas de Pi de l'index qui à été calculer, jusqu'à n//30.

Pour changer de Fam = famille, on change le dernier paramètre de la ligne

GCrible(premiers, n, 1)

et pareille pour Ératosthène en dessous par l'un des 8 paramètres relatif à la fam qui est criblée.

G :crible_G.T.Y_modulo 30


from time import time
from os import system


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


def eratostene(n):
    n = int((2*n)**0.5)
    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))
    #print(f"On prend N = {n}  (30 * {int(n/30)})")
    return n


def lprint(text="", liste=None):
    if len(liste) < 1500:
        print(text + str(liste))


def GCrible(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)

    # On calcule les restes: ri = 2*n/pi
    nbpremiers = len(premiers)
    n2 = 2*n
 
    for i, premier in enumerate(premiers):
        reste = n2 % premier
  # 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 à partir de l'index, par pas de Pi
        for index in range(reste, lencrible, premier):
            crible[index] = 0

    total = sum(crible)
    lprint("crible:", crible)  # permet d'imprimer les entiers 1 congrus ou pas 2n mod Pi.
    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, 1)
    temps = time()-start_time
    print(f"--- Temps total: {int(temps*100)/100} sec ---")


main()
system("pause")

 

E : Crible_Era_gty_mod30  modifié , qui crible suivant le principe Ératosthène comme celui de dessus, mais avec les Pi< racine de n;
qui partent de Pi > ou = 7 ou du produit, calculer par la fonction E du programme ci-dessous :


from itertools import product
from time import time


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)
    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))
    #print(f"On prend N = {n}  (30 * {int(n/30)})")
    return n


def lprint(text="", liste=None):
    if len(liste) < 1500:
        print(text + str(liste))


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,
        # On crible directement à partir de l'index
        for idx in range(index, lencrible, a):  # index qui est réutilisé ici...
            crible[idx] = 0
        #print(j)
           
    total = sum(crible)
    lprint("crible:", crible)  # permet d'imprimer les entiers 1 < n premiers ou pas .
    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)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers entre 7 et n: {len(premiers)}")

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


main()

 

deux extraits:  pour n=15k +1 = 901 ; fam 1; n°1 cribleG , en n°2 crible E
Les deux fonctions utilisent le même principe de criblage par pas de Pi, seule l'index de départ change...dac...

RESTART: E:\Documents\Conjecture de Goldbach\CRibleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 901
n°1 : [1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0]
Extraction des premiers n à 2*n : 0.0 seconds ---
**  14 nombres trouvés en 0.0 secondes **
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 901
n°2 : [ 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0]
Extraction des premiers de 7 à n : 0.0 seconds ---

**  18 nombres trouvés en 0.0 secondes **

Pour cribler Ep,: il suffit de superposer l'image du cribleG sur l'image du cribleE et de marquer avec les ,0, en rouge, les nombres en noir. Car ce sont les complémentaires appartenant à [n ; 2n]

Mais c'est avant tout des entiers d'Ératosthène congrus ou pas à $2n[P_i]$

[" j'espère que tu t'en souviens...??? et que tu avais compris...] c'était la raison de ma question sur la surjectivité....

Dans les deux cribles les $0$ ne sont et ne peuvent être des nombres premiers soit des multiples de $P_i$, soit des entiers $\equiv{2n}[P_i]$ donc des multiples de $P_i$ de $n\;à\;2n$.!!!

c'est pour cela que je les ai utilisé afin de re-cribler Ep, et de voir cette aberration contradictoire sur l'infirmation de la conjecture. Car en superposant, Tu as l'image du crible , où : il ne reste que la représentation des $1\not\equiv{2n}[P_i]$  représentant les couples $(p+q) =2n$ représenté par les ,1, qui restent, lorsque tu superposes ou cribles les entiers d'Ératosthène, ce qui revient au même..

D'où si on suppose que pour $n +15$ , tous les ,0, de EG, vont marquer tous les ,1, de Ep.

IMPOSSIBLE . dû au décalage d'un rang vers la droite des congruences de EG lorsque $n$ augmente de $15$, et donc les entiers qui étaient congru ou non et augmentés de 30 par obligation, le resteront aussi avec 2n+30 modulo Pi car  les restes Ri de 2n+30 par Pi changent pour cribler les 1 relatif à la limite n + 15. Ce qui préserve l'égalité 2n - A = (2n+30) - (A+30).

Donc pour faire simple, si un entier A partageait le même reste R par P avec 2n par Pi il ne peut plus le partageait avec 2n + 30, il s'ensuit que cet entier serra non congru à (2n+30) modulo Pi .

Illustrer dans et en fin du document que tu as...[" En plus il y a une autre raison encore plus rigoureuse dû au changement de $R_i$ que je n'indique pas pour linstant facile à comprendre "]
@+
leg

Dernière modification par LEG (04-07-2021 08:42:38)

Hors ligne

#380 26-03-2019 20:40:59

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Salut,

J'avance...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#381 02-04-2019 17:41:20

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Re Yoshi.
je viens de répondre au mail et je t'ai renvoyé le dernier document de ce jour, avec les deux programmes à utiliser

pour Répondre à ta question

* Pourquoi dès le début, as-tu tu voulu savoir combien il y avait de
premiers entre n = 30k et 2n = 60k ?

je te l'avais dit: le crible de Goldbach permettait de démontrer élémentairement que le nombre de nombres premiers $q$ appartenant à $[n;2n]$ était un corollaire de la fonction du TNP et donc valait $\frac{n}{Log\: 2n}$ qui est d'ailleurs une conséquence directe du TNP. Si on va plus loin, tu as encore une autre fonction suite aux deux cribles qui te donnera le minimum de couple $(p+q) = 2n$ du fait que tu cribles à deux reprises les entiers d'Ératosthène il vient par conséquent :
$\frac{n}{(Log\: n)^2}$ $\sim$ $\frac{(n/log\:n)}{2*\:(Log\:(n/log\:n))}$ formule que j'utilise... Je pense que l'on devrait l'écrire suite au criblage de $\pi(n)$ par la fonction du crible G : $\frac{\pi(n)}{Log\: (2n)}$

Mais personne n'avait le crible, permettant de cribler uniquement les congruences des entiers de 1 à n fixé.

* L'étape clé est venue par hasard lorsque j'ai décidé de remplacer les
premiers par des 1, les autres par des zéros, permettant au lieu de
compter les premiers de faire la somme des éléments 1 ou 0 du fichier
(gagnant un temps précieux), c'est bien ça ?

non car dans tous mes programmes j'ai représenté les entiers en progression arithmétique de raison 30 par des 1 , et donc 0 lorsque l'entier est un multiple de Pi

Là, tu triais encore 8 familles.

Par ce que je n'avais pas le choix mon petit fils n'avais pas le temps de me le faire par famille , alors que j'avais déjà 3 programmes en C++ qui utilisaient ce principe de 1 et 0 par famille en progression arithmétique mod 30

C'est pour cela que sans ton aide , pour me refaire la douzaine de programmes en Python qu'ont à fait , puis retranscrit en c++, dernièrement.
j'étais chocolat.

cette découverte "......." par contre je la connaissait mais impossible de la rendre visible sans les deux cribles...Mais surtout d'en tirer les conséquences...!
car la solution est évidente...!!! maintenant;  car c'est limpide!!! , D'ailleurs sans les cribles comment tu vois cette aberration/contradiction ???

regarde le nouveau doc , et j'attends tes instructions ..Mais n'oublie pas c'est 50/50. car sans toi .....
A+

j'ai aussi défini  sous la ligne E(p+q) le terme fam.

fam : ce terme utilisé, ainsi que dans les deux programmes : désigne l’une des 8 familles modulo 30 que l’on va cribler :
fam 1 ; fam 7 ; fam 11 ; ….13, 17, 19, 23 et 29.

Dernière modification par LEG (27-05-2021 06:19:41)

Hors ligne

#382 30-04-2019 10:30:20

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Les deux cribles du post #379 ci dessus , permettent de résoudre la conjecture de Goldbach par l'absurde, en utilisant le principe de fonctionnement du crible G et sa propriété. "le lecteur connaît le fonctionnement de l'algorithme"
qui permet de donner une fonction asymptotique, $\frac{n}{Ln\:2n}$ donnant le nombres d'entiers naturels non nuls $A\not\equiv{R}[P]$, en utilisant le reste $R$ de $2n$ par $P$ ce qui implique :
$2n\not\equiv{A}[P]$ et donnera le nombre de nombres premiers $q$ , de $n$ à $2n$ ; qui est une conséquence Du TNP
 
Résumé :
[("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 $30 /3,75 = 8$ ce qui donne les 8 débuts $(i)$ = 1,7,11,13,17,19,23,29  en progression arithmétique de raison 30. "Excluant donc les multiples de 2,3 et 5"

Pour tout nombre 2n modulo 30 $\geqslant{300}$ , il y a par conséquent 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.

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 G, 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.")]

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

(1_)
On va introduire les éléments entrant dans le crible d’Eratsothène.

Le crible d'Ératosthène vise à marquer de $1$ à $n$ ou de $7$ à $n$ en criblant par famille Fam(i), les multiples de $p\in{P_n}\leqslant\sqrt{n}$ l'ensemble des nombres premiers .


Ou l'algorithme de Goldbach : utilisera l'ensemble des nombres premier ${P_{2n}}\leqslant\sqrt{2n}$, avec $P\in{P_2n}$ pour marquer les entiers $A\equiv{R}[P]$  de $7$ à $n$  par famille.

On se restreint donc aux entiers naturels impairs non nul, excluant les multiples de 2, 3 et 5.

On défini l'ensemble des entiers naturels impairs, non nuls excluant les multiples de (2;3 et 5): $A_n\in{[1 ; 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$.

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}$  ; avec $p\in{P_n}$ pour cribler les nombres $A$ appartenant à $[7 ; n]$

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

On défini $B_{2n}$ l’ensemble des nombres en progression arithmétique de raison 30, $\in{[n, 2n]}$ et à une des 8 Fam(i) complémentaires aux entiers $A$, par rapport à $2n$, multiples ou pas d’un élément premier de $P_2n\leqslant\sqrt{2n}$.

Par définition, quel que soit $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 complémentaires aux nombres $A$ $\in{A_n}$ par rapport à 2n.

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

Nous allons nous intéresser aux familles Fam(i): $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)$. ce n'est pas le but")

1) Ce principe de fonctionnement et la propriété du crible G utilisant les congruences conduit à une résolution par l'absurde dela CG ; quelque soit 2n ou 2n + 2. Sans perte de généralité, on utilise une seule $Fam(i)$ déterminée par la forme de $n = 15k + a$ avec $a$ appartenant à $[0\: ; 14]$ ce qui donne 15 formes de $n$ pour parcourir l'ensemble des nombres pairs $2n\geqslant{150}$

2) On calcule les restes $R$ de $2n$ par $P$  afin d'indexer le départ des nombres $P$ qui vont cribler "marquer" ces $A\equiv{R}[P]$. c'est à dire qui partage le même reste $R$ par $P$ avec $2n$; d'où $A$ et $2n$ sont congrus modulo $P$.

ie: on va marquer ces$A$ représentés par des 1, d'un 0, de $1\, à\, n$, si ils sont $congruents\:[P]$ par pas de $P$.
("même principe que celui d'Ératosthène, hormis le point de départ qui par obligation est fixé par les restes $R$ de 2n par $P$ et la Fam(i) est fixée par la forme de la limite n") définie.
On constate donc, que le point de départ du crible de Goldbach et plutôt que celui d'Ératosthène; car il est défini par le reste $R$ de $2n$ par $P$ .
On en déduit par évidence, que l'on marquera plus de nombre $A$ congruents à $P$; d'où moins de nombres premiers $q\in{[n;2n]}$ que de nombres premiers $P'\in{[1;n]}$ criblés par Ératosthène.!

Dans Ératosthène les entiers $A$ sont aussi représentés par des 1, qui seront marqués 0 si ce sont des multiples de $p\leqslant\sqrt{n}$ qui criblent par pas de $p$ (" En partant de $p$ suivant le principe de base, ou d'un produit de deux $p$ si on crible par Fam(i) en progression arithmétique de raison 30, tel que définis ci-dessus...etc; avec dans ce cas : $p'$ appartenant à $[7 ; 31]$ pour calculer le produit, voir programme")

3) On crible les $A$ d'Ératosthène avec le crible E , pour une limite fixée : $n = 15k = 210$ avec la $fam\: 7[30]$ : ce qui donne les entiers Premiers $P'$ représentés par des $1$;  de premier terme 7  en progression de raison 30 : $7,37,67,97,.....n=187$ ....etc

4) pour $n = 15k = 210$ fam 7; soit (210 - 7) / 30 : 7 entiers à cribler, de 7 à 187 . résultat obtenu :

      A_) crible E Donnez N: 210
    crible:[1, 1, 1, 1, 1, 1, 0]

       B_) crible G: Donnez N: 210 avec $P\leqslant\sqrt{2n}$ . (" ci-dessous : image du criblage de la fonction G")
....crible: [(0), 1, 1, 0, 1, 1, 1] seul $7 \:et\: 97$ partage le même reste avec $420$ modulo P , {7,17}.
Les A marqués 0 sont congruents à $P$, avec $2n=420$

On va re-cribler E ci-dessus  en A) avec le crible G en B), même limite n = 15k = 210 et la même fam 7 ;
ce qui donne les entiers représentés ci dessous [$7,37,67,97,127$...modulo 30 ..n =187 ]

      C_)  criblage de E avec G : [(1), 1, 1, 1, 1, 1, 0] on marque en rouge les $A$ d'Ératosthène $congruents[P]$ correspondant aux 0 du crible G en B_) ; il reste par conséquent les $1\:non\: congruents\:[P]$ qui vont former les couples P'+q décomposant 420 en somme de deux nombres premiers $P'+q$.

5) On réitère avec $n + 15$ soit $15(k+1) = 225$. selon la propriété de L'algorithme dans les congruences elles vont se décaler d'un rang afin que $(2n+30) - (A+30) =$ $q$ ou $multiple\: de \:(P)$ ; criblé précédemment. On utilise les nouveaux restes $R$ de $(2n+30)\: par (P)$.

      A_) crible E  :  [1, 1, 1, 1, 1, 1, 0]  ("pas de changement ni de décalage ce qui est normal, ce sont les même nombres $P$ qui criblent.")

    B_)  crible G  :  [1, (0), 1, 1, 0, 1, 1] à partir du deuxième rang, on reproduit le criblage précédent décalé d'un rang par obligation : avec les nouveaux $R$ mais les mêmes nombres $P$; le contraire serait absurde. d'où $37\: et\: 127$ seront avec 450 $congruents\; [P]$ et bien entendu 7 et 97 sont libérés de leur congruence, donnant deux couples P'+q=450

    C_) criblage de E , avec G : [1, (1), 1, 1, 1, 1, 0] à partir du 2ème rang là aussi, on reproduit exactement l'image du criblage précédent qui a vérifiée la conjecture, mais avec les nouveaux $R$ et les mêmes premiers $P$ . Dans le cas contraire on perdrait l'égalité et la propriété des entiers de $n\;à\;2n$.
De part ce décalage d'un rang des congruences, on a simplement décalé les couples d'un rang, afin que  P'+ q = 450 le contraire serait absurde.

D'où $7$ qui était avec 420 $congruent\; [P]$ se trouve ainsi libéré de sa congruence; c'est à dire qu'il ne peut plus partager le même reste $R$ par $P$ avec $2n$ qui a augmenté de 30, d'où $7 + (413+30) = 450$ avec q=443 qui est un nombre premier, car déterminé par $450\not\equiv{7}[P]$.

C'est cette propriété de ce principe de fonctionnement du crible, avec le décalage des congruences sur le successeur $A+30 = 37$ qui va être utilisée pour prouver la conjecture.

On voit déjà l'idée pour $n = 15(k+2) = 240$, d'où $37$ va vérifier la conjecture : $480 - 37 = 443$ ; car le décalage de la congruence sur son successeur 37, implique obligatoirement $450\not\equiv{37}[P]$, car q = 443 est toujours un nombre premier, le contraire serait idiot....etc etc.


6) Il vient donc : Afin d'infirmer la CG pour $15(k+2) = 240$ en supposant qu'elle soit fausse :

    a_) La fonction G doit donc marquer d'un 0 les $A$ = 1 d'Ératosthène du criblage précédent au point 5_) , C_) tel que : $30(k+1)\not\equiv{A} [P]$  Mais : avec les nouveaux $R$ de $30(k+2)\: par\: (P)$, c'est à dire, avec les mêmes premiers $P$ de la limite précédente; éventuellement avec un de plus.

    b_) Or : Suite à ce décalage des congruences, la fonction G doit aussi et encore, marquer d'un 0 les entiers (0) qui avec 30(k+1)étaient $congruents \;à \;P$ c'est à dire : pour être rigoureusement sûr, suite à ce décalage, il faut marquer d'un 0 tous les entiers d'Ératosthène du criblage précédent relatif à $n = 15(k+1)$ ; avec les nouveaux reste $R$ et les mêmes nombres premiers; ce qui est absurde.(cqfd)

    c_) En effet selon l'affirmation du point b_) : les restes $R$ relatifs à $n = 30(k+1)$ ont changés pour $n = 30(k+2)$, mais pas les nombres $(P)$ qui criblent.

             Il vient de ce fait que les indexes de ces nombres $P$ qui criblent ne sont plus les mêmes, car les indexes augmentent de 1, ce qui occasionne le décalage d'un rang des congruences sur leur successeur;
la division de $2n = 30(k+2)\: par\:$ $(P)$ ne donne qu'un $R$ par nombre $(P)$ ; elle ne restitue pas les restes $R$ des précédents criblages successifs , relatif à $n  = 15 (k+1) \; ; 15k \; ; 15(k-1)\;...etc$.

D'où il est impossible de marquer d'un 0 tous les éléments d'Ératosthène de 1 à n par la fonction Get donc de n'avoir aucun couple P'+q = 30(k+2) afin d'infirmer la CG suivant cette supposition !
Ou pour 2n + 2 de façon générale, en fonction de la forme de $n$ et la fam(i) fixée suite à la forme de $n$.

En effet, un raisonnement par l’absurde est évident : (Si on marquez tous les A d'Ératosthène pour la limite n suivante, il est clair qu'il n'y aurait plus de nombres premiers q entre n et 2n ...!

Ou encore,  pour que les [0] de Goldbach, se décalent sur les [1] d’Ératosthène, il aurait fallu que la répartition des nombres premiers [1] du crible Ératosthène, correspondent à l’index de départ du crible de Goldbach et en plus qu’ils soient en progression arithmétique de raison P de Goldbach « les nombres P qui criblent ». Ce qui est clairement impossible.

Mais en conclusion : il vient que pour n = 15(k+1) + a, on ne fera que répliquer à partir du deuxième rang une solution des congruences ayant vérifié la conjecture précédemment pour n = 15k + a, Mais simplement décalée d'un rang.
Car dans le cas contraire :
Cela reviendrait à dire, que l'on supprimerait les nombres premiers q de n à 2n, ayant été défini pour la limite précédente n = 15k + a si tel était le cas.....!
Ce qui est absurde. voir l'illustration du dernier pdf.

Pour résumer, quel que soit la limite n = 15k vérifiée, il vient de par le décalage d’un rang qui s’ensuit, la conjecture sera donc vrai pour n = 15(k+1) puisque elle aura été vérifiée pour n = 15k et ainsi que les A non congruents à P, qui précèdent les A' = P' premiers; pour cette limite n = 15k.

(« Car suivant la propriété récurrente du crible : Les entiers $A$ premiers ou pas, de $7$ à $n$ non congruent à [P] avec $2n$; qui précèdent un nombre premier $P'$, la conjecture sera alors vérifiée pour : $n = 15(k+1)$. Cette affirmation se démontre élémentairement .»)

Autrement dit, la variation du nombre de couples $P' + q = 2n + 2$ sera négligeable à cause du décalage d'un rang des congruences et il en est tout autant   du nombres de nombres premiers $q$ appartenant à [n;2n], c'est le même cardinal à une exception près.

On prouve par là, qu'il est impossible d'infirmer cette conjecture. Donc la conjecture de Goldbach est vraie !

La densité du nombre de nombres premiers $q$, ainsi que le nombre de couples $P'+q = 2n$ sont étroitement liée au théorème des nombres premiers, à la conjecture ou au " théorème de Goldbach" ainsi qu'à la densité de premiers de 1 à n ou de n à 2n, caractérisé par ces deux cribles E et G avec leurs fonctions.

*************************************************************************************************************************************************************
Par exemple: Si on prend n = 211 ; soit 2n + 2 j'aurai pris la fam 1[30] :
1) qui a vérifié n = 15k + 1 = 196 : dans les deux cas on utilisera pour le crible G les nombres $P$ de $7 \:à\:19$ et $p$ de $7 \:à\:13$ pour le crible E

Donnez N: 196 ; crible G:[0, 0, 1, 0, 1, 1]
Donnez N: 196 ; crible E:[1, 1, 1, 0, 0, 1] donc ok 2 couples avec P' = 61 et 151

2) pour n =15(k+1) +1 = 211 ; 2n + 2 = 422.

Donnez N: 211 ; crible G:[1, 0, 0, 1, 0, 1, 1] on a bien le décalage d'un rang à droite du premier élément, dû au changement de restes.
C'est à dire que l'on réplique la solution précédente à partir du deuxième rang, seul le premier élément est un inconnu.
Donnez N: 211 ; crible E:[1, 1, 1, 0, 0, 1, 1] ok, 2 couples avec P' = 151 et 181

("On utilise le même principe qu'a utiliser Euclide pour démontrer l'infinité du nombre de nombre premier, en rajoutant 1 à la limite n précédente, ayant vérifié la conjecture, on décale d'un rang les congruences, les restes $R$ de $2n+2$ par les même nombres premiers $P$ ne sont plus les mêmes, alors que les nombres $P$ qui sont utilisés dans les deux cribles pour la limite n + 1, eux ne varient pas. !")

A noter : que l'on a aussi la possibilité d'utiliser les deux autres familles $13[30]+19[30]$ et inversement pour cette forme de $n = 211$; relatif à $2n + 2 = 422$. Avec les mêmes $P$ bien entendu. Si on continue il est claire que pour $n = 211 +1$, soit $422 + 2$ , on change de famille pour vérifier $30k + 4 = 420 + 4$ on prendra par exemple la fam $17[30]$ ou les deux fam $11\;et\; 23 [30]$ dont leur somme donnera $30k + 4$.
On testera pour vérifier : $n = 15k + 2 = 197$ suite à $196 + 1$ précédemment.
Par définition, $n = 197$ a lui aussi vérifié la conjecture car vérifiée pour $15(k-1) + 2$. Elle est donc vérifiée jusqu'à n = 211 . D'où on est sûr qu'elle serra vérifiée pour $30k + 4 = 424$...etc.

Dont le lecteur, pourra vérifier le résultat, en utilisant les deux cribles du post ci-dessus.....Mais qui ne changera rien à cette résolution.



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

Pour la forme:

[" On prend une limite $n = 15k + a$ , avec $a$ entier naturel appartenant à $[0\: ; 14]$ afin de parcourir tous les entiers $2n\geqslant{300}$ la conjecture ayant été vérifiée de 6 à 300. En fonction de la forme de n on choisit la famille modulo 30 à utiliser."]

Autre extrait: en ne criblant qu'une fois et où on décale simplement les congruences d'un rang , ce qui permet de vérifier jusqu'où la CG est vérifiée : C'est à dire jusqu'où il faut remonter en arrière en utilisant les restes $R$ de $2n\:par\: P$ précédants

On a fixé $n = 15k = 1140$ , $Fam=7[30]$ on crible $mod30$ : de $7\: à\: 1140$ avec E , puis avec G….

ce qui donne les $A$ et 2280 congruents à $[P]$  [7,37,67,97,......modulo 30  ....n = 1117] marqués par des 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, 1, 1] G
[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] E .

Pour $n= 15(k+1)$: seul la première cellule [X] est l'inconnue, on reporte les congruences sur les successeurs $A+30$

[x]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, 1, [1 ]
[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]


Pour $15(k+2)$  ; On aura deux [x,x] inconnues

[x, x] 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,] [1,1
[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]

Puis : Trois [xxx] inconnues pour $15(k+3)$
[x x, x]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, 1,1
[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]

Constat et conclusion, elle serait encore vérifiée sur plus d'une dizaine de criblages successifs....simplement avec les $R$ de $30k = 2280$ et leurs $P$ qui ont criblés, sans utiliser les deux cribles. Autrement dit, le crible n'a fait que de décaler d'un rang , 2 rangs, 3 rangs une solution ayant vérifiée la conjecture précédemment .

On peut d'ailleurs remarquer que c'est tout simplement une conséquence directe du TNP et des deux cribles E et G, avec leur fonction :$\frac{n}{Ln\:n}$ et $\frac{n}{Ln\:2n}$ qui utilisent les nombres premiers $P\leqslant\sqrt{n}$ ou $P\leqslant\sqrt{2n}$

Ce qui donnerait au minimum, le nombres de couples  $P' + q = 2n$ par la fonction : $\frac{\pi(n)}{Ln\:\pi(n)}$ puisque l'on crible à nouveau les nombres $ = P'$ de $\pi(n)$ ; c'est à dire les $P'$ non congruents à $P$ , tel que $2n\not\equiv{P'}[P]$.

On a donc pour la première ligne d'Ératosthène $n = 1140$ où le nombre de premiers "1" $P_{(n)} = 26$ : $\frac{26} {Ln\: 26} = 7,98...$ sur un réel de $16$ couples. ("Mais on peut encore affiner cette fonction. la variation du nombre de couples p+q = 2n sera oscillatoire.")

On se retrouve à peu près dans le principe de la descente infinie de Fermat : pour marquer tous les $1$ et les $0$ des criblages précédent et bien il faut les restes $R$ précédents de : $15(k+2) ;15(k+1) ; 15k = 1140 ; 15(k-1) ; 15(k-2)$....etc. Plus $n\rightarrow\infty$  il faudra redescendre de plus en plus, sur les restes $R$ des criblages précédents ... Ce qui prouve qu'il est impossible d'infirmer la conjecture.

Explication sur le principe de base de l'algorithme G:

Criblage Par famille en progression arithmétique de raison 30, en fonction de $n$ :

On calcule le reste $R$ de la division de $2n$ par $P\leqslant\sqrt 2n$ afin de l'utiliser pour marquer les entiers $A$ congrus $R$ modulo $P$
puis on calcule : $J = R$ + $k*P$  si $R$  est pair ;
si $R$ est impair$ J = R$ puis $J + k*P$  jusqu’à j %30 == Fam : « la famille qui a été choisie par rapport à $n$. »

si j %30 == Fam ; on calcule l'index : j//30 = idx et on crible les entiers $A\equiv{R} [P]$ c'est à dire $\congruents\; avec\; 2n \;[P]$ par pas de $P$ , de l'idx à n//30 : en remplaçant le 1 par 0. (" ces entiers et 2n qui partagent le même reste $R$ modulo $P$")

Fam(i) est une des 8 familles, de premier terme : {1,7,11,13,17,19,23,29} fixée par la forme de $n$ et sa limite.

En exemple ci-dessus: pour $n = 1140$ $P = 7$ , le reste $R$ de 2n par 7 = 5 ; d'où $j = 5 + k*7 = 187$, qui est $\equiv {7}[30]$ la Fam fixée
l'idx = 187//30 = 6
$P_i = 7$ part de la 6ème cellule $= 187$ , qu'il marque d'un 0, puis par pas de 7 on marque les entiers représentés par des 1 d'un 0 jusqu'à la limite n / 30 , 38 cellules ou entiers modulo 30.
etc. On réitère avec $P = 11$....etc $P \leqslant 47$

dossier modifié:
https://www.cjoint.com/c/MLwhYgOjWGB

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

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

Dernière modification par LEG (22-12-2023 08:51:53)

Hors ligne

#383 07-05-2019 07:31:30

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Salut,

Réponse par mail refusée via no-log : incidents de spam...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#384 07-05-2019 10:56:01

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bonjour Yoshi
je viens de regarder dans les spam ..ton message n'y figure pas  surement erreur de la messagerie orange..
@+

Hors ligne

#385 07-05-2019 12:41:40

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Ok,

Nouvel essai d'envoi.

@+

[EDIT]
Nouveau refus

Dernière modification par yoshi (07-05-2019 13:07:01)


Arx Tarpeia Capitoli proxima...

Hors ligne

#386 10-09-2019 13:32:59

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

Dernière modification par LEG (10-09-2019 13:37:06)

Hors ligne

#387 21-03-2020 10:17:51

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

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

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

@+
mise à jours des fichiers :

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

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

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

Dernière modification par LEG (22-12-2023 08:52:17)

Hors ligne

#388 21-03-2020 11:50:43

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Bonjour,

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

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


Arx Tarpeia Capitoli proxima...

Hors ligne

#389 21-03-2020 13:25:50

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

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

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

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

Dernière modification par LEG (22-12-2023 08:52:34)

Hors ligne

#390 30-03-2021 11:39:28

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bonjour à tous

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

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

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

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

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

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

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

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

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

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

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

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

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


// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
void fill_crible(vector<unsigned> &crible, unsigned p)
{
  crible.resize((p - 1) / 64 + 1);
  unsigned cs = crible.size();
  unsigned lastnum = 64 * cs;
  unsigned lastsieve = int(std::sqrt(double(lastnum)));
  unsigned primesieved = 1;
  crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
  for (unsigned i = 1; i < cs; ++i)
    crible[i] = 0xffffffff;
  for (; primesieved <= lastsieve; primesieved += 2)
  {
    // find next prime
    unsigned pos = primesieved / 2;
    for (; pos < cs; pos++)
    {
      if (crible[pos / 32] & (1 << (pos % 32)))
        break;
    }
    // set mutiples of (2*pos+1) to false
    primesieved = 2 * pos + 1;
    unsigned n = 3 * primesieved;
    for (; n < lastnum; n += 2 * primesieved)
    {
      pos = (n - 1) / 2;
      crible[(pos / 32)] &= ~(1 << (pos % 32));
    }
  }
}
unsigned nextprime(vector<unsigned> &crible, unsigned p)
{
  // assumes crible has been filled
  ++p;
  if (p % 2 == 0)
    ++p;
  unsigned pos = (p - 1) / 2, cs = crible.size() * 32;
  if (2 * cs + 1 <= p)
    return -1;
  for (; pos < cs; ++pos)
  {
    if (crible[pos / 32] & (1 << (pos % 32)))
    {
      pos = 2 * pos + 1;
      // if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
      return pos;
    }
  }
  return -1;
}

typedef unsigned long long ulonglong;

size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau de 1 modulo 30 et rappeler les premiers p
  int cl = clock();
  // size_t lencrible = n / 30,
  size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
  //vector<bool> crible(lencrible, true);                    // on rappelle les nombres premiers p d'Eratotene ci dessus
  // ulonglong n2=2*n;
  vector<ulonglong> indices(nbpremiers);
  for (size_t i = 0; i < nbpremiers; ++i)
  {
    ulonglong p = premiers[i];
    ulonglong produit;
    int GM[] = {7, 11, 13, 17, 19, 23, 29, 31}; // on va calculer le produit de p par un element du groupe GM
    for (size_t j = 0; j < sizeof(GM) / sizeof(int); j++)
    {
      produit = p * GM[j]; // calcul du produit, jusqu'a ce que le produit soit égale à fam modulo 30
      if (produit % 30 == fam)
      {
        produit /= 30; // puis on va va calculer l'indice, afin de commencer à cribler de l'indice à n/30 et on réitère
        break;
      }
    }
    indices[i] = produit;
  }
  ulonglong nslices = lencrible / 1500000, currentslice = 0;
  if (nslices == 0)
    nslices = 1;
  for (; currentslice < nslices; ++currentslice)
  {
    size_t slicelimit = currentslice + 1;
    slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
    for (size_t i = 0; i < nbpremiers; ++i)
    {
      ulonglong p = premiers[i];
      size_t index;
      for (index = indices[i]; index < slicelimit; index += p)
        crible[index] = 0;
      indices[i] = index;
    }
  }
  size_t total = 0;
  for (size_t index = 0; index < lencrible; ++index)
    total += int(crible[index]);
  //cout << "Nombre premiers criblés famille " << fam << " plus petits que " << n << ": " << total << " time " << (clock() - cl) * 1e-6 << endl;
  return total; // à la fin du crible on return le résultat est le temps mis
}

size_t GCrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{
  int cl = clock();
  //size_t lencrible = n / 30,
  size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
  //vector<bool> crible(lencrible, true);                    // on rappelle les nombres premiers p d'Eratothene ci dessus
  ulonglong n2 = 2 * n;
  vector<ulonglong> indices(nbpremiers);
  for (size_t i = 0; i < nbpremiers; ++i)
  {
    ulonglong p = premiers[i];
    ulonglong reste = n2 % p; // on calcule le reste de 2n par p
    if (reste % 2 == 0)
      reste += p;
    ulonglong pi2 = 2 * p;
    while (reste % 30 != fam) // tant que le reste += p n'est pas = à Fam % 30 on rajoute 2*p
      reste += pi2;
    reste /= 30; // on ensuite on va calculer l'indice pour commencer à cribler le tableau de 1.1.1.... avec p, de l'indice à n/30
    indices[i] = reste;
  }
  ulonglong nslices = lencrible / 1500000, currentslice = 0;
  if (nslices == 0)
    nslices = 1;
  for (; currentslice < nslices; ++currentslice)
  {
    size_t slicelimit = currentslice + 1;
    slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
    for (size_t i = 0; i < nbpremiers; ++i)
    {
      ulonglong p = premiers[i];
      size_t index;
      for (index = indices[i]; index < slicelimit; index += p)
        crible[index] = 0;
      indices[i] = index;
    }
  }
  size_t total = 0;
  for (size_t index = 0; index < lencrible; ++index)
    total += int(crible[index]); // le criblage du tableau de 1 modulo 30 jusqu'a n/30 (1.1.1.1...etc) est fini on va retourner le résultat
  cout << "Nombre couples p+q=2N criblés famille " << fam << " : " <<total << " time " << (clock() - cl) * 1e-6 << endl;
  return total;
}

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

  vector<int> familles;
  familles.push_back(1);
  familles.push_back(7);
  familles.push_back(11);
  familles.push_back(13);
  familles.push_back(17);
  familles.push_back(19);
  familles.push_back(23);
  familles.push_back(29);

  for (int i = 0; i < familles.size(); i++)
  {
    int fam = familles[i];

    for (ulonglong limite = debut; limite < fin; limite += 15)
    {
      cout << "famille : " << fam << " limite : " << limite << endl;
      double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
      fill_crible(temp, sqrt2N);
      vector<ulonglong> premiers;
      for (ulonglong p = 7; p <= sqrt2N;)
      {
        premiers.push_back(p);
        p = nextprime(temp, p);
        if (p == unsigned(-1))
          break;
      }

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

Dernière modification par LEG (22-12-2023 08:53:02)

Hors ligne

#391 29-11-2021 11:11:21

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

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

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

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

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


from time import time
from os import system

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

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

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

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

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

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

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

J'utilise [Code::block]

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

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


// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
void fill_crible(vector<unsigned> &crible, unsigned p)
{
  crible.resize((p - 1) / 64 + 1);
  unsigned cs = crible.size();
  unsigned lastnum = 64 * cs;
  unsigned lastsieve = int(std::sqrt(double(lastnum)));
  unsigned primesieved = 1;
  crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
  for (unsigned i = 1; i < cs; ++i)
    crible[i] = 0xffffffff;
  for (; primesieved <= lastsieve; primesieved += 2)
  {
    // find next prime
    unsigned pos = primesieved / 2;
    for (; pos < cs; pos++)
    {
      if (crible[pos / 32] & (1 << (pos % 32)))
        break;
    }
    // set mutiples of (2*pos+1) to false
    primesieved = 2 * pos + 1;
    unsigned n = 3 * primesieved;
    for (; n < lastnum; n += 2 * primesieved)
    {
      pos = (n - 1) / 2;
      crible[(pos / 32)] &= ~(1 << (pos % 32));
    }
  }
}
unsigned nextprime(vector<unsigned> &crible, unsigned p)
{
  // assumes crible has been filled
  ++p;
  if (p % 2 == 0)
    ++p;
  unsigned pos = (p - 1) / 2, cs = crible.size() * 32;
  if (2 * cs + 1 <= p)
    return -1;
  for (; pos < cs; ++pos)
  {
    if (crible[pos / 32] & (1 << (pos % 32)))
    {
      pos = 2 * pos + 1;
      // if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
      return pos;
    }
  }
  return -1;
}

typedef unsigned long long ulonglong;

size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau de 1 modulo 30 et rappeler les premiers p
  int cl = clock();
  // size_t lencrible = n / 30,
  size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
  //vector<bool> crible(lencrible, true);  // on rappelle les nombres premiers p d'Eratotene ci dessus
  // ulonglong n2=2*n;
  vector<ulonglong> indices(nbpremiers);
  for (size_t i = 0; i < nbpremiers; ++i)
  {
    ulonglong p = premiers[i];
    ulonglong produit;
    int GM[] = {7, 11, 13, 17, 19, 23, 29, 31}; // on va calculer le produit de p par un element du groupe GM
    for (size_t j = 0; j < sizeof(GM) / sizeof(int); j++)
    {
      produit = p * GM[j]; // calcul du produit, jusqu'a ce que le produit soit égale à fam modulo 30
      if (produit % 30 == fam)
      {
        produit /= 30; // puis on va va calculer l'indice, afin de commencer à cribler de l'indice à n/30 et on réitère
        break;
      }
    }
    indices[i] = produit;
  }
  ulonglong nslices = lencrible / 1500000, currentslice = 0;
  if (nslices == 0)
    nslices = 1;
  for (; currentslice < nslices; ++currentslice)
  {
    size_t slicelimit = currentslice + 1;
    slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
    for (size_t i = 0; i < nbpremiers; ++i)
    {
      ulonglong p = premiers[i];
      size_t index;
      for (index = indices[i]; index < slicelimit; index += p)
        crible[index] = 0;
      indices[i] = index;
    }
  }
  size_t total = 0;
  for (size_t index = 0; index < lencrible; ++index)
    total += int(crible[index]);
  cout << " Nbr p' criblés Fam " << fam << " < à " << n << ": " << total << " time " << (clock() - cl) * 1e-6 << endl;
  return total; // à la fin du crible on return le résultat est le temps mis
}

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

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

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

  for(ulonglong limite = debut; limite<fin; limite += 15){
    cout << "--> limite : " << limite << endl;
    double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
    fill_crible(temp, sqrt2N);
    vector<ulonglong> premiers;
    for (ulonglong p = 7; p <= sqrt2N;)
    {
      premiers.push_back(p);
      p = nextprime(temp, p);
      if (p == unsigned(-1))
        break;
    }

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

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

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

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

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

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

Dernière modification par LEG (22-12-2023 08:53:32)

Hors ligne

#392 31-10-2022 12:04:28

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bonjour à tous

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


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

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

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

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

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

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

Exemple :
Avec ce petit extrait  des 2 cribles ;

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

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

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

Donnez N =300

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

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

Donnez N =315

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Principe de base:

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

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

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

Dernière modification par LEG (22-12-2023 08:53:51)

Hors ligne

#393 21-11-2022 17:35:21

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

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

Ok mon ami

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


from time import time
from os import system
import math

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


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


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

    return n


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

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

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


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

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

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


main()
system("pause")    
 

ça fonctionne impec.


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

Dernière modification par LEG (24-11-2022 06:12:32)

Hors ligne

#394 22-11-2022 17:57:14

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Bonsoir,

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

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

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

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#395 23-11-2022 07:26:36

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bonjour@Yoshi

OKok

problème résolu

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

impec

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

Dernière modification par LEG (24-11-2022 06:16:18)

Hors ligne

#396 23-11-2022 07:59:11

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 947

Re : crible en python

Re,

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

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

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#397 23-11-2022 09:56:31

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

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

from time import time
from os import system
import math

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


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


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


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

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

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


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

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

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


main()
system("pause")    
 

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

Dernière modification par LEG (07-09-2023 08:19:27)

Hors ligne

#398 23-11-2022 10:00:25

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bon tout marche bien :

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

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

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

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

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

Préambule :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@+
G

modifié le 20/12/2023 :

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

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

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

Dernière modification par LEG (23-12-2023 14:34:00)

Hors ligne

#399 27-11-2022 04:29:29

LEG
Membre
Inscription : 19-09-2012
Messages : 690

Re : crible en python

Bonjour @yoshi , je reviens sur ton message:

yoshi a écrit :

Il y a plus simple...
@+

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


 from time import time
from os import system

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Dernière modification par LEG (23-12-2023 14:57:29)

Hors ligne

Réponse rapide

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

E-mail (obligatoire)

Message (obligatoire)

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

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

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

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

Pied de page des forums