Collatz Sequence Parameters

[bill]

A CS is comprised of two sets of numbers;

1. The odd numbers which are called "hailstones" and
2 The even numbers, which act as "spacers" for the hailstones.
The quality of the spacers
is less important that their quantity The quantity of spacers
between two successive
hailstones is called a "vector"! In a CS, the totality of
the vectors is a
"vector sequence" (VS)

NOTE: Some authorities prefer to denote all elements in the CS as
hailstones, but in
further discussions, it will be convenient to restrict hailstones to
the odd numbers.

A typical CS is shown below;

4,097 1 6,147 2 4,611 2 3,459 2 2,595 2 1,947 2 1,461 1 2,193 1 3,291
2 2,469 1 3,705 1 5,559 3 2,085 1 3,129 1 4,695 3 1,761 1 2,643 2
1,983 6 93
.
The VS associated with SEED 4097 is {1 2 2 2 2 2 1 1 2 1 1 3 1 1 3 1
2 6} This same
vector is also associated with an infinity of other SEEDs. There is a
simple formula that calculates all SEEDs that have this same VS.

Another simple formula calculates the last hailstone of the CS's for
each initial SEED.

I will discuss the derivation of these formulas in subsequent
posts!.

Bill J

[mensa...@aol.com]

On Dec 27, 1:47�pm, bill <b92...@yahoo.com> wrote:
> A CS is comprised of two sets of numbers;
>
> � �1. �The odd numbers which are called "hailstones" and
> � �2 � The even numbers, which act as "spacers" for the hailstones.
> The quality of the spacers�is less important that

> their quantity �

Don't forget their order. {1 2 3 4} vs {2 4 1 3}.

> The quantity of spacers between two
> successive�hailstones is called a "vector"! � In a CS,
> �the totality of the vectors is a�"vector sequence" �(VS)

Catchy. Wish I had thought of something like that.

>
> NOTE: �Some authorities prefer to denote all elements in the CS as
> hailstones, but in further discussions, it will be convenient
> to restrict hailstones to the odd numbers.

Does this mean the CS must end on an odd number?

>
> A typical CS is shown below;
>
> 4,097 � 1 � � � 6,147 � 2 � � � 4,611 � 2 � � � 3,459 � 2
> 2,595 � 2 � � � 1,947 � 2 � � � 1,461 � 1 � � � 2,193 � 1
> 3,291 2 � � � 2,469 � 1 � � � 3,705 � 1 � � � 5,559 � 3
> 2,085 � 1 � � � 3,129 � 1 � � � 4,695 � 3 � � � 1,761 � 1
> 2,643 � 2 1,983 � 6 � � � 93
> .

Uh...not quite. You seem to have made a miscalculation
here. The correct sequence is

4097
12292
6146 <- you have 6147
3073
9220
4610 <- you have 4611
2305
6916
3458 <- you have 3459
1729

> The VS associated with SEED 4097 is {1 2 2 2 2 2 1 1 2 1
> 1 3 1 1 3 �1 2 6}

Should be: [2, 2, 2, 2, 2, 3, 3, 2, 1, 1, 2, 1, 1, 1, 2, 3,
1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 4, 2,
2, 4, 3]

> This same vector is also associated with an infinity of

> other SEEDs. �

Agreed.

> There is a simple formula that calculates all
> SEEDs that have this same VS.

Hopefully based on the correct CS, not the one you posted.

>
> Another simple formula calculates the last hailstone of the
> CS's for each initial SEED.

Been there, done that.

>
> I will discuss the derivation of these formulas in subsequent
> posts!.

Looking forwards to it.

>
> Bill J

[bill]

On Dec 27, 6:18 pm, "mensana...@aol.com" <mensana...@aol.com> wrote:
> On Dec 27, 1:47�pm, bill <b92...@yahoo.com> wrote:
>
> > A CS is comprised of two sets of numbers;
>
> > � �1. �The odd numbers which are called "hailstones" and
> > � �2 � The even numbers, which act as "spacers" for the hailstones.
> > The quality of the spacers�is less important that
> > their quantity �
>
> Don't forget their order. {1 2 3 4} vs {2 4 1 3}.

The order is determined by the initial seed.

>
> > The quantity of spacers between two
> > successive�hailstones is called a "vector"! � In a CS,
> > �the totality of the vectors is a�"vector sequence" �(VS)
>
> Catchy. Wish I had thought of something like that.
>

> If you didn't, then who did? It's not my idea. I would call the odd-numbers;
the "ODD.s" and the even numbers, the "spacers".

>
> > NOTE: �Some authorities prefer to denote all elements in the CS as
> > hailstones, but in further discussions, it will be convenient
> > to restrict hailstones to the odd numbers.
>
> Does this mean the CS must end on an odd number?
>

> Yes!

> Your hopes have come true.

>
> > Another simple formula calculates the last hailstone of the
> > CS's for each initial SEED.
>
> Been there, done that.
>

> Maybe, maybe not.

>
> > I will discuss the derivation of these formulas in subsequent
> > posts!.
>
> Looking forwards to it.
>
>
>
> > Bill J

Let CS_0 be the CS with the smallest initial SEED that generates a
specific VS_0
Let S_0 be the smallest initial seed that generates
VS_0.
Let H_0 be the last odd hailstone of CS_0
Let V be the number of vectors in VS.
Let M be the sum of the vectors in VS
Let S_i be the initial seed of a CS_i which has the same VS as
CS_0.
Let H_i be the last odd hailstone in CS_i. Then, the empirically
derived formulas are;

S_i = S_0 + ( 2 * 2 ^ M) * i
H_i = H_0 + ( 2 * 3 ^ V) * i
For the cited CS.
S_0 = 4097
H_0 = 23
V = 36
M = 63

S_1 = 4097 + (2 *2 ^ 63) * 1 =
18,446,744,073,709,555,700
H_1 = 23 + 2*3 ^ 36) * 1 =
100,063,090,197,999,437
Bill J

[mensa...@aol.com]

On Dec 29, 4:19 pm, bill <b92...@yahoo.com> wrote:
> On Dec 27, 6:18 pm, "mensana...@aol.com" <mensana...@aol.com> wrote:
>
> > On Dec 27, 1:47�pm, bill <b92...@yahoo.com> wrote:
>
> > > A CS is comprised of two sets of numbers;
>
> > > � �1. �The odd numbers which are called "hailstones" and
> > > � �2 � The even numbers, which act as "spacers" for the hailstones.
> > > The quality of the spacers�is less important that
> > > their quantity �
>
> > Don't forget their order. {1 2 3 4} vs {2 4 1 3}.
>
> The order is determined by the initial seed.

Right. But there is a certain quirk you should be
aware of. If the vector represents a loop cycle, all
cyclic permutations, {1 2 3} {2 3 1} {3 1 2} are loop
cycles also (all the same cycle, actually). The example
I gave earlier are NOT cyclic permutations.

>
> > > The quantity of spacers between two
> > > successive�hailstones is called a "vector"! � In a CS,
> > > �the totality of the vectors is a�"vector sequence" �(VS)
>
> > Catchy. Wish I had thought of something like that.
>
> > If you didn't, then who did?

I was just being funny. Of course I know I coined the
phrase "sequence vector" after seeing the terms "parity
sequence" and "parity vector" used to describe lists of
1's and 0's that represent the parity of the numbers in
the Collatz sequence.

> It's not my idea. I would call the odd-numbers;
>
> the "ODD.s" and the even numbers, the "spacers".

Well, I call emphasis on values "value-centric" thinking.
To me, what's important are the spacers. The sequence of
spacers is what's important, what I call "pattern-centric"
thinking. What's significant about 4097 is that it's a
power of two plus one (1000000000001 in binary) and it's
the PATTERN of 0's bracketed by ones that is significant.
Try comparing it to 4095, a very slight value change, to
see an extreme sequence difference. This is because 4095
is a Mersenne number (111111111111 in binary) and the bit
pattern difference is what accounts for the sequence difference.

>
>
> > > NOTE: �Some authorities prefer to denote all elements in the CS as
> > > hailstones, but in further discussions, it will be convenient
> > > to restrict hailstones to the odd numbers.
>
> > Does this mean the CS must end on an odd number?
>
> > Yes!

Ok, just being clear on that. In my system, only the Seed is
required to be odd (because of how the Hailstone Function is
calculated). Also, I don't name the intermediate odd numbers,
I use "hailstone" to refer to the just last number in the
sequence.

Ok, personally, I don't see the need for the CS structure,
just the list of spacers.

> Let S_0 be the smallest initial seed that generates VS_0.

Ok.

> Let H_0 be the last odd hailstone of CS_0

Ok.

> Let V be the number of vectors in VS.

And would be one less than the number of OOD.s (which
include the seed and all the hailstones), right?

> Let M be the sum of the vectors in VS

Ok.

> Let S_i be the initial seed of a CS_i which has the same VS as
> CS_0.

Ok. I call the smallest positive solution to a linear congruence
(which has an infite number of solutions) the a0 solution, the
ith member of that set of solutions the ai solution. The Seed,
of course, is the gi solution.

> Let H_i be the last odd hailstone in CS_i.

> Then, the empirically derived formulas are;

You derived them epirically? Not algebraically? How do you
know they always hold?

>
> S_i = S_0 + ( 2 * 2 ^ M) * i

The extra 2 in there is because you insist on stopping on an odd
number. If you used S_0 + (2 ^ M) * i you would get sequences that
stop alternately on even and odd numbers.

> H_i = H_0 + ( 2 * 3 ^ V) * i

Ditto.

> For the cited CS.
> S_0 = 4097
> H_0 = 23

Ok, sequence verified.
4097
12292
6146
3073
9220
4610
2305
6916
3458
1729
5188
2594
1297
3892
1946
973
2920
1460
730
365
1096
548
274
137
412
206
103
310
155
466
233
700
350
175
526
263
790
395
1186
593
1780
890
445
1336
668
334
167
502
251
754
377
1132
566
283
850
425
1276
638
319
958
479
1438
719
2158
1079
3238
1619
4858
2429
7288
3644
1822
911
2734
1367
4102
2051
6154
3077
9232
4616
2308
1154
577
1732
866
433
1300
650
325
976
488
244
122
61
184
92
46
23

> V = 36

Not ok, you have mis-counted again, s/b 35.

> M = 63

Ok.

>
> S_1 = 4097 + (2 *2 ^ 63) * 1 =
> 18,446,744,073,709,555,700

You made another typo.
>>> 4097+(2*2**63)*1
18446744073709555713L

> H_1 = 23 + 2*3 ^ 36) * 1 =
> 100,063,090,197,999,437

Actually, this number is correct - for the correct exponent.
>>> 23+(2*3**35)*1
100063090197999437L

So, the 36 was a typo?

Let's step through the exercise using my collatz_funtions library.

I've already verified that 4097 does sequence to 23, so we can
start by creating the Sequence Vector (same as your VS).

>>> sv = cf.build_sv(4097,23,1000,1)
>>> sv

[2, 2, 2, 2, 2, 3, 3, 2, 1, 1, 2, 1, 1, 1, 2, 3, 1, 1, 2, 1, 2,
1, 1, 1, 1, 1, 3, 1, 1, 1, 4, 2, 2, 4, 3]

How many vectors? That would be your V. They're in a list, so
let the computer count them.

>>> len(sv)
35

See, not 36. If you don't believe me, do the empirical test
and count them yourself from the sequence I printed above.

We can have the computer sum them also, to get your M.

>>> sum(sv)
63

For the next step, I calculate the X, Y, Z constants (the
Z term is necessary if I have the VS but neither the S_0
nor H_0). Amazingly, both S_0 and H_0 can be calculated
from just VS. My functions calculate X and Y as shown
above (without the extra factor of 2). We don't need the
Z term for this exercise, but my function calculates all
of them.

>>> xyz = cf.calc_xyz(sv)
>>> xyz
(mpz(9223372036854775808L),
mpz(50031545098999707L),
mpz(7158316577058044005L))

so, to get the ith seed and hailstone, I have to get the
2nd elements since I allow even hailstones.

>>> s_1 = 4097 + xyz[0]*2
>>> s_1
mpz(18446744073709555713L)
>>> h_1 = 23 + xyz[1]*2
>>> h_1
mpz(100063090197999437L)

So, we agree that finding S_i and H_i are trivially easy,
once you know S_0 and H_0. My system's advantage is that it
can find S_0 and H_0 purely from VS (CS being unnecessary).

One place where this is an advantage is where you calculate
VS, such as generating all partitions of N items into M
bins such that each bin contains at least one item. Very
handy for Factor Congruence in 3n+C systems.

Also, the constants X, Y and Z are used to find the Crosover
Point, the most important thing of all.


> Bill J

[bill]

On Dec 30 2007, 9:41 pm, "mensana...@aol.com" <mensana...@aol.com>

With your permission, heretofore I will use the terms "vectors" and
"VS's"
for the evens. However, it will be less ambiguous if I use "ODD" for
a
general odd-number and hailstone for a specific odd element.

The CS structure defines the VS, S_0 and H_0.

>
> > Let S_0 be the smallest initial seed that generates VS_0.
>
> Ok.
>
> > Let H_0 be the last odd hailstone of CS_0
>
> Ok.
>
> > Let V be the number of vectors in VS.
>
> And would be one less than the number of OOD.s (which
> include the seed and all the hailstones), right?

Right!

>
> > Let M be the sum of the vectors in VS
>
> Ok.
>
> > Let S_i be the initial seed of a CS_i which has the same VS as
> > CS_0.
>
> Ok. I call the smallest positive solution to a linear congruence
> (which has an infite number of solutions) the a0 solution, the
> ith member of that set of solutions the ai solution. The Seed,
> of course, is the gi solution.
>
> > Let H_i be the last odd hailstone in CS_i.
> > Then, the empirically derived formulas are;
>

> You derived them empirically? Not algebraically? How do you
> know they always hold?
>
> Since they are identical to your formulas, I rely on you for their
consistency?

> > S_i = S_0 + ( 2 * 2 ^ M) * i
>
> The extra 2 in there is because you insist on stopping on an odd
> number. If you used S_0 + (2 ^ M) * i you would get sequences that
> stop alternately on even and odd numbers.
>

I disagree. For example; SEED_4097 can stop on 184, 92, 46 or 23;
which is not alternating odds and evens.

Right.

>
> Let's step through the exercise using my collatz_funtions library.
>
> I've already verified that 4097 does sequence to 23, so we can
> start by creating the Sequence Vector (same as your VS).
>
> >>> sv = cf.build_sv(4097,23,1000,1)
> >>> sv
>
> [2, 2, 2, 2, 2, 3, 3, 2, 1, 1, 2, 1, 1, 1, 2, 3, 1, 1, 2, 1, 2,
> 1, 1, 1, 1, 1, 3, 1, 1, 1, 4, 2, 2, 4, 3]
>
> How many vectors? That would be your V. They're in a list, so
> let the computer count them.
>
> >>> len(sv)
>
> 35
>
> See, not 36. If you don't believe me, do the empirical test
> and count them yourself from the sequence I printed above.

I believe you, I believe you!

Not if there is a Table which shows the VS's for each odd number
up to say 999,999. Of course, not all possible VS's would be
represented
in such a table. But the table could be extended indefinitely; if
time
was not a factor. Any VS with an M < 23 should appear in the
999,999
table. (the limit might be 22 or it might be 24, I haven't thought it
thru.)

> One place where this is an advantage is where you calculate
> VS, such as generating all partitions of N items into M
> bins such that each bin contains at least one item. Very
> handy for Factor Congruence in 3n+C systems.
>
> Also, the constants X, Y and Z are used to find the Crosover
> Point, the most important thing of all

One of the reasons that I hesitate to "stop" on a even number is that
I think that a Crossover Point cannot be an even number..
>
> > Bill J

When I started this exercise I had the naive idea that if you found
a VS that came close to looping; then other iterations of this VS
might tend to converge since delta S <> delta H.

Silly me!

[mensa...@aol.com]

But those are different VS. The VS that stops at 23 ends [..., 4, 3]
Stopping at 46 would be a VS that ends [..., 4, 2] and stopping at
92 would be a VS that ends [..., 4, 1].

What I'm saying is that between H_0=23 and H_1=100063090197999437
there
is another occurence of VS=[2, 2, 2, 2, 2, 3, 3, 2, 1, 1, 2, 1, 1, 1,
2,
3, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 4, 2, 2, 4, 3] but that
particular one ends on an even number, if you extended the sequence
to the next odd number, the last number in the VS wouldn't be 3.

That's why I was asking if you always stop on an odd number. You must
adjust your formulae (which you've done and confused me at first) to
accomplish this since the general rule gives stopping points on even
and odd numbers (which is what I use).

I'm not saying there's anything wrong, just that there are
consequences
that have to be accounted for.

And sonce many small numbers have the same VS, it's safe to say
there would be far fewer than 999,999 distinct VS in such a table,
right?

> Any VS with an M < 23 should appear in the 999,999 table.  

Should it? M is the total number of n/2 operations. How many ways
can 22 be partitioned (order matters, the partitions would be the VS).

There is 1 way to partition 23 into 1 number: [23]
There are 22 ways to partition 23 into 2 numbers: [1,22] [2,21]
[3,20]...
.
.
.
There is 1 way to partition 23 into 23 numbers:
[1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1]

so M=22 has way more than 999,999 distinct VS:

C(22-1,p-1) running sum
1 1
21 22
210 232
1330 1562
5985 7547
20349 27896
54264 82160
116280 198440
203490 401930
293930 695860
352716 1048576
352716 1401292
293930 1695222
203490 1898712
116280 2014992
54264 2069256
20349 2089605
5985 2095590
1330 2096920
210 2097130
21 2097151
1 2097152

> (the limit might be 22 or it might be 24, I haven't thought it
> thru.)

Even M=21 requires 1048576 (and that doesn't consider the duplicates).

>
> > One place where this is an advantage is where you calculate
> > VS, such as generating all partitions of N items into M
> > bins such that each bin contains at least one item. Very
> > handy for Factor Congruence in 3n+C systems.
>
> > Also, the constants X, Y and Z are used to find the Crosover
> > Point, the most important thing of all
>
> One of the reasons that I hesitate to "stop" on a even number is that
> I think that a Crossover Point cannot be an even number..

Well, there is always a Crossover Point that's a rational number
(whatever even/odd means in that context). If it's an integer,
it would have to be odd since an integer Crossover Point is a
loop where Hailstone=Seed and we defined Seed to be odd.

[bill]

I think I understand the problem and concede that you are correct
(as far as it goes) But once you have calculated H_0 and discovered
that it is an even number; why not revert to my formulas to get
only odd H_i's?

>
> What I'm saying is that between H_0=23 and H_1=100063090197999437
> there
> is another occurence of VS=[2, 2, 2, 2, 2, 3, 3, 2, 1, 1, 2, 1, 1, 1,
> 2,
> 3, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 4, 2, 2, 4, 3] but that
> particular one ends on an even number, if you extended the sequence
> to the next odd number, the last number in the VS wouldn't be 3.
>

SO?

> That's why I was asking if you always stop on an odd number. You must
> adjust your formulae (which you've done and confused me at first) to
> accomplish this since the general rule gives stopping points on even
> and odd numbers (which is what I use).
>
> I'm not saying there's anything wrong, just that there are
> consequences that have to be accounted for.

Don't leave me hanging! I've been wracking my brain trying to figure
out why you insist on even H_i's. An even H_0 maybe, but why
even H_i ' s?

> ...
>
> read more »

[mensa...@aol.com]

So your question was wrong. I'm not saying an individual sequence ends
in alternating evens and odds, but that the last number of different
sequences is alternately even or odd.

Take the Sequence vector [1,4]. That means a sequence of operations

(Seed=n)->(3n+1)(n/2)(3n+1)(n/2)(n/2)(n/2)(n/2)->(n=Hailstone)

The function that describes that sequence of operations is

32*H_i - 5
S_i = ----------
9

There are an infinite number of seeds that give us that sequence of
operations and result in integer hailstone.

They are

S_i: 3, 35, 67, 99... (32*i + 3).

Note that all the seeds are odd, but that the hailstones alternate
between even or odd:

H_i: 1, 10, 19, 28... (9*i + 1)

>
> > That's why I was asking if you always stop on an odd number. You must
> > adjust your formulae (which you've done and confused me at first) to
> > accomplish this since the general rule gives stopping points on even
> > and odd numbers (which is what I use).
>
> > I'm not saying there's anything wrong, just that there are
> > consequences that have to be accounted for.
>
> Don't leave me hanging! I've been wracking my brain trying to figure
> out why you insist on even H_i's. An even H_0 maybe, but why
> even H_i ' s?

Because even H_i's come out of the function even when you supply only
odd seeds.

Does that matter? Sometimes.

Take for example the seeds and hailstones of [1,2].

8*H_i - 5
S_i = ---------
9

S_i: 3, 11, 19, 27, 35, 43, 51, 59, 67, 75...
H_i: 4, 13, 22, 31, 40, 49, 58, 67, 76, 85...

Note that the number 67 is on the S_i list AND on the H_i list.

What that means is

8*H_8 - 5
S_8 = ---------
9

and that

8*S_8 - 5
S_7 = ---------
9

In other words, we can plug the seed of H_8 into the function
as a hailstone to get S_7. Thus, H_8 is the hailstone of a
Second Generation Type [1,2] Sequence Vector. Generation counts
how many times a base Sequence Vector type can repeat and still
produce an integer.

1st Generation Type [1,2] = [1,2]
2nd Generation Type [1,2] = [1,2,1,2]
3rd Generation Type [1,2] = [1,2,1,2,1,2]
4th Generation Type [1,2] = [1,2,1,2,1,2,1,2]
5th Generation Type [1,2] = [1,2,1,2,1,2,1,2,1,2]

For Type [1,2], every 9th 1st Generation is a 2nd Generation,
every 9th 2nd Generation is a 3rd Generation, every 9th 3rd
Generation is a 4th Generation, etc. But its's not always that
easy. For some Sequence Vectors, you get very complicated
generation rules like

every 27th 1st generation is a 2nd generation starting from the 5th
every 27th 2nd generation is a 3rd generation starting from the 11th
every 27th 3rd generation is a 4th generation starting from the 23rd
every 27th 4th generation is a 5th generation starting from the 17th

And the goofy rules are different for every Sequence Vector.

Trying to solve THAT makes the simple H_i = H_0 + ( 2 * 3 ^ V) * i
a doddle:

def gen0_recursive(k,xyz):
"""Find first member of generation k of Hailstone Function.

gen0(k,xyz)
k: generation
xyz: HailstoneFunctionParameters
Locates the first _a_ for the requested generation k of the
Hailstone Function.
Needs to know _d_ and _c_ from previous generation, so it calls
itself recursively until generation 1.
At generation 1, results are simple linear congruence of x,y,z.
a: the first solution to the Hailstone Function
g: seed that genertes _a_
d: difference between _a_ and _g_
j: index of _a_ where d == 0 (mod y**k)
c: a[j] the
returns [0,0,0,0] if k invalid
returns GenerationParameters [a,g,d,c]
"""
if k<1: return [0,0,0,0]
if k==1:
# divm finds n such that
# n*x == a (mod y)
#
# this is the first gen 1 _a_
#
a = gmpy.divm(xyz[2],xyz[0],xyz[1])
g = seed(a,xyz)
d = a - g
c = a
return [a,g,d,c]
else:
prev_gen = gen0(k-1,xyz)
j = gmpy.divm(xyz[1]**(k-1)-prev_gen[2],xyz[1]-
xyz[0],xyz[1]**(k-1))/xyz[1]**(k-2)
a = j*xyz[1]**(k-1) + prev_gen[3]
g = seed(a,xyz)
c = a
d = a - g
return [a,g,d,c]

You see, I really DO need the even hailstones otherwise the generation
calculation would break down.

Why do we care about Generations? Because the Crossover Point is
invariant under generation. Thus, [1,2], [1,2,1,2], [1,2,1,2,1,2]
and [1,2,1,2,1,2,1,2] all have the same Crossover Point. Think
about it. If [1,2] is a loop cycle, then [1,2,1,2] represents two
cycles of the loop, [1,2,1,2,1,2] represents 3 cycles of the loop,
etc. and the cycle keeps returning to the same number.

Also, if a Sequence Vector is a loop cycle, every cyclic permutaion
of the Sequence Vector is also a loop cycle. The Crossover Points
of all those loop cycles are then the odd numbers of the loop cycle.

For example, if [1,2,3,4,5,6,7,8] is a loop cycle, then there are
8 cyclic permutations, whose Crossover Points describe the loop
cycle

[1,2,3,4,5,6,7,8]
[2,3,4,5,6,7,8,1]
[3,4,5,6,7,8,1,2]
[4,5,6,7,8,1,2,3]
[5,6,7,8,1,2,3,4]
[6,7,8,1,2,3,4,5]
[7,8,1,2,3,4,5,6]
[8,1,2,3,4,5,6,7]

Sequence length: 8, cyclic permutions: 8

Now a loop cycle that doesn't have as many cyclic permutations
as elements must be an nth generation of some smaller Type
Sequence Vector. Thus, the Sequnce Vector [1,2,1.2,1,2,1,2]
has only 2 cyclic permutations

[1,2,1,2,1,2,1,2]
[2,1,2,1,2,1,2,1]

because it's a 4th generation Type [1,2] and need not be
considered as a length 8 loop cycle.

[bill]

When you calculated

g = (8 *a - 5)/9

if you had used only 'odd' trial values
for 'a'; this problem would not exist!

Bill

[mensa...@aol.com]

But the formula is not calculated from trial values for 'a'.

The formula is determined first and THEN solutions for 'a'
are determined from the formula. No 'trial solutions' are
needed, the formula returns EXACTLY the first solution
when solved by linear congruence.

The starting point is the Sequence Vector, a list of non-zero
integers representing the count of contiguous n/2 operations,
which, by definition, are always preceeded by exactly one
3n+1 operation.

Thus, [1,2] represents

g_(3n+1)_e
|
(n/2)
|
d_(3n+1)_c
|
(n/2)
|
b
|
(n/2)
|
a

Solving algebraically from 'g' to 'a' gives you 'a' in terms
of 'g'. Solving algebraically from 'a' to 'g' gives you 'g'
in terms of 'a'. For the latter, the operations need to be
inverted:

g_((n-1)/3)_e
|
(n*2)
|
d_((n-1)/3)_c
|
(n*2)
|
b
|
(n*2)
|
a

So, without even having any trial values, we know that

b = 2a
c = 4a
d = (4a - 1)/3
e = (8a - 2)/3
g = ((8a -2 )/3 - 1)/3
= ((8a - 2)/3 - 3/3)/3
= ((8a - 2 - 3)/3)/3
= ((8a - 5)/3)/3
= (8a - 5)/9

For ANY valid Sequence Vector, the formula ALWAYS reduces to

g = (Xa - Z)/Y

One merely has to figure out what X, Y and Z are. And this can
be done directly from the Sequence Vector. Suppose the SV was
[1,2,3,4]. To calculate X, Y, Z

X = 2**sum(SV) X = 2**10

Y = 3**count(SV) Y = 3**4

Z = 3**(0)*2**(1+2+3)+3**(1)*2**(1+2)+3**(2)*2**(1)+3**(3)*2**(0)

X = 1024 Y = 81 Z = 133

making the function g = (1024a - 133)/81.

Thus, the function is determined without any initial values
of 'a', even or not. Solving the linear congruence

1024a == 133 (mod 81)

>>> print 'a =',cf.gmpy.divm(1024,133,81)
a = 1

That's the a_0 solution. Plugging it in gives us g_0

>>> print 'g =',(1024*1 - 133)/81
g = 11

Check: 11__34
17__52
26
13__40
20
10
5__16
8
4
2
1

NOW, we can find other solutions using
a_i = Y*i + a_0
a_1 = 81*1 + 1
= 82
g_i = X*i + g_0
g_1 = 1024*1 + 11
= 1035

Note, a_1 is even. Nevertheless, it is still valid for
[1,2,3,4]:

>>> cf.zigzag(1035,sv,1,7)
1035
3106
1553
4660
2330
1165
3496
1748
874
437
1312
656
328
164
82

Because I don't use 'trial values', even solutions will
always exist and the 'problem' won't go away.

>
> Bill

[bill]

From "Blueprint

"working out all the algebra, we get.

Now we need to solve the equation by finding an integer a>0 such that
g is also an integer:
for a=1
for a=2
for a=3
for a=4

So 4 is the Hailstone derived from Sequence Vector [1, 2] whose Seed
is 3".

It seems that here you are using trial solutions for "a".

>
> The formula is determined first and THEN solutions for 'a'
> are determined from the formula. No 'trial solutions' are
> needed, the formula returns EXACTLY the first solution
> when solved by linear congruence.

So REJECT the first solution if its not odd!

> For ANY valid Sequence Vector, ...

I have never disputed that g = (8a - 5)/9. Just that the even values
of
"a" can be ignored..
>
>
> read more »

[mensa...@aol.com]

That paper was written in hindsight and the above
was an example of how you can use brute force to
solve the equations...

...when Y is small, like 9 or 27. The first solution
will always be between 0 and Y since solutions repeat
every Y. But what drove me to develop the XYZ algorithm
was knowing that the XYZ parameters can quickly become
intractable to a brute force approach with trial values
of 'a'. But using linear congruence, I can solve problems
where Y has over 50000 digits in less time you can solve
the (8a-5)/9 problem by hand.

>
>
>
> > The formula is determined first and THEN solutions for 'a'
> > are determined from the formula. No 'trial solutions' are
> > needed, the formula returns EXACTLY the first solution
> > when solved by linear congruence.
>
> So REJECT the first solution if its not odd!

Which is basically what I said originally, that
if I choose to only accept odd values, than the
basic algebraic solution must be modified
accordingly. The difference between your equations
and mine (the factor of 2) accomplishes this
rejection.

Personally, until I see a valid reason for
rejecting the evens, I'm keeping them.

So ignore them. Ignoring something that's true
is generally less of a problem that introducing
something that's false, as Alan Tyte does (see
the Collatz.co.uk thread).

But I've just put the last nail in his coffin
and will be summing it up there shortly.
His fallacy transcends his goofy use of 3n+1 rule
on even numbers, so we can finally quit arguing
about that. In fact, we can quit arguing altogether
now that his paper is shown to be a Non Sequitur
fallacy. It remains to be seen whether he'll suck
it in and admit his failure or jam his fingers
in his ears and shout "Nah, nah, nah!"