# The Collatz Step and 2-adic Integers

This is a follow-up to my previous post on Collatz in base 2 and 3. I got a response from a reader, Olaf K., who pointed out that the functions defined there work just fine not only on finite sequences of base 2/3 digits, but infinite sequences as well. In the base 2 case, where the digits were listed from right to left, this has a common mathematical interpretation. An integer with possibly non-zero bits extending infinitely to the left is a called 2-adic integer. And the function defined there yields some interesting observations when applied to the 2-adic integers!

## Brief introduction to 2-adic integers

A standard binary integer is a finite sequence of bits, either 0 or 1, with each bit having a value equal to some power of two. Because any non-negative integer can be written as a sum of powers of two, it can be written in this way.

But a *finite* sequence isn’t exactly right. We can always make that sequence longer, incorporating greater powers of two, by adding zeros on the left side. For this reason, if we think of a binary number as a finite sequence, we get non-unique representations: one with a 1 as the largest digit, but others that add leading zeros on the left. This is messy, so in general we tend to think of a binary integer as having *infinitely* many bits, but with the constraint that only finitely many of them can be non-zero. We don’t usually write the leading zeros, but that’s just a matter of notation. They are still there.

This leads to the obvious question: what happens if you remove the restriction that all but finitely many digits must be zero? The answer is the 2-adic integers. It turns out that we can write a lot of rational numbers as 2-adic integers. For example:

- Even without a negative sign, we can write -1 as …111, the 2–adic integer all of whose bits are 1. Why? Try adding one, and you’ll notice that the result is all 0s, so clearly this is the opposite of 1.
- What happens when you multiply 3 (binary 11) by the 2-adic integer …01010101011? If you work it out, you’ll get 1. So that 2-adic integer is the multiplicative inverse of 3, making it effectively 1/3.

In fact, it turns out that the 2-adic integers include all rational numbers with odd denominators! Not only that, but all of them ultimately end up with digits in a repeating pattern to the left, similar to how rational numbers in traditional decimal representations end up with digits in a repeating pattern to the right. (There are even irrational 2–adic integers that don’t repeat their digits; but they don’t correspond to the traditional irrational numbers, but rather to some completely new concept that doesn’t happen in traditional numbers!)

## The Collatz map on 2-adics

The Collatz map on 2-adic integers can be defined in precisely the same way as it is on integers: even numbers are halved, while odd numbers are mapped to 3*n*+1. But hold on… if we can represent numbers like 1/3, what does it mean to be even or odd?

For arbitrary rationals, this would be a tricky question to answer, but in the 2–adic integers, there’s an easy answer: just look at the 1s place. If it’s 0, the number is even; if it’s 1, the number is odd. This is equivalent to saying that a rational number is even iff its *numerator* is even. And this notion is well-defined because we’ve already constrained the denominator to be odd.

I’m now going to redefine the Collatz step function on binary numbers from my previous post, but with one difference: I’ll assume that the numbers are odd. Because every number therefore ends with a 1, we won’t represent the 1 explicitly, but rather let it be implied. This implied 1 is expressed by the `OddBits`

newtype.

`data Bit = B0 | B1`

newtype OddBits = XXX1 [Bit]

data State = C0 | C1 | C1_Trim | C2 | C2_Trim

threeNPlusOneDiv2s :: OddBits -> OddBits

threeNPlusOneDiv2s (XXX1 bits) = XXX1 (go C2_Trim bits)

where

go C1_Trim [] = []

go C1_Trim (B0 : bs) = go C0 bs

go C1_Trim (B1 : bs) = go C2_Trim bs

go C2_Trim [] = []

go C2_Trim (B0 : bs) = go C1_Trim bs

go C2_Trim (B1 : bs) = go C2 bs

go C0 [] = []

go C0 (B0 : bs) = B0 : go C0 bs

go C0 (B1 : bs) = B1 : go C1 bs

go C1 [] = [B1]

go C1 (B0 : bs) = B1 : go C0 bs

go C1 (B1 : bs) = B0 : go C2 bs

go C2 [] = [B0, B1]

go C2 (B0 : bs) = B0 : go C1 bs

go C2 (B1 : bs) = B1 : go C2 bs

This function, in a single pass, multiplies an odd number by 3, adds 1, then divides by 2 as many times as needed to make the result odd. Therefore, this is a map from the *odd* numbers to other *odd* numbers. The states represent:

- The amount carried from the previous bit when multiplying by 3.
- Whether the lower-order bits are all zeros, in which case we should continue to trim zeros instead of emit them.

This function still handles finite lists, but you can generally ignore those equations, since they are equivalent to extending with 0 bits to the left. And as Olaf suggests, the function extends to the 2-adic numbers by operating on infinite lists. (That is, except for one specific input: …010101, on which the function hangs non-productively. That’s because this 2-adic integer corresponds to the rational -1/3, and 3(-1/3) + 1 = 0, which can never be halved long enough to yield another odd number!)

## Fixed points

The Collatz conjecture amounts to finding the orbits of the Collatz map, which fall into two categories: periodic orbits, which repeat infinitely, and divergent orbits, which grow larger indefinitely without repeating. Among positive integers, the conjecture is that the only orbit is the periodic one that ends in 4, 2, 1, 4, 2, 1, 4, 2, 1…

Since we’re skipping the even numbers, our step function has the property that *f*(1) = 1, making 1 a fixed point. Not all periodic orbits are fixed points, but it’s natural to ask whether there are any *other* fixed points of this map. Let’s explore this question!

We start by looking only at the non-terminating equations for the recursive definition. (Recall that the terminating equations are really just duplicates of these, since leading zeros are equivalent to termination.)

` go C1_Trim (B0 : bs) = go C0 bs`

go C1_Trim (B1 : bs) = go C2_Trim bs

go C2_Trim (B0 : bs) = go C1_Trim bs

go C2_Trim (B1 : bs) = go C2 bs

go C0 (B0 : bs) = B0 : go C0 bs

go C0 (B1 : bs) = B1 : go C1 bs

go C1 (B0 : bs) = B1 : go C0 bs

go C1 (B1 : bs) = B0 : go C2 bs

go C2 (B0 : bs) = B0 : go C1 bs

go C2 (B1 : bs) = B1 : go C2 bs

These observations will be relevant:

- We start in the state
`C2_Trim`

- The
`Trim`

states do not emit bits to the result, only consuming them. Therefore, the output will lag behind the input by some number of bits depending on how long evaluation lingers in these`Trim`

states. - Once we leave the
`Trim`

states, we can never re-enter them. Inputs and outputs will then match exactly, so the lag stays the same forever. - If we’re searching for inputs that evaluate in a certain way, the bits of the input are completely determined by whether we want to stay in
`Trim`

states or leave them, and then whether we want the next output to be a`0`

or`1`

.

Because of this, when searching for a fixed point of this function, the input value is entirely determined by one choice: for how many input bits do we choose to remain in the `Trim`

states. Once that single choice is made, the rest of the input is entirely determined by that plus the desire for the input to be a fixed point.

Let’s work some out.

**Lag = 1**. Here, we want to stay in the `Trim`

states for only one bit of input. Then that bit must be a `1`

, since that’s what gets us out of the `Trim`

state. From that point, we will stay in state `C2`

, and in order to produce the `1`

output bits to match the inputs, we’ll need to keep seeing `1`

s in the input! Then the fixed point here is `XXX1 (repeat 1)`

, which corresponds to the 2-adic integer …111.

We noted earlier that this 2–adic integer corresponds to -1. We can double-check that -1 is indeed a fixed point of the function that computes 3*n*+1 and then divides by 2 until the result is odd. To compute *f*(-1), we first compute 3(-1)+1 = -2, then divide by 2 to get -1, which is odd. So it is indeed a fixed point.

**Lag = 2**. Here, we want to stay in the `Trim`

states for two bits of input. That means we expect the first bit to be `0`

so that we’ll switch to state `C1_Trim`

, and then the second bit to be `0`

again to transition us to the `C0`

state. At this point, we’re producing output, which must match the input bits already chosen, and the input bit we need will always be a `0`

so as to produce the `0`

that matches the input. Then the fixed point is `XXX1 (repeat 0)`

, and keeping in mind that there’s an implied `1`

on the end, this corresponds to the 2-adic integer …0001, which is just 1.

This is the standard period orbit mentioned up above: 4, 2, 1, 4, 2, 1, which is just 1s when we skip the even numbers.

Now things start to get interesting:

**Lag = 3**. To stay in the `Trim`

states for exactly three bits of input, we need those bits to be `0`

, `1`

, and `1`

. This ends up in state `C2`

, with the input sequence `011`

left to match. The next input must therefore be `0`

, yielding a `0`

as output, and leaving us in state `C1`

with `110`

left to match. The next input must be `0`

again, leaving us in `C0`

with `100`

left to match. We need a `1`

next, leaving us in `C1`

with `001`

left to match. Then we need to see a `1`

again to leave us in `C2`

with `011`

left to match. That’s the same state and pending bits as we were in when we left the `Trim`

states, so we’ve *finally* found a loop.

The fixed point that produces this behavior is `XXX1 (cycle [0, 1, 1, 0])`

, and including the implied `1`

on the end, this corresponds to the 2-adic integer …(0110)(0110)(0110)1. This turns out to correspond to the rational number 1/5. We can check that 3(1/5) + 1 = 8/5, and halving that three times yields 1/5 again, so this is indeed a fixed point of the map, even though it’s not an integer.

## Observations about fixed points

A few observations can be made about the fixed points of this map:

- There are an infinite number of them. Every possible choice of lag, starting with one but increasing without bound, yields a fixed point, and they all must be different since they produce different behaviors.
- There are only a countably infinite number of them. This is the
*only*way to produce a fixed point, so the list of fixed points we compute in this way is complete. There are no others. - The 2-adic fixed points are all rational. Once we leave to
`Trim`

states, there’s only a finite amount of state involved in determining what happens from here: the state of the function implementation, together with the pending input bits remaining to match, which keeps the same length. We progress through this finite number of states indefinitely, so we must eventually reach the same state twice, and from that point, the bits will follow a repeating pattern. Therefore, interpreted as a 2–adic number, they will correspond to a*rational*value. - The only integer fixed points are 1 and -1. You can see this for non-negative integers by looking at the terminating equations in the original code: the longest terminating case produces two bits at the end before ending in trailing zeros, so the lag can be no greater than 2. Similar logic applies to negative integers, which have 1s extending infinitely to the left.

In fact, if we work out what’s going on here, we find that fixpoints of this function are precisely 1 / (2*ⁿ* - 3) for *n* > 0. (In fact, *n* = 0 yields -1/2, which is also a fixed point as a rational, but is not a 2-adic integer so it didn’t occur in our list.)

## Periodic points

We can press further on this, and consider periodic points with period greater than one, by composing the function with itself and writing down the state machine that results. This grows more complex, as every additional iteration of the function adds a new choice about lag, yielding a larger-dimensional array of periodic points. The general form of the computation seems to remain the same, but the state diagrams grow increasingly daunting.

The diagram above gives the state transitions for the composition of two Collatz steps. The left two states are those where the first of the two steps has yet to produce a bit. The next six are states where the first is producing bits but the second is not. The final nine, then, represent the situation where both of the two composed steps is productive.

I have not labeled the outputs, but the general rule is that the trim states have no output, the non-trim states with an even number of occurrences of C1 will produce outputs that are the same as their inputs, and the states with odd occurrences of C1 produce outputs the opposite of their inputs.

Because there are now two kinds of trimming that happen, we can choose any combination of the two lags, giving a 2D array of points that repeat with period 2. The computations are similar to the above, so I’ll just give the results for lag 1, 2, and 3 in each dimension.

The diagonal elements are not new. This is expected, though, because a periodic point of period 1 is also periodic with period 2. The off-diagonal elements yield three new period-2 orbits:

- -5, -7, -5, …
- 5/7, 11/7, 5/7, …
- 7/23, 11/23, 7/23, …

Just as with fixed points, we can work out a closed form for the period two points. This time, we get (2^*m* + 3) / (2^(*m*+*n*) - 9). As we noticed above, this simplifies to the earlier formula for fixed points when *m* = *n*. (Hint: the denominator factors as a difference of squares.)

You might wonder if there’s a pattern here that continues to all periodic points, and indeed there is! On the Wikipedia page about the Collatz Conjecture, a formula is given for the unique rational number that generates any periodic sequence of even and odd numbers from the “shortcut” Collatz map. (The shortcut map is defined there as the map that divides by 2 once after each 3*n*+1 step.)

To translate this into our terms:

*m*is the period, which is also the number of lag values.*k*₀ = 0, because the function defined here can only be evaluated on odd numbers.- Each additional
*kᵢ*is the sum of the first*i*lag values. *n*is the sum of all the lag values.

We can make the interesting observation that the sign of the number is determined by the denominator: if *n* > *m* log₂(3), or about 1.585 *m*, then the result will be positive. But *n*/*m* is also understood as the average of the lag values. So looking for positive periodic points amounts to choosing lag values with an average of greater than about 1.585. But perhaps not too much greater, if we want them to be integers, because we should not allow the denominator to grow too large. (Indeed, we saw in the fixed point case above that there was a bound on how large the lag could grow because the output needs to catch up!) Working out more precise upper bounds on lag would be an interesting step toward a search for periodic points.

The fact that this rational number is unique, left somewhat mysterious in the Wikipedia statement, comes down to the way that fixed points of these composed state machines are always determined by how long we linger in each of the trim states. The result on Wikipedia already implies that these are the only periodic points among the rationals with odd denominators. The analysis here also makes it clear that these are the only periodic points in the 2-adic integers, as well, so there are no irrational 2-adic periodic points of the Collatz map.

Of course, the trick would be to show that none of these rational values except for 1 are positive integers, and then that there are also no orbits that increase aperiodically. Actually solving the Collatz Conjecture is left as an exercise for the reader. :)