The **array of** operator is an operator used to accompany Array Notation and BEAF.^{[1]} It has not completely defined as BEAF has not been defined up to the legion level, and hence is currently ill-defined.

## Usage

When used on two integers, the "array of" operator (written a & b) means \(\{\underbrace{b,b,b,b,\ldots,b,b,b,b}_a\}\). This is primarily used in legion arrays.

Bowers also uses a^{n} & b to mean solving an *n*-hypercube (sidelength *a*) of *b*'s.
The exponent on the left side of the operator should never be solved as a normal exponent unless \(n = 1\) For example, 3^{3} & 3 = dimentri, but 27 & 3 = ultatri.

In general, for a space S and natural number b, S&b means an array that has side length b and is in the space S.^{[citation needed]} For example, to represent tetrational, pentational, and further arrays, Bowers uses \(a\underbrace{\uparrow\uparrow\ldots\uparrow\uparrow}_x n\) & b or {a,n,x} & b, where the side length of the hypercube is *a*, *n* is the dimension, and *x* indicates the operator used to build the hypercube (2 for tetration, 3 for pentation, etc). Once again, the expression on the left should never be solved normally.

This process continues to higher arrays, which has been used to define golapulus and golapulusplex.

It is possible to nest array of operations; they are always solved left to right. When doing so, we must take extra care not to solve the left array before computing. For example, 3 & 3 & 3 = {3, 3, 3} & 3 is a pentational array (equal to triakulus when solved), while (3 & 3) & 3 = {3, 3, ..., 3, 3} (with 3 & 3 = {3,3,3} 3's) is a much smaller linear array. These nested operations produce incomprehensibly large numbers; even the arrays used to calculate them are impossible to visualize.

The number of the entries in the resulting array can be calculated by taking the left argument and solving. For example, there are 10^{3} = 1000 tens in 10^{3} & 10.

## In legion arrays

Since BEAF is ill-defined, the explanation here is based on an assumption that BEAF will be completely defined. The array of operator is normally a convenient shorthand for defining numbers like 10^{100} & 10, but it is crucial to the operation of legion arrays. We call all array spaces up to, but not including, legion arrays **legion space**. The prime block of a structure in legion space, then, is an array the size of *b* & *b* ... & *b* & *b*, where there are *p* *b*'s. We use a slash / as a separator for legion spaces, so the previous rule can be written as {*b*, *p* / 2} = *b* & *b* ... & *b* & *b*, *p* times. Ones are default, so {*A* / 1} = {*A*}.

We can use more than two legions: {*b*, *p* / 1 / 2} = {*b* & *b* & ... & *b* & *b* / *b* & *b* & ... & *b* & *b* }. Since these legions form rows, we can even use multiple dimensions of legions: {*b*, *p* (/1) 2} = {*b* & ... & *b* / *b* & ... & *b* / ...} with *p* copies of the array. We can make tetrational, pentational, etc. legion arrays using separators like (/1, 2 (1) 3, 4).

Then next logical step is to structure these legions using legion arrays themselves. We can define *a* && *b*, or *a* legion array of *b*, as {*b* & ... & *b* / *b* & ... & *b* / ...}, where the copies of *b* & ... & *b* themselves form a legion structure of size *a*. Again, *a* can be an integer, an exponent, or an array. We define the prime block of a "legion legion" array to be *b* && *b* && ... && *b* && *b*, and we use the separator //.

It is a common misconception that *a* && *b* = *b* & *b* & ... & *b* & *b*, *a* times, but this is *not* true. The right-hand expression is merely {*b*, *a* / 2}, while the left-hand one is {*b* & ... & *b* / *b* & ... & *b* / ... / *b* & ... & *b*}, where the legions form a multidimensional structure of size *a*. One sign that the equality is incorrect is that *a* is an array, not a number. For example, what is {3, 3, 3} && 3?

Of course, we can go on to legion legion legion arrays, by defining *a* &&& *b* (*a* legion legion array of *b*) as {*b* && ... && *b* // *b* && ... && *b* // ...}, where the legion legions form an *a*-sized structure. We use the separator ///. Naturally, this extends to larger legion types.

Since the legion marks //...// form a row, our next step is to give dimensional structure to the legions themselves: ///(1)///. To define this, we let the symbol L represent legion space (the way X represents a row), and we define {L,*n*}_{b, p} be a legion legion ... legion legion, with *n* legions, with *b* and *p* as the base and prime. If *n* = 1, we have the legion array {L, 1} = {*b*, *p* / 2}. If *n* = 2, we have a legion legion array: {L, 2} = {*b*, *p* // 2}, etc.

However, *n* can be more than just a positive integer. If we let *n* = X, we have {L, X} = {*b*, *p* (1)/ 2} — X becomes *p* when we solve the array, so this is equal to {*b*, *p* //...// 2} with *p* legion marks. If we let *n* = X^{2}, we have {L, X^{2}} = {*b*, *p* (2)/ 2}, a *p* by *p* square of legion marks. *n* can be tetrational, pentational, etc. Then we can let *n* be a legion space, giving us {L, L}. But, since {L, L} = {L, 2, 2}, we can even let the notation extend into BEAF itself: {L, L, L}, {L, L, L, L}, {L, L (1) 2} (which becomes {L, L, ..., L, L} *p* times), 10^{100} & L ... These arrays are called legiattic arrays.

Now we can define *a* @ *b* as the *a* legiattic array of *b*, which is *b* & L_{a, b}. If *b* is an integer, we just have a linear legiattic array: {L, L, ..., L, L}, but *b* can be an array, just like the & operator. This leads us to "lugiattic" arrays, denoted L2, which have a prime block of *b* @ *b* @ ... @ *b* @ *b*, *p* times. Lugiattic arrays have the separator \. We can go into lugion lugions {L2, 2} = {*b*, *p* \\ 2}, lugion lugion lugions {L2, 3} = {*b*, *p* \\\ 2}, etc. We can do everything with L2 as we did with L: {L2, L2}, 10^{100} & L2, L & L2, etc.

Eventually, we reach *a* % *b* as the *a* lugiattic array of *b*, which is *b* & L2_{a, b}. This forms L3, the "lagiattic" arrays, denoted L3. Lagion marks are vertical pipes: |. We use *a* # *b* for lagiattic array of, creating "ligion" space, denoted L4 with separator -. We can go on to L5, L6, L7, L8, ... LX (where X becomes *p* when solving), LL, LL2, LLL, LLLLL, LLL(1)LLL(1)LLL, 10^{100} & L, ...