As we last left our heroes, we had exhausted the practical limits of rendering planar array-type 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 three-dimensional arrays to generate very large planar arrays. We shall do this by extending our notation a little further once again.

Three-dimensional arrays

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 non-1 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 p-by-p 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 non-trivial 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 p-by-p 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 xappol-by-xappol 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 10-by-10 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 n-dimensional previous structure is now a pn 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 p-by-p-by-p 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 3-by-3-by-3 array of threes

  • colossal = <10,10 (3) 2>, a 10-by-10-by-10 array of tens

  • colossalplex = < 10,colossal (3) 2 >, a colossal-by-colossal-by-colossal array of tens

  • terossol = <10,10 (4) 2>, a 10-by-10-by-10-by-10 array of tens

  • terossolplex = <10,terossol (4) 2 >, a terossol-by-terossol-by-terossol-by-terossol array of tens

  • petossol = <10,10 (5) 2>, a 10-by-10-by-10-by-10-by-10 array of tens

  • petossolplex = <10,petossol (4) 2 >, a petossol-by-petossol-by-petossol-by-petossol-petossol array of tens

  • ectossol = <10,10 (6) 2>, a 10-by-10-by-10-by-10-by-10-by-10 array of tens

  • ectossolplex = <10,ectossol (6) 2 >, an ectossol-by-ectossol-by-ectossol-by-ectossol-by-ectossol-by-ectossol array of tens

  • zettossol = <10,10 (7) 2>, a 10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens

  • yottossol = <10,10 (8) 2>, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens

  • xennossol = <10,10 (9) 2>, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens

  • dimendecal = <10,10 (10) 2>, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens

  • gongulus = <10,10 (100) 2>, a 10100 array of tens

  • gongulusplex = <10,10 (gongulus) 2>, a 10gongulus array of tens

  • gongulusduplex = <10,10 (gongulusplex) 2>, a 10gongulusplex array of tens

  • gongulustriplex = <10,10 (gongulusduplex) 2>, a 10gongulusduplex array of tens

  • gongulusquadraplex = <10,10 (gongulustriplex) 2>, a 10gongulustriplex array of tens

Aaaaand we're done. Arbitrary-dimensional arrays are officially exhausted. Where could we possibly go next?

Overview of the story so far

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 non-1 entry in an array to the next non-1 entry in the array - can be rendered into the following standard form:

(X) = (n)kn(n-1)kn-1...(1)k1(0)k0

where n and all the ki 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 (n-1)p(n) where each (n-1) 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 mind-bogglingly 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 ever-huger numbers; and it is the drastic augmentation and expansion of the navigation notation on which we now focus our attention.

Next: nested array notation.

Log in or registerto write something here or to contact authors.