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 09:50:04

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

Re : crible en python

@Yoshi : ça me va parfaitement

1) : la fonction est le criblage

j'ai pris l'exemple de a = 7, 15k = 900 et la fam est la famille 7[30] que tu as en fin de document page 4 les deux premières lignes; criblage 1 et 2 puis re 1

2) : je crible les éléments de l'Ensemble EC avec le crible G, qui à sa fonction; pour une même limite N fixée et pour une même famille d'éléments fixés

3) : j'obtiens l'image des éléments criblés:
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]

4) :je crible les éléments de l'Ensemble Ep avec le crible E, qui à sa fonction; pour une même limite N fixée et pour une même famille d'éléments fixés que
ci-dessus. ("qui au départ , ne sont que des éléments [1,1,1,1,1,1,1,1,1,1,1.............................................1,1,1,1,1,1,] pour la lim n fixée.)"

5) : j'obtiens l'image des éléments criblés:
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) je vais donc cribler à nouveau les éléments de l'Ensemble Ep  mais avec le crible G. Ce qui revient à superposer les [0] de l'image de Ec sur Ep; afin de marquer en rouge ses éléments situé en face des [0] et bien évidemment les [1] ne marquent rient, car ils indiquent les couples de nombres premiers $P$ dans Ep, où $P\not\equiv{2n}[P_i]$

7 ) la fonction du crible G et donc surjective sur Ep....non? ou si tu veux, l'image des éléments de Ec est surjective sur les éléments deEp

8) Ce qui donne le résultat suivant : on reporte les 0 en rouge de n°1a sur les éléments criblés de Ep1b correspondants à ces 0.

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 de Ec qui sont congrus à 2n[p] sont aussi congrus à 2n[p] dans Ep d'où l'image de Ec est équivalente ou égale à celle de Ep après avoir été criblée par la fonction G...! il vient que si Ec est vraie entraine 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.

c'est pour cela que je parle de surjectivité des éléments de Ec sur Ep après le troisième criblage en utilisant la fonction du premier crible G les éléments qui auront été marqué en rouge("criblés") ont bien pour antécédent les éléments 0 de Ec , précédent.

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

lorsque tu augmentes n de 15 , les éléments de Ec augmente de 30 et provoque le décalage d'un pas entre deux criblages successif ... Ce qui permet de construire une contradiction à la conjecture de Goldbach qui est indécelable sans le recourt au crible G, que nous avons programmé (" et ça c'était pour une autre raison...)
Or les pointures comme tu dits, qui se cassent les dents depuis 250 ans; ils n'avaient qu'a découvrir 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 ...!

comment veux tu marquer tous les [1]  de Ep, d'un [0] lors du criblage de 15 (k+1) avec le cribleG alors que les reste Ri ont changés.
tu ne peux donc pas cribler avec les restes Ri de 15k et 15(k+1) c'est absurde...!
Pour une même limite n fixée , et une même Famille en progression arithmétique de raison 30 fixée ! et ça ce n'est pas évident à voir sans ce fameux cribleG...!

Si tu préfère si A est congru à B[P] on ne peut pas dire, que A est encore congru à (B+30)[p].... où P premier, ne divise pas 30...! donc P > 5. 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 en reste 1 (couple p+q).. quelque soit n qui tend vers l'infini qui décompose 2n en somme de deux premiers...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 été fichu de trouver et étudier ce crible avec sa fonction...""

Dernière modification par LEG (25-05-2019 08:54:41)

Hors ligne

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

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 312

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 02:31:21

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

Re : crible en python

re @Yoshi
A) : on fait référence au post ci dessus #376 ; relatif au deux cribles G et E , que l'on a programmer 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 reprend les deux version utilisé dans le document....ok ils sont déjà paramétré 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

justement je ne travaille qu'avec les familles d'impairs en progression arithmétique, donc deux impairs (p+q)= pair =2n i.e : la somme de deux nombres premiers.

Ec 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) : est donc l'image des éléments de Ec criblé ,de 7 à n =907, par les $P_i\leqslant\sqrt {2n}$ où les ,1, sont donc, bien les nombres premiers q. de 907 à (2*907) : de n à 2n. c'est à dire les complémentaires des éléments de Ep


4) les éléments de Ep sont les même élément que Ec : entiers en progression arithmétique de raison 30, et, de la même famille. de 7 à 907 dans cet exemple. Mais criblé avec le crible Ératosthène  :crible E
soit : 1814 - 7 = 1807 le complémentaire de la fam 7[30]...ok qui représentent bien les deux Ensembles Ec 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 à lautre, i.e : de 3) à 5)...?

Et bien c'est simple: tu repasses avec la fonction du crible G sur les élément de Ep donc par obligation, tu auras l'image criblée, qui n'est rient d'autre que l'image de Ec 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 des éléments de Ep.

Car en définitive, si tu regardes l'image de n°1 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]$ et par conséquent celle des entiers [,1,] nombres premier q de 907 à 1814.

6) : Sera donc bien l'image de Ep criblé représenté en exemple :n°1 crible G; n°11 crible E ; n°12 re-crible G sur Ep par superposition d'image n°1 sur n°11qui sera représenté par le criblage en : n°12, où
il suffit simplement de marquer en rouge les 1 de Ep qui sont sous les 0 de Ec ce qui représentera 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]$...ok

les ,1, rouge sont les nombres premiers q...ok donc ils sont bien des nombres premiers et ne peuvent en aucun cas marquer 0 les 1 d'Ératosthène et ils seront leurs complémentaires q pour 2n - P. ("Comme tu peux le constater ce crible à plusieurs fonctions")

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 donne :
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, 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 sont les couple (p+q)=2n=1814 de la fam 7[30]. ok
("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 décalage...!!!

pourquoi cette contradiction :
comment pourrais tu marquer en rouge, les éléments de Ep en repassant avec cribleG sur le criblage suivant n°2,n°21 n°22  alors que les reste Ri , qui index les Pi dans le crible G ne sont pas les mêmes, n a augmenté de 15 donc les 0 = entier congrus à Pi qui sont nommé les congruents de Ec ('élément') augmentent de 30 donc se décalent....
Et par évidence le cribleG dans Ep, les Pi qui criblent ne partent pas du même index; sinon l'image Ec et Ep serait identique: ce qui se traduirait par autant de nombres q de n à 2n que de nombres P de 7 à n dans cet exemple...absurde...Théorème élémentaire...!!!

On a pas besoins du postulat de (.......)

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 (11-06-2019 07:25:08)

Hors ligne

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

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

Re : crible en python

petit rappel:
voici le cribleG qui crible dans les congruences ...: les entiers congrus à 2n [Pi]  inférieur racine de 2n et > ou = 7, par famille arithmétique de raison 30 : fam = famille, Ri, reste de la division Euclidienne de 2n par Pi qui indexera la position de départ de Pi, afin de cribler par pas de Pi de lindex à 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.

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 avec l'index
        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")

 

Crible_Era_gty_mod30  modifié , qui crible suivant le principe Ératosthène comme celui de dessus, mais : les entiers multiples de Pi< racine de n;
qui part de Pi > ou = 7 ou du produit, suivant la fonction E du programme :


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 cas les $0$ ne sont et ne peuvent être des nombres premiers , puisque ce sont les entiers $\equiv{2n}[P_i]$.!!!

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 pas vers la droite des congruences de EG lorsque $n$ augmente de $15$, et donc les entiers congru ou non, augmentent de 30 mais aussi, tu changes de reste Ri . 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
PS: tu as conscience que je la refais en directe....mais elle protégée par enveloppe solo...

Dernière modification par LEG (11-06-2019 11:25:24)

Hors ligne

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

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 312

Re : crible en python

Salut,

J'avance...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

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

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

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\: 2\pi(n)}$

Mais personne n'avait le crible, permettant de cribler uniquement les congruences 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 ???

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 (11-06-2019 08:23:41)

Hors ligne

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

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

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

Résumé :

On travaille dans les entiers impairs en progression arithmétique de raison $30$ de premier terme $1\,ou\,P$ premier appartenant à $[7 ; 29]$

Principe de fonctionnement du crible G, on crible les entiers $\equiv{2n}[P_i]$ . Attention on crible avec la fonction G de 1 à $n = 15k $, mais on utilise les restes $R$ de $30k$ par $P_i\leqslant\sqrt{2n}$ , ie : on marque les entiers de $1\, à\, n$ qui sont $\equiv {30k}[Pi]$ par un 0 .

1) Ce principe de fonctionnement du crible G prouve par l'absurde que la CG est vraie

2) On utilise ces restes $R$ afin d'indexer le départ des $P_i$ qui criblent ces entiers congrus 2n [Pi]. ie: on marque ces entiers représentés par des 1, d'un 0; de $1\, à\, n$ si ils sont $\equiv {30k}[Pi]$ par pas de $P_i$.
("même principe que celui d'Ératosthène, hormis le point de départ, qui est fixé par les restes $R_i$").

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

3) On crible les entiers 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 modulo 30 : $7,37,67,97,.....n=187$ ....etc ;  avec les $P_i\leqslant\sqrt{n}$.

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 avec $P_i\leqslant\sqrt{n}$
    crible:[1, 1, 1, 1, 1, 1, 0]

5) On va re-cribler E ci-dessus avec le crible G, même limite n = 15k = 210 et même fam 7
ce qui donne les entiers représentés ci dessous [$7,37,67,97,127$...modulo 30 ..n =187 ] les entiers marqués 0 sont $\equiv{420}[P_i]$

       B_) crible G: Donnez N: 210 avec $P_i\leqslant\sqrt{2n}$ . (" ci-dessous : image du criblage de la fonction G")
....crible: [(0), 1, 1, 0, 1, 1, 1] seul $7 \:et\: 97$ sont $\equiv{420}[P_i]$

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

6_) On réitère avec $n + 15$ soit $15(k+1) = 225$. selon la théorie des congruences, les congruences vont se décaler d'un rang afin que $(2n+30) - (i+30) =$ $q$ ou $multiple\: de \:(P_i)$ ; criblé précédemment. On utilise les nouveaux restes $R$ de $(2n+30)\: par (P_i )$.

      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 $P_i$ 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 $P_i$; le contraire serait absurde. d'où $37\: et\: 127$ seront $\equiv{450}[P_i]$

    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 avec les nouveaux $R$ et les mêmes $P_i$. Dans le cas contraire on perdrait la propriété des entiers de $n\;à\;2n$. De part le fait de ce décalage d'un pas des congruences on a simplement décalé les couples p+q = 450 d'un pas.
et $7$ qui était $\equiv{420}[P_i]$ se trouve libéré de sa congruence d'où $7 + (413+30) = 450$ avec 443 qui est un nombre premier déterminé par $7\not\equiv{450}[P_i]$. C'est cette propriété de ce principe de fonctionnement du crible et le décalage des congruences qui va être utilisée pour prouver la conjecture. On voit déjà l'idée pour $n+15 = 240$, où $37$ va vérifier la conjecture : $480 - 37 = 443$ ; le décalage va occasionner $37\not\equiv{450}[P_i]$. 


7_) Afin d'infirmer la CG pour $15(k+2) = 240$ en supposant qu'elle soit fausse :

    a_) La fonction G doit marquer d'un 0 les entiers 1 d'Ératosthène qui étaient  $\not\equiv{30(k+1)} [P_i]$ lors du criblage précédent au point 6_) , C_) ; avec les nouveaux $R$ de $30(k+2)\: par\: (P_i)$.

    b_) Suite au décalage des congruences, la fonction G doit aussi et encore, marquer d'un 0 les entiers (0) qui étaient $\equiv{30(k+1)} [P_i]$ et 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)$. 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 $(P_i)$ qui criblent.

             Il vient de ce fait que les indexes de ces $(P_i)$ ne sont plus les mêmes; la division de $2n = 30(k+2)\: par\:$ $(P_i)$ ne donne qu'un $R$ par $(P_i)$ ; 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ù: contradiction de la supposition d'une conjecture fausse; la conjecture de Goldbach est vraie !

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

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, où on décale simplement d'un rang les congruences 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_i$ 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 entiers congrus à $2280[P_i]$  [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 modulo 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,] [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,] [1ou0]

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_i$ qui ont criblés, sans utiliser les deux cribles.

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_i\leqslant\sqrt{n}$ ou $p_i\leqslant\sqrt{2n}$

Ce qui donnerait au minimum, le nombres de couples  $p + q = 2n$ par la fonction : $\frac{\pi(n)}{Ln\: 2.\pi(n)}$ puisque l'on crible à nouveau les nombres premiers de $\pi(n)\not\equiv{2n}[P_i]$

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\: (2\,*\,26)} = 6,58...$ sur un réel de $16$ couples.

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 faut de plus en plus redescendre sur les restes $R$ des criblages précédent...Ce qui prouve la conjecture.

Dernière modification par LEG (15-06-2019 08:33:58)

Hors ligne

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

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 312

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 09:56:01

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

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 11:41:40

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 312

Re : crible en python

Ok,

Nouvel essai d'envoi.

@+

[EDIT]
Nouveau refus

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


Arx Tarpeia Capitoli proxima...

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)?
soixante neuf plus vingt trois
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