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

Répondre

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)?
trente six moins huit
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.

Retour

Résumé de la discussion (messages les plus récents en premier)

LEG
Aujourd'hui 09:50:04

@Yoshi : ça me va parfaitement

1) : la fonction est le criblage

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, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 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, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0]

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

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

8) Ce qui donne par évidence le résultat suivant : met en rouge les éléments criblés de Ep: 1b correspondants sous les [0] de 1a.

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]   ('15k + a  : 8 couples (p+q) 30k +2a') pour cette famille.
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]

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

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é(" ç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 congruence....!
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] ne me dit pas 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 étudié ce crible...""

yoshi
Aujourd'hui 08:32:11

Re,

Boufre !
Tu m'en poses des questions !...
Il y a des dizaines d'années que je n'ai pas manipulé cette notion de surjection, faut donc que je me replonge dedans...
En attendant, voilà ce qu'en dit le dico de Bibmath :
http://www.bibmath.net/dico/index.php?a … ction.html

l'image de Ec est surjective sur Ep

Questions
1. Qu'est-ce exactement (ensemble) EC ? Que contient-il ?
2. Qu'est-ce exactement (ensemble) Ep ? Que contient-il ?
3. Tu utilises le terme d'image. Tu le prends bien dans son sens mathématique, ? C'est à dire si on considère deux ensembles E et F une fonction f de E dans F, qui à un élément x de E fait correspondre un élément y, noté f(x), de F, x est l'antécédent f(x) l'image...

Je ne crois pas dans ce cas que ta formulation ait un sens : une fonction peut être surjective, pas un élément et donc une image au sens mathématique.

Il va te falloir définir très précisément la fonction f qui à un élément de Ec associe un élément de Ef...
Après quoi, on verra si la fonction en question est surjective ou pas...

Qu'est ce que signifie  : Si l'image de Ec est vraie ?
Dans quel cas dis-tu qu'une image est vraie (et on en revient à la définition d'une image pour toi).

J'ai lu tous tes documents. A mes yeux, ils ne répondent pas à la structure attendue par un memorandum sur la démonstration de la conjecture de Goldbach... Le document final proposé ne me parait pas assez didactique : les pointures dans ce domaine, déterminent en 1 ou 2 min si elles vont continuer à lire ou pas...
Il faut pouvoir éveiller leur intérêt très vite, d'autant qu'un "amateur" qui se pointe et annonce qu'il a résolu une conjecture qui résiste depuis 1742, d'entrée de jeu, ça laisse dubitatif...

Je vais donc m'atteler à la rédaction d'un plan détaillé que je te communiquerai et dont tu développeras les "parties techniques" qui te concernent et laissées vides...
Ça te va ?

Jusqu'à présent, ce qu'elle énonçait exactement ne me dérangeait pas trop : je me contentais de programmer... Mais maintenant les choses sérieuses commencent, alors je suis allé rafraîchir ma mémoire et je n'ai trouvé que ça :
Tout nombre entier strictement positif peur être écrit comme la somme d'au plus 3 nombres premiers
(lettre de Goldbach à Euler)
ou http://villemin.gerard.free.fr/ThNbDemo/GoldbaPr.htm

Ce que j'ai retenu de tout ce à quoi j'ai participé :
tu calcules le nombre de nombres premiers entre n = 30k et 2n et tu les répartis en 8 familles que tu peux dénombrer et lister.
Quel rapport avec la conjecture de Goldbach citée ci-dessus ?
Il y en a une autre que Wikipedia (par ex) n'est pas foutu de citer ?

@+

LEG
Aujourd'hui 06:58:27

Salut @Yoshi
En Définitive le criblage de (l'Ensemble C) , Ec est surjectif sur Ep, (l'ensemble P).
l'image de Ec est surjectif sur Ep.
Si l'image de Ec est vraie , Ep est vraie....  non?

LEG
23-03-2019 07:04:56

Re Salut @Yoshi

Ecris à yoshik _at_ no-log.org
(Remplacer _at_ par @)

c'est fais..
@ +
leg

LEG
17-03-2019 16:56:57

Bonjour et Salut @Yoshi.

si tu superposes le criblage des cellules [1] avec le crible G de Goldbach sur le même criblage  crible É des cellules [1]  par exemple fam {1} pour les deux cribles , et tu prends n = 3000, ensuite tu re cribles avec crible G pour n+15; inutile de re cribler Ératosthène qui te donneras les mêmes [1] premiers . Ce qui et normal la racine de n ne change pas  . Tu vas trouver l'anomalie du raisonnement absurde de la conjecture de G....!

mais en rouge les 1 qui se superposent G esur É , et en bleu les 1 de la ligne en dessous de G qui se superpose à nouveau avec É ...

puis tu regardes ce qui c'est passé, dans le même plan vertical entre les deux criblage de G, donc pour n et n+15...

si tu veux le document , tu me le fais savoir par mail. Car je ne peux le poster publiquement pour l'instant.

à+

LEG
14-01-2019 14:14:22

Bonjour @Yoshi

je met ci dessous le crible Ecrible Ératosthène en C++, que Mr B Parisse à eut la gentillesse de transformé , sur la base de ton programme Python.
il faut faire attention au ['i] où il faut enlever l'apostrophe ' que j'ai dû mettre pour pouvoir l'éditer.


// -*- compile-command: "/usr/bin/g++ -g goldbache.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 GCrible(const vector<ulonglong> & premiers,ulonglong n,int fam){
  int cl=clock();
  size_t lencrible=n/30,nbpremiers=premiers.size();
  vector<bool> crible(lencrible,true);
  // 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};
    for (size_t j=0;j<sizeof(GM)/sizeof(int);j++){
      produit = p*GM[j];
      if (produit %30==fam){
  produit /= 30;
  break;
      }
    }
    indices[i]=produit;
  }
  ulonglong nslices=lencrible/3000000,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;
}

int main(int argc,char ** argv){
  vector<unsigned> crible;
  ulonglong N;
  int fam=1;
  if (argc>1){
    N=atoll(argv[1]);
    if (argc>2)
      fam=atoi(argv[2]);
  }
  else {
    cout << "Syntaxe " << argv[0] << " N fam. Donnez N puis fam: " ;
    cin >> N;
    cin >> fam;
  }
  double sqrtN=unsigned(std::sqrt(double(N)));
  fill_crible(crible,sqrtN);
  vector<ulonglong> premiers;
  for (ulonglong p=7;p<=sqrtN;){
    premiers.push_back(p);
    p=nextprime(crible,p);
    if (p==unsigned(-1))
      break;
  }
  GCrible(premiers,N,fam);
  cin>>N;
}
 

Ce qui permet d'avoir les deux cribles E et G, en C++, par famille arithmétique de raison 30
@+
Leg

LEG
02-01-2019 09:04:19

Bonjour à tous
j'espère que 2019 verra tous vos projets se concrétiser, et qu'elle vous apporte le meilleur de cette nouvelle année...
@Yoshi je te remercie pour toute l'aide que tu m'as apporté en 2018, en espérant que 2019 te le rende passe une très très belle année.
A +
Gilbert.

Le crible converti en C++ a une limite de 7500 000 000 000 , et pour Goldbach de N à 2N = 15 000 000 000 000 .
je pense que même en améliorant Ce crible Ératosthène , comme indiqué ci dessus  pour l'optimiser, change de beaucoup sa limite et vitesse.. Mais c'est comme cela qu'il devrait fonctionner, en incrémentant de 30 les Ai> 31.

pour info:
Crible É
Pour n = 6000 mds, nombre de premiers  13 mod 30, 26 422 717 616 en 1 677,97 secondes
Pour n =7500 mds, nombre de premiers 13 mod 30, 32 770 358 492 en 2142,95 secondes

Grible G, pour fam = 13
Pour n = 6000 mds , nombre de premiers  17 mod 30, entre 6000 et 12 000 mds = 25 161 218 215  en 1 625,3 secondes
Pour n = 7500 mds , nombre de premiers  17 mod 30, entre 7500 et 15 000 mds = 31 217 840 128  en 2181,1 secondes

LEG
26-12-2018 07:24:36

Donc tu penses que même en incrémentant Ai de 30 , pour calculer l'index suivant...de la liste des Ai, ça ne ferait pas tellement gagner de temps ("il faut quand même vérifier que Ai+30 est bien dans la liste Ex 13*19; puis 13 * (19+30) faux out, donc 13*(49+30) > 73 donc out..on passe à Bi suivant =17...
Pourtant lorsque l'on incrémente Ai de 30, on incrémente par la même son idx de Bi appartenant au GM:
EXemple fam = 7: B1 = 11 ; Ai = 17 , idx = 6 ; on aura donc Ai +30 = 47 , donnera idx + 11 =17

Tu as peut être raison, car les deux algorithmes curieusement sont aussi rapides l'un que l'autre...et traduit en C++ , même temps d'exécution pour une même limite N = 128 700 000 000; en 13 secondes...!
l'un calcule des restes que l'on incrémente de 2*pi jusqu'au %30==fam, pour ensuite calculer l'idx....et l'autre calcule les produits (b*a) ....>%30 == fam ; puis idx..., et :

1)_ Criblage de l'idx par de pas $p_i\leqslant\sqrt{2n}$ , pour Goldbach .
2)_Criblage de l'idx par de pas $A_i\leqslant\sqrt{n}$ , pour Ératosthène .

Alors que G, crible avec plus de premiers que É ....? De plus, G crible de l'idx plus petit que celui de E..d'où plus de cellules à marquer...? Comme quoi cela n'influence pas beaucoup le temps d'exécution...Que ce soit en python ou en C++ .

Par contre en C++ par rapport à python il n'y a pas photo....en terme de rapidité * 500 et de limite * 4 ...! Et encore j'utilise Code:bloc qui est en 32 bits sous Windows et non en 64.... ils l'on testé en 64 bits il a mis un peu moins de 60 secondes pour n = 450 000 000 000 ce qui donne pour G de 450 GO à 900 Go...!

Un petit résultat :

Avec Goldbach ; fam 7: nombre de nombres premiers entre 510 000 000 000 et 1020 000 000 000 =
2 331 532 960 en : 55,111 secondes

Avec Ératosthène ; fam 7: nombre de nombres premiers de 7 à : 510 000 000 000 =
2 459 907 472  en : 55,158 secondes

Je les ai testé jusqu'à 1200 GO en 75 secondes chacun à 2 secondes près..

Record ou Pas : sur le site Bibm@th du plus grand nombre de nombres Premiers criblés élémentairement, entre N et 2N ..?

RÉSULTAT Pour N = 3 billions , fam = 11: par Gcrible_mod 30
  nombre de premiers criblée de 3 billions à 6 billions = 12 880 098 499 en  734,93 secondes

Par E_crible_mod30 :
Pour N = 3 billions, nombre de premiers  11 mod 30, de 7 à N : 13 542 540 483 en 735,5 secondes

Voila un bon crible de noël , Mr ..YOSHI..
@+ LEG

yoshi
25-12-2018 09:17:48

Re,

Noyeux Joël à toi aussi...
Je ne m'attendais pas à une réponse un 25 déc.
A) Ton objection est à examiner de près...

B) Je pensais bien que ce serait coton... Je n'espérais pas une solution obtenue d'un simple claquement de doigt.  Je suis têtu, un peu Saint Thomas et probablement un lointain descendant de Guillaume d'Orange :
Il n'est pas  nécessaire d'espérer pour entreprendre ni de réussir pour persévérer...

Sinon, j'ai une 2e idée en réserve, un peu plus ch... ou moins, c'est selon, mais probablement plus lente.
* Considérer une liste de 1000 nb 1
* Ecrire à la place un nb binaire de 1000 bits égaux à 1 (ce qui correspond au décimal $2^{125}-1$)
* transformer le bit n° idx (compté à partir de la gauche) en un 0
* Lorsque c'est fini, compter le nb de 1

2e variante (douteuse) :
....
* transformer le bit idx (en partant de la droite et en progressant de D à G cette fois) en un 0
* transformer le nombre binaire restant une fois fin en décimal

Mais tester ce genre de choses demande de disposer d'un petit confoert de programmation, ce que je n'ai pas ici...

@+

LEG
25-12-2018 09:09:06

re :
POUR N = 6000, c'est faisable en 46 opérations , tu peux regarder , je disais que cela allez plus vite, car pour les 8 nombres premiers A, de la liste A, des-que A%30== 7 ,l'index est calculé, A = 31 crible;
Pour le calcule de l'index suivant, on incrémente Aide  30 qui serra obligatoirement =7%30 , et donc  re calcule de l'index..de Ai = 61..qui crible, puis Ai+30 = 61 > 73 la boucle B = 7 est fini. i += 1 , B =11

B = 11; "", 11*17 ok idx = 6, 17 crible, suivant : 11* (17+30) idx = 6+11, crible, .suivant 11*(47+30) si par exemple 77 qui n'est pas dans la liste A car il n'est pas premier; pas de problème, on incrémente de 30 Ai et suivant : 77+30 = 107 >73...fin de boucle B pour i = 1, B = 11...!

("C'est à peu près le principe de l'algorithme nbpremier c++ de 2003 , car cette optimisation est justement meilleur que nbpremier")

En inversant les deux listes du programme; les 8 boucles B du GM vont parcourir la liste A des nombres premiers d'Eratosthène                         

B = [7, 11, 13, 17, 19, 23, 29, 31]   n= 6000   Fam =7    nbcell = 6000/30 = 200 à cribler
--------------------------------------------------------------------------------------------
A = 7,,,,11,,,,13,,,,17,,,,19,,,,23,,,,29,,,,31],,,37,,,41,,,43,,,47,,,53,,,59,,,61,,,67,,71,,73]
-----------------------------------------------------------------------------------------------
7 """"  """"  """"  """"  """"  """"  """"  217].,......  ,...... ,...... ,...... ,...... ,......,427..,......  ,...... ,......,
11  """"  """"  """"  187,......,......,......,......]....., ......,......,.697.,.....,......,......,.......,......,......,.
13  """ """"  """"  """"  247..,......  ,...... ,].....,......  ,...... ,...... ,...,on saute49.. ,...... ,...... ,...... ,...... ,.....,.....,
17  """"  187 ,.....  ,...... ,...... ,...... ,...... ,]..... ,...... 697....,..... ,...... ,...... ,...... ,...... ,...... ,......  
19  """"  """"  247.. ,...... ,...... ,...... ,...... ,]..... ,...... ,...... 817...,...... ,...... ,...... ,...... ,...... ,...... ,
23  """"  """"  """"  """"  """"  """"  667.. ,]..... ,...... ,...... ,...... ,...... ,......667... ,...... ,...... ,...... ,
29  """"  """"  """"  """"  """"  667.. ,...... ,]..... ,...... ,...... ,...... ,.......667.. ,...... ,...... ,...... ,...... ,
31...217..,.....,.....,.....,.....,......,...... ,..... ,].1147.....,......,......,...... ,...... ,......,2077,.....,.....,
--------------------------------------------------------------------------------------------------------

Ce qui supprime toutes les opérations de calcule: produit et modulo pour tout Ai > 31 .
incrément = 30 : Ai + 30, +30 ...+30k  et on peut "aussi" incrémenter l'index de: Bi si c'est plus rapide...

D'où , il n'y a que les 8 boucles GM quelque soit le nombre de Ai, de la liste A .
Ainsi que les 8 opérations au maximum, des Ai <= 31, pour trouver les 8 index et ensuite : Bi * [Ai +30k]

C'est faisable...?

illustration, en partant du carré des nombres premiers Bi de la liste GM :

Exemple : on a choisie fam =1 , i = 0, Bi=7:
7*7, 7*11, (7*13) == 1%30. L’index du couple est 3 ; [7 et 13] vont cribler par pas de 7 et de 13, de 3 → n//30.

Une fois terminé on fait un break et on les incrémente de 30, pour réitérer et continuer avec Bi+30 ; (7+30 , 13 +30)qui sont bien dans la liste des Ai(premiers), (« sinon on augmente de 30 jusqu’à fin de liste des Ai(premiers) donc <= 89. »).

Ce qui donne :(Ai)² = 37*37 , calcul index et criblage, puis 43*43, index et criblage. Break ; on incrémente à nouveau ces deux Ai (37 et 73 )de 30 ; soit: 67*67, index et criblage ; puis 73*73, index , criblage ; fin pour ces deux Familles Bi[30].
On passe à Bi suivant.

Suivant Bi=11 : (11*11) == 1%30 ; index 4 et crible par pas de 11, de 4 → n/30.
Break ; on incrémente Bi de 30 ; soit Ai = 41, produit = 41*41 ; index, criblage,break et on incrémente à nouveau de 30 tant que Ai +30k est <= à  sqrt n fixé, soit 89 pour cet exemple.
Donc :71*71 , index, criblage ; fin pour cette Famille Bi[30].
On passe au suivant.
Bi suivant = 17 car la famille Bi = 13[30] a déjà été utilisé et finie….

17*17, 17*19, 17*23 == 1%30 ; calcule de l’index pour le couple (17,23)//30 = 13 le couple va cribler par pas de 17 et de 23 ; de 13 → n/30 , break, on incrémente de 30 : 17 et 23 , produit des carrés, index, criblage fin des deux Familles Bi = 17 et 23 [30]
etc ….etc.
On réitère avec Bi suivant = 19…. etc…jusqu’à la dernière Famille Bi=31[30].
A la fin on fait le total des [1] qui donnera le nombre de nombres premiers : q[n ; 2n].

le programme est un peu plus difficile, mais on supprime beaucoup d'opérations...

LEG
25-12-2018 07:34:03

Bonjour Yoshi
j'attendais le père noël après 21h30 ...pour qu'il m'apporte ses idées....je te remercie et j'espère que tu vas bien en profiter .

A_)
concernant tes 50 boucles.. ok..Mais je pensais vraiment que c'était plus rapide 8 boucles sur 50 nombres ..! car il y a justement le phénomène qu'après les 8 premiers sur les 50 nombres premiers, il y a de plus en plus d'écart entre ces premiers, de ce fait la congruence du produit %30 ==fam, est plus rapprochée , d'où moins d'opérations lorsque n tend vers l'infini...Sur excel , manuellement je vais plus vite...

B_)
Si c'était faisable, effectivement la sommation finale est automatique..
Mais justement le problème des doublons n'est pas gérable...

n=3000 ; fam = 7 , Pi =7
ok : on a les 1000 [1], j'ai l'index 7,pour Pi = 7; par pas de 7, j'enlève un 1 à chaque pas de 7 et autant de 0 à la place..Sachant que je vais partir de 7 ....>1000 = (993/7) +1, le premier 1 enlevé au départ . J'ai enlevé 141 + 1 [1] . Somme = 1000 -142. ON est d'accord..? sous total = 858.

Pi = 11 pour l'index 6 ; même opération par pas de 11 de 6 à.....> 1000 ; soit :(858 / 11) + 1. 72 [1] d'enlevés... Où sont les doublons parmi ces 72 [1]....Comment tu les vois..? ou comment le programme va le savoir. ..?

Sachant que les doublons vont se répéter en fonction du nombres de pas UNIQUES par Pi...dixit le TFA..("thèoreme fond de l'arith..")..cela revient à prévoir la factorisation unique d'une cellule[1]...Imagine les conséquences....

Il y a un polynôme avec 26 variables de degré 25 ; qui ne prends que les nombres premiers...donc qui élimines les doublons....

tu peux illustrer et faire un essais : j'ai marqué les deux index de départ, [(0)] =7 pour Pi = 7 ; "0" 6, pour Pi =11


111111"0"[(0)]111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)111111(0)1
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

1) la seule chose que l'on sait: c'est que la cellule d'index 6 partagé par 11 *17  se retrouvera dans 187 cell, donc d'index 6 + 187 cellules, avec comme factorisation (7,11 et bien sûr 31) = 5797 et (5797-7)/30 = l'index 193..!

Quel est la factorisation de la cellule X = (7,11, z) le ou les doublons...?

au pif: 9 * 7 = 63  au départ de la 8ème cellule = 71 cellules; moins la cellule 0 =7 , cela fait 70 cellules :
vérification : 70*30 + 7 = 2107 ; 2107/7 = 301; 301 / 11 = Faux...   le conjoint de 7 avec 11, c'est 11 + 30 = 41.
cellule 106 ok....(105*30 + 7) est /7/11 et 41.
41 qui a pour index 23 donné par (17*41) // 30 ...c'est ingérable , comme le polynôme schmoldu...à 26 variables...

Je vais regarder de mon côté ce que donne le nombre d'opérations pour 8 boucles et n nombres: avec 6000...

Joyeux Noël cher ami...
Gilbert
@+

yoshi
24-12-2018 20:16:20

Re,

Je ne suis pas chez moi, jusqu'au 26, mais 450 km plus loin.
Rapidement comme ça, non !
Il y a une autre idée que je voudrais tester...

Cela dit 50 boucles sur 8 nombres ou 8 boucles sur 50 nombres, ça fait toujours 400 couples de valeurs et pratiquement un couple sur 2 à éliminer (redondance).

L'idée que je voudrais tester est de ruser avec un nombre par exemple au départ de 1000 cellules pour n=30000, ne contenant que des 1.
Au lieu de gérer 1000 cases de 1, utiliser le nombre 1000, et enlever 1 à ce nombre au lieu d'écrire 1 dans la case déterminée grâce à l'index.
Il faudrait, par contre, que je sache si j'ai affaire à un "doublon" parce que dans ce cas où dans la liste j'écrirais un 0 là ou j'en ai déjà inscrit un, j''enlèverais par contre un au nombre une fois de trop...

Ça doit être faisable...
Si ça  l'est effectivement, je réduirais autant d'accès à la liste, autant d'écriture de 0 et la sommation finale : le nombre restant donnerait automatiquement le total...

@+

LEG
24-12-2018 07:50:11

Bonjour Yoshi

est ce que tu as essayé d'inverser la boucle : a,b  en b,a:


GM=[7, 11, 13, 17, 19, 23, 29, 31] # c'est aussi une liste
premiers=[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53] # c'est une liste
for b in premiers:
    print ("Avec a =",a,end="    ")
    for a in GM:
        print ((a,b),end=" ") # Affichage des couples (a,b)
    print()

de sorte, que c'est B = 7 , qui va parcourir les éléments de a, calculer a%30==fam, puis calculer les index, pour chaque a trouvé, a part cribler ... jusqu'à la fin , on sort de la boucle,] puis on change d'indice i+=1 , B=11...et on réitère...???

il n'y aura que 8 boucles [Bi.....> a]

LEG
23-12-2018 18:59:00

crochets, accolades,  parenthèses...et cannes à pêche ...pour moi je nage....Est-ce que tu le veux transcrit en C++, à la suite des post...?

Ce qui veut dire aussi que pour n > 10: il existe plus de premiers entre 1 et n qu'entre n et 2n.
Et la conjecture de LEG, quelle est-elle ?

la même affirmation que toi..!
En effet les deux algorithmes criblent la même limite de 7 à N : pour compter le nombre de nombres premiers de 7 à N ou de N à 2N

or, il est simple de montrer que l'algorithme d'Ératosthène comptera plus de premiers de 7 à N car il n'utilise que les nombres premiers Pn $\leqslant\sqrt{N}$ pour marquer les multiples n de P .

Alors que l'algorithme de Goldbach, pour la même limite de 7 à N comptera plus d'entiers N congru à 2N modulo P , car il utilise les nombres premiers Pn  $\leqslant\sqrt{2N}$ d'où par obligation, moins de premiers entre N et 2N....!

Ce n'est pas une conjecture, mais une évidence....tu ne crois pas....?

c'est aussi pour cela que j'en ai déduit que le nombre de nombres premiers qu'il y a entre N et 2N vaut environ $ \frac{N}{Ln (2N)}$, pour N>= 15; et non $\frac{N}{Ln (N)}$ pour Ératosthène . Cela n'engage que moi, bien entendu..

Si j'utilise le terme de crible ou algorithme de Goldbach, cela vient tout simplement que pour compter le nombre de couples (p,q) qui décompose un entier pair >= 16, en somme de deux premiers p,q on utilise le même crible en ne comptant que les nombres premiers p <=N , qui n'ont pas été marqués par ce crible...Donc :("qui peut le plus peut le moins").....sans aucune prétention, simplement un hobby...


Passe une bonne fin de soirée
@+

yoshi
23-12-2018 18:49:03

Re,

je parle des crochets [] pas des accolades {}, hein...

@+

Pied de page des forums