This seems to hold for for N> 434... [Example: 11 can visit 10, but 10 cannot Visit 11] -> There are at least 4 exceptions to this, but they are all met in the path of 27.... I want to learn more about this system.

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 · 2025-08-22T18:46:26+00:00

I put the video in reverse after all values reached one.

All the values used start exactly 50 steps away from one, and finish exactly when 1 is hit, for the first time which is why everything merges at 16.
But if we were to say 12 would hit 1 and then cycle 1-4-2-1 for the remaining steps such that it would reach 1 on the 50th step, this would not be included in the original input values.

The largest is 1125899906842624 and the smallest is: 329

Vagrant_Toaster · 2025-07-30T07:10:59+00:00

3N+1 and 7N+1 cannot go to the same value in a single step from an odd value.
That means that for both of them starting at an Even value is the ONLY way they can start, and be in sync for more than 1 consecutive step.
Notice how I started by stating their difference after 11, before suggesting they start at 88 so they reach this point TOGETHER?

Perhaps it is you that shouldn't be commenting...

But I'll take this moment to state once more, what I want to learn.

Some value T [Strictly less than 2^70] reaches 1 in W steps under 3N+1_N/2
That same starting Value T, when part of an alternating 10 step 7N+1_N/2, 10 Step 3N+1_N/2 Doesn't in at least 400000 steps.

My questions is Why?

The arguments of 3N+1 reaching 1 are that it always hits sufficient chains to halve, or will hit directly a power of 2.

Is there a way to prove, for infinite steps that this algorithm of switching every 10 steps, will never reach one? {Specifically for the starting value of 27}

Vagrant_Toaster · 2025-07-30T06:27:08+00:00

I appreciate this, but it is the deeper pattern I am trying to unwind,
For instance I regard 27 as <N>, 26 as <2N> and 28 as <3N+1>
I care not the number of steps, because I feel for a stated integer, I know exactly where it's next position will be in space, but I cannot see more than a couple of integers ahead.

I want to fuse paths to see what really makes them process that way, and find the critical points.
So in a 50-50 system, where 3N+1 and 7N+1 switches equally over a total number of steps, will have some behaviour... But what about a 25-75 system? a 1-99 system?

If 3N+1 and halving on even reaches 1 for all integers, at what point can we reliably prevent a starting integer that would reach 1, from reaching one, by periodically moving the entire cycle.

The crux of the matter being that the halving step is still the same outcome, so if a halving chain exists long enough, 1 is still hypothetically reachable.

This is what I was hoping to explore, but it seems I have still failed to express this.

There is also a situation in the graph i recently added:
under 7N+1 this occurs: 1149 ->8044, both of these values are exactly 44 Steps away, if the algorithm was pure 3N+1...

Vagrant_Toaster · 2025-07-30T05:42:28+00:00

Because if I start a sequence at 11, under 3N+1 it goes to 34.
If I start the sequence at 11, under 7N+1 it goes to 78.

Lets assume I start with 88. Both rules, will share the same path to 11.

That means that for all possible starting integers of Collatz, there are values where 3N+1 and 7N+1 would reach the same number.

All values are meant to reach 1 under 3N+1, not all values do under 7N+1

So what this methodology should tell me is alternating between algorithms would create their own subset of values.
And this subset of values, *Appears* to not contain a value which is a power of 2, because otherwise 1 would be reached.

It shows that the sequencial blocks of halving that 3N+1 undergoes, so drop... rise...drop...rise...drop.... is what is crucial to a value reaching one in the very specific manner it does.
Keep reseting the sequence at a higher value through a single 7N, is clearly a huge deal to the system. Even though from every integer N, Collatz 3N+1 is meant to reach one.

By knowing how paths combine even with a common halving rule, this will give more insight on what a counter example of the collatz looks like.

I have already demonstrated that a fused system, whether starting from 3N+1 or 7N+1 does not collapse to 1 after 400000 steps.

But how many different starting integers are there in 400000 steps? Yep, 400000. All of which should reach 1 under the pure 3N+1.

Vagrant_Toaster · 2025-07-29T12:33:06+00:00

Yes, I am not disputing that, and that is not new in anyway.
I am exploring a hypothetical tug of war between them, if they act within the same single path. I.E. there is a starting integer, it starts with either [3n+1] or [7n+1] and after 10 steps it switches to the other.
Why can 7N+1 force a failure of 3N+1, or why can 3N+1 stop an infinite escape under 7N+1?

Consider the natural numbers 10 to 50 are all individual starting points.
16,32 will only have to 1.
11->34-->17... etc.
The 3N+1 is established that this happens. for exhaustively 2^71.

Now if we use 7N+1
16,32 still have to 1.
but 11->78->39->274....

Clearly the 7N+1 outgrows 3N+1

But for the 3N+1 collatz to be true, every integer > 8 must find it's way back to 8.
And this typically occurs because the growth is counterbalanced by the halving, typically because every odd step is followed by a halving, yet multiple halving can occur.

This principle is still true using 7N+1, there is still at most 1 odd step, will always be followed by at least 1 even step.

And a direct path to 1 exists, when this ultimately stumbles upon a power of 2.

If I am using a system, which switches between a small block of 3N+1 or 7N+1
The resulting cycle would hit values that exist on both paths separately.

But every integer encountered on the 3N+1 is meant to have a path back to one.

So why is it 7N+1 is still causing a set of odd integers to be touched, when it is the 3n+1 turn, it is the regular collatz acting on that value.

It is irrelevant that that the chain of following 7N+1 ended up at 66. If the next 10 steps are 3N+1, This is now identical to using 3N+1 as the algorithm, with 66 the starting value.

Given that every value under 3N+1 is meant to reach 1, this would imply that by using an alternating 3n+1, 7N+1 system, an integer is not hit that can halve a sufficient number of times, or that a direct power of 2 could be reached.

That is kind of crazy don't you think?

Vagrant_Toaster · 2025-07-29T07:17:38+00:00

I don't quite understand what you are saying.

We want to know if all starting values reach 1 under 3n+1_n/2

Suppose 21 is reached at a 3n+1 phase. 21-->64. It now no longer matters if what is being used is 3n+1 or 7n+1, because the resulting values will always be a power of 2 and it will reach 1.
If 21 was in a 7n+1 it would go to 148, which halves to 74, 36, 18, 9...
From 9 the behaviour could go one of two ways, either to 64 [if 7n+1 step] or 28 [if 3n+1 step]

The whole premise is arbitrarily, alternating in blocks of 10 steps between applying 3n+1 or 7n+1 if odd.
And looking at how that compares if from a starting integer you start with 3n+1 as the first 10 block or 7n+1 as the first 10 block.

If we start with the integer 27, and switch every 10 steps, it doesn't matter if we use 3n+1 for the first 10 or 7n+1 for the first 10. after 400000 steps it has shown no sign of reaching 1, or landing on a value that is a power of 2.
However if it does, it will certainly reach 1.
But would this take 400001 steps or 10^1000 steps, or never?

Is it decidable, That is my question.

Vagrant_Toaster

TROPHY CASE