This page will deal with the smallest and simplest arrays. The arrays here will have no more than three entries. We will start with arrays with 0, 1, and 2 entries - these are quite trivial. Then we'll go into three entry (or "trientrical") arrays in detail. In operator notation, {a,b,c} = a {c} b, where a {0} b = ab (speed 2 on the FGH), a {1} b = a

**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:

Since the pilot must be after the prime (2nd entry) it can't be amongst the first two entries - so therefore there's no pilot when there are fewer than three entries, this means that rule 3 isn't needed for the trivial arrays. Rule 1 isn't needed either since it becomes redundant for less than three entries, as can be seen by this equation: {a,1} = a^{1} (rule 2 result) = a (rule 1 result), so rule 1 and 2 have the same result for the trivials. So we are left with rule 2 - {b,p} = b^{p}. When there are 0 or 1 entries, we can convert the array into a 2 entry array by filling in the extra entries by the default value 1 - so {a} = {a,1} and {} = {1,1} - as a matter of fact, {} = {1} = {1,1} = {1,1,1} = {1,1,1,1,1,1,1,1,1} - these 1's act like the surrounding white space on a picture that can be cropped off.

So for summary:

{} = 1 - this is the most primative array of all - it is of size 0.

{a} = a - arrays of size 1

{a,b} = a^{b} - arrays of size 2

There's also another kind of trivial array, where the base is equal to 1. Since the value of the array v(A) will always be equal to some power (k) of its base then for a base = 1, v(A) = 1^{k} = 1 - no matter how big the array gets, so {1,5,8,7,3,2,9,10,789,234} = 1

So far the arrays seem quite tame giving us values we can easily handle, such as {3,2} = 9, {5,3} = 125, {10,9} = one billion, and for a larger one {10,100} = googol. These are numbers we have all seen before staying in the range of counting and astronomical sized numbers. Many of the illion numbers are in this range also. So lets see what happens when there are three entries!

We'll be using {a,b,c} for our general 3 entry array, for this array a is the base and b is the prime. If c = 1 then there are no entries past the prime larger than 1 - in other words - no pilot - so {a,b,1} = a^{b} = {a,b} - notice how we can simply crop off the 1 to solve it, {a,b,1} = {a,b} - this cropping isn't a rule, but is a result of the rules. When c > 1, then c will be the first entry beyond the prime larger than 1 - therefore c is the pilot, and b is the copilot. Since we are dealing with linear arrays, the only structures will be entries, so that means the first two entries a and b are the previous structures, the prime block of these structures are the same entries again a and b - therefore the airplane will be the pilot c and the prime block of the previous structures a and b - and finally the passengers are all of the entries in the airplane except the pilot and copilot - so a is the only passenger - to summarize: for {a,b,c} (c > 1), a = base is the only passenger, b = prime is the copilot, c is the pilot, and the airplane consist of all three entries. So lets rewrite the rules to fit a 3 entry array:

Rule 1 - {a,1,c} = a

Rule 2 - {a,b,1} = a^{b} - this is essentially a two entry array

Rule 3 - {a,b,c} = {a,{a,b-1,c},c-1} - notice that the pilot decreased by 1 and the copilot is now the array with its prime lowered by 1, and the passenger = base

Lets play around with this, lets let c = 2, that means rule 1 is {a,1,2} = a, rule 2 isn't needed, and rule 3 is {a,b,2} = {a,{a,b-1,2},1} = a^{{a,b-1,2}} = a^{aaa::a} - b times = a^^b (a tetrated to b, or a to the b'th exponent) - uh oh, NOW its looking a bit dangerous - how about some values:

{1,b,2} = 1 of course

{a,1,2} = a of course

{2,2,2} = 4

{3,2,2} = 27

{4,2,2} = 256

{5,2,2} = 3125

{10,2,2} = 10000000000 - well not too bad

{2,3,2} = 16 - yawn

{3,3,2} = 7,625,597,484,987

{4,3,2} = 13.4078 quinquagentillion (10^{153}) - uh oh

{10,3,2} = one followed by ten billion zeroes - 10^{10000000000}

{2,4,2} = 65,536

{3,4,2} = 3^{7625597484987} - a number with over 3.6 trillion digits - yikes!

{10,4,2} = one followed by 'one followed by 10 billion zeroes' zeroes - 10^{1010000000000} - WELL over a googolplex = 10^{10100}

{2,5,2} = 2003529930406846464979072351560255750447825475569751419265......19729 digits total.......77965048175856395072895337539755822087777506072339445587895905719156736

{10,10,2} = one followed by 'one followed by 'one followed by 'one followed by 'one followed by 'one followed by 'one followed by 'one followed by 10 billion zeroes' zeroes' zeroes' zeroes' zeroes' zeroes' zeroes' zeroes = 10^^10 = ^{10}10 = 10^{1010^10^10^10^10^10^10^10} - I call this number the **Decker** - it is larger than a googolseptaplex (10^{1010^10^10^10^10^googol}) - many of the googol group numbers belong in the tetrational ranges of {a,b,2}, such as googolplex, googolduplex (also googolplexian) = 10^{googolplex}, googoltriplex = 10^{googolduplex}

{10,100,2} = 10^^100, I call this number **Giggol**, it is 10 to the power of itself 100 times - 10^{1010101010^10^10^10^10^10^.....^10}

Whew - three entry arrays lead to some seriously huge numbers - and guess what, we're just getting started .... with only the three entry arrays, now lets let c = 3!

When c=3, by rules 1 and 3 we get {a,1,3} = a.

{a,2,3} = {a,{a,1,3},2} = a^^a.

{a,3,3} = {a,{a,2,3},2} = a^^{a,2,3} = a^^a^^a.

So {a,b,3} = a^^a^^a^^a^^....b times.....^^a -- this is a tetrated to itself b times which equals a^^^b also called a pentated to b (I like to call it *a to the b'th tower*, below shows you why).

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} :^{:::::::::: -->} :^{::::::::::: ->} :^{::::::::::: :::::: b towers :::::: -->} a^{aaaaaaaaaaa::a = a^^^b = {a,b,3} }

Where each tower reveals the number of a's exponentiated to itself in the next tower!

Lets introduce a few examples:

{2,2,3} = 2^^^2 = 2^^2 = 2^2 = 4

{2,3,3} = 2^^^3 = 2^^2^^2 = 2^^4 = 65536 - not too bad

{2,4,3} = 2^^^4 = 2^^2^^2^^2 = 2^^65536 = 2 to the power of itself 65536 times, this is pretty bad.

{2,5,3} = 2^^^5 = 2^^2^^2^^2^^2 = 2^^{2,4,3} = 2 to the power of itself {2,4,3} times

{3,2,3} = 3^^^2 = 3^^3 = 7625597484987

{3,3,3} = 3^^^3 = 3^^3^^3 = 3^^7625597484987 = 3 to the power of itself 7625597484987 times - This power tower of 3's can reach Venus!! - this is the number I call **Tritri**

{3,4,3} = 3^^^4 = 3^^3^^3^^3 = 3^^tritri = 3 to the power of itself tritri times.

{10,100,3} = 10^^^100 (ten to the hundredth tower - try to savor and seep in how enormous this is) = 10^^10^^10^^10^^10^^......100 10's......^^10 - I call this one **Gaggol**

Now, lets go for c = 4 (the hexational range).

{a,1,4} = a.

{a,2,4} = {a,{a,1,4},3} = a^^^a.

{a,3,4} = {a,{a,2,4},3} = a^^^{a,2,4} = a^^^a^^^a.

So {a,b,4} = aa^^^aa^^^aa^^^......b times.....^^^aa ---- or a pentated to itself b times (also a to the **Tower** of itself b times) - this is a hexated to b (a^^^^b). See detail below:

a

_{\}||_{/}

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} :^{::::::::::: ->} :^{::::::::::: ::::::: -->} a^{aaaaaaaaaaa::a}

_{\}||_{/}

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} :^{:::::::::: -->} :^{::::::::::: ->} :^{::::::::::: ::::::: -->} a^{aaaaaaaaaaa::a}

_{\}||_{/}

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} :^{:::::::::: -->} :^{::::::::::: ->} :^{::::::::::: ::::::: -->} a^{aaaaaaaaaaa::a}

_{\}||_{/}

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} :^{:::::::::: -->} :^{::::::::::: ->} :^{::::::::::: ::::::: -->} a^{aaaaaaaaaaa::a}

_{\}||_{/}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

_{\}||_{/}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

_{\}||_{/}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: b layers :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

_{\}||_{/}

^{a -->} a^{aaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} a^{aaaaaa::a -->} :^{:::::::::: -->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ->} :^{::::::::::: ::::::: -->} a^{aaaaaaaaaaa::a}

Here each layer reveals how many towers will be in the next layer - so we can call a hexated to b "a to the b'th layer", and just think - this is only {a,b,**4**}. Notice the trend, starting from {a,b,1} and continuing through {a,b,2}, {a,b,3}, and {a,b,4} -

{a,b,1} = a^{b} (a to the b'th power)

{a,b,2} = a^^b (a to the b'th level = a to the power of itself b times) - also called tetration

{a,b,3} = a^^^b (a to the b'th tower = a to the level of itself b times) - each tower reveals the number of levels of exponents in the next tower - also called pentation

{a,b,4} = a^^^^b (a to the b'th layer (or quatower) = a to the tower of itself b times) - each layer reveals the number of towers in the next layer - also called hexation

- now lets continue forward -

{a,b,5} = a^^^^^b (a to the b'th quintower (or field) = a to the layer of itself b times) - each quintower reveals the number of layers in the next quintower - also called heptation

{a,b,6} = a^^^^^^b (a to the b'th hextower = a to the quintower of itself b times) - each hexower reveals the number of quintowers in the next hextower - also called octation

.....

{a,b,c} = a^^^^^{....c arrows....}^^^^b (a to the b'th 'c'ower = a to the 'c-1'ower of itself b times) - each 'c'ower reveals the number of 'c-1'owers in the next 'c'ower - also called 'c+2'ation

As you can see, these numbers are getting seriously large now. As large as these may seem, numbers in this range have been known since the 1920's by W. Ackermann. Also these three entry arrays mimic Knuth's up arrow notation, and thats exactly what it is - just in another format. One version of the Ackermann function (there are a few of them) generates the numbers {n,n,n} for each integer n - so the Ackermann numbers are 1 = {1,1,1}, 4 = {2,2,2}, tritri ={3,3,3}, {4,4,4}, {5,5,5}, etc - the number {10,10,10} is also one of them - I like to call it **Tridecal**. Imagine the sheer size of {10,10,100}, which I call **Boogol** - it requires 100 levels of recursion beyond multiplication, where powers, tetration, pentation, etc can be considered as 1, 2, 3, etc levels of recursion beyond multiplication - we can call this multilevel recursion - "Ackermann style recursion" on multiplication.

So in summary:

{} = 1

{a} = a

{a,b} = a^{b} - results are in the countable to astronomical range

{a,b,c} = a^^^^^^^{....c arrows....}^^^^b (Knuth's up arrow notation) - results are in the Ackermann range - grows at speed c+2 on the FGH (Fast Growing Heirarchy).

Trientrical arrays grow at speed w on the FGH, the same speed as the Ackermann function. Coming up next are the size 4 arrays (four entry arrays), the numbers generated by them will utterly clobber the numbers on this page - making these huge Ackermann sized numbers look like dust.