User blog:Mh314159/Rank and Argument Strings

Once again I try to crawl toward TREE(3). It occurred to me that the statement that I cannot reach it by recursing numbers, that I need ordinals, cannot be true since Bowers' and Bird's notation achieves it by recursing exponentiation, although it uses increasing powerful notation to indicate increasingly larger arguments. I'm not trying to compete with Bowers, wouldn't dream of it, but I wonder if the following is more powerful than my vertical bar functions were. Thanks!

for a = 1, [n](1) = n+1

for a > 1, [1](a) = a↑aa

[n](a,b,c,...,p,0) = [n](a,b,c,...,p) drop trailing zeroes

[n](a) = [n-1][n](a-1)(a) functional recursion notation

[n](a,b) = n](a,b-1)(a,b-1)

[n](a,b,c,...p) = [[n](a,[n](a,b),[n](a,b,c),...,p-1)](a,b,c,...p-1)

The number or string in brackets is the "rank" of the function and the number or string in parentheses is the "argument"

[2](2) = [1][2](1)(2) = [1]3(2) = [1]([1]([1](2))) = [1]([1](4)) = [1](4↑44) (This is approximately G2 (slightly greater) in the Graham's number sequence)

[2](3) = [1][2](2)(3) = [1][1](4↑↑↑↑4)(3) (This is greater than the G2 th iteration of the Graham's number sequence = G(G2) )

[2](4) = [1][2](3)(4) > G(G(G2)))

[3](2) = [2][3](1)(2) = [2]4(2) = [2]([2]([2]([2](2)))) = [2]([2]([2](N))) with N = [2](2) = [1](4↑44) as above and where [2](N) recurses as above into a [1]-functional recursion pyramid N layers high; i.e., find [2](1) = 3 so find [1]3(2). Next find [1]P(3) where P = [1]3(2) and repeat this process N times. Then to find [3](2) apply the [2] function two more times.

[1](2,1) = 1](2)(2) = [4](2).

[1](3,2) = 1](3,1)(3,1) = [1](3,1)](3)](3).

[1](3,4,5,6) = [[1](3,[1](3,4),[1](3,4,5),5)](3,4,5,5) and if [1](3,[1](3,4),[1](3,4,5),5) = n, the next step is [[n](3,[n](3,4),[n](3,4,5),4)](3,4,5,4) etc.

A rank string generates a long argument string

[n,m](a) = [n](a,a,...,a) instances of a = [[n](a),m-1](a)

[n,m,...,p,r](a) = [n](a,a,...,a) #a = [[n](a),[n,m](a),...,[n,m,...p](a),r-1](a)

[1,1](2) = [1](2,2,...,2) instances of 2 = [[1](2)](2) = [4](2)

[2,1](4) = [2](4,4,...,4) instances of 4 = [[2](4)](4)

[2,2](4) = [2](4,4,...,4) instances of 4 = [[2](4),1](4) which = [[2](4)](4,4,...,4) where instances of 4 = [[[2](4)](4)](4) [2,3,4](5) = [2](5,5,...5) instances of 5 = [[2](5),[2,3](5),3](5)

If I need an extremely long rank string, I would go back to the argument string and add an operator. The process of alternating between rank strings and argument strings generating each other can be extended indefinitely depending on clever choice of notation, I think.