Un tour en orbite autour de l'arbre de Collatz - Page 8 — Les-mathematiques.net The most powerful custom community solution in the world

Un tour en orbite autour de l'arbre de Collatz

1234568

Réponses

  • Comme il pleut tout ce que ça peut ce dimanche, autant avancer un peu.

    Je refais donc un mini résumé et je repose mon objectif.

    En attribuant un code de lignée aux entiers présents dans un arbre de Collatz, on définit leur descendance. Si x.y.z est un code de lignée, cela veut dire que z a pour parent y et y pour parent x. De même selon leurs valeurs, z sera le Zème descendant de y et y le Yème descendant de x. Il suffit pour connaitre z ou y de faire l'arrondi supérieur de la moitié du nombre d'étapes paires entre chaque impair de leur suite.
    Quant à x le premier membre, sa valeur indique de quel 2^n il est extrait, sachant que x=1 correspond à (2^4-1)/3 = 5. 
    Il n'y a pas de limite à la longueur d'un code de lignée, ni à la valeur de ces membres.

    Un arbre de Collatz de n orbites est d'abord correctement construit si les n orbites sont calculées depuis la 1ère et à chaque fois pour tous leurs termes.

    Puis on attribue à tous les impairs de l'arbre un code de lignée. Cela permet d'obtenir un nouvel arbre ordonné par famille de code de lignée. Une famille pour un code de longueur 3 commence par le premier descendant x.y.1. qui est suivi des autres descendants dans leur ordre d'apparition. 

    Le tableau ci-dessous montre les 17 impairs d'un arbre de 14 orbites et leurs codes de lignée :



    On peut déduire de cet arbre de Collatz réordonné que l'on peut calculer le nième membre d'une famille selon une valeur d'orbite visée.
    Par exemple on trouve 1.2.1 en 8ème ligne. En visant l'orbite 33, le calcul donne 1.2.11. correspondant à (13*2^(2*11)-1)/3 = 18175317. 13 est obtenu en calculant quel est le parent de cette famille depuis les infos du code de lignée. La formule prend aussi en compte que 1.2.1. se trouve en 8ème ligne.
    La façon d'implanter ce calcul dans un tableur Excel est ici :
     https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2340025#Comment_2340025

    Par contre il faut bien comprendre que seuls les descendants directs de tous les premiers descendants trouvés peuvent être calculés. Dans un arbre de 34 orbites, on trouve 705 premiers descendants dans l'ensemble de 1878 impairs de l'arbre. Comme les orbites contiennent vite des milliards d'impairs, c'est une toute petite proportion d'entre eux qui peut être estimée ainsi. 

    Mon objectif est de construire directement un arbre avec des codes de lignée sans recourir à l'algorithme. Pour cela, je dois établir des règles qui vont positionner au bon endroit le code de lignée d'un premier descendant (ce qui permet de placer tous les suivants) et savoir déterminer si un code de lignée est fertile ou stérile.

    En transformant chaque code de lignée par l'indication d'état suivante :
    IF : le code de lignée se trouve sur une orbite impaire et il est fertile
    IS : le code de lignée se trouve sur une orbite impaire et il est stérile
    PF : le code de lignée se trouve sur une orbite paire et il est fertile
    PS : le code de lignée se trouve sur une orbite paire et il est stérile

    On obtient un tableau de ce type :


    Il apparait clairement que des cycles IF_IF_IS ou PF_PF_PS se répètent indéfiniment en se décalant : le premier descendant étant en 1ère, 2ème ou 3ème position dans le cycle. 

    Réussir à déduire du code de lignée la position du premier descendant dans le cycle permettrait de réaliser mon objectif. On peut déjà considérer que la première colonne (1.) est acquise puisqu'il suffit de savoir que l'on commence un cycle  IF_IF_IS en position 2. Pour les autres, il va falloir chercher un peu... Si quelqu'un a une idée, je suis preneur ! (sans vous demander de faire les choses à ma place, bien entendu)
  • Il faudrait d'abord que tu comprennes que quand on te parle des nombres impairs, tu dois parler toi aussi des nombres impairs et que tu ne mélange pas tout.
    Enfin que tu comprennes si tu veux être lu que'il faut donner à tes lecteurs éventuels des raisons de te lire.
    En ce qui me concerne je pense que j'ai perdu assez de temps avec toi.

  • "Il apparait clairement que des cycles IF_IF_IS ou PF_PF_PS se répètent indéfiniment en se décalant"

    Voilà le genre de phrases que j'adore en mathématique, surtout quand elles suivent un tableau de moins de 20 lignes, ce doit être suffisant pour parler de l'infini  :D
    504, c'est trop !
  • @Médiat_Suprème
    Réaction typique et désolante.  Pas une once de compréhension mais le premier truc à tacler, on y va joyeusement !
    Pour la lisibilité du tableau je n'en mets qu'un extrait. Si je dis qu'il y a des cycles, il faut me faire confiance à minima. Je ne fais pas tout ça sans vérifier.
    Je veux bien dire que je fais l'hypothèse de cycles au vu des données observées. Si je code ces cycles, il y aura après moyen de vérifier ce que ça donne en dehors des données observées. 
  • @Médiat_Suprème

    D'autre part il ne t'auras pas échappé qu'une colonne se compose d'impairs ayant le même i dans la forme (i*2^n-1)/3
    De ce fait qu'on trouve un entier multiple de 3 pour 2 qui ne le sont pas est tout de même évident. Ce qui m'intéresse c'est de trouver la bonne position dans le cycle au départ. 
  •  PMF : il faut me faire confiance 

    Ben non, je fais des mathématiques ! Vous distinguez la différence ?
    504, c'est trop !
  • Modifié (6 Feb)
    L'arbitre vient de siffler. Réaction du joueur : "Pas une once de compréhension mais le premier truc à tacler, on y va joyeusement !"
    Petit joueur, PMF
    "Si je code ces cycles, il y aura après moyen de vérifier ..." Avec des "si" on mettrait Paris en bouteille.
    Au lieu de dire "si", fais ce que tu dis qu'il faut faire, pour l'instant tu ne produis que du bruit.
    Que de temps perdu à venir raconter ce qu'il faudrait faire au lieu de le faire toi-même !!
  • PMFPMF
    Modifié (6 Feb)
    @Médiat_Suprème
    @gerard0

    Et c'est parti pour un tour encore une fois.

    La seule réponse qui justifie ces cycles c'est pour par exemple les descendants directs du 5  :
    n i = (5*2^n-1)/3 i mod 3 F ou S
    1 3 0 S
    3 13 1 F
    5 53 2 F
    7 213 0 S
    9 853 1 F
    11 3413 2 F
    13 13653 0 S
    15 54613 1 F
    17 218453 2 F
    19 873813 0 S
    21 3495253 1 F
    23 13981013 2 F
    25 55924053 0 S
    27 223696213 1 F
  • Modifié (6 Feb)
    Toujours des non-réponses.
    C'est du baratin élusif sous forme de tableau. Tu es malade ? Tu ne sais qu'écrire des phrases dans un vocabulaire personnel incompréhensible par les autres et produire des tableaux ?
    Oui, tu es certainement malade ...
  • @PMF,

    Supposons qu'un code donné figure à différents endroits dans l'arbre de Collatz. Peut-on prévoir où ?

    Prenons le code 2.3.4.5.6.7, qui est celui de l'entier $n_0$, premier terme d'une suite impaire. Cette suite est notée

    $n_0,n_1,...,n_d$

    où $n_d$ est l'entier impair de départ utilisé pour calculer $n_0$, donc en remontant. Ce sera généralement 1. Le problème est qu'avec le code ci-dessus, $n_d=1$ ne fonctionne pas, $n_0$ n'est pas entier. J'ai donc testé plusieurs valeurs de $n_d$, non multiples de 3 évidemment. Voici la liste de celles qui fonctionnent :

    37, 55, 77, 79, 97, 113, 145, 187, ...

    Impossible de les calculer, on ne trouve même pas de relation de récurrence.

    On ne peut calculer $n_0$ que si on connaît $n_1$. Du coup, ta théorie ne présente aucune utilité. Calculer le code d'un entier impair ne sert en effet à rien quand on peut obtenir le même résultat (retrouver $n_0$ en partant de 1) à partir de sa suite d'exposants de 2 (voir ce message) ou en connaissant son successeur $n_1$. Par exemple, le code de 39 est

    2, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1

    et sa suite d'exposants de 2 est

    1, 1, 2, 1, 4, 1, 3, 1, 2, 3, 4

    Le code n'ajoute rien à ce qu'on savait déjà faire, il ne s'agit même pas d'une simplification, c'est juste la même chose en plus compliqué.

  • PMFPMF
    Modifié (8 Feb)
    @Wilfrid

    D'abord merci pour cette réponse documentée. Tu as de grandes chances d'avoir raison.

    Restons cependant une petite seconde encore sur les codes de lignée dans l'hypothèse où on puisse les manipuler de manière indépendante.

    Je cherche donc des règles. En voici une première. Elle peut donner tous les codes de lignée de 2 éléments qui seront stériles.

    Voici la matrice de calcul 



    Les colonnes C vont de 1 à n en répétant 3 fois chaque valeur ---> C : {1,1,1,2,2,2,3,3,3...} 
    Les lignes L vont de 1 à n
    on pose pour chaque jeu de 3 colonnes des paramètres a, b, c valant dans l'ordre (1, 1.5, -2) (3, -0.5, -1) (7, 4.5, 0)
    et la formule est =SI(EST.IMPAIR(C);((C-1)*9/2)+a;((C-1)*9/2)+b)&"."&3*L+c
    traduction :
    Si C est impair, on calcule le premier membre du code : ((C-1)*9/2)+a
    Si C est pair, on calcule le premier membre du code : ((C-1)*9/2)+b
    Pour le deuxième membre (le plus à droite) il suffit de calculer 3L+c

    Plus généralement, pour chaque valeur C et L , la formule renvoie un triplet de codes de lignée de 2 membres correspondant à des entiers multiples de 3.

    Vérification pour quelques codes de lignée du tableau
    3 1.1.
    213 1.4.
    453 3.2.
    909 4.2.
    7281 6.1.
    13653 1.7.
    29013 3.5.
    58197 4.5.
    233013 7.3.
    466005 6.4.
    873813 1.10.
    932067 10.1.
    1856853 3.8.
    3724629 4.8.
    7456533 9.3.
    14912853 7.6.
    29824341 6.7.
    55924053 1.13.
    59652309 10.4.
    118838613 3.11.
    119304645 12.2.
    238376277 4.11.
    238609293 13.2.
    477218133 9.6.
  • Wilfrid dit à PMF :  Le code n'ajoute rien à ce qu'on savait déjà faire, il ne s'agit même pas d'une simplification, c'est juste la même chose en plus compliqué.
    PMF répond : tu as de grandes chances d'avoir raison ... 

    Ahh, on voit enfin le bout du tunnel ? 
  • @lourrran

    Tu viens de faire la démonstration que tu ne sais pas lire un texte de plus d'une ligne
  • Zut, mes espoirs s'envolent.
  • PMFPMF
    Modifié (9 Feb)
    Voici le code vba générant des codes de lignée correspondant à des entiers multiples de 3
    on peut vérifier les équivalences code de lignée et entiers ici 
    https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2340814#Comment_2340814Aucun recours n'est fait à l'algorithme de Collatz puisque ce code ne manipule que les codes de lignée
    Dim Col(15)
    Col(1) = 1
    Col(2) = 1
    Col(3) = 1
    Col(4) = 2
    Col(5) = 2
    Col(6) = 2
    Col(7) = 3
    Col(8) = 3
    Col(9) = 3
    Col(10) = 4
    Col(11) = 4
    Col(12) = 4
    Col(13) = 5
    Col(14) = 5
    Col(15) = 5
        
        For L = 1 To 9
        For C = 1 To 15 Step 3
        Range("A1").Select
        ActiveCell.Offset(L, C).Range("A1").Select
        If Col(C) Mod 2 <> 0 Then
        ActiveCell = (Col(C) - 1) * 9 / 2 + 1 & "_" & 3 * L - 2
        Else
        ActiveCell = (Col(C) - 1) * 9 / 2 + 1.5 & "_" & 3 * L - 2
        End If
        Next
        
        For C = 2 To 15 Step 3
        Range("A1").Select
        ActiveCell.Offset(L, C).Range("A1").Select
        If Col(C) Mod 2 <> 0 Then
        ActiveCell = (Col(C) - 1) * 9 / 2 + 3 & "_" & 3 * L - 1
        Else
        ActiveCell = (Col(C) - 1) * 9 / 2 - 0.5 & "_" & 3 * L - 1
        End If
        Next
        
        For C = 3 To 15 Step 3
        Range("A1").Select
        ActiveCell.Offset(L, C).Range("A1").Select
        If Col(C) Mod 2 <> 0 Then
        ActiveCell = (Col(C) - 1) * 9 / 2 + 7 & "_" & 3 * L - 0
        Else
        ActiveCell = (Col(C) - 1) * 9 / 2 + 4.5 & "_" & 3 * L - 0
        End If
        Next
        
        Next
  • PMFPMF
    Modifié (12 Feb)
    @Wilfrid

    "Le code n'ajoute rien à ce qu'on savait déjà faire, il ne s'agit même pas d'une simplification, c'est juste la même chose en plus compliqué."

    Pas forcement compliqué, c'est juste différent. Je réexpose pour illustrer cela la manip qui permet d'isoler des codes de lignée "stériles" cad correspondant à des entiers multiples de 3 :

    Soit une série d'entiers dont le code de lignée est composé de 2 éléments :
    3, 13, 53, 113, 213, 227, 453, 853, 909, 1813, 3413, 3637, 7253, 7281, 13653, 14549, 14563, 29013, 29125, 54613, 58197.

    Soit les codes de lignée qui les représentent
    1.1. // 1.2. // 1.3. // 3.1. // 1.4. // 4.1. // 3.2. // 1.5. // 4.2. // 3.3. // 1.6. // 4.3. // 3.4. // 6.1. // 1.7. // 4.4. // 7.1. // 3.5. // 6.2. // 1.8. // 4.5.

    Il est possible d'isoler les codes de lignée correspondant à des multiples de 3 en se basant uniquement sur ces codes, et donc sans aucun calcul sur les entiers. 

    pour C de 1 à n & L de 1 à n 
    On calcule un triplet de valeurs {CDL1, CDL2, CDL3]
    si C est impair :
    CDL1 = (C - 1) * 9 / 2 + 1 & "_" & 3 * L - 2
    CDL2 = (C- 1) * 9 / 2 + 3 & "_" & 3 * L - 1
    CDL3 = (C - 1) * 9 / 2 + 7 & "_" & 3 * L
    Si C est pair :
    CDL1 = (C - 1) * 9 / 2 + 1.5 & "_" & 3 * L - 2
    CDL2 = (C - 1) * 9 / 2 - 0.5 & "_" & 3 * L - 1
    CDL3 = (C - 1) * 9 / 2 + 4.5 & "_" & 3 * L

    Les codes de lignée indiqués ci-dessus sont calculés pour n = 3
    Les CDL stériles de liste ci-dessus étant :
    1.1. \\ 1.4. \\ 3.2. \\ 4.2. \\ 6.1. \\ 1.7. \\ 3.5. \\ 4.5.
    Pour n = 3 on obtient :
    1.1. \\ 3.2. \\ 7.3. \\ 6.1. \\ 4.2. \\ 9.3. \\ 10.1. \\ 12.2. \\ 16.3. \\ 1.4. \\ 3.5. \\ 7.6. \\ 6.4. \\ 4.5. \\ 9.6. \\ 10.4. \\ 12.5. \\ 16.6. \\ 1.7. \\ 3.8. \\ 7.9. \\ 6.7. \\ 4.8. \\ 9.9. \\ 10.7. \\ 12.8. \\ 16.9.


    En donnant n = 5 cette macro VBA calcule tous les CDL de 2 éléments stériles dans un arbre de 34 orbites
    Range("A1").Select
    For L = 1 To 5
    For C = 1 To 5
    If C Mod 2 <> 0 Then
    ActiveCell = (C - 1) * 9 / 2 + 1 & "." & 3 * L - 2 & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    ActiveCell = (C - 1) * 9 / 2 + 3 & "." & 3 * L - 1 & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    ActiveCell = (C - 1) * 9 / 2 + 7 & "." & 3 * L & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    Else
    ActiveCell = (C - 1) * 9 / 2 + 1.5 & "." & 3 * L - 2 & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    ActiveCell = (C - 1) * 9 / 2 - 0.5 & "." & 3 * L - 1 & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    ActiveCell = (C - 1) * 9 / 2 + 4.5 & "." & 3 * L & "."
    ActiveCell.Offset(1, 0).Range("A1").Select
    End If
    Next
    Next

    VBA très facile à tester dans Excel, sachant qu'il ne faut pas que le nombre de boucles L*C dépasse 1048576 (nbr max de lignes d'une feuille)

    Cette méthode est parfaitement opérationnelle. Il existe donc au moins une possibilité pour manipuler les codes de lignée sans aucun recours à l'algorithme de Collatz , ni autre calcul impliquant un entier. 
  • Prenons par exemple  1.6.1.7. qui est le 7ème descendant d'une lignée commençant par 1.6.1.1.

    Imaginons que sans connaitre ce code de lignée je teste 12424533 (c'est l'impair qui correspond à ce code)

    Voici un script VBA où il suffit d'écrire en A1 l'impair à tester
    Dim I As Long
    Dim I_FIRST As Long
    I = Range("A1").Value
    n = 1
    I_FIRST = 1
    Range("A2") = n
    Do Until I_FIRST Mod 2 = 0
    n = n + 1
    Range("A2") = n
    I_FIRST = (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))
    Loop
    n = n - 1
    Range("A2") = n
    Range("A3") = I & " a un code de lignée se finissant par " & n & " dont le même code se finissant par 1 est " & (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))
     
    Avec 12424533 en A1 le script retourne en A3 :
    "12424533 a un code de lignée se finissant par 7 dont le même code se finissant par 1 est 3033"

    On peut tester tous les impairs que l'on veut (dans les limites  calcul d'Excel).
    Si le code de lignée de ce nombre se finit par 1 on aura par exemple pour 3 dont le code de lignée est 1.1.
    "3 a un code de lignée se finissant par 1 dont le même code se finissant par 1 est 3"

    En simplifiant on peut écrire dans 3 cellules : # impair testé # n° de descendance #1er impair de la lignée
    soit pour 3 :  3    1    3
    ou pour 12424533 :  12424533   7   3033

    En testant les impairs à partir de 3, on obtient alors facilement la liste suivante :
    i testé n° de descendance 1er descendant
    3 1 3
    5 2 1
    7 1 7
    9 1 9
    11 1 11
    13 2 3
    15 1 15
    17 1 17
    19 1 19
    21 3 1
    23 1 23
    25 1 25
    etc...

    On remarquera que si le 1er descendant est "1", cela veut dire que l'impair I testé est tel que I*3+1 = 2^n
    Ce sera donc le cas de 5, 21, 85, 341....

    Si ce test était fait à l'infini, théoriquement tout impair I se verrait alloué un numéro de descendance et un premier descendant

    Donc la question de la conjecture est de savoir quel est l'impair I qui échapperait à cette allocation.

    La formule que j'ai utilisée pour ces scripts est  :
    avec i l'impair à tester, i' l'impair correspondant au premier descendant, et n le numéro de descendance
    i = 2^(2*(n-1))*i'+(2^(2n-2)-1)/3

    Si vous voulez faire le test vous-même dans Excel, voici la vba

    Dim I As Long
    Dim I_FIRST As Long
    Range("A1").Select
    For I = 3 To 100 Step 2
    ActiveCell.Offset(1, 0).Range("A1").Select
    ActiveCell = I
    n = 1
    I_FIRST = 1
    ActiveCell.Offset(0, 1).Range("A1").Select
    ActiveCell = n
    Do Until I_FIRST Mod 2 = 0
    n = n + 1
    ActiveCell = n
    I_FIRST = (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))
    Loop
    n = n - 1
    ActiveCell = n
    ActiveCell.Offset(0, 1).Range("A1").Select
    ActiveCell = (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))
    ActiveCell.Offset(0, -2).Range("A1").Select
    Next

    Pour nommer les 3 colonnes, entrer en A1, B1 et C1 :
    "i testé",  "n° de descendance", "1er descendant"

  • PMFPMF
    Modifié (14 Feb)

    work in progress

  • PMFPMF
    Modifié (14 Feb)

    Conjecture de Syracuse

    DEFINITIONS

    On appelle ‘’code de lignée’’ une description de la descendance d’un entier impair dans un arbre de Collatz. Ce codage, inspiré de la généalogie, donne depuis l’ancêtre qui est le premier membre, la position générationnelle de chaque descendant. Les ancêtres ont la particularité d’être des impairs directement issus d’une puissance de 2 tel que i=(2^n-1)/3. Leur ordre 1, 2, 3, 4, 5… renvoie donc à 5, 21, 85, 341, 1365…

    Par exemple 181 s’écrit 1.2.1.3 ce qui veut dire qu’il correspond à la suite de Collatz inversée 5, 13, 17, 181 où 5 est le 1er ancêtre, 13 le deuxième descendant de 5 (3 est le premier), 17 le premier descendant de 13, et 181 le troisième de 17 (11 et 45 étant les 2ème et 3ème).

    Dans la mesure où l’arbre de Collatz est plutôt vu ici comme un arbre généalogique, il est plus naturel de parler de descendant, ascendant, parent, enfant, voire de famille pour grouper tous les descendants d’un même parent. Le ‘’premier descendant’’ est selon ce principe le premier enfant d’un parent donné.

    On définit ensuite 2 groupes d’entiers impairs i qui sont

    GROUPE A : 7, 9, 11, 15, 17, 19, 23, 25, 27, 31, 33, 35, 39, 41, 43

    GROUPE B : 5, 13, 21, 29, 37

    Avec c >=1 et i membre du groupe A ou du B, tout impair x >=7 est tel que :  x = i + 40 * (c-1).

    On pose enfin qu’il est toujours possible de trouver un impair i en lui associant un premier descendant i’ et un rang de génération n, en calculant :

    i = 2^(2*(n-1))*i’ + (2^(2n-2)-1)/3

    Par exemple 181 = 2^(2*(3-1))*11+(2^(2*3-2)-1)/3 (avec n = 3 et i’ = 11). Le code de lignée de 181 est 1.2.1.3 et celui de 11 est 1.2.1.1.

    11 est donc bien le premier descendant de la famille du 181


    CALCUL

    Il est possible de calculer rapidement le dernier membre du code de lignée sans avoir à effectuer une suite de Collatz pour en déduire ce code.

    On calcule pour chaque impair i :  i’ = (i - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1)), en incrémentant n à partir de 1 jusqu’à ce que i’ soit pair. Il suffit alors de recalculer la formule avec n = n-1 pour obtenir le premier descendant i’ de la famille de i et de connaitre le dernier membre de son code de lignée n (voir le script vba joint).

    Exemple :

    i =45 ; n = 2 ;  i’ = 11 signifie que le code de lignée de 45 se termine par 2 et que le premier descendant de sa famille est  11, sachant que le code de lignée complet de 45 est 1.2.1.2 et celui de 11 est 1.2.1.1

    Lorsque le calcul est fait pour tous les impairs <= 1999999, il se trouve que les impairs testés sont du groupe A pour tous les codes de lignée se terminant par 1, et que tous ceux du groupe B ont un code de lignée se terminant par une valeur supérieure à 1.

     

    HYPOTHESE

    Cette relation qui s’établit pour le premier million d’entiers impairs entre deux types de code de lignée (dont le dernier membre est =1 ou <>1) et deux types d’impairs ( groupe A ou B ) induit l’hypothèse qu’elle soit valable pour tout entier impair.

    Dans ce cas, la conjecture est résolue puisque le fait que tout impair s’associe selon son type A ou B à un code de lignée étant celui d’un premier descendant ou d’un nième descendant implique que tout impair aurait une suite de Collatz le menant à 1, puisqu’il ne peut avoir un code de lignée sans que l’impair qui lui correspond fasse partie d’un arbre de Collatz.

    Pour valider cette hypothèse, la démonstration devrait prouver que :

    ·        Il est toujours possible de trouver des valeurs i’ et n pour i = 2^(2*(n-1))*i’ + (2^(2n-2)-1)/3

    ·        Tout impair x = i + 40 * (c-1) avec c>=1, x>=7, et i élément de {7, 9, 11, 15, 17, 19, 23, 25, 27, 31, 33, 35, 39, 41, 43} a toujours le code de lignée d’un premier descendant

    ·        Tout impair x = i + 40 * (c-1) avec c>=1, x>=7, et i élément de {5, 13, 21, 29, 37} a toujours le code de lignée d’un énième descendant.

    ·        La synthèse des 3 premiers points fait que tout entier impair se positionne dans un arbre de Collatz unique en revenant toujours vers 1 via une puissance de 2 


    TESTER SOI-MEME DANS EXCEL

    ·        Copier la macro VBA et régler les paramètres de la boucle (for 3 to 2000000 est assez long en calcul)

    ·        Ecrire de A1 à D1 le titre des colonnes « impair testé », «fin de code de lignée», «1er descendant», «groupe»

    ·        Après exécution de la macro, entrer en cellule D2  =SI(OU(A2-ENT(A2/40)*40=3;A2-ENT(A2/40)*40=1);A2-ENT(A2/40)*40+40;A2-ENT(A2/40)*40) et copier cette cellule jusqu’à la dernière ligne des valeurs calculées par la macro. Ecrasez les valeurs en faisant un copier de la colonne D et collage spécial 123 (ça ira plus vite)

    ·        Activer le filtrage sur les 4 colonnes et sélectionner uniquement 1 dans la colonne B. Vérifier que toutes les valeurs de la colonne D sont celles du groupe A

    ·        Activer le filtrage sur les 4 colonnes et sélectionner tous sauf 1 dans la colonne B. Vérifier que les valeurs de la colonne D sont celles du groupe B


    La vba

    Application.ScreenUpdating = False

    Dim I As Long

    Dim I_FIRST As Long

    Range("A1").Select

    For I = 3 To 2000000 Step 2

    ActiveCell.Offset(1, 0).Range("A1").Select

    ActiveCell = I

    n = 1

    I_FIRST = 1

    ActiveCell.Offset(0, 1).Range("A1").Select

    ActiveCell = n

    Do Until I_FIRST Mod 2 = 0

    n = n + 1

    ActiveCell = n

    I_FIRST = (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))

    Loop

    n = n - 1

    ActiveCell = n

    ActiveCell.Offset(0, 1).Range("A1").Select

    ActiveCell = (I - (2 ^ (2 * n - 2) - 1) / 3) / 2 ^ (2 * (n - 1))

    ActiveCell.Offset(0, -2).Range("A1").Select

    Next

     Application.ScreenUpdating = True

     


  • Modifié (14 Feb)
    @PMF : Leur ordre 1, 2, 3, 4, 5… renvoie donc à 5, 21, 85, 341, 1365…

    Aussi longtemps que tu n'auras pas compris que les prédécesseurs de 1 sont 1, 5, 21, ... et que tu persisteras dans ton erreur, tes résultats seront faux et sans intérêt.

  • PMFPMF
    Modifié (14 Feb)
    @Wilfrid
    Je vais tenter une nième explication du code de lignée pour le premier membre

    avec n = 1, 2, 3, 4, 5, 6, 7, 8, 9,10....
    calcule x = 2^(2n+2) et pose ces résultats sur une ligne imaginaire :
    16, 64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304
    effectue (x-1)/3 à partir de cette série :
    5, 21, 85, 341, 1365, 5461, 21845, 87381, 349525, 1398101
    elle correspond donc bien à n = 1, 2, 3, 4, 5, 6, 7, 8, 9,10....
    et c'est ce n qui devient la valeur du premier membre du code de lignée 

    Ce n n'est pas un entier de l'arbre mais l'exposant de 2^(2n+2)

    Toute suite de Collatz aboutit à un moment donné sur 5, 21, 85, 341, 1365, 5461, 21845, 87381, 349525, 1398101...
    qui se transforme par 3x+1 en 16, 64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304...
    et file directement vers 1 en n étapes

    Tu peux donc passer maintenant à la 5ème ligne du message 
    https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2342071#Comment_2342071

  • PMFPMF
    Modifié (14 Feb)
    Quelques formules pour obtenir depuis un impair x, le premier descendant y qui correspond à son code de lignée
    n>+1
    a = 1/2^(2*n-2)
    b = a/3-1/3
    y = a*x+b

    Exemple 
    n impair testé x 1er descendant y code de lignée x code de lignée y
    1 11 11 1.2.1.1 1.2.1.1
    2 29 7 1.2.1.1.2 1.2.1.1.1
    3 693 43 1.2.1.1.1.2.1.1.3 1.2.1.1.1.2.1.1.1
    4 1237 19 1.2.1.1.2.4 1.2.1.1.2.1
    5 6485 25 1.2.1.1.2.1.5 1.2.1.1.2.1.1

    n impair testé  x 1er descendant y code de lignée x code de lignée y
    1 39 39 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.1
    2 157 39 1.2.1.1.2.1.2.1.1.1.2 1.2.1.1.2.1.2.1.1.1.1
    3 629 39 1.2.1.1.2.1.2.1.1.1.3 1.2.1.1.2.1.2.1.1.1.1
    4 2517 39 1.2.1.1.2.1.2.1.1.1.4 1.2.1.1.2.1.2.1.1.1.1
    5 10069 39 1.2.1.1.2.1.2.1.1.1.5 1.2.1.1.2.1.2.1.1.1.1

    n>+1
    a = 1/2^(2*n-2)
    b = a/3-1/3
    x = (y-b)/a

    n 1er descendant y impair testé x code de lignée y code de lignée x
    1 39 39 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.1
    2 39 157 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.2
    3 39 629 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.3
    4 39 2517 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.4
    5 39 10069 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.5
    6 39 40277 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.6
    7 39 161109 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.7
    8 39 644437 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.8
    9 39 2577749 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.9
    10 39 10310997 1.2.1.1.2.1.2.1.1.1.1 1.2.1.1.2.1.2.1.1.1.10

    On voit bien que le premier descendant n'est pas le parent de l'impair testé. 
    Si un impair est le nième descendant d'un parent, il existe un premier descendant de ce même parent

    Le premier descendant joue un rôle clé dans l'hypothèse que j'ai expliquée ici :
    https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2342071#Comment_2342071
  • @PMF : Je vais tenter une nième explication du code de lignée pour le premier membre

    Il est évident que tu ne comprends pas ce que tu fais, alors je vais te l'expliquer. Prenons le nombre 131, dont le code de lignée est 2, 2, 1, 1, 1, 2, 2, 1 (je ne remplace pas les virgules par des points pour m'épargner ce boulot inutile). Chez toi, le premier 2 est remplacé à tort par un 1. Comme je ne connais rien à VBA, voici l'algorithme Python qui permet de retrouver $n_0$ à partir de son code de lignée :

    def code2n0(code):
    	n = 1
    	for r in code:
    		u = 2 * r - (3 - n % 3) % 2
    		n = (n * 2**u - 1) // 3
    
    	return n
    
    print(code2n0([2, 2, 1, 1, 1, 2, 2, 1]))

    Il renvoie 131 comme on s'y attendait. Mais si tu remplaces 2, 2, 1, ... par 1, 2, 1, ... il renvoie 17.

    Tu n'as pas été sans t'en rendre compte, mais au lieu de chercher pourquoi et finir par réaliser que 5 est le second prédécesseur de 1 et non pas le premier, tu as imaginé un traitement différent pour le premier chiffre du code. Cette différence de traitement est le signe que quelque chose ne va pas, parce que c'est anormal. Alors tu peux m'expliquer sur les 30 prochaines pages pourquoi le code de lignée commence par 1, tu ne me convaincras pas.

    Le pire est qu'il est difficile de faire confiance à la "méthode PMF" quand on voit que son auteur commet des erreurs qu'il est incapable de reconnaître et de corriger.

  • @Wilfrid

    Les codes de lignée sont faits pour désigner les entiers impairs à partir du premier impair issu d'une puissance de 2

    Point barre
  • @Wilfrid

    "Prenons le nombre 131, dont le code de lignée est 2, 2, 1, 1, 1, 2, 2, 1"

    Pour commencer, le code de lignée de 131 est  1.2.1.1.1.2.2.1

     C'est sympa de passer ce codage en Python mais il faudrait que tu en comprennes un peu mieux la logique

    Ton problème est le numéro du premier membre. Cela te semble hérétique quant à St Collatz, pourtant :

    1) ce numéro c'est juste une valeur n tel que (2^(2n+2)-1)/3 = i. Ce i pour n>=1 est égal à 5, 21, 85, 341, 1365...

    2) remarque que l'on pourrait très bien envisager n = 0. Dans ce cas (2^(2n+2)-1)/3 = (2^2 - 1)/3 = 1. Et donc dire que le code de lignée de 1 est "0.1."


    Ce qui est intéressant avec un code de lignée, c'est de classer les impairs par famille, cad ce qui partagent le même code de lignée à l'exception du dernier membre. Pour 131, on aura donc 131, 525, 2101, 8405, 33621, 134485, 537941... donc les codes de lignée sont 1.2.1.1.1.2.2.1, 1.2.1.1.1.2.2.2,  1.2.1.1.1.2.2.3, 1.2.1.1.1.2.2.4,  1.2.1.1.1.2.2.5, 1.2.1.1.1.2.2.6,  1.2.1.1.1.2.2.7 ...

    Il y a des impairs qui ont donc 1 comme dernier membre de leur code de lignée. Je les appelle "premier descendant"
    J'ai déjà expliqué comment calculer pour tout impair son dernier membre et son premier descendant
    https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2342101#Comment_2342101

    Ce qui est intéressant c'est que l'on peut classer tout N selon que :
    Avec c >=1 et i membre du groupe A ou du B, tout impair x >=7 est tel que :  x = i + 40 * (c-1).
    GROUPE A : 7, 9, 11, 15, 17, 19, 23, 25, 27, 31, 33, 35, 39, 41, 43
    GROUPE B : 5, 13, 21, 29, 37
    Le groupe A est celui de tous les premiers descendants (exemple pour 131, i = 11 et c = 4)
    Le groupe B celui de tous les autres (exemple pour 525, i = 5 et c = 14)

    Le rôle des premiers descendants et des groupes A et B est à mes yeux une piste à suivre.
  • @PMF, pourrais-tu m'expliquer comment tu calcules les prédécesseurs de 5 et de 7 ?
  • @Wilfrid
    le code de lignée de 5 est 1.
    le code de lignée de 7 est 1.2.1.1.1
    Les deux sont issus de 16 : si le premier membre est 1 on calcule pour n = 1,  2^(2n+2) = 16
    5 : son 1er descendant est 3 de code de lignée 1.1.
    7 : son 1er descendant est 9 de code de lignée 1.2.1.1.1.1
  • Modifié (17 Feb)
    Je ne t'ai pas demandé le code de lignée de x et de y mais comment tu calcules, disons les quatre premiers prédécesseurs de 5 et ceux de 7. Par exemple, les quatre premiers prédécesseurs de 13 sont 17, 69, 277 et 1109.
  • PMFPMF
    Modifié (17 Feb)
    @Wilfrid
    C'est une pure application des codes de lignée ce tu me demandes
    Ce que tu appelles "prédécesseurs" sont pour moi une famille dont le parent est 13 et les enfants par ordre de descendance 17, 69, 277 et 1109. Puisque le code de lignée est issu de la généalogie, je trouve plus parlant d'utiliser la terminologie de la généalogie (ascendants, descendants, enfants et parents)

    13 1.2
    17 1.2.1
    69 1.2.2
    277 1.2.3
    1109 1.2.4

    Les codes de lignée permettent de faire ce type de classement très rapidement une fois que l'on a traduit les étapes impaires dans ce codage
    Ils sont obtenus via la suite de Collatz comme ici dans l'exemple du 17

    1 16
    2 5 1
    3 10 1
    4 20 1
    5 40 1
    6 13 1.2
    7 26 1.2
    8 52 1.2
    9 17 1.2.1

    La façon d'y parvenir ne dépend que de l'outil que tu utilises. On le fera différemment avec Excel et VBA qu'avec Python
    En espérant avoir répondu à ta demande
  • Bonjour,

    Non, PMF, tu n'as pas répondu à cette question: "comment tu calcules".
    Fais le en montrant ton calcul (minimal en longueur) et non le résultat.
    Par exemple, à partir du nombre 13, quelle opération mathématique donne le nombre 17 ?

    Cordialement,
    Rescassol

  • PMFPMF
    Modifié (17 Feb)
    @Rescassol

    Expliquer ce "comment tu calcules " revient donc à "comment je fais ce calcul dans l'environnement d'Excel"

    Donc voici step by step pour le 17 :

    1) calculer une suite de Collatz classique : SI(EST.IMPAIR(X);X*3+1;X/2) Chaque nouveau résultat devient le X du suivant
    2) inverser l'ordre de cette suite : 16, 5, 10, 20, 40, 13, 26, 52, 17 
    3) calculer Y le nbr d'étapes paires entre chaque impair  : 1, 0, 1, 2, 3, 0, 1, 2, 0
    4) à chaque fois que l'on arrive sur une étape impaire X (ou Y=0), calculer n =SI(X<>"";SI(EST.IMPAIR(X);ARRONDI.SUP(Y/2;0);"");"")
    5) ce n est le numéro du descendant, il faut donc maintenant faire la concaténation du code de lignée
    6) à chaque fois que Y = 0; on va donc ajouter le nouvel n obtenu (n.n.n....) 
    7) avec comme cas particulier que le premier n est calculé depuis la puissance de 2 qui débute la série inversée :
    premier membre du code de lignée= (0,5*LOG(16;2))-1 = 1

    Cela se programme facilement ou on peut l'organiser dans un tableur ce qui a l'avantage de donner un résultat sans exécuter une macro

    Ce qui donne très précisément quand on passe de 13 à 17
    40 3 1
    13 0 2 1.2
    26 1 1.2
    52 2 1.2
    17 0 1 1.2.1
    col 1 : suite inversée (X), col2 : comptage étapes paires (Y), col3 : calcul n = ARRONDI.SUP(Y/2;0); col 4 : concaténation n

    En espérant avoir répondu à ta demande "comment tu calcules".
  • Je comprends mieux maintenant pourquoi tu remplaces le 2 initial d'un code de lignée (si la suite passe par 5) par 1. En fait tu n'as aucune idée de la manière de calculer les prédécesseurs d'un terme impair dans une suite de Collatz. Je me demande même si tu sais de quoi il est question quand on parle de prédécesseur. Ce serait pourtant bien de le savoir avant de t'attaquer à la conjecture, surtout lorsqu'il est question de remontée depuis 1.

    Script Python pour le calcul des prédécesseurs. Si le second paramètre (d) est égal à 1, on n'affiche que les prédécesseurs non-multiples de 3 :

    def preds(n, d=0):
    	m = 3 - n % 3
    	if m == 3:
    		return "multiple de 3"
    	else:
    		lst = []
    		k = (n * 2**m - 1) // 3
    		lst.append(k)
    		for j in range(1, 9):
    			k = 4 * k + 1
    			lst.append(k)
    		if d == 1:		# supprimer les multiples de 3
    			return [k for k in lst if k % 3 > 0]
    		else:
    			return lst
    
    
    print(preds(5))
    print(preds(5, 1))

    Ce qui renvoie
    [3, 13, 53, 213, 853, 3413, 13653, 54613, 218453]
    [13, 53, 853, 3413, 54613, 218453]

    Et pour les prédécesseurs de 1 on obtiendra
    [1, 5, 21, 85, 341, 1365, 5461, 21845, 87381]
    [1, 5, 85, 341, 5461, 21845]

    @PMF : remarque que l'on pourrait très bien envisager n = 0. Dans ce cas (2^(2n+2)-1)/3 = (2^2 - 1)/3 = 1. Et donc dire que le code de lignée de 1 est "0.1."

    Encore une erreur. Dans la suite des prédécesseurs d'un entier impair, chacun d'eux possède un rang (ou indice) débutant par 1 pour le plus petit d'entre eux. Dans la suite de prédécesseurs 3, 13, 53, 213, ..., 3 est au rang 1, 13 au rang 2, etc. Un code de lignée est tout simplement constitué du rang de chaque terme impair (en tant que prédécesseur) appartenant à une suite de Collatz donnée. De ce fait, le code 0.1 (ou 0, 1) signifie qu'il existe un rang 0, ce qui est impossible !

    Tu vois que ta théorie prend l'eau de toute part. Ne te fatigue pas à écoper, le trou est trop gros.

  • PMFPMF
    Modifié (18 Feb)
    @Wilfrid

    Ta critique est totalement absurde. J'ai strictement le même arbre de Collatz que toi. Tout le monde a le même arbre de Collatz. 

    ". En fait tu n'as aucune idée de la manière de calculer les prédécesseurs d'un terme impair dans une suite de Collatz. "

    C'est totalement n'importe quoi. Lors de mon premier message sur ce fil, j'ai montré que mon premier script consistait à reproduire le même arbre que celui de Wikipedia (le graph circulaire). Comment veux-tu que l'on puisse faire autrement avec cette suite que de toujours se référer à cet arbre et de se déplacer dedans ? Les codes de lignée sont les positions des impairs dans l'arbre.  

    Ton problème c'est que tu veux absolument que ta terminologie et ton interprétation fassent foi. Tu es tellement aveuglé par ton propre argumentaire que tu n'arrives même plus à comprendre des choses ultra-simples.

    Donc je le répète encore un fois : ma méthode considère que l'arbre est construit sur les puissances de 2 avec un exposant 2n+2. Le tronc de l'arbre c'est donc bien les puissances de 2.
    Si le code de lignée commence par un 1, il désigne le premier impair extrait de (2^(2*1+2)-1)/3 donc 5
    Si le code de lignée commence par un 2, il désigne le premier impair extrait de (2^(2*2+2)-1)/3 donc 21
    Si le code de lignée commence par un 3, il désigne le premier impair extrait de (2^(2*3+2)-1)/3 donc 85
    etc...
    si n= 0, (2^(2*0+2)-1)/3 = 1  je ne vois pas où est le problème. Mais par définition il n'y a pas d'intérêt à donner un code de lignée à 1

    Le code de lignée est donc stricto sensu la codification des descendances depuis les puissances de 2
  • Modifié (18 Feb)
    Bonjour
    J'ai écrit :
    par exemple, à partir du nombre 13, quelle opération mathématique donne le nombre 17 ?
    PMF a répondu :
    1) calculer une suite de Collatz classique : SI(EST.IMPAIR(X);X*3+1;X/2). Chaque nouveau résultat devient le X du suivant
    2) inverser l'ordre de cette suite : 16, 5, 10, 20, 40, 13, 26, 52, 17
    Où vois-tu que tu pars de 13 ?
    Ma question est :
    J'ai 13 dans la main et rien d'autre. Qu'est-ce que je fais pour fabriquer 17 ?
    Cordialement,
    Rescassol
  • PMFPMF
    Modifié (18 Feb)
    @Rescassol

    J'ai 13 dans la main et rien d'autre. Qu'est ce que je fais pour fabriquer 17 ?

    le code de lignée de 13 est 1.2
    le code de lignée de 17 est 1.2.1

    Si j'ai un code de lignée de type n.n. je peux supposer l'existence de son premier descendant n.n.1. , que ce descendant existe ou non, (ce qui dépend du fait que l'impair correspondant à n.n. ne soit pas multiple de 3)

    Puisque j'ai dans la main le 13, que son code de lignée est 1.2. cherchons donc à calculer 1.2.1.

    je commence avec 13*2=26 mais je ne peux diviser 26-1 par 3, je dois continuer
    13*4=52 je peux diviser 52-1 par 3 ce qui me donne 17
    17 est le premier descendant de 13, je le note donc 1.2.1

    Ai-je répondu à ta question ?

  • PMFPMF
    Modifié (18 Feb)
    Ceci fait un peu suite à ma réponse à @Rescassol

    Regardons cette suite de Collatz pour 3997

    En n'indiquant que les étapes impaires :
    5, x, 13, 17, 11, x, 29, 19, xx, 101, 67, 89, xx, xxx, xxx, 3797, 2531, 1687, 2249, 1499, xxx, 3997
    ce qui correspond en codes de lignée à :
    1<---1.2<---1.2.1<---1.2.1.1<---1.2.1.1.2<---1.2.1.1.2.1<---1.2.1.1.2.1.2<---1.2.1.1.2.1.2.1<---1.2.1.1.2.1.2.1.1<---1.2.1.1.2.1.2.1.1.4<---1.2.1.1.2.1.2.1.1.4.1<---1.2.1.1.2.1.2.1.1.4.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1.1.2

    On remarquera que j'ai inclus des xxxx dans la suite ci-dessus, voici ce qui ce passe si je les remplace :
    5, 3, 13, 17, 11, 7, 29, 19, 25, 101, 67, 89, 59, 237, 949, 3797, 2531, 1687, 2249, 1499, 999, 3997

    De ce fait cette nouvelle suite correspond à 
    1<---1.1<---1.2<---1.2.1<---1.2.1.1<---1.2.1.1.1<---1.2.1.1.2<---1.2.1.1.2.1<---1.2.1.1.2.1.1<---1.2.1.1.2.1.2<---1.2.1.1.2.1.2.1<---1.2.1.1.2.1.2.1.1<---1.2.1.1.2.1.2.1.1.1<---1.2.1.1.2.1.2.1.1.2<---1.2.1.1.2.1.2.1.1.3<---1.2.1.1.2.1.2.1.1.4<---1.2.1.1.2.1.2.1.1.4.1<---1.2.1.1.2.1.2.1.1.4.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1.1.1<---1.2.1.1.2.1.2.1.1.4.1.1.1.1.2

    Ce que j'ai inclus, ce sont tous les codes de lignées intermédiaires quand on ne passe pas d'un premier descendant à un autre. Comme par exemple pour 1.2.1.1.2.1.2.1.1<---1.2.1.1.2.1.2.1.1.4


    Ce chemin correspond à une manière de faire une suite de Collatz avec des codes de lignée : en partant d'un code, on remonte tous les descendants jusqu'au 1er descendant, puis on passe au parent et on continue de même en fonction du rang de descendance de ce dernier
  • Modifié (18 Feb)

    PMF : je commence avec 13*2=26 mais je ne peux diviser 26-1 par 3, je dois continuer

    Maintenant on va commencer par 1 : 1*2-1 n'est pas divisible par 3, je dois continuer.

    1*4-1 est divisible par 3 ... pour donner 1. Ce 1-là est le prédécesseur de 1, tout comme précédemment 17 était le prédécesseur de 13 parce que 13*4-1 est divisible par 3 pour donner 17.

    On a donc 1 pour premier prédécesseur de 1. On cherche le suivant : 1*8-1 n'est pas divisible par 3, je dois continuer. 1*16-1 est divisible par 3 pour donner 5, second prédécesseur de 1.

    En notant 5, 21, 85, ... les prédécesseurs de 1 tu as zappé 1 lui-même. Le code de lignée d'une suite passant par 5 doit donc commencer par 2 (puisque 5 est le 2ème prédécesseur de 1) et non par 1. Tu commences à comprendre ?

    Mais je suis persuadé que non, tout comme tu ne comprends pas qu'il ne peut exister de 0 dans un code de lignée. Comme il est impossible de faire entrer quoi que ce soit dans le crâne d'un âne bâté, je jette l'éponge.

  • PMFPMF
    Modifié (18 Feb)
    @Wilfrid
    Mais je n'ai rien zappé du tout. Le cycle trivial ce n'est pas toi qu'il l'a inventé, non plus
    Il n'y a pas de problème là où tu t'échines à en voir un.
    Les codes de lignée sont définis pour que le premier d'entre eux, "1." correspondent à i = (2^(2n+2)-1)/3 avec n=1 soit i=5
    C'est une codification qui est conçue pour définir tous les impairs dans l'arbre à partir de i = (2^(2*1+2)-1)/3
    St Collatz ne va pas en faire une jaunisse. Personne ne va lui voler son cycle trivial.
  • Voici la suite des codes de lignée pour i = 27 dont le cdl est 1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1

    1. au sommet  correspond à i = 5

    1
    1.1
    1.2
    1.3
    1.3.1
    1.3.1.1
    1.3.1.1.1
    1.3.1.1.2
    1.3.1.1.2.1
    1.3.1.1.2.2
    1.3.1.1.2.2.1
    1.3.1.1.2.2.1.1
    1.3.1.1.2.2.1.1.1
    1.3.1.1.2.2.1.1.2
    1.3.1.1.2.2.1.1.2.1
    1.3.1.1.2.2.1.1.2.1.1
    1.3.1.1.2.2.1.1.2.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2
    1.3.1.1.2.2.1.1.2.1.1.1.2.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1
    1.3.1.1.2.2.1.1.2.1.1.1.2.1.1.1.1.1.1.1.1.1.1.2.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1

  • Voici la suite de code de lignée pour i = 331

    CDL impairs CDL Suite impairs Suite Col.
    1 5 5 5
    10
    1.1 3 20
    40
    1.2 13 80
    160
    1.3 53 53 53
    106
    1.3.1 35 35 35
    70
    1.3.1.1 23 140
    280
    1.3.1.2 93 560
    1120
    1.3.1.3 373 373 373
    746
    1492
    1.3.1.3.1 497 497 497
    994
    1.3.1.3.1.1 331 331 331

  • Bonsoir au Forum


    @PMF ton "code de ligne" c'est pas très mathématiques!
    T-as plus simple
    Prenons les deux impairs 331 et 335
    331 est 1 modulo 3, le plus petit prédécesseur de 331 dans une suite de Collatz est (4*331-1)/3=1323/3=461, le suivant est 4*461+1 puis 4*(4*461+1)+1 et ainsi de suite
    335 est 2 modulo 3, le plus petit prédécesseur de 335 est (2*335-1)/3=669/3=223, le suivant est 4*223+1, puis 4*(4*223+1)+1 et ainsi de suite

    Pourquoi utiliser un code de ligne alors qu'il y a plus simple?

  • @PierrelePetit

    Code de lignée pas "code de ligne"
    Lignée = Ensemble des descendants d'une personne.

    Le code de lignée c'est un outil qui est destiné à décrire les impairs dans l'arbre de Collatz selon leur descendance, leur famille, de qui sont-ils les enfants, et de qui sont-ils les parents.

    C'est donc un outil qui se focalise sur l'arborescence de l'arbre : l'arborescence est une structure qui pourrait accueillir autre chose que des nombres. Un arbre généalogique a par exemple une arborescence identique à un arbre de Collatz puisque ces fameux codes de lignée peuvent autant définir des personnes ou des nombres.

    Evidemment dans un arbre généalogique, il n'y a pas une infinité de descendants et les humains n'ont pas une vie éternelle. Mais ça c'est une autre histoire...
  • Modifié (19 Feb)
    @PMF
    Tout nombre impair positif et non 0 modulo 3 (multiple de 3) est soit 1 modulo 3 soit 2 modulo 3
    Tout nombre impair  x 1 modulo 3 s'écrit 3n-2 et a pour prédécesseurs possibles dans une suite de Collatz l'infinité des nombres ((3n-2)*2^2j)-1)/3 pour n et j entiers positifs non nul, ce que tu appelles la lignée, bizarre lignée qu'une infinité puisse avoir un seul et unique descendant!!
    Tout nombre impair  x 2 modulo 3 s'écrit 3n-1 et a pour prédécesseurs possibles dans une suite de Collatz l'infinité des nombres ((3n-1)*2^(2j)-1)-1)/3 pour n et j entiers positifs non nul.
    T'as la possibilité de progresser mais t'avances pas vite et tu ne tiens pas un discours de maths.
    A + mais pas sur!!
  • T"as la possibilité de progresser mais t'avances pas vite et tu ne tiens pas un discours de maths.
    A + mais pas sur!!
    J'adore. Venant de PierrelePetit qui n'a rien pigé à ce que dit PMF... 🤣

    Plus qu'un tour en orbite autour de l'arbre de Collatz ici c'est un tour en orbite tout court...
  • @raoul.S

    Merci !

    Je suis pas mal wilfridisé ou pierrelepetitisé en ce moment. 
  • PMFPMF
    Modifié (20 Feb)
    Les codes de lignée amèneraient à voir la conjecture de Collatz sous un angle intéressant.

    La conversion d'un impair en code de lignée est une opération qui décrit selon l'ordre de descendance la suite d'impairs vers celui qui aboutit à une puissance de 2 (5, 85, 341...) . N'importe qu'elle suite de Collatz se convertit "mécaniquement" en un code de lignée. 

    Ce qui est intéressant c'est surtout ce qu'on peut faire directement avec les codes de lignée. Si on en a un, à condition que l'on sache qu'il soit bien relié à un impair, alors on peut sans problème savoir comment il revient à sa racine (le premier impair extrait d'une puissance de 2).

    Comme cet exemple : https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2342741#Comment_2342741
    ou https://les-mathematiques.net/vanilla/index.php?p=/discussion/comment/2342742#Comment_2342742

    Le chemin suivi n'est pas tout à fait une suite car on passe toujours par les premiers descendants.  Mais c'est totalement superposable à la suite de Collatz

    la suite de code de lignée   :  1.<---1.1<---1.2<---1.3<---1.3.1<---1.3.1.1<---1.3.1.2<---1.3.1.3<---1.3.1.3.1<---1.3.1.3.1.1
    les impairs correspondants :  5<---3<---13<---53<---35<---23<---93<---373<---497<---331
    Collatz standard                  :  5<---x<---x<---  53<---35<---   x<---  x<---373<---497<---331

    Des codes de lignée, on peut en fabriquer à l'infini. La plupart ne s'associeront pas à un impair, ce seront des branches imaginaires dans l'arbre (comme une descendance imaginaire du 3 par exemple qui commencerait par 1.1.x). Mais par contre toute suite de Collatz trouvera toujours son équivalent en codes de lignée.

    S'il existe un code comme 1.3.1, alors tous les descendants de type 1.3.n existent, et pourquoi pas des 1.3.n.n.n.n.n.......

    On a vu aussi qu'on pouvait faire une opération directe sur les codes de lignée pour connaitre ceux qui correspondent à des multiples de 3.

    Donc tout le souci est de trouver une liaison ente un cdl et un impair qui ne passerait pas par le recours à une suite de Collatz. Un outil encore imaginaire qui saurait fabriquer tous les codes de lignée possibles correspondant à tous les impairs possibles...
  • Modifié (19 Feb)
    @PMF
    Commences les 60000 suites de Collatz par les 60000 premiers nombres impairs a(i) définis par a(0)=1 puis a(i+1)=a(i)+2 et a(i+2)=a(i+1)+4 soit la suite commençant par 1, 3,7, 9, 11, 15, 17, 19, 23 , 25, 27, 31 et ainsi de suite jusqu'au 60000 ème terme 160001.
    56189 suites de Collatz se terminent par 5 avant d'atteindre 1
    2355 se terminent par 341 avant d'atteindre 1
    1423 se terminent par 85 avant d'atteindre 1
    26 se terminent par 21845 avant d'atteindre 1
    7 se terminent par 5461 avant d'atteindre 1
    Puisque tu t'y connais si bien peux tu donner les résultats obtenus pour les 120000, 180000,  240000 termes de la suite définie ci-dessus ?
  • @PierrelePetit

    Les codes de lignée permettent de facilement répondre à ce type de question
    En effet il suffit de les classer par leur premier membre pour savoir quel est l'impair directement issu d'une puissance de 2 qui est leur ancêtre
    On rappelle que ''1.''= 5; ''2.'' = 21, ''3.'' =85, ''4.'' = 341 , etc...

    Pour les impairs de 3 à 20.001 (soit les 10.000 premiers impairs pour commencer)
    Pour les cdl ayant au moins 2 membres :
    9394 commencent par "1." et donc se terminent par 5
    254  commencent par "3." et donc se terminent par 85
    342 commencent par "4." et donc se terminent par 341
    1 commence par "6." et donc se terminent par 5461
    3 commencent par "7." et donc se terminent par 21845
    soit un total de 9994 auquel on ajoutera les cdl ayant un seul membre soit 5, 21, 85, 1365, 341, 5461 ce qui nous fait 10.000

    On peut évidemment continuer cette liste aussi loin que l'on veut. Mais c'est sans intérêt.

  • Modifié (20 Feb)
    @PMF
    Commence les 1000000 suites de Collatz par les 1000000 premiers nombres impairs a(i) définis par a(0)=1 puis a(i+1)=a(i)+2 et a(i+2)=a(i+1)+4 soit la suite commençant par 1, 3,7, 9, 11, 15, 17, 19, 23 , 25, 27, 31 et ainsi de suite jusqu'au 1000000 ème terme 26666771.

    937966 se terminent par 5

    23814 se terminent par 85
    37654 se terminent par 341
    75 se terminent par 5461
    459 se terminent  pat 21845
    31 se terminent par 349525
    1 se terme par 1398101

    937966+23814+37654+75+459+31+1 = 1000000, pas besoin des prédécesseurs de 1 pour trouver le bon résultat.

    Chercher l'erreur !!

    Pas de problème, que des solutions.

    Si comme tu dis ça ne sert à rien, ça permet à vérifier l'exactitude des résultats de chacun.

    Une dernière question, quel est le plus petit nombre impair commençant une suite de Collatz qui conduit à 1398101 avant d'atteindre 1 ?
  • Modifié (20 Feb)

    PMF : ... trouver une liaison entre un code de lignée et un impair qui ne passerait pas par le recours à une suite de Collatz. Un outil encore imaginaire ...

    Et qui à coup sûr le restera. Il faudra que tu me dises ce que tu fumes, parce que ça m'a l'air d'être de la bonne ! A ton avis, l'arbre de Collatz est-il issu de la génération spontanée ? Collatz a-t-il découvert cette espèce inconnue au détour d'un sentier forestier ? Les nombres dont il est constitué sont-ils différents de ceux qu'on utilise quotidiennement ?

    C'est l'algorithme imaginé par Collatz qui engendre l'arbre portant son nom. Sans lui, point d'arbre de cette sorte. Mais toi qui te prends pour un découvreur de génie, tu crois possible de le reproduire sans passer par ledit algorithme, en assemblant des listes de nombres qui elles-mêmes en sont issues, qu'on ne pourra jamais obtenir sans faire appel à lui, le tout en étant dans l'incapacité de reconnaître cette étroite parenté !

    Il est évident que persister dans son erreur relève chez toi d'une vocation.

Cette discussion a été fermée.
Success message!