Pour les curieux, un petit script en .net pour le tester.
1. On indique un impair (un très grand nombre devrait marcher, si tr-s grand, peut-être changé le type int en Bigint),

2. Le nombre de colonne on veut afficher.

Console.Write("Enter an odd starting value x: ");
var inputX = int.Parse(Console.ReadLine());

Console.Write("Enter the number of terms n: ");
int n_terms = int.Parse(Console.ReadLine());

var sequence = new List<(int n, long L)>();
for (int n = 0; n < n_terms; n++)
{
    var inputL = ((3 * inputX + 1) * (long)Math.Pow(4, n) - 1) / 3;
    sequence.Add((n, inputL));
}

string csvPath = "c:\\compressed_syracuse_sequence.csv";
using (var writer = new StreamWriter(csvPath))
{
    writer.WriteLine("n,L_x[n]");
    foreach (var item in sequence)
    {
        writer.WriteLine($"{item.n},{item.L}");
        Console.WriteLine($"{item.n},{item.L}");
    }
}

Console.WriteLine($"Sequence exported to: {csvPath}");

Je me réponds à moi-même.

C'est une formule connue mais pas si courante sous cette forme-là.
On retrouve souvent une autre formule y => 4y +1 pour représenter les écarts entre les valeurs des colonnes.

Mais elle met moins en avant l'aspect structuré (et nécessite des itérations si on veut aller parcourir dans des colonnes très éloignées).

Me concernant, elle a été le point de départ d'une analyse plus poussée du tableau de compression de Collatz.

Pour les curieux, je joins ma petite étude sur le sujet. Certainement des choses déjà vu et plus approfondi ailleurs, mais qui reste intéressant d'un point de vue amateur et les curieux comme moi de ce tableau intriguant.


PDF - 499 Ko

Salut,

merci et beau boulot.

Merci

J'ai poursuivi l'étude à partir du tableau compressé des impairs.

- J'ai  re-modélisé en distances paires : toute distance entre deux impairs est paire.
  Pour une distance D donnée, on obtient deux couples (racine, lien) :





- Exemples (par distance) :
  D=2 : (3,5) et (9,7)
  
  D=4 : (7,11) et (17,13)
  
  D=6 : (11,17) et (25,19)

On retrouve ainsi le tableau des impairs :
- 3 → 5 car (3·3+1)/2 = 5
- 9 → 7 car (3·9+1)/2^2 = 7

Sur cette base, j'ai pu produire un autre tableau/grid

Transition : du modèle “distance paire” vers la “glued grid”

(1) Re-étiquetage. Pour tout impair y, on pose

Chaque impair vit donc sur une “ligne” indexée par D.

(2) Deux branches canoniques (venant du modèle distance ci-dessus) :
les couples (r_{-},Y_{-}) et (r_{+},Y_{+}) décrivent exactement les paires “(racine, lien)” du tableau compressé.

(3) Observation centrale (pur calcul). Si y=2D-1 est impair, alors


En “oddisant” :


En re-étiquetant :


(4) Naissance de la “glued grid”. Pour chaque D, on se donne deux “positions” :
— le bord gauche L(D) qui représente y=2D-1 ;
  
— un pivot M(D) sur la même ligne (il sert de “couture”).
  
On introduit deux mouvements atomiques :
• LH : L(D) → M(D) (on “parcourt” la demi-ligne) ;
  
• SEAM : M(D) → L(Σ(D)) (on “coud” vers la ligne imposée par l'algèbre).

(5) Exactitude en 2 pas. Pour l'impair y=2D-1, on part de L(D).
Un pas LH puis un pas SEAM amènent à L(Σ(D)).
Cette position représente exactement T(y), car


(6) Sens “structurel” de la couture (SEAM). Le facteur 2^{\nu_2(3D-1)} retiré par oddize
correspond à “combien de fois” on retire des 2 (on peut le voir comme une somme de coutures « unités » κ∈{1,2}).
SEAM encode cette part “2-adique” du pas impair ; LH encode la traversée du demi-bloc (parcours horizontal de la ligne).


Identité “glued grid” (clé)



Tableau — Partie A (D = 1…8) : on ajoute le pivot P=3D−1 et v=ν₂(P)

PDF - 274 Ko

"Dire 'ΔΨ > 0 sur chaque arête' ne suffit pas. Il faut prouver que Ψ est intégrable (que la 1-forme est exacte), c'est-à-dire qu'il existe une fonction globale Ψ : nœuds → ℝ telle que Ψ(v) - Ψ(u) = ΔΨ(u→v) pour toute arête.
Sans cette intégrabilité, un cycle peut avoir somme de poids > 0 même si chaque arête a poids > 0.
Contre-exemple : Graphe A ⇄ B avec poids +1 dans les deux sens. Chaque arête a poids > 0, mais il y a un cycle !"

Par conséquence, difficile de prouver le no-cycle via Ψ.

L'IA a proposé de faire avec la partie 2, c'est-à-dire d'utiliser un certificat dual :

Supposons un cycle y₀ → ... → yₘ = y₀
Sur un cycle : Σ Δlog₂(yᵢ) = 0 et Δh = 0
Par inégalité de bloc : 0 ≤ μ*_aug · S ≤ μ*_aug · m
Or μ*_aug < 0 et m ≥ 1 → Contradiction !

Si ça intéresse quelqu'un, je met ici la mise à jour du document.