User blog comment:Edwin Shade/How Do I Evaluate BEAF Arrays In Two Dimensions ?/@comment-30754445-20170827183955/@comment-30754445-20170829150104

Here is a detailed breakdown of how the beginning of tetrational arrays works:

Regular dimensional arrays can be contained in a space with a fixed number of dimensions. So you can have an array with 2 dimensions, 3 dimensions, 100 dimensions, a googol dimensions... but no matter how big the array, it is contained in some dimensional space.

Tetrational arrays go beyond this restriction: they cannot be contained by ANY finite number of dimensions.

How is this possible? Well, here is the simplest tetrational array (and the basis for the entire concept) is this:

{a,b (0,1) 2}

This expands to a hypercube with b dimensions with a side of a. In other words, the b tells us how many dimensions will be in the next step of the expansion. And since b can be as large as we like, {a,b (0,1) 2} is a structure that trancends ANY number of dimensions.

One way to visualize this:

Imagine a magic box which is "big" enough to contain any number of dimensions. Any regular dimensional array, even with a googol dimensions, can fit snuggly in that box.

Then, the seperator (0,1) means the rest of the array goes outside that box.

So {a,b (0,1) 2} means: "a,b in the box and '2' outside the box". And we already know how to evaluate things like that. Remember that {a,b (anything) 2} means that we need to feel the entire structure up to (and not including) the '2' with a's:

{a,b (1) 2} = a row of b a's

{a,b (2) 2} = a square of a's with side b = b rows of b a's

{a,b (3) 2} = a cube of a's with side b = b planes of b rows of b a's

.

.

.

{a,b (0,1) 2} = a "magic box" of a's with side b = a b-dimensional cube of a's with side b.

Of-course, once we have our "magic box" and the 2 outside, we can fill that box with any (regular) dimensional array:

The next step after {a,b (0,1) 2} would be {a,b,2 (0,1) 2} (that's "a,b,2 in the box and 2 outside"). The smallest nondegenerate example of such a number:

{3,3,2 (0,1) 2}

Which expands - at first - using the usual rules of ordinary dimensional arrays:

{3,3,2 (0,1) 2} = {3, {3,2,2 (0,1) 2} (0,1) 2} = {3, {3,3 (0,1) 2} (0,1) 2}

That {3,3 (0,1) 2} in there is of the form {a,b (0,1) 2} so:

{3,3 (0,1) 2} = a 3x3x3 cube of 3's = Dimentri

And the expansion continues:

{3, {3,3 (0,1) 2} (0,1) 2} = {3, Dimentri (0,1) 2} = a hyper cube of 3's with a Dimnetri dimensions!

Note that this hypercube, as monsterous as it is, has a fixed (albiet) huge number of dimensions, so from here we can proceed normally.

Going further:

{3,4,2 (0,1} 2} wil eventually evaluate to a hypercube with {3,3,2 (0,1) 2} dimensions

{3,5,2 (0,1} 2} wil eventually evaluate to a hypercube with {3,4,2 (0,1) 2} dimensions

After that you can have any regular dimensional array inside the magic box:

{10,10,10 (0,1) 2} ("a 3-entry linear array in the magic box and a 2 outside")

{10,10 (1) 2 (0,1) 2} ("a row of 10 tens in the magic box and a 2 outside")

{10,10 (2) 2 (0,1) 2} ("a square of 10x10 tens in the magic box and a 2 outside")

{10,10 (3) 2 (0,1) 2} ("a cube of 10x10 tens in the magic box and a 2 outside")

{10,10 (10) 2 (0,1) 2} ("a 10 dimensional hypercube of 1010 tens in the magic box and a 2 outside")

This last number can also be written as {10,10 (0,1} 3}, and the process can continue all over again. Repeating this we can get:

{10,10 (0,1) 4} = {10,10 (10) 2 (0,1) 3}  = "a 10D hypercube in the box, and a 3 outside"

{10,10 (0,1) 5} = {10,10 (10) 2 (0,1) 4} = " a 10D hypercube in the box, and a 4 outside"

And so on.

The next step would be to start building another array outside the box:

{10,10 (0,1) 10,10}

{10,10 (0,1) 10,10,10}

{10,10 (0,1) 10,10,10,10}

{10,10 (0,1) 10,10,10,10,10}

Or even multidimensional arrays:

{10,10 (0,1) 10,10 (2) 2}

{10,10 (0,1) 10,10 (3) 2}

{10,10 (0,1) 10,10 (10) 2}

Now, note that any multidimensional array can be "stored" inside a second magic box! We can use the same trick that started all this madness again, and have two magic boxes with a '2' after them:

{10,10 (0,1) (0,1) 2} which expands to two magic boxes filled with 10's (a 10D cube with 1010 entries in each box, for a total of 20,000,000,000 entries).

See where this is going? We can have any number of magic boxes in a row. Say 10 boxes in a row:

{10,10 (1,1) 2}.

Oh, did I say "row"? Well then, why not have a 10x10 plane of boxes:

{10,10 (2,1) 2}

or a cube of boxes:

{10,10 (3,1) 2}

Here is a picture of Bower's Dulatri = {3,3 (3,1) 2} = {3,3 (2,0) 2}:

The "magic boxes" here are colored in yellow. Each of them has a 3x3x3 cube of 3's, and the boxes themselves are also arranged in a 3x3x3 cube.

Of-course, we can have any number of dimensions we want. How about a 10-dimensional array of boxes:

{10,10 (10,1) 2} = {10,10 (0,2) 2}

Let us think for a moment about this monster: It is a 10D cube of magic boxes with side 10, and each box has a 10D cube of 10's in it. That's 10 billion boxes, each with 10 billion tens!

Yet we barely even started with what tetrational arrays can do. The next step is to repeat the process all over again: We define a "doubly-magic box" which can hold any dimensional structure of ordinary magic boxes. The seperator for this doubly-awsome structure is (0,2) and can put a '2' outside of it to get:

{a,b (0,2) 2} = a hypercube of magic boxes with b dimensions and a side b, filled with a's.

As before, we can fill our "doubly-magic box" with anything we've done earlier:

{[any dimensional array of ordinary magic boxes] (0,2) 2}

The limit of which will be {a,b (0,2) 3}

Then we start filling additional super-magic boxes:

{a,b (0,2) [any dimensional array of ordinary magic boxes] (0,2) 2}

We can have rows of such boxes:

{a,b (1,2) 2}

Or cubes of them:

{a,b (3,2) 2}

Here is a picture of {3,3 (3,2) 2} which Bowers calls "Trilatri":

See the yellow magic boxes and the red doubly-magic boxes? See how everything is neatly arranged in cubes of 3x3x3?

Of-course we can continue this indefinitely. We can have a triply-magic box that can contain any dimensional array of doubly-magic boxes:

{a,b (0,3) 2}

And since the process just repeats over and over, we can simply speak of "level-n magic boxes":

level 0: ordinary numbers

level 1: magic boxes (can hold any dimensional structure of numbers)

level 2: doubly-magic boxes (can hold any dimensional structure of magic boxes)

level 3: triply-magic boxes (can hold any dimensional structure of level 2 boxes)

level n: can hold any dimensional structure of level n-1 boxes.

As you might have guessed, the seperator for "the next level-n box" is (0,n). Want a level-100 magic box? easy:

{10,10 (0,100) 2} would expand to a level-100 magic box filled with 10's.The 10's would be organized in 10 billion level-99 boxes which form a 10D hypercube of side 10.

Seems crazy? We've still barely scratched the surface of tetrational arrays, because the next step is the big one (the thing that Deedlit called "nesting"). What Bowers does here is really a stroke of genius:

He organizes the "box types" (levels) themselves in a dimensional array! The first row of this mega-structure is everything we've done so far:

[ numbers, magic boxes, doubly magic boxes, level 3 boxes, level 4 boxes ... ]

So what goes into the first entry of the 2nd row? A new kind of box, which can store any dimensional array of boxes from the first row. Let's call it the uberbox. The seperator for this uberbox would be (0,0,1) and we'll have:

{a,b (0,0,1) 2}

Which expands to a level-b box filled with a's (with all the sides and dimensions within limited by b).

Now we can start writing the second row of our mega-structure:

Row 1: < numbers, magic boxes, doubly-magic boxes, level 3 boxes, level 4 boxes ... >

Row 2: 

The names are starting to get confusing, but the main idea is clear:

By ordering the types of boxes in an array, we are able to use all the work we've done until now all over again. We can take the second box from the 2nd row:

{a,b (0,1,1) 2}

or the third one:

{a,b (0,2,1) 2}

Or a box from the 3rd row:

{a,b (0,0,2) 2}

Or from the 4th row:

{a,b (0,0,3) 2}

We're not even limited to 2 dimensions. How about taking the first box from the 2nd plane:

{a,b (0,0,0,1) 2}

Or the first box from the 2nd 3D realm:

{a,b (0,0,0,0,1) 2}

So what's the limit of this entire monsterous thing? Well, the megastructure of "box types" can surely extend into an arbitrary number of dimensions. Say, ten dimensions:

{a,b (0,0,0,0,0,0,0,0,0,0,1) 2}

Such arrays are called "superdimensional arrays".This arrays use boxes from any finite dimension on our "boxes list" grid.

But that's not all. After all, we already have an extension to dimensional arrays. Why not extend our megastructure of box-types into a superdimensional array? This gives us trimensional arrays, the simplest of which is:

{a,b ((1)1) 2} = {a,b (0,0,0,...[b zeros]...,0,0,0,1) 2}

The '((1)1)' here represents a box which can contain ''any superdimensional box. ''The situation here is very similar to what we did in the very beginning, when we used (0,1) to extend ordinary dimensional arrays.

Indeed, for every step we did up until now, there's a trimensional analogue. The only difference is that instead of arranging ordinary numbers, we are arranging the boxes types themselves. We can organize them in a magic box, or a doubly-magic box, or and uberbox etc. The entire process we did before, repeating itself again.

Now, eventually, our new superdimensional structure of box-types will fill up. This is the limit of trimensional arrays.

Similarly, we can use a trimensional structure of box-types to build 4-mensional arrays... and then use a 4-mensional structure of box-types to build 5-mensional arrays... and this can go on forever.

And this entire insanely complex structure is what we call "tetrational arrays".

(and going beyond tetrational arrays turns out to be devilishly difficult. It isn't at all clear how to proceed form here, which is why BEAF is not really well-defined above this point)