I recently went on a nice long SCUBA diving trip with my wife and daughters. Lots of diving implies lots of showers, and lots of showers means lots of shower-thoughts! An especially interesting one I had turned into a nice way to visualize some aspects of the Collatz Conjecture.

The Collatz Conjecture defines a very simple function on all positive integers as follows:

• If the number is even, divide it by 2
• If the number is odd, multiply it by 3 and then add 1

If you can prove that repeated applications of this function, starting from any positive integer, will eventually reach 1 then you have proved the Collatz Conjecture and won a million dollars and plenty of fame and glory!

Individual inputs are trivial to verify. For example, if we start with 6, we get:

• 6 is even, so 6 / 2 → 3
• 3 is odd, so 3 × 3 + 1 → 10
• 10 is even, so 10 / 2 → 5
• 5 is odd, so 5 × 3 + 1 → 16
• 16 is even, so 16 / 2 → 8
• 8 is even, so 8 / 2 → 4
• 4 is even, so 4 / 2 → 2
• 2 is even, so 2 / 2 → 1

I'm not going to solve the Collatz Conjecture. Somehow I'm turning 50 this year, and my PhD was more than two decades ago (and in a branch of math that's unlikely to impact the conjecture). But I love that it's just there, waiting and inspiring people. I hope to see it solved in my lifetime.

Anyway, my shower-thought was that it would be nice to visualize this repeated application of the Collatz function for many positive integers all at once, rather than just one at a time. To do that, I thought, why not keep track of the sequence of branches taken for each input and then since there are only two branches, why not treat them as binary digits?! We could use those binary digit sequences to make a fraction from each input, by summing 2^-nb_n for each bit b_n in the sequence, making it really easy to graph them and perhaps more easily see what the Collatz process is doing.

After a little more thinking I decided this approach would be a little too naive. The output of the Collatz function at each step seems like it would be biased towards producing even numbers, making the bit-sequences more full of one binary digit than the other, and maybe obscuring any interesting features we could otherwise see. I decided I would fix that by immediately dividing by 2 at the end of the 3n + 1 step (since we know 3n + 1 will be even if n is odd). It turns out this idea is well-known, as the "shortcut" Collatz function.

With that tweak, here's a simple JavaScript implementation of this idea:

function collatzBits(n) { 
    let bits = [];
    while (n !== 1) {
        if (n % 2 === 0) {
            bits.push(1);
            n = n / 2;
        } else {
            bits.push(0);
            n = (3 * n + 1) / 2;
        }
    }
    return bits;
}

function bitsToFraction(bits) { 
    let fraction = 0;
    for (let i = 0; i return fraction;
}

Here's an interactive version you can play with. Try putting in a few numbers to see how the Collatz process gets encoded into binary fractions.

Choose an input n =
The corresponding sequence of bits, interpreted as a binary fraction, is 0.0₂
which is 0 as a decimal.

Something fun to think about: How long of a bit-sequence can you construct? Can you make an arbitrarily long one, by choosing the right starting number?

Of course, now that we have a mapping from positive integers to fractions, we can also plot them.

Here's a plot of the Collatz fractions for the first N positive integers. You can adjust N to see more points. Try some big values of N to get a sense of the distribution of the Collatz fractions. N =