As we last left our heroes, we had exhausted the practical limits of rendering planar arraytype numbers. Those arrays were just getting a little too big, so, in the same way that we use planar arrays to generate very long linear arrays, we will now use threedimensional arrays to generate very large planar arrays. We shall do this by extending our notation a little further once again.
Definitions
All of our old definitions still hold now, with the following small changes.
 An array may now have up to three dimensions, though it is still finite in size. The default value of an entry in an array is still 1 and we still use 1s as padding when necessary. Inline, as we represented the commencement of a new row by a (1), we can now represent a new 2D surface (I'll avoid using "plane" so as not to confuse this with "airplane") with (2).
 The pilot (the first non1 entry after the prime entry) may now appear on later row than the first row, or a later surface than the first surface, or even a later row of a later surface.
 Nevertheless, entries in the array are still in a logical order, row by row and now surface by surface. The terms "previous line" and "previous entry" are now joined by "previous surface" for any surface which comes wholly before the pilot.
 The term "prime block" is now expanded. The prime block of a surface is the first p entries in each of the first p rows of that surface  that is, a pbyp square.
 The "airplane" is now the union of the pilot and the prime blocks of all its previous structures (rows and surfaces). Again, the definition of "passengers" is likewise expanded.
Nothing else has changed. We still obey the usual three rules for evaluating a nontrivial array: decrement the pilot, let all the passengers become equal to b, and substitute v(A') for the copilot if it exists.
Examples
The most important examples are the simplest.
Something of the form <b,p (2) 2>, once one step has been taken to evaluate it, will become a plain, unadorned 2D pbyp square with each entry being equal to b.
Some of these you have seen before:
hyperal = /10 10\ = <10,2 (2) 2>
\10 10/
dutritri = /3 3 3\ = <3,3 (2) 2>
< 3 3 3 >
\3 3 3/
dutridecal = /10 10 10\ = <10,3 (2) 2>
< 10 10 10 >
\10 10 10/
xappol = <10,10 (2) 2>
= / 10 10 10 10 10 10 10 10 10 10 \
/ 10 10 10 10 10 10 10 10 10 10 \
/ 10 10 10 10 10 10 10 10 10 10 \
/ 10 10 10 10 10 10 10 10 10 10 \
/ 10 10 10 10 10 10 10 10 10 10 \
\ 10 10 10 10 10 10 10 10 10 10 /
\ 10 10 10 10 10 10 10 10 10 10 /
\ 10 10 10 10 10 10 10 10 10 10 /
\ 10 10 10 10 10 10 10 10 10 10 /
\ 10 10 10 10 10 10 10 10 10 10 /
xappolplex = <10,xappol (2) 2>, a xappolbyxappol array of 10s
grand xappol = <10,10 (2) 3>
This last example is different because of the trailing 3. Once one step in the evaluation process is taken, you end up with a 10by10 array of 10s, but still with an extraneous 2 on the next row:
grand xappol = <10,10 (2) 3>
= < 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (1)
10, 10, 10, 10, 10, 10, 10, 10, 10, 10 (2) 2 >
= <10,X (2) 2> for some monumental value of X
= ...
Make sense? This is a little bit of a gear change but it should be emphasised that all we have done is expand our definitions slightly. An equally slight expansion leads us to:
Arbitrary numbers of dimensions
New definitions
 We can take this to its logical conclusion fairly swiftly, thanks to the cunning way in which our notation has been devised, by extending (1) for "new row" and (2) for "new surface" to (3) for "new volume" and so on into the higher dimensions.
 Clearly the pilot can now be in a distant dimension compared to the base and prime entry.
 We can introduce the term "previous structure" for previous entries, rows, surfaces, volumes et cetera coming wholly before the pilot.
 We can say the "prime block" of an ndimensional previous structure is now a p^{n} block in the "top corner" of that structure  the prime block of an entry is the entry itself, the prime block of a row is its first p entries, the prime block of a volume is a pbypbyp cube, and so on.
 The "airplane" is now simply the union of the pilot and the prime blocks of all previous structures.
Which allows the following
Examples
dimentri = <3,3 (3) 2>, a 3by3by3 array of threes
colossal = <10,10 (3) 2>, a 10by10by10 array of tens
colossalplex = < 10,colossal (3) 2 >, a colossalbycolossalbycolossal array of tens
terossol = <10,10 (4) 2>, a 10by10by10by10 array of tens
terossolplex = <10,terossol (4) 2 >, a terossolbyterossolbyterossolbyterossol array of tens
petossol = <10,10 (5) 2>, a 10by10by10by10by10 array of tens
petossolplex = <10,petossol (4) 2 >, a petossolbypetossolbypetossolbypetossolpetossol array of tens
ectossol = <10,10 (6) 2>, a 10by10by10by10by10by10 array of tens
ectossolplex = <10,ectossol (6) 2 >, an ectossolbyectossolbyectossolbyectossolbyectossolbyectossol array of tens
zettossol = <10,10 (7) 2>, a 10by10by10by10by10by10by10 array of tens
yottossol = <10,10 (8) 2>, a 10by10by10by10by10by10by10by10 array of tens
xennossol = <10,10 (9) 2>, a 10by10by10by10by10by10by10by10by10 array of tens
dimendecal = <10,10 (10) 2>, a 10by10by10by10by10by10by10by10by10by10 array of tens
gongulus = <10,10 (100) 2>, a 10^{100} array of tens
gongulusplex = <10,10 (gongulus) 2>, a 10^{gongulus} array of tens
gongulusduplex = <10,10 (gongulusplex) 2>, a 10^{gongulusplex} array of tens
gongulustriplex = <10,10 (gongulusduplex) 2>, a 10^{gongulusduplex} array of tens
 gongulusquadraplex = <10,10 (gongulustriplex) 2>, a 10^{gongulustriplex} array of tens
Aaaaand we're done. Arbitrarydimensional arrays are officially exhausted. Where could we possibly go next?
Standard form
Extending the (1), (2) etc. notation backwards, let (0) represent "new entry" (usually represented with a comma), as in, for example:
<b,p,1,d,#> = <b(0)p(0)(0)d(0)#>
In addition, let's say
(n)^{k} = (n)(n)...(n)
\_________/
k
For example,
<10,10 (1)(1)(1)(1)(1)(1)(1)(1)(1)(1) 2> = <10,10 (1)^{10} 2>
Finally, observe that the navigation notation  the instructions for moving from any non1 entry in an array to the next non1 entry in the array  can be rendered into the following standard form:
(X) = (n)^{kn}(n1)^{kn1}...(1)^{k1}(0)^{k0}
where n and all the k_{i} are obviously finite.
Given all this, we find that every nontrivial array so far demonstrated can be rendered into the following standard form:
base

 prime entry
 
  pilot
  
  
< b, p, (X) d, # >
 
 
 remainder of array

navigation
instructions
...where # may or may not exist, d>1, p>1, (X) is some standard piece of navigation notation, and the copilot may or may not exist, depending on whether or not (X) has any trailing (0)s.
So what?
Now observe that the process of evaluating an array revolves entirely around (X). From left to right, each element of (X) defines a previous structure, and each previous structure (along with p) defines a prime block, and each prime block defines something to be filled up with bs.
 (1) in (X) gets replaced with b(0)b(0)...(0)b(0)(1) in the new array, where there are p b(0)s in a row.
 (2) in (X) gets replaced with (1)^{p}(2) where each (1) is treated as above.
 (3) in (X) gets replaced with (2)^{p}(3) where each (2) is treated as above.
 Generally, (n) is replaced with (n1)^{p}(n) where each (n1) is treated as above.
For example:
<8,2 (3)(1) 5 (2)(1) 2,1,2> = <8,2 (3)(1) 5,#>
Here, b=8 and p=2. So (3)(1) becomes (2)(2)(3)(1) which becomes (1)(1)(2)(1)(1)(2)(3)(1) which becomes 8(0)8(0)(1)8(0)8(0)(1)(2)8(0)8(0)(1)8(0)8(0)(1)(2)(3)8(0)8(0)(1) which is then simplified to 8,8(1)8,8(2)8,8(1)8,8(3)8,8(1), so:
<8,2 (3)(1) 5,#> = <8,8 (1) 8,8 (2) 8,8 (1) 8,8 (3) 8,8 (1) 4,#>
= <8,8 (1) 8,##>
Here, b=8 and p=8. So (1) becomes 8,8,8,8,8,8,8,8(1), so:
<8,8 (1) 8,##> = <8,8,8,8,8,8,8,8 (1) 7,##>
= <8,8,8,###>
= <8,v(<8,7,8,###>),7,###>
= ...
...and the mindbogglingly lengthy evaluation continues.
The important point here is to recognise the navigation notation, (X), as a key component in the creation and evaluation of Bowers arrays. It is the navigation notation, more than b, p or d, which now provides the most scope for the generation of everhuger numbers; and it is the drastic augmentation and expansion of the navigation notation on which we now focus our attention.
Next: nested array notation.