De LEG

LEG · Enigmes, casse-têtes, curiosités et autres bizarreries

Bonjour à tous

Ce Crible G fonctionne très bien par Famille d'entiers positifs de la forme $30k + i$ , avec $i\in(1;5;7;11;13;19;23;29)$ 8 Fam i ou 8 suites arithmétiques de raison 30, contenant l'ensemble des nombres premiers $\geqslant{7}$ ou : On peut aussi le faire fam 1[2]

Le document joints donnent le principe de base du fonctionnement de ce crible avec en parallèle le crible E d'Ératosthène , le crible G utilise le tableau criblé du crible E , ce qui permet d'avoir directement le nombre de solutions qui décompose $2n$ en somme de deux premiers., sans avoirs besoins de s'occuper de l'intervalle $[n;2n]$ et encore moins de la primalité de leur complémentaire les nombres B = $q$ premiers de cet intervalle.
----------------------------------------------------------

Propriété de l'algorithme : décalage récurrent d'un rang de l'axe des ordonnées des congruences de Goldbach, sur l'axe des abscisses d'Ératosthène

https://www.cjoint.com/c/MArk02rOh5T
.Cordialement Leg.

LEG · Programmation

Ok , pas de souci. merci

LEG · Programmation

Oui c'est ce que m'a confirmé le collègue qui s'occupe de mon PC , lorsque j'ai un souci pour charger une application ... donc je verrai par la suite pour le télécharger sur le site Hasquell ...

HASKELL

LEG · Programmation

Bonjour:
Re;
Pour installer Haskell, deux options s'offrent à vous, le télécharger depuis le site du projet ou l'installer depuis le gestionnaire de paquet de votre système d'exploitation préféré :

# Pour Ubuntu
$ apt-get install haskell-platform

J'ai vérifié sur mon système ; je suis allé dans gestionnaire de paquets synaptiques ; ce paquet ne figure pas , il y a uniquement : @ apt

Donc je suppose qu'il me faudra aller sur la plateforme Haskell pour télécharger cette application ...?

LEG · Programmation

Re : rassure toi je ne m'impatiente pas du tout , le but est que tu prennes ton temps , et qu'effectivement il soit plus rapide que python .

Pour info en C++ , ce programme complet met pour le résultat avec n = 999 999 999 les deux dernières parties ; 0,0879 secondes et 0,08873 seconde , cela te permettra de voir une fois le tout complété ... Merci pour ton aide et tes explications...

Il est clair que l'édition des nombres premiers , ou les tableaux criblé, prennent du temps , mais ce n'est pas le but , éditer les [tableau / liste] de 1 , criblé c'est bon jusqu'à $n = 300 000$ maxi , car ensuite c'est comme regarder des grains de sables sur la plage ...

Bonne après midi .

LEG · Programmation

Ok , j'ai lu ... mais je ne comprend pas tout ..., effectivement je comprend le but de tes explications, mais pour quelqu'un qui fait ou veut modifier le programme .

En python j'ai su le faire (sur certaine partie) mais surement pas en C++ ...

Je pense que Yoshi serra à même de voire la différence ...

Moi je ne peux que tester , comme tu l'as très bien fait d'ailleurs ...

Je vais me comporter comme la tortue et non comme le renard...

LEG · Programmation

Bonjour
@rareStrophe.
ok pour tes explications afin de rendre le programme plus rapide ...(je n'y connais strictement rien en programmation) mais je comprends tes explications...

Ceci dit : gagner du temps sur cette première partie du programme de la def eratostene(n): qui énumère les nombres premiers $P\leqslant\sqrt(n)$
permettra de gagner du temps, dans la deuxième et troisième partie ...

Mais pourquoi avoir extrait tous les nombres premiers < 3000 , pour comparer les vitesses (éfficacité) des deux langages de programmation je suppose suite à tes explications....
N'oublies pas que pour $n = 999 999 999$ , c'est la racine carrée de $n$ qui est à prendre en compte pour extraire les nombres premiers Ératosthène dans cette première partie...

Premiers Ératosthène que l'on va ensuite utiliser, dans la deuxième et troisième partie, afin de cribler : la liste "ou tableau " de 1,1,1......< n//30 .

Exemple :

Donnez N: 3000
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73] premiers Ératosthène < racine de 3000

crible Ératosthène : [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0]
Nombre premiers criblés famille 7 : 55 ----- 0.0

crible É ET G: [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]
Nombres P' non congru 2n[pi] ou couple P'+q = 2N, de (i) à 3000 famille 7 : 18 ----- 0.0

LEG · Programmation

il y a 8 familles d'entiers en progression arithmétique de raison 30, donc de la forme $30k + i$ avec $i\in(1,7,11,13,17,19,23,29)$ comme $1$ n'est pas un nombres premier, il est clair que dans GM et dans l'algorithme il est donc remplacé par 31.

for a in premiers:
for b in GM:
j = a * b
le programme de l'algorithme exécute le produit j de chaque a premier avec b de GM jusqu'à ce que j%30 = Fam , la famille en progression arithmétique de raison 30

Exemple : $Fam = 7$ , limite $n = 150$

$a = 7$ premier dÉratosthène $P\leqslant\sqrt{n}$

$B = (7,11,13,17,19,23,29,31)$ de la liste GM
$7 * 7$ ; qui n'est pas égal à 7 modulo 30
$7 * 11$ ; qui n'est pas à 7 modulo 30
$7 * 13$ ; qui n'est pas à 7 modulo 30
etc etc il reste :
$7 * 31$ ; qui est égal à 7 modulo 30 : if j%30 == fam:

le programme va donc calculer l'index de j , index = j // 30 ; qui est l'index de départ du crible , donc à partir de cet index :

for idx in range(index, lencrible, a):
crible[idx] = 0
le programme va commencer à cribler avec le $a$ premier = $7$ , jusqu'à $n$ , puis le programme réitère avec le $a$ premier suivant qui est $11$
etc ..

C'est ok ?

dans le crible G Gcrible on crible pareil mais en utilisant les congruences et par conséquent on partira du reste $R$ de 2n par $P\leqslant\sqrt{2n}$ c'est à dire de l'indexe de $R$ par pas de $P$ jusqu'à $n$

cette fonction : def GCrible_2N(premiers, crible, lencrible, n, fam): va réutiliser le tableau d'Ératosthène criblé et retourner par la fonction return crible,lencrible

Dans cette partie où on utilise les congruences , on crible les entiers A, congrus à 2n modulo P : reste + premier
if reste % 2 == 0:
reste += premier
pi2 = 2*premier

tant que le reste%30 est différent de Fam = 7 dans cet exemple
while reste % 30 != fam:

puis on calcul l'index : reste //= 30

afin de cribler ces entiers jusqu'à $n$, congrus à 2n modulo P.
for idx in range(index, lencrible, a): ## index qui est réutilisé ici...et on va cribler le avec $a$ premier en partant de l'idx , comme dans Ecrible
crible[idx] = 0

"" en partant de l'index, le programme remplace le 1 en 0 si l'entier 1 est congruent modulo P , tout comme dans Ératosthène où on remplace le $1$ en $0$ si $1$ est un multiple de P , en partant de l'index du produit $j$""

Pour info le fonctionnement de l'algorithme de Goldbach et son principe de base avec sa propriété récurrente :

Cet algorithme permet incontestablement , de montrer qu'il est impossible d'infirmer cette conjecture, le contraire rendrait impossible le décalage des congruences, avec toutes les conséquences que cela impliqueraient sur la répartition des nombres premiers...

Principe de base élémentaire : https://www.cjoint.com/c/LKngfx5FcCL

Document et explication du crible: https://www.cjoint.com/c/LKkhzOrlT7u

LEG · Programmation

Merci d'avance , c'est un programme fait par notre cher ami Yoshi . iL est paramétré pour éditer les deux tableaux criblé ÉRATOSTHÈNE et GOLDBACH dans la Fam = 7.

print("crible Ératosthène :", crible)

print("crible É ET G:", crible) ## criblage du tableau d'Ératosthène criblé, par le crible G

fromtimeimporttime
fromosimport 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 =[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("crible Ératosthène :", crible)  ## pour éditer le tableau Ératosthène criblé

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

    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 % 30 != fam on fait reste += pi2

        while reste % 30 != fam:

            reste += pi2

        ## Ensuite on divise reste par 30 pour obtenir l'index

        reste //= 30

        ## On crible directement à partir de l'index

        for index in range(reste, lencrible, premier):

            crible[index] = 0

    total = sum(crible)  

    print("crible É ET G:", crible) ## éditer le tableau criblé É et G 

    print(f"Nombres P' non congru 2n[pi] 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=7 ## ou 1, 7, 11, 13, 17, 19, 23, 29, au choix en fonction de n

    crible,lencrible=E_Crible(premiers, n, fam)

    GCrible_2N(premiers, crible, lencrible, n, fam)

main()

system("pause")

Je suis sous linux Umbutu :

je lance mes programme python avec python :
Python 3.9.5 (default, Nov 23 2021, 15:27:38)
[GCC 9.3.0] on linux .

ou avec code::block , pour les programme fait en C++

Je suis nul en informatique, tu pourras me dire ensuite comment et avec quoi je lance le programme ... Merci .

A+, cordialement leg

LEG · Programmation

Bonjour :
@rareStrophe , Est-que tu peux traduire un programme Python , En Haskell ? Afin de comparer leurs performances si possible ... ?

Un algorithme sur les nombres premiers .

LEG · Programmation

Peut être qu'il serait bien venu de fermer ce sujet , qui n'apporte rien aux mathématiques , si ce n'est les élucubrations d'un illuminé ...

LEG · Programmation

Tu prends les gens pour des imbéciles ou tu ne sais pas de quoi tu parles ?

Tu indiques que tu as résolu P= NP en faisant référence à cette conjecture , et ensuite que tu ne parles pas de cette conjecture, une foie qu'on te met devant l'évidence de ta prétention...

Puis : tu as le culot de dire que ton travail est une découverte sans définir au préalable de quoi tu parles ? Et de quelle découverte ? Que dans un champ de patates tu as trouvé des navets et des bananes ...?

Qu'est-ce-que $P$ ; Qu'est-ce-que $NP$ .? Un navet et une carotte ? Une paire de boules ? $\sqrt(X+y)=P+N$ et alors ???

Continue à jouer aux billes, car celle qui est transparente = P de quelle couleur et celle de NP ?

LEG · Programmation

Quel rapport avec la définition de cette conjecture ?

Est ce que tu as compris sa définition ?

Ton texte ne dit rien du tout ! C'est toi qui interprète mal cette conjecture relative à deux problèmes de complexité identique ou pas, et que tu là ramènes à deux entiers naturels !

Qu'est-ce qui te fait croire que le problème P = 1 ou ce que tu veux...? Idem pour le problème NP qui vaut 0 ou autre ??? Tu as compris quoi ?

Tu penses sérieusement que tous les Matheux professionnels qui ce sont cassés les dents sur ce problème, depuis plus de deux siècles, sont des abrutis au point de ne pas avoir vu qu'il s'agirait tout bêtement d'un polynôme qui s'annule .... Ou tu rêves ?

Car sinon à ta place, je filerai en vitesse récupérer mon prix de 1 million de $ , avant qu'un autre illuminé vienne le récupérer ...!

Commence par réfléchir :

{Très schématiquement, il s'agit de déterminer si le fait de pouvoir vérifier rapidement une solution à un problème implique de pouvoir la trouver rapidement ; ou encore, si ce que nous pouvons trouver rapidement lorsque nous avons de la chance peut être trouvé aussi vite par un calcul intelligent.}

Plus précisément, il s'agit de savoir si la classe de complexité $P$ des problèmes de décision admettant un algorithme de résolution s'exécutant en temps polynomial sur une machine de Turing est équivalente à la classe de complexité $NP$ des problèmes de décision, dont la vérification du résultat une fois celui-ci connu, demande un temps polynomial.

Prouve qu'il s'agit d'un polynôme ... ou .... d'un plat de frites et au temps qu'il te faudrait, pour éplucher les patates ; avant de rêver au million de $ ... Lolll

LEG · Programmation

Bonjour
Ce n'est pas par-ce-que deux problèmes de complexité équivalente ou différente, qui s'écrivent de la même façon , qu'ils sont égaux ...

Prouve que ces deux problèmes sont de complexité équivalente ! C'est à dire :

que le problème P est de complexité 0
et
que le problème NP est aussi de complexité 0 .

LEG · Programmation

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 les entiers A positifs de 1 à $n>3$ 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$ , en choisissant la Fam i par rapport à l'une des 14 formes de cette limite $n$ fixée.

On crible les entiers $A$ positifs, appartenant à une des 8 Fam(i) de 1 à n par rapport à la forme de $n$ fixé; 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$ , l'entier $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$. (évident à démontrer) où 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 modulo P il est marqué 1 , sinon il est marqué 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’ congrus ou pas modulo P , mais où les congruences ce sont décalées d’un rang sur leurs successeur $A+30$. (" donc par évidence, libère de leur congruence les entiers $A$ de la limite $n$ précédente ").

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 +30 = 277 = p'$ , qui devient donc non congru [P] ... alors que pour $n=300$ , il était congru ! Il vérifiera donc la conjecture $277 + q = 630$ par obligation !

Car : $A = 247$ qui était non congru pour $n = 300$ , l'égalité $2n – A = 353 = q$ premier, restera identique pour la limite suivante $n+15 = 315$ ;
c’est à dire pour l'entier $2n+30 = 630$ et tel que $(2n +30) – (A+30) = q = 353$ , le contraire serait absolument faux ; car contraire à la répartition des nombres premiers due au TNP et au TFA .

Cette égalité et propriété récurrente de l’algorithme, permet de prendre en compte tous les entiers A ≢2n[P] , premiers ou pas, qui précèdent un $A’= P’ $
Le contraire serait faux , car contraire à la répartition des nombres premiers, conséquence du TNP et du 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 par rapport à l'une des 14 forme de $n$, limite fixée. (expliquée dans les fichiers joins)»

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 deviendrait fausse …?

Or pour chaque limite $n$ fixée et où l'on a vérifié le nombre de solutions qui décompose $2n$ en somme de deux nombres premiers $p'+q$ , on a aussi vérifié le nombre de solutions qui vérifiera l'entier suivant $2n+30$ ou $2n+2$; ce qui interdit de supposer que pour pour l'entier suivant $2n+30$ ou $2n+2$ il n'y aurait pas de solution, c'est à dire que la conjecture 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, ce qui est clairement faux, car le nombre de solutions de ces entiers précédents ont déjà été vérifiées ...
Ainsi que le nombre de nombres premiers vérifiés $q$ appartenant à la limite $[n;2n]$ précédente et qui ne peut varier que négligemment ...

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 une estimation asymptotique $\frac{n}{log\; 2n}$ qui a été vérifiée .

Mais au contraire, le nombre de solutions $p’+ q = 2n$ augmentent lorsque n tends vers l'infini

Cela serait absurde, contraire au TFA ainsi qu’au TNP , en résumé :

Il est clairement évident : que tout nombre $p'$ congru à $2N$ modulo $P_{1} , P_{2}, P_{3} ,...P_{n}$ lors de la limite précédente $N=15k$, ne peut plus être congrus modulo $P_1 , P_2, P_3 ,...P_n$ , pour cette limite suivante $N=15(k+1)+i$ ,les nombres $p'$ se trouvent ainsi libéré de leur congruence, puisque les restes $R$ vont changer et que le nombre de nombre premiers $q$ entre ces deux intervalles successifs (n+1;2n+2) serra le même à une exception près...

Ce qui nous garanti toujours une densité minimum > 0 , de solutions qui vérifient $2n+2 = p'+q$.

Mais: Si on suppose fausse la conjecture, il faut que pour la limite suivante $N=15(k+1)+i$ les nombres $p'$ qui étaient congrus $P_n .. P_3, P_2 ,P_1$ le soient à nouveau par ces nombres $P{n}$ qui criblent.
Mais alors, ceux qui n'étaient pas congrus modulo $P{n}$ ne peuvent pas l'être non plus pour cette limite suivante $N=15(k+1)+i$ ...
car le nombre de premiers $q$ entre ces deux intervalles successifs $(n+1 ; 2n+2)$ est déjà définis ... On aura la même quantité , ce qui ne serait plus le cas si les nombres $p'$ qui étaient non congrus modulo $P_{n}$ , deviennent congrus modulo $P_{n}$ par miracle ...

Ce qui est clairement impossible, le nombre de premiers $P_n$ qui criblent serra le même à une exception près.. !

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

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

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

LEG · Café mathématique

Bonjour
C'est bien pour cela, qu'il valait mieux poser directement ta question, sur ce forum café mathématique; en faisant référence à youtube , tu t'enlèves la pertinence de ta question .

En générale les gens qui viennent sur les sites de mathématiques regardent un peu tous les sous forums en fonction de leur besoin, ou de leur intérêt dans ces différents domaines que propose les forum de Maths..

Je pense qu'en regardant les sujets développés dans les sous forums, tu vas te faire assez vite une idée de ce que regardent les intervenants ...

Si on devait classer les sous forums en fonction du nombre de vues par sujet , il est clair que le forum programmation remporte haut la palme , ensuite il y a le forum café mathématique , assez loin derrière ...

Bonne journée.

LEG · Café mathématique

Bonjour
Pourquoi cette question, tu penses que Youtube, c'est la panacée des maths en lignes ?
Vous venez chercher votre clientèle sur Bibmath ?

Je suppose que la plupart du temps, les jeunes regardent sur les sites de Math .. comme Bibmath et pose leur question sur le ou les sites spécialisés pour ça ...
Et, ils obtiennent des réponses ou de l'aide, des différents intervenants .

Rien ne t'empêche d'intervenir en ligne... sur les sujets qui te passionnes, Algèbre ou autre .

LEG · Café mathématique

Bonjour

Il y a des fois où ça marche et des fois où tu te plantes... Donc je peux affirmer à 99,9999 ... % que ton nombre de Mersenne suivant , n'est pas le bon !

De plus tu racontes n'importe quoi ! Où tu as vu que les nombres de Mersenne > 10 000 chiffres pouvait être consécutif selon ta ""définition"" de nombres premiers consécutifs ???

Prends simplement le premier nombre de Mersenne $P_M = 2^3 - 1$ et refais ton calcul , tu trouves le nombre de Mersenne suivant $P_M= 31$ ...?

Tu es sûr d'avoir toutes tes capacités, pour avancer ce genre de sottises ???

LEG · Café mathématique

Bonjour
Tu sélectionnes tout ce que tu as écrit puis tu fais un copié collé sur ton support word ou autre...non ?

Il n'y a pas de sélection imprimé sur les posts ...

LEG · Programmation

Bonjour
c'est quand même loin d'être clair ...
tout dépend de la longueur de ta liste de courses(" produits") et combien de groupes sont définis ! quelles valeurs peuvent être indiquées par groupe ..etc
Exemple liste de 100 produits avec leur prix...avec différents groupes {4€,5€,...10€...etc}

ensuite je suppose que si cela se termine sur une boucle finie c'est que tu dois avoir paramétré ton algorithme programme de sorte qu'il finisse une fois qu'il a fait le tour ou le trie des produits dont le montant = 5 € en essayant toutes les combinaisons ...sinon il continuerait sans s'arrêter .

Ton exemple ne dit pas ce que doit faire ton algorithme à part indiquer les différents groupes de 5€ qu'il a trouvé parmi ta liste de produits, dans ton exemple il n'y en a qu'un. Alors rajoute : poids chiche : 0,80 et haricot : 2€
Que va t'il sortir ...???

LEG · Café mathématique

Salut : et ben au lieu de faire une multiplication, une addition et une division : tu fais une addition , une division et re addition ...
Donc ("Hibernatus" loll) ton nombre d'itérations ne serra pas plus simple....

par exemple avec i = 31

31+1 = 32 , 32/2 = 16 , 31+16 = 47 , 47+1= 48 ; 48 /2 = 24 et 24 +47 = 71

31*3 = 93, 93+1=94 ,94/2 =47 , (47*3 +1) / 2 = 71 .......etc etc

LEG · Programmation

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.

fromtimeimporttime
fromosimport system
importmath

def candidats(n):

    start_crible = time()

    n = int((2*n)**0.5)

    m = (n-1) // 2

    b = [True]*m

    i = 0

    p = 3

    premiers = [2]

    while p*p < n:

        if b[i]:

            premiers.append(p)

            j = 2*i*i + 6*i + 3

            while j < m:

                b[j] = False

                j = j + 2*i + 3

        i += 1

        p += 2

    while i < m:

        if b[i]:

            premiers.append(p)

        i += 1

        p += 2

    print(f"Nombre premiers[3:] : {int((time()-start_crible)*100)/100}")  

    return premiers[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 = candidats(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 2024 :

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

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

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

LEG · Programmation

@ re Yoshi
Impeccable c'est bien ce sujet. Merci pour tout et bonne semaine...

LEG · Programmation

Bonjour
@Yoshi :
Dans le but de ne pas ré-ouvrir un autre sujet sur ce programme, qui à l'air d'avoir beaucoup de visite.

Serait il possible de ré-ouvrir le sujet crible en python ci dessous , car je voudrai y remplacer deux fichiers que j'ai modifiés mais surtout y rajouter le programme en C++ relatif à la conjecture de Goldbach que j'ai modifié pour l'adapter à la conjecture de (Lemoine - Lévy) une variante de la conjecture de Goldbach
qui dit : tout entier impair $2N+1 = 2P + q$ avec $P$ et $q$ premiers.

Je me suis servi du crible en python que tu m'avais programmé et que j'ai modifié [Crible_G.T.Y_mod30.py] , puis cela m'a permis de modifié ce programme qui avait été retranscrit en C++.

Merci d'avance .
Cordialement LeG.

LEG · Programmation

Bonjour Yoshi

Merci de ta réponse:

Sauvegarder les derniers nombres premiers trouvés, environ 15 000 000 pour un seul fichiers

Par exemple il me faut les nombres premiers > 30 000 000 000, je lance l'algorithme "Programme" je rentre la limite demandée par exemple 60 000 000 000 et deux familles ou une....
et je sauvegarde les 15 000 000 derniers , autrement dit il faut que le programme à la demande, sauvegarde dans un fichier les derniers nombres premiers trouvés en commençant par la fin...

Sinon cela fait trop de fichiers, et si ils sont trop volumineux c'est galère pour les ouvrir je pense même que 10 000 000 pour un fichier c'est suffisant.

le programme C++ qui est joint et très rapide environ 2 minutes pour une Famille et la limite N = 1200 000 000 000
c'est pour comparer la densité de premiers ayant 2 d'écart et 246 d'écart par tranche de 100 nombres...

Je compare donc deux fichiers, les familles jumelles 11 et 13 modulo 30 pour les Pj, puis les deux familles 11 et 17 modulo 30 pour les P + 246 = q .

je pensai qu'une fois le programme terminé , il fait la somme des 1 = premiers qu'il a donc en mémoire , puis il faut rétablir leur valeur par exemple
Famille 30k +11 uniquement pour les [1] , [0] puis à la fin il sauvegarde les derniers....

Donnez N: 60000
crible: [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0,
..........(11,41,71,101,131,..191...221,251,281,.....,371.....etc
Mais si tu penses qu'il faut les sauvegarder au fur et à mesure dans la mémoire virtuelle , et puis sauvegarder les derniers dans un fichier ...

Il me faudrait les 200 derniers nombres premiers ça me conviendrait bien....

@+

Forum de mathématiques - Bibm@th.net

#126 Enigmes, casse-têtes, curiosités et autres bizarreries » peut on enterrer la conjecture de Goldbach ? » 21-11-2022 17:07:16

#127 Re : Programmation » Programme python en Haskell » 10-11-2022 06:21:09

#128 Re : Programmation » Programme python en Haskell » 09-11-2022 14:20:08

#129 Re : Programmation » Programme python en Haskell » 09-11-2022 07:00:58

#130 Re : Programmation » Programme python en Haskell » 07-11-2022 13:47:49

#131 Re : Programmation » Programme python en Haskell » 07-11-2022 12:27:53

#132 Re : Programmation » Programme python en Haskell » 07-11-2022 07:44:21

#133 Re : Programmation » Programme python en Haskell » 06-11-2022 15:57:26

#134 Re : Programmation » Programme python en Haskell » 06-11-2022 15:41:11

#135 Programmation » Programme python en Haskell » 06-11-2022 15:22:08

#136 Re : Programmation » P=NP résolu » 04-11-2022 09:17:07

#137 Re : Programmation » P=NP résolu » 02-11-2022 15:46:56

#138 Re : Programmation » P=NP résolu » 02-11-2022 12:55:01

#139 Re : Programmation » P=NP résolu » 02-11-2022 08:57:15

#140 Re : Programmation » crible en python » 31-10-2022 12:04:28

#141 Re : Café mathématique » Que regardez-vous comme maths sur youtube ? » 24-08-2022 06:46:14

#142 Re : Café mathématique » Que regardez-vous comme maths sur youtube ? » 21-08-2022 07:03:00

#143 Re : Café mathématique » pouvez vous trouver un contre exemple a cette conjecture sur les nombr » 09-07-2022 08:28:05

#144 Re : Café mathématique » imprimer une feuille d'exercices qu'on a crée sur Bibmath » 14-01-2022 13:11:40

#145 Re : Programmation » Problème de courses en python (facile pour vous, difficile pour moi) » 22-12-2021 08:40:00

#146 Re : Café mathématique » Syracuse! encore » 29-11-2021 15:30:58

#147 Re : Programmation » crible en python » 29-11-2021 11:11:21

#148 Re : Programmation » crible Python et C++ » 29-11-2021 10:15:39

#149 Programmation » crible Python et C++ » 29-11-2021 08:01:14

#150 Re : Programmation » Modifier un programme C++ » 22-09-2021 09:30:16

Pied de page des forums