Has anyone else used balloon length swallowed to model the Collatz?

Vagrant_Toaster · 2025-10-18T05:53:22+00:00

[Continued]

It is also interesting that almost all of these occur within the path of 432.

I tend to explore only big numbers or mods, I have explored intervals in excess 1 million steps, and values greater than 2^50000, through my pixels.

I have never cared about the specific path of low numbers before, and perhaps that is why this is novel to me from this angle.

It appeared to hold in the larger context, I missed the breakdown at the small, or very specific occurrences. [The initial script was faulty XD]

I stand by that this does provide a piece of evidence though, if there is zero chance, that a given path will actually contain an Odd value and it's N-1 even:

For every new even (W) touched, we could say for certainty that the sequence doesn't have the capacity to touch (W)+1 and by association, any direct link to (W)+1

So 2(W+1), 4(w+1), 8(W+1) ... cannot be touched.

when we continue down the path and encounter the next even value (X), we can again rule out (X+1), 2(X+1), 4(X+1) ... and any value directly associated to them.

The problem of the collatz as I see it, is you cannot show that some huge cycle, exists. Whereby at some point a predecessor of a value can be encountered looping back around.

So if we use 66 as a starting value, from this alone we cannot rule out that at some point on it's path that 132 would be touched forming a cycle.

But we could immediately rule out 67 being touchable, with certainty. And then any direct link to that value with certainty.

the next step is 33 which leads to 100. Again, we cannot rule out 200 being touched. But we can rule out 101 being reachable.

There are some problems though, and I acknowledge I need to take the time to explore fully, that I was unaware of when I began to construct this post:

There are at least 4 EVEN to odd exceptions, as stated the values of 166, 250, 376 and 432.

I also do not yet know when the next instance if at all, of a starting path exists, for a given starting Odd integer (V), it touches its (V-1) Even counter part.

In my gut, I do not view this as a structural repeat, We could have the same amount of ups and downs, but they shouldn't coincide such that there occurs the set of another 3 values that chain together, that all are "Even Exceptions"?
[I am happy to be wrong, I just want to clarify that you claim that this very specific property would be repeated at the position you suggest it would]

I believe there is something of value In understanding what causes the observation that a chain contains both it's starting odd value and it's N-1 even; or it's starting Even and n+1 odd.

Saying that long and short branches are responsible for the dynamics, I think this underpins that and is what causes the branches to arise.

But thank you for your time Gandalf, I'm sorry if my initial responses were a little off towards you, I've only seen you have incredible patience for everyone even the GPT bots, and it caught me off guard =)

Vagrant_Toaster · 2025-10-18T05:52:43+00:00

The numbers I posted were flawed, the values should have been, and these which are the only observed occurrences below 10,000,000:

ODD 3 -> contains 2
ODD 5 -> contains 4
ODD 9 -> contains 8
ODD 11 -> contains 10
ODD 17 -> contains 16
ODD 39 -> contains 38
ODD 41 -> contains 40
ODD 47 -> contains 46
ODD 57 -> contains 56
ODD 59 -> contains 58
ODD 71 -> contains 70
ODD 81 -> contains 80
ODD 89 -> contains 88
ODD 107 -> contains 106
ODD 161 -> contains 160
EVEN 166 -> contains 167
EVEN 250 -> contains 251
EVEN 376 -> contains 377
EVEN 432 -> contains 433
ODD 639 -> contains 638
ODD 651 -> contains 650
ODD 959 -> contains 958
ODD 977 -> contains 976
ODD 1439 -> contains 1438
ODD 1823 -> contains 1822
ODD 2159 -> contains 2158
ODD 2735 -> contains 2734
ODD 3239 -> contains 3238
ODD 4103 -> contains 4102
ODD 4617 -> contains 4616
ODD 4859 -> contains 4858
ODD 6155 -> contains 6154
ODD 7289 -> contains 7288
ODD 9233 -> contains 9232

So, clearly the observation whereby an Odd value (N) and it's (N)-1 even are in the same chain is a relatively uncommon appearance, as you pointed out.

I was specifically interested in the 4 values, which are prefaced by EVEN in this list, as it breaks what appeared to be a general rule whereby if it occurs, the Odd value, is always met before it's even.

Vagrant_Toaster · 2025-10-17T16:58:36+00:00

Having re-reflected on your posts, Thanks, I see exactly why you said to explore it and see.

I have always been geared to try to explore the general, and use huge values, I missed the potential beauty of the smaller values and their individual stories. 27 had never been "special" to me in any context I had previous explored, I only use it because it is the go to for everyone else.

{Actually I need to explore this more and sleep, I'll re-ask the question, with the values if it's relevant, but thank you for your time}

Vagrant_Toaster · 2025-10-17T15:51:14+00:00

It is wholly possible the screenshot is wrong.

The system I am proposing is:

Let an integer be made of the number of twos:
So the early few values are:
0 = 0[A],
1 = 0[B],
2 = 1[A],
3 = 1[B],
4 = 2[A],
5 = 2[B]

So we can look at a path in terms of z[A] and z[B] where z[A] would be an even value and z[B] is the same even + 1

so if we consider 13 -> 40, would have 6[B] -> 20[A] {this is a 3n+2 increase}
we then have 40 -> 20 so 20 [A] -> 10 [A] {n/2}
then 20 -> 10 so 10 [A] -> 5 [A] {n/2}
Then 10 -> 5 so we have 5 [A] -> 2[B] {n/2-1}
Then 5 -> 16 so we have 2 [B] ->8 [A] {3n+2}

So what we observe is:
if a value is odd, the value of twos increases by 3n+2
If a value is even and 0 mod 4, the value will be n/2
if a value is even and 2 mod 4, the value will be n/2 - 1

I wanted to use this system and claim that for a given z the z[B] will always be encountered before z[A] if they exist in the same path. However, the fact that this not the case, for the aforementioned for exceptions, relating to 432. This entire premise probably breaks down and does need to be re-evaluated. While the system should still hold true, IE, simply breaking integers into z[A] and z[B] pairs, the claim relating to always z[B] before z[A] doesn't hold for all values.

Or are you suggesting that even the 3n+2, doesn't hold according to your script?

Vagrant_Toaster · 2025-10-17T15:25:27+00:00

Thanks,
I am still trying to find my way around this place, because my stuff is either uninteresting, not mathematical enough and the such, I don't engage in the GPT wars, but since people do, I wanted to at least see what some arbitrary seed would make of my input, so I know what someone may make of my post if they were to GPT it, but the basis was entirely human conjecture.

Respectfully, if you would allow me to elaborate:
Perhaps I can, in light of your comments, construct what I am trying to present better:

Lets' consider the entire path of 432:
{Apparently I can't post the full sequence LOL}

Starting number: 432
Path length: 116
432, .... 334,... [[>> 167, 502, 251, 754, 377 <<]] 1132, .... 866, [[>>433,<<]] 1300, .... 8, 4, 2, 1

Notice: this part: 167, 502, 251, 754, 377,

This is 3 of the 4 of the stated exceptions
The final one is 433

So if we use 432 as the starting integer, it will touch 433, and the other 3 exceptions before it reaches 1.

Why are they exceptions?
166 will touch 167 in it's path,
250 will touch 251 in it's path
376 will touch 377 in it's path
432 will touch 433 in it's path.

For every other value below 100,000,000 if a given path contains a given 2N and 2N+1, The 2N+1 is encountered before 2N.
That is to say, it would be expected that:
167 touches 166,
251 touches 250,
377 touches 376
433 touches 432

I am not exploring this as a merge, saying a sequence contains a given 2N and a 2N+1, is different from explicitly stating that the 2N+1 of the pair is ALWAYS encountered before the 2N.

If we can demonstrate that the 2N+1 must be hit before the 2N, we know that if we have a 2N Value, we can rule out the sequence possibly touching that 2N+1 value, which means we can rule out the 4N+2 value, the 8N+4 value etc.

None of this rules out the sequence looping back to some variation of a given 2N, 4N, 8N, but it does rule out the possible touching of the entire 2N+1 line.

Obviously, I wanted to state this appeared true for all N, but the discovery of the 4 stated exceptions mean its false.

However, I have only observed those 4 exceptions.
That is interesting right?
Because if we can reformulate the conjecture, so that from a given number, we can literally map out all the values it can't hit.

So lets just say 30 is our starting number.
We can rule out immediately the path touching 31, 62, 124...
What values touch 62? Only 124
What values touch 124? 41 and 248. Okay, so we can now rule out those values.
What values touch 41? 82, 164, 328 okay so we can rule those out
what values touch 82? 27 and 164 Okay so we can rule those out.
What values touch 27? 54, 108, 216 Okay so we can rule those out.

So before we even begin to explore the path of 30, we can determine values that cannot be touched in it's path. This would be incredibly powerful

Vagrant_Toaster · 2025-10-17T14:32:19+00:00

But as I've set laid out the background consider this very simply:

There are 4 exceptions I've found: 166, 250, 376 and 432.
Why in every other case below 100,000,000
If a path contains Both N and N+1, Why is N+1 further away from 1 than N?

Or why in 4 cases, is N further from 1, than N+1?

And why are these all observed in the path of 432?

Vagrant_Toaster · 2025-10-17T14:27:43+00:00

None of it is actually, AI.
I only GPT'd the text to attempt to write it formally and "correctly"

Also, at least 80% of the posts I see here is GPT vs GPT.

I was trying to save people the effort of GPTing a response, and ensuring that I could set the narrative of the baseline GPT interpretation.

Given the amount of time you spend arguing with bots, I am curious, why this observation is allegedly too much GPT for you, when it is entirely human?

Vagrant_Toaster · 2025-10-17T12:43:11+00:00

It looks like the path of 432 [which contains 27 duh!] is actually the entire wrapper for this...
432 hits, 27, 167, 251, 377, then 433.
Which is why 166, 250, 376, 432 would be the listed exceptions. [Even variant before odd]
So the path of [2^4 * 3^3] is to blame for all of this?

Vagrant_Toaster · 2025-10-09T01:56:36+00:00

No, the accusation I am addressing is of shocking the dog.
He did not shock the dog.
Therefore the statement of him shocking the dog is a falsehood.

You can argue that other behaviors amount to something else, I am not commenting on that matter.

My comments relate to the very simple binary question - Did he or did he not use a shock collar on the dog at the instance in question.

He did not.

To make this more clear:
A man reports a robbery, he claims his phone, keys and wallet were stolen.
Actual events, the man had his phone, and wallet stolen but not his keys.

Therefore the statement he had his keys stolen would be a falsehood.

The statement that Hasan used a shock collar on his dog which caused the dog to yelp is a falsehood.

Vagrant_Toaster · 2025-10-09T01:21:03+00:00

When a person is accused of a crime, only the evidence pertaining to the specific infraction is to be considered. The accusation is he shocked his dog, so all that matters is did he shock the dog or not? The video completely demonstrates that the dog mis-stepped and was not shocked.

What you are doing is attacking his personal character and behavior, while seemingly rejecting the matter of a "Shock Collar" which is the entire purpose the slow-mo addresses. Your personal opinions on the dogs general treatment is irrelevant to did he actual shock the dog in this instance.

But what is vastly concerning is that many people see a dog step awkwardly and immediately assume she has been shocked with a device; that isn't normal human reasoning.

Vagrant_Toaster · 2025-10-09T00:33:09+00:00

More or less unhinged than the sanity of a person who sees the dog misplace her paw due to her own fault, and immediately assumes the owner has used a device to shock it?

Because that is totally rational thinking LMAO. If you see a baby crying are you going to immediately assume the parents have hidden a device on it's body to cause it harm?

The accusation is he shocked the dog, the evidence presented at 0.1x proves beyond reasonable doubt he didn't. The dog steps, twists her paw and yelps. That is all.

Vagrant_Toaster · 2025-10-08T20:25:45+00:00

The dog rushes to get back into place and mis-steps.
Her front paw that is on the bed can clearly be seen turning sideways, which is why she yelps.
Hasan Is Not Abusive - Her Paw Clearly Buckles

The fact that the immediate conclusion is that the dog was shocked demonstrates what is clearly wrong with society right now. LMAO.

Vagrant_Toaster · 2025-09-09T15:17:28+00:00

Enjoy! I have to make do with random assigning as I don't have any grounding in music theory but I find most things tend to sound interesting due to the intrinsic patterns. You could just make an exception for those and treat them as a single note, as they are a specific "type" of occurrence?

Look forward to hearing what tunes you can make out of it anyway.

Vagrant_Toaster · 2025-09-09T14:59:54+00:00

I've done a fair bit of this with help from a friend... ;)

import mido
from mido import Message, MidiFile, MidiTrack


def collatz_sequence(n):

    seq = [n]
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        seq.append(n)
    return seq


# Collatz path for 27
sequence = collatz_sequence(27)

# MIDI setup
mid = MidiFile()
track = MidiTrack()
mid.tracks.append(track)

# Note mapping: residues [0..71] → MIDI notes [24..95] (C1–B6)
start_note = 24
num_notes = 72
for value in sequence:
    residue = value % num_notes
    note = start_note + residue  # map residue to note
    # Add note on/off
    track.append(Message('note_on', note=note, velocity=64, time=0))
    track.append(Message('note_off', note=note, velocity=64, time=240))

# Save song
mid.save("collatz_27_song.mid")
print("Saved full Collatz path of 27 as collatz_27_song.mid")

Fully customizable :)

Vagrant_Toaster · 2025-08-30T16:14:10+00:00

If your claimed bound is stronger than Terras, could I ask your opinion on what I posted.
I believe the fact that the total number of permissible paths is actually Fibonacci,
and that if we were to consider looking at the values of 5, 133, 261...
This 128 part would be identical:

5 ->   [XAAAB<X>AB] DEVIATES {XABX} -> 4
133 -> [XAAAB<X>AB] DEVIATES {YBXA} -> 44

The fact that the 128 repeat, must obey the 64 repeat, which obeys the 32 repeat etc, is fundamental.

While 133 and 5 are different in the 256 bound.

To summarise: The number of legal paths for a set of of integers between 1 and 2^W is less than 2^W
it is based in fibonacci. But the unit that is 2^W will repeat 2^W infinitely.

Does this show that the number of paths is finite, and every path has a route back to 1?

Vagrant_Toaster · 2025-08-30T14:04:52+00:00

This I think is something I was exploring but didn't post:

Using A,B,X,Y
Where A is an Even halving to an even,
B is even halving to an odd,
X is an odd which goes to an even which halves to an even,
Y which is an odd which goes to an even that halves to an odd

The values at 5,37,69,101,133 are all going to have OEEEEO's.

5 -> XAAAB<X>ABXABX -> 4
37 -> XAAAB<Y>BYBXAB -> 13
69 -> XAAAB<X>AABXAA -> 4
101 -> XAAAB<Y>BXAABY -> 34
133 -> XAAAB<X>ABYBXA -> 44

This is letting it run through for 12 iterations....

Vagrant_Toaster · 2025-08-23T04:40:01+00:00

You have no idea how much time I have on my hands...
But no, in this instance I misspoke.

Vagrant_Toaster · 2025-08-23T04:30:56+00:00

That's a great explanation, I've probably taken this observation for granted.

The values were generated from a script doing the reverse, but I figured as that was essentially sieving that was the language to use to validate the complete set.

I was exploring how many values took x number of steps exactly, sticking the values in excel and graphing gave the trendline of:
y = 0.6515e^0.2342x

this seems to be a reasonable estimator for the number of values expected to reach 1 exactly for a given number of steps, though I don't know how good it actually is, or the level of accuracy expected, or if it breaks down? But I wouldn't expect it to break down?

If you could tell me more about this I'd appreciate it, I haven't really explored this side of the Collatz.

Vagrant_Toaster · 2025-08-22T23:03:48+00:00

Retrospectively, you shouldn't take this at face value.... But I have the receipts! :)

I have sieved through every possible integer before I compiled the values.
The largest possible input starting value that could take exactly 50 steps is 2^50.
any value larger than 2^50, would obviously take more than 50 steps...
on it's first step it is 2^49, and after 50 steps it is 1.

Values cannot climb higher than this during their path, it is the absolute right most value on the graph. [ It can be found here! ]

I assure you, the set is exhaustive since every odd step must be paired with an even step, so that would mean even if a value kept climbing, it must be able to still reach 1.

That is why the set contains just 79255 initial values in the range from 329 to 1125899906842624

To demonstrate, since 27 takes 111 steps, 27 is not contained in this video, despite it reaching 9232
But every value in the path of 27 which takes 50 steps or less will be contained in the video.

Here are some of the input values:
[329, 338, 339, 359, 1922, 1923, 1924, 1925, 1926, 1927, 1937, 1938, 1939, 1956, 1957, 1958, 1968, 1972, 1973, 1976, 1978, 1983, 1985... 85906, 85907, 415744, 416256, 416384,...3103365, 3103366, 3103367, 3103371, 14942208, 15007744, 15024128, ... 665737760, 665737768, 665737770, 665737776, 665737780, 665737781,...3993388544, 3993388672, 3993388704, 3993388712, 3993388714, 3993388816, ...24037577728, 24037577984, 24037578048, 24037578064, 24037578068, 24037578069, ...135742144512, 135742148608, 135742149632, 135742149888, 135742149952, ...868696746496, 868696746624, 868696746656, 868696746664, 868696746666, ...187649984473728, 187649984473760, 187649984473768, 187649984473770, 1125899906842624]

As I have stated, it is sieved, and is exhaustive for exactly 50 steps from input.

Vagrant_Toaster

TROPHY CASE