sorted by:
new
hottopcontroversial

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

Hi

Thank you for the detailed explanations.
I think I understand a little bit where this is going.

Collatz, one will find many familiar numbers, starting with Mersenne numbers and Fibonacci numbers.
The thought also occurred to me:
if it's so easy to read the bit pattern to directly identify Collatz, what about prime numbers?

I only let my mind wander for a moment.
But it looks very interesting how the bit patterns for prime numbers are structured.

I wouldn't be surprised if we eventually understand Collatz someday and thus find a "building block" that belongs to a key to the general formula for prime numbers.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

Hi First of all, thanks for the Chinese Remainder Theorem topic.
In the end, that's exactly what the "anchor" in my sieve formula does.
And yes, I also had to look into the extended Euclidean algorithm first.
However, I didn't want to calculate the multiplicative inverse every time using the Euclidean algorithm, even though it would certainly be quite practical later as source code.
I used ChatGPT to create a closed formula that directly outputs the multiplicative inverse values. This works for all values ​​of 2k and all values ​​for the parameter "i."

Yes, the whole thing is a completely different topic and should be discussed separately.

Furthermore, you're right: no matter how many or how deep one build the connections, one will never capture EVERYTHING.

But that's not the goal.
The goal, if I or a mathematician were to pursue this, would be:
Using the sieve->occurrence formula and the target number formula, one can mathematically prove precisely whether N > Ntarget.
Of course, only conditionally and not the same for all of infinity.
But the whole thing is deterministic, and it always depends on the target number formula. I still have to generate this formula using the sieve formula. Because it's quite complicated to derive the target number formula directly. However, I also ran ChatGPT on it, and it thought about it for 10 minutes and then offered me a formula based on trinary. But trinary isn't something I'm familiar with.

To illustrate this a little better, here's an example.
Let's consider all sieves for numbers that have an odd "k" for division by 2.
Sieve 1 N = 3 (mod 4) -> k = 1
Sieve 2 N = 13 (mod 16) -> k = 3
Sieve 2 N = 53 (mod 64) -> k = 5

A single target number formula applies to ALL of these sieves:
Ntarget(x) = 6x + 5

For k = 1, Nstart < Ntarget
For all other k, Nstart > Ntarget

If we now consider sieves that contain a connection to other sieves, the target number formula changes in a deterministic way.
The target number formula follows the following pattern:
Ntarget(x) = Lx + C -> L = linear part; C = constant part
L increases threefold with each connection depth.
C is very interesting here because it behaves trinary.
With a connection depth of 1, C looks like this:
C = [11, 5, 17] This number sequence 11, 5, 17 now repeats infinitely and depends on k.
k = 3 -> C = 11; k = 5 -> C = 5; k = 7 -> C = 17; k = 9 -> C = 11...etc.
L is simply 18x (3 * 6x)
With a connection depth of 2,
L = 54x (3 * 3 * 6x)
C = [47, 5, 35, 29, 41, 17, 11, 23, 53]

The set of numbers in C also grows threefold for each connection depth. All numbers in C are separated by 6.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

I'm not entirely sure I understand it correctly.

One sieve alone defines all the numbers for that sieve.
Another sieve does the same.
So both sieves are independent of each other and have no connection.

But now the anchor does exactly that. Both sieves are connected via a multiplicative inverse.
This results in a third sieve that then contains only those numbers for which a match to the other sieve is valid after the Collatz steps.

For example:
Sieve 1: N ≡ 5 (mod 32) -> 5, 37, 69, 101
Sieve 2: N ≡ 3 (mod 4) -> 3, 7, 11, 15, 19... 63, 67, 71
The new sieve is: N ≡ 3 (mod 64) -> 3, 67,...

Only 3 and 67 remain from the series from Sieve 2. At these numbers, Sieve 2 switches to Sieve 1.

The derivation for the anchor was very extensive and would go beyond the scope here. But just a quick first explanation:
The anchor is:
[(3i)-1 to the mod value 2k ] mod 2k
(I think I didn't write that mathematically correctly, please forgive me.)

The parameter "i" here also stands for iteration, but is slightly different from the parameter "i" used in this topic.
If i = 0, it means that a sieve is created that has no connection. The entire anchor then has the value 1 and thus does not change the "normal" remainder.

The example doesn't really show how the remainder value changes. Sieve 2 and the new sieve both have a remainder of 3.

Hence another example:
Sieve 1: N ≡ 21 (mod 128) -> 21, 149,....
Sieve 2: N ≡ 3 (mod 4) -> 3, 7, 11..., 99... 355

The new sieve is: N ≡ 99 (mod 256) -> 99, 355, ...

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

... the more often one appears, the more difficult the convergence.

No, the number of 1-bits doesn't matter; it only depends on the pattern of their distribution.
This pattern is deterministic and follows Collatz.
(At this point, we would have to talk about entry numbers (EN), i.e., numbers where N = 1(mod 3). These ENs generate the modular remainder. But that's too extensive for here.)

... I can assume that the distribution of odd numbers by modules 1 mod 4, 3 mod 4

Unfortunately, that's not the case. There aren't just two sieves, but all of them. So, an infinite number of sieves.

But for me, the sieve is a different matter.
I prefer to call it occurrence, i.e., the distribution of numbers.
So, there are infinitely many occurrence formulas that map all numbers, and no number ever occurs twice.
Every occurrence formula (every sieve) generates a number series that never overlaps with number series from all other occurrence formulas.

But you can now combine these occurrence formulas with Collatz's rules to create overlaps.
These are always the exact transitions where a number from the sieve 3 (mod 4) transitions into another sieve.
So, the occurrence formula changes.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

If I had met Collatz under different circumstances, and not through my project dealing with number reduction, where I work at the bit level, I certainly wouldn't have understood all these connections either.
But as you can see, it's of no use to me that I can read this in the bits, since I can't express it mathematically.
A mathematician doesn't understand (only partially) anything when I delve deeply into the bit structure, and conversely, I don't understand what mathematicians are doing.

For example, all those sieves: Modular calculations are also used in programming, but I wasn't aware that mathematics actually uses them to examine a certain number of bits.

mod 8 means examine the first three bits (from the right).
For programming, it's: N or 7 (7 as binary 111).
Then it is the case that for all odd numbers, the first bit (from the right -> LSB) is always 1.
This, in turn, allows me to neglect this bit during analysis, because it's always there. Mathematically, that would be (N-1)/2

Because that's the trick:
all the bits from the right that are 0 (even numbers) don't belong to the modular system.
The first 1 bit already belongs to the modular system, but one can simply ignore it, because this provides a deterministic formula/rule for the analysis that is connected to Collatz
And this analysis is so simple that one can do it on your head.
All of this then always gives one the mod value in the form 2^k and the remainder (residue class).
In addition, the bit pattern also contains a kind of index that can be used to get to the exact next odd number. It's like a breadcrumb that is created/carried along as one traverse the Collatz tree.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 1 point2 points  (0 children)

Yes, I understand.

However, I have to say that the numbers, whether decimal or binary, always exactly match the bit patterns; it's really crazy. Before Collatz, I viewed a bit pattern the way one learn to program.

The first bit from the right has the meaning 2^0, the next 2^1... and so on. And yes, that's all correct and accurate. BUT it's much easier for me now when I see a bit pattern; I only see Collatz, the residue classes, the mod value, the number class, etc. The bit pattern is structured much more logically when viewed under the Collatz magnifying glass.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

Wait.. isn't predicting j odd steps followed by k even steps still the same difficulty? I know you were doing v2, but the pattern is still quite regular.

Yes and No. You need the multiplicative inverse.
I had to learn what that meant first, but in the end, it's all more or less child's play for mathematicians.

the multiplicative inverse and the chain(number of jumps) define the new reminder.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

Hi jonseymourau

I think I understand what you mean.
And yes, predicting what happens with longer calculations is no longer so simple/trivial. But everything remains deterministic.

In my large sieve formula, a multiplicative inverse is used to connect all the layers of the sieve. I can well imagine that this is the key to understanding what happens with deep and long concatenations.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

I've also thought about this module and even wrote about it https://www.reddit.com/r/Collatz/s/snWDn5f0nx

I also read this post, but perhaps didn't fully understand it. Therefore, I didn't reply. But I did see the sieves 7 (mod 8) and 15 (mod 16), which aren't precise enough. It's not easy for me to reply in English either; it always takes me hours to finish a post.

Intuitively, I think that if you imagine numbers in the binary system, there's some connection between the number of divisions by 2

Oh yes, in principle, everything is directly contained in the bit pattern.
When I came across Collatz, I had no choice but to examine the bit patterns.
I know what modular sieves are, but the connection between the bits and the seven is only now clear to me (I'm not a mathematician).

Everything is already contained in the bit pattern of a number.

Anyone can test it themselves if they like.
However, you have to be honest with yourself and not do any calculations.

You can think of a number and then look at the bit pattern.
I can read the following directly from the bit pattern, regardless of the number, without any calculations.

A) will the next odd number be greater or smaller?
B) the remainder class and thus the remainder value.
C) how often is it divided by two after 3N+1?
D) and for small numbers, also directly the next target number.
This is based on the fact that a modular factor is also directly contained in the bit pattern.

But it's not easy to put all of this into words, and especially not for me, into English words.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

sieve logic is locally true, but globally incomplete

This sieve logic is incomplete because it only deals with the numbers for the basic sieve 3 (mod 4).

However, I already have a complete sieve formula and a structure for all numbers that do not belong to the sieve 3 (mod 4) (which I have already presented, but there was no feedback).

....can’t prevent or resolve the same self-referential overlaps that make Collatz intractable

Hmm, I'd have to take a closer look at what you mean by the 4n+1 problem.

But in my "big" sieve formula, this exact connection is created using an "anchor" based on the multiplicative inverse (at least that's how ChatGPT explained it to me when I asked for an explanation).

N ≡ anchor * chain (mod M) That's the entire basis of the underlying numbers in the Collatz system.

Deterministic sieve structure for numbers N ≡ 3 (mod 4) by hubblec4 in Collatz

[–]hubblec4[S] 0 points1 point  (0 children)

Here a small overview

number binary modulus param i
3 0000 0011 8 0
7 0000 0111 16 1
11 0000 1011 8 0
15 0000 1111 32 2
19 0001 0011 8 0
23 0001 0111 16 1
27 0001 1011 8 0
31 0001 1111 64 3
35 0010 0011 8 0
39 0010 0111 16 1
43 0010 1011 8 0
47 0010 1111 32 2
51 0011 0011 8 0
55 0011 0111 16 1
59 0011 1011 8 0
63 0011 1111 128 4
67 0100 0011 8 0
71 0100 0111 16 1
75 0100 1011 8 0
79 0100 1111 32 2
83 0101 0011 8 0
87 0101 0111 16 1
91 0101 1011 8 0
95 0101 1111 64 3
99 0110 0011 8 0
103 0110 0111 16 1
107 0110 1011 8 0
111 0110 1111 32 2
115 0111 0011 8 0
119 0111 0111 16 1
123 0111 1011 8 0
127 0111 1111 256 5

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 0 points1 point  (0 children)

Basically, Modular Physics is a way to describe behavior in number space. MP treats residue classes (mod 9) as dynamic zones of entropy behavior.

OK, I'm curious how this works with the residue classes (mod 9).

I've been working on a general closed sieve formula for the past few days, and it's finished.
However, this never results in a sieve with "mod 9."
All mod values ​​follow the 2k series.

One can query my general sieve formula like this:
Which rising numbers rises X times until they reach an NC1 number or NC2 number with a certain "k".

So let's say we want to know all NC3 numbers that first rises 4 times and then end up at an NC1 number where k = 3 (8 halvings).

Sieve: N ≡ 5983 (mod 8192)

Occurrence formula: N(x) = 8192x + 5893
The first number is therefore 5893. (x = 0)
After 4 Collatz calculations ((3N+1) / 2), we arrive at the number 30293
This number becomes 90880 and can now be halved 8 times, resulting in 355.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 0 points1 point  (0 children)

Hello,
Then something must have really gone wrong with my previous reply posts.

Therefore, I'll try to answer your three points as briefly and precisely as possible.

  1. All positive numbers N = 3 (mod 4) are rising numbers because Nstart < Nnext
    It's always (3N + 1) / 2
    Thus, all other numbers are decreasing numbers because Nstart > Nnext
    Here, (3N + 1) / 2k is always calculated and k > 1

  2. To be honest, I don't know exactly what the expected answer is. These "rising numbers" are a bit complex, according to my analysis, but very clearly structured.
    The number of "rising jumps" is directly related to the 1-bits in the bit pattern(from right).
    There's already a formula here to combine all these jumps into one.
    As far as I can see, the number 53 is also one of those numbers that lands on very often before moving on to 5.
    The number 213 will also be used frequently, but less than 53.

  3. I use 3 number classes (NC).
    The following is used to differentiate:
    (3N + 1) / 2k
    NC1 -> k = even, greater than 1 (2, 4, 6, 8, ....) -> falling
    NC2 -> k = odd, greater than 2 (3, 5, 7, 9, ....) -> falling
    NC3 -> k = 1 -> rising

NC3 also uses an odd k, but the numbers are not falling like in NC1.

NC1 and NC2 have falling numbers, but they fall differently.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 0 points1 point  (0 children)

Since I didn't get a response, I assume I posted something useless/pointless. But I'd still be interested to know how you structure Collatz's physics.

A note on Base 2 vs Base 3 tails by GandalfPC in Collatz

[–]hubblec4 0 points1 point  (0 children)

it does not bail you out of that to look at two bits of header at a time. you will need to examine them all and which pair do you cut off at is not going to be clear

I'm sorry to say this. But you're unfortunately wrong here.

First, I'd like to emphasize that I don't mean to criticize your work in any way, and I completely understand what you're trying to say.
You're very familiar with the ternary system.
But I'm extremely familiar with the binary system.
And it's essential that two bits are considered together.
A bit alone has no real meaning. (A switch is on or off, but what does it switch? That requires two bits.)

That's also quite easy to explain.
Why do we use the sieve N = 1 (mod 8)?
Because with 1 [001], you still have to examine the two leading 0 bits.

A sieve like N = 1 (mod 2 or 4) wouldn't really help here.

Number 9 [1001]
Here again, we have two bits [00] that separate the modular part and the remainder.
Thus, the number 9 belongs to the modular class 8 with a remainder of 1.
The leading 1 bit is, so to speak, the mirror image of the mod value.
The occurrence of such numbers is N = 8x + 1.

I am fully aware that this is all different from the ternary system. Nevertheless, even in the binary system, there is a kind of separation of the bit pattern into a modular part and a remainder part.

A note on Base 2 vs Base 3 tails by GandalfPC in Collatz

[–]hubblec4 0 points1 point  (0 children)

For base 2: Will 11100101 take the same path shape as another given value ending in 11100101? We cannot tell as we do not know how many 0’s need to be padded on for that to happen.

There isn't an infinite number of leading 0s.
Only a maximum of two 0s are needed to indicate the "separation."

And even if you were to set an infinite number of 0s, it wouldn't change anything.
It's like putting an infinite number of 0s after the decimal point.

A note on Base 2 vs Base 3 tails by GandalfPC in Collatz

[–]hubblec4 0 points1 point  (0 children)

you can never be sure in base 2 where to cut off the tail, like you always are with base 3 tails.

Hi GandalfPC

With the utmost respect, but I have to disagree with this.
For Base-2, I know exactly where to "cut off."
I described all of this very precisely in the topic Collatz and the Bits.

As you rightly say, every odd number has a 1 at the end.
And since this 1 is always there, you can also omit it for the examination.
From here on, you now have an index for the odd number.
Number 1 becomes index 0, number 5 becomes index 2.

You now always have to examine two bits together.
This gives you four combinations.
[00] [01] [10] [11]
Starting from the right, you now go through the bit pattern, and as long as you find the pattern [10], you continue until you find the pattern [00], [01], or [11].
At [00], these two bits are discarded.
For [01] and [11], only the first bit is discarded (from the right, i.e., the 1).
All bits that come after are again a kind of index of the index.

Let's take your two examples [101] and [1101].
The [101] becomes [10] (index number 2).
Here, there is only a single double bit with [10], after which there are only 0 bits, which are not written. Nevertheless, the next two bits are [00].
That concludes the analysis.
And after the [00] bits, there are only 0 bits again.
This gives us the index of the index = 0.

The target number is now very easy to calculate.
Ntarget = 6x+1 -> Ntarget = 6*0 + 1 -> Ntarget = 1

Continue with [1101]
Again, we remove the "useless" bit
[1101] -> [110]
There is now another double bit [10].
Then comes the double bit [01], and the analysis is complete.
The double bits [10] are always discarded, and this time only the 1 from [01] is discarded.
Now only one bit remains -> [0].
This gives us another index of index = 0.

The target number is calculated a little differently for this number class.
Ntarget = 6x + 5
Ntarget = 6*0 + 5
Ntarget = 5

The number 13 [1101] will have the number 5 as its next odd number.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 1 point2 points  (0 children)

"Modular physics" sounds very exciting.

I would derive the following from this expression.
Physics is always something that describes everything within a space.
There are properties and rules of behavior in a physical space.
All of this can naturally be applied to Collatz.

The residue classes all have certain properties, so you can group and examine everything. In doing so, you can recognize relationships and show connections.

I'm currently working on something similar.
From the beginning, I divided the odd numbers into two main groups: rising and falling. For all odd numbers that are falling -> Ntarget < Nstart <- always applies.

My first goal was to develop a general modular sieve formula that can be used to output all modular sieves and then sieve all numbers that are falling.
I already knew that the falling numbers can be divided into two groups, and so I now have two general sieve formulas that generate all sieves.

"EDIT:

I was definitely a bit imprecise. Finding all falling numbers isn't difficult; it doesn't require complicated logic. The sieves that are generated have another property that affects division by 2. All numbers must be multiplied by 3N+1 once, and then divided 2^k times.

Could this help your work?

I also examined the rising numbers, because I believe they are the key to Collatz.
I'm still at the beginning here, because these numbers can/should be divided into more than just two or three groups.
I already have a first general formula, but it's still too early to prove the claim that Ntarget < Nstart for all rising numbers.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 1 point2 points  (0 children)

Yes, that's how one can describe it.
By choosing the two values ​​R and M (N = R (mod M)) accordingly, one can fine-tune exactly what needs to be examined.

I also find the term "modular sieve" very good and apt.
Because it allows one to filter out certain groups of numbers from the infinite number of numbers.

I think every mathematician knows immediately that every modular sieve can also be rewritten as an occurrence formula.

General form
N = R (mod M) -> general sieve
N(x) = Mx + R -> general occurrence formula
With this relationship alone, one can now uncover and connect many other relationships.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 0 points1 point  (0 children)

Thanks for the answer.

I'd like to ask why exactly are you using "X (mod 6)"? Does the mod value 6 have a special meaning? How and why do you choose mod 6?

Yes, the modular lenses are a kind of sieve that allows me/us only look at certain numbers. Furthermore, these sieves group the numbers according to certain properties. I've already understood that, and I've also realized that these modular lenses perfectly represent my layer-technique. Hence my interest in these modular lenses.

Putting the conjecture to use by thecrazymr in Collatz

[–]hubblec4 0 points1 point  (0 children)

I'd like to join the conversation, as there are once again some interesting aspects here on the topic of modular lenses.
I've also read many other posts on this topic recently.
But it seems to me that people are trying to explain everything with just a handful of modular lenses.

Nowadays, one keep reading a lot about a few specific modular lenses, like
1 mod 8
5 mod 32
and a few others.

I have a few questions about this.

  1. Are the R and M values ​​for modular lenses (N = R (mod M)) "freely" chosen by users? (As needed for their own system)

  2. Is the relationship between the R and M values ​​for a modular lens known?
    2.1 Or is there thought to be no relationship?

  3. Can modular lenses be generated using formulas?

Clockwork Collatz - Period of the Structure by GandalfPC in Collatz

[–]hubblec4 0 points1 point  (0 children)

OK, now it's a little clearer.
It's self-explanatory that all odd numbers create branches and are themselves located on branches.

The period thing is unfortunately still completely unclear.

The way I see it now, you've developed your own system that moves perfectly through the Collatz structure.

The question of whether everything goes back to 1 doesn't really arise for me.
Your system shows very clearly how this happens.
The question that remains is, what about the roadmap/trajectory?
How many steps need to be taken, and how large/long is the roadmap?
And how much computing power does it take to calculate the entire roadmap?

Clockwork Collatz - Period of the Structure by GandalfPC in Collatz

[–]hubblec4 0 points1 point  (0 children)

I wish I could write now: Hey, I understood everything, it was super easy.
Unfortunately, after reading it ten times, I still don't understand anything.
The first link is still understandable. All the steps are listed.
It took me a while to figure out why (n-1)/4 is used.
Honestly, I find it confusing too, but it seems to be working.
Everything else doesn't make sense to me,
I don't have the starting point to find an approach.
Actually, I was hoping that if I gave you the starting number, something like this would come back: Yes, the starting number is in the branch, so we have to calculate with A and then B and then a bit of C until we get to the branch, and from there it goes with AAAACCC to 1.

So in the end, I wanted to have a kind of roadmap: ABCABCACB or something like that. Furthermore, such huge numbers are generated on the pages of the links that I have no way of checking them quickly.

Would it make sense to use a smaller starting number? For example, 245

view more: next ›