Collatz.co.uk

[mugbuff]

This shows how it could be done using odd integers only. For
explanation of terms see Collatz.co.uk :

Reworking of Collatz.co.uk using odd integers

Step up functions 3o << 16o + 1
3e+1 << 4e + 1
3o+2 << 2o + 1

1chains available formats : 2p + 1
= 1/2
link function : 4p + 1
link formats : 8i + 5 = 1/8
proportion left : 1/2 - 1/8 = 3/8 of odd
integers
pivots : 4i + 3
8i + 1 total 1/4 +
1/8 = 3/8


2chains available formats : 4i + 3
8i +
1 = 3/8
link functions : 2p + 1
32p + 17
link formats : 2(8i+1) +1 = 16i + 3
32(4i+3) + 17 = 128i + 113
proportion left : 3/8 - 1/16 - 1/128 = 39/128
of odd integers
pivots : 8i + 7 (16/128)
16i + 9 (8/128)
16i + 11 (8/128)
32i + 1 (4/128)
64i + 17 (2/128)
128i + 49 (1/128) total = 39/128 = 13/16 x 3/8

[mensa...@aol.com]

> This shows how it could be done using odd integers only. For
> explanation of terms see Collatz.co.uk :
>
> Reworking of Collatz.co.uk using odd integers

Ok, looking better.

>
> Step up functions 3o << 16o + 1
> 3e+1 << 4e + 1
> 3o+2 << 2o + 1

As I said, one of the ways I'm trying to understand this
is by converting it to the equivalent in my Sequence Vector
- Hailstone Function system (and I don't believe I have
anything equivalent to your nchains). Such conversion was
impossible and made no sense when you allowed 3n+1 operations
on even numbers and placed false nodes on the graph.

One other minor point: in my system, there is no such thing
as a "step up" from 3o as a 0(mod 3) can only appear in a
Collatz sequence if it starts with one. I insist that my
threads be invertable, that if I allow 9 << 49 then 49 >> 9
should also be legal, which it isn't. My Sequence Vector
data structure permits strict step downs using standard
Collatz rules n/2 & 3n+1 or strict step ups using inverse
rules n*2 & (n-1)/3. There is no provision for mixing
standard and inverse rules in a sequence as is required
to step up from a 0(mod 3) number to a "cousin" branch
of a childless parent.

Without an appropriate data structure, the Hailstone Function
parameters can't be calculated for the closed form expression
that is equivalent to your formulae above and completely
dispenses with the constructions you have in your appendices.
Hence, the insistence on strict directional rules.

Nevertheless, I CAN manually determine the formula for a single
step up to get the parameters, for ALL mod3 congruence classes.

I get:

for n==0(mod 3)

g__h
i
j__k note: if n==0(mod3) then j==1(mod3)
l
n__m

m = 3n + 1
l = 6n + 2
k = 12n + 4
j = 4n + 1
i = 8n + 2
h = 16n + 4
g = (16n + 3)/3

Now, g must be an integer, so we can write the RHS as a problem
in linear congruence:

16n == -3 (mod 3)

which, when solved, will give me integer values of n that result
in integer values of g. A linear congruence (in the form
Xn==Z(mod Y)) is solvable IF AND ONLY IF the gcd(X,Y) divides Z,
which it does.

Solving, using Python/gmpy

>>> import gmpy
>>> print gmpy.divm(-3,16,3) # linear congruence solver
0

So the first solution n(0) is 0. And if a linear congruence has a
first solution, it has an infinite number of them. The ith solution
is n(i) = Y*i + n(0), so the solution set of n is

n(i) = [0, 3, 6, 9, 12, ...]

but we only need the odd values.

n(i) = [3, 9, 15, 21, 27, ...]

To get the values they step up to, plug n(i) into (16n+3)/3 to get
g(i).

g(i) = [17, 49, 81, 113, 145, ...]


For n==1(mod 3)

g__l
m
n

m = 2n
l = 4n
g = (4n - 1)/3

4n == 1(mod 3)

>>> print gmpy.divm(1,4,3)
1

n(i) = [1, 7, 13, 19, 25, ...] # odds only

g(i) = [1, 9, 17, 25, 33, ...]


For n==2(mod 3)

g__m
n

m = 2n
g = (2n - 1)/3

2n == 1(mod 3)

>>> print gmpy.divm(1,2,3)
2

n(i) = [5, 11, 17, 23, 29, ...] # odds only

g(i) = [3, 7, 11, 15, 19, ...]


Note that the solution sets of the linear congruences prove that
every odd integer is on the graph. It does NOT imply that the
graph is connected.


One last thing. I want to check my generation calculator.
I would think it would work with the 0(mod 3) numbers since
it depends only on the Hailstone Function parameters which
I did manually for the step up. But have to only ask for
even members of the kth generation to get odds.

So, the first 33rd generation 0(mod 3) number would step
up to another 0(mod 3) number, which would step up to
another 0(mod 3) number, ... repeated 33 times.

My Python Collatz function library reports that it's

>>> print cf.geni(33,2,xyz)
6841920697299105

And we can check that it really does indeed step up 33
times before hitting a number not 0(mod 3):

1 : 6841920697299105
steps up to 36490243718928561 0 (mod 3)

2 : 36490243718928561
steps up to 194614633167618993 0 (mod 3)

3 : 194614633167618993
steps up to 1037944710227301297 0 (mod 3)

4 : 1037944710227301297
steps up to 5535705121212273585 0 (mod 3)

5 : 5535705121212273585
steps up to 29523760646465459121 0 (mod 3)

6 : 29523760646465459121
steps up to 157460056781149115313 0 (mod 3)

7 : 157460056781149115313
steps up to 839786969499461948337 0 (mod 3)

8 : 839786969499461948337
steps up to 4478863837330463724465 0 (mod 3)

9 : 4478863837330463724465
steps up to 23887273799095806530481 0 (mod 3)

10 : 23887273799095806530481
steps up to 127398793595177634829233 0 (mod 3)

11 : 127398793595177634829233
steps up to 679460232507614052422577 0 (mod 3)

12 : 679460232507614052422577
steps up to 3623787906707274946253745 0 (mod 3)

13 : 3623787906707274946253745
steps up to 19326868835772133046686641 0 (mod 3)

14 : 19326868835772133046686641
steps up to 103076633790784709582328753 0 (mod 3)

15 : 103076633790784709582328753
steps up to 549742046884185117772420017 0 (mod 3)

16 : 549742046884185117772420017
steps up to 2931957583382320628119573425 0 (mod 3)

17 : 2931957583382320628119573425
steps up to 15637107111372376683304391601 0 (mod 3)

18 : 15637107111372376683304391601
steps up to 83397904593986008977623421873 0 (mod 3)

19 : 83397904593986008977623421873
steps up to 444788824501258714547324916657 0 (mod 3)

20 : 444788824501258714547324916657
steps up to 2372207064006713144252399555505 0 (mod 3)

21 : 2372207064006713144252399555505
steps up to 12651771008035803436012797629361 0 (mod 3)

22 : 12651771008035803436012797629361
steps up to 67476112042857618325401587356593 0 (mod 3)

23 : 67476112042857618325401587356593
steps up to 359872597561907297735475132568497 0 (mod 3)

24 : 359872597561907297735475132568497
steps up to 1919320520330172254589200707031985 0 (mod 3)

25 : 1919320520330172254589200707031985
steps up to 10236376108427585357809070437503921 0 (mod 3)

26 : 10236376108427585357809070437503921
steps up to 54594005911613788574981709000020913 0 (mod 3)

27 : 54594005911613788574981709000020913
steps up to 291168031528606872399902448000111537 0 (mod 3)

28 : 291168031528606872399902448000111537
steps up to 1552896168152569986132813056000594865 0 (mod 3)

29 : 1552896168152569986132813056000594865
steps up to 8282112896813706592708336298669839281 0 (mod 3)

30 : 8282112896813706592708336298669839281
steps up to 44171268783006435161111126926239142833 0 (mod 3)

31 : 44171268783006435161111126926239142833
steps up to 235580100176034320859259343606608761777 0 (mod 3)

32 : 235580100176034320859259343606608761777
steps up to 1256427200938849711249383165901913396145 0 (mod 3)

33 : 1256427200938849711249383165901913396145
steps up to 6700945071673865126663376884810204779441 1 (mod 3)

Nifty, eh?

That's as far as I've got.

>
> 1chains available formats : 2p + 1 = 1/2
> link function : 4p + 1
> link formats : 8i + 5 = 1/8
> proportion left : 1/2 - 1/8 = 3/8 of odd integers
> pivots : 4i + 3
> 8i + 1
> total 1/4 + 1/8 = 3/8
>
>
> 2chains available formats : 4i + 3
> 8i + 1 = 3/8
> link functions : 2p + 1
> 32p + 17

> link formats : 2(8i+1) + 1 = 16i + 3

[mugbuff]

I will need some time to digest your reply.
Re even numbers and inversion. All I am saying is that the even
numbers are at the same level as a set of odd integers, i.e take the
same number of steps to converge. My structure defines integers that
are at the same level.
If one shows that integers are at the same level, then showing that
any one of those integers converges to 1 , shows that all the integers
at that level converge to 1. Stepping down from 2,using my algorithm,
gives exactly the same set of integers as it converges to 1 as does 9,
37, etc after the start value. I do state in my paper that it is
impossible to step down to an even integer or to a multiple of 3. 2 is
even, 9 is a multiple of 3 and no integer can step down to them, but
37 is at the same level as 2 and 9 and it is possible to step down to
37, i.e. 49 >> 37. All I am claiming is that 49 is one level up from 2
and 9, but part of the same "tree" and that if 2 steps down to 1 then
so does 49.

> > total = 39/128 = 13/16 x 3/8- Hide quoted text -
>
> - Show quoted text -

[mensa...@aol.com]

On Dec 27, 3:31 pm, mugbuff <at...@waitrose.com> wrote:
> I will need some time to digest your reply.

Fine, I haven't digested all the nchain stuff yet.

> Re even numbers and inversion. All I am saying is that the even
> numbers are at the same level as a set of odd integers, i.e take the
> same number of steps to converge.

It's just that these aren't the "real" even numbers,
the ones that show up when you use n/2 instead of
n/2**i. It's not like they're not there. Shortcuts
like n/2**i are only valid if all the hidden intermediate
steps are integers. I've seen whacky systems where
they aren't, they're a grid of rationals, and the part
of the set that's integers correlates to legitimate
Collatz sequences.

Frankly, I don't see these evens helping any. And even
if they did, why wouldn't we just dismiss your work
and say "get back to us when you've proved something
about the REAL Collatz Conjecture".

> My structure defines integers that
> are at the same level.

How do you define "level" in a system with counterexamples,
like 3n-1? When you say "same level", aren't you making
the truth of the conjecture an axiom in your system?

> If one shows that integers are at the same level, then showing that
> any one of those integers converges to 1 , shows that all the integers
> at that level converge to 1. Stepping down from 2,using my algorithm,
> gives exactly the same set of integers as it converges to 1 as does 9,
> 37, etc after the start value. I do state in my paper that it is
> impossible to step down to an even integer or to a multiple of 3. 2 is
> even, 9 is a multiple of 3 and no integer can step down to them, but
> 37 is at the same level as 2 and 9 and it is possible to step down to
> 37, i.e. 49 >> 37. All I am claiming is that 49 is one level up from 2
> and 9, but part of the same "tree" and that if 2 steps down to 1 then
> so does 49.

Well, I need to study it more. Have you looked at Ken Conrow's
site?

<http://www-personal.ksu.edu/~kconrow/>

It's not light reading, but much of his stuff reminds me
of these levels and steppig up/down stuff. He has formalized
his system into what he calls Left Descent Assemblies.
He, too, thinks he has a proof. Unfortunately, after a
LOT of study, I found a major fallacy in his work,
although strangely, he doesn't seem to acknowledge it.

Even after I pointed it out to him, he's still fretting
about showing that all the integers are on his tree
(sound familiar?). He's focussing on the necessary part
but seems oblivious to the sufficient part - that all
his tree branches are connected. The problem is that
the way he connected them together mathematically results
in all integers being present even when the components are
not connected!

Now, I'm not saying your system is the same as LDAs or
that it suffers from the same fallacy, but that's certainly
where I'm going to focus my study, as it's a commonly
misunderstood aspect of the problem. The spine thing
looks interesting, I expect any proof to explain why
things work AND why they fail. Amateur researchers like
Ken often ignore the second part where the fallacy of their
argument is easily demonstrated with a counterexample like
3n+5.

> > - Show quoted text -- Hide quoted text -

[mugbuff]

Levels are not axiomatic unless you translate axiomatic as meaning
factual. There is no doubt that 9, 37, 149, 597, etc all step down to
7 in one step and are therefore, by my definition of a level, are at
the same level.
3*9+1 = 28, 28/4 = 7
3*37+1 = 112, 112/16 = 7
3*149+1 = 448, 448/64 = 7
3*597+1 = 1792, 1792/256 = 7
It seemed to me logical to continue the dividing sequence of 256, 64,
16, 4 by adding 1.
What number divided by 1 gives 7 ? So it seemd tidy and logical to
say 3*2 + 1 = 7
A 1chain is just the sequence of numbers where the power of 2 required
to reduce 3x+1 to an even integer increases by 2. The dividing
sequence is either 1,4,16,etc if the pivot is even, or 2,8,32,etc if
the pivot is odd.
2 is an even pivot, 3 is an odd pivot.
The 1chain with pivot 3 is 3,13,53,etc giving 10/2, 40/8, 160/32
If you stop short of following the sequence back to an even number,
then you have a 1chain where the divisors are 2,8,32 if the pivot is
of format 4i+3, and a 1chain where the divisors are 4,16,64 if the
pivot is of format 8i+1. Instead of all integers of format 4i+1 being
links, 1chain links have format 8i+5.
By the way, I am quite prepared to be shot down over the proof of
Collatz, however much I would like not to be, but would like the 13/16
result to be recognized as a valuable contribution which is why I
place a lot of emphasis on it. I stumbled across it and when I proved
it, over ten years ago, falsely thought I had proved Collatz. I was
surprised to see 13/16 cropping up so early when I started the re-work
using odd integers only. But I still believe that my use of evens is
legitimate in the context that I use them.

> > > 24 :- Hide quoted text -
>
> - Show quoted text -...
>
> read more »

[mensa...@aol.com]

Ok, I'll set that issue aside for now.

=================================================================

Review status to date.

=================================================================

I've been looking at section 3.1 and have found a problem with your
step up equations:

L(r) L(r+1)
3e steps up to 4e
3e + 1 steps up to e
3e + 2 steps up to 16e + 12 *wrong*
3o steps up to 4o
3o + 1 steps up to 8o + 3 *wrong*
3o + 2 steps up to 2o + 1

A couple derivations (3e+2 & 3o+1), although done correctly, were
inappropriate.

It is only necessary to do an indirect step up to L(r+1) when L(r)
has no child branches. In such cases, you first step down to L(r-1),
go up the L(r-1) branch until you reach an appropriate sibling
(4p+1 rule) of L(r) and proceed to step up from there to L(r+1)
as shown:

L(r+1)__L(r)__L(r-1)
L(r-1)
L(r)__L(r-1)

But the only branches that have no child branches are those that
are 0(mod 3), 3e and 3o.

For 3e+2 & 3o+1 you are using the indirect step up inappropriately
since these have valid direct step ups:

L(r+1)__L(r) the direct step up from 3e+2
L(r)

L(r+1)__L(r) the direct step up from 3o+1

The step up equations, when done properly, become

L(r) L(r+1)
3e steps up to 4e
3e + 1 steps up to e
3e + 2 steps up to 2e + 1
3o steps up to 4o
3o + 1 steps up to o + 1
3o + 2 steps up to 2o + 1

Notice the beautiful symmetry in the correct equations.

How does this affect the lchains? Obviously, some of the numbers
you called pivots are actually links since only the first step up
can be a pivot which you skipped by failing to do a direct step up.

=================================================================

Of course, 3n+1 is just a specific case of the general form 3n+C
where C is an odd number not divisible by 3. When these step ups
are generalized to 3n+C, we get two sets depending on whether C
is 1(mod 3) or 2(mod 3). Note that in the fractions (x-C)/3, x
is always the same congruence class as C, so the numerator is
always 0(mod 3), thus, always reducing to an integer.

For C == 1(mod 3) # 3n+1 is a special case. when C=1,
# formulae reduce to above

L(r) L(r+1)
3e steps up to 4e
3e + 1 steps up to e + (1-C)/3
3e + 2 steps up to 2e + (4-C)/3
3o steps up to 4o
3o + 1 steps up to o + (1-C)/3
3o + 2 steps up to 2o + (4-C)/3

For C == 2(mod 3)

L(r) L(r+1)
3e steps up to 4e
3e + 1 steps up to 2e + (2-C)/3
3e + 2 steps up to e + (2-C)/3
3o steps up to 4o
3o + 1 steps up to 2o + (2-C)/3
3o + 2 steps up to o + (2-C)/3

[mensa...@aol.com]

It seems I did all that work on step ups for nothing, as there
is a serious problem in the previous section which, if I had
noticed it earlier, could have saved me a lot of work.

But I often don't analyze things in the order presented. In
this case, I went back to section 2.3 after developing the
step up functions for 3n+C and in light of that, the problem
became obvious.

Obvious, yet subtle because it's a Non Sequitur fallacy.
That's where the premise is true yet the conclusion does not
follow from it. Ken Conrow's "proof" using Left Descent
Assemblies suffers from the same fallacy. In his case, the
premise being true seems to be confusing him. He seems to be
having trouble with the concept "necessary but not sufficient".

Hopefully, the following will be clear to you where "sufficient"
is lacking.

<quote>
1/4 of the positive integers have format 4i+1 (where i
is a positive integer) and are therefore at the same
level as i.
</quote>

For example, for i in {0,1,2,3,4,5,6,7} we can see how this
holds locally on the graph...

i=0 5__16 i=2 37__112 i=3 53__160 i=4 64__208
=1 8 56 80 104
1___4 9___28 13___40 17___52
2 14 20 26
0___1 2____7 3___10 4___13

i=5 85__256 i=6 101__304 i=7 117__352
128 152 176
21___64 25___76 29___88
32 38 44
5___16 6___19 7___22

...and how it holds globally (* elements of loop cycle).

101_304
152
24__76
37_112 38 117_352
56 6_19_58 176
9__28 29_______88
14 44
2___7_________________22 69_208
11_34 104
17_____52 53_160
26 80 85_256
13_____40 128
20 21__64
3__10 32
5_____16
8
1*_4*
2*
0_1*

All well and good. But a question remains to be answered:
is 3n+1 true because this works or does it work because 3n+1
is true?

We can answer that by repeating the example with 3n+C. Keeping
in mind that in 3n+C, the "4p+1" rule becomes "4p+C" and that
the trivial loop cycle is C-4C-2C-C instead of 1-4-2-1.

Using 3n+7, it is still ture locally...

i=0 35_112 i=1 51__160 i=2 67__208 i=3 83__256
=7 56 80 104 128
7__28 11___40 15___52 19___64
14 20 26 32
0___7 1___10 2___13 3___16

i=4 99__304 i=5 115__352 i=6 131__400
152 176 200
23___76 27___88 31__100
38 44 50
4___19 5___22 6___25

...BUT NOT GLOBALLY!!

131_400
200
31_100
50
6__25_82
41_130
65_202
101_310
155_472
67_208 236
104 118
15__52 59_184
26 92 99_304
2__13______________46 152
23_____76 83_256
38 128
4__19_____64
147_448 32
224 3__16
112 8 115_352
56 4 176
7*__28* 2 27__88
14* 1_10* 44 51_160
0____7* 5*______22* 80
11*_____40*
20*
10*

Because the graph components are not connected (there are
two distinct loop cycles, the trivial loop 7-28-14-7 and
the counterexample 10-5-22-11-40-20-10).

So we see that although the premise "all 4i+1 are on the
same level as i" is true, the 3n+7 example demonstrates
that "connected" DOES NOT FOLLOW from "same level".

To be sufficient, you must additionally prove that ALL
graph components for ALL i are connected when C=1.

No such proof was given.

That makes the conclusion...

<quote>
Hence, after considering 1chains, only 3/4 of the
positive integers need to be tested.
</quote>

...a Non Sequitur fallacy.

All further analysis becomes moot.