Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#226 Re : Programmation » modifier un programme Python » 19-08-2020 13:30:43
@Yoshi , il n'y a pas de faille dans le programme de l'algorithme que tu as fais.
Dans la chaine , en rouge ce sont les multiples de 11, en bleu les multiple de13 pour la Fam(11) . le hic serait dans la modification avec l'absence des multiples de 7...qui pourrait peut être créer un bug, si dans l'exemple cité il ne trouve pas la valeur $1441 + 330 =1771$ pour la remplacer par 0 suite à la modification...
.................................
Mais j'ai besoins des valeur réelles des nombres premiers représenté par des 1 : [11,41,71,101,131,0,191,0,251....etc ]
Fam 11, par exemple avec le programme actuel
crible: [1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0]
A moins qu'à la fin du programme il restitue directement et à la demande les valeurs des 1 , en rajoutant 30k...ce qui peut être est plus facile ...je n'y ait pas pensé.
C'est pour cela que j'ai pensé au départ, à modifier le code du programme et en supprimant les multiples de 7, qui prendrait de la mémoire .
Mais peut être que cela risque de rendre le programme ainsi modifié, plus lent même sans les multiples de 7 ....? Plutôt que de restituer les valeurs des 1 .
Je viens de faire un essais et je pense que c'est inutile; vue le temps qu'il met, rient que pour éditer les 1...
Je pense que python n'est pas fait pour ça et qu'il faut du C++. J'aurai dû commencer par là avant de poser mon problème de modification...
pour N = 600 000 000 Temps total: 586.17 sec -
Pour une base de données de un milliard de nombres premiers.....ça va trainer...
#227 Programmation » modifier un programme Python » 19-08-2020 12:44:34
- LEG
- Réponses : 4
Bonjour
@Yoshi
Tu te rappelles du programme Ératosthène modulo 30 que je reposte ici
from itertools import product
from time import time
from os import system
import math
def candidate_range(n):
cur = 5
incr = 2
while cur < n+1:
yield cur
cur += incr
incr ^= 6 # or incr = 6-incr, or however
def eratostene(n):
n = int(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))
return n
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 remplace 7 par 37####
# 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 et On crible directement à partir de l'index
for idx in range(index, lencrible, a): # index qui est réutilisé ici...
crible[idx] = 0
#print(index)
total = sum(crible) ## à la place on utilise ce tableau d'Ératosthène criblé, pour utiliser ce tableau dans le crible de Goldbacn, on return "crible:", crible
print("crible:", crible)
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 ###on remplacera 7 par 11 de partout où il y a 7###
premiers = eratostene(n)
#print(f"nombres premiers entre 7 et (n**0.5): {len(premiers)}") # nombre de premiers qui criblent
start_time = time()
# On crible
E_Crible(premiers, n, 1) ## pour changer de Fam(i) on remplace la dernière valeur ### ou par (1,11,13,17,19,23,29,37) nouvelle Famille ###
temps = time()-start_time
print(f"--- Temps total: {int(temps*100)/100} sec ---")
main()
system("pause")
1 ) Mon but est de supprimer les multiples de 7 et de commencer à cribler à partir de $P_i = 11$
d'où :
2 ) il me faut les entiers naturels et non leur représentation par 1
# On génère un tableau de N/30 cases rempli de 1
crible = n//30*[1] ## ici ##
lencrible = len(crible)
GM = [11,13,17,19,23,29,31,37]
Mais le problème on va travailler modulo 210 à partir de N > 199
où les 8 Famille commence ainsi :
1 11 13 17 19 23 29 37
31 41 43 47 79 53 59 67
61 71 73 107 109 83 89 97
121 101 103 137 139 113 149 127
151 131 163 167 169 143 179 157
181 191 193 197 199 173 209 187
Puis on progresse modulo 210k
211 221 223 227 229 233 239 247
241 251 253 257 289 263 269 277
271 281 283 317 319 293 299 307
Donc pour la fam(1) on aura 1,31,61,121,151,181,211,241,271,......> N limite fixée.
le debut du programme ne change pas sauf la ligne return on remplace 3 par 4 puisque l'on élimine 2,3,5, et 7
#print(prime_list[4:])
return prime_list[4:]
Ensuite
la partie modifiée que je ne suis pas arrivé à faire fonctionner avec Fam (1) et N = 3000.
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] ### ici ,on a la liste des entiers naturels selon le modèle ci-dessus ###
lencrible = len(crible)
GM = [11,13,17,19,23,29,31,37] ### on a remplacé 7 par 37 ###
# On calcule les produits: j = a * b
for a in premiers:
for b in GM:
j = a * b
if j%30 == fam:
index = j ### ici l'index devient la valeur de J ###
for idx in range(index, lencrible, a): ### ici l'index qui a changé var cribler modulo ($a*30$) à partir de l'index = J ;qui est réutilisé ici...
crible[idx] = 0
il y a un souci : comme on a supprimé les multiple de 7 en criblant ($a*30$) chaque valeur serra remplacé par 0 = multiple de ($a$), il faut sauter cet entier multiple de 7, absent et continuer en rajoutant ($a*30$)
Exemple :$ Fam(11)$ , $N =3000$ , $J = 121$ on crible à partir de $121$, avec $a = 11$ en rajoutant $11*30 = 330$ et on marque les multiple de 11 par 0.
[1,31,61,121,151,181,211,241,271,331,361,391,421,451=0,481 =0,541,571,601,631,661,691,751,781=0,811,841,871=0,901,961,991,1021,1051,1081,1111=0,1171,1201,1231,1261=0,1291....etc ..>$N<3000$ ]
Mais 1441 + 330 =1771 ne peut exister car multiple de 7, donc il faut que le programme , continue et augmente tel que 1771+330 =2101, qui serra marqué 0
Puis on réitère avec j%30 == fam = 13*37 ; on peut cribler en partant de $J = 481$ soit : 481=0 avec le modulo $13*30 = 390$ , puis ensuite directement avec modulo $37*30 = 1110$ ...etc
A la fin on fait la somme des nombres premiers, et on peut sauvegarder les nombres premiers par fichier de 500 000 par exemple...ou les éditer....
#228 Re : Programmation » Comment "aller vers" en Python » 29-06-2020 07:06:08
Bonjour , et désolé de ma réponse tardive : j'étais absent .
C'est exactement ce que je voulais
Concernent le "and len(collatz) <10000000" ? tu as entièrement raison il ne sert à rien, je l'ai supprimé.
c'est impeccable , et je l'ai aussi modifié pour les itérations paires uniquement, pour l'AS2.
while d > 2:
if d%4 == 0:
d = d//2
np[-1] = np[-1] + 1
else:
i = d
d = (3*d+2)//2
np.append(0)
if i == 2:
break
merci
@+
#229 Re : Programmation » Comment "aller vers" en Python » 25-06-2020 05:58:48
Bonjour
@Freddy ou Yoshi
j'ai récupéré ce petit programme en Python mais pas avec le même script que celui de Yoshi que j'ai : l'inconvénient il n'indique pas la durée du vol ni l'altitude j'ai bien essayé avec le script de @Yoshi , mais sans succès ???
l'avantage si on veut imprimer touts les itérations c'est quasiment instantané sur de grands nombres, un peu comme si il faisait une copie collé de la mémoire des itérations; par exemple avec :$ n = i = 2^{63} - 1$
voici le code et les lignes du code de Yoshi , si votre Bonté pouvez faire en sorte qu'il m'indique durée et altitude Maxi.
Avec celui de Yoshi j'ai testé $ n = 2^{337} - 1$ ; pour imprimé ....et ben.... bonsoir la durée, sinon pour les résultats simples il faut 1 à 2 secondes....
Je viens d'essayer par acquis 2^257 - 1 : pour imprimer et ben ..... pas de miracles....... il est aussi long...! on voit juste le début des itérations et ensuite il faut prendre son mal en patience .....Ou faire des copies collés des itérations inférieures .....et la on gagne du temps et ça va très vite sur une douzaine de copies.
1_)
for n in [31,63,213]:
maxi,n0,duree = n,n,1
print("Vol de",n, ":")
while True:
n=n//2 if n%2==0 else 3*n+1
duree, maxi=duree+1,max(n,maxi)
#print (n,end=" ")
if n==2:
print()
break
print ("Altitude maxi :",maxi, "Durée de vol :",duree,"\n")
2_)
def collatz_pour_Raoul(i_prime):
collatz = [i_prime]
d = i_prime
np = [0]
i = i_prime
while d > 1 and len(collatz) < 10000000:
if d%2 == 0:
d = d//2
np[-1] = np[-1] + 1
else:
i = d
d = 3*d+1
np.append(0)
collatz.append(d)
np = np[1:-1]
return collatz,np,i
# c'est ici que tu insères ton i'
i_prime = 1277
c, np, i = collatz_pour_Raoul(i_prime)
print(f"suite de Collatz de {i_prime} :\n\n{c}\n")
D'avance merci @leg
#230 Re : Programmation » Comment "aller vers" en Python » 16-06-2020 08:01:15
Bonjour.
On peut remonter par exemple les nombres premiers de la forme $4k - 1$ certain nombre de Mersenne, par exemple : 8191 ; Mais ça va être coton, même en remontant jusqu'à la valeur paire $6*3^{n-1} \:-2$.
Je pense que cela ne change pas grand chose que les nombres soient premiers ou pas .
Il est dit : que pratiquement les nombres 4k + 1, repassent sous leur valeur de départ .
#231 Re : Programmation » Comment "aller vers" en Python » 14-06-2020 10:25:55
Re Freddy.
je te comprends, je sais que le but est de faire de la programmation...le reste n'a aucune importance, et à part programmer une colonne d'itérations ou plus, en partant de la base -2 , n'apporterait pas grand chose
le pdf n'avait que pour but de montrer la structure arithmétique de Syracuse,qui ne peut avoir des multiples de 3 à partir de la première colonne d'itérations $N_n$ et où, ces colonnes d'itérations, montrent clairement qu'il n'y a rien d'aléatoire dans les vols de Syracuse; puisque en fait ce sont des suites arithmétiques qui progressent dans chaque colonne en partant de l'axe -i = -1, soit 2*-i =-2, -2 -2 ....etc
cette structure est donc parfaitement ordonnée .
Mais ce n'est pas pour autant qu'il serait facile de remonter l'arbre de Syracuse à l'envers, je pense même que le programme doit être très compliquer.
Bonne journée et bonne continuation.
@+
#232 Re : Programmation » Comment "aller vers" en Python » 13-06-2020 19:43:05
Oui mais c'est l'arbre qui cache la forêt ....
voila un peu d'eau pour ""comprendre"" la forêt de Syracuse , et pourquoi il ne peut y avoir de multiple de 3 dans les valeurs des itérations paires.
toutes les colonnes d'itérations sont indexées à partir du vol $i = -1$ , soit pour $2i = -2$ la fonction de Syracuse créait cette structure arithmétique qui est donc cachée par cette fonction.....
Ce qui explique et montre la formule pour calculer la valeur = $6*3^{n-1}\: -\: 2$ au rang $n$ de chaque changement de Transition initié par les vols $i = 2^n -1$.
On peut donc dire que chaque vol $i$ dépend de ses prédécesseurs depuis le vol $i = -1$. Il y a pour moi qu'un seul et unique cycle dans les entiers naturel non nuls.
Un vol successeur qui bouclerait sur une autre boucle que la boucle $4,2,4,2$ dans l'AS2 ou $4,2,1$ dans l'AS1 et par conséquent impossible , le contraire affirmerait que cette structure arithmétique est fausse , ce qui est absurde de part l'existence de ces suites arithmétiques et géométriques ....
voici un petit pdf de l'époque en se promenant vers Syracuse...
https://www.cjoint.com/c/JFrgJfgFQFF
#233 Re : Programmation » Comment "aller vers" en Python » 13-06-2020 17:02:08
Dommage, ils ont oublié de tester le vol $2^{63} - 1$ qui vérifie Syracuse supérieur à celui de T Oliveira et la valeur paire du 63ème itéré vaut :
$6867367640585024969315698178564$ c'est à dire si on compte les impairs masquée par la structure de L'AS2, c'est la valeur du 125ème itéré...
Je pensais qu'ils parlerait de la relation avec les vols des entiers négatifs, ils auraient vue que la structure de Syracuse dépend aussi de cette relation dans les entiers négatifs...avec leur trois cycles .
Bref Syracuse comme Goldbach sont vraie .... foi de Leg ....!
#234 Re : Programmation » Comment "aller vers" en Python » 13-06-2020 12:19:10
voila le pdf
https://www.cjoint.com/c/JFnkBZ1DoiQ
tu sais sur cette conjecture, il y a plein de formule Arithmétique suite à cette structure qui invalide pratiquement la possibilité d'un contre exemple qui affirmerait qu'il existe un entier i qui ne redescende sur le cycle 4,2,1.
la structure arithmétique de Syracuse existe et a été démontrée. quelque soit un vol $i$, il ait toujours relié à deux autres vols d'écart $2^n$ au rang $n$ y compris en prenant les vol $-i$, c'est à dire avec les entiers relatifs négatifs .
Ce qui enlève le côté soit disant aléatoire d'un vol de Syracuse avec sa fonction soit l'AS1 ou l'AS2.
Exemple on est dans l'AS2: je prend la 4ème itération ce qui donne l'exposant 4: rang $n = 4$ pour le vol $i = 2^n \:-1 = 15$ la valeur au rang $4 = 6*3^{n-1} \: - 2 =160$
Tu vas donc relier les deux autres vols $i = -1$ et $i = -17$ selon la formule de "leg" $2*2X - -Y = Z$ au rang $n = 4$.
$(2* -2) -(-164) =160$ valeur du rang 4 pour $i = 15$
Comment veux tu dès lors qu'il existe un vol i = NF , contredisant Syracuse avec sa fonction...Car il est clair, que toutes les itération de ce NF ne peuvent appartenir à un vol vérifiant la conjecture, ni relier deux autres vols i entre eux...Donc il ne peut pas appartenir à cette structure arithmétique...!
Structure qui implique 3 boucles dans les entiers négatifs:
{-4 , -2 } ; {-14,-20,-10} et {-34,-50,-74,-110,164,-82,-122,-182,-272,-136,-68,-34,}.
au lieu d'une seule (4,2,1) dans les positifs .
#235 Re : Programmation » Comment "aller vers" en Python » 13-06-2020 09:53:12
Salut Freddy
concernant les ascensions constantes avec les nombres de Mersenne jusqu'à la valeur de l'exposant , il y a longtemps que cela é été prouvé, il y a même une formule pour connaître la valeur de la dernière ascension constante tel que N%4==0, avant de commencer à redescendre , mais cela n'implique pas que le vol ne peut remonter , pour ensuite repasser sous la valeur de 2n=N
j'ai vue le document de Yoshi à l'époque ...
il y a un bon PDF de J.P Delahaye en 2006 2007.
voila avec n=127 soit N=54 et l'exposant de 2; 7
Vol de 127 :
382 574 862 1294 1942 2914 4372 2186 3280 1640 820 410 616 308 154
Altitude maxi : 4372 Durée de vol : 16
il y a 7 ascension constantes avant que la valeur de N%4==0
la formule de cette valeur au rang 7 est :$(6*3^{7-1})\: – 2 $
pour le vol i =31, tu auras donc la valeur N%4==0 au rang 31 = $(6*3^{31-1}) – 2 = 1235346792567892$ qui était l'altitude maxi de ce vol....
la formule de la valeur paire pour ces vols est ; $(6*3^{n -1})\: – 2$ à l'itération $n$
#236 Re : Programmation » Comment "aller vers" en Python » 13-06-2020 07:23:21
Bonjour
@freddy : Je pense qu'il n'est pas possible de remonter à l'envers.
car si tu essayes de remonter à l'envers ne serait-ce que pour $n=2^{31}-1$ tu n'es pas sortie de l'auberge...pour la programmation...
regarde, avec le crible de @yoshi , où j'ai limité la durée de vol jusqu'à la valeur <= à n0.
en utilisant les nombres de Mersenne $2^P-1$
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Simulation de la suite de syracuse "classique"
for n in [127,2047,8191,131071,524287,8388607,536870911,2147483647]:
maxi,n0,duree = n,n,1
print("Vol de",n, ":")
while True:
n=n//2 if n%2==0 else 3*n+1
duree, maxi=duree+1,max(n,maxi)
print (n,end=" ")
if n<=n0:
print()
break
print ("Altitude maxi :",maxi, "Durée de vol :",duree,"\n")
Vol de 2147483647 :
6442450942 3221225471 9663676414 4831838207 14495514622 7247757311 21743271934 10871635967 32614907902 16307453951 48922361854 24461180927 73383542782 36691771391 110075314174 55037657087 165112971262 82556485631 247669456894 123834728447 371504185342 185752092671 557256278014 278628139007 835884417022 417942208511 1253826625534 626913312767 1880739938302 940369969151 2821109907454 1410554953727 4231664861182 2115832430591 6347497291774 3173748645887 9521245937662 4760622968831 14281868906494 7140934453247 21422803359742 10711401679871 32134205039614 16067102519807 48201307559422 24100653779711 72301961339134 36150980669567 108452942008702 54226471004351 162679413013054 81339706506527 244019119519582 122009559759791 366028679279374 183014339639687 549043018919062 274521509459531 823564528378594 411782264189297 1235346792567892 617673396283946 308836698141973 926510094425920 463255047212960 231627523606480 115813761803240 57906880901620 28953440450810 14476720225405 43430160676216 21715080338108 10857540169054 5428770084527 16286310253582 8143155126791 24429465380374 12214732690187 36644198070562 18322099035281 54966297105844 27483148552922 13741574276461 41224722829384 20612361414692 10306180707346 5153090353673 15459271061020 7729635530510 3864817765255 11594453295766 5797226647883 17391679943650 8695839971825 26087519915476 13043759957738 6521879978869 19565639936608 9782819968304 4891409984152 2445704992076 1222852496038 611426248019 1834278744058 917139372029 2751418116088 1375709058044 687854529022 343927264511 1031781793534 515890896767 1547672690302 773836345151 2321509035454 1160754517727 3482263553182 1741131776591 5223395329774 2611697664887 7835092994662 3917546497331 11752639491994 5876319745997 17628959237992 8814479618996 4407239809498 2203619904749 6610859714248 3305429857124 1652714928562 826357464281 2479072392844 1239536196422 619768098211 1859304294634 929652147317 2788956441952 1394478220976 697239110488 348619555244 174309777622 87154888811 261464666434 130732333217 392196999652 196098499826 98049249913 294147749740 147073874870 73536937435 220610812306 110305406153 330916218460 165458109230 82729054615 248187163846 124093581923 372280745770 186140372885 558421118656 279210559328 139605279664 69802639832 34901319916 17450659958 8725329979 26175989938 13087994969 39263984908 19631992454 9815996227 29447988682 14723994341 44171983024 22085991512 11042995756 5521497878 2760748939 8282246818 4141123409 12423370228 6211685114 3105842557 9317527672 4658763836 2329381918 1164690959
Altitude maxi : 1235346792567892 Durée de vol : 188
les vols avec les nombres de Mersenne ont une ascension constante jusqu'à la valeur du double de l'exposant - 1 . Pour l'exposant 31 tu comptes 61 ascensions constantes, avant de commencer à redescendre; mais tu peux aussi remonter, car parfois, l'altitude maxi se trouve après ce point d'ascension constante.
C'est plus simple avec l'AS2 , en ne calculant qu'avec les nombres pairs....selon la formule avec i un entier impair:
((3*2i)+2)/2 = 2n , si 2n%4 == 0 tu divises par 2 sinon tu réitères soit par ((2n*3)+2)/2 ou par 2n / 2 , car 2n%4 == 0...etc
Normalement il faudrait modifier cette ligne :
while True:
n=n//2 if n%2==0 else 3*n+1
par celle ci, avec N=2n où n est l'entier impair :
N=2n
while True:
N=N//2 if N%4==0 else (3*N+2)//2
mais je pédale dans la choucroute.....pour modifier le reste...., c'est bon.....!!! :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Simulation de la suite de syracuse "classique"
for n in [27,31,127]:
maxi,n0,duree = n,n,1
print("Vol de",n, ":")
N=2*n0
while True:
N=N//2 if N%4==0 else (3*N+2)//2
duree, maxi=duree+1,max(N,maxi)
print (N,end=" ")
if N<=2*n0:
print()
break
print ("Altitude maxi :",maxi, "Durée de vol :",duree,"\n")
========= RESTART: E:\executable algo\CRIBLE_de Syracuse yoshi.py ========
Vol de 27 :
82 124 62 94 142 214 322 484 242 364 182 274 412 206 310 466 700 350 526 790 1186 1780 890 1336 668 334 502 754 1132 566 850 1276 638 958 1438 2158 3238 4858 7288 3644 1822 2734 4102 6154 9232 4616 2308 1154 1732 866 1300 650 976 488 244 122 184 92 46
Altitude maxi : 9232 Durée de vol : 60Vol de 31 :
94 142 214 322 484 242 364 182 274 412 206 310 466 700 350 526 790 1186 1780 890 1336 668 334 502 754 1132 566 850 1276 638 958 1438 2158 3238 4858 7288 3644 1822 2734 4102 6154 9232 4616 2308 1154 1732 866 1300 650 976 488 244 122 184 92 46
Altitude maxi : 9232 Durée de vol : 57Vol de 127 :
382 574 862 1294 1942 2914 4372 2186 3280 1640 820 410 616 308 154
Altitude maxi : 4372 Durée de vol : 16
#237 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 14:29:11
c'est bon...@yoshi.
il faut juste que je change la valeur finale <= n de départ
par exemple: pour n = 17467
je met :
if n<=17460:
break
résultat :
Vol de 17467 :
52402 26201 78604 39302 19651 58954 29477 88432 44216 22108 11054
Altitude maxi : 88432 Durée de vol : 12
#238 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 13:20:47
@yoshi : c'est nouveau, ça vient de sortir.....j'ai abrégé dans ma tête (en supprimant qui à pour reste 2 ou 4) .
Mais je n'arrive toujours pas à modifier ton programme pour que la durée soit <= à n a de départ , au lieu de 1 , donc break .
je n'ai pas réussi ..car ensuite le programme n'arrête plus de calculer 2,1...etc
@freddy : je pense que cela a été prouvé assez facilement...
#239 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 11:25:13
c'était pour répondre à freddy , tous les nombres pairs dans un vol de Syracuse sont congrus à 2 ou 4 modulo 6.
#240 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 11:14:17
ils se terminent sur la branche de l'arbre primitif : S.13 ou S.23
@ Yoshi
Est-ce que tu peux calculer uniquement la durée du vol, lorsqu'au rang N , la valeur passe sous la valeur de départ par conséquent stop .... car cela indique que la conjecture a été vérifiée
#241 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 10:59:50
Re
cela a été essayé de remonter à l'envers en partant de 8 ou 16 , mais n'a jamais rien donné car il y a de multiples branches qui se rattachent à l'arbre primitif
avec 4 cas possibles
1) $3k+1 = 2^n$
2) les multiples de 20 :$3k+1 = 20m$
3) la branche $3k+1 = S.13$ ....> exemple et tel que (13*3)+1 = 40 ;20 ;10 ;5 puis 4.2.1
4) la branche $3k+1 = S.23$ ....> tel que (23*3) +1 = 35,53,160..20,10 ;5 puis 4.2.1
toutes les vols finissent ou se raccordent sur une de ces 4 branches finales ....
tous les vols intermédiaires prendront des valeurs qui ont déjà été testé et par conséquent finiront sur un de ses 4 cas...
"
pour le modulo 6; "si je me rappel" tous les nombres pairs modulo 6 dans une suite de Syracuse sont égal à 4 ou à 2.
#242 Re : Programmation » Comment "aller vers" en Python » 12-06-2020 07:26:53
Re,
Ton truc est bizarre car $3N+2=2(3i+1)$ ... pas encore compris l’intérêt mais bon, ce n’est pas mon projet
A l'époque, cela a permis à J .R , de démontrer la structure arithmétique de Syracuse ; ("qui en fait est une structure très simple qui comprend des suites arithmétiques et géométriques...."). Notamment en montrant que si une deuxième boucle ('" autre que la boucle 4.2.1") existait, elle ne pourrait avoir lieu uniquement, sur la première colonne des têtes de séquence ; une séquence se termine toujours sur un multiple de 4...etc etc. Ce n'est pas ce qui t'importe....
#243 Re : Programmation » Comment "aller vers" en Python » 10-06-2020 12:32:09
re @freddy
N= 2i avec i un entier non nul impair >1
3N+2 ou (3x+1)/2 revient au même si ce n'est que tu exites les impairs lors des itérations.
i = 27 ; 3*27+1 = 82
3N+2 = 164 , qui n'est pas multiple de 4 on continu 164/2= 82 ; (3*82)+2 =124 multiple de 4 fin de séquence donc 124/2 = tête de séquence donc
62...> etc on réitère 94 , 142 , 214 , 322 , 484 multiple de 4 donc tête de séquence
242
etc
bien entendu que le but est ta programmation et non de démonter Syracuse , là tu ne programmes en utilisant que les nombres pairs, par exemple tu peux ne garder que les têtes de séquences, et lorsque la valeur d'une tête de séquence passe sous la valeur N=2i de départ le programme arrête ...
tu peux donc vérifier le nombre de séquences pour chaque entier i, soit N = 2i
exemple:
i = 27 , a 30 séquence avant de redescendre sur 2 , et il repasse sous sa valeur de départ à la 23ème séquence n = 23 : 46 70 106 160 donc le programme doit s'arrêter à la séquence n= 23 etc etc
tu cherchais comment remonter en partant de 2.... Alors, peut être est-ce plus simple avec cette algorithme de Syracuse 2....
@+
#244 Re : Programmation » Comment "aller vers" en Python » 10-06-2020 08:07:08
Bonjour
@Freddy
c'est assez lourd de programmer la conjecture à l'envers et de la remonter...
par contre comme tu sais que si un entier i impair de départ, lors de son itération rencontre un nombre i qui a déjà été testé c'est à dire inférieur à la valeur de départ cela indique que ton i vérifie la conjecture et le programme repart sur i +=2 .
Ou encore en programmant l'AS2.(Algorithme de Syracuse 2)
le principe est plus simple on part de 2i
exemple ("Travaille dû à Jules Rennucci")
Nous allons donner une représentation simplifiée, réduite, de cette suite de la manière suivante :
Soit le nombre pair N = 2i (avec i impair) ex : N= 2*27 = 54
A tout N=2i, pair et non multiple de 4, nous appliquons la transformation : (3*N+2)/2
Si N est multiple de 4 nous passons à N/2qui devient une tête de séquence exemple ligne 1 : avec 124 = 4x donc divisé par 2 donne 62 tête de séquence et on réitère .
lorsque la tête de séquence passe sous la valeur de départ 2i , la conjecture est vérifiée.
Nous désigneront cet algorithme par AS2, AS1 étant l’algorithme classique et bien connu de Syracuse.
Tableau 1 obtenu pour N =2*27 :
n: N=2i
1 : 54 82 124
2 : 62 94 142 214 322 484
3 : 242 364
4 : 182 274 412
5 : 206 310 466 700
6 : 350 526 790 1186 1780
7 : 890 1336
8 : 668
9 : 334 502 754 1132
10 566 850 1276
11 638 958 1438 2158 3238 4858 7288
12 3644
13 1822 2734 4102 6154 9232
14 4616
15 2308
16 1154 1732
17 866 1300
18 650 976
19 488
20 244
21 122 184
22 92
23 46 70 106 160
24 80
25 40
26 20
27 10 16
28 8
29 4
30 2 4
On obtient ainsi, par séquences successives, et dans leur ordre d’apparition, tous les pairs de la suite de Syracuse relative au nombre 27.
Ceci est généralisable à tout nombre 2i (i impair)
Pour 54=2*27, AS2 donne 30 séquences, chaque séquence étant une suite dont le premier terme est moitié du dernier terme de la séquence précédente et dont les termes sont ceux d’une suite de pairs déduits du premier terme par la transformation (3*x+2)/2 et X/2 lorsque X est multiple de 4
Première colonne : Rang de chacune des suites.
De la deuxième à la 8ème colonne : Pairs de la suite générale par la transformation (3*x+2)/2
Nous obtenons tous les pairs successifs et uniquement les pairs du développement (à l’exception de 54) du nombre 27 par l’algorithme classique AS1 appliqué au nombre 27.
Cette procédure est applicable à tout impair (i) et limite la suite de Syracuse à la suite de ses pairs successifs. La suite des pairs pour le nombre 27 comprend 71 termes
Les séquences sont croissantes, finies. Elles se terminent par un multiple de 4 qui est double du premier terme de la tête de séquence n suivante.
Il est à remarquer que les impairs de la suite primitive, bien que masqués, peuvent être dénombrés. En effet chacune des séquences n masque un nombre d’impairs diminué d’une unité par rapport au nombre de pairs.
Ainsi la séquence n = 11, par exemple, compte 7 pairs et masque 6 impairs. Ce qui conduit à proposer la formule :
Nombre de séquences = Nombre de pairs – nombre d’Impairs +1 (S = P-I+1)
….etc
On montre simplement les affirmations suivantes :
Si une boucle doit se produire elle ne peut le faire que sur un terme de la première colonne N des têtes de séquences 2i.
Le premier nombre pair inférieur au premier terme de la suite (54 dans le cas de 27) est nécessairement situé dans la première colonne N=2i (46 dans l’exemple cité)
C’est donc cette colonne qui fera l’objet d’une attention particulière.
Est ce plus facile de programmer à l'envers avec l'AS 2 ....?
Est - ce que tous les nombres pairs 2i seront vérifiés ?
Si il existe un nombre pair N=2i tel que : aucun nombre pair de ses séquences, n'appartient aux séquences itérées de tous les nombres N=2i - 2 testés, alors Syracuse est vraie...! Ce qui est vraie pour l'instant ....
Bon courage ...
#245 Re : Programmation » Comment "aller vers" en Python » 25-05-2020 07:52:24
Bonjour
@Freddy : et si tu parts du principe de jouer un seul numéro, tu as 5000€ à perdre , tu attends 20 tours de roulette avant de jouer ton n° plein , qui n'est pas encore sortie, par exemple le 11.
Ensuite tu commences à miser 1€ , et à chaque tour tu rajoutes un € : 1,2,3, 4.....> soit : (n*(n+1)) / 2 = 5000€ .
Est-ce que tu vas sortir gagnant, ou tu auras perdu tes 5000€ .... Autrement dit, plus tu perds plus tu risque de gagner plus ....?
#246 Re : Programmation » Comment "aller vers" en Python » 15-05-2020 10:27:46
Tu es sûr que ce n'est pas le Bon, la Brute et le Covid.....
#247 Re : Programmation » crible en python » 21-03-2020 13:25:50
Désolé je n'en savais rien , je pensai qu'en fichier W , pour corriger c'était plus simple..aucun souci voici le lien en PDF et je supprime l'autre
https://www.cjoint.com/c/OByklBXrpoj
https://www.cjoint.com/c/NKfghFoR7dN
#248 Re : Programmation » crible en python » 21-03-2020 10:17:51
Bonjour
@Yoshi
Je met le dernier fichier sur la résolution de la conjecture de Goldbach; qui utilise le principe de récurrence de l'algorithme de Goldbach dans les congruences avec un raisonnement par l'absurde qui contredit la possibilité d'une conjecture fausse.
En résumé, quelque soit la limite $2n = 30k +2i$ vérifiée, tel que $2n = P' + q$ alors elle serra vérifiée pour $2n = 30(k+1) + 2i$ par le crible de Goldbach avec une variation négligeable du nombres de couples $P' + q = 2n\geqslant{300}$. "La conjecture étant vérifiée jusqu'à 2n = 300 "
On crible et on vérifie la conjecture avec une seule $Fam(i)$ pour une limite $n = 15k + i\geqslant{150}$ sans perte de généralité.
@+
mise à jours des fichiers :
https://www.cjoint.com/c/OByklBXrpoj
#249 Re : Programmation » Fusion de deux cribles » 18-03-2020 09:48:16
Bonjour
@Yoshi : je vois qu'hier j'ai oublié de répondre à ta question (il faut que je récupère de mon retour du Québec ...encore dans le brouillard)
les deux programmes qui ont été retranscrit en C++ sont brut je suppose que c'est le code source car je les ouvre avec Code:bloc.pour les lancer...
je te les ai fait parvenir hier soir par Mail ...ainsi que ma résolution de la conjecture.
Il y a quand même des fonctions intéressantes au sujet de cet Algorithme de Goldbach ou du dernier programme EG que tu as fais et qui est excellent
par exemple prenons la limite n = 3 000 000 000 avec sa Fam(i) = 7[30] , et la Fam(i) complémentaire = 23[30] le nombre de couple P'+q = 2n de ces deux familles =
Nombres P' non congruent à un élément de $P_{2n}\leqslant\sqrt{2n}$ de 1 à 3000000000 famille 7, ou couple p+q=2n : 2 860 259 -
$\pi(n) = 7[30]$ vaut pour n = 3 000 000 000 : 18 056 145 nombres premiers $P'$
et $\pi(n) = 23[30]$ vaut de n = 3 000 000 000 à 6 000 000 000 : 16 887 276 nombres premiers q
Or la fonction asymptotique du nombre de $P'$ criblé par EG serra toujours inférieur au réel et qui vaut environ : $\frac{\pi(n)}{log\;\pi(n)}$ soit pour ce cas : 1 080 624 couples P'+q = 6 000 000 000 , qui serra bien inférieur au réel , car on ne tient compte dans ce cas précis uniquement des nombres premiers
$P'\in{[7 ; n]}$ qui seront criblé par EG
Alors que le décalage des congruences et par conséquent l'algorithme de Goldbach, tient compte des entiers A de 7 à n, en progression arithmétique de raison 30 qui ne sont pas des nombres premiers , mais qui précèdent des $A$ premiers P' , non congruents à $P\in{P_{2n}}$ ; c'est à dire $2n\not\equiv{A}[P]$
Dont le nombre de $A$ dans cette $fam(7)$ qui vont être criblés vaut : (3000 000 000 /3,75) / 8 = 100 000 000. le résultat de la fonction asymptotique , qui est une conséquence directe du TNP, donne : $\frac {100000000}{Ln\:200000000} = 5 231 814$ de $A$ non congruent à $P$ donc bien supérieur au résultat réel du nombre de couples $P' + q = 2n$ et supérieur bien sûr à la fonction $\frac{\pi(n)}{log\;\pi(n)}$ qui en donne une estimation.
on s'en fou du nombre de nombres premiers $q$ de n à 2n de la Fam(i) = 23[30] puisque l'algorithme indique les $A$ non congruents à $P$ donc $P$ $\in $ $P_{2n}\leqslant\sqrt{2n}$ ne divise pas la différence $2n - A$, qui est donc un nombre premier q suivant la propriété des congruences utilisée par cet algorithme ...
Ou encore par la propriété du crible d'Ératosthène, qui permet d'affirmer que si un nombre B tel que $2n - A = B$ n'est pas divisible par $P\leqslant\sqrt{2n}$
et ben il est premiers q et il est bien dans l'intervalle $[n ; 2n]$ ou je me trompe ?
Mais qui plus est, on put utiliser qu'une seule fam(i) pour trouver le nombre de A = P', non congruent à $P$ qui permet de vérifier la conjecture pour un nombre de couples minimum, $P' + q$ qui décomposent $2n$ en somme de deux premiers ; sans avoir à s'occuper des nombres premiers $q\in{[n ; 2n]}$.
@+
Il y a un autre intérêt avec cet algorithme, c'est de connaître de grands nombres premiers de 500 à 1000 chiffres en criblant les entiers A non congruents modulo $P\leqslant\sqrt{2n}$ cela peu être plus rapide qu'Ératosthène ....peut être....
l'idée on utilise une fam(i) et une limite n=30k pour utiliser n'importe laquelle des 8 fam(i)
par exemple fam(11) ..
on vérifie si $11$ est non congruent modulo P...mais tu vas me dire il y a un paquet de nombres premiers P à vérifier, donc aussi long qu'avec Ératosthène , mais en partant de 11, modulo 30avec un algorithme probabiliste cela va aussi vite voir plus vite qu'avec les nombres de Mersenne car il y a beaucoup plus de couples de nombres premiers P' + q qui vérifie 2n.
je l'ai fait sur le site d'Alpertron en prenant de petit A, non congruents à P que j'ai additionné à $2n = 10^{25} * 30$avec A = 247 on peut aussi soustraire
tel que $2n = 10^{200} * 30 - 247$, puis descendre modulo 30...il ne faut pas attendre longtemps pour trouver de grands nombres premiers...
@+
https://www.cjoint.com/c/JGnldtso4BX
https://www.cjoint.com/c/JGnlbR22XiX
#250 Re : Programmation » Fusion de deux cribles » 17-03-2020 13:34:00
ok tu as raison, j'étais avec l'idée de voir le nombre de couples P+q = 2n aux alentour de 400 000 000 000 faire 5 à 6 tests en augmentant la limite n par itération de 15, afin de regarder le comportement et la variation du nombre de couples
Mais effectivement cela ne changera pas grand chose si je le fais à partir de 27 000 000 000 sur trois fam(i) différente en augmentant de 15 sur 6 tests différents
quant à la démonstration elle utilise la récurrence du crible et l'absurde
paragraphe au point 6a et la suite..que je peux t'envoyer...