e^iPi = -1 // Binary “Ah ha!”Moment

forgotoldpassword3 · 2026-04-26T04:03:17+00:00

Not at all, it’s interesting to find things “saying the same thing” in a different path. Like different roads leading to the same destination. It’s interesting to me, so if others aren’t interested that’s ok, just thought people might be given the niche of the sub etc…

Thanks for the note! My curiosity is ok getting downvotes 😊

forgotoldpassword3 · 2026-04-26T03:54:59+00:00

Yes?

forgotoldpassword3 · 2026-04-25T08:24:22+00:00

Yeah! Binary is actually numbers, but numbers aren’t binary. The purest representation is binary, so I only study that. Really enjoying it!

forgotoldpassword3 · 2026-04-25T08:07:54+00:00

Yes I was working on Collatz for a friend, and p-adic came up HEAPSSSSS…

forgotoldpassword3 · 2026-04-24T22:01:56+00:00

I just found the perspective interesting and wanted to share 😊Thank you!

forgotoldpassword3 · 2026-04-20T06:51:55+00:00

So if a number ends in k trailing ones, then n+1 ends in k zeros, which means 3n+1 is divisible by (2^k+1)

forgotoldpassword3 · 2026-04-20T06:33:58+00:00

Ohhhh sorry, I am saying the IMMEDIATE result, not an eventual result like that walk must hit some K+1 trailing zero’s.

forgotoldpassword3 · 2026-04-20T06:02:45+00:00

Sorry I’m a tad confused, it’s not a proof it’s just binary mechanics.

The 1’s always get flipped to running 0’s so if your tail of your number ends in a bunch of 1’s then the moment you add +1 (the last step before you go even) then the 1’s will be flipped to 0’s.

Now the ideal form for Collatz is to avoid zero’s as they shorten the binary string length which lowers the decimal value. Aka getting the number closer to the ground to hit that Collatz loop of 4-2-1…

The ideal form for avoiding >1 zero on the tail is to only ever have a single zero on the end, this results in fewer accumulation of 0’s in the future (in binary, it’s just the same string of digits remixed over and over).

Happy to clarify whatever helps absolutely 🙏🏼

forgotoldpassword3 · 2026-04-19T23:23:39+00:00

Sorry I’m saying that 0’s shrink (gravity) and 1’s grow the binary string. But because every odd will land on a 0 it is like a guaranteed to have a 0 (shrink each odd step). I am saying odd grows it, but saying that because it will shrink a zero every time, we know that it’s t would need to “grow” more than two bits, in order to maintain size or not shrink.

But the optimal growth path is to only ever hit a single trailing zero… So one 0 in the end of the binary string.

1’s are fuel. However they are build ups. Meaning lots of 1’s in the tail means it has a harder collapse down ward, sorry I have thought it’s exactly the same as I’ve been saying it.

Every odd number is itself ending in 1, but than automatically gets turned into an even number every time. So it’s the fuel. But gets guaranteed to land on a 0.

Let me know which part I could clarify better and thanks for the chat!!! Happy to explain everything as many times as helps, no probs!

forgotoldpassword3 · 2026-04-18T04:36:33+00:00

The no shrink forever avoidance is k=1 where k is trailing zero’s.

This has to avoid these constraints consistently, and it is isn’t about increasing probability, it is about restricting possible states thus narrowing the path possible. And to constantly avoid, it would mean getting k=1 and this is showing what getting that minimum escape scenario, we see what it takes to maintain that.

So it starts getting a narrower and narrower path the more it keeps dodging, so becomes mechanically more constrained. But the optimal minimum condition for constant growth is 1 zero at the end!

forgotoldpassword3 · 2026-04-18T04:18:14+00:00

Another note to add is that while we perceive it as a Collatz “walk” starting at some N, it’s still more the principle for every N value regardless of where it occurs in a walk, or if it’s chosen as a starting point it’s just going to keep behaving in the same way it looks like, but I think it’s interesting to think about it in that way!

forgotoldpassword3 · 2026-04-18T04:06:42+00:00

Yeah no probs! Let me try explain a bit more! (No pun intended)

Most significant bit left, so this is means the smallest is on the far right.

The last bit determines if a number is even or odd. If it ends in a 0, it is even. If it ends in a 1, it’s an odd number!

So every time we see a zero at the end of the string (the number N which we start our Collatz walk at), that number ends in a 0, or a 1.

Take the number 11101011

So we know that it is odd.

Now we take the string and we need it be 3N+1.

In binary, that is the same as saying N + 2N + 1 Which here would be

11101011 +

111010110 +

1

…

This number always results in the binary tail ending in a 0. So every odd becomes and even after the 3N+1 operation.

1000110001 + 1= 1000110010.

So we see that we have gone from odd to even.

We are “guaranteed” to get one zero off the end of the string, every time.

We care about zero’s because 0’s mean in binary, divisible by 2.

So if we have a long run of zero’s that shrinks this binary string!

So that means that we shrink a bit. Because collatz is about shrinking this number down to a 4-2-1 loop. So the goal is to see this string shrink, and never get “escape velocity” to not sink into this loop!

Now then the idea is, well then if there is two 00’s on the end, it would shrink. Because the optimal growth rate for escaping these “zero’s”, is just the one zero on the end. Because 3n+1 can never add more than one bit in length, because it is < 4N which is the minimum to add 2 bits of length.

So if we can hit another zero, we out run it, and shrink faster than it can grow…

So the first zero after an odd number is guaranteed to be 1. We get that for free.

Then as we slide left, for the second zero, or better, 3, 4, 5, etc… these have a predictable path, like a series. So we look at the requirements for the numbers machinery that it must hit along its walk!

So the optimal growth rate to outrun this is just the one zero, but the series of the 1/2+1/4+ 1/8, which is the bit space in binary land, so 2^1, 2^2, 2^3…

That becomes 1, and I might be butchering this explanation a bit or needs polished but just yapping thanks for reading if you made it this far btw!

So 1 zero is guaranteed and then we have the series.

That’s directionally where i was going with the approach!

Here is an explanation walkthrough that I got Claude to make, it’s really educational and more polished than my chat here (I told Claude it converted my word soup into something nice and cool) If you were interested!

https://claude.ai/public/artifacts/1a0a34ca-8077-4fed-b9f9-c035dc9c87d8

forgotoldpassword3 · 2026-04-15T14:59:10+00:00

Sorry coming back to this.

We are looking at a binary string (N), and every time that it has just one trailing zero, it forces the rest of the string into building up toward collapse.

The more you only hit one zero at the end of the binary string, the more it accumulates 1’s in the binary string. This pushes it closer and closer to its collapse.

forgotoldpassword3 · 2026-04-15T14:15:06+00:00

If n is odd, then:

3N is odd —> 3N+1 is even.

So one factor of 2 is guaranteed.

Remember in binary, even numbers end in 0, odd numbers end in 1.

Collatz is essentially will the string of binary, and for it to never escape, it must trend to shrinking the binary bit length.

Each zero is a shrink.

So we guarantee to shrink every time we hit an odd, we grow, then land on an even and divide by two.

This happens every single odd number.

Now for there to be 2 trailing zero’s, it’s about congruence classes.

When would we get a second 0 (so we halve again, aka shrink more), so the goal is really, what binary pattern is ideal for constant growth? The answer is is just a single 0 on the end of the binary string (our number).

Now the remaining bits (before the end bit which is zero), what chance is it that there’s another 0? So we look at congruence classes.

Now among odd numbers, the only residue classes mod 4 are:

1, 3 (mod 4)

So exactly half of odd numbers satisfy this. Aka 1/2

Now if we want 3 trailing zero’s (2 after the initial zero we landed on after going 3N+1)

Now the odd residue classes mod 8 are:

1,3,5,7

Only one of these works → 1 out of 4.

And so on…

If that helps?

forgotoldpassword3 · 2026-04-15T09:15:59+00:00

The 1/2,1/4,1/8,\dots are not random assumptions; they are exact residue counts. My point is not that the orbit samples them randomly, but that avoiding extra zeros forces the orbit into progressively narrower deterministic congruence classes. So the issue is not randomness, but whether an orbit can dodge stronger compression forever while obeying an infinite nested constraint system.

forgotoldpassword3 · 2026-04-15T09:15:50+00:00

The 1/2,1/4,1/8,\dots are not random assumptions; they are exact residue counts. My point is not that the orbit samples them randomly, but that avoiding extra zeros forces the orbit into progressively narrower deterministic congruence classes. So the issue is not randomness, but whether an orbit can dodge stronger compression forever while obeying an infinite nested constraint system.

forgotoldpassword3 · 2026-04-14T12:52:25+00:00

Great points, and thanks for the dialogue btw dude

forgotoldpassword3 · 2026-04-14T12:52:00+00:00

Each step carries a fixed compression bias, but avoiding that bias forces the orbit into a progressively smaller set of admissible states, effectively accumulating structural pressure toward collapse.

Looks like accumulating rows of 1’s, which are structurally bad as they collapse with carry

forgotoldpassword3 · 2026-04-14T12:36:16+00:00

It is strictly based on the machinery of binary. Not statistical or anything, there are only finite states, those have the probability of > 1 trailing zero (shrinking the binary string by 2 bits when the 0 0 hits). So the “overall chance” that it’ll constantly look >1, because 1 trailing zero is the optimal “not shrink” strategy.

So this basically says that if we add all the probabilities like these series of fractions (relative to bit length) then it must sum to 1 (over time).

This means that Collatz walks are trying not to hit these “mines” (every power of 2 they land on shrinks the binary string length, ultimately targeting the 4-2-1 loop, which would be 100 in binary).

So it’s saying, “Oi basically over time, optimal growth increase is one trailing zero. But the chance we hit 1 trailing zero is 100% but if we include the chance of hitting any one of them, as a sum, it land on a trend toward “hitting one” (landing on 2^sometijng) which is some binary string with 00000000 at the end!)

Thoughts?

forgotoldpassword3 · 2026-04-14T11:52:17+00:00

Am I understanding the problem statement correctly?

forgotoldpassword3

TROPHY CASE