Re: this: $10 000 the new conjecture
mensa...@aol.com
rachid baih wrote:
> The prize is now this: $10 000 for a counterexample .
>
> www.newalgo.tk
Are you sure you don't want to upgrade this to a proof instead
of a mere conjecture?
And as stupid as your webpage is, it is, in fact related to the
fact that every possible sequence vector occurs on the Collatz
Tree infinitely many times.
I'll bet you didn't know that.
mensa...@aol.com
rachid baih wrote:
> I did not include your remark .
That's ok. Read all the FAQ messages in this group and then
it will make sense.
>
> but about the Collatz
> u can remplace
>
> 3n+1 /2 by n + (n+1)/2
>
> n + (n+1)/2 very easy :
>
> exemple : n = 7
>
> 7 -- 11 --- 17 ---- 26 ---- 13 ---- ........................... 1
So how does this insight help me?
>
>
> thanks
mensa...@aol.com
rachid baih wrote:
> really I do not know but excus me ok
Ok, you're excused.
It's ok to start a discussion.
It's ok to ask questions.
But in order to reply, I need some kind of hint where you're going.
Now if you had _asked_ if there was any significance to
(3n+1)/2 = n + (n+1)/2
then I might have said
"None that I'm aware of. However, although the standard odd
rule is 3n+1 and it is mathematically valid to use (3n+1)/2
since 3n+1 always produces an even number, that alternate
rule CANNOT be used with the Sequence Vector-Hailstone
Function-Crossover Point system I discuss in this group.
As such, n + (n+1)/2 has no value to me even though it is
mathematically equivalent."
That's not to say n+(n+1)/2 CAN'T be used, it just can't be
used in my system. Do you understand why I was short with
you when I asked "So how does this insight help me"? If you
have some profound insight involving n+(n+1)/2, I would be
happy to hear about it.
Next time make your statements in the form of a question and
I won't then try to pry more information out of you and will try
instead to answer your query.
mensa...@aol.com
rachid baih wrote:
> yes i think doesn't wrok for you because you need (3n+1) always
> produces an even number
> the only advantag is the time :
> if yo replaced (3n+1)/2 with n + (n+1)/2 (which are algebraically
> equal); you' This will skip the even numbers immediately after an odd
> number.
> excuse me i m amateur mathematician .
Hey, I'm just an amateur also.
There is also another thing you can do: skip ALL the even
numbers following an odd number. That gives you a real
nice speedup.
For example
>>> collatz(11,3)
11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
[10, 4]
This gives me a collatz sequence starting at 11 with print
option 3 (which means print both even & odd numbers).
The numbers in square brackets are the counts of the number
of n/2 operations & the number of 3n+1 operations.
If I turn on power division, then only the odd numbers in
the sequence print
>>> collatz(11,2)
11 17 13 5 1
[10, 4]
Power division is done by scanning the binary pattern of n
to find the least significant 1 bit. The position of the
1 bit is also the count of contiguous least significant
0 bits. That count can then be added to the operation total
(or appended to a Sequence Vector) and n can then be
arithmetic-right-shifted by the 0 bit count:
f = gmpy.scan1(n,0) # scan for first LS 1 bit
if f>0: # if f>0, the number is even
n = n >> f # power division
u += f # add f to 2-factor count
But note that the operation counts remain unchanged.
That's part of why I don't use (3n+1)/2 or the equivalent
n+(n+1)/2. Those alternate rules give me a false count of
the number of factors of 2 that were removed. Building a
Sequence Vector requires an EXACT count of the 2-factors.
And yes, the missing factors could be tracked, but it's
more hassle.
A Sequence Vector is a list of contiguous 2-factor counts.
For n=11, the Sequence Vector is
[1, 2, 3, 4]
That is the count of even numbers that fall between the
odd numbers:
11 17 13 5 1
34 52 26 40 20 10 16 8 4 2
11 is just one of an infinite number of sequences that
have that pattern. One thing that becomes apparent with
the Collatz Conjecture is that you need to abandon
value-centric thinking and focus on patterns. That means
the actual numbers in the sequence are less inportant
than the pattern of 2-factor counts.
You see, it's not simply a minor speedup I'm after.
There is much more beyond that. Sequence Vectors are the
key to my whole area of research. That's why I can't on
a whim just use n+(n+1)/2.
mensa...@aol.com
rachid baih wrote:
> ok
> amateur + amateur = prof
>
> I have the problem to studie your project ,because i use the auto
> translation (english)
> but I must make an effort (no problem)
> thank u
Let me know if you have trouble. I will try to rephrase it.
mensa...@aol.com
rachid baih wrote:
> A Sequence Vector is a list of contiguous 2-factor counts.
> For n=11, the Sequence Vector is
>
>
> [1, 2, 3, 4]
>
>
> That is the count of even numbers that fall between the
> odd numbers:
>
>
> 11 17 13 5 1
> 34 52 26 40 20 10 16 8 4 2
> but has it there an effective method for count ( A Sequence Vector)
> if n is the biger number with 100000....000 digits.
You can estimate what the count would be for large numbers.
If n has 1000000000 decimal digits, then it has
1000000000 * log(10)/log(2) = 3321928094 binary digits
If the number was chosen at random, we can estimate the number
of odd numbers (the length of the Sequence Vector) as
2.410 * 3321928094
and the number of even numbers would be about twice that.
Of course, that estimate will be wrong for numbers whose binary
digit pattern does not look random. For example, a Mersenne
Number with 3321928094 binary digits would have
4.819 * 3321928094 odd numbers in the sequence.
And even then, estimates are not exact. See
<http://members.aol.com/mensanator666/Page.htm>
to see how estimates compare to actual results.
>
>
> exampl
> n = 11
> whith your method you must test 11 to 1
> but my question about the new method ( test only n ) and give A
> Sequence Vector
I think such a method would prove the conjecture. The only way
to generate a Sequence Vector for a number is to run it through
a Collatz Sequence. We can't prove the conjecture with Sequence
Vectors.
Sequence Vectors are a tool for studying the Collatz Conjecture.
For instance, we can create Sequence Vectors by a program and
see what numbers they are associated with. We can prove that
every possible Sequence Vector exists on the Collatz Tree infinitely
many times.
We can also use them to study the properties of loop cycles.
Finding a non-trivial loop would prove the Collatz Conjecture false.
The threads in this group on Factor Congruence is a study on how
3n+C systems fail the conjecture. From these, we may learn what
it would take for 3n+1 to fail. So, it may be possible to construct
a non-trivial loop from a Sequence Vector.
No, I haven't been able to do that yet.
mensa...@aol.com
rachid baih wrote:
> wath about : 3n+1/2 - n + (n+1) /2
>
>
> 3n+1/2 - n + n+1 /2 = setap of sequance vector
I do not know what "setap" is, but I think I can figure it out.
>
>
>
> For n=11, the Sequence Vector is
>
>
> [1, 2, 3, 4] = 4 setap ( 1; 2 ; 3 and 4 )
It looks like you are saying "setap" is how many numbers
are in the sequence vector. If that is what you mean, then
you are correct.
>
> my remark
>
>
> n = 11 with 3n+1/2
>
> 11 17 13 5 1
> 34 52 26 40 20 10 16 8 4 2
>
> = 15 setap
I may have been unclear before. A sequence vector counts the
number of mathematical operations, not the numbers. There will
always be 1 less operation then there are numbers. Does this help?
11 (3n+1)
34 (n/2)
17 (3n+1)
52 (n/2)
26 (n/2)
13 (3n+1)
40 (n/2)
20 (n/2)
10 (n/2)
5 (3n+1)
16 (n/2)
8 (n/2)
4 (n/2)
2 (n/2)
1
There is no operation after 1, so there are 14 operations,
4 (3n+1) operations and 10 (n/2) operations.
The two numbers 4 and 10 are encoded in the sequence vector as
[1, 2, 3, 4]
| | | |
|__|__|__|______ count of elements: 4
+__+__+__+______ sum of elements: 10
The sequence vector is done this way because the PATTERN of
numbers is important. [2, 4, 1, 3] has exactly the same
count of elements and exactly the same sum of elements but
it is NOT the same as [1, 2, 3, 4] and represents a different
path in some other part of the Collatz Tree.
>
> and with n + (n+1) /2
>
>
> 11 17 26 13 20 10 5 8 4 2 1
>
> = 11 setap
10 if you count operations.
>
> and
>
>
> 15 - 11 = 4
14 - 10 = 4
>
> 4 = stap of a sequance vectors of 11
Yes, it is still 4. The reason it is correct is that with
n+(n+1/2) you still have 4 operations on odd numbers, so
the vector will still have 4 elements. What changes is the
elements inside the vector, they will all be reduced by 1
since n+(n+1/2) removes one of the 2-factors without counting
it:
11 n+(n+1/2)
17 n+(n+1/2)
26 n/2
13 n+(n+1/2)
20 n/2
10 n/2
5 n+(n+1/2)
8 n/2
4 n/2
2 n/2
1
So instead of [1, 2, 3, 4] I would have [0, 1, 2, 3].
>
> because
> For n=11, the Sequence Vector is
>
> [1, 2, 3, 4] = 4 setap
Count of elements is 4, but sum is 10.
>
>
> but wath s u opinion
> ( 3n+1/2 - n + n+1 /2 )
With n+(n+1/2) I get [0, 1, 2, 3].
Count of elements is also 4, but sum is 6, so this will
not work for me. Yes, I could just add 1 to each element
but that kind of defeats the purpose of using n+(n+1/2)
if the work is not saved but simply moved to another part
of the process. One feature of using the 3n+1 rule is that
you cannot have two consecutive odd numbers in the sequence.
This also means that a sequence vector cannot have a 0 as
an element. What I haven't mentioned yet is HOW the sequence
vectors are actually used.
>From a sequence vector, I create a Hailstone Function.
Hailstone functions are always of the form
X*a - Z
g = ---------
Y
where g,a must be integers and X,Y,Z are constants derived
from the sequence vector:
X = 2**sum(sequence vector)
Y = 3**count(sequence vector)
so for [1, 2, 3, 4], X=2**10 and Y=3**4.
Z is a little harder. For each element in the sequence vector,
create a sum where each term is a power of 3 multiplied by a
power of 2. Since there are 4 elements in [1, 2, 3, 4], we
sum 4 terms
Z = (3**?)(2**?)+(3**?)(2**?)+(3**?)(2**?)+(3**?)(2**?)
Now we need to replace the ?'s with actual values. For the
powers of 3, simply start at the left term with 0 and increment
each term
Z = (3**0)(2**?)+(3**1)(2**?)+(3**2)(2**?)+(3**3)(2**?)
For the powers of 2, again start at the left and replace the ?'s
as follows
sum all elements of sequence vector EXCEPT the last one (1+2+3)
sum all elements of sequence vector EXCEPT the last two (1+2)
sum all elements of sequence vector EXCEPT the last three (1)
sum all elements of sequence vector EXCEPT the last four (0)
so Z is then
Z = (3**0)(2**6)+(3**1)(2**3)+(3**2)(2**1)+(3**3)(2**0)
Our Hailstone function is then
1024*a - 133
g = ------------
81
What does the Hailstone function actually tell us? For the
given sequence vector, it tells us the first number in the Collatz
Sequence (g) and the last number in the sequence (a) without having
to calculate all the numbers in between. This is a real advantage
when the sequence vector is quite long:
>>> a = geni(1,1,xyz)
>>> a
mpz(1)
>>> g = seed(1,xyz)
>>> g
mpz(11)
So solving the Hailstone Function tells us that the sequence vector
[1, 2, 3, 4] starts at 11 and ends at 1.
Of course, we already knew that. But suppose we didn't. I know that
the sequence vector [1,2,3,4,5,6,7,8,9,10] must appear somewhere on
the Collatz Tree, but where?
>>> sv = [1,2,3,4,5,6,7,8,9,10]
>>> xyz=calc_xyz(sv)
>>> xyz
(mpz(36028797018963968L), mpz(59049), mpz(35393006061245L))
>>> a = geni(1,1,xyz)
>>> a
mpz(58690)
>>> g = seed(a,xyz)
>>> g
mpz(35809752267608075L)
>>> zigzag(g,sv,1,1)
35809752267608075
107429256802824226
53714628401412113
161143885204236340
80571942602118170
40285971301059085
120857913903177256
60428956951588628
30214478475794314
15107239237897157
45321717713691472
22660858856845736
11330429428422868
5665214714211434
2832607357105717
8497822071317152
4248911035658576
2124455517829288
1062227758914644
531113879457322
265556939728661
796670819185984
398335409592992
199167704796496
99583852398248
49791926199124
24895963099562
12447981549781
37343944649344
18671972324672
9335986162336
4667993081168
2333996540584
1166998270292
583499135146
291749567573
875248702720
437624351360
218812175680
109406087840
54703043920
27351521960
13675760980
6837880490
3418940245
10256820736
5128410368
2564205184
1282102592
641051296
320525648
160262824
80131412
40065706
20032853
60098560
30049280
15024640
7512320
3756160
1878080
939040
469520
234760
117380
58690
Note the last number is even, but we count the n/2 operations,
not the even numbers.
So you can see I am heavily invested in using the 3n+1 rule.
To use n+(n+1)/2 would take a lot of rework. I would do it if
there was some other advantage to using n+(n+1)/2, but I am
not aware of any.
mensa...@aol.com
> just the sequence vector with 10 and 9 the small sequence but i will
> make the true sequence
> question ( the time ).
>
> 58254222222746453
> 174762666668239360
> 87381333334119680
> 43690666667059840
> 21845333333529920
> 10922666666764960
>
> 5461333333382480
> 2730666666691240
> 1365333333345620
> 682666666672810
>
> 341333333336405
> 1024000000009216
> 512000000004608
> 256000000002304
> 128000000001152
> 64000000000576
> 32000000000288
> 16000000000144
> 8000000000072
> 4000000000036
> 2000000000018
> 1000000000009
That's an interesting set of numbers.
How did you come up with them?
Let's have some fun with them.
First, I load my utility library (this is the Python
programming language).
>>> from collatz_functions import *
The sequence vector of your example is [9,10], so we
create a variable to use with the library.
>>> sv = [9,10]
Once we have a sequence vector, we can calculate the
Hailstone Function parameters X,Y,Z. By convention,
the first number in the Collatz sequence is called the
seed and the last number in the sequence is called the
hailstone. In your example, we say 1000000000009 is the
hailstone produced from the seed 58254222222746453 by
a Type [9,10] sequence vector.
>>> xyz = calc_xyz(sv)
>>> xyz
524288,
9,
515
That means our Hailstone Function is
524288*a - 515
g = --------------
9
With the Hailstone Function parameters, we can calculate
the seed number directly from the hailstone
>>> g = seed(1000000000009,xyz)
>>> g
58254222222746453
At this point we ask, since there are infinitely many
seed:hailstone pairs of Type [9,10], which one is this?
To answer that, we need to know what the smallest hailstone
of Type [9,10] is (we'll call it a0).
>>> a0 = geni(1,1,xyz)
>>> a0
1
Aha! There is actually a [9,10] sequence vector that
ends at 1. The seed of a0 (called g0) is
>>> g0 = seed(1,xyz)
>>> g0
58197
Take a quick moment to verify that:
>>> z = zigzag(58197,sv,1,1)
58197
174592
87296
43648
21824
10912
5456
2728
1364
682
341
1024
512
256
128
64
32
16
8
4
2
1
So if the first hailstone is 1, which one is 1000000000009?
The ith hailstone (ai) is
ai = Y*i + a0
Solving for i we get
i = (ai - a0)/Y
>>> i = divmod(1000000000009 - 1,9)
>>> i
(111111111112, 0)
So 1000000000009 is the
one hundred eleven billion,
one hundred eleven million,
one hundred eleven thousand,
one hundred twelth
Type [9,10] hailstone.
Now what if we extend your sequence past [9,10]
and all the way to 1 (which it will if the Collatz
Conjecture is true).
>>> collatz(58254222222746453,0)
[181, 79]
So your seed number 58254222222746453 must have a
complete sequence whose vector contains 79 elements
summing to 181.
Let's check that:
>>> sv1 = build_sv(58254222222746453,1,1000,1)
>>> sv1
[9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4]
Now here is an interesting bit. since the hailstone
for this seed:vector is 1, it MUST be the FIRST
occurrence of that vector (because you can't have
a smaller hailstone than 1). But's let's check that.
First, we need to know the X,Y,Z Hailstone Function
parameters for the extended vector sv1.
>>> xyz1 = calc_xyz(sv1)
>>> xyz1
3064991081731777716716694054300618367237478244367204352,
49269609804781974438694403402127765867,
194828283336001091457457643799667913282145270678484601
Now we'll ask for the 1st, 1st generation hailstone
of Type sv1.
>>> a1_0 = geni(1,1,xyz1)
>>> a1_0
1
Yep, it's 1. But what did I mean by 1st generation?
A sequence vector is said to be muti-generation if
it can be partitioned into identical sub-partitions.
The sequence vector [9,10] can only be partitioned
as [9] and [10] which are not equal, so it's 1st
generation. But for [1,2,3,1,2,3] we can partition
it into 2, 3 or 6 sub-partitions
[1,2,3] [1,2,3] <-- sub-partitions identical
[1,2] [3,1] [2,3] <-- sub-partitions not identical
[1] [2] [3] [1] [2] [3] <-- sub-partitions not identical
So we say [1,2,3,1,2,3] is a 2nd generation Type [1,2,3]
sequence vector (that has important implications).
So your example is the 1st member of the 1st generation
Type sv1 hailstones.
>From my Collatz library, I can, of course, ask for ANY
member of ANY generation. For instance, the 6th hailstone
of the 1st generation Type sv1 is
>>> a1_6 = geni(1,6,xyz1)
>>> a1_6
246348049023909872193472017010638829336
And the 6th member of the 6th generation would be
>>> a1_6_6 = geni(6,6,xyz1)
>>> a1_6_6
73174245449674452607758382852174123159522586
22480473382723543814113715649760796500096847
47959497521811218642138013356737611666714611
26099865635603877633061803484325004233437534
10878585971194000344682077684207595859884558
6575894
But that's just the hailstone. What seed generates it?
>>> g1_6_6 = gclass(a1_6_6,xyz1)
>>> g1_6_6
(6,
42409075661646398452349555127393245778868
13667569136750084910390854638425595631177
63000592040680408534872919715068423760742
72959259923207681348169364445572394091389
51299748150743565610993675182443519455327
83729679051528421543622284042845948620734
18485837633542051737545408074512088717958
21652101626426932959730729838110597768021)
The first number (6) is the generation, the second BIG
number is the seed.
But don't take my word for it. If we run the Collatz
sequence from seed g1_6_6 to hailstone a1_6_6 and record
its sequence vector, we should see the sv1 pattern
repeated 6 times (because that's what 6th generation
means)
>>> sv2 = build_sv(g1_6_6[1],a1_6_6,1000000,1)
>>> sv2
[9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4,
9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4,
9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4,
9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4,
9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4,
9, 10, 2, 1, 1, 2, 3, 3, 1, 2, 2, 2, 3, 2, 2, 1, 3,
1, 3, 1, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 4, 2, 8, 1,
1, 3, 1, 2, 2, 4, 3, 2, 2, 1, 2, 2, 1, 3, 5, 1, 1,
1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 4,
3, 6, 2, 1, 2, 1, 1, 2, 4, 9, 4]
>>>
We could then, extend that sequence to 1, find the new
Hailstone Function, determine the 6th, 6th generation
seed of that function and repeat ad infinitum.
Or at least until we run out of memory.
That was interesting, but it doesn't prove anything.
But things get even more interesting when you start
looking at loop cycles, which, if one exists, will prove
the conjecture false.
That's the important implications I alluded to earlier.
mensa...@aol.com
rachid baih wrote:
> The sequence vector [8,9], but n is very large numbre World Records
>
> i cant devleope sequence vector with n = 10000000000 ...000000 digits
That's right, you can't. At least not directly.
>
> yes for u question i will give you may thechnik ok .
> if i give you one sequence vector with n = 10000000000 ...000000
> digits can you help me registered voter officially in the list of
> World Records.
I don't think anyone is keeping that kind of record.
There is a distributed computer project to test all
the integers, but the world records they keep are
for relative record holders, not absolute records.
Unless you can show that there is no SMALLER
number with the properties you are claiming is
a record, then no one will be interested.
The reason is because you can ALWAYS construct
a number larger than your proposed world record.
If you give me a record sequence vector with
n = 10000000000 ...000000 digits, all I have to do
is calculate the generation:member number, double it and I've
beaten your record. But unless I test all numbers between
your number and my number (which is impossible for
numbers that size) I won't know if it is an absolute record
or not. Of course, the same applies to you.
And I have no connection to those record keeping groups.
But if you want to join them, check the Wikipedia article,
I think there is a link to them there.
>
>
> n= 31247793240386927598027938732463673230673057786307877973
>
> //////////////////////////////////////////
> 31247793240386927598027938732463673230673057786307877973
>
> 93743379721160782794083816197391019692019173358923633920
> 46871689860580391397041908098695509846009586679461816960
> 23435844930290195698520954049347754923004793339730908480
> 11717922465145097849260477024673877461502396669865454240
> 5858961232572548924630238512336938730751198334932727120
> 2929480616286274462315119256168469365375599167466363560
> 1464740308143137231157559628084234682687799583733181780
> 732370154071568615578779814042117341343899791866590890
>
> 366185077035784307789389907021058670671949895933295445
>
> 1098555231107352923368169721063176012015849687799886336
> 49277615553676461684084860531588006007924843899943168
> 274638807776838230842042430265794003003962421949971584
> 137319403888419115421021215132897001501981210974985792
> 68659701944209557710510607566448500750990605487492896
> 34329850972104778855255303783224250375495302743746448
> 17164925486052389427627651891612125187747651371873224
> 8582462743026194713813825945806062593873825685936612
> 42912313715130973569069129729030312969369128429683062
>
> 21456156857565486784534564864515156484684564214841531
The last number is wrong. It should be
2145615685756548678453456486451515648468456421484153
mensa...@aol.com
rachid baih wrote:
> big sequnce vector ( 99;100) yes
> n is large numbre and the sequense is also large 99&100
> n =
> ((((15546368009147828205655497029495868709924872394186556968979346830352877966835765108761255270461354288653903307603952643465480119368447935690445282259274901588562072406924436860384294629146658369955634806401298377456806313504490655468230464748036595698288593277735082575287035595124567369752102068349990377900242540386380070564807519884707955120330329262740821))))
>
> 1
> 2
> 3
> 4
> .
> .99 setap
> .
>
> 73583531643572009390368939945436377592002002041853967650109042870852063431677570953751873009834423762041853980808495602961417537370584693822059568303918027155392901637251360488726234970584690448965048804644209758783257458011245663365401941542600771615658265515440477033218694845846224999940129070197538199554369816178915859060053
>
>
> 1 to 100 setap
>
>
> The last number is
>
> 174141514145121545812415545812415154581241554581241515458124155458124151545812415545812415154581241554581241546598534354581241546598534354581241546598534354581241546598534354581241546598534346598534358453841354541534154135453415341541534153151515153451454531654651220021515015451200021415121584554535
How are you finding these?
mensa...@aol.com
> hi why not (you and me) organize a concour of (sequance vector prize
> )Everyone can take part.
>
> I want to know your opinion Mister
>
> thank you
It would not be a fair contest.
You cannot win.
No matter how large your world record is,
I can always construct a larger one.
I explained this before, but maybe you did
not read or understand it, so I'll go over
it again.
You cannot win.
Here's why:
There are an infinite number of solutions to
every sequence vector. I don't know which
solution yours is, so let's call it ni (the
ith solution). Because there are an infinite
number of solutions, no matter how large ni is,
there exists a j such that:
solutions: n0, n1, n2, n3, ... ni, ... nj ...
If I can find out what i is, then I can
construct nj, which will beat your contest
entry.
You cannot win.
Watch as I beat the last one you submitted.
sv = [4,5,6,7]
ni = 24734845893
First, let's check that it's valid.
vv = zigzag(ni,sv,1,1)
24734845893
74204537680
37102268840
18551134420
9275567210
4637783605
13913350816
6956675408
3478337704
1739168852
869584426
434792213
1304376640
652188320
326094160
163047080
81523540
40761770
20380885
61142656
30571328
15285664
7642832
3821416
1910708
955354
477677
Ok, looks good. Next I'll get the hailstone
(the last number in the sequence) and since it's
generated by ni, we'll call it ai.
ai = vv[-1]
The reason the sequence vector is important is
because we use it to calculate the Hailstone
Function Parameters xyz which are the key to
solving these problems by construction.
xyz = calc_xyz(sv)
I don't know if your solution is 1st generation
or not, but I can find out.
k = gclass(ai,xyz)
Your solution ni generates hailstone ai. To find
out what i is, we have to find a0, the 1st solution
of the sequence vector (that's why I need to
know the generation).
a0 = geni(k[0],1,xyz)
>From which i follows immediately.
i = (ai-a0)/xyz[1]**k[0]
I don't even have to print the actual value of i,
I can make it a LOT bigger by squaring it (adding
1 makes sure the hailstone is also an odd number).
j = i**2 + 1
Do you see why you cannot win. If my index (j)
is bigger than your index (i), then nj will be
bigger than ni.
You cannot win.
But we haven't got nj yet. To get it, we need aj
first.
aj = geni(k[0],j,xyz)
>From aj, we get the seed (kj[1]) from gclass.
The seed will be nj.
kj = gclass(aj,xyz)
Now all I have to do is run the sequence starting
from nj.
vvj = zigzag(kj[1],sv,1,1)
145855282662341
437565847987024
218782923993512
109391461996756
54695730998378
27347865499189
82043596497568
41021798248784
20510899124392
10255449562196
5127724781098
2563862390549
7691587171648
3845793585824
1922896792912
961448396456
480724198228
240362099114
120181049557
360543148672
180271574336
90135787168
45067893584
22533946792
11266973396
5633486698
2816743349
The sequence vector is [4,5,6,7].
145855282662341 > 24734845893
You lose.
Game over.
Want to play again?
But remember...
You cannot win.
rachid baih
sequance ( 71;72;73) you or me or another person
ok
play (hi hi hi hi )
mensa...@aol.com
This is the smallest such number:
42905007716819594580632857561028721859121306461605710196748146005
128715023150458783741898572683086165577363919384817130590244438016
64357511575229391870949286341543082788681959692408565295122219008
32178755787614695935474643170771541394340979846204282647561109504
16089377893807347967737321585385770697170489923102141323780554752
8044688946903673983868660792692885348585244961551070661890277376
4022344473451836991934330396346442674292622480775535330945138688
2011172236725918495967165198173221337146311240387767665472569344
1005586118362959247983582599086610668573155620193883832736284672
502793059181479623991791299543305334286577810096941916368142336
251396529590739811995895649771652667143288905048470958184071168
125698264795369905997947824885826333571644452524235479092035584
62849132397684952998973912442913166785822226262117739546017792
31424566198842476499486956221456583392911113131058869773008896
15712283099421238249743478110728291696455556565529434886504448
7856141549710619124871739055364145848227778282764717443252224
3928070774855309562435869527682072924113889141382358721626112
1964035387427654781217934763841036462056944570691179360813056
982017693713827390608967381920518231028472285345589680406528
491008846856913695304483690960259115514236142672794840203264
245504423428456847652241845480129557757118071336397420101632
122752211714228423826120922740064778878559035668198710050816
61376105857114211913060461370032389439279517834099355025408
30688052928557105956530230685016194719639758917049677512704
15344026464278552978265115342508097359819879458524838756352
7672013232139276489132557671254048679909939729262419378176
3836006616069638244566278835627024339954969864631209689088
1918003308034819122283139417813512169977484932315604844544
959001654017409561141569708906756084988742466157802422272
479500827008704780570784854453378042494371233078901211136
239750413504352390285392427226689021247185616539450605568
119875206752176195142696213613344510623592808269725302784
59937603376088097571348106806672255311796404134862651392
29968801688044048785674053403336127655898202067431325696
14984400844022024392837026701668063827949101033715662848
7492200422011012196418513350834031913974550516857831424
3746100211005506098209256675417015956987275258428915712
1873050105502753049104628337708507978493637629214457856
936525052751376524552314168854253989246818814607228928
468262526375688262276157084427126994623409407303614464
234131263187844131138078542213563497311704703651807232
117065631593922065569039271106781748655852351825903616
58532815796961032784519635553390874327926175912951808
29266407898480516392259817776695437163963087956475904
14633203949240258196129908888347718581981543978237952
7316601974620129098064954444173859290990771989118976
3658300987310064549032477222086929645495385994559488
1829150493655032274516238611043464822747692997279744
914575246827516137258119305521732411373846498639872
457287623413758068629059652760866205686923249319936
228643811706879034314529826380433102843461624659968
114321905853439517157264913190216551421730812329984
57160952926719758578632456595108275710865406164992
28580476463359879289316228297554137855432703082496
14290238231679939644658114148777068927716351541248
7145119115839969822329057074388534463858175770624
3572559557919984911164528537194267231929087885312
1786279778959992455582264268597133615964543942656
893139889479996227791132134298566807982271971328
446569944739998113895566067149283403991135985664
223284972369999056947783033574641701995567992832
111642486184999528473891516787320850997783996416
55821243092499764236945758393660425498891998208
27910621546249882118472879196830212749445999104
13955310773124941059236439598415106374722999552
6977655386562470529618219799207553187361499776
3488827693281235264809109899603776593680749888
1744413846640617632404554949801888296840374944
872206923320308816202277474900944148420187472
436103461660154408101138737450472074210093736
218051730830077204050569368725236037105046868
109025865415038602025284684362618018552523434
54512932707519301012642342181309009276261717
163538798122557903037927026543927027828785152
81769399061278951518963513271963513914392576
40884699530639475759481756635981756957196288
20442349765319737879740878317990878478598144
10221174882659868939870439158995439239299072
5110587441329934469935219579497719619649536
2555293720664967234967609789748859809824768
1277646860332483617483804894874429904912384
638823430166241808741902447437214952456192
319411715083120904370951223718607476228096
159705857541560452185475611859303738114048
79852928770780226092737805929651869057024
39926464385390113046368902964825934528512
19963232192695056523184451482412967264256
9981616096347528261592225741206483632128
4990808048173764130796112870603241816064
2495404024086882065398056435301620908032
1247702012043441032699028217650810454016
623851006021720516349514108825405227008
311925503010860258174757054412702613504
155962751505430129087378527206351306752
77981375752715064543689263603175653376
38990687876357532271844631801587826688
19495343938178766135922315900793913344
9747671969089383067961157950396956672
4873835984544691533980578975198478336
2436917992272345766990289487599239168
1218458996136172883495144743799619584
609229498068086441747572371899809792
304614749034043220873786185949904896
152307374517021610436893092974952448
76153687258510805218446546487476224
38076843629255402609223273243738112
19038421814627701304611636621869056
9519210907313850652305818310934528
4759605453656925326152909155467264
2379802726828462663076454577733632
1189901363414231331538227288866816
594950681707115665769113644433408
297475340853557832884556822216704
148737670426778916442278411108352
74368835213389458221139205554176
37184417606694729110569602777088
18592208803347364555284801388544
9296104401673682277642400694272
4648052200836841138821200347136
2324026100418420569410600173568
1162013050209210284705300086784
581006525104605142352650043392
290503262552302571176325021696
145251631276151285588162510848
72625815638075642794081255424
36312907819037821397040627712
18156453909518910698520313856
9078226954759455349260156928
4539113477379727674630078464
2269556738689863837315039232
1134778369344931918657519616
567389184672465959328759808
283694592336232979664379904
141847296168116489832189952
70923648084058244916094976
35461824042029122458047488
17730912021014561229023744
8865456010507280614511872
4432728005253640307255936
2216364002626820153627968
1108182001313410076813984
554091000656705038406992
277045500328352519203496
138522750164176259601748
69261375082088129800874
34630687541044064900437
103892062623132194701312
51946031311566097350656
25973015655783048675328
12986507827891524337664
6493253913945762168832
3246626956972881084416
1623313478486440542208
811656739243220271104
405828369621610135552
202914184810805067776
101457092405402533888
50728546202701266944
25364273101350633472
12682136550675316736
6341068275337658368
3170534137668829184
1585267068834414592
792633534417207296
396316767208603648
198158383604301824
99079191802150912
49539595901075456
24769797950537728
12384898975268864
6192449487634432
3096224743817216
1548112371908608
774056185954304
387028092977152
193514046488576
96757023244288
48378511622144
24189255811072
12094627905536
6047313952768
3023656976384
1511828488192
755914244096
377957122048
188978561024
94489280512
47244640256
23622320128
11811160064
5905580032
2952790016
1476395008
738197504
369098752
184549376
92274688
46137344
23068672
11534336
5767168
2883584
1441792
720896
360448
180224
90112
45056
22528
11264
5632
2816
1408
704
352
176
88
44
22
11
rachid baih
mensa...@aol.com
rachid baih wrote:
> very good ; How are you finding ! with the aj and nj !!!
Yes, my programs can do anything, all I need is a sequence vector.
from collatz_functions import *
sv = [71,72,73]
Once I have this, I can find ANY of the infinite solutions.
But since this will be big, I picked the first pair n0,a0.
xyz = calc_xyz(sv)
These functions are defined backwards, to find the starting
number (n0), I first must find the ending number (a0).
a0 = geni(1,1,xyz)
a0
mpz(11)
So the sequence ends at 11 (as you saw in the run).
Now I just need to know the starting number n0.
g0 = gclass(a0,xyz)
g0[1]
mpz(42905007716819594580632857561028721859121306461605710196748146005L)
If I thought the starting number was too small (such that you
might find a bigger one), I just need to ask for a larger element
of a higher generation:
a1000 = geni(1000,1000,xyz) # element 1000 of generation 1000
g1000 = gclass(a1000,xyz)
g1000[1]
30126... < 65016 digits snipped > ...21845
And if you ran that sequence, you would see the sequence pattern
71,72,73 repeat 1000 times.
mensa...@aol.com
Very good. I think I see what you are doing.
Similar idea to what I do, but a little different.
If you put all the integers on a tree structure, like
<http://members.aol.com/mensanator666/treemap/mainmap.htm>
the problem is: can we get from ni to ai by the path described
by the sequence vector?
Here I'll use __ to represent 3n+1 and | to represent n/2.
So the sequence vector [1,2] means the path through the tree
would be
ni__w
| <- 1 step
x__y
|
z
| <- 2 steps
ai
For this path to exist for a given pair of integers ni,ai
w,x,y,z must also be integers. What we would like is an
algorithm that takes us from ai to ni without having to
compute w,x,y,z.
Your algorithm checks the modulo 9 of ni and if it's
1; 7 or 9 it implies that w,x,y,z must have also been
integers so ni is a solution to the sequence vector for ai.
My algorithm doesn't need to start with a random ni, all I
need is the sequence vector. My algorithm always finds a
solution. I'll show you how it's different from yours:
>ok
> my algo is very simple:
> the sequnce (a;b;c)
> [(n*2^a)-1]/3 * [2^b-1]/3 * [2^c-1]/3
First, let's make this a liitle easier by doing just (1,2)
and draw a tree
g__e
|
d__c
|
b
|
a
What I do is first solve for each variable in terms of a.
b = a*2
c = a*4
d = (a*4 - 1)/3
e = (a*8 - 2)/3
g = (a*8 - 2 - 3)/9
= (a*8 - 5)/9
And here is the key trick: EVERY sequence vector, REGARDLESS
of length, will produce the same equation:
ni = (ai*X - Z)/Y
(see my Nov 22 message for how X,Y,Z are determined)
Once we have the X,Y,Z (for which I only need the sequence
vector), we have to solve the equation. That means finding
an integer ai such that ni will also be an integer. Here
our algorithms differ slightly, you look for ni to have
a specific congruence class. But for my equation, I just
need to look for
(ai*X - Z) == 0 (mod Y)
(because that is what it means for (ai*X - Z) to be
divisible by Y). Note that ni disappears at this point,
I'll get it back later, once I solve for ai.
If I rearrange the congrunce, I get a form
ai*X == Z (mod Y)
known as a Linear Congruence. A Linear Congruence is
solvable IIF GCD(X,Y) divides Z. Because X is always a
power of 2 and Y is always a power of 3, GCD(X,Y) always
is 1 and 1 always divides Z, so the Linear Congruence is
always solvable. That proves that EVERY POSSIBLE sequence
vector appears somewhere on the Collatz Tree. And if
there is one solution, there are an infinite number of
them because if ai is a solution, so is ai+Y (which by
induction means there are an infinite number of them).
Now since GCD(X,Y)=1, there exists a modular inverse
(lookup the Extended Euclidean Algorithm if you don't
have a modular inverse function). In Python, the function
is invert() so the solution to the Linear Congruence is
a0 = invert(X,Y)*Z % Y
This solution is always the first solution, hence it's
actually a0. If I want the ith solution, then
ai = Y*i + a0
Now I plug ai into
ni = (ai*X - Z)/Y
to find ni (see, I got it back).
As you may have noticed, I have a whole library of
functions that work with sequence vectors. It's all written
in Python but could be translated to other languages
if you're interested.
> if dosnt work next n +
>but if n modulo 9 = t and 2^a modulo 9 = c
> modulo 9
> if t*c = 1 ; 4 ; or 7 deos work alwese .
>
>exemple :
> the sequnce : 9 ; 10
> [(n*2^10)-1]/3 * [2^9-1]/3
>and
> 2^10 = 1024 ------- 7 modulo 9 c = 7
>then t * c = 1 ; 4 or 7
> t * 7 = 1 ; 4 or 7
>then t = 1 ; 7 or 9
>
> random n = 1000000000009 then t = 1
>
>[1000000000009*2^10-1]/3 * [2^9-1]/3 = 58254222222746453
mensa...@aol.com
rachid baih wrote:
> yes im very intersted to translatesd but im from morocco , and i dont
> think that very importanet to translted to arabic you must translatesd
> to frensh & other languages is very best .
Sorry, I meant PROGRAMMING languages. If you have Python,
you can run my programs directly. If you are using Java or c++
or something else, the programs have to be re-written for that
system. What I meant was there isn't anything in my Python
programs that can't be done in any other language, but it may be
harder to do.
Alas, I speak only English and could not translate to French or
anything else.
>
> but i like work with you of course if you want .
>
> i have the prove for the prime numbres and i want win the million ยง
> (lol)
>
>
> http://www.claymath.org/millennium/
> if you're interested. to give the prove ; you must bilieve . way not
The Collatz Conjecture is not a million dollar prize. I don't even
understand the problems, let alone think I can solve any of them.
Good luck.
> .
rachid baih
1.01 free because it compiles for back (compatible Windows 95 98 NT...)