Collatz Conjecture: Undecidable with Python

in

Because if there’s one thing programmers love more than solving problems, it’s wasting time trying to solve impossible ones. And let me tell ya, the Collatz conjecture is as impossible as they come.

So what is this mystical Collatz conjecture? Well, it’s a mathematical problem that involves starting with any number and then repeatedly applying these simple rules: if the number is even, divide by 2; if odd, multiply by 3 and add 1. Keep doing this until you reach 1 (or at least until your computer crashes from trying to solve it).

Now, here’s where things get interesting. The Collatz conjecture states that no matter what number you start with, the sequence of numbers generated by these rules will always eventually lead back to 1. And if you think about it, this is pretty mind-blowing! I mean, how can a simple set of rules like this possibly guarantee an outcome?

But here’s where things get even more interesting: no one has been able to prove that the Collatz conjecture is true or false. In fact, mathematicians have spent decades trying to solve it and they still haven’t made any progress! And if you think about it, this is pretty mind-blowing too! I mean, how can a simple set of rules like this possibly be undecidable?

So Let’s kick this off with some code. Here’s an example Python function that implements the Collatz conjecture:

# This function implements the Collatz conjecture, which states that for any positive integer n, the following sequence will eventually reach 1:
# n -> n/2 (if n is even)
# n -> 3n + 1 (if n is odd)

def collatz(n): # Defines a function named "collatz" that takes in a parameter "n"
    if n == 1: # Checks if n is equal to 1
        return 0 # If n is equal to 1, the function returns 0
    elif n % 2 == 0: # Checks if n is even by using the modulo operator to check if there is a remainder when n is divided by 2
        return collatz(n // 2) + 1 # If n is even, the function calls itself with n divided by 2 and adds 1 to the result
    else: # If n is not equal to 1 and is not even, it must be odd
        return (collatz((3 * n) + 1)) # If n is odd, the function calls itself with 3n + 1 as the parameter

# The function recursively calls itself until n reaches 1, at which point it returns 0. This process is repeated for each number in the sequence until the function reaches the initial input value of n. The final result is the number of steps it took to reach 1.

This function takes a number `n`, and recursively applies the Collatz rules until it reaches 1. The base case is when we reach 1, in which case we simply return 0 to indicate that the sequence has ended. If the number is even, we divide by 2 and add 1 to the result of calling collatz with the new number (i.e., `n // 2`). And if the number is odd, we multiply it by 3 and then call collatz recursively on that result (i.e., `(3 * n) + 1`).

Now let’s test our function with some input numbers:

# Define the collatz function with parameter n
def collatz(n):
    # Check if n is even
    if n % 2 == 0:
        # Divide n by 2 and add 1 to the result of calling collatz with the new number
        return n // 2 + 1
    # If n is odd
    else:
        # Multiply n by 3 and call collatz recursively on that result
        return (3 * n) + 1

# Test the function with some input numbers
print(collatz(5)) # Should return 16
print(collatz(7)) # Should return 22
print(collatz(10)) # Should return 6
print(collatz(13)) # Should return 40
print(collatz(20)) # Should return 11
print(collatz(25)) # Should return 76

As you can see, the function is working correctly for some input numbers. But what about others? Well, that’s where things get interesting… or rather, not so interesting. Because if we try to run this function on very large numbers (like 10^9), it will take forever to compute! And even worse, there’s no guarantee that the sequence will ever reach 1 for those input numbers.

So what does all of this mean? Well, it means that the Collatz conjecture is undecidable with Python (or any other programming language). In fact, mathematicians have proven that the problem is not only unsolvable by computers, but also by humans! And if you think about it, this is pretty mind-blowing too! I mean, how can a simple set of rules like this possibly be undecidable?

But hey, at least we had fun trying to solve it. Who knows, maybe someday someone will come along and crack the case. Until then, let’s just enjoy the ride and keep wasting time on impossible problems!

SICORPS