The Collatz Conjecture

A Reformulation and Applications with Intent to

Solve
Morgan T. McKee
4/20/2010

Abstract

The aim of this paper is to summarize the problem of the Collatz Conjecture and the steps
needed to find a solution. This will be done by reformulating the problem and narrowing the
range of possible solutions to a more manageable size. Applications of other areas of thinking
will be applied to this problem in order to explain and help to solve it.
Contents
1. Introduction..................................................................................................................................... 3
2. Statement of the Problem .............................................................................................................. 3
3. History ............................................................................................................................................. 5
3.1 Previous Work and Theorems ................................................................................................ 5
3.1.1 Generalized Formula for the Collatz Problem ............................................................ 5
3.1.2 Allowing for the Use of Negative Integers .................................................................. 6
3.1.3 Using Computer Software to Find a Counterexample ................................................ 6
3.1.4 Inverse Map ................................................................................................................. 7
4. Applications to the Conjecture ....................................................................................................... 8
4.1 Tag Systems ............................................................................................................................ 8
4.2 The Halting Problem ............................................................................................................. 10
4.3 Correlation Between Total Stopping Time and Random Walks ........................................... 10
5. Attempting to Solve ...................................................................................................................... 13
5.1 Induction............................................................................................................................... 13
5.2 Narrowing the Possible Values for n .................................................................................... 13
5.2.1 Collatz Class................................................................................................................ 14
5.2.2 Narrowing by Finding Common Trajectories ............................................................ 15
5.3 Applying an Upper Bound to the Total Stopping Time ......................................................... 16

5.4 Steps Needed To Solve Assuming Truth of the Conjecture .................................................. 17

6. Conclusions .................................................................................................................................... 18
References .................................................................................................................................................. 19
 1. Introduction
The Collatz Conjecture has remained an open problem ever since it was first introduced in
1937. Several attempts have been made in solving this problem using various methods. Some of
these include using computer programs to run through all the possible values, using a
probabilistic heuristic and attempts to prove the theorem directly (or indirectly). This paper will
explain why these methods have not and will not be enough to solve this problem.

The problem that everyone has faced in proving this thus far is that this is believed to be a
valid theorem. In other words, this will need to be proven for every possible value in the
domain of the function. If this were to be an invalid theorem, then one would only need to
provide a single counterexample to solve it. Since there is a degree of uncertainty with the
behavior of this problem, it is difficult to provide a direct proof that such a number either does
or does not exist.

Therefore, the proof of the Collatz Conjecture needs to be reformulated to provide a new
way of attempting to solve it. This paper will explain how such a solution can exist and what
properties that solution will have. This will not be a direct proof of the theorem, but instead be
an informal reasoning that may break ground for a future proof to be formulated.

2. Statement of the Problem

The Collatz problem (or 3n+1 problem) is very easily stated. Two of the main ways of stating
this problem are, first, as a piecewise function of the following form:

and, secondly, to consider the algorithm with the following pseudo code:

collatz(n)
while n ≠ 1
if n is odd then
set n <- 3n + 1
else if n is even then

3
 set n <- n / 2

This sequence will continue in this manner until the sequence reaches 1 or it will not halt. The
theorem behind this problem is to prove that for all positive integers, this sequence will
eventually converge to one. Then this will enter what is known as a 2-1 cycle. We say this
because f(1) = 2 and f(2) = 1 and this produces the recurring sequence <1, 4, 2, 1> [1]. A
sequence in this form is known as the trajectory of n.

The trajectory of n is the sequence of numbers that from a starting input n, the
algorithm reaches before converging to one. For example, the trajectory of 7 is <7, 22, 11, 34,
17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2> and the trajectory of 33 is <33, 100, 50, 25, 76, 38, 19,
58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2>. The trajectory corresponds to
the total stopping time which is defined as the number of iterations that the algorithm needs to
complete on a number n before reaching one or converges toward infinity [1].

Figure 1: Above are the graphs of the total stopping time for f(n) on input n.

If the total stopping time is infinite on some input, this gives the theorem:

Theorem 2.1 The conjecture is false if there exists a number n such that the total stopping time
of n is infinite.

Then considering the contrapositive of this theorem produces:

Corollary 1 If the total stopping time for all positive integer input n is finite, then the conjecture
holds.

There are two ways of using this theorem. The first is to find an n such that the trajectory
diverges toward infinity and the other is that n will produce an infinite loop trajectory that does
not include one. An infinite loop trajectory sequence would be of the form <n1, n2, n3, … , ni, n1>
where n1 is not equal to one. So far, no such number has been found to disprove it.

4
 3. History
The problem was first proposed in 1937 by a German mathematician named Lothar Collatz.
Since it was first introduced, it has received other names such as the Syracuse problem,
Kakutani's problem, Hasse's algorithm, Ulam's problem and the 3n+1 problem. Many attempts
have been made to solve this in the past and generalizations of the problem have also been
formed to help better explain it.

3.1 Previous Work and Theorems

3.1.1 Generalized Formula for the Collatz Problem

One such generalizations of this problem comes from M. Brushci at the Universit`a di Roma in
Rome, Italy. The Collatz problem structure is generalized by the function defined as f(n, b, m)
where

(𝑛 = 1, 2, … )(𝑏 = 2, 3, … )
𝑛
𝑓(𝑛, 𝑏, 𝑚) = 𝑖𝑓 𝑛 ≡ 0 (𝑚𝑜𝑑 𝑏)
𝑏
𝑓(𝑛, 𝑏, 𝑚) = (𝑏𝑚 + 1)𝑛 + 𝑏𝑚 − (𝑛 𝑚𝑜𝑑 𝑏𝑚)𝑖𝑓 𝑛 ≠ 0 (𝑚𝑜𝑑 𝑏)

and the trajectory of n is defined by the sequence Sk by repeatedly calling the function f on
input. More specifically,

𝑆0 = 𝑛

𝑆𝑘 = 𝑓(𝑆𝑘−1 , 𝑏, 𝑚), 𝑓𝑜𝑟 𝑘 = 1, 2, ….

The interesting result of this generalization is in the conjecture that states “If m = b−1 the
sequence Sk shall eventually reach the number 1, irrespective of which positive integer is chosen
initially.” We are interested in the case where b=2 which produces the original Collatz
conjecture [3]. Many have speculated that if we were to expand the conjecture to higher m and
b-values, we would be able provide a general proof that would apply to the Collatz conjecture.

5
 3.1.2 Allowing for the Use of Negative Integers

It is possible that a more general proof of the conjecture could arise from allowing for the use
of all integer inputs. The claim is that every sequence will enter one of the following cycles:

<4, 2, 1> (the original Collatz cycle)

<-2, -1>

<-5, -13, -7, -20, -10>

<-17, -50, -25, -74, -37, -110, -55, -164, -82, -41, -122, -61, -182, -91, -272, -136, -68, -34>

<0, 0> (the trivial cycle)

The idea is that by analyzing this general case, this will provide some insight into the original
Collatz problem [9].

3.1.3 Using Computer Software to Find a Counterexample

For many years, there have been teams using computer software to implement a “Busy Beaver”
method to try to solve the problem. A “Busy Beaver” problem is a term that originated from a
Turing Machine problem where, on an initially blank tape, the machine runs for a very long,
finite, amount of time and then halts. Considering the high total stopping time on inputs in the
Collatz problem, it is unreasonable to compute the trajectories by hand. This means that these
machines are necessary to test the conjecture at sufficiently large values for the input. These
methods continue to run on all sequential values in the domain of the function. When the
machine halts on one input, then it begins running on the next input.

Recently, a research project, simply called the Collatz Conjecture, has used a series of
Internet-connected computers and has been running the problem continually on inputs. The
most recent test was on input 2,362,741,986,945,773,554,503 which ended on February 22,
2010. This project was an extension of the 3x+1@home BOINC project which ended in 2008 and
is based in Wood Dale, Illinois [5]. These tests have shown a direct relation between the input
and the total stopping time as shown below:

6
 Figure 2: This graph shows the best-fit line between the input and the total stopping time of the known trajectories of the
Collatz function.

This experimental evidence is not a sufficient method to prove the conjecture since it will never
reach all possible inputs (all positive integers). This method is simply used to find a possible
counterexample of the conjecture. If there exists such a counterexample, then this algorithm
will not halt on that input. An approach such as this provides a new formulation of the Collatz
conjecture:

Theorem 3.1 The Collatz conjecture holds if and only if on all input n,𝑛 > 0 & 𝑛 𝜖 𝑁, the
sequence halts.

This method is an extension of the Halting Problem which will be explained later in this paper.

3.1.4 Inverse Map

Another way of reformulating the problem is by introducing the inverse map of the function f.
This allows for starting from the end of the trajectory and working back to all the inputs. An
inverse tree will be formed from the inverse function and started at root one. The inverse
function is:

2𝑛 − 1
𝑓 −1 (𝑛) = {2𝑛, }
3
At every node of the tree, two branches will define the children of the node as such, if 2n is an
2𝑛−1
integer, then we will create this child node and if is an integer, we create this child node.
3
2𝑛−1
The 2n nodes are the “even” nodes of the inverse map and the 3
nodes are the “odd”
nodes. An example of this process is

7
 Figure 3: This is an example of the inverse tree that maps the inverse function f-1 starting at root 1.

The idea is that if we continue to branch out from these nodes, the trajectories of all integers
will be formed and if an integer is not represented in this tree, then this integer will disprove
the conjecture [1]. This will have the same problem as with the computer-software method of
solving the conjecture in that we will never reach all positive integers. This method will
therefore not be sufficient evidence of the Collatz conjecture.

4. Applications to the Conjecture

4.1 Tag Systems

An introduction to tag systems comes from Liesbeth De Mol at Gent University, Gent, Belgium:

“Tag systems were invented by Emil Leon Post and proven recursively unsolvable by
Marvin Minsky. These production systems have shown very useful in constructing small
universal (Turing complete) systems for several different classes of computational
systems, including Turing machines, and are thus important instruments for studying
limits or boundaries of solvability and unsolvability.

Tag systems are used to simulate Turing Machines. A tag system consists of a finite
alphabet ∑ = {a0, a1, ..., aμ−1} of μ symbols, a shift number and a finite set of μ words

8
 defined over the alphabet, including the empty word ɛ. Each of these words corresponds
with one of the letters from the alphabet as follows:

𝑎0 → 𝑎0,1 𝑎0,2 … 𝑎0,𝑛0

𝑎1 → 𝑎1,1 𝑎1,2 … 𝑎1,𝑛1
…
𝑎µ−1 → 𝑎µ−1,1 𝑎µ−1,2 … 𝑎µ−1,𝑛µ−1

where each ai,j ϵ ∑, 0 ≤ i < μ. Now, given an initial word a0, the tag system tags the word
associated with the leftmost letter of A0 at the end of a0, and deletes its first v symbols.
This process is iterated until the tag system halts, i.e. produces a word Ai, after i
iterations, having a length smaller than v. If this does not happen the tag system can
become periodic or show divergent behavior.

To give an example, consider the case where v = 3, 0 → 00, 1 → 1101, with A0 =

10111011101000000. We then get:

10111011101000000
110111010000001101
1110100000011011101
01000000110111011101
0000011011101110100
001101110111010000
10111011101000000

The word A0 is reproduced after 6 steps, thus leading to the production of a period of
length 6 [7].”

The application of these tag systems to the Collatz problem is to assign the word a0 to the
number n and a word ai to the number one. The production period will then correspond to the
trajectory of n. This gives rise to the theorem in this paper by Liesbeth De Mol:

Theorem 4.1 “The function f(n) is reducible to a tag system TC with μ = 3, v = 2 [7].”

As described above, if this tag system does not halt, then it can produce a recurring sequence
or diverge toward infinity. This gives way for a new way to solve the conjecture by creating a
tag system that describes f(n) and seeing if it halts on input n. There is a similar method
described in the Halting Problem.

9
 4.2 The Halting Problem

The Halting Problem is one of the most famous problems in the math community. It simply
states that determining if a given Turing Machine will halt on input is undecidable [8].

Informal proof: Assume that for a Turing Machine M on a given input n, there exists an
effectively computable function A, that takes input M and n, defined as

𝑦𝑒𝑠, 𝑖𝑓 𝑀 ℎ𝑎𝑙𝑡𝑠 𝑜𝑛 𝑖𝑛𝑝𝑢𝑡 𝑛

𝐴(𝑀, 𝑛) = {
𝑛𝑜, 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

Since A is effectively computable, then A will produce output on all possible inputs in a
finite amount of time. This is a contradiction since, if M does not halt, it may run
infinitely.

Therefore there does not exist such a function.

The case that concerns us is with a 5-state Turing Machine. The process for this machine is, on
initial configuration (in base 1)
∞0001n+1000000∞

(note: 1n+1 represents n)

calls the function f and eventually reaches terminal tape

∞0001n+10110000∞

by continually calling f and replacing the output by the next number in n’s trajectory. Consider a
process that would start running a Turing Machine on input n, n > 1, and once it halts, start
running this machine on the next input. If this process were to not halt on a given input, then it
could not continue. This value would disprove the Collatz conjecture, but there would be no
way of knowing if this process will halt or not as shown above.

4.3 Correlation Between Total Stopping Time and Random Walks

“In probability theory, a process for determining the probable location of a point subject to
random motions, given the probabilities (the same at each step) of moving some distance in
some direction” [11] is known as a random walk. More information on random walks can be
found from Dartmouth College in [10]. A random walk in its most basic form is known as the
“drunkard walk”. This is the 1-dimensional case where at each step, there is an equal chance of

10
moving one space in either direction (either toward home or the bar) and stopping when it
reaches either end. In our application, the starting point will be at the input n and will then call
Collatz(n) and have one probability of using the even case and another for the odd case. This
will continue, with each step being independent of the previous one, until reaching one. The
pseudo code of this process will be:

Collatz_Random_Walk(n, p)
Set steps <- 0
while n ≠ 1
Set r <- Get_Random_Number()/RANDMAX // 0 ≤ 𝑟 ≤ 1
if r > p then
set n <- 3n + 1
else then
set n <- n / 2 // integer division
set steps <- steps + 1
return steps

The p-values in this process are the probabilities of a number in the trajectory of n to be even.
Below is a graph of these p-values:

1.2

0.8
Probability of Even Numbers
0.6 in Trajectories
Average Probability (.69)
0.4

0.2

0
6501

8001
501
1001
1501
2001
2501
3001
3501
4001
4501
5001
5501
6001

7001
7501

8501
9001
9501
1

Figure 4.1 This graph shows the probabilities of even numbers in the trajectories on inputs ranging from 1 to 10,000.
The average probability in this range is given as the best fit line.

As shown in Figure 4.1, the average p-value is .69. When applying p=.69 as the input for
Collatz_Random_Walk, the following comparisons are shown:

11
 300

250

200

150 Random Walk

Collatz
100

50

0
1 1000 2000 3000 4000 5000 6000 7000 8000 9000

Figure 4.2 in the graph above, the total stopping times of the Collatz_Random_Walk and Collatz are compared on inputs
ranging from 1 to 10,000 (comparisons at intervals of 500).

The difference between these estimated stopping times using a random walk and the actual stopping
times are fairly close (with a few outlier exceptions).

150

100

50

0 Differences Between
Stopping Times
-50
Best Fit Line of
-100 Average Difference

-150

-200

-250

Figure 4.3 This graph shows the differences between the total stopping times of Figure 4.2. The average difference is also
shown to be very close to 0.

12
When averaged, the difference between these stopping times is close to 0 and can therefore be used as
an accurate estimate. This method will be used later in establishing an upper bound for the total
stopping times to solve the halting problem with the Collatz Conjecture.

5. Attempting to Solve the Problem

5.1 Induction

The first and most obvious way to attempt to solve the Collatz Conjecture is by using a proof by
induction on n. We will see why this cannot be done directly. A proof would proceed as such:

If n is odd

n = 3n+1

if n is even

n = n/2

Basis: let n=1

Then we are done since this sequence will enter the loop <1, 4, 2, 1>

Induction step: Assume that on input n, the sequence will reach 1.

Then we want to show this for n+1.

Without further information about the properties of n+1 or a relation

between the trajectories of n and n+1, this cannot be done.

Using a proof by induction will result in a problem that is as difficult to solve as the conjecture
itself. A different method is therefore required to solve this.

5.2 Narrowing the Possible Values for n

The underlying problem in solving the Collatz conjecture is the difficulty in finding a common
relation between the trajectories of all inputs n. Because of this, it seems necessary to test all
positive integers. We will see that this is not required. It can be shown that there does not exist
a “unique” number in the sense that for a given number, there are no other numbers with a
similar trajectory.

Proof: Consider a positive integer n to be unique in this sense.

13
 This implies that n cannot be represented in the following forms:

(1) 𝑛 = 2𝑘, for n even, and

𝑘−1
(2) 𝑛 = , for n odd
3

Case 1: n is even

This means that n can be represented as 𝑛 = 2𝑖, 𝑖 𝜖 𝑁.

Then let k = i and this is the same as (1).

Case 2: n is odd

This implies that n can be expressed in the form

𝑛 = 2𝑖 + 1, 𝑖 𝜖 𝑁.
3(2𝑖+1)
= 3

(6𝑖+3)
= 3

Then let 𝑘 = 6𝑖 + 4.
𝑘−1
This means that 𝑛 = which is the same as (2).
3

Therefore n is not unique.

One way of limiting the possible values of n is by considering all values with common
trajectories together.

5.2.1 Collatz Class

We will define such numbers as a set called a Collatz Class:

Definition (Collatz Class) A set of numbers that are contained in a single trajectory are known
as a Collatz Class.

An example of this is:

Consider the trajectory for 22, <22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2>

The corresponding Collatz Class is the set ∑ = {22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16,
8, 4, 2}

14
 Next, consider the trajectory for 7, <7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4,
2>

This means that 22 belongs to the same Collatz Class of numbers as 7.

If a higher number k were to contain 7 in its trajectory, then 7 would belong to the same Collatz
Class as k and so on. This is useful since it will tell us that on input 22, 22 belongs to the Collatz
Class of 7 and f(7) halts, then we know that f(22) will halt.

Theorem 5.1 For input x, x > 0 and xϵN, f(x) halts and for y, y > 0 and yϵN, if y belongs to the
same Collatz Class as x, f(y) will halt.

This means that if one input in a certain Collatz Class is known to converge to one in its
trajectory, then all other members of that Collatz Class will also converge to one in their
trajectories. The question is how to find these values belonging to a common Collatz Class.

5.2.2 Narrowing by Finding Common Trajectories

From Theorem 5.1, we know that for any member m of a Collatz Class containing an input n
where f(n) halts, f(m) will also halt. Then from the Collatz function, the following theorem
holds:

Theorem 5.2 For all inputs m such that m belongs to the Collatz Class of n such that f(n) halts,
then for all values k defined as

𝑘 = 2𝑖 𝑚, or

𝑘 = 3𝑚 + 1, where m is odd

f(k) will also halt.

Since we know from previous work that for all input values m up to
2,362,741,986,945,773,554,503, f will halt, we can apply theorem 5.2 to these numbers and
reduce the total domain for n that needs to be run for f. The pseudo code of this process is:

Reduced_Collatz(n, A)
set x <- n
if n ≠ A[i] mod 2 and (n-1)≠ A[i] mod 3, for all i ≤ size(A)
while n ≠ 1
if n is odd then
set n <- 3n + 1
else if n is even then
set n <- n / 2
add x to A

15
 Reduced_Collatz(n+1, A)

This program will run through all positive integers k such that k is not defined in the form
described in theorem 5.2. This will drastically reduce the search space of the problem. It still
can never be complete using a method of this type. A program of this type will also have the
same problem as the previous computer software methods in that if a number is found to
disprove the conjecture, Reduced_Collatz will not halt.

5.3 Applying an Upper Bound to the Total Stopping Time

One way of solving the halting problem with the Collatz Conjecture is to apply an upper bound
to the total stopping time. This will make the algorithm stop running if it reaches this bound
and will return, on input, it doesn’t halt and this number should be tested to disprove the
conjecture.

Proposition 5.3 For a sufficient upper bound for the total stopping time, if on input n
Bounded_Reduced_Collatz(n, A) returns that the process does not halt, then n will disprove the
Collatz Conjecture.

Proposition 5.3 cannot be tested until such an n is found. Also, it is unclear what it means to
have a “sufficient upper bound” for the total stopping time. The algorithm for this process will
be an extension of the Reduced_Collatz algorithm and will proceed as such:

Bounded_Reduced_Collatz(n, A)
set x <- n
set bound <- Collatz_Random_Walk(n, .69)
set steps <- 0
if n ≠ A[i] mod 2 and (n-1)≠ A[i] mod 3, for all i ≤ size(A)
while n ≠ 1 and steps < z*bound
if n is odd then
set n <- 3n + 1
else if n is even then
set n <- n / 2
set steps <- steps + 1
add x to A
if steps >= z*bound
return “on input x, the process does not halt”
break
Bounded_Reduced_Collatz(n+1, A)

16
This algorithm will continue to run until one of these numbers is found where the total stopping
time exceeds the upper bound. It is not necessary that this n-value will disprove the Collatz
Conjecture, however it will be a possible candidate. The z-value in this algorithm is a constant
value that will be sufficiently large to ensure that, in the values tested z*bound will be an upper
bound to all known total stopping times. The maximum ratio between the random walk
stopping time and the actual stopping time will provide this z-value.

9
8
7
6
5
4 Rato of Random Walk's
Stopping Times to Actual
3
2
1
0
418
835

9175
1

1252
1669
2086
2503
2920
3337
3754
4171
4588
5005
5422
5839
6256
6673
7090
7507
7924
8341
8758

9592

𝑻𝒐𝒕𝒂𝒍 𝑺𝒕𝒐𝒑𝒑𝒊𝒏𝒈 𝑻𝒊𝒎𝒆 𝒐𝒇 𝑹𝒂𝒏𝒅𝒐𝒎 𝑾𝒂𝒍𝒌 𝑪𝒐𝒍𝒍𝒂𝒕𝒛

Figure 5 Above is the ratio of in the input range between 1 and 10,000.
𝑨𝒄𝒕𝒖𝒂𝒍 𝑻𝒐𝒕𝒂𝒍 𝑺𝒕𝒐𝒑𝒑𝒊𝒏𝒈 𝑻𝒊𝒎𝒆

When testing these ratios up to 100,000 for input n, we find the maximum z to be
approximately 8. To be safe, we will set z=10 in practice. Again, an input n with total stopping
time exceeding this z*bound will not necessarily disprove the Collatz Conjecture, but should
instead be seen as a possible value.

5.4 Steps Needed To Solve Assuming Truth of the Conjecture

Up until now, we have looked at the ways of testing an input for being a possible case for
disproving the Collatz Conjecture. Let’s assume that the conjecture is in fact valid. This implies
that, on all inputs n, the algorithm will halt. We would need to prove this in one of two ways:

(1) First, by providing a general form that will fit all inputs and show that the trajectory
of an input in this form will eventually converge to one, or
(2) by assuming that there does exist an input that disproves the conjecture and arriving
at a contradiction showing that this input cannot possibly exist.

17
For case 1, as described in section 5.1 Induction, this would be as difficult to prove as the
original Collatz Conjecture. Since there is a certain amount of “randomness” involved in the
problem, a general form seems nearly impossible to find. Lagarias sees this as a problem as well
in his conclusion of “The 3x+1 Problem and its Generalizations”:

“The difficulty of settling the 3x+1 problem seems connected to the fact that it is a
deterministic process that simulates ``random'' behavior. We face this dilemma: On the
one hand, to the extent that the problem has structure, we can analyze it --- yet it is
precisely this structure that seems to prevent us from proving that it behaves
``randomly.'' On the other hand, to the extent that the problem is structureless and
``random,'' we have nothing to analyze and consequently cannot rigorously prove
anything” [2].

Therefore, if the structure of this problem truly is “random” as described, then it will be
impossible to provide a direct proof in this form.

In case 2, we arrive at the same problem. Since it seems impossible to find a general
form for an input, then it will be equally difficult to prove that a number disproving the
conjecture cannot exist. In order to prove this, we would need to find the form of such a
number. This makes finding a direct proof of the Collatz Conjecture improbable with the current
methods.

6. Conclusions

In this paper, many of the problems have been addressed to reduce the size of the search space
of positive integers needed to be tested to provide a counterexample to the conjecture. The
problem with whether the algorithm will halt has been improved by providing a sufficient upper
bound for the total stopping time using random walks. Also, using Collatz Classes, there is now
a recursive method for reducing the size of the input space. This method can be applied to the
inputs in which the algorithm is already known to halt to reduce future work in the Collatz
Conjecture project [5].

The Collatz Conjecture still remains unsolved and even with the number of
breakthroughs in the subject, we are still not any closer to providing a clear, direct proof of the
theorem. The only hopes for solving this problem in the future is by either using these
techniques to find a counterexample or for someone to find a way of understanding patterns in
the trajectories to provide a general form that can be applied to all inputs. With this
generalization, we would be able to provide a proof of the Collatz Conjecture, but until then,
this will remain as one of the Mathematical mysteries of our time.

18
 References
[1] “Explorations of the Collatz Conjecture” [Online]. LaTourette, Kelly S. November 2007. Available:
http://math.moravian.edu/mfraboni/math/LatouretteHonors.pdf.

[2] “The 3x+1 Problem and its Generalizations” [Online]. Lagarias, Jeffrey C. January 16, 1996. Available:
http://www.cecm.sfu.ca/organics/papers/lagarias/paper/html/paper.html.

[3] “A Generalization of the Collatz Problem and Conjecture” [Online]. Brushci, M. Available:
http://arxiv.org/PS_cache/arxiv/pdf/0810/0810.5169v1.pdf.

[4] “The Collatz Conjecture: A Case Study in Mathematical Problem Solving” [Online]. Van Bendegem, Jean Paul.
Available: http://www.logika.umk.pl/llp/141/jpvb.pdf.

[5] “Collatz Conjecture” [Online]. Available: http://boinc.thesonntags.com/collatz/.

[6] “Encyclopedia > Busy Beaver Function” [Online]. Available: http://www.statemaster.com/encyclopedia/Busy-

beaver-function

[7] “Tag systems and Collatz-like functions” [Online]. De Mol, Liesbeth. October 22, 2007. Available:
http://logica.ugent.be/liesbeth/TagColOK.pdf.

[8] “Halting Problem” [Online]. Available: http://mathworld.wolfram.com/HaltingProblem.html.

[9] “Collatz Problem” [Online]. Available: http://mathworld.wolfram.com/CollatzProblem.html.

[10] “Random Walks” [Online]. Available:

http://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter12.pdf.

[11] “Random Walk Definition” [Online]. Available: http://www.britannica.com/EBchecked/topic/491074/random-

walk.

19