Collatz Conjecture

[bplus]

OK last night and this morning I been working on a rule change to Collatz:

When the number is odd do this: (3*N + 1)/2 because with the bare 3*N + 1 your next step IS ALWAYS to divide by 2 because an Odd + 1 ALWAYS makes an Even number, automatically dividing by 2 saves a step and more importantly to computer programs keeps the highest working number (it's working with) considerably lower! (so you don't hit the Type limit so soon).

Because this is how you could work an equivalent expression:

(((N + 1) / 2) * 3) - 1 = (3*N + 1) / 2 and the computer math on the left expression never exceeds ~~ 1.5 * N (+/-) as opposed to 3 * N + 1


If the number is odd then add 1 (makes the odd number even) so you can divide by 2 (and stay an Integer) then multiply by 3 (this gives us a higher limit we can go with our number Type, nearly doubling it!) now you subtract 1 because when adding 1 before dividing by 2 you are really adding 2.

Before limit for Integers is 32XXX/ 3, with rule change that gets equivalent results limit for Integers is (32XXX / 3) * 2. So you've effectively doubled the numbers you can work with a given Type.

[bplus]

Code: QB64: [Select]

1. ' 2020-07-09 Write up  from reply I left at QB64 forum yesterday
2. ' ref: https://www.qb64.org/forum/index.php?topic=2789.msg120521#msg120521
3. ' here is essence  (((N + 1) / 2) * 3) - 1 = (3*N + 1) / 2   is New Rule for Odd
4. ' here is new limit (32766 / 3) * 2
5.  
6. _TITLE "Collatz Array Program revist 2020-07-09"
7. _DEFINE A-Z AS INTEGER
8. CONST topLimit = (32766 / 3) * 2 'just integers today
9. REDIM cSeq$(0)
10. DO
11.     PRINT "The highest number Interger Type can handle is"; topLimit; ","
12.     PRINT "If our test number wanders up there we must cut the run short."
13.     PRINT "Go ahead try 20,000 it is over 1/3 of Integer Type Limit!"
14.     INPUT "(0 quits) Enter a number to try New Collatz Sequencer "; n
15.     IF n = 0 THEN EXIT DO
16.     done = 0: odd = 0: even = 0: l = 1
17.     WHILE n <> 1 OR done
18.         s$ = STR$(l) + ":" + STR$(n)
19.         IF n MOD 2 THEN 'odd
20.             IF n < topLimit THEN s$ = s$ + " odd": l = l + 1 ELSE s$ = s$ + " hit limit, end of run.": done = 1
21.             n = (((n + 1) / 2) * 3) - 1: odd = odd + 1
22.         ELSE
23.             s$ = s$ + " even": l = l + 1
24.             n = n \ 2: even = even + 1
25.         END IF
26.         sAppend cSeq$(), s$
27.     WEND
28.     IF done = 0 THEN
29.         s$ = STR$(l) + ":" + STR$(n)
30.         sAppend cSeq$(), s$
31.         even = even + 1
32.     END IF
33.     s$ = STR$(odd) + " times the odd rule was applied.": sAppend cSeq$(), s$
34.     s$ = STR$(even) + " times the even  rule was applied.": sAppend cSeq$(), s$
35.     s$ = STR$(odd + even) + " steps were taken to create this sequence.": sAppend cSeq$(), s$
36.     display cSeq$()
37.     REDIM cSeq$(0)
38.     CLS
39. LOOP
40. PRINT: PRINT "0 tells me to say, goodbye!"
41.  
42. SUB sAppend (arr() AS STRING, addItem$)
43.     REDIM _PRESERVE arr(LBOUND(arr) TO UBOUND(arr) + 1) AS STRING
44.     arr(UBOUND(arr)) = addItem$
45. END SUB
46.  
47. SUB display (arr() AS STRING)
48.     lb = LBOUND(arr): ub = UBOUND(arr)
49.     IF ub - lb + 1 < 21 THEN top = ub ELSE top = lb + 19
50.     CLS: PRINT "press any key to quit scroller..."
51.     LOCATE 3, 1
52.     FOR i = lb TO top
53.         PRINT arr(i)
54.     NEXT
55.     DO
56.         IF ub - lb + 1 > 20 THEN
57.             DO WHILE _MOUSEINPUT
58.                 IF row >= lb THEN row = row + _MOUSEWHEEL ELSE row = lb 'prevent under scrolling
59.                 IF row > ub - 19 THEN row = ub - 19 'prevent over scrolling
60.                 IF prevrow <> row THEN 'look for a change in row value
61.                     IF row >= lb AND row <= ub - 19 THEN
62.                         CLS: PRINT "press any key to quit scroller..."
63.                         LOCATE 3, 1
64.                         FOR n = row TO row + 19
65.                             PRINT arr(n)
66.                         NEXT
67.                     END IF
68.                 END IF
69.                 prevrow = row 'store previous row value
70.             LOOP
71.         END IF
72.     LOOP UNTIL INKEY$ > ""
73. END SUB
74.  
75.  
76.  

So what? I just made the Odd Rule Odder! ;-))

[bplus]

Collatz Collapse, reducing Collatz Sequence to it's essential sequence of odd integers by removing all the Even Step fluff:

Code: QB64: [Select]

1. ' 2020-07-09 Write up  from reply I left at QB64 forum yesterday
2. ' ref: https://www.qb64.org/forum/index.php?topic=2789.msg120521#msg120521
3. ' here is essence  (((N + 1) / 2) * 3) - 1 = (3*N + 1) / 2   is New Rule for Odd
4. ' here is new limit (32766 / 3) * 2
5.  
6. ' 2020-07-09 A dream I had this morning to change 2 rules into 1 (almost) in order to simplify
7. ' the Collatz sequence into the significant sequence of ascending odd numbers.
8. ' What do they look like in terms of prime numbers?
9.  
10.  
11. _TITLE "Collatz Collapse 2020-07-09"
12. _DEFINE A-Z AS INTEGER
13. CONST topLimit = (32766 / 3) * 2 'just integers today
14. REDIM cSeq$(0)
15. DO
16.    1 PRINT "The highest number Interger Type can handle is"; topLimit; ","
17.     PRINT "If our test number wanders up there we must cut the run short."
18.     PRINT "Go ahead try 20,000 it is over 1/3 of Integer Type Limit!"
19.     INPUT "(0 quits) Enter a number to try New Collatz Sequencer "; n
20.     IF n = 0 THEN EXIT DO
21.     IF n > topLimit THEN GOTO 1
22.     done = 0: odd = 0: even = 0: l = 1
23.     sAppend cSeq$(), "Starting number is" + STR$(n)
24.     WHILE n MOD 2 = 0 'drop down and give me an odd number of pushups
25.         n = n \ 2
26.     WEND
27.     WHILE n <> 1 OR done
28.         s$ = STR$(l) + ":" + STR$(n)
29.         IF n MOD 2 THEN 'odd
30.             IF n < topLimit THEN
31.                 s$ = s$ + " odd": l = l + 1
32.                 n = (((n + 1) / 2) * 3) - 1
33.                 odd = odd + 1
34.             ELSE
35.                 s$ = s$ + " hit limit, end of run.": done = 1
36.             END IF
37.         ELSE
38.             s$ = s$ + " even": l = l + 1
39.             n = n \ 2: even = even + 1
40.         END IF
41.         WHILE n MOD 2 = 0 'drop down and give me an odd number of pushups
42.             n = n \ 2
43.         WEND
44.         sAppend cSeq$(), s$
45.     WEND
46.     IF done = 0 THEN
47.         s$ = STR$(l) + ":" + STR$(n)
48.         sAppend cSeq$(), s$
49.         even = even + 1
50.     END IF
51.     sAppend cSeq$(), "------------------------------------------------------------------"
52.     s$ = STR$(odd) + " odd steps were taken to create this sequence.": sAppend cSeq$(), s$
53.     display cSeq$()
54.     REDIM cSeq$(0)
55.     CLS
56. LOOP
57. PRINT: PRINT "0 tells me to say, goodbye!"
58.  
59. SUB sAppend (arr() AS STRING, addItem$)
60.     REDIM _PRESERVE arr(LBOUND(arr) TO UBOUND(arr) + 1) AS STRING
61.     arr(UBOUND(arr)) = addItem$
62. END SUB
63.  
64. SUB display (arr() AS STRING)
65.     lb = LBOUND(arr): ub = UBOUND(arr)
66.     IF ub - lb + 1 < 21 THEN top = ub ELSE top = lb + 19
67.     CLS: PRINT "press any key to quit scroller..."
68.     LOCATE 3, 1
69.     FOR i = lb TO top
70.         PRINT arr(i)
71.     NEXT
72.     DO
73.         IF ub - lb + 1 > 20 THEN
74.             DO WHILE _MOUSEINPUT
75.                 IF row >= lb THEN row = row + _MOUSEWHEEL ELSE row = lb 'prevent under scrolling
76.                 IF row > ub - 19 THEN row = ub - 19 'prevent over scrolling
77.                 IF prevrow <> row THEN 'look for a change in row value
78.                     IF row >= lb AND row <= ub - 19 THEN
79.                         CLS: PRINT "press any key to quit scroller..."
80.                         LOCATE 3, 1
81.                         FOR n = row TO row + 19
82.                             PRINT arr(n)
83.                         NEXT
84.                     END IF
85.                 END IF
86.                 prevrow = row 'store previous row value
87.             LOOP
88.         END IF
89.     LOOP UNTIL INKEY$ > ""
90. END SUB
91.  
92.  

[bplus]

@bplus: Why you don't use the type _UNSIGNED _INTEGER, your upper limit is much higher,
as I have used it in my old program?

A reasonable question from those impressed by big numbers.

If I can't discover the essence of what makes Collatz tick in the Integer range then I am not so interested in the problem. I do know I have the option to go the way you suggest, if I have to, as yet I am not so compelled. With number there is no end to going bigger, it's an essential part of the proof process if something happens for small number it will also happen with big. "As above, so below." or is it the other way around? Well if it's universal, it is the same above and below.