Parenthesis Block Notation

I defined a notation somewhat similar to an array notation, so named because the only characters used besides the arguments themselves are ( and ), and separators can form blocks of arguments (plus the name just sounds good). The notation is defined as follows:

(n) = n,

(a, b) = a^b

Terminating Rule: If the final argument of an expression is 1, simply remove it.

Argument Substitution Rule: If an expression has at least 3 arguments and the final argument is greater than 1, replace the 3rd last argument with the result of evaluating all arguments up to the penultimate argument as a standalone expression, and replace the penultimate argument with the result of evaluating all arguments starting at the 2nd argument in the original expression as a standalone expression. Then,decrement the final argument by 1.

Order of Separators: If an expression contains different separators, resolve the lower ones first. When resolving a lower separator, the final argument before the next higher separator can be treated as the last argument.

Base Separator Rule: If a separator is a (1), remove the separator and repeat the expression to the left going until either the beginning of the expression or a higher separator the number of times resulting from the expression just to the right.

Successor Separator Rule: If a 1-argument separator with an argument greater than 1 or a multi-argument separator whose final argument is non-zero, decrement the final argument by 1 and repeat the expression to the left the number of times given by the expression to the right, with the new separator between each.

Since the values of 2 arguments are trivial, we will begin with some 3-argument examples.

(2, 2, 2) = ((2, 2), (2, 2), 1) = ((2, 2), (2, 2)) = (4, 4) = 256

(2, 2, 3) = ((2, 2), (2, 3), 2) = (4, 8, 2) = ((4, 8), (8, 2), 1) = ((4, 8). (8, 2)) = (65536, 64) = 2¹⁰²⁴ = 179,769,313,486,231,590,772,930,519,078,902,473,361,797,697,894,230,657,273,430,081,157,732,675,805,500,963,132,708,477,322,407,536,021,120,113,879,871,393,357,658,789,768,814,416,622,492,847,430,639,474,124,377,767,893,424,865,485,276,302,219,601,246,094,119,453,082,952,085,005,768,838,150,682,342,462,881,473,913,110,540,827,237,163,350,510,684,586,298,239,947,245,938,479,716,304,835,356,329,624,224,137,216

(2, 2, 4) = (4, 16, 3) = (4294967296, 4096, 2) = (2¹³¹⁰⁷², 16777216) = 2^{2199023255552} ~ 6.49*10^{661,971,961,083}

(3, 3, 2) = ((3, 3), (3, 2), 1) = ((3, 3), (3, 2)) = (27, 9) = 7625597484987 (The fact that this is the same as 3^^3 is just a coincidence)

(3, 3, 3) = ((3, 3), (3, 3), 2) = (27, 27, 2) = (443426488243037769948249630619149892803, 729) = 3⁵⁹⁰⁴⁹ ~ 3.4116*10²⁸¹⁷³

First and last digits of (n, n, n)

(1, 1, 1): 1

(2, 2, 2): 256

(3, 3, 3): 34116929758866750127553491474623116002737575085292...49933514477452926276185591240649572770556941930083 (3^{3^10})

(4, 4, 4): 25184062326694576620005206846544579282529254890609...79223914076214624237201360673458275625362056544256 (4^{4^41})

(5, 5, 5): 25806266708327270794877035345939543742537121541036...09393516383657374291260566678829491138458251953125 (5^{5^206})

(6, 6, 6): 26077249671846589064699992289408717575038590372655...10822897022951297101957191714914813265070371373056 (6^{6^1237})

(7, 7, 7): 45840598422239209804682760102128838572623340632051...47020238800343386985374954481074134669215743200007 (7^{7^8660})

(8, 8, 8): 16925604541586681822902157269222871943118368545303...02998595602574393681306419722237229596195963273216 (8^{8^69281})

(10, 10, 10) is equal to 10^{10^6235301}, and (13,13, 13) would already require more RAM than I have on my computer to find the first digits, as its number of digits has over 11.9 billion digits.

4-argument expressions leave the numbers generated by 3 arguments in the dust. The smallest nontrivial example, (2, 2, 1, 2) is already equal to 18446744073709551616, and prepare to be (somewhat) surprised by (2, 2, 2, 2):

(2, 2, 2, 2)

= (2, (2, 2, 2), (2, 2, 2), 1)

= (2, 256, 256)

~> 2^{256^256!}

This solves to 2^{256^floor(256!*(e-1))}, or approximately 10^{10^3.5496*10^507}, much larger than a googolduplex! The last 10 digits of the number are ...3775860736, while the first digits are already inaccessible.

(2, 2, 2, 3) is slightly harder to evaluate, but its exact form is 2^{N^(floor((2^2^3075)! * (e-1))} where N is equal to 2^{256^(floor((2^1024)! * (e-1)))}. The whole number is approximately 10^{10^10^10^1.39909*10^925}, and its last 5 digits are ...14336.

In case you're wondering how I find the last digits of these numbers, here is the method:

Add up part of the sum to find the topmost exponent floor(n! * (e-1)) (i. e. 1 + n + n(n-1) + n(n-1)(n-2) + ...) until the last digits stabilize, for any expression with a factorial encountered during the evaluation. Then, simply perform modular exponentiation if the base's last digits are known.

The 4-argument function grows roughly tetrationally with respect to the final argument. At first, it seems as if the 4-argument function grows significantly faster than tetrationally, but upon further analysis, the growth rate is only slightly above tetrational (in fact, it is roughly the same n^^(n*3/2) with n*3/2 rounded to the nearest integer). (3, 3, 3, 3) is approximately 10^{10^10^10^1.1187965*10^84525} (or slightly larger than 3^{3^3^3^3^177157}), (4, 4, 4, 4) is approximately E(2.911383*10²⁴)#7, (5, 5, 5, 5) is approximately E143#9, and (10, 10, 10, 10) is slightly more than E6235301#17 (or a power tower of 17 10s topped off with 6,235,301, for those unfamiliar with Hyper-E Notation).

Last digits of (n, n, n, n)

(1, 1, 1, 1): 1

(2, 2, 2, 2): ...5156511831318098394811526791383521783620044195040391141575155527080356661637784323799083803775860736 (tetralineabi)

(3, 3, 3, 3): ...6859029136048184496003 (tetralineatri)

(4, 4, 4, 4): ...3304821047296 (lineatet)

(5, 5, 5, 5): ...5962677001953125 (tetralineapent)

(6, 6, 6, 6): ...2916909056 (tetralineahex)

(7, 7, 7, 7): ...000007 (tetralineasept)

(8, 8, 8, 8): ...372261728256 (tetralineaoct)

(9, 9, 9, 9): ...72009 (tetralineaenn)

The 5-argument function, which feeds back the 4th argument, grows pentationally. (2, 2, 2, 2, 2) is already approximately a power tower of 3*(2, 2, 2, 2)/2 10s! (3, 3, 3, 3, 3) is approximately equal to 10^^10^^(3, 3, 3, 3), making it even larger than 3^^^4.

Last digits of (n, n, n, n, n)

(1, 1, 1, 1): 1

(2, 2, 2, 2): ...94336

(3, 3, 3, 3): ...003

As we increase the number of arguments, we achieve a growth rate similar to diagonalizing over the hyperoperators. The next major turning point comes when we add a separator within the array. (a(1)b) is equal to (a, a, a, a...a, a, a, a) w/ b copies of a.

When a (1) separator is encountered, first evaluate the expression to the right, then remove the separator and repeat the expression to the left that many times. For example,

(2, 4(1)5, 3, 8) = (2, 4(1)5^{3^69281}) = (2, 4, 2, 4, 2, 4, ... 2, 4, 2, 4, 2, 4) where 2, 4 is repeated 5^{3^69281} times

However, if a higher separator is encountered, we ignore anything further to the right:

(3, 7, 5(1)2, 8(2)3, 2, 2) = (3, 7, 5(1)256(2)3, 2, 2) = (3, 7, 5, 3, 7, 5, 3, 7, 5...3, 7, 5, 3, 7, 5, 3, 7, 5(2)3, 2, 2) where 3, 7, 5, is repeated 256 times

A separator can have arbitrarily many arguments, and increasing the final argument is effectively the same as increasing the argument of a one-argument separator. If the last argument of any separator is a 0, decrement the penultimate argument by 1 and replace the 0 with the result of the expression just to the right. However, if the penultimate argument is also 0, treat it the same as if it were the last argument, and then resolve the final 0. For example,

(5, 7(4,2,0,0)3, 2) = (5, 7(4, 1, 9, 0)3, 2) = (5, 7(4, 1, 8, 9)5, 7) (The expression to the right is not changed until the last argument of the separator is no longer 0) = (5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)...5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)5, 7(4, 1, 8, 8)5, 7) where 5,7 is repeated 78125 times

But wait, there's more... the separators can themselves contain separators. The simplest example is (a, b, ..., c(1(1)1)d, e, ..., f), which just solves to (a, b, ..., c(1,0,0,.....(number of 0s is (d, e, ..., f))..., 0, 0, 0)a, b, ..., c).

(a, b, … z(1(1)1)c, d, …, x) = (a, b, …, z(1,0,0,0……(number of 0s is (c, d, …, x))……0,0,0,0)a, b, … z)

(a, b, … z(1(1)1)c, d, …, x) = (a, b, …, z(2

(a, b, …, z(n(1)1)c, d, …, x) = (a, b, …, z(n-1(1)1,0,0,0,0…0,0,0,0,0,)c, d, …, x) (number of 0s is (c, d, …, x)) for n > 1

(a, b, …, z(1,0(m)1)c, d, …, x) = (a, b, …, z(N(m)1)a, b, …, z) where N is (c, d, …, x)

(a, b, …, z(1(2)1)c, d, …, x) = (a, b, …, z(1, 0, 0, 0, …(number of 0s is (c, d, …, x)) … 0, 0, 0, 0(1)1)c, d, …, x) (growth rate is w^w*2)

(a, b, …, z(1(2)1(1)1)c, d, …, x) = (a, b, …, z(1(2)1,0,0,0,0…((c, d, …, x) 0s)…0,0,0,0,0)c, d, …, x)

(a, b, …, z(n(2)1)c, d, …, x) = (a, b, …, z(n-1(2)1, 0, 0, 0, 0 …((c, d, …, x) 0s)… 0, 0, 0, 0(1)1)c, d, …, x), n >= 2

(a, b, …, z(1,0(2)1)c, d, …, x) = (a, b, …., z(N(2)1)a, b, …, z) where N = (c, d, …, x)

(a, b, …, z(1(m)1)c, d, …, x) = (a, b, …, z(1, 0, 0, … ((c, d, …, x) 0s) … 0, 0, 0(m-1)1)c, d, …, x)

(a, b, …, z (1(1,0)1)c, d, …, x) = (a, b, …, z(1(N)1)a, b, …, z) where N = (c, d, …, x)

After that, incrementing the argument just to the right of the second level of parentheses functions the same as increasing the last argument of a 1-level separator.

(a, b, … z(m(n)l)c, d, …, x) = (a, b, …, z(m(n-1)m(n-1)m(n-1)…(l times)…(n-1)m)c, d, …, x)

(a, b, … z(k, l, … m(n)r, s, … y)c, d, … x) = (a, b, … z(k, l, … m(n-1)k, l, … m(n-1)k, l, … m(n-1)k, l, … m(n-1)……(the number of (n-1)s is (r, s, …, y))……(n-1)k, l, … m)c, d, … x)

(a, b, …, z(1(1(1)1)1)c, d, …, x) = (a, b, …, z(1(1(1,0,0,0,…((c, d, …, x) 0s)…0,0,0,0)1)1)c, d, …, x)

Deeper levels of separators function the same as the second level.

(a(₂1)b) = (a(1(1(1(…1(1(1)1)1….)1)1)1)a) w/ b layers

We have finally reached the second order of parentheses, which has a growth rate of epsilon-zero in the fast-growing hierarchy if my analysis is correct. In general, if a (₂1) is encountered, resolve the expression to the right as a standalone expression, and then replace the expression to the right with the expression to the left and have as many layers of parentheses with only 1s as the result.

(a, b, …, z(₂1)c, d, …, x) = (a, b, …, z(1(1(1(…1(1(1)1)1….)1)1)1)a, b, …, z) w/ (c, d, …, x) layers

(a, b, …, z(₂1)(1)c, d, …, x) = (a, b, …, z(₂1) a, b, …, z(₂1) a, b, …, z(₂1) …… a, b, …, z(₂1) a, b, …, z) where a, b, … z is repeated (c, d, …, x) times

(a, b, …, z(₂1)(m)c, d, …, x) = (a, b, …, z(₂1)(m-1)a, b, …, z(₂1)(m-1)a, b, …, z(₂1)(m-1)…… a, b, …, z(₂1)(m-1)a, b, …, z) where a, b, … z is repeated (c, d, …, x) times

(a, b, ….,z(_m1)c, d, …, x) = (a, b, …, z(_m-11(_m-11(_m-11…(_m-11(_m-11(_m-11)1)1)…1)1)1)c, d, …,x)

(a, b, …, z(_{(1, 0)}1)c, d, … x) = (a, b, …, z(_N1)a, b, …, z) where N = (c, d, …, x)

(a, b, …, z(_(1(1)1)1)c, d, …, x) = (a, b, …, z(_{(1,0,0,0,0…0,0,0,0,0)}1)a, b, …, z) w/ (c, d, …, x) 0s

(a, b, …, z₁²(1)c, d, …, x) = (a, b, …, z(_{(_(_(_...(_(_(_2 1) 1) 1)…1) 1) 1)}1)a, b, …, z) w/ (c, d, …, x) 0s

(a, b, …, z₁³(1)c, d, …, x) = (a, b, …, z_{(_(_(_...(_(_(_2 1)))…)))}²(1)c, d, …, x) w/ (c, d, …, x) layers in the subscript

(a, b, …, z₁^(1,0)(1)c, d, …, x) = (a, b …, z₁^N(1)a, b, …, z) where N = (c, d, …, x)

(a, b, …, z³₂²₁¹₁(1)c, d, …, x) = (a, b, …, z₁^{(^(^(^(…^(^(^(2 1)))…)))}(1)a, b, …, z) w/ (c, d, …, x) layers

(a, b, … z^m₂¹₁¹₁(1)c, d, …, x) = (a, b, … z^m-1₂^{(^(^(^(…^(^(^(2 1)))…)))}₁¹₁(1)c, d, …, x), m >= 2

Names of PBN googolisms:

Tetralineabi, (2, 2, 2, 2) ~ 10^{10^3.5496*10^507}

Pentalineabi, (2, 2, 2, 2, 2)

Hexalineabi, (2, 2, 2, 2, 2, 2)

Tetralineatri, (3, 3, 3, 3)

Pentalineatri, (3, 3, 3, 3, 3)

Dutrilineatri, (3, 3, 3(1)3, 3, 3)

Triunatri, (3, 3, 3(1)3, 3, 3(1)3, 3, 3) = (3, 3, 3(2)3)

Tridiatri, (3, 3, 3(2)3, 3, 3(2)3, 3, 3) = (3, 3, 3(3)3)

Tetra-by-trilineatri, (3, 3, 3, 3(1)3, 3, 3)

Penta-by-trilineatri, (3, 3, 3, 3, 3(1)3, 3, 3) = (3, 3, 3, 3 ………. 3, 3, 3, 3) w/ 5*3⁵⁹⁰⁴⁹ ~ 1.706*10^28,174 3s

Pentabilineatri, (3, 3(3)3, 3)

Heptabilineatri, (3, 3, 3(3)3, 3, 3)

Dulevabi, (2, 2(2, 2)2, 2)

Dulevatri, (3, 3, 3(3, 3, 3)3, 3, 3)

Dulevatet, (4, 4, 4, 4(4, 4, 4, 4)4, 4, 4, 4)

Trilevabi, (2, 2(2, 2(2, 2)2, 2)2, 2)

Trilevatri, (3, 3, 3(3, 3, 3(3, 3, 3)3, 3, 3)3, 3, 3)

Tetralevatri, (3, 3, 3(3, 3, 3(3, 3, 3(3, 3, 3)3, 3, 3)3, 3, 3)3, 3, 3)’

Triundulatri, (3, 2, 3)

Tetrundulatri, (3, 2, 3, 2) = (3, (3, 2, 3), (2, 3, 2)) = 3^{3^(1024*floor(134217728!*e-1))}

Pentundulatri, (3, 2, 3, 2, 3)

Duiteratri, (3(2)3) = (3(1)3(1)3)

Iteratri, (3(2)3)

Iteratet, (4(2)4)

Iterapent, (5(2)5)

Iterabilineatri, (3, 3(2)3, 3)

Iteralevatri, (3(₂1)(1)3)