## Thursday, 24 October 2013

### A binary representation of the Collatz conjecture part 2

We can make several probabilistic observations from this method. And also there are a few things that we can note about the way the patterns develop (I’ve mentioned these in previous posts, but I think using binary gives more clarity).

I will summarise these quickly here but will give more detail on some of these thoughts later. I think a lot of this stuff would also apply to any binary attempt at Collatz, so suspect it isn't too groundbreaking, just interesting to see how it works.

1. If the active part of the number ends 111110 (any number of 1s) then these digits will end up as 000000. So 10 -> 00, 110 -> 000 etc.
2. If the active part of the number ends 01010100 (any number of 01s) then these digits will end up as 11111110
3. If the active part of the number ends 0000000 (any number of 0s) then these digits will end up as 0101010
4. At each stage we mark one digit with an X, reducing the active part of the chain by 1 digit. We may also skip any number of 1s to reach the next 0 – this further reduces the active part of the chain by however many 1s we skipped.
5. At each stage the whole binary number is extended by 1 or 2 digits (for an infinite chain we would need this to stay below about 1.6)
6. Any 1s that remain in the non-active part of the chain represent a skipped 1. However long the initial chain, the last zero will ‘catch up’ with the start of the chain if the number of skipped 1s is more than the amount by which the extra digits exceed 1 per step. So, say we start from a 20 digit number. After 100 steps we will have reach (approximately) a 180 digit number, and we will have 100 Xs. If we have in addition skipped a one 80 times, then we must have reached a number without any zeroes.
7. So if this chain doesn’t reach 1 (eg is a counterexample to the conjecture) we need to have a number that has more zeroes than 1s in the non-active part – in fact we need the proportion of 1s to stay below about 40%.
8. This isn’t actually very surprising since it is equivalent to a well known probabilistic result – on average we would expect each step in a Collatz chain to halve twice (since the average number of factors of 2 among all even numbers is 2). A binary number with 50% 1s and 50% 0s is equivalent to a chain with an average of two halvings per step. This is also equivalent to a chain that is falling in value and thus one that must eventually reach 1.
9. The final thing which I find really interesting is that if we isolate any number within the binary chain, that set of digits will behave the same way as if we started from that number, as long as they remain active. (for instance if we have a number 10100110 then the last 3 digits will behave the same as the last three digits of the chain for 7 given in the previous post). This gives us a rather stronger probabilistic approach – since all ‘small numbers’ eventually lead to 1, we can probably assume that an average section of their hailstone sequence is downward. The binary representation of a very large number contains a large number of smaller numbers if we isolate these. The digits for these numbers will behave the same way as a section of their own hailstone sequence, so this gives us a fairly strong reason to expect the overall sequence to contain the same proportion of 1s and zeroes as the smaller numbers, which would mean it also has to reach 1 eventually. Of course, as with any probabilistic approach this can’t rule out the numbers ‘conspiring’ in such a way as to produce a counterexample. So to get from here to a proof would involve more than just probabilistic speculation.
10. One possible approach might consist of running this binary addition backwards. This can be done, for instance you can show that 100X can only be reached from 11X + 10 (though it’s a bit fiddly for bigger numbers…) But one would need to prove that starting from a chain of 1s you can reach any even number. Which is probably no easier (or different to) the original conjecture so not sure it helps.

### A binary representation of the Collatz conjecture

Here is a restatement of the Collatz conjecture expressed in binary numbers. It is a compression and extension of recent posts on this subject which I think gives a bit more clarity.

First I’ll explain the method, then I’ll explain why it works.

I.                    Starting from any odd number N, write it down in binary, but turn the final 1 into a 0 (in other words write down the even number N – 1.

II.                  Next, add 2N – which is just N with an extra zero on the end.

III.                Now, mark the final 0 of the resulting number with an X so you don’t ‘use it again’ next time (but continue to treat it as a zero). Also ignore any 1s to the immediate left of that number. The remnant of the binary number will be a new even number. This is the active part of the number. For instance, if you have 1100111X – the even number is 1100.

IV.                Change the zero at the end of this even number to a 1 and add a zero at the end -> 1010. Then add as many zeros as there are 1s and Xs at the end of the previous number you reached, then add the result to the previous number. For instance, to 1100111X, add 110100000

V.                  Repeat steps III and IV. Keep doing this until you have no zeros left – this will give you the Collatz chain for N (I’ll explain how after the example).

So the Collatz conjecture can be restated thus – repeating this process will always lead to a number with no remaining zeros.

I’ll run an example for N = 7
N-1 = 110
2N = 1110 (=2x7)
110
+ 1110
10100
Mark last zero X  ->  1010X
Add 101100 (note that 1011 = 11)
1010X
+ 101100
100000X
Mark last zero as X  ->  10000XX
Add 10001000 (note that 10001 = 17)
10000XX
+ 10001000
110010XX
Mark last zero as X  ->  11001XXX
Add 110100000 (note that 1101 = 13)
11001XXX
+ 110100000
1001101XXX
Mark last zero as X  ->  10011X1XXX
Add 10100000000 (note that 101 = 5)
10011X1XXX
+ 10100000000
111011X1XXX
Mark last zero as X  -> 111X11X1XXX
No zeroes remaining

OK, so what is happening here? I’ve mentioned before that we can do two things to a Collatz chain. First, if you ignore the halving, you can express the chain thus:

(3^n x X) + 3^(n-1) + [2^a x 3^(n-2)] + [2^b x 3^(n-3)] …. + [2^c x 3]+ 2^d = 2^e

The calculation can be of any length (as indicated by the dots) but must fit two requirements:

1)      The power of 3 falls by one in each term, until we reach 2^n x 3 in the penultimate term.
2)      The power of 2 increases in each term but can rise by more than 1 at a time – so in the example above e>d>c>b>a.

For instance, the chain for 7 would be

7*243 + (1x81) + (2x27) + (4x9) + (16*3) + (128x1)  = 2048

Secondly we can find an equivalent chain that uses the same powers of 2 – but not multiplied by powers of 3 - to reach the same total.

For instance the equivalent for the above chain is

1897 + 1  + 2 + 4 + 16 + 128 = 2048

I have previously explained that to find this equivalent chain, we can use the system below:

A+1
B+1+2^p
C+1+2^p+2^q
D+1+2^p+2^q+2^r (where r > q > p)

p, q, r are defined by the power of 2 you need to add to reach a multiple of the highest power of 2 possible. For instance, from 36, adding 2 gets you to 19 x 2, adding 4 gets you to 5 x 8, adding 8 gets you to 4 x 11, adding 16 gets you to 4 x 13 and so on – so you need to add 4.

To get from A to B etc, you add the first term to twice the full equation. For instance:

A + 2(A) = B
B + 2(B+1) = C
C + 2(C+1+2^p) = D

Etc. Here is the worked example.

7
21+1=22 (=11*2)
21+(2*22)=65
65+1+2 = 68 (=17*4)
65+(2*68)=201
201+1+2+4=208 (=13*16)
201+(2*208)= 617
617+1+2+4+16 = 640 (=5*128)
617+(2*640)=1897
1897+1+2+4+16+128 = 2048

Now, the binary method given above is simply a cleaner way of doing the exact same thing. At each step we add the next number in the Collatz chain x 2^n.

In the chain above we ended up with 111X11X1XXX
11101101000 = 1896 – or if we replace the last digit with a 1 it is 1897.

There is a reason for this apparent ambiguity. If instead of starting from 6 we had started from 7 and tripled it, then followed the rest of the path above, then we would have replicated the method above. However, if we had reached 7 from a precursor in a Collatz chain, we would have reached a number where the active digits were 110. For instance, if we start at 9 and use the binary method above:
9 = 1001
N-1 = 1000
2N = 10010 (=2x9)
1000
+ 10010
11010
Mark last zero X  ->  1101X

The active part of this number is 110..

If we continue the process we will reach the same number 11101101000 but with an extra 1X on the end (the last 2 digits of 1101X). And the equivalent number for any chain that passes through 7 on the way to 1 will also start with 11101101000.

This is a number to which we need to add 1 + 2 + 4 + 16 + 128 to reach a number without zeroes. (each of the zeroes or Xs mark a power of 2 we would need to add to reach this)

A number without zeroes is one less than a power of 2. If we then add 1 more (because in fact the chain started with N, not N – 1) we reach a power of 2. This is why a number with no zeroes marks the end of the chain, the point at which a normal Collatz chain reaches 1.

I'll make a few observations on what this method shows us in another post.