Bon, je vais essayer d'éclaircir les choses. On considère la suite impaire de Collatz dont les termes sont n0, n1, n2, n3, n4, n5 et les diviseurs successifs d1, d2, d3, d4, d5, donc une suite impaire de 6 termes. Or, il se trouve que lorsqu'on remplace les divers symboles de l'expression de n5, le dernier terme, par des valeurs numériques (pertinentes bien sûr) on obtient toujours 1, ce qui signifie que ce dernier terme est toujours égal à 1 (voir images plus bas). Il n'y a là aucune invention de ma part, ni magie, c'est tout simplement la valeur que donne le calcul !
Mon algorithme tente de comprendre ce phénomène en le reproduisant : se basant sur la valeur de n0 il calcule par récurrence n1, n2, n3, etc., et lorsqu'il arrive à n5 il prend fin parce que la condition de la boucle while cesse d'être vraie : la somme représentant le numérateur est maintenant égale au produit représentant le dénominateur, et non plus différente, ce qui prouve que n5 est effectivement égal à 1.
Il y a une chose importante à comprendre dans la fonction sommeEgale() : ce qui importe n'est pas ce qu'elle renvoie mais de sortir de la boucle while. Si vous faites sommeEgale(n) et que plusieurs secondes après la fonction n'a toujours rien renvoyé, ça veut dire qu'à aucune étape la variable
somme n'est devenue égale à la variable
div : la boucle while tourne indéfiniment parce qu'elle ne rencontre jamais les conditions de sa sortie, et la fonction ne peut rien renvoyer. On peut en déduire que
n n'a pas passé le test, autrement dit que la suite de Collatz de
n ne se termine pas par 1. A mon avis ce cas n'a aucune chance de se produire. De ce fait, on peut demander à sommeEgale() de renvoyer ce qu'on veut, "tartampion" par exemple. Je le répète, la sortie de la boucle while est l'unique chose qui importe pour que
n soit déclaré avoir passé le test.
A partir de là on peut procéder très rapidement au test d'un grand nombre d'entiers impairs. Il suffit de transformer la dernière ligne de la fonction, {div, rangee*listeP3}, en commentaire, de manière à ce qu'elle ne soit plus prise en compte et surtout que vous ne la perdiez pas. Puis en-dessous vous mettez le chiffre 1. Maintenant sommeEgale(n) va renvoyer 1 si
n passe le test et ... rien du tout s'il ne le passe pas. Mais on peut aller encore plus vite en exécutant l'instruction suivante (syntaxe Mathematica) :
Table[sommeEgale(n), {n,3,999,2}]
Ceci va générer une liste des valeurs de sommeEgale() pour tous les entiers de 3 à 999 par incrément de 2, c'est-à-dire les 499 premiers entiers impairs, liste qui sera composée de 499 chiffres 1. Il sera parfaitement inutile de vérifier si elle ne contient bien que des 1, parce que ce sera soit une liste de 1 soit aucune liste (cas où l'une des valeurs de
n ne passerait pas le test).
Je viens de faire ce test pour les entiers impairs de 3 à 9999, et la fonction m'a renvoyé une liste de 4999 chiffres 1, donc tous l'ont passé. Attention cependant : cet algorithme manipule des nombres qui peuvent être énormes ! Il vaut donc mieux disposer d'un processeur performant et d'une quantité suffisante de mémoire, mais également limiter la fourchette du test. Je pense que les très grands nombres impairs ne pourraient pas être testés sur un PC ; il faudrait un gros ordinateur, comme ceux de la météo ou de la NASA.
Il semble en conséquence, au moins pour les 4999 premiers entiers impairs, que l'expression du dernier terme d'une suite, c'est-à-dire la dernière division d'une somme par un produit de diviseurs, soit bien égale à 1, puisque l'algorithme reproduit cette expression. Maintenant, on peut toujours essayer de le démontrer formellement. Voici les expressions que l'algorithme calcule par récurrence pour une valeur de n0 telle que sa suite impaire comporte 6 termes (C = 3n0+1):
Ces expressions représentent n1, n2, n3, n4 et n5. Le dernier terme, n5 dans cet exemple, est (semble-t-il) toujours égal à 1 :
C'est ce qu'il faut démontrer. Je précise que si
N est le nombre de termes d'une suite impaire, alors celle-ci compte
N-1 diviseurs.
Bon courage !