Transformation continue d'une liste d'expos.

Ce fil fait suite à ce post de Serge Burckel dans lequel il proposait un algorithme équivalent à celui de Collatz mais dont le principe de fonctionnement est entièrement différent. Rappel :

$S$ est l'ensemble des exposants issus de la décomposition de $n$ en base 2, où $n$ est un entier positif impair (le $n_0$ d'une suite de Collatz). On entre ensuite dans la boucle suivante :

while length($S$) $>1$ {
$\quad S=S\cup S^+\cup $ {min($S$)}
$\quad$Supprimer les doublons de $S$
}

En sortie on obtient une valeur de $S$ de longueur 1. Pour $n=55$, $S=\{0,1,2,4,5\}$. Le résultat de la première itération sera $S=\{0,1,2,4,5,1,2,3,5,6,0\}$ suivi de $\{1,2,5,7\}$ après suppression des doublons. Si – après avoir soustrait min($S$) de tous ses termes (réduction de $S$) – on calcule la somme des puissances de 2 dont les exposants appartiennent à $S$, on obtient 83, le successeur impair de 55 dans une suite de Collatz. Aboutir à un ensemble de 1 élément revient à atteindre le 1 final, ceci dans le même nombre d'étapes.

Le problème avec ces deux algorithmes est qu'une fois $n$ ou $S$ obtenus on les transforme en quelque chose d'entièrement différent par le calcul de $3\,n+1$ ou $S=S\,\cup\,...$, si bien que le lien disparaît entre leur valeur initiale et celle qui est la leur à une étape quelconque du processus. Si on ne peut pas éviter le passage par $3\,n+1$ on peut néanmoins éliminer $S=S\,\cup\,...$ et rendre ainsi ce processus continu, puisqu'on partira de l'état initial de $S$ pour parvenir à un ensemble de 1 élément sans le transformer autrement qu'en lui appliquant les quelques règles énoncées plus bas. Ces règles ont bien entendu sur $S$ le même impact que si on avait appliqué $S=S\,\cup\,...$ suivi de la suppression des doublons. La différence est qu'elles ne le transforment pas radicalement mais modifient progressivement le nombre et la valeur de ses termes.

L'approche ensembliste n'ayant plus d'utilité, $S$ sera dorénavant une liste d'exposants, notée $[a,b,c,...]$, tous distincts et disposés par ordre croissant, si bien que $a$ est son minimum. Étant donné que $n$ est par définition impair, $a$ sera toujours égal à 0. Avec l'algorithme originel on aurait commencé par supprimer deux doublons (voir règle 3) : $\{0,...,1,...,0\}$ devient $\{1,...,1,...\}$ puis $\{2,...\}$. On remplacera donc toujours le 0 de $S$ par 2. Dans ce qui suit, le minimum de $S$ sera nommé $m$.

Un algorithme en charge de cette transformation procèderait par passes successives.

Règles, par ordre de plus haute priorité. Important : les règles 1 et 2 ne tiennent pas compte de $m$ :
  1. Lorsque l'intervalle entre deux ou plusieurs termes consécutifs est $1$ on les transforme comme suit :
    $[a,b] \to [a,b+2]$
    $[a,b,c] \to [a,b+1,c+2]$
    $[a,b,c,d] \to [a,b+1,c+1,d+2]$
    $[a,b,c,d,e] \to [a,b+1,c+1,d+1,e+2]$
    $\text{etc.}$
  2. Lorsque l'intervalle entre deux ou plusieurs termes consécutifs est $>1$, ou lorsqu'un terme est isolé, on en crée une copie incrémentée. Par exemple, $[...,3,6,...]$ devient $[...,3,4,6,7,...]$ ; ou encore, $[m,5]$ devient $[m,5,6]$ parce que 5 est isolé.
  3. Faire $m=m+2$. Si min($S$) est maintenant en seconde position, inverser les deux premiers termes de la liste.
  4. Lorsque deux termes sont égaux (doublon) on les remplace par un seul incrémenté. Par exemple, $[a,...a,...]$ devient $[...,a+1,...]$ (on supprime le premier et on incrémente le second).
Remarques :
  • Si les règles 1 et 2 s'appliquent toutes deux, la règle 2 opère indépendamment de la règle 1, c'est-à-dire sans tenir compte de ce qu'elle a produit.
  • La règle 4 opère sur ce qu'ont produit les règles précédentes. Elle seule prend $m$ en compte.
  • Mode opératoire avec l'exemple de $[0,3,4,6,8]$ :
    1. Identification des règles à appliquer sans prise en compte de $m$ : la règle 1 s'applique à 3,4 et la règle 2 à 6,8.
    2. $[0,3,6,6,8]$ Règle 1.
      $[0,3,6,6,7,8,9]$ Règle 2.
      $[2,3,6,6,7,8,9]$ Règle 3.
      $[2,3,10]$ Règle 4 sur 6,6 puis 7,7 etc.
Exemple de processus complet. $n=57$ est représenté par $[0,3,4,5]$. Une liste indentée signifie qu'on reprend les règles depuis le début, toutes les règles applicables à une valeur donnée de $S$ l'ayant été :

$[0,3,4,5]$
$[0,3,5,7]$ Règle 1 sur 3,4,5.
$[2,3,5,7]$ Règle 3.
$\;[2,3,4,5,6,7,8]$ Règle 2 sur 3,5,7.
$[3,4,4,5,6,7,8]$ Règle 3 et inversion de 4,3 (le nouveau $m$ est 3 et doit être en première position).
$[3,9]$ Règle 4 sur 4,4 puis sur les doublons créés.
$\;[3,9,10]$ Règle 2 sur 9.
$[5,9,10]$ Règle 3.
$\;[5,9,12]$ Règle 1 sur 9,10.
$[7,9,12]$ Règle 3.
$\;[7,9,10,12,13]$ Règle 2 sur 9,12.
$[9,9,10,12,13]$ Règle 3.
$[11,12,13]$ Règle 4 sur 9,9 puis 10,10.
$\;[11,12,15]$ Règle 1 sur 12,13.
$[12,13,15]$ Règle 3 et inversion de 13,12.
$\;[12,13,14,15,16]$ Règle 2 sur 12,15.
$[13,14,14,15,16]$ Règle 3 et inversion de 14,13.
$[13,17]$ Règle 4 sur 14,14 puis sur les doublons créés.
$\;[13,17,18]$ Règle 2 sur 17.
$[15,17,18]$ Règle 3.
$\;[15,17,20]$ Règle 1 sur 17,18.
$[17,17,20]$ Règle 3.
$[18,20]$ Règle 4 sur 17,17.
$\;[18,20,21]$ Règle 2 sur 20.
$[20,20,21]$ Règle 3.
$[22]$ Règle 4 sur 20,20 puis 21,21. Liste de 1 élément. Fin.

Lorsqu'on réduit chaque valeur de $S$ précédent l'indentation et qu'on calcule la somme des puissances de 2 correspondantes, on obtient la suite impaire de Collatz de 57. A noter que $[22]$ réduit donne $[0]$, c'est-à-dire $2^0=1$.

Cet algorithme et celui de Collatz étant étroitement liés, démontrer que la transformation continue de $S$ aboutit toujours à une liste de 1 élément reviendrait à démontrer la conjecture de Collatz.

EDIT : message modifié 3 semaines plus tard car l'ordre des règles avait changé.

Réponses

  • L'attaque du problème par l'écriture binaire a déjà été tentée, sans espoir de la moindre avancée.
  • @nodgim,

    Ta réponse démontre que tu n'as lu que le titre (tronqué, certes, mais compréhensible). Qu'aurais-tu répondu si au lieu de "liste d'exposants" j'avais écrit "liste aléatoire d'entiers naturels" ?

    Il faut bien comprendre que le concept de liste d'exposants n'a de sens que dans un contexte particulier, celui des suites de Collatz par exemple. La transformation s'applique à toute liste triée d'entiers naturels, peu importe qu'il s'agisse d'exposants ou du nombre de bébés nés en 24 h dans les maternités des Yvelines.

    Prenons $S=[1,2,3]$. Il existe deux manières d'interpréter cette liste :
    1. $N=2^1+2^2+2^3=14$, pair, ce qui ne convient pas puisqu'on s'occupe de valeurs impaires de $N$.
    2. On calcule $N$ après avoir réduit $S$, ce qui signifie soustraire son minimum de tous ses termes. Dans ce cas, $N=2^0+2^1+2^2=7$.
    Quelle que soit la liste, si on la réduit on aura toujours $N$ impair. Mais cette réduction n'aura lieu que si on a besoin de la valeur de $N$ à chaque étape du processus. La transformation elle-même s'applique à la liste en l'état, sans s'occuper de savoir à quelle valeur de $N$ elle correspond.
  • Je ne sais pas ce que je n'ai pas compris, j'ai cru comprendre qu'il y avait là la technique de calcul du terme suivant en travaillant en base 2. Je connais bien cette technique là, mais à quoi ça peut bien avancer ?
    Sinon, c'est amusant. Pour 27, ça donne ça :

    11011
    0100101
    00011111
    0000111101
    000001110001
    0000001101011
    ........

    Quand on est un peu entraîné, on n'a pas à réfléchir pour écrire la ligne suivante.

    Mais, hélas, ça ne fait pas avancer d'un pouce la conjecture.
  • Aucun rapport entre les deux approches.
    nodgim a écrit:
    j'ai cru comprendre qu'il y avait là la technique de calcul du terme suivant en travaillant en base 2

    C'est bien ce que pensais : tu fais une fixation sur la base 2. Je vais donc réexpliquer ce qu'à mon avis tu ne comprends pas.

    Je génère aléatoirement la liste de nombres $[3,4,7,9,10]$. En l'état elle ne signifie strictement rien, je pourrais l'avoir créée pour un tas de raisons différentes, et c'est justement l'usage que je compte en faire qui lui donne un sens particulier. Je décide de l'utiliser pour tester la transformation continue dont il est question sur ce fil, et comme je m'y attendais j'obtiens une liste de 1 élément, ce qui peut être considéré comme une curiosité mathématique.

    C'est uniquement lorsque je décide d'associer cette liste à une valeur de $n$, en l'occurrence 841, que je m'aperçois d'une chose étonnante : le même processus de transformation recrée la suite de Collatz de 841 ! Bon, ça s'explique (voir mon premier message) mais ce n'est pas ce qui nous intéresse ici.

    Considérer cette liste de nombres comme une liste d'exposants a relevé d'un choix, et le résultat de sa transformation a été interprété en fonction de ce choix. Rien à voir avec une approche binaire.
  • Ben....pourtant, je suis ce que tu as fait, et je fais la même chose en....binaire.

    (0,3,4,5) = 100111

    100111
    00110101
    0001000001
    00000100011
    0000000101001
    00000000000111
    0000000000001101
    000000000000010001
    0000000000000001011
    000000000000000000101
    00000000000000000000001

    reste 1 au rang (22)

    Après, on peut l'appeler comme tu veux, en tout cas ça ressemble beaucoup à du binaire !

    Disons que j'arrive au même résultat ( et aux mêmes nombres intermédiaires ) en écriture binaire. Il y a équivalence.
  • La liste $[0,3,4,5]$ correspond à $2^0+2^3+2^4+2^5=57$, dont la représentation binaire est $111001_2$. Toi tu mets le bit de poids faible à gauche. Mais c'est un détail.

    Si on inverse tes nombres binaires et qu'on les convertit en base 10, on obtient tout simplement la suite impaire de 57, c'est-à-dire 57, 43, 65, 49, etc. Un peu facile, non ?

    Pourrais-tu expliquer ce que tu entends par "je fais la même chose [que toi]" ?
  • Poids fort à droite : Normal, l'algorithme se déploie à partir du poids faible. C'est plus facile à présenter avec un alignement à gauche.

    J'ai cru comprendre que tes règles permettent de passer d'une étape à l'autre, c'est à dire tout bêtement de calculer le nombre suivant, tout ça en binaire. C'est ce que je fais également. Bien entendu, rien ne me permet d'affirmer qu'on aboutit forcément à 1. L'intérêt de la présentation en binaire aurait pu être de faire apparaître une propriété qui serait masquée en décimal. Perso, je n'ai remarqué de particulier.
  • nodgim a écrit:
    Poids fort à droite : Normal, l'algorithme se déploie à partir du poids faible. C'est plus facile à présenter avec un alignement à gauche.

    Si le minimum de $S$ se trouve à gauche c'est uniquement parce que les règles 1 et 2 se fondent sur l'intervalle entre ses termes (ou différences de valeurs), et que de ce fait la liste a tout intérêt à être triée au départ et maintenue triée tout au long du processus. Il ne s'agit aucunement de la position du bit de poids faible.

    Le seul intérêt de la représentation de la liste sous forme binaire est que les intervalles en question apparaissent clairement. Par exemple, écrire $[0,3,4,5]$ sous la forme 100111 permet de voir immédiatement qu'il existe un groupe de trois nombres séparés d'une unité. C'est probablement ce que tu entends par "propriété qui serait masquée en décimal". C'est le seul lien qu'en ce qui me concerne je pourrais trouver entre cet algorithme et une approche binaire. Pour le reste, tu n'as toujours pas explicité la méthode qui permet de "faire la même chose en binaire". Comment construis-tu la représentation binaire suivante ? Question subsidiaire : comment représentes-tu $[9,9,12]$ ou $[13,12,13]$ en binaire (voir l'exemple de mon premier message) ?
    J'ai cru comprendre que tes règles permettent de passer d'une étape à l'autre, c'est à dire tout bêtement de calculer le nombre suivant, tout ça en binaire.

    Au risque de me répéter, "passer au nombre suivant" implique que la liste de nombres est interprétée comme une liste d'exposants en lien avec une suite de Collatz. Si tu te débarrasses de cette approche tu comprendras que l'algorithme s'applique avant tout à une liste triée d'entiers naturels quelconques. Il ne s'agit pas de calculer le terme suivant mais d'appliquer à cette liste 4 règles de transformation, ce qui, jusqu'à preuve du contraire, aboutira invariablement à une liste de 1 terme. Si tu intégrais ce fait tu orienterais tes efforts vers la compréhension de ce mécanisme, en vue de sa démonstration, au lieu de perdre ton temps à lui trouver une relation avec sa représentation en base 2, d'autant plus que, comme tu l'as souligné, aucune approche de cette sorte n'a jamais abouti.

    Il y a un autre aspect des choses qui mérite d'être souligné (j'en ai déjà parlé mais il est important de le répéter) : l'algorithme de Collatz – mais ça concerne aussi celui de Serge – transforme le nombre de départ à l'aide de deux opérations distinctes : $3\,n+1$, puis divisions par 2. Le résultat est que ce nombre est constamment "réinitialisé". A l'inverse, si j'ai nommé "continu" l'algorithme dont il est question ici c'est parce qu'il réorganise encore et encore la même liste, sans la transformer en autre chose avant de poursuivre, un peu comme si l'algorithme de Collatz consistait à appliquer sans cesse $3\,n+1$ au même nombre, ou à le diviser constamment par 2.

    Ce que je veux dire est que si tu tiens absolument à l'approche binaire il faudra que tu t'arranges pour conserver le caractère continu du processus que tu mettras en place. Si tu ne le fais pas ce sera une énième imitation de l'algorithme de Collatz, et tu n'aboutiras à rien. C'est la raison pour laquelle je t'ai demandé comment tu fais "la même chose en binaire". Par exemple, comment passes-tu de 11011 à 0100101 puis à 00011111 ?
  • Wilfrid a écrit:
    la liste a tout intérêt à être triée au départ et maintenue triée tout au long du processus.

    Rectificatif : supposons que la liste soit $[m,a,b,c]$, où $m$ est son minimum. Ce qui doit demeurer trié est seulement $a,b,c$. Le seul cas identifié jusqu'à présent où il faut veiller à ce que la liste soit ordonnée est lorsque $m$ est en double et qu'il disparaît : il est alors remplacé par le nouveau minimum. Ceci arrive lorsque le début de la liste se présente comme ceci : $[m,m-x,m,...]$, $x>0$, qui devient $[m+1,m-x,...]$. Le nouveau minimum est alors $m-x$, qu'il faut placer en première position.
  • La technique du " 3n+1 " appliquée à un nombre binaire obéit à quelques règles simples, pour peu qu'on imagine des jetons dans des cases ( un jeton est un 1 ).

    - le 1er jeton à gauche est déplacé de 2 cases vers la droite. S'il existe 1 jeton intermédiaire, ou plusieurs consécutifs, alors le 1er jeton à gauche saute au dessus du groupe et atterrit 2 cases après le dernier jeton du groupe. Si, en plus, la case où il atterrit est occupée par un autre jeton, celui-ci est détruit et le 1er jeton " rebondit " et continue sa course en suivant la même règle.

    - Pour les autres jetons, de la gauche vers la droite : si un jeton est isolé, on lui en ajoute 1 juste à sa droite. S'il y a 2 jetons consécutifs isolés, le second est envoyé 2 cases plus loin, son déplacement suivant alors la même règle que le 1er jeton. Pour un groupe de plus de 2 jetons, c'est le second du groupe qu'on déplace ( toujours vers la droite ) en suivant encore la même règle de déplacement.

    C'est amusant, mais bon ça ne mène pas loin.

    Cela dit, je ne suis pas du tout convaincu que ton approche prouve qu'on aboutit nécessairement à un 1 final.
  • La méthode proposée par Serge est plus simple : si $n$ est représenté par $\{a,b,c\}$, $3\,n+1$ l'est par $\{a,b,c,a+1,b+1,c+1,a\}$. Pour reprendre l'exemple de $\{0,3,4,5\}$, qui correspond à 57, $\{0,3,4,5,1,4,5,6,0\}$ correspond à $3 \times 57+1 = 172$. Après avoir supprimé les doublons on obtient $\{2,3,5,7\}$, et $2^2+2^3+2^5+2^7=172$.
    je ne suis pas du tout convaincu que ton approche prouve qu'on aboutit nécessairement à un 1 final.

    Le 1 final ne concerne que les suites de Collatz. La transformation continue aboutit à une liste de 1 élément, qui une fois réduite devient $[0]$, c'est-à-dire $2^0=1$. Mais effectivement, rien ne prouve qu'on aboutit toujours à une telle liste. Du moins pour l'instant.
  • Un petite remarque : puisque les règles 1 et 2 se fondent non pas sur la valeur des termes de la liste mais sur leurs différences (que j'ai nommées intervalles plus haut), la liste $[0,1,4,5]$ se transformera exactement de la même manière que la liste $[10,11,14,15]$, et dans le même nombre de passes. De ce point de vue, la liste $[m,a,b,c]$ est strictement identique à la liste $[m+x,a+x,b+x,c+x]$. Par conséquent, si on part d'une liste d'entiers naturels aléatoires on commencera par la réduire et la trier avant d'entamer sa transformation. Une liste débutant par 0 n'est pas un cas particulier mais plutôt le cas général.

    Pour conserver la nature continue de cette transformation il faut éviter d'avoir à trier la liste à nouveau. Les règles 1 et 2 ne perturbent pas l'ordre croissant des termes. Prenons la liste triée $[m,a,b,c]$. Trois cas se présentent :
    1. $[m,a,b,c]=[m,a,a+1,a+3]$. La règle 1 s'applique à ($a,b$) et la règle 2 à $c$, ce qui donne $[m,a,a+3,a+3,a+4]$, puis, une fois les doublons supprimés, $[m,a,a+5]$. Si $c$ avait été égal à $b+1$ la règle 1 se serait appliquée à ($a,b,c$). L'écart minimal entre $b$ et $c$ ne pouvait être que 2.
    2. $[m,a,b,c]=[m,a,a+2,a+3]$, auquel cas la règle 1 s'applique à ($b,c$) et la règle 2 à $a$, ce qui donne $[m,a,a+1,a+2,a+5]$
    3. $[m,a,b,c]=[m,a,a+2,a+4]$, la règle 2 s'appliquant alors aux trois termes, ce qui donne $[m,a,a+1,a+2,a+3,a+4,a+5]$.
    Dans les trois cas la liste demeure triée. On notera en passant que seul le cas 1 a provoqué l'apparition d'un doublon.

    Ce qui peut perturber l'ordre des termes se situe selon moi au niveau de $[m,a,b,...]$, peut-être même seulement de $[m,a,...]$. Si un tri est nécessaire à une étape du processus il ne peut porter que sur les deux ou trois premiers termes. En fait, après application de la règle 4 il s'agira probablement de s'assurer que le minimum est toujours au début de la liste, et s'il n'y est pas de l'y transférer.

    Enfin, la question à un million : les écarts entre les termes de la liste originelle et le nombre de passes nécessaires pour parvenir à $[x]$ sont-ils corrélés ? Probablement que oui. Si c'est le cas ça devrait permettre, sinon de démontrer la conjecture, du moins de parvenir à une bonne estimation de la longueur d'une suite de Collatz.
  • L'algorithme suivant traite les règles 1 et 2 en même temps, et surtout, il évite d'avoir à identifier les termes isolés et les groupes de termes séparés d'une unité.
    S = [0, ...]	// Représente n impair > 1
    Remplacer le 0 par 2
    L = length(S) - 1
    b = false
    
    while L > 1
    {
    	if (S[L] - S[L-1] == 1) {
    		if (b) S[L] += 1 else S[L] += 2
    		b = true
    	} else {
    		if (! b) insérer S[L]+1 après S[L]
    		b = false
    	}
    	L--
    }
    if (! b) insérer S[1]+1 après S[1]
    
    Suppression des éventuels doublons : supprimer la première occurrence et incrémenter la seconde (pour conserver le tri).
    S'assurer que min(S) est en 1ère position (voir si on peut éviter ça).
    Afficher S
    
    Exemples :

    [0,2,3,7,8,11,12] --> [2,2,5,7,10,11,14] --> [3,5,7,10,11,14]
    [0,1,5,6,7,8,10] --> [2,1,2,5,7,8,10,10,11] --> [1,3,5,7,8,12]

    Si on réduit la sortie et qu'on calcule la somme des puissances de 2 dont les exposants figurent dans $S$, on obtient le successeur impair de $n$ (représenté par la valeur initiale de $S$) dans une suite de Collatz, sans avoir à calculer $3\,n+1$ suivi de divisions par 2. Pour reprendre le premier exemple, [0,2,3,7,8,11,12] représente n = 6541, dont le successeur 2453 est représenté par [3,5,7,10,11,14]. Je rappelle que $n>1$ (la longueur minimale de $S$ doit être 2).

    Test :

    Vous pouvez ouvrir Try It Online et coller le code JavaScript suivant dans le champ Code, remplacer le contenu de la variable S par ce que vous voulez, et cliquer sur le bouton Play (ou Run, en haut). Le résultat apparaît dans le champ Output. Pour éviter de compliquer, les doublons ne sont pas supprimés :
    var S = [0,3,5,6,7,11,12], L = S.length - 1, b = false;
    S[0] += 2; // On suppose que min(S) est en 1ère position
    
    while (L > 1)
    {
    	if (S[L] - S[L-1] == 1) {
    		if (b) S[L] += 1; else S[L] += 2;
    		b = true
    	} else {
    		if (! b) S.splice(L+1, 0, S[L]+1);
    		b = false
    	}
    	L--
    }
    if (! b) S.splice(2, 0, S[1]+1);
    
    console.log(S);
    
    Doublons :

    Les doublons qu'on doit supprimer sont ceux qu'on a créés. Par exemple, [..., 3,4,6,7, ...] devient [..., 3,6,6,8, ...]. Au lieu de faire S[L] += 2, avec L pointant sur 4, on pourrait très bien envisager de supprimer S[L] puis faire S[L] += 1 (son successeur prend sa place) si S[L+1] = S[L] + 2. On réduirait le nombre de doublons mais ça ne veut pas dire qu'on les supprimerait tous.
  • Les sauts de puce sont en effet possibles, on peut en fait compacter autant d'étapes qu'on veut. Mais l'intérêt est assez limité.

    Si on écrit un nombre en binaire, les k derniers chiffres poids faible ( le dernier bit toujours à 1 ) peuvent être traités globalement et indépendamment du reste, pour donner un nombre binaire qui sera ajouté au nombre initial amputé de ses k derniers chiffres. Mais je ne crois pas que l'informatique y gagne en temps de calcul.
Connectez-vous ou Inscrivez-vous pour répondre.