# Size 4 Arrays

This page will deal with arrays with only four entries which we can call tetrentrical arrays. These arrays may look small, yet they are powerful enough to keep up with Conway's Chained Arrow. We will use {a,b,c,d} for the tetrentrical arrays, starting with d = 1, and increasing d as we go through these arrays. As before here are the general rules to Array Notation for reference. For the operator notation equivalent, we could write it as:

{a,b,c,d} = a {{{{{{.....{{{{c}}}}.....}}}}}} b -- with d pairs of {}.

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

{a,b,c,d} = a {c,d} b = a {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 Tetrentrical Arrays

We can take the above rules and rewrite them for a 4 entry linear array {a,b,c,d}. First notice that the pilot could only be in positions 3 or 4 which are c and d in our example - if c = 1 and d = 1 then there's no pilot, if c = 1 and d > 1 then d is the pilot. If c > 1 regardless of what d is, then c is the pilot. If c is the pilot, then b is the copilot and the only passenger is a, just as in the trientrical arrays. If d is the pilot, then c is the copilot and both a and b are passengers. Since tetrentrical 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 be a,b, and c when the pilot is at c, and the airplane would be all four entries when the pilot is at d. Since passengers are non-crew airplane members, then the passengers are a (when pilot = c) or a and b (when pilot = d). So lets see how this changes the rules:

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

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

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

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

## {a,b,c,1} Cases - a Repeat of Size 3 Arrays and an Introduction to 1-Cropping

When d = 1 then rule 3a is not needed since the pilot d needs to be greater than 1 for this rule. Rule 1 becomes {a,1,c,1} = a, also notice that for trientrical arrays {a,1,c} = a, so {a,1,c,1} = {a,1,c} = a. Rule 2 is the same - but notice that {a,b,1} = ab also, so {a,b,1,1} = {a,b,1}, this is also equal to {a,b}. For rule 3b, we have {a,b,c,1} = {a,{a,b-1,c,1},c-1,1}. If c=2, then we have {a,{a,b-1,2,1},1,1} = a{a,b-1,2,1} = a^^b when followed through - this is the same result as {a,b,2} - so {a,b,2,1} = {a,b,2}. Continuing we will come to the following: {a,b,c,1} = {a,b,c} - this seems to work for all sized arrays, we can call this "1-cropping".

1-cropping is no longer a rule for array notation (as it was in the old version) it is a result of the other rules, we can crop as many 1's off as necessary as long as the non-1 entries remain in their same positions. Here are some valid examples: {a,b,1,1,1,1} = {a,b}, {a,b,c,d,1,1,1} = {a,b,c,d}, {a,b,1,d,1,1} = {a,b,1,d}, {1,4,5,1} = {1,4,5}. Here are some non-valid examples - in otherwords - !DON'T DO THIS! : {a,b,1,d} = {a,b,d}, {1,4,5,1} = {4,5}, {a,1,1,1,1,1,6} = {a,6} - this would lead to erroneous results.

There's also a flip side to 1-cropping which we can call 1-filling, for example: {a,b,c} = {a,b,c,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,......,1,1,1,1..}. For linear arrays, 1-filling isn't needed, but when we go beyond linear we will have previous rows, previous planes, and the like to find the prime blocks of and the prime might be a very large number such as tridecal - we can use 1-filling just to show that the airplane can consist of entires that wasn't showing up in the original array - so if the prime block of a row is a tridecal entries long, but that row was originally {a,b}, we can use the 1-filling to show those tridecal entries on that row {a,b,1,1,1,1,1,1,........,1} to represent its prime block - but we are getting way ahead of ourselves, lets go back to 4 entries.

So for the {a,b,c,1} cases, these are no different than the {a,b,c} cases which are in the Ackermann size range.

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

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

{a,b,1,2} = {a,a,{a,b-1,1,2}} = a^^^^^^^^....{a,b-1,1,2}.....^^^^^^^a - we are in some serious trouble now!

Solving it completely leads to this - where each level after the first has 'number on previous level' ^'s:

a

|

a^^^^^^....^^^^^^a

|

a^^^^^^^^^^^^^...............^^^^^^^^^^^^^^^^a

|

a^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^................................^^^^^^^^^^^^^^^^^^^^^^^^^^^^^a

:

:

:

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

:

|

a^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^.......................................^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^a

If the top 'a' was a 4 and all the others were 3's and we went to the 65th level - it would be Graham's Number, which made it into the Guiness Book of World Records for largest number in a mathematical proof, so Graham's Number is a bit larger than {3,65,1,2} (not exact since the first layer needs to be a 4, but in the array it would solve to a 3) and its a whole lot smaller than {3,66,1,2}. For a good base 10 number, consider {10,100,1,2} which I've given the name Corporal, it is far larger than Graham's number - imagine having a 10 on the first level, then 10^^^^^^^^^^10 on the second (this is tridecal), 10^^^^^.....tridecal ^'s......^^^^^^10 on the third level, and go all the way to the 100th level - lets just put it this way, you DON'T want the Corporal coming up to you asking for a corporal push ups, or worse - a Corporalplex which is {10,corporal,1,2}.

Lets imagine that we have a function called G that works like this: G(n) in base a = a^^^^^^....n ^'s....^^^^^a, so G(4) in base 3 = 3^^^^3, G(2) in base 10 = 10^^10. This "G function" shows up a lot on pages that describe Graham's Number, which would be described as G(G(G(.....G(G(4)))...))) - with 64 G's of base 3 - another way we could write this would be GGGGGGGGGGGG.....GGGGGG4, where G is in base 3 and there are 64 of them. We could take it further by allowing G = a (when G is in base a). So lets assume G is in base 3, then G = 3, GG = G3 = 3^^^3, GGG = GG3 = G(3^^^3) = 3^^^^^......3^^^3 ^'s.....^^^^^3, etc. So now consider this: G1 = G, G2 = GG, G3 = GGG, and Gn = GGGGGGG.....n G's......GGGGGG. Using this G function {3,65,1,2} = G65 base 3 = GGGGGGG......65 G's......GGGGG in base 3 and the corporal {10,100,1,2} = G100 base 10 = GGGGGGGGGGGG......100 G's......GGGGGGGGGG - G's in base 10. So {a,b,1,2} = Gb base a = GGGGG.....b G's....GGGGG in base a.

Now lets look at {a,b,2,2} = {a,{a,b-1,2,2},1,2} = G{a,b-1,2,2} base a = GG{a,b-2,2,2} base a = GGGG^G^....^G in base a with b G's - YIKES!!!!!. This can be rewritten as {a,b,2,2} = G^^b base a - this is two levels of recursion above the G function in the same way tetration is 2 levels above multiplication. Lets get a better feel of this, G's are in base a:

G

|

GGGGG....GGG

|

GGGGGGGGGGGGGGG.............GGGGGGGGGGGGGGGG

|

GGGGGGGGGGGGGGGGGGGGGGGG............................................GGGGGGGGGGGGGGGGGGGGGGGGGG

:

:

Take this to the b'th level, where each level has 'number on previous level' G's

:

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG................................................GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

OK, you can scream now!

Here's an example: {3,3,2,2} = G^^3 (G's are in base 3) = GGG = GG3 = GGGG = GGGGGGGGGGGGG.......GGG G's............GGGGGGGG, where GGG = GG3 = G(3^^^3) = 3^^^^^^^^^^^^........3^^^3 ^'s..........^^^^^^^^^^3.

Imagine 3 is on level 1, 3^^^3 on level 2, 3^^^^^^^^^^^^........3^^^3 ^'s..........^^^^^^^^^^3 is on level 3,

3^^^^^^^^^^^.......3^^^^^^^^^^^^........3^^^3 ^'s..........^^^^^^^^^^3 ^'s.........^^^^^^^3 is on level 4, etc - we would need to go all the way to level 3^^^^^^^^^^^^........3^^^3 ^'s..........^^^^^^^^^^3 to get to {3,3,2,2}!

A shorter way to write 3^^^^^^^^^^^''n^'s''^^^^^^^3 is 3 {n} 3, so 3 {1} 3 = 3^3, 3 {2} 3 = 3^^3, and 3 {3} 3 = 3^^^3. We can now redescribe {3,3,2,2} as 3 on level 1, 3 {3} 3 on level 2, 3 {3 {3} 3} 3 on level 3, 3 {3 {3 {3} 3} 3} 3 on level 4, etc - go to level 3 {3 {3} 3} 3.

Next consider {a,b,3,2} = {a,{a,b-1,3,2},2,2} = G^^{a,b-1,3,2} = G^^G^^G^^G^^....^^G - b times = G^^^b (base a of course), keep in mind this is not normal pentation - but functional pentation on the G function, where functional multiplication is like G(G), and functional exponentiation is like Gn = GGGGGGG.....GGGG (n G's). This "G pentation" is 3 levels of recursion past the G function, see below.

G --> GGGG::G --> GGGGGGG::G --> GGGGGGG::G --> ::::::::::: --> :::::::::::: -> :::::::::::: :::::: b towers :::::: --> GGGGGGGGGGGG::G = {a,b,3,2} ------ G's in base a

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

All of this leads to {a,b,c,2} acting like c levels of recursion past the G function in the same way that {a,b,c} = {a,b,c,1} being c levels of recursion past multiplication. In other words {a,b,c,2} is none other than Ackermann style recursion on the G function.

In operator notation:

{a,b,0,2} = a {{0}} b = a {b} a - the {{0}} grows at speed w on the FGH (Fast Growing Heirarchy).

{a,b,1,2} = a {{1}} b = a {{0}} a {{0}} a {{0}} ....a {{0}} a - b times, solved in reverse, which is equal to a {a {a {a ....... a {a} a ....... a} a} a} a - the {{1}} operator grows at speed w+1 on the FGH.

{a,b,2,2} = a {{2}} b = a {{1}} a {{1}} a {{1}} ....a {{1}} a - b times, solved in reverse. The {{2}} operator grows at speed w+2 on the FGH.

{a,b,3,2} = a {{3}} b = a {{2}} a {{2}} a {{2}} ....a {{2}} a - b times, solved in reverse. The {{3}} operator grows at speed w+3 on the FGH.

..

{a,b,n+1,2} = a {{n+1}} b = a {{n}} a {{n}} a {{n}} ....a {{n}} a - b times, solved in reverse. The {{n}} operator grows at speed w+n on the FGH.

Here are a few more numbers in this range:

Grand Tridecal = {10,10,10,2} = 10 {{10}} 10

Biggol = {10,10,100,2} = 10 {{100}} 10

Biggolplex = {10,10,biggol,2} = 10 {{biggol}} 10

Biggolduplex = {10,10,biggolplex,2} = 10 {{biggolplex}} 10

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

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

{a,b,1,3} = {a,a,{a,b-1,1,3},2} = a {{a {{a {{a ....... a {{a}} a ...... a}} a}} a}} }} a, where there are b a's. This also equals a {{{1}}} b in operator notation which grows at speed w2+1 on the FGH. The {{{0}}} operator grows at speed w2 on the FGH, it can befined as a {{{0}}} b = a {{b}} a.

This is doing just like before, but with a function much grander than the G function - lets call it the H function: H(n) in base a = a {{n}} a in the same way G(n) in base a = a {n} a - and just like before where {a,b,1,2} = GGGGG....GGGG - b times, {a,b,1,3} = HHHHH....HHHHH - b times - letting H = a, when in base a. {a,b,1,3} is also equal to H^b in base a - where this is functional exponentiation not regular exponentiation. When this is followed through {a,b,c,3} turns out to be c levels of recursions past the H function.

{a,b,2,3} = a {{{2}}} b = a {{{1}}} a {{{1}}} a {{{1}}}.......{{{1}}} a - b times, solved in reverse. The {{{2}}} operator grows at speed w2+2 on the FGH.

{a,b,3,3} = a {{{3}}} b = a {{{2}}} a {{{2}}} a {{{2}}}.......{{{2}}} a - b times, solved in reverse. The {{{3}}} operator grows at speed w2+3 on the FGH.

{a,b,k+1,3} = a {{{k+1}}} b = a {{{k}}} a {{{k}}} a {{{k}}}.......{{{k}}} a - b times, solved in reverse. The {{{k}}} operator grows at speed w2+k on the FGH.

Lets look at Tetratri = {3,3,3,3} = 3 {{{3}}} 3 = 3 {{{2}}} 3 {{{2}}} 3 = 3 {{{2}}} 3 {{{1}}} 3 {{{1}}}3 = 3 {{{2}}} 3 {{{1}}} HHH = 3 {{{2}}} HHHHHHH...(HHH H's).....HHHHHHH = 3 "{{{1}}}" to itself HHHHHHHHHHH........(HHH H's)..........HHHHHHHHH times - H's in base 3. This leads to:

H

|

HHHHH....HHH

|

HHHHHHHHHHHHHHHHH.............HHHHHHHHHHHHHHHHHH

|

HHHHHHHHHHHHHHHHHHHHHHHHHHH............................................HHHHHHHHHHHHHHHHHHHHHHHHHHHHH

:

:

Take this to the HHHHHHHHHHHHHHHHHH.............(HHH H's)............HHHHHHHHHHHHHHHHH'th level, where each level has 'number on previous level' H's

:

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH................................................HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

Keep in mind, H=3, HH = 3 {{3}} 3, HHH = 3 {{3 {{3}} 3}} 3, etc. - and just how big IS the comparitively miniscule HH you may ask? - it is the following, where G is in base 3:

G

|

GGGGG....GGG

|

GGGGGGGGGGGGGGG.............GGGGGGGGGGGGGGGG

|

GGGGGGGGGGGGGGGGGGGGGGGG............................................GGGGGGGGGGGGGGGGGGGGGGGGGG

:

:

Take this to the GGGGGGGGGGGGG..............(GGG G's)...........GGGGGGGGGGGGGG'th level, where each level has 'number on previous level' G's

:

GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG................................................GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG

Where G is the Graham's function.

HHH would require HH levels of recursion past the G function instead of just 3 levels like HH above.

And for a few more large numbers:

Baggol = {10,10,100,3} = 10 {{{100}}} 10

Baggolplex = {10,10,baggol,3} = 10 {{{baggol}}} 10

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

Continuing onwards, {a,b,c,4} = a {{{{c}}}} b will be c levels of recursion past function I: I(b) base a = a {{{{0}}}} b = a {{{b}}} a. The {{{{0}}}} operator grows at speed w3 on the FGH. The {{{{k}}}} operator grows at speed w3+k on the FGH.

{a,b,c,5} = a {{{{{c}}}}} b is c levels of recursion past function J: J(b) base a = a {{{{{0}}}}} b = a {{{{b}}}} a. The {{{{{0}}}}} operator grows at speed w4 on the FGH. The {{{{{k}}}}} operator grows at speed w4+k on the FGH.

...

{a,b,c,d} = a {{{{{{{.........{{{{{{{{c}}}}}}}}.........}}}}}}}}} b (there are d sets of {}) - this is c levels of recursion past function Z: Z(b) base a = a {{{{{{.....{{{{{{0}}}}}}.....}}}}}}} b (d sets of {}) = a {{{{{{{{.......{{{{{{{b}}}}}}}.........}}}}}}}}}}}}}}} a - where there are d-1 sets of {}. The {{{{{....{{{{{k}}}}}....}}}}} (d sets of {}) operator grows at speed w(d-1)+k on the FGH.

This is like doing Ackermann style recursion, not once, but over and over again - generating a new function after each Ackermann recursion.

Here are some numbers:

Beegol = {10,10,100,4} = 10 {{{{100}}}} 10

Bigol = {10,10,100,5} = 10 {{{{{100}}}}} 10

Boggol = {10,10,100,6} = 10 {{{{{{100}}}}}} 10

Bagol = {10,10,100,7} = 10 {{{{{{{100}}}}}}} 10

General = {10,10,10,10} = 10 {{{{{{{{{{10}}}}}}}}}} 10

Troogol = {10,10,10,100} =

10 {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{10}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} 10

Generalplex = {10,10,10,general} = 10 {{{{{....{{{{{10}}}}........}}}}}} 10 - general sets of {}

Troogolplex = {10,10,10,troogol} = 10 {{{{{{{........{{{{{{{{10}}}}}}}}.......}}}}}}} 10 - troogol sets of {}

Troogolduplex = {10,10,10,troogolplex} = 10 {{{{{{{........{{{{{{{{10}}}}}}}}.......}}}}}}} 10 - troogolplex sets of {}

The numbers produced by these size 4 arrays {a,b,c,d} are large enough to keep up with Conway's Chained Arrow, where the variable "d" has similar growth potential as the length of a Conway Chain, and "c" has similar growth potential as the last entry in the Conway Chain - and "b" has similar growth potential as the second to last entry in a Conway Chain. Tetrentrical arrays have the limit growth of speed w2 on the FGH.

Coming up next are the five entry arrays, which generates numbers that far exceeds the ones mentioned here, making these look like the dust off a sub-atomic particle.