Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#176 Re : Café mathématique » Algorithmes faciles : la "programmatrice" » 24-05-2021 10:44:49
Bonjour
j'ai bien essayé hier mais étant sous linux débian, impossible de télécharger la programmatrice avec le lien que tu as indiqué..mais je ne suis pas du tout programmeur .
#177 Re : Café mathématique » Algorithmes faciles : la "programmatrice" » 23-05-2021 07:41:57
Bonjour
ta "programmatrice" pour être utilisée ou faire de la programmation, demande une connaissance en programmation mais elle ne permet en aucun d'apprendre à programmer.
si tu ne sais pas taper une ligne de programme je doute fort qu'elle te dise ce qu'il faut faire ...non ?
si tu tapes une ligne de programme en Python , par exemple un petit programme python, l'algorithme d'Ératosthène:
import math
def eratostene(n):
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
return premiers
def compteInfN(liste, n):
lenListe = len(liste)
compte = 0
for i in range(0, lenListe):
if(liste[i] >= n):
compte += 1
return compte
def premiersNa2N(n):
liste = eratostene(2*n)
compte = compteInfN(liste, n)
print("> On prend N = "+str(n)+" , donc 2N = "+str(2*n))
print("> "+str(n)+" / log("+str(2*n)+") = "+str(n/math.log(2*n)))
print("> On compte "+str(compte)+" nombres premiers entre "+str(n)+" et "+str(2*n))
print("> Voici la liste des nombres premiers entre "+str(n)+" et "+str(2*n)+" :")
print(liste[len(liste)-compte:])
n = int(input("Donnez la valeur de N : "))
premiersNa2N(n)
input()
Quel résultat donne ta machine, si on ne peut pas importer la première ligne du programme : import math ...?
Peux tu donner l'image de cet exemple...?
#178 Enigmes, casse-têtes, curiosités et autres bizarreries » probabilité conditionnelle et indépendance » 11-05-2021 09:38:08
- LEG
- Réponses : 0
Bonjour :
un petit souci de logique et de compréhension :
Prenons deux entiers naturels non nuls A et B on dit que A et B sont indépendants si rien ne les relie ... par exemple A= P premiers et $B= P+2 = q$ premier donc $p$ et $q$ sont indépendant l'un de l'autre,
Erreur d'interprétation il s'agit d'événement indépendant et non de deux entiers naturel...
Si @Yoshi veut bien supprimer ce sujet merci.
LEG
#179 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Conjecture de Goldbach vraie ou indécidable ? » 06-05-2021 09:44:53
Bonjour
c'est l'effet boule de neige que tu as du mal à imaginé alors que la comète de Goldbach est plus simple à visualiser...mais c'est relatif, car elle n'explique pas ce nombre de solutions qui augmentent lorsque $n$ tend vers l'infini, ni le décalage récurrent des congruences sur leur successeur qui en est la cause principale...!
Personne n'a étudié cet effet, c'est beaucoup plus facile à étudier et à visualiser en utilisant qu'un seule des 8 familles de nombre premiers de la forme $30k + (i)$ avec $i\in{1,7,11,13,17,19,23,29}$ , en progression arithmétique de raison 30, de premier terme (i); pour montrer que pour tout $n =15k + (i);\; n \geqslant {150}$ pour $n=15(k+1) + (i)$ il y a par obligation un $A\not\equiv{2n}[P]$ qui précède un $A' + 30 = P'$ ; d'où $2n=30(k+1) + (2i)$ se décomposera en somme de deux premiers $P'+q$. ("Il s'agit bien d'un seul et même événement .")
Car on ne peut pas marquer tous les $P'$ comme si ils étaient tous congruents modulo P , et par conséquent invalider la conjecture pour un entier $2n$ qui existerait.
La raison est simple, il faudrait que l'algorithme/crible de Goldbach dispose des même IDX index de départ des nombres $P$ qui criblent, identiques à ceux d'Ératosthène, ce qui est clairement impossible.
Un autre constat parmi les entiers $A\leqslant{n}$ qui sont non congruent modulo P, les A' = P' ou pas, ne sont pas indépendant les uns des autres , ils sont criblé suivant le même principe ; avec les même nombres premiers P; pour une même limite $n$ caractérisé ou pas , par les deux fonctions du TNP. Par conséquent : pour $A'=P'$ tel que $A\not\equiv{2n}[P]$ qui implique $q$ , $P' \;et\; q$ ne sont pas deux événements indépendants, c'est le même événement car $q$ dépend de la congruence de $P'$.
Soit on crible le tableau des $P'$ d'Ératosthène avec le crible de Goldbach , soit l'inverse , mais on aura la même égalité du nombres de $A' = P'$ non congrus à 2n modulo P, Ce qui permet par conséquent, d'unifier les deux fonctions du TNP en une seule , qui devient : $\frac{n}{(Ln\:n\:*\:Ln\;2n)}$ pour avoir une estimation de couples $p'+q =2n$ pour tout $2n > 4$.
Note: Une seul famille (i) est suffisante pour montrer la conjecture , on a donc pas besoins de tous les nombres premiers < N, ni de tous les entiers naturels positifs.
Car suivant cette propriété de l'algorithme , où les index augmentent de 1; ce qui décale les congruences d'un rang lorsque $n$ augmente de 15, il s'ensuit un effet boule de neige : c'est à dire que le nombre de solutions qui décomposent 2n , va augmenter avec un effet oscillatoire soit un peut plus soit un peut moins ...etc.
Mais cela n'aura que peu d'incidences pour une limite $2n = 4*10^{18}$ car ce seront des milliards de solutions qui se décaleront d'un rang ...! En définitive on décale d'un rang l'image criblée précédemment , où seul, le premier élément est inconnu au niveau de sa congruence.
Par Exemple :
Ex: on fixe la limite n = 15k = 300, la fam(i) = 7 progression arithmétique de raison 30 ;
-les A seront représenté par des 1: A ∈[7,37,67,97,127……….277 < 300]
-tableau du crible n//30 [1,1,1,1,1,1,0,0,0,1] P = 7,11,13,17,19,23 le R de 600 par P = 5, 6, 2, 5, ... ("les R de 19 et 23 n'apporteront rient")
On marque les multiples de p par 0
-on calcule j = R + P si R%2=0 , sinon R +=2P → j%30 == fam(i)=7
P=7 , R =5 va donner → 5+14 , 19+14 →33, 47, 61,75, 89, 103, 117,131, 145, 159, 173, 187==7%30,
on calcul l’index : idx = j//30 , 187 // 30 == 6. et on va cribler en partant de idx,« attention on compte en commençant
par 0 ,1 ,2 , n...→n//30 » on marque en rouge les congruent modulo P, puis par pas de 7 .
cela va donner idx = 6→[1,1,1,1,1,1,0,0,0,1] puis on réitère avec P = 11, R = 6
127 == j%30 et idx = 4→[1,1,1,1,1,1,0,0,0,1] puis on réitère . P = 13, R = 2,
67 == j%30 et idx = 2 → [1,1,1,1,1,1,0,0,0,1] puis on réitère . P = 17, R = 5 donnera 277 ,
277== j%30 et idx = 9→ [1,1,1,1,1,1,0,0,0,1] fin on fait la somme des 1 = 7 A ≢2n[p] = 7 premiers q∈[n;2n].
Donc pour n = 15(k+1) = 315 , les restes R changent , mais les iDX augmentent uniquement de 1 ...! donc on décale les congruences des entiers 1 ou 0 d'un rang.
L'image des congruences devient alors avec un x sur le premier élément car on ignore sa congruence, puisque par supposition on ne cribles pas :
ce qui va donner pour P=7,idx =7→[x,1,1,1,1,1,0,0,0,1]
127 == j%30 pour P =11 idx = 5 → [x,1,1,1,1,1,0,0,0,1]
67 == j%30 pour P = 13 idx = 3 → [x,1,1,1,1,1,0,0,0,1]
277== j%30 pour P =17 idx = 10→[x,1,1,1,1,1,0,0,0,1] idx hors limite
déjà on sait que pour n = 15(k+2) = 330 , on aura un élément de plus = 307 . qu'il sera non congru à 2n [P] et par conséquent il vérifiera 30(k+2)
tel que 660 - 307 = q car on sait d'après Ératosthène que 307 = P', Ce qui rend impossible l'infirmation de la CG pour n =15(k+1 ,+2)..etc
Les trois éléments marqués 0 ne sont pas premiers; et deux inconnus au niveau des congruences qui seront les 2 premiers éléments en bleu, 7 et 37 et les IDX sont : 8, 6, 4, et 11 hors limite
vérification : [x, x,1, 1,1,1,0,0,0,1, 1] et tes premiers $P'\leqslant {n}$ non congruents modulo P sont : x = 7 et 37 ; 67 ;97 ; 157; 277 et 307
On peut aussi pousser plus loin, avec l'analyse des deux intégrales relatif aux deux fonction du TNP, en utilisant le programme de l'algorithme qui donne le nombre de premiers P' criblés par famille:
entiers A non congruent à P , par la fonction $\frac{n}{Ln\:2n}$
nombres premiers p' par la fonction $\frac{n}{Ln\:n}$
nombre de $P'\not\equiv{2n}[P]$ par la fonction $\frac{n}{(Ln\:n\:*\:Ln\;2n)}$, ou plus précis : avec la fonction $\frac{\pi(n)}{Ln\:2n}$ ce serra un résultat minimum
On peut tout aussi bien le calculer avec le nombre de premiers et d'entiers naturels par famille : n//30 , exemple : $\frac{\pi(n//30)}{Ln\:(n//30)}$
etc...etc
Mais le plus surprenant , c'est le rapport entre les premiers $P'$ et les $P'\not\equiv{2n}[P]$ ,pour une limite $n$ qui progresse de raison 15 et par famille. Ce qui n'a jamais été étudié, il en résulte que quelque soit une limite N > 150, et une famille (i) fixée, les densité de couples p'+q = 2n et le rapport tel que défini si dessus seront en moyenne générale les même par famille.
Sachant que la conjecture serait vraie pour les multiples de 30, donc pour les 8 Familles (i), alors elle implique tout nombre pair ainsi que sa famille (i ) correspondante à ce 2n.
je vais rajouté demain en image les tests pour deux autres limites et ses familles (i), avec un test sur les 2n = 30k , avec 4 ou 5 familles la limite serra sera toujours 4500 mds.
En utilisant le programme C++ des deux algorithmes joint en fin de document que je remet. j'ai utilisé la limite $n$ = 4 500 000 000 002 et les Familles (11;17 et 23 mod 30) l'image :
On pourra vérifier et analyser les fonctions d'estimations désignées ci-dessus par famille.
#180 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Conjecture de Goldbach vraie ou indécidable ? » 05-05-2021 09:32:18
Bonjour à tous :
@Bernard-maths
c'est bien ce que j'ai essayé de montrer par des raisonnements : pour tout entier pair $2n\geqslant{4}$ il existe un entier non nul $A\leqslant{n}$, premier ou pas , qui précède un entier $A' = P'$ premier et tel que $A\not\equiv{2n}[P]$ alors par obligation : pour $n+1$ on aura $(2n+2) - (A'+2) = q $ premier , on obtient alors le décalage d'un rang des congruences; d'où , La conjecture serra vérifiée pour 2n + 2.
Comme : $P\leqslant\sqrt{2n}$ est un nombre premier, qui ne peut diviser $2n - A' = q$ ce qui implique aussi $(2n+2) - (A'+2) = q $ , d'où la différence $q$ serra bien le même nombre premier.
C'est une propriété récurrente de l'algorithme de Goldbach dans les ""congruences"" qui se décalent d'un rang lorsque lorsque la limite $n$ augmente de 1, donc $2n +2$
par conséquent tout pour tout $A\leqslant {n}$ impair qui précède $A'+ 2 = p'$ premier et tel que $A\not\equiv{2n}[P]$ , sa congruence ""propriété"" se reportera sur $A'$
d'où : $(2n+2) - (A'+2)$ serra une solution vérifiant que $2n+2 = P'+q$ car le contraire serait clairement faux ...
Donc on n'a nul besoin de s'occuper de l'existence d'un entier $p\leqslant{n}$ et de l'existence de son complémentaire $q$ par rapport à $2n$.
Mais qu'il existe toujours pour une limite $n\geqslant{3}$ un $A\not\equiv{2n}[P]$ qui précède $A'=p'$.
On sait d'après le TNP que quelque soit la limite $n\geqslant{3}$ il existe environ :
1): $\pi(n)$ équivalent à $\frac{n}{Ln\:n}$ et en 2): $G(n)$ le nombre de $A\not\equiv{2n}[P]$ équivalent à $\frac{n}{Ln\:(2n)}$ qui implique le nombre de premiers $q\in{[n ; 2n]}$ .
On peut d'ailleurs par famille et pour toute limite fixée $N = n/30$ avec $n\geqslant{300}$ en déduire avec la fonction $\frac{\pi(N)}{Ln\:2N}$ le nombre de $A' = P'$ qui implique le nombre de couples $P' + q = 2n$ par famille.
Pourquoi : pour toute limite $2n$ vérifiée on a aussi vérifié grâce à la propriété de l'algorithme, le nombre de $A\leqslant {n}$ non congruent à $P$, qui précèdent $A'+2 =p'$ un nombre premier.
Or cela implique le nombre de solutions qui vont vérifier la limite suivante $p'+q = 2n+2$, donc l'existence d'un $p'\leqslant{n}$ Tel que $p'\not\equiv{2n}[P]$ , qui sera une solution pour $2n+2 = p'+q$
Supposons le contraire pour $n+1$ : il faut que tous les $A$ soient congrus à $2n+2$ modulo $P$.
A) : c'est à dire, ceux qui étaient déjà congrus à $2n$ modulo $P$ , mais aussi ceux qui le seront, ""congrus"" pour $2n+2$ modulo $P$ . Ce qui est clairement impossible, les restes $R$ de la division de $2n$ par $P$ ne sont plus les mêmes pour la division de $2n + 2$ par $P$ avec le même cardinal +1 ... !
B) : Cela modifierait de façon importante le nombre de nombres premier $q\in[n ; 2n]$ qui ont été vérifiés et dénombrés lors de la limite précédente, donc contraire au TNP et au TFA.
Les restes $R$ de $2n$ par $P$ , changent pour toute limite $n+1$ criblée, par conséquent les $A$ premiers ou pas , qui précédaient des $p'$ et qui étaient congrus à $2n[P]$ ne peuvent plus l'être , dès lors ils deviennent en moyenne générale non congru à $2n+2 [P]$ avec ces mêmes nombres $P$ ...
là aussi on aurait une contradiction avec le TNP mais aussi le TFA, si $2n - A$ est un multiple de $P$ il est clair que $(2n+2) - (A'+2)$ serra toujours un multiple de $P$ ; car par évidence, on ne peut pas utiliser les restes $R$ de la limite $n$ précédente.
lorsque $n$ augmente de 1, le nombre de $p'$ restent le même, le nombre de premiers $P$ qui criblent la limite $n+1$ sont les mêmes, éventuellement à une exception près;
le nombre de $A\equiv{2n+2}[P]$ à une exception près est le même , donc il en est ainsi pour le nombre de $A\not\equiv{2n+2}[P]$
il vient par conséquent que la variation de $A\not\equiv{2n}[P]$ qui précédaient les $A'=P'$ ,ne peut varier que de façon négligeable..!
Car il n'y a que les index de départ des nombres P qui criblent, qui vont se décaler d'un rang, ce qui occasionne le décalage d'un rang des congruences sur leur successeur $A_i + 2$, ou $A_i + 30$,si on crible par famille modulo 30 ...
C) : On en déduit donc de façon formelle, qu'un couple de premiers $p'+q = 2n + 2 $ vérifiant la conjecture, $p'$ et $q$ ne sont pas deux événements indépendants, puisque $q$ dépend de la congruence de $p'$ ou encore de $A = p'$ ou pas ! Et tel que $A\not\equiv{2n}[P]$ où $A$ précède un nombre premier $p'$ .
Ou alors il n'y a plus de $A$ qui précèdent un nombre premier $ p'$, ni de premiers $p'$ consécutif pour la limite $n+1$ suivante car ils ont disparus par miracle ce qui est complètement idiot , car l'algorithme est récursif ...
L'algorithme reproduit la même image des congruences de la limite $n$ décalait d'un rang, du fait que les index relatif à chaque nombre premier P augmentent de 1; ainsi que l'image des nombres premiers $p'$ qui serra la même.
Le contraire est clairement impossible, suivante l'égalité récurrente démontrée : $2n - A$ est identique à $(2n +2) - (A+2)$ ...etc etc...
j'utilise diverses fonction asymptotique du TNP pour estimer le nombre de $A'=P'$ non congrus à 2n modulo P , inférieur à une limite $n$ fixée .
Il faudrait donc éventuellement montrer aussi si possible, un bornage minorant et majorant ce nombres de $A'=P'$ non congrus à 2n modulo P par rapport à $n$ et dès lors cela rendrait analytiquement impossible, l'existence d'un entier $2n\geqslant{6}$ qui ne se décompose pas en somme de deux nombres premiers $p'+q$; sachant que cela n'apportera pas grand chose de plus...
Puisque par supposition, la conjecture étant vérifiée pour la limite $n$ ; il est alors impossible de l'infirmer pour la limite $n+1$ conséquence de cette propriété récurrente de l'algorithme. (" C'est un peu le principe de la démonstration de l'infinité des nombres premiers utilisait par Euclide ")
27.06.2025
#181 Enigmes, casse-têtes, curiosités et autres bizarreries » Conjecture de Goldbach vraie ou indécidable ? » 29-04-2021 09:33:30
- LEG
- Réponses : 11
Bonjour
Est ce que cette conjecture pourrait être indécidable ?
suite aux conditions et explications montrées dans ces documents, relatif à l'impossibilité d'infirmer la conjecture de Goldbach pour toute limite $n\geqslant{3}$ fixée , où il n'existerait pas de limite 2n, 2n+2 qui ne pourrait être vérifiée, c'est à dire il existerait une limite $2n={p+q}$ qui serait impossible à vérifier...
Avec la condition : on suppose que les limites 2n - 2, 2n - 4 , 2n - k ont été vérifiées et donc :
Il vient que la propriété récurrente de l'algorithme de Goldbach interdit par conséquent cette possibilité d'indécidabilité....
les programmes des algorithmes utilisés son sur le forum programmation , programme en python LEG .. dernière page 16.
#182 Re : Programmation » [FF++] Question sur un bout de code » 10-04-2021 07:50:07
Bonjour
Dans quel domaine est utilisée cet algorithme et dans quel but...? ainsi que tes formules , peut être qu'il faudrait regarder manuellement ce que cela donne puis le faire en python...
Avant de demander à quoi sert un programme que tu as récupéré quelque part...???
Car il semblerait que tu n'ais pas beaucoup de réponse ''sur les sites de mathématiques''
#183 Re : Programmation » Programme python x²=r » 07-04-2021 11:11:59
Bonjour
ben : il me semble que la fonction des accolades {x} et {-x} sert à imprimer la valeur des tes x sinon cela n'imprime rien le f" prend en compte l'instruction de ta ligne.
pourquoi tu n'essayes pas de remplacer tes accolade par (x) et (-x) tu vas vite comprendre...et si tu enlèves ton f" tu auras surement un message d'erreur de python
#184 Re : Café mathématique » Vidéos éducatives Youtube et mathématiques ! » 06-04-2021 07:21:17
Bonjour
Est-ce que tu regardes ou tu poses des questions sur ce forum de mathématiques pour comprendre cette matière, et qu'en penses tu ?
#185 Re : Programmation » crible en python » 30-03-2021 11:39:28
Bonjour à tous
Je joins ci dessous le programme unifié des deux algorithmes Ératosthène et Goldbach en C++ ; qui donne directement le nombre de couples p+q qui décomposent 2N en somme de deux nombres premiers , avec le nombre de nombres premiers < N qui sont criblés, pour une limite N fixée. Le deuxième document joint donne l'explication sur la conjecture de Goldbach , le fonctionnement de l'algorithme et pourquoi cette conjecture ne peut être infirmée quelque soit une des 8 Fam(i) fixée par rapport à la forme de la limite $N\geqslant{150}$ fixée
Il est paramétré ligne 156 et 157 :
ulonglong debut = 45000000000; // début du crible par fam(i) le crible progresse de raison 15 pour chaque famille (i) en fonction de la forme de N
ulonglong fin = 4500000330; // fin
pour définir les limite $N$ de début et de fin on change la valeur de début et de fin suivant la limite N que l'on veut vérifier par pas de 15 ou de raison 15 suivant le principe d'une suite arithmétique de raison 15, d'où on obtiendra le nombre de $A\not\equiv{2n}[P]$ ce qui implique le nombre de couples $P'+q = 2N$
Sachant que l'on connaît les fam (i) à utiliser en fonction de la forme de $N$ ceci implique la vérification de $2N$ en somme de deux nombres premiers (p+q) l'algorithme en déduit directement la Fam(i) q complémentaire, conséquence des congruences utilisées par l'algorithme de Goldbach modulo 30.
Exemple: limite début $30001$, la limite fin serra $30001 + 15k$ par exemple $15k =165$ ce qui donnera comme limite fin : $30166$ on vérifiera le nombre de couples solutions de 2N de $60002\: à\: 60332$, avec une limite N + 15k criblée par famille, (la limite N progresse de raison 15 de 30001 à 30166)
il n'y a que la ou les fam(i) à activer ou à désactiver les autres, par deux barres slach // de la ligne 160 à 168.
Pour cet exemple $2N = 30k + 2$ on a que trois possibilités fam 1, fam13 ou fam 19. et on désactive les 5 autres Fam par 2 // devant chaque Fam(i)
car $1+31 = 30k+2$ et $13+19 = 30k+2$ et les 5 autres fam(i) ne peuvent décomposer en somme de deux nombres premiers 30k + 2, car leur complémentaire q ne serait pas un nombre premier, mais un multiple de 3 ou de 5...("ex : 32 -7=25 ; 32-29 = 3 ; 32-11 =21...etc")
Ces documents joints :
résumé:
modifie le /2024
https://www.cjoint.com/c/OByklBXrpoj
https://www.cjoint.com/c/NKfghFoR7dN
https://www.cjoint.com/c/NIuh5hROHk6
il vous indique en fin de document la fam (i) où $î\in(1,7,11,13,17,19,23,29)$ à utiliser en fonction d'une des 15 formes de $N$
Il prouve aussi avec les illustrations, pourquoi on en déduit, que cette conjecture ne peut être infirmée grâce aux propriétés de l'algorithme de Goldbach utilisant les congruences . Avec les documents joints des post précédents.
Pour le fonctionnement du programme c++ , j'utilise (Code::Block).
J'ai rajouté dans le programme les 8 familles ligne 160 à 168 que l'on actives ou désactives avec les 2 // en fonction de la forme de N , si N différent de 15k , par exemple pour début N = 15k +8 = 3 000 008 et fin N = 15(k+7) + 8 = 3 000 113 on active les trois familles (i) = 17, 23 et 29 ; on désactive les 5 autres avec //
// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
void fill_crible(vector<unsigned> &crible, unsigned p)
{
crible.resize((p - 1) / 64 + 1);
unsigned cs = crible.size();
unsigned lastnum = 64 * cs;
unsigned lastsieve = int(std::sqrt(double(lastnum)));
unsigned primesieved = 1;
crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
for (unsigned i = 1; i < cs; ++i)
crible[i] = 0xffffffff;
for (; primesieved <= lastsieve; primesieved += 2)
{
// find next prime
unsigned pos = primesieved / 2;
for (; pos < cs; pos++)
{
if (crible[pos / 32] & (1 << (pos % 32)))
break;
}
// set mutiples of (2*pos+1) to false
primesieved = 2 * pos + 1;
unsigned n = 3 * primesieved;
for (; n < lastnum; n += 2 * primesieved)
{
pos = (n - 1) / 2;
crible[(pos / 32)] &= ~(1 << (pos % 32));
}
}
}
unsigned nextprime(vector<unsigned> &crible, unsigned p)
{
// assumes crible has been filled
++p;
if (p % 2 == 0)
++p;
unsigned pos = (p - 1) / 2, cs = crible.size() * 32;
if (2 * cs + 1 <= p)
return -1;
for (; pos < cs; ++pos)
{
if (crible[pos / 32] & (1 << (pos % 32)))
{
pos = 2 * pos + 1;
// if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
return pos;
}
}
return -1;
}
typedef unsigned long long ulonglong;
size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau de 1 modulo 30 et rappeler les premiers p
int cl = clock();
// size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
//vector<bool> crible(lencrible, true); // on rappelle les nombres premiers p d'Eratotene ci dessus
// ulonglong n2=2*n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong produit;
int GM[] = {7, 11, 13, 17, 19, 23, 29, 31}; // on va calculer le produit de p par un element du groupe GM
for (size_t j = 0; j < sizeof(GM) / sizeof(int); j++)
{
produit = p * GM[j]; // calcul du produit, jusqu'a ce que le produit soit égale à fam modulo 30
if (produit % 30 == fam)
{
produit /= 30; // puis on va va calculer l'indice, afin de commencer à cribler de l'indice à n/30 et on réitère
break;
}
}
indices[i] = produit;
}
ulonglong nslices = lencrible / 1500000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]);
//cout << "Nombre premiers criblés famille " << fam << " plus petits que " << n << ": " << total << " time " << (clock() - cl) * 1e-6 << endl;
return total; // à la fin du crible on return le résultat est le temps mis
}
size_t GCrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{
int cl = clock();
//size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
//vector<bool> crible(lencrible, true); // on rappelle les nombres premiers p d'Eratothene ci dessus
ulonglong n2 = 2 * n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong reste = n2 % p; // on calcule le reste de 2n par p
if (reste % 2 == 0)
reste += p;
ulonglong pi2 = 2 * p;
while (reste % 30 != fam) // tant que le reste += p n'est pas = à Fam % 30 on rajoute 2*p
reste += pi2;
reste /= 30; // on ensuite on va calculer l'indice pour commencer à cribler le tableau de 1.1.1.... avec p, de l'indice à n/30
indices[i] = reste;
}
ulonglong nslices = lencrible / 1500000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]); // le criblage du tableau de 1 modulo 30 jusqu'a n/30 (1.1.1.1...etc) est fini on va retourner le résultat
cout << "Nombre couples p+q=2N criblés famille " << fam << " : " <<total << " time " << (clock() - cl) * 1e-6 << endl;
return total;
}
int main(int argc, char **argv)
{
vector<unsigned> temp;
ulonglong debut = 4500000000;
ulonglong fin = 4500000060;
vector<int> familles;
familles.push_back(1);
familles.push_back(7);
familles.push_back(11);
familles.push_back(13);
familles.push_back(17);
familles.push_back(19);
familles.push_back(23);
familles.push_back(29);
for (int i = 0; i < familles.size(); i++)
{
int fam = familles[i];
for (ulonglong limite = debut; limite < fin; limite += 15)
{
cout << "famille : " << fam << " limite : " << limite << endl;
double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
fill_crible(temp, sqrt2N);
vector<ulonglong> premiers;
for (ulonglong p = 7; p <= sqrt2N;)
{
premiers.push_back(p);
p = nextprime(temp, p);
if (p == unsigned(-1))
break;
}
size_t lencrible = limite / 30; // on peut modifier cette ligne par = sqrt(limite)/30; pour vérifier la conjecture avec la limite n < sqrt , pour n > 3000000
vector<bool> crible(lencrible, true);
ECrible(premiers, limite, fam, crible, lencrible);
GCrible(premiers, limite, fam, crible, lencrible);
}
}
}
#186 Re : Café mathématique » Composants d'une pompe de gavage » 29-03-2021 18:43:35
Bonsoir
le lien de Yoshi : https://www.cjoint.com/c/KCDmz0O8uTa ;
te montre bien l'éclaté de ta pompe de gavage : le principe de fonctionnement est simple le carburant en rose rentre dans ta pompe lorsque celle ci tourne (action du moteur avec les charbons sur le collecteur de l'induit qui créait un champ magnétique autour des inducteur faisant tourner ton moteur électrique, qui est immergé, le plateau ou rouleau aspire le carburant avec un clapet anti retour pour le refouler avec son un clapet anti retour pour le refoulement , ce qui est bien indiqué ...
les différentes pièces de ta photo sont facilement reconnaissable, par rapport à l'éclaté sur la photo du lien à toi de leur mettre le nom...
1)porte charbon avec surement entrée et clapet anti retour avec sortie et clapet de sortie carburant
3) moteur électrique induit et inducteur
4)plateau cranté qui peut être la fixation de la pompe sur le réservoir
bonne soirée.
#187 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 26-03-2021 12:45:15
Bonjour
Re: je n'ai jamais dis que je comprenait ce que fait H Helfgott et ce quelque soit son domaine ... je t'ai simplement fait allusion à son crible , dont très peu de Mathématiciens de renommés mondiale, savent comment il s'y prend...alors imagine quelqu'un qui n'a jamais appris les maths...
pour te donner un exemple sur le modulo 30 par rapport au modulo 210 par exemple dans ces deux cribles on perdrait uniquement les multiples de 7; mais il ne serait pas plus performant voir moins rapide car le programme est beaucoup plus em.... à faire et pour rien gagner.
on en a discuté dernièrement avec Yoshi lorsque je lui est demandé si cela ne serait pas plus facile en gain de temps et de mémoire sans les multiples de 7... On a vite laissé tomber car même manuellement c'est galère à ""cause des trous que cela occasionnent""
Donc regarde le forum PROGRAMMATION et le Sujet : modifier un programme python page 2 par (leg) tu vas comprendre...
fait l'expérience en écrivant les entiers impairs sans les multiples de 7 , modulo 210 à partir de la bonne limite, tu verras qu'il te faut revenir pour vérifier sans arrêt les trous...tu n'as pas une progression linéaire mais en escalier...enfin bref , ça ne sert à rien a part passer du temps à faire le programme....sans garantie qu'il ne sautera pas des nombres premiers, si il y a un bug dans le programme qui oublie de vérifier....etc ...etc
#188 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 25-03-2021 12:15:40
Salut Antho
je connais le lien et le travail de Denise C
c'est un travail similaire au mien ; mais elle ne travaille pas dans les suite Arithmétique de raison 30.
ce qui est beaucoup plus long et qui raccourci la limite des cribles et leur vitesse, et n'utilise pas le même principe de fonctionnement.
si je ne travail pas modulo 6, c'est que cela n'a aucun intérêt à part avoir des multiples de 5 en plus qui ne servent à rien (au début j'ai travaillé modulo 6) ni même généraliser à l'ensemble des entiers positifs ce qui n'apporte strictement rien à la répartition des nombres premiers dans une suite arithmétique de raison, puisque l'on se débarrasse des 73% des entiers naturels contenant aucun nombre premiers à part 2 , 3 et 5, lorsque l'on s'intéresse aux nombre premiers qui peut le plus peut le moins...
regarde le crible de Harald Andrés Helfgott il utilise la racine cubique de n et en cercle...il élimine d'office les multiples des nombres premiers p < 19 , ne va donc pas lui demander d'utiliser modulo 6, ou autre tous les entiers naturels ça n'a aucun sens , à part passer du temps pour extraire la suite des nombres premiers...
si tu avais compris le principe des deux cribles tu ne me poserais pas tes questions....Il me semble que l'étude des primorielles à été étudiée depuis des lustres...
Et malgré cela personne , n'a été capable de construire la variante du crible d'Ératosthène utilisant les congruences avec des propriétés remarquables sur la répartition des nombres premiers , en fonction de ce que l'on veut regarder....notamment en ce qui me concerne , pour la conjecture de Goldbach...et sur le nombre de solutions qui vérifient un entier 2n en somme de deux premiers p+q...
Mais que cela ne t'empêche pas de construire ton propre algorithme afin d'extraire la suite des nombres premiers et pourquoi pas uniquement entre N et 2N en ne criblant jusqu'à n...
Bon courage.
#189 Re : Programmation » Programmes sous linux debian » 25-03-2021 08:58:36
Bonjour
@Yoshi
C'est ok , le programme en C++ pour unifier les deux algorithmes C++ est fait, il est très fonctionnel jusqu'à 8billion en gros, il est posté sur le sujet au dessus : crible en python leg , dernier post ; dernière page.
on peut le faire fonctionner avec une limite n de début à la ligne 156 et une limite n de fin, à la ligne 157 on change les valeurs ainsi que le choix des familles en fonction de la forme de la limite début N fixée .
la ligne // 106 permet aussi de publier si on veut, le nombres de premiers P' d'Ératosthène ECrible qui sont criblé par GCrible Goldbach.
voila l'image du résultat fam 7 limite n de 300 000 000 000 à 300 000 000 300 , par pas de 15 l'algorithme progresse de raison 15
https://www.cjoint.com/c/KGBelCYkZ0B
https://www.cjoint.com/c/KCzh4RazqWI
https://www.cjoint.com/c/KECi6gJ31IB
#190 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 24-03-2021 14:29:37
Bonjour
il est clair que moi je raisonne en fonction de mes connaissances sur la répartition des nombres premiers dans des suites arithmétique de raison 30 .
Et non en tant que Mathématicien, car je ne le suis pas du tout....
je n'ai jamais étudié les bases élémentaires des mathématiques , algèbre et compagnie...
Pour cela, je pense que si tu poses des questions mathématiques , Yoshi te répondra...
Sur mes deux cribles aucun souci.... pour te répondre .
Concernant l'imagination c'est probablement qu'elle n'est pas bridée par les formules Mathématique et mon absence de connaissance Mathématique , donc je procède comme quelqu'un qui pour comprendre est obligé de décortiquer au maximum les formules en nombres entiers et réels pour les comprendre. Je procède au cas par cas.
Peut être est ce la raison que mes algorithmes n'ont jamais été trouvé.. surtout celui de Goldbach qui a des propriétés très intéressantes sur la répartition des nombres premiers, notamment entre N et 2N , au lieu du postulat de Bertrand qui ne veut rien dire ou presque...
Sachant que la fonction qui donne son estimation est une conséquence directe du TNP, et non au lieu de dire : il y a au moins un nombre premier entre N et 2N ; ce qui pour moi est absurde ...
Sur la propriété que tu cites , les nombres premiers entre eux , je ne pense pas que j'aurai pu avec cela, construire mes algorithmes; Yoshi t'en diras plus et éventuellement sur des liens que tu pourras regarder.
Mais il me semble que tu t'intéresses surtout à la construction de la suite des nombres premiers ... donc comment construire le plus simplement cette ou ces suites... Or regarder les nombres premiers entre eux , ou utiliser les multiples de 2, 3 et 5.... je ne vois pas ce que cela t'apportera en plus ....?
Voici un exemple, sur la répartition des couples de nombres premiers p+q = 2N sur différentes limites N criblées et différente Famille (i) ("avec les trois algorithmes")
https://www.cjoint.com/c/KCynyRURh4p
Cordialement
@+
#191 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 22-03-2021 14:27:57
Bonjour
@Antho17 tu as raison avec ce fichier que tu regardes il te permet effectivement de comprendre l'algorithme de Goldbach utilisant les congruences
tout d'abord avec les entiers A impair et non nul, si tu veux te passer des A pairs dans ce cas tu parts directement de la suite
[1.3.5.7........61] et tu calcule le reste R de 2n = 2*61 par P > 2 premier et inférieur à racine de 2n et non de n , puisque tu vas calculer les entiers A congru à 2n (mod P) de 1 à 61, que tu marqueras d'un 0; en partant du reste R puis par pas de P ("principe Ératosthène") ; ce qui impliquera obligatoirement les nombres premiers q appartenant à [n ; 2n] .
Un $A\not\equiv{2n}[P]$ implique $B = q $ premier, tel que $2n - A = B = q$ et inversement si :
$A\equiv{2n}[P]$ implique $B\neq{q}$ premier, tel que $2n - A = B = C$ nombre Composé multiple de P
Une fois le principe compris, tu passes directement aux 8 Familles : fam (i) avec $i\in(1,7,11,13,17,19,23,29)$ famille d'entiers A en progression arithmétique de raison 30 et de premier terme (i). ce qui te permet de ne travailler qu'avec une seule famille de nombres premiers de la forme 30k + (i)
en travaillant avec une limite N = 15k par exemple 300 , donc 2N = 600 = 30k
pour les programmes @Yoshi t'expliquera au cas où tu as des questions...moi je ne suis pas Mathématicien...
Tu devrais t"en sortir sans trop de difficulté , c'est quand même de l'arithmétique élémentaire ...
Bon courage
#192 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 21-03-2021 13:15:46
re Yoshi
oui effectivement tu as raison, d'autant que dans le deuxième lien il y a les deux programmes en python qui ont servis à unifier le troisième crible_EG_2N mod 30 avec les explications et qui ont été retranscrit en C++ qui ne lui apporteront rien à part des résultats...
#193 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 21-03-2021 11:50:29
Bonjour
tu peux déjà regarder sur ce lien: forum programmation: http://www.bibmath.net/forums/viewtopic.php?id=13408
tu as trois programmes d'algorithme 2 en C++ et un en python qui indique directement les couples de nombres premiers p+q qui décomposent 2n en somme de deux premiers.
pour ce qui est de l'explication de l'algorithme de Goldbach , du crible qui utilise les congruences suivant le principe d'Ératosthène; tu as ce fichier qui explique très bien le décalage d'un rang des congruences sur leur successeurs, lorsque la limite n augmente de 15.
que ce soit pour la suite des entiers non nuls en partant de 1 ; ou des 8 suite arithmétique de raison 30 et de premier terme $i\in(1,7,11,13,17,19,23,29)$
https://www.cjoint.com/c/KCrizkRjovJ
ou encore :
https://www.cjoint.com/c/KCpkiO5Fs54
où dans les illustrations, les nombres premiers $p'$ sont représenté par des 1 et leurs multiples par des 0 en ce qui concerne le ECrible d'Ératosthène
pour le Gcrible de Goldbach les entiers $A\not\equiv{2n}[P]$ avec $P\leqslant\sqrt{2n}$ sont représentés par des $1$ et les $A$ congruent à $P$ représentés par des 0
tu t'apercevra alors, que les nombres premiers $q$ appartenant à $[n;2n]$ dépendent de la congruence des entiers $A$ de 1 à n,
autrement dit, ils ont pour antécédent un entier $A$ non congrus à 2n modulo $P$.
@Yoshi à quelle discussion tu fais référence ... j'espère que tu te portes bien...@+
#194 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 19-03-2021 11:13:26
Re
Je pense que tu n'as pas compris ce que j'ai voulu te dire
On ne s'occupe pas de regarder les entiers premiers entre eux y compris si $i$ tel que défini, est premier avec 30k c'est une évidence..
Mais de s'intéresser aux nombres premiers de la forme $30k + i$ , car refaire le crible d'Ératosthène ou le formaliser d'une façon plus compliquée n'a pas d'intérêt, pour construire la suite des nombres premiers , qui est le but de ton sujet...
Comprendre l'algorithme que j'ai fait et qui a été programmé par Yoshi n'est pas très difficile de comprendre son principe qu'i est celui d'Ératosthène , mais modulo 30
En définitive on a besoin uniquement des 8 nombres premiers $p$ appartenant à $7;31$ pour extraire la suite des nombres premiers inférieur à une limite n fixée.
selon deux méthodes
A) soit on barre les multiples de p jusqu'à la limite $n$ en utilisant les premiers inférieur à racine de $n$
B) soit on utilise les congruences , et on barre les entiers A inférieur à racine de $n$ est congru à 2n modulo P, mais avec P inférieur à racine de 2n...et on construit au fur et à mesure la suite des nombres premiers...
Bon courage
#195 Re : Café mathématique » Z/nZ;algorithme permettant de construire la suite des nombres premiers » 19-03-2021 08:02:38
Bonjour
Peut être que tu devrais aussi regarder de quelle forme sont les nombres premier $p'\geqslant{7}$ et tu constatera qu'il sont tous de la forme $30k + i $ avec K entier non nul et $i\in(1,7,11,13,17,19,23,29)$ 8 familles de nombres premiers en progression arithmétique de raison 30 et de premier terme $i$ ; on supprime ainsi 2 , 3 et 5 et leurs multiples, qui n'ont plus aucune utilité.
Si un entier $A$ non nul, tel que $A\leqslant{30}$ n'est pas divisible par $P\leqslant\sqrt{30}$ alors il est premier $p'$ Ératosthène, ce qui donne : $7,11,13,17,19,23,29.$
L'algorithme permettant d'extraire tous les nombres premiers de $7\: à\: n$ se trouve sur le forum programmation, ainsi que l'algorithme permettant d'extraire les nombres premiers $q\in{[n ; 2n]}$ de ces 8 familles en criblant toujours jusqu'à la limite $n$ sans avoir besoin de cribler jusqu'à $2n$ "en utilisant les congruences"
Si tu t'intéresses à ces algorithmes ... je pense que @Yoshi pourras t'indiquer les liens.
#196 Re : Entraide (collège-lycée) » Mathématiques » 19-03-2021 07:26:39
1) avant de demander de l'aide on dit Bonjour
2) S = B somme des chiffres de A; le reste R de S par 9 = 5 ; combien valent les autres R ....
#197 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » répartition aléatoire des nombres premiers » 01-03-2021 08:58:09
Bonjour à tous
voici ci joint, un résumé simplifié de mon post ci-dessus , sur la résolution de cette conjecture ...
Pour toute limite $n\geqslant {3}$ fixée , la fonction qui est une conséquence du TNP $\frac{n}{(Ln\;n\; *\;Ln\; 2n)}$ , donne un minimum de solutions p+q = 2n ou 2n+2...etc et ne peut jamais être nulle.
https://www.cjoint.com/c/KHxiZT0RcWW
https://www.cjoint.com/c/KECi6gJ31IB
https://www.cjoint.com/c/KEnnPffujp0
#198 Re : Programmation » Jeux » 26-02-2021 13:10:35
bonjour
Non et toi ???
#199 Re : Programmation » Programmes sous linux debian » 19-02-2021 12:42:43
Bonjour
@Yoshi
je viens de regarder les deux programmes en C++ pour les raccorder :
le programme à été modifié et il fonctionne parfaitement.
@+
#200 Re : Café mathématique » Configuration possible d'un dé a 100 face opposé » 06-02-2021 11:01:39
Je peux déplacer le roi pour protéger les deux pions ,la dame elle faut qu'elle face au moins 3 déplacement pour s'échapper, ca me laisserais assez de temps pour développez une stratégie pour la capturer et améliorer mon retard pour contre attaquer.
Tu plaisantes ....?
La dame ne fait qu'un déplacement pour te remettre en échec....tu ne vois même pas l'évidence ...qu'elle stratégie ???
Et en plus je ne suis pas joueur d'échec...
Bonne continuation ...