{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(d1)+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 non1 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 subarrays 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,..,nD array of dimensional groups (X^(X+n)),..dimensional group of dimensional groups (X^(2X)),...X^(2X+n),...mD 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 nspaces are nspaces in the same n+1space that are before the pilot's nspace, 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.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 noncrew 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} = a^{b}  essentially a two entry array
Rule 3a (pilot at d)  {a,b,1,d} = {a,a,{a,b1,1,d},d1}
Rule 3b (pilot at c)  {a,b,c,d} = {a,{a,b1,c,d},c1,d}
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} = a^{b} 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,b1,c,1},c1,1}. If c=2, then we have {a,{a,b1,2,1},1,1} = a^{{a,b1,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 "1cropping".
1cropping 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 non1 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 nonvalid 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 1cropping which we can call 1filling, 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, 1filling 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 1filling 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 1filling 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.
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,b1,1,2},1} = {a,a,{a,b1,1,2}}, and rule 3b becomes {a,b,c,2} = {a,{a,b1,c,2},c1,2}. Lets examine rule 3a a bit closer:
{a,b,1,2} = {a,a,{a,b1,1,2}} = a^^^^^^^^^{....{a,b1,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: G^{1} = G, G^{2} = GG, G^{3} = GGG, and G^{n} = GGGGGGG.....n G's......GGGGGG. Using this G function {3,65,1,2} = G^{65} base 3 = GGGGGGG......65 G's......GGGGG in base 3 and the corporal {10,100,1,2} = G^{100} base 10 = GGGGGGGGGGGG......100 G's......GGGGGGGGGG  G's in base 10. So {a,b,1,2} = G^{b} base a = GGGGG.....b G's....GGGGG in base a.
Now lets look at {a,b,2,2} = {a,{a,b1,2,2},1,2} = G^{{a,b1,2,2}} base a = G^{G{a,b2,2,2}} base a = G^{GGG^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) = G^{GG} = G^{G3} = G^{GGG} = 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,b1,3,2},2,2} = G^^{a,b1,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 G^{n} = GGGGGGG.....GGGG (n G's). This "G pentation" is 3 levels of recursion past the G function, see below.
^{G >} G^{GGG::G >} G^{GGGGGG::G >} G^{GGGGGG::G >} :^{:::::::::: >} :^{::::::::::: >} :^{::::::::::: :::::: b towers :::::: >} G^{GGGGGGGGGGG::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
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,b1,1,3},2}, and rule 3b becomes {a,b,c,3} = {a,{a,b1,c,3},c1,3}. Lets examine rule 3a a bit closer:
{a,b,1,3} = {a,a,{a,b1,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
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 d1 sets of {}. The {{{{{....{{{{{k}}}}}....}}}}} (d sets of {}) operator grows at speed w(d1)+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 w^{2} 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 subatomic particle.