User blog:Mh314159/A hopefully powerful new system

Please comment on my latest attempt to climb toward TREE(3) as a personal intellectual challenge. I have read the intro to googology documents and am trying to contribute something original, not a salad and not just an exension or renaming of the work of others. I have also tried to avoid using adjectives. The experts can decide how big these numbers are without any hype (although I have noticed that some quite famous googologists are not immune to using a lot of hyperbola). I am interested to learn whether everything I have done here is valid, whether everything is uniquely defined and terminates, and how large a number this system can make. I extend great appreciation to anyone who spends some time on this. It's fairly complex, I know but I hope the examples and descriptions are helpful. Conceptually, here's how this works. The base function is successorship. Then there is a line of bracket-enclosed numbers or comma-separated strings of numbers. The last two brackets expressions and the "rank" and "argument". All others to their left are "orders". There are rules that recurse longer and more complex expressions down to simpler expressions. A number to the left of a backslash indicates the cycle of the expressions to its right and there is a powerful cycle factorial rule. In order from most complex to least complex, expressions recurse in the following order of rule sets: c > o > ss > sn > ns > nn > base. I think this generates numbers much bigger than anything else I have tried to do. I am not necessarily done with this. Here are the rule sets with some examples. For two sets of brackets, the number or string in the left brackets is the "rank" of the function and the number or string in the right brackets is the "argument" Rule set n (single bracket containing a number

[a] = a Rule set nn (two bracket sets contain numbers)

[n][1] = [n+1]

[1][a] = [a+1]

[n][a] = [n-1][n][a-1][a] functional recursion notation Some examples:

[2][1] = 3

[2][2] = [1]3[2] = 5

[2][3] = [1][2][2][3] = [1]5[3] = 8

[2][4] = [1][2][3][4] = [1]8[4] = 12

[2][5] = [1][2][4][5] = [1]12[5] = 17

[2][6] = [1][2][5][6] = [1]17[6] = 23

[2][n] = 3 + 2 + 3 + 4 + ... n = 3 + (n-1)(n+2)/2

[2][n] grows approximately as fast as (n^2)/2

[3][1] = 4

[3][2] = [2]4[2] = ffff2 = fff5 = ff17 = f155 = 12,092

[3][3] = [2][3][2][3] = [2]12,092[3] = approx 3 repeatedly squared 12,092 times, so 3^(2^12,092) which is greater than 3^2^3^8 which is greater than 3^^4

[3][4] = [2][3][3][4] > [2]3^^4[4] > 4 repeatedly squared 3^^4 times, so > 4^(2^(3^^4)) or approx 3^^6

[3][5] = [2][3][4][5] > 3^^8

[3][n] > 3^^(2n-2)

[4][1] = 5

[4][2] = [3]5[2] = [3][3][3][3][3][2] > [3][3][3][3]3^8 = [3][3][3](3^^3^8) = [3][3](3^^3^^3^8) > [3][3]3^^^3 > [3](3^^(3^^3^^3) = [3](3^^^4) > 3^^^5

[4][3] > tetrating 3 3^^^5 times, > 3^^^6

[4][n] = approx n^^^(n+3)

[n][n] > n^...^n with n-1 up-arrows

Rule set ns [left bracket contains number, right bracket contains string)

[n][a,b,c,...,0,q,0] = [n][a,b,c,...,q] drop all zeroes

y = a,b,c,...,p-1,q

[n][a,b,c,...p,q] = n][y a][y],[b][y],[c][y],...q-1] [1][2,2] = [[1][1,2[[2][1,2],1]

[1][1,2] = 1][2[[1][2],1] = [4][4,1]

[4][4,1] = 4][3,14][3,1

[4][3,1] = 4][2,14][2,1

[4][2,1] = 4][1,14][1,1

[4][1,1] = 4][14][1 = [5][5]

so if f(n) = [n][n], then [n][n,1] is f n[n+1]

[4][4,1] corresponds approximately to G4, the fourth iteration in Graham's sequence

[2][1,2] = 2][2[[1][2],1] = [5][3,1] > G3

[3][1,2] = 3][2[[3][2],1] = [12092][12092,1] > G12092, the 12092nd iteration of Grahams' sequence on which G64 = the Graham-Gardner number, and is therefore the smallest expression in this system that is greater than that famous large number.

[1][2,2] = 1][1,22][1,2],1] = [[4][4,1[[2][1,2],1] = [G4][G3,1] is therefore greater than G3 iterations of Graham's sequence

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

[3][2,2] = 3][1,2[[3][1,2],1] > [3][1,2] iterations of Graham's sequence and therefore much larger than Conway's 3-->3-->3-->3, which is G27 iterations.

[1][2,1,2] = 1][2,2[[2][2,2],[1][2,2],1] because the second term in the string is a large number, this is incomparably larger than all of the previous numbers.

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

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

Rule set sn (left bracket contains string, right bracket contains number)

[n,m,...,0,q,0][a] = [n,m,...,p][a] drop all zeroes

y = n,m,...,p-1,q

[n,m,...,q][a] = a][y[a,a,...,a] instances of a = [[n][y],[m][y],...,q-1][a] Rule set ss (left bracket contains string, right bracket contains string)

Define x = string a,b,...p

Define y = string q,r,...v

Define y' = string q,r,...,u-1,v

drop trailing zeroes

[x][y] = [x,x,...x][[x][y'],[x][y'],...v-1] with [x][[x][y'],[x][y'],...v-1] instances of x Example:

[2,3,4][5,6,7] = [2,3,4,2,3,4,...][[2,3,4][5,5,7],[2,3,4][5,5,7],6] with [2,3,4][[2,3,4][5,5,7],[2,3,4][5,5,7],6] instances of 2,3,4

From the previous expression, the number of groups of 2,3,4 in the elliptical string would recurse as follows:

[2,3,4][[2,3,4][5,5,7],[2,3,4][5,5,7],6] = [2,3,4,2,3,4,...][[2,3,4][y'],[2,3,4][y'],5] with [2,3,4][[2,3,4][y'],[2,3,4][y'],5] instances of 2,3,4 and where y' = [2,3,4][5,5,7],([2,3,4][5,5,7]-1),6 and the next step would be to begin to find the value of [2,3,4][5,5,7] We would begin to recurse the simplest possible string/string expression as follows:

[1,1][1,1] = [1,1,...]1,1][1 with [1,1]1,1][1 1's

[1,1][1] = 1][1[1,1,...] with 1][1[1] = [2][1] = 3 1's

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

[2][1,1,1] = 2][1,11][1,1],[1][1,1

[1][1,1] = 1][11][1 = [2][2] if if using successor, this equals 5

[2][1,1,1] = 2][1,1[5,5]

[2][1,1] = 2][11][1 = 12092

[2][1,1,1] = [12092][5,5]

[1,1][1,1] = [1,1,...]12092][5,5 with [1,1]12092][5,5 1's

Rule set o for n sets of expressions

Define z = string q,r,...v

Define z' = string q,r,...,u-1,v

Define z = string z with every term except the last replaced by [x][y][z'] and the last term decreased by one.

drop trailing zeroes

[x][y]...[z] = [x,x,...x][y,y,...y]...[z] with [x][y][z'] instances of x, y, etc. in the first n-1 sets of expressions [1][2,3][2,2] = [1,1,...][2,3,2,3,...][[1][2,3][1,2],1] with [1][2,3][1,2] instances in the first two sets of expressions Eventually, the last expression develops zeroes and drops them and recurses to nothing while the remaining strings become long; when there are only two sets of brackets, the ss rules apply.

Rule set c for cycles of all previous rules

[0]\N where N is any set of bracketed expressions is equal to the above set of rules from successorship to rule set o.

[p]\[1] = p+1

[p]\[a] = [p-1]\[a,a,...,a]...[a,a,...,a] with [p-1]\[a] sets of brackets and [p-1]\[a] terms in each string.

Cycle factorial rule: the bracketed number to the immediate left of a slash is the cycle number. When reducing an expression to the right of that cycle number of the form [a][1] or [1][a], the base function of the previous cycle is used. This applies to superscripts and subscripts also. Unless clarity is needed for embedding in an expression with a higher cycle number, the [0]\ indicator can be dropped, indicating a pure number.

[p]\[1][a] = [p-1]\[u] where u = [p-2]\[v] etc., terminating at z = [0]\[1][a]

[p]\[a][1] = [p-1]\[u] where u = [p-2]\[v] etc., terminating at z = [0]\[a][1] [1]\[3][2] = 1\[2][3][1][2] and by the cycle factorial rule [1]\[3][1] = [1]\[u] where u = [0]\[3][1] = 4 and [1]\[4] = [0]\[4,4,4,4][4,4,4,4][4,4,4,4][4,4,4,4]and if this is m, then [1]\[3][2] = 1\[2]m[2] = [1]\[2][2]...[2][2] with m instances of [2] and the last instance is evaluated as [1]\[2][2]= [1]\[1][2][1][2]and a similar process is used to turn this into a string of [3,3,3][3,3,3][3,3,3] [1] functions, etc.

[2]\[1][1] = [2]\[u] where u = [1]\[v] where v = [0]\[1][1] = 2, so u = [1]\[2] = [0]\[2,2][2,2]and therefor [2]\[1,1] = [2]\[m] where m is the large number [2,2][2,2] = and [2]\[m] = [1]\[m,m,m]...[m,m,m] with m sets of brackets and m terms in each bracket. This is then evaluated using rules o through nn and the cycle factorial rule down to a cycle zero number.

[2]\[2][2] = [2]\[1][2][1][2] and now the [2][1] rule is applied from cycle 1 = [1]\[2][1], which in turn means use the [2][1] rule from cycle 0, and since [0]\[2][1] = 3, then [1]\[2][1] is [1]\[3] = [0]\[3,3,3][3,3,3][3,3,3] so we have [2]\[2][2] = [2]\[1][0]\[3,3,3][3,3,3][3,3,3][2] which is a long sequence of cycle 2 base functions. For example, [2]\[1][2] = [2]\[u] where u = [1]\[v] where v = [0]\[1,2] = 3, so u = [1]\[3] = [0]\[3,3,3][3,3,3][3,3,3] and [2]\[1,2] therefore = [2]\0]\[3,3,3][3,3,3][3,3,3 and if [0]\[3,3,3][3,3,3][3,3,3] is m, then [2]\[1][2] = [2]\[m] = [1]\[m,m,m]...[m,m,m] with m sets of brackets and m terms in each string. This is then evaluated using the rules o through nn and the cycle factorial rule down to a cycle zero number, let's call it p. Then the next function in the string of cycle 2 base functions ([3,3,3][3,3,3][3,3,3] repetitions of them) is 2\[1][p] Expressions containing multiple backslashes associate from left to right, so that

[c]\[d]\[e] = ([c]\[d])\[e] [1]\[2]\[2] = [N]\[2] where N = [2,2][2,2] and then the [p]\[a] rule would apply, so the next recursion is [N]\[2] = [N-1]\[2,2,...,2]...[2,2,...,2] (cycle of order strings) with [N-1]\[2] brackets and terms per string. Many more recursions would have to be performed in order to finally determine the number of order strings in [N]\[2]. Rule set cc for consecutive backslashes:

[a]\...\[1] = [a\...\[a] number of backslashes decreases by 1

[a]\n[b] = [a](n backslashes)[b]

[a]\n[b] = [a]\n[b-1]\n[b-1]\n... [b-1] with [a]\n[b-1] instances of [b]

These expressions associate from left to right, so that

[c]\\[d]\\[e] = ([c]\\[d])\\[e]

[2]\\[1] = [2]\[2]

[2]\\[1]\\[1] = [2]\[2]\\[1] = 2]\[2\2]\[2

[2]\\[2] = [2]\\[1]\\[1]... with [2]\\[1] = [2]\[2] instances of [1]

[3]\\\[5] = [3]\\\[4]\\\[4]... with [3]\\\[4] instances of [4] Rule set cs for strings of cycle indicators

[0,b]\m[c] = [b]\m[c]

[a,0]\m[c] = [a]\m[c]

[a,b]\[c] = [ (a-1), [a,(b-1)]\[c] ] \ [a,(b-1)]\[c][c]

[a,b]\m[c] = [a,[a,...[a,b]\m-1[c]...]\m-1[c]]\m-1[c] with [a,b]\m-1[c] instances of [c] [1,1]\[2] = [0,[1,0]\[2]]\[1,0]\[2][2] = 1]\[2\[2,2][2,2][2] which is of the form [a]\n[b] where a and n = [2,2][2,2] and by the cycle factorial rule, the reduction of n is [a]\([2,2][2,2]) which must be recursed using the cycle factorial rule similarly to example [2]\[m] above, but of course with a much larger value of p. When this is evaluated, it determines the number of backslashes in 2,2][2,2\[2,2][2,2][2] Example assuming only three nestings:

[1,1]\2[2] = [1,[1,[1,1]\[2]]\[2]]\[2] (in actuality, [1,1]\[2] instances of [2]