# Size 5 Arrays

This page will deal with arrays with five entries which we can call pententrical arrays. These arrays are unbelievably powerful, even if we did Ackermann style recursion on the length of a Conway chain in his chained arrow notation - it would come no where close. What about repeated Ackerman style recursion over and over again to make a series of higher order Conway chains? - even this will not reach the full potential of pententrical arrays. We would need to do repeated "tetrentrical" style recursion on the length of the chain over and over again to reach its potential! We will use {a,b,c,d,e} for the pententrical arrays, starting with e = 1, and increasing e as we go through these arrays. For the operator notation equivalent, we could write it as:

{a,b,c,d,e} = a [[[[[[....[[[[{{{{{{.....{{{{c}}}}.....}}}}}}]]]]....]]]]]] b -- with d {} pairs and e-1 [] pairs!

I also have alternative functions, here are "array operator" and "ordinal operator" notations for {a,b,c,d,e}:

{a,b,c,d,e} = a {c,d,e} b = a {w2(e-1)+w(d-1)+c} b

As before here are the general rules to Array Notation for reference.

Definitions:

Array - a structured set of entries (the array will be represented as A)

Entry - a position in the array that holds a positive integer value (1 is default - so any entry not represented automatically has the value of 1)

Base - first entry (value represented by b)

Prime entry - second entry (value represented by p)

Pilot - first non-1 entry after prime entry (can be as early as 3rd entry, can be in a different dimension or beyond)

Copilot - entry right before pilot (if pilot is the first entry on its row, then there's no copilot. Copilot might be the prime entry itself, if the pilot is 3rd entry.

Structures - structures are sub-arrays of the following types: entry (X^0), row (X^1), plane (X^2), realm (X^3), flune (X^4),..,X^n,..,dimensional group (X^X)=X^^2,..,n-D array of dimensional groups (X^(X+n)),..dimensional group of dimensional groups (X^(2X)),...X^(2X+n),...m-D array of dim.group of dim.group of.....dim.groups n times (X^(nX+m)),...dimensional gang (X^(X^2)),...X^(polynomial),...X^(X^X)=X^^3,....X^(X^X+polynomial),........X^^4,....X^^n,...X^^X,......X^^^X,....X^^^^````^^^X,...etc.

Previous Structures - previous entries are entries before the pilot but are on the same row, previous rows are rows before the pilot's row, but are in the same plane, previous n-spaces are n-spaces in the same n+1-space that are before the pilot's n-space, etc. They are structures before the pilot's version of that structure, but on the same structure that is of higher order.

Prime Block - the prime block of an X^n structure is the first p^n block of entries in that structure, - this generalizes to all structures, turning the X's to p's, where p is the prime. - so if p=10, and the structure is X^(3X^5+2X^4+3X+6), the prime block is the first 10^(3*10^5+2*10^4+3*10+6) set of entries.

Airplane - a set of entries that include the pilot, all previous entries, and the prime block of all previous structures.

Passengers - any entry in the airplane that is not the pilot or copilot. This will always include the base.

Allowance: Default entries (entries that have a 1 value) can be chopped off as long as none of the entries change their positions.

Rules:

Rule 1 - the prime rule - Condition: default prime (p = 1) - Result: v(A)=b. where v(A) means value of array.

Rule 2 - the initial rule - Condition: no pilot - Result: v(A)=b^p.

Rule 3 - the catastrophic rule - Condition: first two rules don't apply - Result: Array changes in the following way:

a) pilot decreases by 1.

b) copilot (if exists) becomes original array, but with its prime entry reduced by 1.

c) passengers take on base value.

d) remainder of array remains unchanged.

## Rules for Pententrical Arrays

We can take the above rules and rewrite them for a 5 entry linear array {a,b,c,d,e}. The pilot could be in positions 2, 3, or 4 which are c, d, and e in our example (starting position is at position 0) - if c = 1, d = 1, and e = 1 then there's no pilot. If c = 1, d = 1, and e > 1 then e is the pilot, d is the copilot, and a,b, and c are the passengers. If c = 1 and d > 1, then d is the pilot, c is the copilot, and the passengers are a and b. If c > 1 regardless of what d or e is, then c is the pilot, b (the prime) is the copilot, and a is the passenger. Since pententrical arrays are linear then the only previous structures are previous entries, and the prime block of an entry is the entry itself - couple this info with the definition of airplane, then we can see that the airplane would all the entries from a to the pilot. So lets see how this changes the rules:

Rule 1 (b=1) - {a,1,c,d,e} = a

Rule 2 (no pilot) - {a,b,1,1,1} = ab - essentially a two entry array

Rule 3a (pilot at e) - {a,b,1,1,e} = {a,a,a,{a,b-1,1,1,e},e-1}

Rule 3b (pilot at d) - {a,b,1,d,e} = {a,a,{a,b-1,1,d,e},d-1,e}

Rule 3c (pilot at c) - {a,b,c,d,e} = {a,{a,b-1,c,d,e},c-1,d,e}

## {a,b,c,d,1} Cases - a Repeat of Size 4 Arrays

When e = 1 then rule 3a is not needed since the pilot e needs to be greater than 1 for this rule. Rule 1 becomes {a,1,c,d,1} = a, also notice that for tetrentrical arrays {a,1,c,d} = a, so {a,1,c,d,1} = {a,1,c,d} = a. Rule 2 is the same - but notice that {a,b,1,1} = ab also, so {a,b,1,1,1} = {a,b,1,1}, this is also equal to {a,b}. For rule 3b, we have {a,b,1,d,1} = {a,a,{a,b-1,1,d,1},d-1,1}. Rule 3c becomes {a,b,c,d,1} = {a,{a,b-1,c,d,1},c-1,d,1}. If we follow this through we will find out that {a,b,c,d,1} = {a,b,c,d} this is 1-cropping. So when e = 1, we get the 4 entry arrays again.

## {a,b,c,d,2} Cases

When d = 2, then rule 1 becomes {a,1,c,d,2} = a. Rule 2 in not needed, rule 3a becomes {a,b,1,1,2} = {a,a,a,{a,b-1,1,1,2},1} = {a,a,a,{a,b-1,1,1,2}}. Rule 3b becomes {a,b,1,d,2} = {a,a,{a,b,c-1,d,2},d-1,2}. Rule 3c becomes {a,b,c,d,2} = {a,(a,b-1,c,d,2},c-1,d,2}. Lets examine rule 3a a bit closer:

{a,b,1,1,2} = {a,a,a,{a,b-1,1,1,2}} = a {{{{{{......{{{{{{a}}}}}}......}}}}}} a -- where there are {a,b-1,1,1,2} pairs of {} (this is in operator notation) - did I just hear someone scream?

Solving it completely leads to the following - where each level after the first has 'number on previous level' pairs of {}:

a

|

a {{{{......{{{{{a}}}}}......}}}} a

|

a {{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}} a

|

a {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} a

:

:

:

go all the way to the b'th level!!!

:

|

a {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} a

---Yep I did hear someone scream, and they ain't stopping! - AAAAHHHHHH!!!!

We can even define the above as a [{1}] b in extended operator notation, we are now using two types of brackets.

a [{0}] b = a {{{{....{{{{a}}}}....}}}} a -- with b {} - the [{0}] operator grows at the speed of w2 on the FGH (Fast Growing Hierarchy).

a [{1}] b = a [{0}] a [{0}] a [{0}] a [{0}]......[{0}] a -- a [{0}]'ed to itself b times. The [{1}] operator grows at the speed of w2+1 on the FGH.

a [{2}] b = a [{1}] a [{1}] a [{1}] a [{1}]......[{1}] a -- a [{1}]'ed to itself b times. The [{2}] operator grows at the speed of w2+2 on the FGH.

...

a [{n+1}] b = a [{n}] a [{n}] a [{n}] a [{n}]......[{n}] a -- a [{n}]'ed to itself b times. The [{n}] operator grows at the speed of w2+n on the FGH.

So in a nut shell, the [{n}] operator is n levels of recursions past the [{0}] operator which dictates the number of {} pairs, which is essentially the fourth entry in a four entry array which has the same power as the length of a Conway chain. - So where does that put us on array notaion - - only to {a,b,n,1,2} - the "d" component hasn't even budged. Another way to put it, {a,b,c,1,2} grows as fast as Ackermann style recursion on the length of Conway chains.

Lets up the stakes (BEAF steaks that is), continuing with extended operator notation:

a [{{0}}] b = a [{b}] a - the [{{0}}] operator grows at the speed of w2+w on the FGH (Fast Growing Hierarchy).

a [{{1}}] b = a [{{0}}] a [{{0}}] a [{{0}}] a [{{0}}]......[{{0}}] a -- a [{{0}}]'ed to itself b times. This is equal to a [{a [{a [{a [{....[{a [{a [{a [{a}] a}] a}] a}]....}] a}] a}] a}] a -- with b nestings of [{..}] brackets! The [{{1}}] operator grows at the speed of w2+w+1 on the FGH.

a [{{2}}] b = a [{{1}}] a [{{1}}] a [{{1}}] a [{{1}}]......[{{1}}] a -- a [{{1}}]'ed to itself b times. The [{{2}}] operator grows at the speed of w2+w+2 on the FGH.

...

a [{{n+1}}] b = a [{{n}}] a [{{n}}] a [{{n}}] a [{{n}}]......[{{n}}] a -- a [{{n}}]'ed to itself b times. The [{{n}}] operator grows at the speed of w2+w+n on the FGH.

Now the recursion is nesting within the [{..}] brackets, and [{{n}}] is n levels of recursions past the [{{0}}] operator which is based on Ackermann style recursion on the [{0}] operator which parallels the fourth entry in a 4-entry array. So NOW where are we on array notation? - - only to {a,b,n,2,2} - the "d" component is only a TWO (Gesundheit!). Another way to put it, {a,b,c,2,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on the length of Conway chains. Faints - Hello, you OK! - Lightly slaps face a couple times - Come on dude, wake up! - Hello! - Wakes up groggy - Ah great, you're alive - we got a LONG way to go - Screams and then goes unconcious.

Lets continue:

a [{{{0}}}] b = a [{{b}}] a - the [{{{0}}}] operator grows at the speed of w2+w2 on the FGH (Fast Growing Hierarchy).

a [{{{1}}}] b = a [{{{0}}}] a [{{{0}}}] a [{{{0}}}] a [{{{0}}}]......[{{{0}}}] a -- a [{{{0}}}]'ed to itself b times. This is equal to a [{{a [{{a [{{a [{{....[{{a [{{a [{{a [{{a}}] a}}] a}}] a}}]....}}] a}}] a}}] a}}] a -- with b nestings of [{{..}}] brackets! The [{{{1}}}] operator grows at the speed of w2+w2+1 on the FGH.

a [{{{2}}}] b = a [{{{1}}}] a [{{{1}}}] a [{{{1}}}] a [{{{1}}}]......[{{{1}}}] a -- a [{{{1}}}]'ed to itself b times. The [{{{2}}}] operator grows at the speed of w2+w2+2 on the FGH.

...

a [{{{n+1}}}] b = a [{{{n}}}] a [{{{n}}}] a [{{{n}}}] a [{{{n}}}]......[{{{n}}}] a -- a [{{{n}}}]'ed to itself b times. The [{{{n}}}] operator grows at the speed of w2+w2+n on the FGH.

Now the recursion is nesting within the [{{..}}] brackets, and [{{{n}}}] is n levels of recursions past the [{{{0}}}] operator which is based on Ackermann style recursion on the [{{0}}] operator! This gets us to {a,b,n,3,2} - the "d" component is now a three. Another way to put it, {a,b,c,3,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on the length of Conway chains, this is three tiers of Ackermann style recursion on the length of Conway chains. Screams while still unconcious.

OK, time to go BOOYAH on this thing!:

a [{{...{{0}}...}}] b (with k+1 {} pairs) = a [{...{{b}}...}] a (with k {} pairs) - the [{{...{{0}}...}}] operator grows at the speed of w2+wk on the FGH (Fast Growing Hierarchy).

a [{{...{{1}}...}}] b = a [{{...{{0}}...}}] a [{{...{{0}}...}}] a [{{...{{0}}...}}] a [{{...{{0}}...}}]......[{{...{{0}}...}}] a -- a [{{...{{0}}...}}]'ed to itself b times. This is equal to a [{...{{a [{...{{a [{...{{a [{...{{::::::::[{...{{a [{...{{a [{...{{a [{...{{a}}...}] a}}...}] a}}...}] a}}...}]::::::::}}...}] a}}...}] a}}...}] a}}...}] a -- with b nestings of [{{...{{--}}...}}] brackets! The [{{...{{1}}...}}] operator grows at the speed of w2+wk+1 on the FGH.

a [{{...{{2}}...}}] b = a [{{...{{1}}...}}] a [{{...{{1}}...}}] a [{{...{{1}}...}}] a [{{...{{1}}...}}]......[{{...{{1}}...}}] a -- a [{{...{{1}}...}}]'ed to itself b times. The [{{...{{2}}...}}] operator grows at the speed of w2+wk+2 on the FGH.

...

a [{{...{{n+1}}...}}] b = a [{{...{{n}}...}}] a [{{...{{n}}...}}] a [{{...{{n}}...}}] a [{{...{{n}}...}}]......[{{...{{n}}...}}] a -- a [{{...{{n}}...}}]'ed to itself b times. The [{{...{{n}}...}}] operator grows at the speed of w2+wk+n on the FGH.

Now the recursion is nesting within the [{...{{---}}...}] brackets, and [{{...{{n}}...}}] is n levels of recursions past the [{{...{{0}}...}}] operator. This gets us to {a,b,n,k+1,2} - the "d" component is finally moving up. Get ready!! {a,b,c,d,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of ............................... Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of the length of Conway chains, this is "d" tiers (or multiple tiers) of Ackermann style recursion on the length of Conway chains. Uh oh, I think he's dead! - and he's still screaming!!!. We can call this multiple tiered Ackerman style recursion "tetrentrical style recursion", for it is the same level of recursions necessary to get from a^b to {a,b,c,d}. To get from {a,b,c,d} to {a,b,c,d,2} it also takes tetrentrical style recursion on position three in the array ('a' is at position 0, 'b' at position 1, etc.)

Here are some numbers in this range:

Triggol = {10,10,10,100,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with 100 {} pairs.

Triggolplex = {10,10,10,triggol,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with triggol {} pairs.

Triggolduplex = {10,10,10,triggolplex,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with triggolplex {} pairs.

## {a,b,c,d,3} Cases

When d = 3, then rule 1 becomes {a,1,c,d,3} = a. Rule 2 in not needed, rule 3a becomes {a,b,1,1,3} = {a,a,a,{a,b-1,1,1,3},2}. Rule 3b becomes {a,b,1,d,3} = {a,a,{a,b,c-1,d,3},d-1,3}. Rule 3c becomes {a,b,c,d,3} = {a,(a,b-1,c,d,3},c-1,d,3}. Lets examine rule 3a a bit closer:

{a,b,1,1,3} = {a,a,a,{a,b-1,1,1,3},2} = a [{{{{{{......{{{{{{a}}}}}}......}}}}}}] a -- where there are {a,b-1,1,1,3} pairs of {} within the [].

Solving it completely leads to the following - where each level after the first has 'number on previous level' pairs of {} within the []:

a

|

a [{{{{......{{{{{a}}}}}......}}}}] a

|

a [{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}] a

|

a [{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}] a

:

:

:

go all the way to the b'th level!!!

:

|

a [{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}] a

---Wakes up from the dead to scream some more! - AAAAHHHHHH!!!!

We can even define the above as a [[{1}]] b in extended operator notation.

a [[{0}]] b = a [{{{{....{{{{a}}}}....}}}}] a -- with b {} - the [[{0}]] operator grows at the speed of w22 on the FGH.

a [[{1}]] b = a [[{0}]] a [[{0}]] a [[{0}]] a [[{0}]]......[[{0}]] a -- a [[{0}]]'ed to itself b times. The [[{1}]] operator grows at the speed of w22+1 on the FGH.

a [[{2}]] b = a [[{1}]] a [[{1}]] a [[{1}]] a [[{1}]]......[[{1}]] a -- a [[{1}]]'ed to itself b times. The [[{2}]] operator grows at the speed of w22+2 on the FGH.

...

a [[{n+1}]] b = a [[{n}]] a [[{n}]] a [[{n}]] a [[{n}]]......[[{n}]] a -- a [[{n}]]'ed to itself b times. The [[{n}]] operator grows at the speed of w22+n on the FGH.

The [[{n}]] operator is n levels of recursions past the [[{0}]] operator which dictates the number of {} pairs within two pairs of [] brackets. This takes us to {a,b,n,1,3}.

Continuing on:

a [[{{0}}]] b = a [[{b}]] a - the [[{{0}}]] operator grows at the speed of w22+w on the FGH.

a [[{{1}}]] b = a [[{{0}}]] a [[{{0}}]] a [[{{0}}]] a [[{{0}}]]......[[{{0}}]] a -- a [[{{0}}]]'ed to itself b times. This is equal to a [[{a [[{a [[{a [[{....[[{a [[{a [[{a [[{a}]] a}]] a}]] a}]]....}]] a}]] a}]] a}]] a -- with b nestings of [[{..}]] brackets! The [[{{1}}]] operator grows at the speed of w22+w+1 on the FGH.

a [[{{2}}]] b = a [[{{1}}]] a [[{{1}}]] a [[{{1}}]] a [[{{1}}]]......[[{{1}}]] a -- a [[{{1}}]]'ed to itself b times. The [[{{2}}]] operator grows at the speed of w22+w+2 on the FGH.

...

a [[{{n+1}}]] b = a [[{{n}}]] a [[{{n}}]] a [[{{n}}]] a [[{{n}}]]......[[{{n}}]] a -- a [[{{n}}]]'ed to itself b times. The [[{{n}}]] operator grows at the speed of w22+w+n on the FGH.

The recursion is nesting within the [[{..}]] brackets, and [[{{n}}]] is n levels of recursions past the [[{{0}}]] operator which is based on Ackermann style recursion on the [[{0}]] operator which does tetrentrical style recursion on the fourth entry in a 4-entry array. We've reached {a,b,n,2,3} on array notation.

Lets continue:

a [[{{{0}}}]] b = a [[{{b}}]] a - the [[{{{0}}}]] operator grows at the speed of w22+w2 on the FGH.

a [[{{{1}}}]] b = a [[{{{0}}}]] a [[{{{0}}}]] a [[{{{0}}}]] a [[{{{0}}}]]......[[{{{0}}}]] a -- a [[{{{0}}}]]'ed to itself b times. This is equal to a [[{{a [[{{a [[{{a [[{{....[[{{a [[{{a [[{{a [[{{a}}]] a}}]] a}}]] a}}]]....}}]] a}}]] a}}]] a}}]] a -- with b nestings of [[{{..}}]] brackets! The [[{{{1}}}]] operator grows at the speed of w22+w2+1 on the FGH.

a [[{{{2}}}]] b = a [[{{{1}}}]] a [[{{{1}}}]] a [[{{{1}}}]] a [[{{{1}}}]]......[[{{{1}}}]] a -- a [[{{{1}}}]]'ed to itself b times. The [[{{{2}}}]] operator grows at the speed of w22+w2+2 on the FGH.

...

a [[{{{n+1}}}]] b = a [[{{{n}}}]] a [[{{{n}}}]] a [[{{{n}}}]] a [[{{{n}}}]]......[[{{{n}}}]] a -- a [[{{{n}}}]]'ed to itself b times. The [[{{{n}}}]] operator grows at the speed of w22+w2+n on the FGH.

Now the recursion is nesting within the [[{{..}}]] brackets, and [[{{{n}}}]] is n levels of recursions past the [[{{{0}}}]] operator which is based on Ackermann style recursion on the [[{{0}}]] operator! This gets us to {a,b,n,3,3}.

OK, time for another BOOYAH!:

a [[{{...{{0}}...}}]] b (with k+1 {} pairs) = a [[{...{{b}}...}]] a (with k {} pairs) - the [[{{...{{0}}...}}]] operator grows at the speed of w22+wk on the FGH.

a [[{{...{{1}}...}}]] b = a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]]......[[{{...{{0}}...}}]] a -- a [[{{...{{0}}...}}]]'ed to itself b times. This is equal to a [[{...{{a [[{...{{a [[{...{{a [[{...{{::::::::[[{...{{a [[{...{{a [[{...{{a [[{...{{a}}...}]] a}}...}]] a}}...}]] a}}...}]]::::::::}}...}]] a}}...}]] a}}...}]] a}}...}]] a -- with b nestings of [[{{...{{--}}...}}]] brackets! The [[{{...{{1}}...}}]] operator grows at the speed of w22+wk+1 on the FGH.

a [[{{...{{2}}...}}]] b = a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]]......[[{{...{{1}}...}}]] a -- a [[{{...{{1}}...}}]]'ed to itself b times. The [[{{...{{2}}...}}]] operator grows at the speed of w22+wk+2 on the FGH.

...

a [[{{...{{n+1}}...}}]] b = a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]]......[[{{...{{n}}...}}]] a -- a [[{{...{{n}}...}}]]'ed to itself b times. The [[{{...{{n}}...}}]] operator grows at the speed of w22+wk+n on the FGH.

Now the recursion is nesting within the [[{...{{---}}...}]] brackets, and [[{{...{{n}}...}}]] is n levels of recursions past the [[{{...{{0}}...}}]] operator. This gets us to {a,b,n,k+1,3}. {a,b,c,d,3} grows as fast as tetrentrical style recursion on top of tetrentrical style recursion on the length of a Conway chain. Tetrentrical style recursions go from a^b to {a,b,c,d} to {a,b,c,d,2} to {a,b,c,d,3}.

Here are some numbers in this range:

Pentatri = {3,3,3,3,3} = 3 [[{{{3}}}]] 3

Traggol = {10,10,10,100,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with 100 {} pairs.

Traggolplex = {10,10,10,traggol,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with traggol {} pairs.

Traggolduplex = {10,10,10,traggolplex,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with traggolplex {} pairs.

Lets look at Pentatri = {3,3,3,3,3} = {3,{3,2,3,3,3},2,3,3}

= {3,{3,{3,1,3,3,3},2,3,3},2,3,3} = {3,{3,3,2,3,3},2,3,3}

= {3,{3,{3,3,1,3,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,2,1,3,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,3,{3,1,1,3,3},2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,3,3,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3,{3,3,3,1,3},1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,1,1,3},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,2,1,1,3},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,{3,1,1,1,3},2},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3,2},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3,1},1},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3}},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,tetratri},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}

Using the operator notation, Pentatri looks like this:

3 [[{{{3}}}]] 3 = 3 [[{{{2}}}]] 3 [[{{{2}}}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{{1}}}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{3}}]] 3 }}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{3}]] 3 }]] 3 }}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [[{1}]] 3 }]] 3 }}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3[{{{3}}}]3......{{{{3}}}}.......3[{{{3}}}]3.........}}}] 3 }]] 3 }}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........3{{{3}}}3......{{{{3}}}}.......3{{{3}}}3.........}}} 3 }] 3 }}] 3......{{{{3}}}}.......3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........3{{{3}}}3......{{{{3}}}}.......3{{{3}}}3.........}}} 3 }] 3 }}] 3.........}}}] 3 }]] 3 }}]] 3

= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........Tetratri......{{{{3}}}}.......Tetratri.........}}} 3 }] 3 }}] 3......{{{{3}}}}.......3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........Tetratri......{{{{3}}}}.......Tetratri.........}}} 3 }] 3 }}] 3.........}}}] 3 }]] 3 }}]] 3

## Higher {a,b,c,d,e} Cases

Continuing onwards, {a,b,c,d,4} = a [[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]] b - this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4-entry array!

{a,b,c,d,5} = a [[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]] b - this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4-entry array!

{a,b,c,d,6} = a [[[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]]] b - this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4-entry array!

...

{a,b,c,d,e} = a [[[[[[....e....[[[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]]]....e....]]]]]] b - this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of ...............................tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4-entry array! Still dead, running around screaming, catches fire, turns into a skeleton, running everywhere screaming - brain EXPLODES!! taking out a 5000 light year radius!

We can call this repeated tetrentrical recursion - pententrical recursion.

Time to continue:

a [[..[[{0}]]..]] b (with k [] pairs) = a [[..[{{{{....{{{{a}}}}....}}}}]..]] a (with k-1 [] pairs) -- with b {} - the [[..[[{0}]]..]] operator grows at the speed of w2k on the FGH.

a [[..[[{1}]]..]] b = a [[..[[{0}]]..]] a [[..[[{0}]]..]] a [[..[[{0}]]..]] a [[..[[{0}]]..]]......[[..[[{0}]]..]] a -- a [[..[[{0}]]..]]'ed to itself b times. The [[..[[{1}]]..]] operator grows at the speed of w2k+1 on the FGH.

a [[..[[{2}]]..]] b = a [[..[[{1}]]..]] a [[..[[{1}]]..]] a [[..[[{1}]]..]] a [[..[[{1}]]..]]......[[..[[{1}]]..]] a -- a [[..[[{1}]]..]]'ed to itself b times. The [[..[[{2}]]..]] operator grows at the speed of w2k+2 on the FGH.

...

a [[..[[{n+1}]]..]] b = a [[..[[{n}]]..]] a [[..[[{n}]]..]] a [[..[[{n}]]..]] a [[..[[{n}]]..]]......[[..[[{n}]]..]] a -- a [[..[[{n}]]..]]'ed to itself b times. The [[..[[{n}]]..]] operator grows at the speed of w2k+n on the FGH.

The [[..[[{n}]]..]] operator is n levels of recursions past the [[..[[{0}]]..]] operator which dictates the number of {} pairs within k pairs of [] brackets. This takes us to {a,b,n,1,k+1}.

Continuing on:

a [[..[[{{0}}]]..]] b (with k [] pairs) = a [[..[[{b}]]..]] a (with k [] pairs) - the [[..[[{{0}}]]..]] operator grows at the speed of w2k+w on the FGH.

a [[..[[{{1}}]]..]] b = a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]]......[[..[[{{0}}]]..]] a -- a [[..[[{{0}}]]..]]'ed to itself b times. The [[..[[{{1}}]]..]] operator grows at the speed of w2k+w+1 on the FGH.

a [[..[[{{2}}]]..]] b = a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]]......[[..[[{{1}}]]..]] a -- a [[..[[{{1}}]]..]]'ed to itself b times. The [[..[[{{2}}]]..]] operator grows at the speed of w2k+w+2 on the FGH.

...

a [[..[[{{n+1}}]]..]] b = a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]]......[[..[[{{n}}]]..]] a -- a [[..[[{{n}}]]..]]'ed to itself b times. The [[..[[{{n}}]]..]] operator grows at the speed of w2k+w+n on the FGH.

The [[..[[{{n}}]]..]] operator is n levels of recursions past the [[..[[{{0}}]]..]] operator which is based on Ackermann style recursion on the [[..[[{0}]]..]] operator which does tetrentrical style recursion over and over again on the fourth entry in a 4-entry array. We've reached {a,b,n,2,k+1} on array notation.

OK, time for the grand slam BOOYAH!:

a [[..[[{{...{{0}}...}}]]..]] b (with k+1 {} pairs and j [] pairs) = a [[..[[{...{{b}}...}]]..]] a (with k {} pairs and j [] pairs) - the [[..[[{{...{{0}}...}}]]..]] operator grows at the speed of w2j+wk on the FGH.

a [[..[[{{...{{1}}...}}]]..]] b = a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]]......[[..[[{{...{{0}}...}}]]..]] a -- a [[..[[{{...{{0}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{1}}...}}]]..]] operator grows at the speed of w2j+wk+1 on the FGH.

a [[..[[{{...{{2}}...}}]]..]] b = a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]]......[[..[[{{...{{1}}...}}]]..]] a -- a [[..[[{{...{{1}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{2}}...}}]]..]] operator grows at the speed of w2j+wk+2 on the FGH.

...

a [[..[[{{...{{n+1}}...}}]]..]] b = a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]]......[[..[[{{...{{n}}...}}]]..]] a -- a [[..[[{{...{{n}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{n}}...}}]]..]] operator grows at the speed of w2j+wk+n on the FGH.

[[..[[{{...{{n}}...}}]]..]] is n levels of recursions past the [[..[[{{...{{0}}...}}]]..]] operator. This gets us to {a,b,n,k+1,j}.

Here are some numbers in this range:

Treegol = {10,10,10,100,4} = 10 [[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]] 10 with 100 {} pairs.

Superpent = {5,5,5,5,5} = 5 [[[[{{{{{5}}}}}]]]] 5

Trigol = {10,10,10,100,5} = 10 [[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]] 10 with 100 {} pairs.

Troggol = {10,10,10,100,6} = 10 [[[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]]] 10 with 100 {} pairs.

Tragol = {10,10,10,100,7} = 10 [[[[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]]]] 10 with 100 {} pairs.

Pentadecal = {10,10,10,10,10} = 10 [[[[[[[[[{{{{{{{{{{10}}}}}}}}}}]]]]]]]]] 10