Das Collatz-Problem

1. Problemstellung

Es geht um Zahlenfolgen für natürliche Zahlen n > 0, die so definiert sind:

  • a = n
  • wiederhole solange, bis a == 1 ist
    • a = 3 * a + 1 falls a ungerade ist
    • a = a / 2

Beispielfolge für n = 3:
3; 10; 5; 16; 8; 4; 2; 1

Die Collatz-Vermutung lautet nun, dass die Folge für alle natürlichen Zahlen n > 0 mit der 1 endet.

2. Untersuchung der Collatz-Folge im Restklassenring modulo 2^m

Dieser Abschnitt enthält keine Literaturverweise, da der Inhalt eigenständig entwickelt und programmiert wurde. Er stellt keinen Beweis der Collatz-Vermutung dar. Aber er könnte ein Baustein für einen solchen Beweis sein.

Fragestellung: Für welche Zahlen a1 enthält die Collatz-Folge mindestens ein Folgenglied ai, das kleiner als der Startwert a1 ist? Diese Bedingung wird im Folgenden als Kriterium bezeichnet.

2.1 Betrachtung im Restklassenring modulo 2^1

Alle geraden Zahlen erfüllen das Kriterium im zweiten Folgenglied:

ElementStartwertEndwert bei Kriterium
0a1 = 2k + 0a2 = k + 0
1a1 = 2k + 1unbekannt
Anteil für Kriterium = 50%

Somit erfüllen 50% der Elemente des Rings das Kriterium.

2.2 Betrachtung im Restklassenring modulo 2^2

Für Zahlen der Form 4k + 1 ergeben sich die Folgenglieder:
a1 = 4k + 1; a2 = 12k + 4; a3 = 6k + 2; a4 = 3k + 1

ElementStartwertEndwert bei Kriterium
0a1 = 4k + 0a2 = 2k + 0
1a1 = 4k + 1a4 = 3k + 1
2a1 = 4k + 2a2 = 2k + 1
3a1 = 4k + 3unbekannt
Anteil für Kriterium = 75%

Somit erfüllen 75% der Elemente des Rings das Kriterium.

2.3 Betrachtung im Restklassenring modulo 2^4

Für die Zahl 3 lauten die Folgenglieder:
a1 = 3; a2 = 10, a3 = 5; a4 = 16; a5 = 8; a6 = 4; a7 = 2

Es sind hier also vier Halbierungen notwendig. Daher muss der Restklassenring modulo 2^4 verwendet werden.

Für Zahlen der Form 16k + 3 ergeben sich die Folgenglieder:
a1 = 16k + 3; a2 = 48k + 10; a3 = 24k + 5; a4 = 72k + 16; a5 = 36k + 8; a6 = 18k + 4; a7 = 9k + 2

ElementStartwertEndwert bei Kriterium
0a1 = 16k + 0a2 = 8k + 0
1a1 = 16k + 1a4 = 12k + 1
2a1 = 16k + 2a2 = 8k +1
3a1 = 16k + 3a7 = 9k + 2
4a1 = 16k + 4a2 = 8k +2
5a1 = 16k + 5a4 = 12k + 4
6a1 = 16k + 6a2 = 8k +3
7a1 = 16k + 7unbekannt
8a1 = 16k + 8a2 = 8k +4
9a1 = 16k + 9a4 = 12k + 7
10a1 = 16k + 10a2 = 8k +5
11a1 = 16k + 11unbekannt
12a1 = 16k + 12a2 = 8k +6
13a1 = 16k + 13a4 = 12k + 10
14a1 = 16k + 14a2 = 8k +7
15a1 = 16k + 15unbekannt
Anteil für Kriterium = 81,25%

2.4 Betrachtung im Restklassenring modulo 2^5

Für die Zahl 11 lauten die Folgenglieder:
a1 = 11; a2 = 34; a3 = 17; a4 = 52; a5 = 26, a6 = 13, a7 = 40; a8 = 20; a9 = 10

Es sind hier also fünf Halbierungen notwendig. Daher muss der Restklassenring modulo 2^5 verwendet werden.

Für Zahlen der Form 32k + 11 ergeben sich die Folgenglieder:
a1 = 32k + 11; a2 = 96k + 34; a3 = 48k + 17; a4 = 144k + 52; a5 = 72k + 26; a6 = 36k + 13; a7 = 108k + 40, a8 = 54k + 20; a9 = 27k + 10

Auch für die Zahl 23 sind fünf Halbierungen notwendig:
a1 = 32k + 23; a2 = 96k + 70; a3 = 48k + 35; a4 = 144k + 106; a5 = 72k + 53, a6 = 216k + 160,a7 = 108k + 80; a8 = 54k + 40; a9 = 27k + 20

Für die drei Elemente 7, 11 und 15, die das Kriterium im Restklassenring modulo 2^4 nicht erfüllen, ergeben sind nun im Restklassenring modulo 2^5 folgende Veränderungen:

ElementStartwertEndwert bei Kriterium
7a1 = 32k + 7unbekannt
11a1 = 32k + 11a9 = 27k + 10
15a1 = 32k + 15unbekannt
23a1 = 32k + 23a9 = 27k + 20
27a1 = 32k + 27unbekannt
31a1 = 32k + 31unbekannt
Anteil für Kriterium = 87,5%

2.5 Betrachtung im Restklassenring modulo 2^{40}

Für die Berechnung der Anzahl der Elemente im Restklassenring modulo 2^{40}, die das Kriterium erfüllen, müssen jetzt nur noch die Zahlen der Form 32k + 7, 32k + 15, 32k + 27 und 32k + 31 betrachtet werden. Dies wird in dem folgenden Pythonprogramm berücksichtigt. Auf einem PC mit vier Prozessoren erfolgt die Berechnung dieser vier Formen über den Pool-Mechanismus von Python automatisch in parallelen Prozessen. Dennoch dauert die Berechnung mit einem Intel i3-8100 ca. 32 Stunden.

# CollatzRestKlassenRing.py V1.6 für Python 3
# Jens Lippenberger 28.11.2020

from multiprocessing import Pool

def BerechneAnzahlHalbierungenInDerFolge( a1, exponent2 ):
    ai = ( 3 * a1 + 1 ) >> 1
    anzahl = 1
    while anzahl <= exponent2:
        if ai & 1: ai = 3 * ai + 1
        ai >>= 1
        anzahl += 1
        if ai < a1: break
    return anzahl

def BerechneAnzahlGeeigneterElementeImRingProzess( exponent2, start, potenz2, schritt ):
    anzahl = 0
    for a1 in range( start, potenz2, schritt ):
        if BerechneAnzahlHalbierungenInDerFolge( a1, exponent2 ) <= exponent2:
            anzahl += 1
    return anzahl

def BerechneAnzahlGeeigneterElementeImRing( exponent2, potenz2 ):
    parameter = ( ( exponent2,  7, potenz2, 32 ), ( exponent2, 15, potenz2, 32 ),
                  ( exponent2, 27, potenz2, 32 ), ( exponent2, 31, potenz2, 32 ) )
    ergebnisse = Pool().starmap( BerechneAnzahlGeeigneterElementeImRingProzess, parameter )
    anzahl = 0
    for ergebnis in ergebnisse: anzahl += ergebnis
    return anzahl

def BerechneRestKlassenRing( exponent2 ):
    anzahl  = 28 * 2 ** ( exponent2 - 5 )
    potenz2 = 32 * 2 ** ( exponent2 - 5 )
    anzahl += BerechneAnzahlGeeigneterElementeImRing( exponent2, potenz2 )
    print( "m =", exponent2, "; Anzahl =", anzahl, "; 2^m =", potenz2, "; Anteil ={0:8.5f}".format( anzahl / potenz2 ) )

def main():
    BerechneRestKlassenRing( 40 )

if __name__ == '__main__':
    main()

Für die Restklassenringe modulo 2^1 bis 2^{40} ergeben sich folgenden Anteile:

Ring 2^mAnzahl Elemente mit KriteriumAnzahl aller ElementeAnteil
11250,000%
23475,000%
4131681,250%
5283287,500%
711512889,844%
823725692,578%
109601.02493,750%
123.8704.09694,520%
137.8258.19295,520%
1531.47332.76896,048%
1663.42265.53696,774%
18254.649262.14497,141%
201.021.2481.048.57697,394%
212.050.5412.097.15297,777%
238.219.8018.388.60897,988%
2416.490.63516.777.21698,292%
2666.071.49067.108.86498,454%
27132.455.435134.217.72898,687%
29530.485.275536.870.91298,811%
312.123.841.5702.147.483.64898,899%
324.253.619.8134.294.967.29699,037%
3417.027.951.54817.179.869.18499,116%
3534.095.896.99134.359.738.36899,232%
37136.471.574.881137.438.953.47299,296%
39546.144.278.026549.755.813.88899,343%
401.093.108.792.7761.099.511.627.77699,418%

Fazit: Im Restklassenring modulo 2^{40} haben 99,418% aller Elemente a1 in der Collatz-Folge mindestens ein Folgenglied ai, das kleiner als der Startwert a1 ist.