I was "playing" on Project Euler and passed across the Collatz Problem, and it mentioned it was still unproven.
I immediately noticed two things:
- After the $3n+1$ the result is always even, leading to $\frac{n}{2}$
- $\frac{n}{2}$ is an trivial action, especially in a binary representation.
The first optimization that can be done is combining the $3n+1$ step with $\frac{n}{2}$.
$\frac{3n+1}{2} = 1.5n+0.5 = n+((0.5n)-0.5)+1$
Looking at the binary representation, $0.5n$ is simply $n$ bitshifted 1 position to the right.
We now focus on $n$ being an odd positive integer (as even numbers are always $2^x$ of an odd number).
Obtaining $((0.5n)-0.5)$ is easily done with the binary representation of $n$, by bitshifting $n$ to the right, and dropping the least significant bit. (Remember, $n$ is odd.)
We know full adders have a well known and well defined behaviour:
$S = A \oplus B \oplus C_{i}$
$C_{o} = majority(A, B, C_{i})$
Doing $n+((0.5n)-0.5)+1$ is implemented using a full adder where the input $B_{i}$ has been connected to $A_{i+1}$

Sorry for the confusion, but the $n$ on the in-/outputs is unrelated to the number $n$; it needs to be $i$. I will fix this in the image.
By definition, an odd binary number has always $1$ as the least significant bit, and obviously, a $1$ as the most significant bit. The $A_{i+1}$ input from the adder handling the most significant bit falls outside the $n$, and as a result, $0$.
$C_{0} = 1$
$A_{0} = 1$
$A_{i_{max}} = 1$
$A_{i_{max+1}} = 0$
After a complete run has been done, $\frac{n}{2}$ gets done if applicable, and the new $n$ gets fed to the calculator again.
Note that each time the length of the number grows on the most significant bit side, a "foreign" $0$ gets output to $S_{i_{max}}$.
$S_{i_{max}} = (1 \oplus 0 \oplus C_{i_{max-1}}) \neq C_{i_{max-1}}$
$C_{i_{max}} = majority(1, 0, C_{i_{max-1}}) = C_{i_{max-1}}$
$S_{i_{max}} \neq C_{i_{max}}$
(This also implies that $n$ never reaches a value in the form of ${2^x}-1$ after the initial value until it reaches $1$ because of the $0$ passed to the $B$ input for the most significant bit. As the only way not to output a $0$ for $S_{_{[msb]}}$ is to not receive a carry trough $C_{i_{[msb]}}$, which means there is at least an earlier bit with $0$ as value.)
But more importantly, when the first $0$ appears in $A_{1}$ will result in an $0$ to $S_{0}$ making the number even, and shrinking the number itself (by applying $\frac{n}{2}$).
$S_{0} = (1 \oplus 0 \oplus 1) = 0$
$C_{0} = majority(1, 0, 1) = 1$
Now, if it keeps finding an alternating bits of $1$'s and $0$'s, it keeps outputting $0$'s, and keeps the carry on. (This allows you to do $\frac{n}{2}$ several times in a row.)
Only if both $A_{i}$ and $A_{i+1}$ are $1$ again, it will start outputting $1$ on $S$.
If however, it encounters a $O$'s on both $A_{i}$ and $A_{i+1}$, the carry $C_{i}$ will will be output to $S_{i}$, and outputs $A_{i}$ to $S_{i}$ until it encounters a $1$'s on both $A_{i}$ and $A_{i+1}$
$S = (0 \oplus 0 \oplus C_{i-1}) = C_{i-1}$
$C_{i} = majority(0, 0, C_{i-1}) = 0$
$S = (1 \oplus 1 \oplus C_{i-1}) = C_{i-1}$
$C_{i} = majority(1, 1, C_{i-1}) = 1$
How does this translate to a proof of Collatz conjecture?
Note that I'm a mere programmer with a hobby interest in math problems, so excuse me for the low quality. However, I still think this is able to prove that Collatz conjecture is valid, as the growth of the number has hard limits (how many carries can reach the end), while the shrink has no hard limit (shrinks until a 1 occurs) and the switching is fair and one-way (full adder).
Note: my personal truth table for the MSB and LSB
MSB Ci MSB
010-0--- -> 011---
010-1--- -> 100---
011-0--- -> 100---
011-1--- -> 101---
B LSB Co LSB
---0-01 -> ---0-10 (additional $\frac{n}{2}$ once)
---0-11 -> ---1-01
---1-01 -> ---1-00 (additional $\frac{n}{2}$ multiple times)
---1-11 -> ---1-11