On the eventuality of a smallest

counterexample of the Collatz conjecture

Alexandre Bali
December 13, 2018

Abstract
In this paper, we will show a few results which would be implied
if there is indeed a minimal counterexample of the Collatz conjecture,
and trying to find out what kind of properties such a number would
(or wouldn’t) have. This is a revised version, since we recently found
out the original algorithm gave erroneous results.

1 Introduction
The conjecture states that, if we consider (an ) a sequence such that

3an + 1 an odd
an+1 =
an /2 otherwise

then, any value of a0 ∈ N∗ has (an ) oscillate from 1 to 2 past some n.

We’ll imagine a constant a0 > 1 which is the smallest counterexam-
ple, which means that any value below satisfies the conjecture. Then,
no element in the sequence (an ) must be below a0 , because if the se-
quence doesn’t indeed oscillate between 1 and 2 at some point, then
ak < a0 would imply that ak is a smaller counterexample, which is
a contradiction. Therefore, the conjecture is equivalent the nonexis-
tence of a first term a0 such that a0 ≤ an for all n ≥ 0 (hence, the
nonexistence of such a minimal counterexample). Since n/2 < n for
all n > 1, we can show that a0 is forcefully odd.

1
 Let div2 (n) to be the number of times n can be divided by two
until we get to an odd number (the odd number itself being included).
For example, 16/24 = 1 ≡ 1 (mod 2), so div2 (16) = 4. In other words,
we have X
div2 (n) = 1
2k |n,k≥1

and using this function, we could define a new sequence (en ) as

3en + 1
en+1 =
2div2 (3en +1)
which would only give odd numbers if e0 is odd too. In english, we
take an odd value for e0 , and to get the n + 1th term, we multiply the
nth term by 3 and add 1 before we divide it by the biggest power of
two which results into an odd number. We can show that, for e0 = a0 ,
(en ) is a subsequence of (an ). Let e0 be the smallest odd number
which doesn’t satisfy limn→∞ en = 1. Then, e0 would also be smallest
counterexample to Collatz conjecture. From now on, we’ll consider in
this paper that e0 is indeed the smallest counterexample of Collatz
conjecture. The main goal will be to find an algorithm to show some
impossible patterns in the (en ) sequence for this hypothetic e0 value.

2 Theoretical information
2.1 Explicit en+1 ∝ e0 relation
We can show that, for all n ≥ 0, there exists βn such that
n
Y 1
en+1 = (3n+1 e0 + βn )
k=0
2div2 (3ek +1)

We use βn as a shortcut notation, for we don’t even need to find an

expression for it ; after all, all we need to know is that βn 6∝ en .

2.2 Upper bound for div2 (3en + 1)

We know that for all n ≥ 0, en+1 ≥ e0 , by definition of e0 . Using
this, we can derive that
n−1
Y 1
(3n+1 e0 + βn ) div2 (3ek +1)
≥ 2div2 (3en +1) e0
k=0
2

2
After several steps, and using several properties of the logarithm, we
can even get to
  n−1
n+1 βn X
div2 (3en + 1) ≤ log2 3 + − div2 (3en + 1)
e0
k=0

x bxc
Knowing that for x
n+1

∈ R we have 2/2 ≥ 1/2 , we can show that if
log2 3 + βn /e0 ≤ b(n + 1) log2 3 + 1c, then

βn βn
e0 > n+1
≥ b(n+1) log2 3c
3 2·2
Therefore, when e0 satisfies this, we get to a better upper bound for
div2 (3en + 1),
n−1
X
div2 (3en + 1) ≤ (n + 1) log2 3 − div2 (3ek + 1)
k=0

From all of these, we can first off show that if e0 ≡ 1 (mod 2), then
div2 (e1 ) ∈ {1, 2}, which is required for e0 to be the minimal counterex-
emple. Indeed, 1 ≤ div2 (e1 ) < (1 + 1) log2 3 − div2 (e0 ) = 2 log2 3 < 3.
We could afterwards compute that div2 (e1 ) = 1 ⇒ div2 (e2 ) ∈ {1, 2}
and div2 (e1 ) ∈ {1, 2} ⇒ div2 (e2 ) = 1. We could go on for a while,
but instead of doing it by hand, we’ll rather create an algorithm to do
the job itself. Please forgive us for using PHP, we know that’s a much
hated programming language but well, as long as it works...

3
2.3 Algorithm
<?php
function sum($array){
for($i = 0; $i < count($array); $i + +){
$sum+ = $array[$i];
}
return$sum;
}
function conc($array1, $array2){
for($i = 0; $i < count($array2); $i + +){
$array1[count($array1)] = $array2[$i];
}
return$array1;
}
$c + +;
$array[0] = [[1], [2]];
while(0 < 1){
$c + +;
$tempArray = [];
for($i = 0; $i < count($array); $i + +){
for($j = 1; $j <= ($c + 1) ∗ log(3, 2) − sum($array[$i]) −
1; $j + +){
$tempArray[count($tempArray)] = conc($array[$i], [$j]);
}
}
$array = $tempArray;
$a[$c] = $array;
}
//$a[n] is an array that encodes all followable order n paths
//for which a hypothetical smallest counterexemple could take
//because $a[n] = [[1, 1, ..., 1], ..., [div2 (e0 ), div2 (e1 ), ..., div2 (en )]]
?>

4
2.3.1 Outcomes
Unfortunately, it only handles a few iterations, but we could add
ini− set(‘memory− limit‘, b) for some arbitrarily large b, or b = −1 to
not be bothered by memory exhaustion (PHP seems to consider the
p-adic relation −1 = . . . 999), but be cautious doing that. We used
this in previous algorithms, but it never slowed down our computer as
much. Also, we tested with b = 4 294 967 296 but we seemingly got
stuck to only mere sixteen iterations. Oddly, count($a[n]) for values
of n ∈ N∗ seems to follow the same pattern as the number of admissi-
ble sequences of some order j (A100982), which is also Collatz-related.
How weird when one of the article referenced in the OEIS page of the
sequence says that “while working with F : x 7→ (3x + 1)/2div2 (3x+1)
allows one to work only on the odd integers, the variability of div2
seems to prohibit any substantial analysis” and yet finding a common
point with both techniques (which is apparently the sequence). Al-
though, a proof that this is indeed the same sequence seems a bit out
of reach, so it’d be nice to see a proof one day.