/sci/ - Science & Math

OP here. Continuing:

I wrote a Python program to find sequences of consecutive adecous numbers below ten million. (My personal laptop will only do about a million integers a minute, so I haven't checked beyond that). I have found proper sequences of consecutive adecous numbers for every length up to 32, except for 28 and 29; I'm pretty confident that if you ran it out to a hundred million or higher you'd find 28 and 29, along with a bunch of higher sequences.

In fact, I'm so confident that I'm willing to make a conjecture and put money on it:

DEFINITION. An "adecous" number is any positive integer whose Collatz path does not end in the 10-path ({3 or 20} > 10 > 5 > 16 > 8 > 4 > 2 > 1).

CONJECTURE (STRONG VERSION): For any natural number n, there exists a *proper* sequence of n consecutive adecous integers. ("Proper" means that the sequence isn't a subsequence of a longer sequence, so if you find a 20-sequence it doesn't count for a 19-sequence.)

CONJECTURE (WEAK VERSION): For any natural number n, there exists a sequence of n consecutive adecous integers; this sequence may be a subsequence of a longer sequence. (Thus if you find a 20-sequence it counts for 19 and below.)

One property that may be useful that I've figured out is that the proportion of adecous integers seems to bottom out at about 6.2%. 129 of the first 2000 (6.45%) integers are adecous; 6258 (6.258%) of the first hundred thousand are; 620,924 (6.20924%) of the first ten million are adecous. Presumably there's some lower bound where no matter how many integers you have, at least 6.2% or so will be adecous.

Prove either the strong or weak version of the conjecture, and there is a $20 Amazon gift card available to you, which can be received by putting your email in your proof post. Disprove either version, and it'll be $40.

Ok where do I start?

When I have time Ill write a C script.
Do you have a method of finding good candidates?

>>10628930

Here's the Python script I wrote. I'm only a babby programmer so it's probably not as efficient as it could be.

https://pastebin.com/6n4GggXb

>>10628781
>please do my thesis for me /sci/

>>10628782
>seems to bottom out around 6.2%
Inb4 OP calculates more digits and it magically agrees with some known constant from geometry or generating functions which leads to a proof strategy for Collatz. Monitoring this thread

>>10628962
There's also an interesting pattern where usually, the first sequence of n integers long appears before the first sequence n+1 integers long, but not always. Exclamation points mark the first proper sequences of length n which appear after the first proper sequence of length n+1.

First proper 2-sequence (twin) starts at 85.
First proper 3-sequence: 300.
4-sequence: 1610 !
5-sequence: 802
6-sequence: 5729
7-sequence: 10132
8-sequence: 18104
9-sequence: 64368 !
10-sequence: 15276
11-sequence: 20368
12-sequence: 27156
13-sequence: 56946 !
14-sequence: 40744
15-sequence: 85424 !
16-sequence: 36208
17-sequence: 228874
18-sequence: 2130924 ! (this one was a bitch to find and the reason I went to ten million; in fact it's so out of whack I ran the program again to make sure I hadn't fucked anything up. I don't think I have, but others are encouraged to check. My python script is above.)
19-sequence: 203436
20-sequence: 482219 !
21-sequence: 305162
22-sequence: 1516682 !
23-sequence: 1201439
24-sequence: 1280001
25-sequence: 5392672 !
26-sequence: 1601921
27-sequence: 8543616
28-sequence: not yet known
29-sequence: not yet known ! --but clearly appears after the first proper 30-sequence.
30-sequence: 5419009 !
31-sequence: 4261852 !
32-sequence: 3033376

"U-turning" sequences (sequences of length n which appear in the integers before the first proper sequence of length n-1) can themselves be rendered as an integer sequence:

4, 9, 13, 15, 18, 20, 22, 25, 29, 30, 31 and possibly 28.

I think this is all correct. I need to redo my program so that it displays sequences by length rather then by where it finds them in the integers.

>>10628781
>Adecous numbers are rare-ish. There are only 129 below 2000:
Was this list generated automatically? If so, you have a bug somewhere: 10 is missing.

>>10628930
>C
>script

>>10629023
Numbers contain themselves in their Collatz paths, you imbecile

(though even if you allowed it, it would have no effect on OP's conjecture)

>>10629029
Your conjecture is about paths that terminate in {3 or 20} > 10 > ... > 1. 10 doesn't terminate in {3 or 20} > 10 > ... > 1, so it should be in the sequence.

If this is the way you're going to handle friendly and constructive criticisim, then I will no longer be participating in this thread. Goodbye.

Oh, TIL there are ways to tell who is responding to themselves and etc.

My apologies--though I recognize it's not exactly sincere given I did it thinking "Anonymous" was just "Anonymous." New to 4chan.

>>10629081
I had sort of been under the impression that being pointlessly snarky was usual 4chan style. My apologies to all; I won't do this again.

>>10629061
>>10629081
>>10629118

>>10628782
Can you try working out this constant out for larger n? You might find it's a well known one.

OP here, here's a better version of the program that outputs the sequences in question in order of length into the console, so you don't need to go hunting around for the first sequence to have, say, 19 numbers in it when you told the program to look for sequences of at least 16: https://pastebin.com/MKmQnA2y

I went ahead and checked the lowest sequences again. They're all correct, and there still aren't any 28-sequences or 29-sequences below 10 million.

A friend of mine builds MOAR POWAH DESKTOPS for fun and has volunteered to find sequences up to 100 mill. I will report back.

Why did 10+ posts get deleted?

>>10629134
lol you're seriously gonna try dunking on someone with that 2011-era meme? what next, calling it leddit?

>>10628781
>>10628782
If you were to randomly generate an infinite list of numbers where every natural number has a 6% chance of being in that list,
then you can find consecutive sequences of any length in that list.

So your conjecture doesn't really say anything about the clustering you observed.

>>10629671
OP here.

> Can you try working out this constant out for larger n? You might find it's a well known one.

Yes. At lower levels, it depends on how you define 'adecous'. I'm using the definition "anything that does not ever hit 10 in its Collatz path, including 10 itself."--so the list goes 1, 2, 4, 5, 8, 16, 21...

The convergence right now is:

n <= 10 : 50%
n <= 100 :13%
n <= 1000: 6.9% (nice)
n <= 10,000: 6.01% (wait, what?)
n <= 100,000: 6.258%
n <= 1M: 6.2290%
n <= 10M : 6.20924%

Here's a better version of the program that outputs the sequences in question in order of length into the console, so you don't need to go hunting around for the first sequence to have, say, 19 numbers in it when you told the program to look for sequences of at least 16: https://pastebin.com/MKmQnA2y

I went ahead and checked the lowest sequences again. They're all correct, and there still aren't any 28-sequences or 29-sequences below 10 million.

I have a friend whose hobby is building desktops for MOAR POWAH. He's volunteered to run the program on his machine to look at the first hundred million, but I want to look into optimizing the program for speed first. Programmer friend says there is probably a bottleneck in the process of running every single integer all the way through the entirety of its Collatz chain.

>>10628782
So basically an adecuous number is a number whose path encountera 3 or 20 at some point?

>>10628781

Here's a C program, it does all numbers up to 200 million in 27 seconds on my ryzen 2700x, 45 seconds if you print them all out to console. It saves all adecous numbers to an array that it finds along the way. Going through the array to count longest consecutive numbers should be trivial.

#include <stdio.h>
#include <stdlib.h>

int binary_search(int *array, int length, int search){
int start = 0;
int end = length - 1;
while(start <= end){
int mid = (start + end) / 2;
int c = array[mid];
if(search == c)
return mid;
else if(search > c)
start = mid + 1;
else
end = mid - 1;
}
return -1;
}

int main(){
const int n = 200000000;
int adecous_count = 0;
int *adecous = calloc(n / 10, sizeof(int));
printf("calculating\n");
for(int x = 1, i = 1; i < n; ++i, x = i){
while(x != 10 && x >= i){
if(x == 1){
adecous[adecous_count++] = i;
break;
}
x = (x % 2) ? x * 3 + 1 : x / 2;
}
int index = binary_search(adecous, adecous_count, x);
if(index != -1)
adecous[adecous_count++] = i;
}
printf("printing\n");
for(int i = 0; i < adecous_count; ++i){
printf("%i\n", adecous[i]);
}
return 0;
}

>>10629830

Technically it's defined as one that encounters 10. Unless you start with 10, then 10 in a Collatz chain must come from 3 or 20--that's where the branch starts.

(there's also a branch at 16, which can be from 5 or 32, but I'm not looking at it right now. It would look basically the same, because 5 can only come from 10, and so adecous numbers (above the first few, which are basically just trivial instances outputted by the exact definition) can also be thought of as any integer whose Collatz path goes though 32. All numbers except 8, 4, 2 and 1 have paths that go through 16. So, past about the mid-teens, the question is really about numbers that got to 16 via 32 vs. those that got to 16 via 5.)

>>10629848
>Here's a C program, it does all numbers up to 200 million in 27 seconds on my ryzen 2700x, 45 seconds if you print them all out to console. It saves all adecous numbers to an array that it finds along the way. Going through the array to count longest consecutive numbers should be trivial.

Wow. Thank you. I'll see what I can do with it.

>>10629854
Keep us updated OP. Very interesting thread

>>10629854

Here's a tiny speed up of the code : replace the line
x = (x % 2) ? x * 3 + 1 : x / 2;

with

x = (x % 2) ? (x * 3 + 1)/2 : x / 2;


x*3+1 is divisible by 2 so you can do two steps at a time.

For another performance boost, you should change the array in the program to be a 'hash table' so say you want to calculate all adecous integers up to n, make an array of length n initially all zeros, call it A, then you will change the ith index of the array to 1 if i is adecous, keep as 0 if not. You can assume for all j<i, A[j] so use that fact when calculating if i is adecous or not. (I'd do it myself if I knew C).

Also could you or >>10629848 calculate the value of the constant for each n divisible by n*10,000,000 for each integer n<21 say?

all adecous numbers that are larger than 16 are just the ones that eventually go to 32

youre (OP) just splitting the numbers up since there are 2 ways you can reach 16
from above at 32 and from below at 5 (the only way to get to 5 is through 10)
the adaceous numbers are those that come from above
so any number which reaches any power of 2 greater than 16 is immediately adecous

if we look for a general formula for the consecutive numbers
a, a+1
such that a goes down, goes down again then goes up
and a+1 goes up then down then down and then they equal after this
we get that a must be even, and divisible by four, and a/4 must be odd
so a = 4(2n+1)
the smallest such twins are
12,13
20, 21
28, 29
36, 37
...
21 is the only adecous among them

if we look for all adecous pairs
n=10
84, 85 is the smallest
im not going to check for others since im not going to code any of this
and i havent determined a simple way to check if a number is adecous

my conjecture will be that every sequence of consecutive numbers will contain a pair that satisfies the condition
ie 300, 301, 302 contains 300, 301 which is just n = 37
1610 , 1611, 1612, 1613 contains 1612, 1613 which is n = 201

for all sequences longer than 8 this is already guaranteed

>>10630363
The binary search on the array goes through about 50mb of data with n = 100 million, i'm not sure if a hash table would improve the execution time due to poor data locality. I will definitely try it out as soon as I get back home on Saturday, an post the resulting code here

>>10629849
Based on this, I'd be interested to see the asymptotic proportions of numbers that end up going through 16 vs. 32. vs. 64, etc.

>>10631034
if it goes through 32 it must have come from 64
and 128 iff 256
so on, so you only need to look through numbers of the form 2^(2n+1)

>>10631042
Right, so I guess the next power of 2 that can be reached a different way is 1024 = 3*341. Would we see most numbers above that come through 341 or 2048?

>>10631050
id guess 341, analogous to 5 being more frequent than 32 to reach 16
but we'd need someone to check

>>10631058
Seems reasonable to me. I like this line of investigation.

>>10629801

> If you were to randomly generate an infinite list of numbers where every natural number has a 6% chance of being in that list,
then you can find consecutive sequences of any length in that list.

> So your conjecture doesn't really say anything about the clustering you observed.

This is not quite right. You're basically imagining that God is flipping weighted coins, each of which has a 6% chance of getting heads. If he does that long enough then sure, he'll end up with a sequence of heads as long as he wants.

But in reality, we see *far more* sequences of consecutive heads then we should just given the numerical proportion of heads in the integers. Here is a calculator to find the probability of a string of n heads within k trials, given a probability p on each coin: https://www.gregegan.net/QUARANTINE/Runs/Runs.html

Now you can't input a *probability*, exactly--rather you need to choose the nearest integer n to the probability such that n/100 is closest to your probability. 1/16 is 6.25%, which is close enough for now.

We know there is a quintuplet under 1000. If adecous numbers were distributed randomly among the integers, we would expect this to have a 0.08% chance of occurring. We would not expect a quintuplet to appear on average until the upper bound was 1,118,480.

Again: there's a 10-sequence at 15276. The chances of finding a 10-sequence under 20000 is 1.7 in a hundred million; on average you'd need to look at the first trillion-plus integers before finding a 10-sequence.

So it's clear that the distribution isn't random, and that sequences are appearing far more frequently and earlier than they "should". This raises a new question:

Given a sequence length n, is it possible to determine an upper bound below which a sequence of that length (weak version: can be a subsequence, strong version: must be proper) will appear?

>>10629801
the set of all odds is 50% of all naturals and there arent any consecutive sequences in there longer than 1

>>10629816
Watch that bitch turn out to be tau

>>10628781
Mod(1,2,3,4,5,6,7,8,9) Even and odd anon in this base system ? Will do this soon thought ...The infinite sequence of additions implied by a series =0

>>10631078
Let's take a look. There are non-trivial branches at 64 (from 21, or 128?) and at 1024 (341, or 2048)?

Changing the program takes ten seconds. Let's do the 64-fork first, with

> if 21 not in pathlist: adecouslist.append(pathlist[0]). # still called adecous because I can't be assed to change the code there

Results:

n <= 10: 100% (trivial).
n <= 100: 97% (all but 21, 42 and 84)
n <= 1000: 99.4% (all but six numbers that decompose to 21 * a power of 2)

We don't have to check beyond that for a simple reason. How do you get to 21? 20 isn't divisible by 3, so you have to latch onto the chain of 21 multiplied by powers of 2 (21, 42, 84, 168...) All of these are divisible by 3. That means that you can only get there from another member of that sequence, because no odd integer n will get into the sequence via Collatz path (it's an "orphaned chain"). So the only numbers that do go through 21 will be in that sequence. Finding consecutive integer sequences is thus uninteresting. You'll only see proper sequences that satisfy (21*2^n) - (21*2^n-1) for some n. Anything else has to go through 128.

-------------------

OK, let's look at numbers that take the 1024-fork. Now intuitively it seems there should be more to bite on here because 341, unlike 21, isn't divisible by 3. Also, 341 is big, so it's pointless to look at proportions for n <= 10 or 100 (none of them go through 341.

Results:

n <= 1000 : 97.5%
n <= 10K: 96.63% (NOT an "area of rarity")
n <= 100K: 96.309%
n <= 1M: 96.2089%

Convergence here appears to be to about 96%, give or take. Let's see if we can figure out why (next post).

>>10631495
To get to 341, you have to get through its double, 682. Now an interesting property of mod 3--there's surely a quick proof for this but I don't have one, so I'm assuming it for the moment because it looks like it's probably got to be true--is that if you have a number k such that k mod 3 = m and m != 0 (i.e., k isn't divisible by 3), then the sequence (k*2^n) mod 3 will flip between 1 and 2:

5 mod 3 = 2
10 mod 3 = 1
20 mod 3 = 2
40 mod 3 = 1
etc. etc.

341 mod 3 is 2, and you can only latch onto its power-of-two chain from an odd when the mod is 1. So let's look at which numbers in its series allow odd sources:

341: no odd sources
682: from 227
1364: n/a
2728: from 909
...i.e. every other number here will have an odd predecessor

In fact, let's just write a quick Python program to write odd numbers that source into 341 this way:

topexponent = int(input("Top exponent: >"))

oddslist = []
for i in range(0, topexponent+1):
triple = (341 * (2 ** i)-1)
if triple % 3 == 0:
oddslist.append(triple / 3)

print(oddslist)


Result up to 341*(2^20) - 1:

Top exponent: >20
[227, 909, 3637, 14549, 58197, 232789, 931157, 3724629, 14898517, 59594069]

Now, all of these numbers are odd. And that's a problem, because under the Collatz path, no odd number will ever give another odd number on the next path. So all of their predecessors have to be even. What are their even predecessors, and what are those predecessors mod 3? Editing the program quickly, we find:

Top exponent: > 20
[454, 1818, 7274, 29098, 116394, 465578, 1862314, 7449258, 29797034, 119188138]
[1, 0, 2, 1, 0, 2, 1, 0, 2, 1]

(continued in a third post)

>>10631496
In other words, as you go up the tree of sources of 341, you're looking at about only every third number at any point in the tree being sourceable from anything other than its power-of-2 series.

hen when you find a number that can be sourced from an odd, and you multiply that odd by 2, you again find that that number has only about a third of a chance to be sourceable from another odd.

Does this tell us anything about the convergence? Uh, maybe. This is starting to look like the sum of 1/(3^n) as n goes to infinity: 1/3 + 1/9 + 1/27... = 1/2. Except that you are already pruning off the (93.8%) of numbers that can't go through 341 because they go through 5, and the (basically insignificant) proportion of numbers that can't go through 341 because they go through 21. So on average, if you zoom out far enough, nearly half of all numbers that don't go through 5 should go through 341. Half of 6.2% is 3.1%; 100% - 3.1% is 96.9%.

About 0.8% of integers are missing here and that proportion can't merely be accounted for by powers of 2 and (21*2^n). The next branching power of 2 is 4096, which can be from 8192 or 1365. My guess is that numbers that fall into higher forks at even powers of 2 account for the missing proportion.

-----------------------------------------

What does seem clear is that if we are looking at consecutive sequences, probably only the original adecous numbers, whose Collatz paths don't include 10, are of any real interest.

>>10631497
Oh, quick addendum. Are there any other uninteresting branches?

How often should we run into branches like the 21 branch that are totally uninteresting? An uninteresting branch is one where a power of 2 is fed into by a multiple of 3, that is, where (2^n -1)/3 mod 3 = 0.

The powers of 2 will blink between 1 and 2 in mod 3: [2, 1, 2, 1, 2...] starting from 2. That means that 2^n - 1 will blink between 1 and 0, [0, 1, 0, 1, 0, 1...] at [1, 3, 7, 15, 31, 63...] In other words, every other power of 2 has a branch, when its modulo 3 is 1. And that branch is uninteresting when its modulo *9* is also 1 (because then 2/n - 1 can be divided by 3, and the result can also be divided by 3, as in 21).

How do the powers of 2 cycle modulo 9? They cycle [2, 4, 8, 7, 5, 1] starting from 2. The 21-cycle is uninteresting because 64 (2^6) mod 9 is 1. The next uninteresting cycle should be the branch at 2^12, i.e. 4096, whose odd feed-in is 1365.

But note that every odd power of 2, because it gives 2 modulo 3, doesn't have a branch. These are branches whose modulo 9s are [5, 8, 2]. So every third branch should be an uninteresting one:

64: uninteresting branch at 21
128: no branch
256: interesting branch at 85--somehow we missed this one
512: no branch
1024: interesting branch at 341
2048: no branch
4096: uninteresting branch at 1365

etc. etc.

>>10631522

For the 85-branch, here are proportions:

n <= 100 = 98% (all but 85 and 75)
n <= 1000 = 97.3% (there's an island of rarity again!
n <= 10K = 97.65%
n <= 100K = 97.528% (another island?)
n <= 1M = 97.6263%

Seems to be honing in on 97.6%. So my math above about non-341 numbers is wrong, because I didn't realize there were some 85-aimed ones that I was failing to count.

>>10631522

For the 85-branch, here are proportions:

n <= 100 = 98% (all but 85 and 75)
n <= 1000 = 97.3% (there's an island of rarity again!
n <= 10K = 97.65%
n <= 100K = 97.528% (another island?)
n <= 1M = 97.6263%

Seems to be honing in on 97.6%. So my math above about non-341 numbers is wrong, because I didn't realize there were some 85-aimed ones that I was failing to count.

This also explains why so much has to go through 5. Below 64, we have:

1: non-branch at 0
2: no branch
4: loop 1 > 2 > 4 > 1
8: no branch
16: interesting branch at 5
32: no branch

2 and 8 are odd powers of 2: no branch. 4 has a trivial branch that loops at 1. 1 is a "positive power" of 2 (2^0) and fulfills the criterion for 0, but of course nothing feeds into 0 except itself.

Thus, 5 > 16 is the first branch that isn't trivial. And as such it has to include the vast majority of integers.

>>10631522

For the 85-branch, here are proportions:

n <= 100 = 98% (all but 85 and 75)
n <= 1000 = 97.3% (there's an island of rarity again!
n <= 10K = 97.65%
n <= 100K = 97.528% (another island?)
n <= 1M = 97.6263%

Seems to be honing in on 97.6%. So my math above about non-341 numbers is wrong, because I didn't realize there were some 85-aimed ones that I was failing to count.

This also explains why so much has to go through 5. Below 64, we have:

1: non-branch at 0
2: no branch
4: loop 1 > 2 > 4 > 1
8: no branch
16: interesting branch at 5
32: no branch

2 and 8 are odd powers of 2: no branch. 4 has a trivial branch that loops at 1. 1 is a "positive power" of 2 (2^0) and fulfills the criterion for 0, but of course nothing feeds into 0 except itself.

Thus, 5 > 16 is the first branch that isn't trivial. And as such it has to include the vast majority of integers.

Wrt proportions, the obvious next step is...this is getting into infitesimals and so on and so forth.

If you go high enough, almost all numbers will feed into an interesting branch--the powers of 2 and the 2-power of series on the uninteresting branches comprise an increasingly small proportion of integers, going to 0, as your upper bound climbs higher and higher. Their proportion of the integers falls to nothing.

So at each branch, what proportion of the integers does it take? About 93.8% of integers feed into 5. How many feed into 85? How many 341? Remember, as we look at more integers, we find that an increasingly insignificant proportion fail to feed into these.

Can we get more visuals?

>>10631602
I'll see what I can do, might just be crappy Paint shit though. here's a tree from stackoverflow I found on google.

note the first branch is at 16: 5 and 32. all numbers other than 8/4/2/1 have to go through 16.

All numbers that go through 10 also have to go through 5, so we could call our series "apentous" rather than "adecous". Wouldn't matter.

Red numbers, in this diagram, are the "uninteresting paths"--multiples of 3 whose next step is a power of 2, and their predecessors.

...Actually, it looks like all multiples of 3 have to be on an "uninteresting" (red) chain, and nothing can be on an uninteresting chain that isn't a multiple of 3. That's obvious now I think about it, but it may tell us something.

>>10628955
This is not just about a thesis but a Fields medal piece of work.

>>10631409
Here is a pastebin containing all *apentous* (same as adecous, but also excludes 5) numbers under 10K (there are 600 of them, 601 if you include 5)) numbers modulo 2 to 9: https://pastebin.com/YCWfsy8m

If my conjecture is false, this may be a good line of inquiry for a counterexample. Assume the conjecture is true. Then for any positive integer N, there is a sequence of consecutive adecous numbers of length N+1.

This means that if the conjecture is true, then you can pick any positive integer J and any integer K < J. Then there must exist an adecous number N such that N mod J = K. If you could find a counterexample, the conjecture would be wrong.

>>10631620
It is more symmetric than I had initially expected. Perhaps this can be exploited in the calculations?

>>10631317
>You're basically imagining that God is flipping weighted coins, each of which has a 6% chance of getting heads. If he does that long enough then sure, he'll end up with a sequence of heads as long as he wants.
exactly, that's what I'm saying

As for the rest of your post, yes, I can that clustering DOES occur in that sequence.
I can see that that sequence isn't random. I can see that consecutive sequences appear sooner than they should.
I never denied that.

My point was that your conjecture doesn't say anything about this.
Since your conjecture only asks if their EXIST consecutive sequences of any length, which would also be true be true for a random distribution.

>>10631930
It's symmetric only insofar as any number can have at most two sources. What isn't shown in that picture is that about 94% of positive integers are on the left-hand side.

>>10631966
Right. But now that we know that there are (obscure and possibly unanalyzable) rules on which numbers appear, the possibility appears that the rules preclude sequences of certain length from appearing.

It is possible to explicit arbitrarily large pairs [math] (n, n+1) [/math] of consecutive adecous numbers. For instance, take [math] k \geq 3 [/math] and notice that [math] 4^k - 1 [/math] is a multiple of 3 but not of 6, hence [math] \frac{4^k - 1}{3} [/math] defines an odd integer.
Set [math] n:= 4 \frac{4^k - 1}{3} [/math].
Then : [math] n \rightarrow 2 \frac{4^k - 1}{3} \rightarrow \frac{4^k - 1}{3} \rightarrow 4^k \rightarrow \cdots \rightarrow 32 [/math].
And [math] n + 1 = \frac{4 * 4^k - 1}{3} \rightarrow 4*4^k \rightarrow 2* 4^k \rightarrow 4^k \rightarrow \cdots \rightarrow 32 [/math].

I think it would be possible to generalise this and show similar results for triplets or quadruplets but the general case requires more work.

>>10632153
For triplets it seems that if we let [math]n := \frac{2^{13 + 18k} -92}{27}[/math] for [math]k \geq 0[/math] then we have that [math](n, n+1, n+2)[/math] is a adecous triplet. I checked it for [math]k = 0, 1, 2, 3, 4[/math].

>>10632240
Similarly, the formula [math]n := \frac{2^{16+54k}-574}{81}[/math] seems to provide quintuplets of adecous numbers. First ones are :
[math]k = 0 : n = 802[/math]
[math]k = 1 : n = 14575205194042114850[/math]
[math]k = 2 : n = 262563554722946345264949542771426082[/math]
[math]k = 3 : n = 4729924508845335982587490824537991307465244204270370[/math]
[math]k = 4 : n = 85206745022105725770799455089839820400630974965066500681018817577762[/math].

The convergence is quite fast (less than 250 iterations).

>>10631620
OK also what about that Lil 6.2% nigga? How he doing? Is that motherfucker tau or what

>>10632400
If you have a decent computer you could run this code >>10629848 for values n , where n=100,000,000 * m and 0<m<11 say?

>>10632281
Using the same reasoning for sextuplets, I conjecture that the formula [math]n := \frac{2^{22 + 486k} - 17863}{729}[/math] should yield adecuous sextuplets [math](n, n+1, n+2, n+3, n+4, n+5)[/math] .
For [math] k = 0 [/math] we find [math] n = 5729 [/math].
For [math] k = 1 [/math] we find n = 1149503423348988091527265517678827685826420252108401352685490521581084021782711503498103077689206398121573376044794757446309489267142195640126341650017, which you can verify is the first of 6 consecutive adecous numbers.

>>10632501
uh, is there something I'm missing here? is n = extremely long for the 85-less path?

>>10632670
This number n is an adecous number as per the definition of OP, and so is n+1, n+2, n+3, n+4, n+5. You can check that for these numbers the Collatz sequence never reaches 10 (for instance https://www.nitrxgen.net/collatz/1149503423348988091527265517678827685826420252108401352685490521581084021782711503498103077689206398121573376044794757446309489267142195640126341650017/))

i masterbated to this thread mone ty for showing it

>>10628781
I made a visualization of that first quintuple

>>10633301
Different arrangement where I put numbers which are close together into a single node
I think this one is pretty interesting

>>10633301

What's interesting here is that the convergences are always in the same order. In the 802, 401 and 301 sequences, the numbers that converge to 904 always occur prior to the numbers that converge to 454. 226 and 340 are on the same trajectory, and are both lower than 227 and 341, which are also on the same trajectory.

How do you make a formal statement out of this?

>>10634395
edit: durr, of course. Semi-formally:

"Consider a sequence of consecutive adecous numbers (m, m+1, m+2...m+j). Then, for any number n within this sequence, if n and n+2 converge to the same intermediate number k, n+1 must also converge to k."

>>10634395

edit: durr, of course. Semi-formally:

"Consider a sequence of consecutive adecous numbers (m, m+1, m+2...m+j). Then, for any number n within this sequence, if n and n+2 converge to the same intermediate number k, n+1 must also converge to k."

This is a weak version. The strong version (or a slightly different conjecture that looks much stronger) is:

"iven a sequence of consecutive adecous numbers (m, m+1, m+2...m+j); we use <Ḿ> to denote this sequece. Consider a second sequence of consecutive adecous numbers (n, n+1, n+2...n+k), denoted by <Ń>.

Given any two numbers a and b in Ḿ such that b > a. α is any number that a reaches on its Collatz path, and β is likewise any number that b reaches on its Collatz path.

Then if we pick any two numbers c and d in Ń such that d > c (just as b > a), it cannot be true both that d converges to α and c converges to β.

>>10634395

Ninja post: durr, of course. Semi-formally:

"Consider a sequence of consecutive adecous numbers (m, m+1, m+2...m+j). Then, for any number n within this sequence, if n and n+2 converge to the same intermediate number k, n+1 must also converge to k."

This is a weak version. The strong version (or a slightly different conjecture that looks much stronger) is:

"Consider a sequence of consecutive adecous numbers (m, m+1, m+2...m+j); we use <Ḿ> to denote this sequence. Consider a second sequence of consecutive adecous numbers (n, n+1, n+2...n+k), denoted by <Ń>.

Consider any two numbers a and b in Ḿ such that b > a. Then α can be any number that a reaches on its Collatz path, and β can likewise be any number that b reaches on its Collatz path.

Then if we pick any two numbers c and d in Ń such that d > c (just as b > a), it cannot be true both that the Collatz path of d contains α and that the collatz path of c contains β."

>>10629029
>Semi interesting math thread
>Someone asks clarification
>Goes full on autismo hostility
Every time

>>10634556
I feel awful about this, for the record. I know that doesn't help, but I've repented.

>>10629816>>10630896
>>10632400

I've calculated the constant value:
For n=100 million, 6.226179%
For n=200 million, 6.227588%
For n=400 million, 6.227514%

These values are completely accurate (up to the 6th decimal place). So we can be somewhat confident that the constant starts with 6.227+- 0.001. If anyone is interested I can post my code, it's a modified version of >>10629848

>>10634695
6.2275/100 (remember, it's a percent, and the percent itself is unlikely to be a constant) is 0.062275.

I can't find anything that looks like that, even after multiplying it around.

Figuring out the size of the "slices" here might help. 93.772...% of numbers are under the 5-branch. (0.93772). There's another under the 85-branch and then the 341-branch. Looking at their proportions of the integers might tell us something.

>>10634721
I'm aware; people have been referring to it as a % in this thread. This https://oeis.org/ may be useful in identifying if the constant is related to something else, but we need to calculate it to a higher precision, I could probably calculate it for n=1 billion but after that it gets hard.

>>10634743
Yeah. Googling "0.93773" gives me mostly bitcoin addresses, so it certainly doesn't seem to be a known constant.

Then again taking the decimal representation of a number and finding a more elegant representation seems like a Hard Problem.

>>10628781
> $20 Amazon gift card available for a proof, $40 for a disproof.
So.. the odds are 2:1 for a disproof..
Good to know

>>10631338
I was thinking the same thing lol not sure why no one mentioned it yet

>>10629061
>>10629081
>>10629118

Time to go back lads

>>10629794
> This will get me so many upvotes.

>>10635371
Because it isn't. Look at >>10634695

>>10629118
>>10629081

Blow your brains out

>>10629061
>>10629081
>>10629118
Fresh off the boat, from reddit, kid? heh I remember when I was just like you. Braindead. Lemme give you a tip so you can make it in this cyber sanctuary: never make jokes like that. You got no reputation here, you got no name, you got jackshit here. It's survival of the fittest and you ain't gonna survive long on 4chan by saying stupid jokes that your little hugbox cuntsucking reddit friends would upboat. None of that here. You don't upboat. You don't downboat. This ain't reddit, kid. This is 4chan. We have REAL intellectual discussion, something I don't think you're all that familiar with. You don't like it, you can hit the bricks on over to imgur, you daily show watching son of a bitch. I hope you don't tho. I hope you stay here and learn our ways. Things are different here, unlike any other place that the light of internet pop culture reaches. You can be anything here. Me ? heh, I'm a judge.. this place.... this place has a lot to offer... heh you'll see, kid . . . that is if you can handle it...

>>10631620
So, we have the numbers [math]2^n[math] for n>5 and their neighbors that are multiples of 3. Does that describe the 32 side?

This thread has been invaded by plebbit

>>10635425
>I’m not a newfag, I swear... g-guys?

great, someone posted this fucking thread on reddit. more exposure is exactly what we need after the stupid fucking anime problem.
i bet it was this dipshit
>>10629061
>>10629081
>>10629118

>>10635457
>please, don’t let anyone think there are actual intelligent people here. It’s just incel nazis jacking off to toddler anime girls and traps.

>>10635452
Does anyone really want to punch the chick on the right? She’s obviously one of those popular but not hot whores who bases her social status on being a total bitch.

>>10635513
Her face is exactly how I feel reading this still obvious Redditor trying to fit in.

>>10635521
Muh sekrit klubfags are almost as annoying as redditors

>>10635536
>t. I wanna hop on the complaining bandwagon but also want to be contration
More annoying than the secret club fags or the reddit fags.

>>10635555
I'm just kidding all fags are welcome to progress mathematics.

621,295,048 out of the first 10,000,000,000 numbers are adecous. I am running 100 billion now but I had to switch to u128s because otherwise steps overflow a u64

>>10634695
Was one of your modifications changing all the ints to longs? I am getting slightly different results for those numbers in the 100 millions

>>10635619
>>10635619
long long ints yes, not all but x needs to be a long long int.The difference is because of integer overflow for your x. Also please post a results for n=1 billion+ if you can, thanks. (You may need to to stipulate that x<2^63-1 to prevent your program from breaking.)

>>10635608

Now if I didn't know better, 5 is a branch from 16. And 1/16 is 6.25%.

So very nearly 1 in 16 of all integers get to 16 from 32 instead of 5. But if you go high enough you probably can't account for the remainder just with uninteresting branches like 21. Do approximately 1/256 of all integers come from 512 instead of 85?

>>10632501

I need to get some time with some paper to look at it -- but how come the explicit construction for sextuplets skips to a denominator of 3^6 (I was expecting 243)

>>10635641
100M - 6226154
1B - 62304713
10B - 622729689
It turns out I had an embarrassing off by one error. Either way, our numbers are still slightly different, at least for 100M, by ~20. Not sure why, I don't think I'm overflowing since I'm using u128s and I'm doing checked multiplications. Also long long longs are only guaranteed to be 64 bits longs, so you'll run into issues > ~10B

>>10635732
True. If you post a pastebin of the code I'll take a look, maybe I made a mistake

>>10635773
https://pastebin.com/BiMjzsRW

>>10629012
A lot of these are clustered around primes

>>10635732
update
100B - 6226427080

What if one counts only the percentage of odd numbers that are adecous? A lot of treatments of Collatz ignore even numbers almost altogether.

>>10628781
I wrote a program that efficiently finds long-ass consecutive sequences of adecous numbers.

Here is one with length 417452 for example:

The numbers from 10510958753499479380 to 10510958753499896831 are all adecous

>>10628781

I wrote a program that efficiently finds long-ass consecutive sequences of adecous numbers.

Here is one with length 417452 for example:

The numbers from 10510958753499479380 to 10510958753499896831 are all adecous

>>10628781

I wrote a program that efficiently finds long-ass consecutive sequences of adecous numbers.

Here is one with length 417452 for example:

The numbers from 10510958753499479380 to 10510958753499896831 are all adecous.

Okay so this is definitly somehow connected to highly composite numbers/antiprimes, right? Or am I just imagining things?

Been working on AVX2 implementation for both 32bit and 64 unsigned integers since I saw the thread the other day.
I'll also see what I can do about AVX and SSE4.1/2, SSSE3, SSE2.

Expect it tomorrow at the latest.

>>10636376
Also I'm considering CUDA and OpenCL if there is any interest.

>>10636346
holy shit

>>10636369
I think so since on side of the tree is [math]2^n[/math]

>>10635792
>Rust

What are some other convergent piecewise functions like the collatz conjecture?

>>10636395
Wild numbers?

Not sure if this has already been noted yet, but "runs" of consecutive adecous numbers greater than 16, (equivalently numbers whose collatz sequence passes through 32) all have the same length of collatz sequence. I haven't proven this but it seems to be true for even rather large runs. Moreover, If one looks at the lengths of the collatz sequences of adecous numbers, they tend to come in substantially larger "runs" than just the numbers, e.g. all 36 adecous numbers from 16004 to 16107 have collatz sequence length of 46.

Further conjecture, within the sequence of adecous numbers, there exists a "run" of length n of consecutive adecous numbers with the same collatz sequence length ( *here* consecutive means from the nth adecous to the n+1th, not that that a_n + 1 = a_{n+1} ).

Once again strong and weak version. I've verified the strong version up to 219 and the weak up to 1606.

>>10636624
Really? This seems surprising. But I'm also confused-- 36 of those 100 or so numbers are adecous? I thought about 6% of all numbers were. Is there a typo here or is this region just unusually dense in them?

>>10636809
Yep.

Unless my implementation is wrong (which is possible, but it's simple enough that I don't suspect it is.)

That region is just particularly dense.

All of these 16004,16005,16006,16011,16014,16015,16017,16018,16019,16028,16029,16030,16033,16048,16049,16050,16051,16052,16053,16056,16058,16060,16061,16062,16065,16071,16088,16089,16090,16092,16093,16094,16095,16097,16105,16107
are adecous and have the same path length

>>10635503
These two things aren't mutually exclusive.

>>10636729
I've let my machine run for a bit longer, and after a snack, a short shower and a shave, I've verified the strong version up to n = 276 and the weak version up to 3368.

>>10636843
>>10636809
Going even bigger, all 3007 (!!!! this is a big number) adecous numbers between 2394908 and 2418919 have 92 steps in their collatz sequences.

>>10636346
Post the code

>>10636894

OH NO!!! THIS IS WRONG!!!!
I've made a silly mistake! i was looking through some stuff "by hand" here and got the bigger number 3007. (Bigger than what the computer gave me first go through), turns out some of the adecous numbers in the window give the very visually similar, but decidedly not equal collatz sequence length 229 instead of 92. ( easy mistake to make when in a 3 thousand element long list in the terminal)

we don't actually get a sequence that long that early.

That said, (unless *my code* is wrong and not just my lazy copy and pasting of results in ghci) this doesn't mess up my conjecture. It's just a bad example.

>>10636915
Wait, let me get this straight because I had a somewhat similar feeling. Basically what I thought happened was for each consecutive sequence of n adecous numbers, ever number in the sequence had the same collatz length, but just because there are some that are bunched up but not in a consecutive sequence does not guarantee that they have the same collatz length. Is this correct according to the numerics?

>>10636946
>consecutive sequence of n adecous numbers
sequence of n consecutive adecous numbers
my fuck up there

>>10636915
Having been a bit more careful. I can say instead that all 1106 adecous numbers between 2404312 and 2418919 have 92 elements in their collatz sequence.

I suppose that's a bit less impressive, but at least it's correct!!

>>10636946
This is correct.(as I interpret what you are saying)

A "run", a consecutive sequence of adecous numbers, (i,e, a_n + 1 = a_{n+1} ) always has the same collatz length.

I'm not sure precisely what "bunched up" means, but i'd imagine that several (perhaps) "runs" close to each other need not have the same collatz length.

Further, a consecutive sequence of adecous numbers (i.e. a_n , a_{n+1}, ... ) with the same collatz length need not be a run, and in general, is much longer than runs tend to be.

>>10636977
(perhaps) was meant to be (perhaps short)

Not sure how important this stuff about Collatz length is. It's a known fact that when it comes to Collatz lengths, about half of the terms satisfy a(i) = a(i+1). For example, up to 10,000,000, 4,964,705 terms satisfy this condition. Regardless, I'd be curious to see a plot with the x axis as adecous number and the y axis as Collatz length.

>>10637025
Actually, maybe I take that back. From OEIS:
>The number of terms that satisfy a(i) = a(i+1) for i being a power of ten from 10^1 through 10^10 are: 0, 31, 365, 4161, 45022, 477245, 4964705, 51242281, 526051204, 5378743993.
These ratios naively seem to be converging.

(Then again, I'm wary on principal of all this "less than 10^x" stuff. Useful for number crunching and easy gauging, but it threatens to cut off patterns (hence the seemingly-inexplicable result of 6.01% at n <= 10,000) and adds another level of arbitrariness: using powers of 10 for the cut-offs is arbitrary; the choice of 10 in "adecous" is more-or-less arbitrary (cf "apentous" already popping up in this thread); and the 3n+1, n/2 rules are already kind of arbitrary in the first place. Why add more to that?)

>>10635684
Note that poster skipped the explicit construction for quadruplets.

>>10628781
math scrub that sucks ass at even statistics here

i think i understand how this all works, but im wondering

would it be -possible- to reverse the process, writing a program that would let you simply enter the value of a sequence, and get the corresponding "adecous" number?

>>10637113
You mean, "can we write a program that, given a value of n, prints out n consecutive adecous numbers?"
The answer is: we can easily write a program that would do that. The thing is, we don't know whether such a thing is always possible, so the program might run forever since it would never find n consecutive adecous numbers. OP's question is basically the same as "if we wrote such a program, would it always stop in a finite amount of time or might it run forever?"

>>10637121
I'll add to this answer by pointing out that >>10632501 and the posts before it point toward generating functions for different lengths of sequence, but finding the closed form for all lengths would be hard.

>>10637113
not if you mean entering the length, because for many (all?) N, there are multiple sequences of length N.

unless you mean "can you write a program to find the *first* one", or something

>>10637085
Yeah, doing "less than 10^x" is done just for doing initial number crunching. And all adecous numbers are also apentous, except for 5. I should have used "apentous" in the OP but hadn't yet started looking at it as a question of all-numbers-not-in-a-certain-branch

3n+1, n/2 is semi-arbitrary, just the most famous. You can create other rules. For example, if you apply 3n-1 to odd numbers, then you end up with three stable grounding loops: a 1-loop (1 > 2 > 1), a 5-loop (5 > 14 > 7 > 20 > 10 > 5), and a loop about 18 terms long whose lowest term is 17. There is another conjecture in the mathematical literature, unproven so far as I know, that these are the *only* loops for the {n/2, 3n-1} case and that all numbers must eventually end up at one of the three.

>>10637141
So the Collatz conjecture is really better stated as "there is only one loop, the lower number of which is 1", and it's the most famous case of a more general class of Collatz-like conjectures covering different configurations. Neat.

I like the term "adecous" better but defining it in terms of 5 definitely makes it more obvious what specific behavior you're interested in, since all paths must pass through 16, so the connection with 5 is more obvious.

Great thread btw. I'm not coming up with anything immediately helpful right now, in part because I'm on my phone and away from any computing power, but I can already tell I'll be thinking about this one for a long time. (Submit to OEIS!)

>>10637113
>>10637121
>>10637137


i guess i should clarify, im specifically talking about you entering a value, and it telling you what the corresponding "first/proper/unique" sequence is, and the adecous number that sequence comes from
fuckit, another dumb question, can we use this shit to make some neat fractal art or something, or would it just look like a mess?

>I think the 6.2% number is really going to turn out to be 1/16, minus a little bit for other powers of 2 or something along those lines. I dont know how to word that better.
via Reddit

>>10637172
yes, we could make such a program, and a few in this thread have already tried. but it can only work by brute-forcing which takes time

Another upside of apentous over adecous: most modern Collatz research completely ignores even numbers, since they're just odd numbers with extra bits at the end.

>>10637164
>only

A fun game to play if you're bored and have only a paper and pencil is to do Collatz systems by hand. Define a Collatz system this way:

Find a (preferably prime?) integer k. Then, for any integer n:

if nₘ mod k = 0, nₘ+1 = nₘ/k.

if nₘ mod k != 0, then define nₘ+1 in terms of nₘ, using only the four basic arithmetic functions, and never using nₘ+1 = knₘ alone, with each value of nₘ mod k corresponding to one and exactly one term.

Take the following, for example, where k is 3:

- if nₘ mod 3 = 0, then nₘ+1 = nₘ / 3
- if nₘ mod 3 = 1, then nₘ+1 = 2nₘ + 1
- if nₘ mod 3 = 2, then nₘ+1 = 4nₘ - 2

Run this for the first few integers and you'll find that there are two loops: one that goes 1 > 3 >1, and one that goes 2 > 6 > 2.

I think Collatz-like sequences require terms that *increase* the starting number to increase it by more than the decreasing terms decrease it, but also ensure that numbers hit a decrease from time to time. But the increasing term can't be *that* much more than the decreasing term, or you'll spiral off into infinity. Here's a Collatz-like conjecture that also has a 1 > 4 > 2 > 1 grounding loop:

if nₘ is even, nₘ+1 = nₘ/2, BUT
if nₘ is odd, nₘ+1 = 5nₘ - 1

This creates some interesting Collatz-like behavior. Because the increasing term for odds increases them by much more than the halving term decreases them, paths tend to be much longer. The initial grounding loop 1 > 4 > 2 > 1 is identical, but 3 takes 18 terms to settle.

5, 6, 7 and 8 all go to 1. But 9 spirals off into infinity, as far as I can tell--I worked it out up to the mid-six figures and realized that the way it was getting locked in alternating loops of final 7s and final 4s, the latter only divisible by 2, was sending it off into the ether.

There might be a rule where increasing terms can only be so much larger than decreasing terms before numbers fly off.

Started reading this bread earlier, I'm back home from getting drunk lmao

So >>10632281 uses this kind of construction
My idea for getting a proof would be proving it exists a way to produce a construction that works any n
Of course this would only prove weak conjecture but hey

>>10637514
Aaaand got this starting points for some proper sequences lowest n not found is 154
1 8
2 1
3 300
4 1610
5 802
6 5729
7 10132
8 18104
9 64368
10 15276
11 20368
12 27156
13 56946
14 40744
15 85424
16 36208
17 228874
18 2130924
19 203436
20 482219
21 305162
22 1516682
23 1201439
24 1280001
25 5392672
26 1601921
27 8543616
28 15188651
29 11362306
30 5419009
31 4261852
32 3033376
33 16181768
34 23999660
35 40962561
36 28767680
37 45459140
38 26938736
39 30306080
40 40408918
41 34171400
42 111999962
43 53878356
44 38356908
45 90914362
46 113521498
47 31999546
48 80998911
49 107757128
50 98215708
51 136371560
52 71999032
53 157313255
54 149333282
55 68188711
56 170282248
57 191567536
58 461207480
59 189898523
60 176987592
61 128326538
62 199111042
63 201815996
64 265481416
65 559336120
66 474210844
67 331458422
68 226858932
69 1117557306
70 248608086
71 227042996
72 318937428
73 994432342
74 441969978
75 398222128
76 345231920
77 441944577
78 298666594
79 1103678823
80 1021527504
81 745824257
82 1194597772
83 745781800
84 497187650
85 1241638580
86 228136074
87 672126719
88 1076352168
89 883889200
90 551840257
91 994432532
92 1180122304
93 340564508
94 314644608
95 745781500
96 981049376
97 2237345096
98 1178586476
99 1343923080

>>10637519
Cont
100 1573496412
101 3793010914
102 1655518106
103 2133948418
104 1571448833
105 605448064
106 1325909935
107 353975184
108 1491648688
109 1655518244
110 1862457874
111 785724417
112 662954968
113 3775736048
114 4909563390
115 5765830984
116 3188201992
117 5663356271
118 1118672252
119 1862458027
120 735787009
121 4134127527
122 1678009116
123 1988750700
124 4775806752
125 4495420290
126 7449403905
127 1396763137
128 2357173276
129 1962095696
130 7848382332
131 8949892892
132 1988873980
133 2095265250
134 1178518906
135 807264084
136 2483277159
137 3142897736
138 2237473199
139 2095265110
140 5512170036
141 8380579612
142 10372746600
143 1767778400
144 5966254081
145 2207357658
146 5057347882
147 4714075756
148 3488169834
149 2357037866
150 1047572330
151 11174105576
152 1988864908
153 1047632555

>>10637525
Cont
155 4714346944
156 11772574207
157 3924191074
158 5232255296
161 4474946426
162 2483277366
163 3311036492
164 1571358556
167 7955006506
168 11048447318
169 11174105856
172 2983126058
173 5303335226
174 9980322864
175 3142897900
179 5886287208
183 9428693700
184 2943143552
186 4190289692
190 8268255106
191 11174106146
192 9932538176
193 2357173407
196 4650893112
199 3142717154
201 5587052720
208 2793526320
212 9933108968
214 6622072572
215 2651667600
219 3535556800
221 3977501420
223 9933109664
227 6285795800
229 6285434308
233 7449832192
235 2095144704
238 3724916054
245 4966554738
259 10464510620
262 7449403632
265 11772574448
266 4190530500
278 4414715328
302 8380579080
310 6622073000

>>10637519
>>10637525
>>10637528

If you're going to post that many numbers, make a pastebin and post that instead.

>>10636376
What about u128?

>>10634695
Adecuous numbers are equivalently defined as those having 32 in their Collatz path.
I would not be surprised if, on average, 1/16=6.25% of numbers share this property.

>>10637803
Yeah that seems plausible but from >>10635732
you see even after calculating whether or not the first 10 billion numbers are adecous it is still under 6.25% by a small but significant margin.

>>10636906
Here you go:
https://www.pastiebin.com/5cd81c56045a8

As for how it works:

Start with an adecous number [math] n [/math] and a radius [math] r [/math].
Then repeat this process:
- Set [math] n [/math] to be the "center of mass" of the adecous numbers in the range [math] [n-r\ ,\ n+r] [/math].
- Either multiply [math] n [/math] by 2 or subtract 1 and divide by 3, depending on which of these results has more adecous numbers in the range [math] [n-r\ ,\ n+r] [/math].
- If every number in that range is adecous, then multiply [math] r [/math] by 2.

btw,
My program prints numbers which lie inside of big sequences, it doesn't print the length of those sequences.
But if you have a number inside of a sequence it is easy to figure out the length of the sequence of course.

>>10636868
Nobody cares that you showered and shaved anon

>>10636868
>and the weak version up to 3368
bitch, I've verified the weak version up to 417452 >>10636346

>>10637916
don't listen to this anon--everybody knows 4chan posters don't shower

>>10637762
I could, wasn't sure if people were interested in numbers that big yet.

>>10638025

Just to clarify this program is to find consecutive adecous numbers? When you check if some number is adecous it may grow very very large even if the original number isn't, so u128 would help avoid any overflow business. (looking at >>10636346 we see that to verify the weak conjecture for new lengths may require to look at very large numbers).

>>10638071
Yes, it is to find and track consecutive sequences. Currently it has a basic overflow prevention via a check which can be disabled to improve speed if you want.

>>10629848
Where is pthread_t?

One last update:
1T - 62234337467

>>10638422
Sorry--so there is a 1-trillion-integer long adecous sequence beginning at 62,234,337,467? That...can't be right, that's only sixty-two billion. Or is this the longest sequence under 1 trillion?

>>10638435
Maybe she meant 1 Thousand?

>>10638443
Sounds plausible, I would write 1K though.

>>10638435
It means there are 62234337467 adecous numbers smaller than 1 trillion, i believe.

>>10638452
got it, it sounds like 1/16 is a red herring then

>>10638422
> 1T - 62234337467
I can corroborate this result. I have 10 machines working on under 30T right now, should have results later. My code could probably be sped up before going much further. I think modular restrictions are promising. If anyone wants to work on a portion of the space: https://ufile.io/yxt72up1

>>10638662
ETA?

>>10639324
This is what I have so far:
https://pastebin.com/K9ad9fM3

Total for under 10^13 is 621930130594 or 6.2193013%

>>10638071
this looks like a promising path--is it possible for any N to create a formula that generates a sequence N long?

if so, then the weak conjecture has at least been proven

>>10628782
>Prove
define prove

>>10639840
Did you mean to link me? I'm just asking about someone's code which I imagine is a heuristic rather than a formula. Look at these:>>10632153
>>10632240
>>10632281
For a potential way of generating N sequences, (if you can extend it the idea that is).

>>10629061
>>10629081
>>10629118

Since counter-examples to the collatz conjecture are included in your class of numbers I think the analysis is quite difficult.

>>10640615
Hardly. Even if there's just one counterexample, the vast majority of numbers certainly seem to follow Collatz and would stick to these patterns.

This is a conjecture *about Collatz paths*, but it is not itself Collatz. In fact it's really quite different.

>>10629118

>>10640642
You seem confused.

>Even if there's just one counterexample
If there is one there is an infinite amount of them.

>the vast majority of numbers certainly seem to follow Collatz and would stick to these patterns
Since we're talking about all the natural numbers you've literally checked 0% of the numbers needed to make a statement like this in the limit. There are plenty of conjectures that hold for an obscene amount of numbers until they break.

>This is a conjecture *about Collatz paths*, but it is not itself Collatz. In fact it's really quite different.
Stuff like this is why you seem so confused, who exactly made the claim that they are the same?

Just redefine "adecous numbers" to be the ones that end in the 32-path and you no longer have collatz counterexamples in your class of numbers and these numerical approximations make sense without having to worry about collatz being true or not.

Either way best of luck to you.

Hello. I remember you posting about Collatz on /pol/ a while ago. Interesting problem. Thank you for introducing it to me.
>>10631620
is a quality post.

Perhaps you can tell me if there is any work analyzing the problem from the perspective of prime factorization. I'm thinking about a number in the form of something like 2x3^2x5x7. Then the Collatz rules read something like "If there is a 2, remove it. If there is no 2, multiply by 3 and add 1" the latter being the interesting part because it "converts" in a likely predictable way prime factors into another configuration (guaranteed to contain a 2). The branch diagram here helps a lot to illustrate this.

TL;DR - Does anybody think about Collatz as a 'converter-elimination engine' operating on prime factorizations, converting every prime number that isn't 2 into 2 for elimination? I will be thinking about what effect the 3n + 1 operator could be said to have exactly.

>>10641264
You reminded me of the Goodstein's theorem.

>>10641304
yeah i don't know what you call it

>>10641339
https://en.wikipedia.org/wiki/Goodstein%27s_theorem

>>10641343
now i gotta read all about some shit like Peano Arithmetic. Fuck you buddy, im just gonna go drink a steel reserve for a dollar

>>10641264
Certainly wasn't me on /pol/, but thank you.

This is part of what makes Collatz so interesting--given a number N, what is the prime factorization of N+1? This is something of a holy grail for number theory.

>>10639363

It would be more interesting to group these quantities by powers of two, rather than powers of 10.

>>10642143
Here you go: https://pastebin.com/WbApbh0N

>>10629081
Gtfo of here faggot we are not going to do your homework

An amazon card KEK

>>10642388
>https://pastebin.com/WbApbh0N
Interesting. There are islands of relative scarcity and islands of relative abundance. From a relative nadir under 2^23, adecous numbers become more abundant up to 2^39.

Perhaps the 6.25% hunch has more to it?

>>10632142
>It's symmetric only insofar as any number can have at most two sources.
That does not immediately explain why after 16 the tree splits into two sub trees having the same shape.

I have an idea.
You have to focus on the odd numbers; pic very related.
Notice that every odd has an infinite number of even numbers that "lead-into" it.
Playing any even number in the column above an odd integer on the x-axis will end up at the odd integer.
That's common sense, because every even number is halved until it becomes odd.

>>10643933
everyone knows this already

>>10643939
Good; I want to build off a solid base.

>>10643933
Now, consider that
[eqn]3x+1 = e[/eqn]
where x is some odd- and e is some even-integer.
To find the odd that directly leads into an even, we say
[eqn](e-1)/3 = x[/eqn]
Doing this for every even integer on the chart, we find pic related.
All the integers in a column lead to the base of that column.
Not all spaces are filled in, because not all even integers have odds that lead into them;
i.e. (e-1)/3 does not always return an integer.

This is a good way to view the problem and I'll tell you why.

>>10643968
One way to disprove the conjecture is to find a sequence which ascends to infinity.
By doing so it, obviously, will never come back to 1.
I'm interested in finding a series that does this.
Notice how there are only a few odds which lead to odds higher than themselves.
In the pic we only see 3 and 7, but the list goes on. There is a set of odd integers which lead to higher odds; they form what I call the set of "ascending odds:"
[eqn][3, 7, 11, 15, 19, 23, 27, 31. . .][/eqn]
We see that
3>5
7>11
11>17
15>23
etc.

If we want to build a sequence that extends infinitely, we have to use these odds; otherwise, the sequence won't go up.

I posit that it's even MORE obvious that a sequence comprised EXCLUSIVELY of these ascending odds MUST ascend, and do so as long as all odds in the sequence are exclusively part of the ascending set.

Pic related is a look at some odd integers and their sequences.
If an odd leads into an odd higher than itself, I write that odd next to it and begin again.
If the next odd in the sequence ISNT greater, I end the sequence; it is imperfect.

There is a pattern here called the "Ruler Sequence" apparently; I can't explain it, but you see how there IS some underlying order to this madness.

>>10642388
Thank you!

Given that, an additional step is to take successive differences -- since all the even adecous numbers in a given span are just the ones from the previous one times 2.

I wonder if what we should be doing is counting numbers that end up at different powers of two separately.

In other words, only a few things will end up at 256, even fewer at 1024, and so on.

I'll try and put that together.

>>10644022
Now, there is a reason why those sequences don't extend forever. It's because not all x's can ever be integer multiples of 4 apart. Bear with me.

Notice that the odds in the set of ascending odds are all spaced 4 apart. In order for a sequence to have exclusively ascending odds, they, too, would have to be 4 (or a multiple of 4) units apart.

Now take this sequence:
31>47>71>107>161

The differences between the odds are:
16, 24, 36, and 54
All of the differences are multiples of 4 except for one: 54
And all of the odds in the sequence are ascending odds except for one: 161

So we see how important the differences between odds are, but how are they determined?
Can the difference between the second and third odds, for example, be determined by the difference between the first and second?
The answer is it can, and I'll describe it as
[eqn]d_2 = 1.5d_1[/eqn]
where the d's stand for the first and second differences.
Pic related explains it better but, in essence, the ratio between the first and second differences turns out to be 1.5 (or, in the generalized equation, k/2)

>>10644022
You can see the pattern is related to the number of 2's in a prime factorization is the length of the sequence.

For each odd number x=2n-1, the length of ascension is 1 + the number of 2's in the prime factorization of n.

I can thus predict the sequence at 63 will be length 6. Let's try:

63->95->143->215->323->485 -/> 91

>>10644092
Oh and to add, you won't have an infinite ascension unless you have descension included as well, as there is no n with an infinite number of 2's in its prime factorization

>>10644050

I've tabulated how many numbers eventually end up at what power of 2, in different ranges

Each row has the population counts for starting values below each power of two, in order.

So, < 2^5: 1 1 1 1 26 0 1 means that for the numbers 1 through 31, one number ends up at 1, one ends up at 2, one at 4, one at 8, 26 at 16, and 1 at 64.

Most numbers will end up at 16. Odd powers of 2 will always be at most singletons, because they are not congruent to 1 mod 3.

< 2^1: 1
< 2^2: 1 1 0 0 1
< 2^3: 1 1 1 0 4
< 2^4: 1 1 1 1 11
< 2^5: 1 1 1 1 26 0 1
< 2^6: 1 1 1 1 56 1 2
< 2^7: 1 1 1 1 115 1 4 0 3
< 2^8: 1 1 1 1 235 1 5 1 6 0 3
< 2^9: 1 1 1 1 475 1 6 1 15 0 9
< 2^10: 1 1 1 1 955 1 7 1 28 1 26
< 2^11: 1 1 1 1 1916 1 8 1 51 1 64 0 1
< 2^12: 1 1 1 1 3840 1 9 1 99 1 137 1 2
< 2^13: 1 1 1 1 7690 1 10 1 198 1 279 1 4 0 2
< 2^14: 1 1 1 1 15387 1 11 1 401 1 565 1 5 1 4 0 1
< 2^15: 1 1 1 1 30755 1 12 1 810 1 1158 1 6 1 8 0 9
< 2^16: 1 1 1 1 61433 1 13 1 1625 1 2408 1 7 1 13 1 26
< 2^17: 1 1 1 1 122796 1 14 1 3223 1 4940 1 8 1 22 1 57 0 1
< 2^18: 1 1 1 1 245621 1 15 1 6342 1 9980 1 9 1 37 1 124 1 2 0 2
< 2^19: 1 1 1 1 491457 1 16 1 12514 1 19950 1 10 1 63 1 250 1 4 0 12
< 2^20: 1 1 1 1 983310 1 17 1 24831 1 39769 1 11 1 105 1 481 1 5 1 33 0 1
< 2^21: 1 1 1 1 1967074 1 18 1 49555 1 79255 1 12 1 187 1 957 1 6 1 72 0 3
< 2^22: 1 1 1 1 3934631 1 19 1 99011 1 158158 1 13 1 360 1 1948 1 7 1 137 1 6
< 2^23: 1 1 1 1 7869503 1 20 1 198136 1 315957 1 14 1 722 1 3957 1 8 1 264 1 12 0 1
< 2^24: 1 1 1 1 15738936 1 21 1 396349 1 631883 1 15 1 1427 1 8010 1 9 1 523 1 25 1 2 0 1


This is pretty interesting -- the second most common endpoint is 1024!

>>10644083
Sorry for terrible pic.

NOW, what does a ratio of 1.5 have to do with anything? How does it limit the length of perfect sequences?

Recall that differences between all odds in the sequence must be multiples of 4.
In the example sequence
31>47>71>107>161,
we see the first difference is 16, the second is 24, the third is 36, and the fourth 54.

Notice that (as proved in the equation) each difference is 1.5 times the previous:

24 = 1.5 * 16
36 = 1.5* 24
etc.

What this means is that the starting difference, in order for all the odds in the sequence to be ascending odds, must be able to be multiplied by 1.5 an infinite number of times and always return a multiple of 4.

This is the limit on perfect ascending sequences; they cannot last forever because there is no number, no first difference, that can be multiplied by 1.5 infinitely and always produce a multiple of 4. In fact, I posit there is no integer that can be multiplied by 1.5 infinitely in order to produce an infinite number of integers.

THEREFORE you CANNOT make a sequence that perfectly ascends infinitely, and that is one way the conjecture COULD HAVE BEEN disproved, but it is no longer.

>>10644092
>>10644097
This is exactly correct; however, you cannot have infinite perfect* ascention, because the sequences we're dealing with use ascending odds exclusively. Most sequences bounce up and down and all around, because they have ENOUGH ascending odds to make things interesting. But none can be perfect AND infinite, that's all I'm trying to say.

>>10644097
What I mean to say is exactly what you've said: you must have some descent/imperfection in order to be infinite. I'm not disagreeing with you

>>10628781
>We will call numbers whose Collatz paths don't end in the 10-path "adecous" (non-10-ish).
Can we generalise and say all non-adecous paths will have to go through 64?

Budabudabumped

Bump function

>>10644110

Here's a little more data about which power of two things end up at:

2^25: 1 1 1 1 31477147 1 22 1 792182 1 1265000 1 16 1 2797 1 16138 1 10 1 1039 1 55 1 4 0 6 0 1
2^26: 1 1 1 1 62951890 1 23 1 1583707 1 2533047 1 17 1 5510 1 32397 1 11 1 2089 1 131 1 5 1 17 0 4
2^27: 1 1 1 1 125900444 1 24 1 3167784 1 5069096 1 18 1 10942 1 64808 1 12 1 4245 1 277 1 6 1 47 0 9
2^28: 1 1 1 1 251796314 1 25 1 6339117 1 10139078 1 19 1 21771 1 129796 1 13 1 8619 1 554 1 7 1 106 1 20
2^29: 1 1 1 1 503580431 1 26 1 12686837 1 20281154 1 20 1 43397 1 260255 1 14 1 17361 1 1120 1 8 1 221 1 50 0 1
2^30: 1 1 1 1 1007130468 1 27 1 25390292 1 40575844 1 21 1 86392 1 521209 1 15 1 34724 1 2268 1 9 1 425 1 110 1 2
2^31: 1 1 1 1 2014199523 1 28 1 50807581 1 81186640 1 22 1 171948 1 1043025 1 16 1 69241 1 4553 1 10 1 810 1 227 1 4 0 2
2^32: 1 1 1 1 4028288256 1 29 1 101668228 1 162432812 1 23 1 342602 1 2085998 1 17 1 138176 1 9099 1 11 1 1564 1 452 1 5 1 4 0 1
2^33: 1 1 1 1 8056373795 1 30 1 203440904 1 324966344 1 24 1 683892 1 4171487 1 18 1 275967 1 18142 1 12 1 3043 1 894 1 6 1 11 0 4
2^34: 1 1 1 1 16112378062 1 31 1 407079698 1 650104082 1 25 1 1367536 1 8344527 1 19 1 551295 1 36090 1 13 1 6001 1 1746 1 7 1 22 1 10
2^35: 1 1 1 1 32224143743 1 32 1 814511911 1 1300461583 1 26 1 2735766 1 16696310 1 20 1 1101700 1 71831 1 14 1 11939 1 3397 1 8 1 43 1 24 0 1
2^36: 1 1 1 1 64447366789 1 33 1 1629605788 1 2601247178 1 27 1 5471817 1 33408333 1 21 1 2202873 1 143187 1 15 1 23819 1 6695 1 9 1 76 1 53 1 2
2^37: 1 1 1 1 128893414922 1 34 1 3260170009 1 5202821261 1 28 1 10944112 1 66849139 1 22 1 4407069 1 285877 1 16 1 47415 1 13286 1 10 1 138 1 107 1 4 0 2
2^38: 1 1 1 1 257785039305 1 35 1 6521925730 1 10405775175 1 29 1 21892103 1 133763422 1 23 1 8817796 1 571589 1 17 1 94629 1 26565 1 11 1 266 1 214 1 5 1 7 0 1

>>10628781
badump

>>10646516
Er...how do I read this?

>>10648351

Assuming Collatz is true, all numbers eventually end up at a power of 2. This is counting which power of 2 a chain first encounters. Put differently -- Except for the small cycle 1 -> 4 -> 2 -> 1, numbers are all on a tree. This tree can be seen as subtrees, each rooted at a different power of two. This is counting up the sizes of those subtrees.

Take the 2^25 row as an example.

The first five entries are 1 1 1 1 31477147

That means that of the numbers below 2^25:

1 number ended up at 1
1 number ended up at 2
1 number ended up at 4
1 number ended up at 8
31477147 numbers ended up at 16

The next numbers mean:1 ends up at 32, 22 end up at 64, 1 ends up at 128, and 792182 end up at 256

Since odd powers of 2, like 8, 32, 128, aren't congruent to 1 mod 3, they can only ever be reached via division by 2. Therefore, only they themselves end up there (e.g. the first power of two that 128 encounters is 128).

The fifth column (the things that end up at 16) are most of the non-adecous numbers. Everything to the right of that breaks up the adecous numbers into further distinct categories.

>>10648650
Does any of this have anything to do with the fact that with computers you tend to see the numbers 16/32/64/128/256/512/1048?? Is there any connection with Collatz and computer architecture?

>>10648966
no, don't be retarded

>>10648966
those are called powers of 2, anon

>>10648966
>this is the true power of a comp sci student

>>10629081
>>10629118
why is everyone so easily baited by this

>>10649047
its almost summer and this site is 2 years past expiration already so the quality of newfags is even worse now

>>10648966
wew

Well I've found sufficient conditions for generating triplets out of twins. E.g. I believe that 3820, 3821, 3822 is one. If someone could check this for me that would be swell. I haven't (and probably couldn't) show that these are ALL the triplets, and I have no idea if they are proper or not, unfortunately.

You could probably generalize this, but it seems annoying (At least given how I went about it).

>>10649050
>this site is 2 years past expiration already
It’s 2005?

>>10648976
Thank you for the actual answer. I am not good at math so I guess it was a stupid question judging by the replies. I was curious about the significance of those numbers.

>>10650001
the collatz conjecture is important in computer science because computers do calculation by putting your number through the Collatz algorithm and looking at what kind of 1 it ends up at

>>10650770
Based scientific insight

I'm not sure what it's worth, if anything, but I found that the lowest percentage of adecous numbers occurs at 11239, with 5.961% of numbers below and including that being adecous. This is true at least through 10^6. I tried plotting values at which a new low is reached versus all adecous values, but it was not very illuminating. In the graph, orange are adecous values, and the y-axis is meaningless, I just wanted to plot them near the asymptote of the percentage value.