BEAF入门

主条目：BEAF

BEAF，或鲍尔斯爆炸数阵函数，是由乔纳森·鲍尔斯发明的大数函数。这篇文章会直观的描述它，并慢慢的介绍。

箭号表示法

要理解BEAF，就必须理解扩展运算记号。箭号表示法是高德纳发明的一组运算：

\(a\uparrow b = a^b\)

\(a\uparrow\uparrow b = \underbrace{a\uparrow a\uparrow\ldots\uparrow a\uparrow a}_b = \underbrace{a^{a^{a^{.^{.^.}}}}}_b\)。大数研究者称之为迭代幂次。箭号应从右到左运算。

\(a\uparrow\uparrow\uparrow b = \underbrace{a\uparrow\uparrow a\uparrow\uparrow\ldots\uparrow\uparrow a\uparrow\uparrow a}_b\)。又称五级运算。

一般来说，

\(a\uparrow^n b = \underbrace{a\uparrow^{n-1} a\uparrow^{n-1}\ldots\uparrow^{n-1} a\uparrow^{n-1} a}_b\)

例如：

\(3\uparrow 4 = 3^4 = 81\)（3的4次方）

\(2\uparrow\uparrow 4 = 2\uparrow 2\uparrow 2\uparrow 2 = 2\uparrow 2\uparrow 4 = 2\uparrow 16 = 65536\)

\(4\uparrow\uparrow 4 = 2361022671...5261392896\)，大约有\(8.0723\cdot 10^{153}\)位数

\(3\uparrow\uparrow\uparrow 3 = 3\uparrow\uparrow 3\uparrow\uparrow 3 = 3\uparrow\uparrow 3^{3^3} = 3\uparrow\uparrow 7625597484987\)

运算记号

鲍尔斯开发出了运算记号，为箭号表示法的推广:

\(a\ \{n\}\ b = a\uparrow^n b\)

即：\(a\ \{1\}\ b = a^b\)

和\(a\ \{n\}\ b = \underbrace{a\ \{n - 1\}\ a\ \{n - 1\}\ \ldots\ \{n - 1\}\ a\ \{n - 1\}\ a}_b\)

例如\(3\ \{4\}\ 5 = 3\uparrow\uparrow\uparrow\uparrow 5\)。

上述的运算记号只是箭号表示法的简写。但鲍尔斯进一步扩展，现在n外不只有一个大括号，而是两个：

\(a\ \{\{1\}\}\ b = \underbrace{a\ \{a\ \{\ldots a\ \{a}_b\}\ a\ldots\}\ a\}\ a\)

鲍尔斯称此为a expanded to b。其中，b代表“层数”（包含最外层括号外那层）或(a的个数 + 1) / 2。

举一个例子：

\(3\ \{\{1\}\}\ 3 = 3\ \{3\ \{3\}\ 3\}\ 3 = 3\ \{3\ \{2\}\ 7625597484987\}\ 3\)

如果n变为2，将会得到multiexpansion。

\(a\ \{\{2\}\}\ b = \underbrace{a\ \{\{1\}\}\ a\ \{\{1\}\}\ \ldots\ \{\{1\}\}\ a\ \{\{1\}\}\ a}_b\)

n的值更高的情况：

\(a\ \{\{3\}\}\ b = \underbrace{a\ \{\{2\}\}\ a\ \{\{2\}\}\ \ldots\ \{\{2\}\}\ a\ \{\{2\}\}\ a}_b\)（powerexpansion）

\(a\ \{\{4\}\}\ b = \underbrace{a\ \{\{3\}\}\ a\ \{\{3\}\}\ \ldots\ \{\{3\}\}\ a\ \{\{3\}\}\ a}_b\)（expandotetration）

expandopentation，expandohexation，等。

所有运算符都是右结合的，并且它们的运作方式就像超运算一样。

如果再增加一个大括号，就会得到explosion:

\(a\ \{\{\{1\}\}\}\ b = \underbrace{a\ \{\{a\ \{\{\ldots a\ \{\{a\}\}\ a\ldots\}\}\ a\}\}\ a}_b\)

\(a\ \{\{\{2\}\}\}\ b = \underbrace{a\ \{\{\{1\}\}\}\ a\ \{\{\{1\}\}\}\ \ldots\ \{\{\{1\}\}\}\ a\ \{\{\{1\}\}\}\ a}_b\)（multiexplosion）

\(a\ \{\{\{3\}\}\}\ b = \underbrace{a\ \{\{\{2\}\}\}\ a\ \{\{\{2\}\}\}\ \ldots\ \{\{\{2\}\}\}\ a\ \{\{\{2\}\}\}\ a}_b\)（powerexplosion）

\(a\ \{\{\{4\}\}\}\ b = \underbrace{a\ \{\{\{3\}\}\}\ a\ \{\{\{3\}\}\}\ \ldots\ \{\{\{3\}\}\}\ a\ \{\{\{3\}\}\}\ a}_b\)（explodotetration）

explodopentation，explodohexation，等。

四个括号会有detonation（multidetonation，powerdetonation，detonotetration，等），五个则为pentonation（multipentonation，powerpentonation，pentonotetration，等），然后有hexonation，heptonation，等等。

现在，运算记号有四个参数：

\(a\ \{1\}\ b = a^b\)

\(a\ \{1\}^d\ b = \underbrace{a\ \{a\ \{\ldots a\ \{a\}^{d - 1}\ a\ldots\}^{d - 1}\ a\}^{d - 1}\ a}_b\)

\(a\ \{c\}^d\ b = \underbrace{a\ \{c - 1\}^d\ a\ \{c - 1\}^d\ \ldots\ \{c - 1\}^d\ a\ \{c - 1\}^d\ a}_b\)

其中，上标d代表c周围的括号数量。如\(\{\ldots\}^4\)为\(\{\{\{\{\ldots\}\}\}\}\)的简写。鲍尔斯本人并不使用这种简写。

大数研究者克里斯·鸟证明了这个4-参数符号和链式箭号表示法有相同的增长。但这只是BEAF的开始！

线性数阵记号

运算记号开始变得不敷使用。一般来说会用更简单的\(\{a, b, c, d\}\)取代原本的\(a\ \{c\}^d\ b\)。新记号的定义如：

• \(\{a, b, 1, 1\} = a^b\)
• \(\{a, b, 1, d\} = \underbrace{\{a, a, \{a, a, \ldots \{a, a, a, d - 1\} \ldots, d - 1\}, d - 1\}}_b\) if \(d > 1\)
• \(\{a, b, c, d\} = \underbrace{\{a, \{a, \ldots \{a, a, c - 1, d\} \ldots, c - 1, d\}, c - 1, d\}}_b\) if \(c > 1\)

1被认为是默认值，所以数阵结尾的1可以被去掉。如\(\{a, b, 1, 1\}\)可以简化成\(\{a, b\} = a^b\)。

我们可以按照递回的特性简化规则2和3：

\(\{a, b, 1, d\} = \underbrace{\{a, a, \{a, a, \ldots \{a, a, a, d - 1\} \ldots, d - 1\}, d - 1\}}_b\)

\(= \{a, a, \underbrace{\{a, a, \ldots \{a, a, a, d - 1\} \ldots, d - 1\}}_{b - 1}, d - 1\} = \{a, a, \{a, b - 1, 1, d\}, d - 1\}\)

\(\{a, b, c, d\} = \underbrace{\{a, \{a, \ldots \{a, a, c - 1, d\} \ldots, c - 1, d\}, c - 1, d\}}_b\)

\(= \{a, \underbrace{\{a, \ldots \{a, a, c - 1, d\} \ldots, c - 1, d\}}_{b - 1}, c - 1, d\} = \{a, \{a, b - 1, c, d\}, c - 1, d\}\)

但你会发现一个问题，我们已经定出归纳规则，但没有基础情况，因此\(b\)将不断递减下去！当\(b\)达到\(1\)时，便须有如下规则：

\(\{a, 1, c, d\} = a\)

这一步在BEAF的定义中是非常重要的，如果你不清楚它的运作原理，可以将它写在纸上。

五项以上的数阵

让我们回顾一下上面的规则：

• \(\{a, b, 1, 1\} = \{a, b\} = a^b\)
• \(\{a, 1, c, d\} = a\)
• \(\{a, b, 1, d\} = \{a, a, \{a, b - 1, 1, d\}, d - 1\}\), \(b,d > 1\)
• \(\{a, b, c, d\} = \{a, \{a, b - 1, c, d\}, c - 1, d\}\), \(b,c > 1\)

透过这个简化，便可在最后两个规则中找到模式。尝试加入第五个参数：

• \(\{a, b\} = a^b\)
• \(\{a, 1, c, d, e\} = a\)
• \(\{a, b, 1, 1, e\} = ???\)
• \(\{a, b, 1, d, e\} = \{a, a, \{a, b - 1, 1, d, e\}, d - 1, e\}\), \(b,d > 1\)
• \(\{a, b, c, d, e\} = \{a, \{a, b - 1, c, d, e\}, c - 1, d, e\}\), \(b,c > 1\)

第三条规则尚未定出，不过我们可从第四和第五条规则反推回去：

\(\{a, b, 1, 1, e\} = \{a, a, a, \{a, b - 1, 1, 1, e\}, e - 1\}\)

加入第五项是如此简单。我们可以继续添加第六项：

• \(\{a, b\} = a^b\)
• \(\{a, 1, c, d, e, f\} = a\)
• \(\{a, b, 1, 1, 1, f\} = \{a, a, a, a, \{a, b - 1, 1, 1, 1, f\}, f - 1\}\), \(b,f > 1\)
• \(\{a, b, 1, 1, e, f\} = \{a, a, a, \{a, b - 1, 1, 1, e, f\}, e - 1, f\}\), \(b,e > 1\)
• \(\{a, b, 1, d, e, f\} = \{a, a, \{a, b - 1, 1, d, e, f\}, d - 1, e, f\}\), \(b,d > 1\)
• \(\{a, b, c, d, e, f\} = \{a, \{a, b - 1, c, d, e, f\}, c - 1, d, e, f\}\), \(b,c > 1\)

我们应该允许任意个参数的代入，并整理出规则。为了简洁性，我们会引入一些术语。第一项\(b\)是底数，而第二项\(p\)是指数。在指数后，第一个非1项是驾驶员；它前面的项是副驾驶，再前面的所有项则是乘客。数阵的值被写成\(v(A)\)。使用这些术语，我们可以描述出线性数阵记号。

线性数阵记号

设\(b\)为底数，\(p\)为指数。

1. 基础规则：如果没有驾驶员（即指数后的项均为1），则\(v(A) = b^p\)。
2. 指数规则：如果指数为1，\(v(A) = b\)。
3. 灾难规则：否则，
   1. 将副驾驶换成原数阵，但其指数减去1。
   2. 驾驶员减1。
   3. 所有乘客变为\(b\)。

（定义结束）

这是鲍尔斯于2002年发明的古典数阵记号。原来使用了五种规则，但现代BEAF将其简化至三个规则。

例子

我们已经定义出线性数阵，以下会给出一些例子来获得更好的直觉。

\begin{eqnarray*} \{3,3,1,1,1,3\} &=& \{3,3,3,3,\{3,2,1,1,1,3\},2\} \\ &=& \{3,3,3,3,\{3,3,3,3,3,2\},2\} \\ &=& \{3,3,3,3,\{3,\{3,2,3,3,3,2\},2,3,3,2\},2\} \\ &=& \{3,3,3,3,\{3,\{3,\{3,1,3,3,3,2\},2,3,3,2\},2,3,3,2\},2\} \\ &=& \{3,3,3,3,\{3,\{3,3,2,3,3,2\},2,3,3,2\},2\} \end{eqnarray*}

如果数阵中的所有项都是一样的，将可以转换为更简单的高阶数阵：

三项数阵转换为四项：

• \(\{a,a,a\} = \{a,2,1,2\}\)
• \(\{a,a,\{a,a,a\}\} = \{a,3,1,2\}\)
• \(\{a,a,\{a,a,\{a,a,a\}\}\} = \{a,4,1,2\}\)等

四项转换为五项：

• \(\{a,a,a,a\} = \{a,2,1,1,2\}\)
• \(\{a,a,a,\{a,a,a,a\}\} = \{a,3,1,1,2\}\)
• \(\{a,a,a,\{a,a,a,\{a,a,a,\{a,a,a,\{a,a,a,a\}\}\}\}\} = \{a,6,1,1,2\}\)

五项转换为六项：

• \(\{a,a,a,a,a\} = \{a,2,1,1,1,2\}\)
• \(\{a,a,a,a,\{a,a,a,a,a\}\} = \{a,3,1,1,1,2\}\)
• \(\{a,a,a,a,\{a,a,a,a,\{a,a,a,a,a\}\}\} = \{a,4,1,1,1,2\}\)

一般情况下，\(\{a,b,1,1,\ldots,1,1,2\} = \{a,a,a,\ldots,a,a,\{a,a,a,\ldots,a,a,\{a,a,a,\ldots,a,a,\{a,a,a,\ldots,a,a\}\ldots\}\}\}\)（b-1层）。

多维数阵

我们引入一个新的运算：

\(b \& a = \underbrace{\{a, a, ..., a, a\}}_b\)

这个函数“对角化”了我们之前所做的东西。这是一个可观的函数；如果你熟悉快速增长层级，那么作为一个对比，\(n \& n\)相当于\(f_{\omega^\omega}(n)\)。

为了继续扩展数阵记号，我们需要一点直觉的飞跃。\(b \& a\)隐约类似于\(a^b = \underbrace{\{a \cdot a \cdots a \cdot a\}}_b\)，让我们写一个“二阶数阵记号”，其中基础规则变为：

1. 基础规则：如果没有驾驶员（即指数后的项均为1），则\(v(A) = p \& b\)。

为了表示二阶数阵记号，我们在数阵右边标个下标2：\(\{a, b\}_2 = p \& b\)。除了基础规则，数阵记号的其他规则保持不变，所以还是有\(\{a, b, c\}_2 = \{a, \{a, b - 1, c\}_2, c - 1\}_2\)等等。我们也可以定义三阶数阵记号。定义\(b \&_2 a = \underbrace{\{a, a, ..., a, a\}_2}_b\)，并将基础规则的\(\&\)替换为\(\&_2\)，就可以得到三阶数阵记号。

这里的扩展应该是显而易见的，并相对平淡。让我们创建一套，与\(r\)阶数阵记号相关的新规则：

1. 基础规则：如果没有驾驶员、且\(r = 1\)，则\(v(A) = b^p\)。
2. 阶规则：如果没有驾驶员、且\(r > 1\)，则\(v(A) = p \&_{r - 1} b\)。
3. 指数规则和灾难规则不变。

那么，如何发挥这个扩展的最大优势？答案就是，让\(r\)也变为数阵：

\(\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}}\)

那为什么不写\(b\)次数阵？

\(\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{._{._.}}}}\)（每个数阵有\(a\)项）

我们可以使用\(b \&_{1, 2} a\)来表示它，并定义一个“1,2阶记号”，接著是\(2,2\)，代表\(\{a, a, \ldots, a, a\}_{1,2}\)。我们以同样的方式定义n,2阶记号，就像n阶记号那样。

现在来看1,3：

\(\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{._{._.}},2},2}\)

和一般情况1,n，其中n > 1：

\(\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{\{a, a, \ldots, a, a\}_{._{._.}},n - 1},n - 1}\)

不是那么坏。那么1,1,2又是如何？可以看到，\(r\)已经拥有多项，可以采用类似普通数阵的方式来运作。我们可以称\(r\)的第一个非1项作“阶驾驶员”，随即有“阶副驾驶”，然后就可以将阶副驾驶替换为“原数阵将其指数减去1”，阶驾驶员减去1，前面的原始数阵变为\(p\)个\(b\)。

但为什么要将驾驶员和阶驾驶员分开呢？如果需要关心阶数，代表原始数阵只剩下底数和指数，如\(\{b, p\}_{1,1,2}\)。由于\(r\)是数阵的一部份，因此阶驾驶员就是驾驶员。

让我们把\(r\)放到大括号内。鲍尔斯对高维度的迷恋让他把\(r\)放到第二列，如：

\[\left\{ \begin{matrix} b,p \\ 1,1,2 \end{matrix} \right\}\]

若要将其排成一列，我们会写为\(\{b, p\ (1)\ 1, 1, 2\}\)，其中(1)表示列的分隔符。与先前同样，各列可以在最后填充任意多的1（或是可以认为预设有无限个1），所以\(\{b, p, 1\ (1)\ 1, 1, 2\}\)和\(\{b, p, 1, 1, 1\ (1)\ 1, 1, 2, 1, 1\}\)相同。

让我们尝试将现有规则延伸到两列的情况，如\(\{b, p (1) 2\}\)。这里我们可以看到，它没有副驾驶！因而需要修改规则以适应这种状况。这里有另一个问题：

\(\{b, p (1) 1, 1, 2\} = \{b, b, b, \ldots (1) b, \{b, p - 1 (1) 1, 1, 2\}\}\)

问题是在第1列中，b的个数是无限个，我们希望它有p个。要修复它，我们需要修改“乘客”的定义。定义变为：

• 底数为第一项。
• 指数为第二项。
• 驾驶员是指数后的第一个非1项。
• 副驾驶是驾驶员的前一项。如果驾驶员是第二列的开始，那么它不存在。
• 前项代表在指定项那列、在指定项前面的项。（因此，在\(\{a, b (1) c, d\}\)中，\(c\)是\(d\)的前项，而\(a\)和\(b\)不是。）
• 列的指数块包含p项。
• 飞机是驾驶员和的它前项。如果驾驶员在第二列，飞机还包括前一列的指数块。
• 乘客代表飞机中，除了驾驶员和副驾驶（如果有）外的所有项。

规则和线性数阵记号相同。没有阶规则是因为我们已经把阶融入到数阵中。

这里有个例子：

\begin{eqnarray*} \{3,3,3 (1) 2\} &=& \{3,\{3,2,3 (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,1,3 (1) 2\},2 (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,3,2 (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,2,2 (1) 2\},1 (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,2,2 (1) 2\} (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,\{3,1,2 (1) 2\},1 (1) 2\} (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,3 (1) 2\} (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,3,3 (1) 1\} (1) 2\},2 (1) 2\} \\ &=& \{3,\{3,\{3,3,3\} (1) 2\},2 (1) 2\} \end{eqnarray*}

更多列

最小的非平凡三列数阵为\(\{b, p (1) (1) 2\}\)，其中，第二列的项只有一个1（或多个）。正如你期望的，它等于\(\{b, b, \ldots, b, b (1) b, b, \ldots, b, b\}\)，其中每列有\(p\)项。驾驶员已经移到第三列，我们可以引入副驾驶，即\(\{b, p (1) (1) 1, 2\} = \{b, p (1) (1) \{b, p - 1 (1) (1) 1, 2\}\}\)。超过三列的也几乎相同，现在我们可以借此推广。

我们需要再次改变对飞机的定义：

• 飞机是驾驶员和它的前项，和前列的指数块。

当驾驶员在第一列，由于没有前行，飞机仅仅是驾驶员和前项。

现在，我们已经定义好了平面数阵记号。

三维

接著，我们将使用(2)来表示平面间的分隔符。最小的双平面数阵是\(\{b, p (2) 2\} = \{b, b, \ldots, b, b (1) b, b, \ldots, b, b (1) \ldots (1) b, b, \ldots b, b (1) b, b, \ldots, b, b\}\)，或由\(b\)构成的规格为\(p \times p\)的数阵。（也可以写为\(p^2 \& b\)）最后，我们将解决多平面数阵。

要继续推广，我们需要引进更抽象的术语。其中一个是结构，它可以是项、列或平面。以前的定义也略有改变：

• 列的指数块包含\(p\)项，平面的指数块包含成方形的\(p \times p\)项（或\(p\)列）。
• X的前项是在X那列、在X前的项。X的前列是在X的平面中、在X前的列。
• 飞机包含驾驶员、驾驶员的前项、和驾驶员前结构的指数块。

请仔细研究最后这定义，因为它是BEAF运作的核心部份。

四维和更多

无限个平面，或三维空间，鲍尔斯称之为“领域”；四维空间则为“福润”。其分隔符分别为(3)和(4)。

一般来说，(n)代表进入下一个n维空间。逗号是(0)的缩写，因为一项是一个0维空间。"结构"是任何n维空间；我们将标记n维结构为\(X^n\)。

让我们修改“结构”、“指数块”、“前结构”和“飞机”的定义。

• 结构是项、列、平面、领域、福润、5维空间等。
• 列的指数块为\(p\)项；平面的指数块为\(p \times p\)的方形；领域的指数块为\(p \times p \times p\)方块，等。整体来说，列的指数块为\(p\)项，\(X^n\)结构的指数块为\(p\) \(X^{n-1}\)结构。
• A的前结构为跟A在同个\(X^{n + 1}\)结构、在A前的\(X^n\)结构。具体来说，A的前项是跟A同列、在A前的项，A的前列是跟A同平面、在A前的列，等。
• 飞机包含驾驶员、前项、前结构的指数块。

到这里，我们已经定义了多维数阵记号。所有规则如下：

多维数阵记号

定义：

• 底数\(b\)为第一项。
• 指数\(p\)为第二项。
• 驾驶员为指数后第一个非1项。
• 副驾驶是驾驶员的前一项。如果驾驶员位在它那列的第一项，则副驾驶不存在。
• 结构是项、列、平面、领域、福润、5维空间等。
• 列的指数块为\(p\)项；平面的指数块为\(p \times p\)的方形；领域的指数块为\(p \times p \times p\)方块，等。整体来说，列的指数块为\(p\)项，\(X^n\)结构的指数块为\(p\) \(X^{n-1}\)结构。
• A的前结构为跟A在同个\(X^{n + 1}\)结构、在A前的\(X^n\)结构。具体来说，A的前项是跟A同列、在A前的项，A的前列是跟A同平面、在A前的列，等。
• 飞机包含驾驶员、前项、前结构的指数块。
• 乘客代表飞机中，除了驾驶员和副驾驶（如果有）外的所有项。

规则：

1. 基础规则：如果没有驾驶员（指数后的项均为1）则\(v(A) = b^p\)。
2. 指数规则；如果指数为1，\(v(A) = b\)。
3. 灾难规则：否则，
   1. 将副驾驶换成原数阵，但其指数减去1。
   2. 驾驶员减1。
   3. 所有乘客变为\(b\)。

(定义结束)

这就是“扩展数阵记号”，由鸟和鲍尔斯建构。原本有7个规则，但我们已经利用现代BEAF简化了它的规则。

数阵运算符

数阵运算符，记成&（别与程式中的“和”混淆），所输出的数阵，是由&右边的项，组成&左边的结构。什么结构？最简单的结构是数字，即\(n\ \&\ m = \{\underbrace{m,m,m,\cdots,m,m,m}_{\text{n m's}}\}\)。数字以上的结构，使用X结构来评估m。所以，\(X\ \&\ m = m \&\ m = \{m,m (1) 2\}\)。

如果想要指定其他数字，可以用方括号括起来：\(X\ \&\ a[b] = b\ \&\ a[b]\)。鲍尔斯还没有使用这种表示法。

X以上的结构是X+1,X+2,X+3,...,2X,2X+1,2X+2,2X+3,...,3X,4X,...,\(X^2\)，等。X+m可被认为是由原本的列和含m项的第二列组成的，2X为两列，3X为三列，nX+m由n列和它下面有m项的列组成。下面是刚刚的记号和一般数阵间的对比：

\begin{eqnarray*} 1\ \&\ n &=& \{n\} = n \\ 2\ \&\ n &=& \{n,n\} = n^n \\ 3\ \&\ n &=& \{n,n,n\} = n \uparrow^{n} n \\ 4\ \&\ n &=& \{n,n,n,n\} = n \underbrace{ \{\{\cdots\{\{n\}\}\cdots\}\} }_{n \{\}'s} n \\ m\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{m n's}}\} &=& \{n,m (1) 2\} \\ X\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}}\} &=& \{n,n (1) 2\} \\ X+1\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) n\} \\ X+2\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) n,n\} \\ X+3\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) n,n,n\} \\ X+m\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) \underbrace{n,n,n,\cdots,n,n,n}_{\text{m n's}}\} \\ 2X\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) \underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}}\} \\ 3X\ \&\ n &=& \{\underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) \underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}} (1) \underbrace{n,n,n,\cdots,n,n,n}_{\text{n n's}}\} \\ mX\ \&\ n &=& \{\underbrace{X\ \&\ n(1)X\ \&\ n(1)X\ \&\ n(1)\cdots(1)X\ \&\ n(1)X\ \&\ n(1)X\ \&\ n}_{\text{m X's}}\} &=& \{n,m (2) 2\} \\ X^2\ \&\ n &=& \{\underbrace{X\ \&\ n(1)X\ \&\ n(1)X\ \&\ n(1)\cdots(1)X\ \&\ n(1)X\ \&\ n(1)X\ \&\ n}_{\text{n X's}} &=& \{n,n (2) 2\} \end{eqnarray*}

可以发现，最后三个例子可以分别简化为\(\{n,3 (2) 2\}，\{n,m (2) 2\}\)和\(\{n,n (2) 2\}\)。这里的“2”分隔下一平面，也标记著3维数阵的开始。我们可以用多项式形式来表示多维数阵：表达式\(a_1X^m+a_2X^{m-1}+a_3X^{m-2}+\cdots+a_{m-1}X+a_m \&\ b[p]\)意味著数阵有\(a_1\)个\(X^m\)（b的m维阵列）、\(a_2\)个\(X^{m-1}\)、\(a_3\)个\(X^{m-2}\)，等等。总项数可以通过将X表达式中的X更换为p并计算来找到。如，\(X^{100}+X^{99} \&\ 3[4]\)有\(4^{100}+4^{99}\)项。

迭代幂次数阵

目前为止，我们已经达到\(f_{\omega^{\omega^\omega}}\)（FGH）的增长率。下一步不那么明显，但它是继续整个系统的关键。

\(\{b, p (0, 1) 2\}\)

这是什么意思？它代表\(X^X\)结构。另外，\(X^X\)结构的指数块是\(p^p\)结构，或是\(\underbrace{p \times p \times \cdots \times p \times p}_p\)超方形。所以它可以是2x2的正方形，或3x3x3的正方体，或4x4x4x4的超正方体，等。当需要实际解决数阵时，我们可以将(0, 1)替换为(p)：例如，\(\{b, 4 (0, 1) 2\} = \{b, 4 (4) 2\}\)。

Technical note: the space described by an \(X^X\) structure is called a dimensional group. In a dimensional group, each coordinate is described by a row of coordinates (order type \(\omega\)) rather than a fixed finite number.

\(\{b, p (1, 1) 2\}\)

This is an \(X^{X + 1}\) structure; its prime block is \(p^{p + 1}\). Generally, an \((n, m)\) separator creates an \(X^{mX + n}\) structure. It is a row of dimensional groups.

Linear separator arrays can describe all possible \(X^P\), where \(P\) is a polynomial in \(X\). (Here and in the rest of the article, we restrict "polynomial" to have nonnegative integer coefficients.) They do this by supplying a list of coefficients from degree 0 on:

\((a_0, a_1, a_2, a_3, \ldots)\) describes a structure of type \(X^{a_0 + a_1X + a_2X^2 + a_3X^3 + \cdots}\)

So, for example, (0, 0, 1) describes \(X^{X^2}\) (dimensional gang), and (1, 0, 6, 1) describes \(X^{1 + 6X^2 + X^3}\). You will notice that now zeroes are the default rather than 1's; this is one of BEAF's more annoying properties.

\(\{b, p (0 (1) 1) 2\} = \{b, p ((1) 1) 2\}\)

Of course, we have no reason to stop at linear arrays for separators. This structure is \(X^{X^X}\), a superdimensional group. (Vectors in a superdimensional group have order type \(\omega^\omega\).) In general for the second row,

\((a_{00}, a_{01}, a_{02}, \ldots (1) a_{10}, a_{11}, a_{12}, \ldots )\) describes a structure of type \(X^{a_{00} + a_{01}X + a_{02}X^2 + a_{03}X^3 + \cdots + a_{10}X^X + a_{11}X^{X + 1} + a_{12}X^{X + 2} + \ldots}\).

The third row ((1)(1)1) describes \(X^{X^{2X}}\) (no, we're not at \(X^{X^{X^X}}\) yet!), and the (n + 1)-th row describes \(X^{X^{nX}}\). The second plane ((2)1) is \(X^{X^{X^2}}\), the second realm ((3)1) is \(X^{X^{X^3}}\), and so on and so forth. We finally reach \(X^{X^{X^X}} = X \uparrow\uparrow 4\) at the second dimensional group, ((0, 1) 1). The inner pair of parentheses describes a polynomial \(P\) in \(X\), with the outer one describing \(X^{X^{X^P}}\).

\(\{b, p (((1) 1) 1) 2\}\)

This is \(X^{X^{X^{X^X}}} = X \uparrow\uparrow 5\).

\(\{b, p (((0, 1) 1) 1) 2\}\) describes \(X \uparrow\uparrow 6\)

\(\{b, p ((((1) 1) 1) 1) 2\}\) describes \(X \uparrow\uparrow 7\)

\(\{b, p ((((0, 1) 1) 1) 1) 2\}\) describes \(X \uparrow\uparrow 8\)

etc.

The limit of all this is the \(X \uparrow\uparrow X\) structure. If we stop here, we have tetrational array notation.

Attempt at definition

Bowers never bothered to formalize tetrational arrays, but we'll give it a try. The only thing holding us back right now is the definition of prime blocks, which is specifically tailored for dimensional arrays only. Let's look at our current inductive definition:

• The prime block of an entry is an entry.
• The prime block of an \(X^{n + 1}\) structure is the prime blocks of its first \(p\) \(X^n\)-structures.

(There is a slight change here, but it can be seen that it has minimal effect.) This definition doesn't say what happens when our structure is an \(X^X\) structure, because it's not a structure of the form \(X^{n + 1}\).

Let's try to extend this definition to allow all \(X^P\) for degree-1 polynomials \(P\).

• The prime block of an entry is an entry.
• The prime block of an \(X^{P+1}\) structure is the prime blocks of its first \(p\) \(X^P\)-structures, where \(P\) is a polynomial in \(X\).
• The prime block of an \(X^{P+X}\) structure is the prime block of its first \(X^{P + p}\)-structure.

This breaks down at \(X^{X^2}\) as expected, but there is a pattern emerging.

• The prime block of an entry is an entry.
• The prime block of an \(X^{P + 1}\) structure is the prime blocks of its first \(p\) \(X^P\)-structures, where \(P\) is a polynomial in \(X\).
• The prime block of an \(X^{P + X}\) structure is the prime block of its first \(X^{P + p}\)-structure.
• The prime block of an \(X^{P + X^2}\) structure is the prime block of its first \(X^{P + pX}\)-structure.
• The prime block of an \(X^{P + X^3}\) structure is the prime block of its first \(X^{P + pX^2}\)-structure.
• In general, the prime block of an \(X^{P + X^{n + 1}}\) structure is the prime block of its first \(X^{P + pX^n}\)-structure.

This works up until \(X^{X^X}\). At this rate we'll never get to \(X \uparrow\uparrow X\)!

Second attempt

Let's generalize the concept of "structure" to help out our definition.

• \(0\) is a structure.
• If \(\alpha\) is a structure, \(X^\alpha\) is also a structure.
• If \(\alpha\) and \(\beta\) are structures, \(\alpha + \beta\) is also a structure.

This allows things like \(2X\) and \(4X^X + X + 1\), and works up until our limit of \(X \uparrow\uparrow X\). Furthermore, let's define a limit structure as one of the form \(X^\alpha\) for \(\alpha > 0\) or \(\alpha+\beta\) for \(\alpha\) and \(\beta\) being limit structures, and a successor structure as one of the form \(\alpha + 1\).

Now we'll recursively define the prime block of a structure \(\alpha[p]\).

• \(0[p] = \{\}\)
• \((\alpha + 1)[p] = \alpha[p] \cup \{\text{the last entry of }\alpha + 1\}\)
• \(X[p] = p\) and \(X^{\alpha + 1}[p] = X^{\alpha} p\)
• \(X^{\alpha}[p] = X^{\alpha[p]}\) if and only if \(\alpha\) is a limit structure.
• \((X^{\alpha_1} + X^{\alpha_2} + \cdots + X^{\alpha_{k - 1}} + X^{\alpha_k})[p] = (X^{\alpha_1} + X^{\alpha_2} + \cdots + X^{\alpha_{k - 1}} )[p] \cup X^{\alpha_k}[p])\) where \(\alpha_k\) is the smallest \(\alpha_i\)
• \(X\uparrow\uparrow X[0] = 1\) and \(X\uparrow\uparrow X[p] = X^{X\uparrow\uparrow X[p-1]}\)

If you are confused by now, skip it. All you need an intuitive conception of how this works.

There's one final step. Notice how we used the word "smallest" in the definition above, but structures aren't numbers and we haven't yet defined an ordering. This is easy:

• \(\alpha < \alpha + X^0\)
• \(X^\alpha < X^\beta\) iff \(\alpha < \beta\)
• \(\alpha + \gamma < \beta + \gamma\) iff \(\alpha < \beta\)

And we're done! Tetrational arrays.

But can we make this simpler?

As ordinals (advanced)

Some of our more experienced readers may notice the parallels to ordinal hierarchies. \(X\) functions a lot like \(\omega\), and our prime block definition looks like that of the Wainer hierarchy — we picked the \(\alpha[p]\) notation for a reason. We have developed a notation for ordinals up to \(\varepsilon_0\), which is also the strength of BEAF up to this point. It seems reasonable to rewrite our notation using ordinals, and we'll do just that.

We'll define an array as a function \(A : \varepsilon_0 \mapsto \mathbb{N}_+\), where the number of outputs greater than 1 is finite. (This prevents infinite arrays like {6, 6, 6, ...}.) Let \(b = A(0)\), \(p = A(1)\), \(\pi = \min\{\alpha > 1: A(\alpha) > 1\}\) (the position of the pilot), and \(\kappa = \pi - 1\) (the position of the copilot).

Define the prime block \(\Pi(\alpha)\):

• \(\Pi(0) = \{\}\)
• \(\Pi(\alpha + 1) = \{\alpha\} \cup \Pi(\alpha)\)
• \(\Pi(\alpha) = \Pi(\alpha[p])\) if \(\alpha\) is a limit ordinal

(This looks a lot like the slow-growing hierarchy.) Define the passengers as \(S = \Pi(\pi) \backslash \{\pi, \kappa\}\).

And the three rules:

1. Base rule. If \(\pi\) does not exist, \(v(A) = b^p\).
2. Prime rule. If \(p = 1\), \(v(A) = b\).
3. Catastrophic rule. Define \(A'\) as \(A\) with the following modifications:
   • Define \(B\) as \(A\), but with \(B(1) = p - 1\).
   • If \(\kappa\) exists, \(A'(\kappa) := v(B)\).
   • \(A'(\pi) = A(\pi) - 1\).
   • \(A(\sigma) := b\) for \(\sigma \in S\).
   • \(v(A) = v(A')\).

Although less accessible, this is a far simpler definition than above!

One more thing; let's define some fundamental sequences for ordinals below \(\varepsilon_0\).

• \(\omega^\alpha[n] = \omega^{\alpha[n]}\) for limit ordinals \(\alpha\)
• \(\omega^{\alpha + 1}[n] = \omega^\alpha n\)
• \((\omega^{\alpha_1} + \omega^{\alpha_2} + \cdots + \omega^{\alpha_k})[n] = \omega^{\alpha_1} + \omega^{\alpha_2} + \cdots + \omega^{\alpha_k}[n]\) where \(\alpha_1 \geq \alpha_2 \geq \cdots \geq \alpha_k\)
• \(\omega \uparrow\uparrow 0 = 1\)
• \((\omega \uparrow\uparrow (\alpha + 1))[n] = \omega^{\omega \uparrow\uparrow \alpha}[n]\)

We threw in a definition of \(\omega \uparrow\uparrow n\) to ensure that we properly mirror Bowers' \(X\) hierarchy. Indeed, after \(\varepsilon_0\) the fundamental sequences depart a bit from the usual.

Pentational arrays

Pentational arrays are a bit of a mindblow. By far the worst part is that no notation has yet been devised to support them! Bowers never bothered to put one together; he just used the array of operator.

Remember the array of operator?

\(a \& b = \{b, a (1) 2\}\)

We left it behind long ago in the single-row era. Turns out, & has an extension that allows use beyond this level.

\(a^2 \& b = \{b, a (2) 2\}\)

It's not hard to see that the right-hand side is an a by a array of b's, or an a² array of b's. Note that the expression "\(a^2\)" should not be solved first; rather it is a blueprint for the dimensions of the array.

\(a^k \& b = \{b, a (k) 2\}\)

In general, the array-of operator lets us specify many dimensions, and even tetrational arrays such as this one:

\(a^{a^a} \& b = a \uparrow\uparrow 3 \& b = \{b, a ((1) 1) 2\}\)

For those who understood the ordinal definition above, we can formally define \(f(a) \& b = \{0 \mapsto b, 1 \mapsto a, f(\omega) \mapsto 2\}\).

The smallest pentational array is this one:

\((a \uparrow\uparrow a) \& b = \{b, a (???) 2\}\)

There is no notation for this array (an \(X \uparrow\uparrow X\) structure), but it's certainly definable with ordinals, where \(\omega \uparrow\uparrow \omega = \varepsilon_0\) using the fundamental sequence \(\varepsilon_0[n] = \omega \uparrow\uparrow n\). We'll take a moment to apologize to the readers who don't get ordinals yet. Skip ahead to the legion arrays if you're one of them.

At this point you may be wondering what \(X \uparrow\uparrow\uparrow X\) is, but we can't move on to that until we've defined \(X \uparrow\uparrow (X2)\) or the fundamental sequence of "\(\omega \uparrow\uparrow (\omega2)\)". Our current definition of \(\uparrow\uparrow\) over the ordinals would make \(\omega \uparrow\uparrow (\omega2) = \omega \uparrow\uparrow \omega\), so we need to repair that.

If we amend our definition to \(\omega \uparrow\uparrow (1 + \alpha) = \omega^{\omega \uparrow\uparrow \alpha}\), we can clearly see that \(\omega \uparrow\uparrow (1 + \omega) = \omega \uparrow\uparrow \omega\) is the fixed point of the function \(\alpha \mapsto \omega^\alpha\).

\(\omega \uparrow\uparrow (\omega2)\) should be the next fixed point, i.e. \(\varepsilon_1\). One particularly clean definition of \(\varepsilon_1\) is the limit of \(\varepsilon_0, \varepsilon_0^{\varepsilon_0}, \varepsilon_0^{\varepsilon_0^{\varepsilon_0}}, \ldots\), so why not make \(\varepsilon_1 = \varepsilon_0 \uparrow\uparrow \omega = (\omega \uparrow\uparrow \omega) \uparrow\uparrow \omega\)? This seems slightly odd at first, since in general \(a \uparrow\uparrow a2 \neq (a \uparrow\uparrow a) \uparrow\uparrow a\). Ordinals work in mysterious ways.

The next fixed point is \(\omega \uparrow\uparrow (\omega3) = \varepsilon_1 \uparrow\uparrow \omega = \varepsilon_2\), and in general \(\omega \uparrow\uparrow (\omega n) = \varepsilon_{n - 2} \uparrow\uparrow \omega = \varepsilon_{n-1}\) for finite \(n > 0\). Understandably, the limit of all these is \(\omega \uparrow\uparrow (\omega^2) = \varepsilon_\omega\).

Yada yada yada. Nothing too interesting here until \(\varepsilon_{\varepsilon_0} = \omega \uparrow\uparrow (\omega \uparrow\uparrow \omega) = \omega \uparrow\uparrow\uparrow 3\) an \(\varepsilon_{\varepsilon_{\varepsilon_0}} = \omega \uparrow\uparrow\uparrow 4\). The triple arrows are quite promising, and indeed the limit of all this is \(\zeta_0 = \omega \uparrow\uparrow\uparrow \omega\). Boom. Done.

Formal definition

Good news: formalizing this is just a matter of defining some functions over the ordinals and the fundamental sequences they create. Arrow notation is not part of standard ordinal arithmetic, so we have to define it ourselves:

• \(\alpha \uparrow\uparrow 0 = 1\)
• \(\alpha \uparrow\uparrow (n + 1) = \alpha^{\alpha \uparrow\uparrow n}\) for \(n < \omega\)
• \(\alpha \uparrow\uparrow \beta = \bigcup\{\gamma < \beta : \alpha \uparrow\uparrow \gamma\}\) for limit ordinals \(\beta\)
• \(\alpha \uparrow^{k} (\beta + \omega) = lim\{(\alpha \uparrow^k \beta),(\alpha \uparrow^k \beta)^{(\alpha \uparrow^k \beta)},(\alpha \uparrow^k \beta)^{(\alpha \uparrow^k \beta)^{(\alpha \uparrow^k \beta)}},...\}\) for \(\beta \geq \omega\)
• \((\alpha \uparrow\uparrow \beta)[n] = \alpha \uparrow\uparrow \beta[n]\)

Further sublegion arrays

We ended the last section with \(\zeta_0 = \omega \uparrow\uparrow\uparrow \omega\). We can also write \(\omega \uparrow\uparrow\uparrow \omega = \{\omega, \omega, 3\}\), and what's to stop us from defining \(\{\omega, \omega, 4\}\)? Or \(\{\omega, \omega, 1, 2\}\)? Or \(\{\omega, \omega (0, 1) 2\}\)?

The only barrier is formality: we need to define BEAF for ordinals. We'll start off with arrow notation for a finite number of arrows:

• \(\alpha \uparrow \beta = \alpha^\beta\)
• \(\alpha \uparrow^k 0 = 1\)
• \(\alpha \uparrow^{k + 1} (n + 1) = \alpha \uparrow^k (\alpha \uparrow^{k + 1} n)\) for \(n < \omega\)
• \(\alpha \uparrow^k \beta = \sup\{\gamma < \beta : \alpha \uparrow^k \gamma\}\) for limit ordinals \(\beta\)
• \(\alpha \uparrow^{k} (\beta + \omega) = lim\{(\alpha \uparrow^k \beta),(\alpha \uparrow^k \beta)\uparrow^{k-1}(\alpha \uparrow^k \beta),(\alpha \uparrow^k \beta)\uparrow^{k-1}(\alpha \uparrow^k \beta))\uparrow^{k-1}(\alpha \uparrow^k \beta),...\} \) for \(\beta \geq \omega\)
• \((\alpha \uparrow^k \beta)[n] = \alpha \uparrow^k \beta[n]\)

It's not hard to see that ordinal arrow notation is similar to the Veblen function, and the differences are mostly in the fundamental hierarchies. Analogous to the Veblen unction, \(\alpha \mapsto \omega \uparrow^{k + 1} (\omega + \alpha)\) enumerates the fixed points of \(\alpha \mapsto \omega \uparrow^k \alpha\).

Already this definition is mildly annoying due to the sheer number of rules. Anyways, let's try \(k = \omega\):

• \(\alpha \uparrow^\omega \beta = \sup\{k < \omega : \alpha \uparrow^k \beta\}\)
• \((\alpha \uparrow^\omega \beta)[n] = \alpha \uparrow^n \beta\)

Take note that \(\omega \uparrow^\omega \omega = \phi_\omega(0)\). Our existing framework works for successor ordinals \(k\), but we need some limits here:

• \(\alpha \uparrow^\kappa \beta = \sup\{\gamma < \kappa : \alpha \uparrow^\gamma \beta\}\)
• \((\alpha \uparrow^\kappa \beta)[n] = \alpha \uparrow^{\kappa[n]} \beta\)

Putting it all together:

• \(\alpha \uparrow \beta = \alpha^\beta\)
• \(\alpha \uparrow^\kappa 0 = 1\)
• \(\alpha \uparrow^{\kappa + 1} (n + 1) = \alpha \uparrow^\kappa (\alpha \uparrow^{\kappa + 1} n)\) for \(n < \omega\)
• \(\alpha \uparrow^\kappa (\beta + 1) = (\alpha \uparrow^\kappa \beta) \uparrow^\kappa \alpha\) for \(\beta \geq \omega\)
• \(\alpha \uparrow^\kappa \beta = \sup\{\gamma < \kappa : \alpha \uparrow^\gamma \beta\}\) for limit ordinals \(\kappa\)
• \(\alpha \uparrow^\kappa \beta = \sup\{\gamma < \beta : \alpha \uparrow^\kappa \gamma\}\) for limit ordinals \(\beta\)
• \((\alpha \uparrow^\kappa \beta)[n] = \alpha \uparrow^{\kappa[n]} \beta\) for limit ordinals \(\kappa\)
• \((\alpha \uparrow^\kappa \beta)[n] = \alpha \uparrow^\kappa \beta[n]\) for limit ordinals \(\beta\)

This definition works okay, but the last two pairs of rules have identical conditions. In the case of \((\omega \uparrow^\omega \omega)[n]\), we'd rather have \(\omega \uparrow^n \omega\), so if \(\kappa\) and \(\beta\) are limit ordinals, we should focus on \(\kappa\) first.

In the meantime, let's write this out as three-entry array notation. This is ordinary three-entry notation with some limit ordinal cases. To simplify things, we won't allow any of the entries to be 0 as with ordinary array notation.

• \(\{a, b, 1\} = a^b\)
• \(\{a, 1, c\} = a\)
• \(\{a, b + 1, c + 1\} = \{a, \{a, b, c + 1\}, c\}\) for \(b < \omega\)
• \(\{a, b + 1, c\} = \{\{a, b, c\}, a, c\}\) for \(b \geq \omega\)
• \(\{a, b, c\} = \sup\{x < c: \{a, b + 1, x\}\}\) for \(c \in \text{Lim}\)
• \(\{a, b, c + 1\} = \sup\{x < b: \{a, b + 1, c + 1\}\}\) for \(b \in \text{Lim}\)
• \(\{a, b, c\}[n] = \{a, b, c[n]\}\) for \(c \in \text{Lim}\)
• \(\{a, b, c + 1\}[n] = \{a, b[n], c + 1\}\) for \(b \in \text{Lim}\)

Where \(\text{Lim}\) is set of all limit ordinals.

We can also remove the fourth and fifth rules if we define them as the limits of the sixth and seventh rules, respectively.

Now for four entries:

• \(\{a, b, 1, 1\} = a^b\)
• \(\{a, 1, c, d\} = a\)
• \(b < \omega:\)
  • \(\{a, b + 1, 1, d + 1\} = \{a, \{a, b, 1, d + 1\}, 1, d\}\)
  • \(\{a, b + 1, c + 1, d\} = \{a, \{a, b, c + 1, d\}, c, d\}\)
• \(b > \omega:\)
  • \(\{a, b + 1, c, d\} = \{\{a, b, c, d\}, a, c, d\}\)
• \(\{a, b, c, d\}[n] = \{a, b, c, d[n]\}\) for \(d \in \text{Lim}\)
• \(\{a, b, c, d + 1\}[n] = \{a, b, c[n], d + 1\}\) for \(c \in \text{Lim}\)
• \(\{a, b, c + 1, d + 1\}[n] = \{a, b[n], c + 1, d + 1\}\) for \(b \in \text{Lim}\)

Generalization is easy from here.

Linear ordinal array notation

Definitions are unchanged — the first entry is the base \(b\), the second entry is the prime \(p\), the first non-1 entry after the prime is the pilot, the entry before it is the copilot, and the passengers are all entries before the copilot. In addition, we'll define the limiter \(l\) as the last limit ordinal after the base; it may not exist if there are only successor ordinals from the prime on.

All entries are between zero and \(\omega_1\) exclusive.

1. Base rule. If there is no pilot, \(v(A) = b^p\).
2. Prime rule. If \(p = 1\), \(v(A) = b\).
3. Catastrophic rule. If there is no limiter and \(p < \omega\)...
   1. Replace the copilot with a copy of the array with the prime decreased by 1. (The prime must be a successor ordinal, otherwise there would be a limiter.)
   2. Decrease the pilot by 1.
   3. Set all the passengers to \(b\).
4. Infinite catastrophic rule. If there is no limiter and \(p \geq \omega\)...
   1. Replace the base with a copy of the array with the prime decreased by 1. (The prime must be a successor ordinal, otherwise there would be a limiter.)
   2. Set the prime to the original value of \(b\).
5. Limit rule. Otherwise...
   1. Let \(v(A)[n]\) be the value of the array with the limiter changed to \(l[n]\).
   2. \(v(A) = \sup\{1 \leq n < \omega : v(A)[n]\}\).

(end of definition)

Of course, we have no reason to stop at linear arrays. Our tetrational BEAF easily extends to ordinals; we just need to throw in the limit rule, and expand the domain of \(A\) from \(\varepsilon_0\) to \(\omega_1\), the first ordinal without a fundamental sequence with countable length. We'll prohibit ourselves from just plugging in any large countable ordinal, since we're building from the ground up and using BEAF to define the ordinals as we go along.

By the way, what ordinals have we defined? Quite a few.

• \(\Gamma_0 = \{\omega, \omega, 1, 2\}\) (expandal arrays)
• \(\vartheta(\Omega^2) = \{\omega, \omega, 1, 1, 2\}\)
• \(\vartheta(\Omega^\omega) = \{\omega, \omega (1) 2\}\)
• \(\vartheta(\Omega^\Omega) = \{\omega, \omega, 2 (1) 2\}\)
• \(\vartheta(\varepsilon_{\Omega + 1}) = \{\omega, \omega (\varepsilon_0) 2\}\)

The limit of our notation at the moment is \(\vartheta(\Omega_\omega)\). This is quite an accomplishment!

Legion arrays

Thank you, non-ordinal readers, for waiting this long! Up to now we have what could be called "sublegion BEAF." Bowers called everything up to this point "L-space."

We're resurrecting the array of operator & again. As our notations get more and more powerful, so does &: by now we have a good definition for things such as {3, 3, 3}&3 (triakulus), a pentational array. The array of operator will always be able to diagonalize over our most powerful notations.

Note that we can also write triakulus as (3&3)&3, and we'll make the operator left-associative so we can get rid of parentheses as in 3&3&3. This naturally invites an operator, b♦p = b&b&...&b&b p times. This operator expresses the limit of sublegion BEAF; it's the most powerful function we've defined so far. Note that the ♦ notation hasn't been used by Bowers himself.

\(b♦p\) reminds us a bit of \(b^p\), so let's use the same trick we did far back in two-row arrays. We can make this "second-order sublegion BEAF" by redefining the base rule to \(b♦p\).

As we did with two-row array notation, we could keep expanding higher-order sublegion BEAF until we need to merge the order into the array. We'll cut to the chase and immediately put the order into the array.

\(\{b, p / 2\} = b♦p\)

The slash separator marks off a new kind of space called legion space. The pilot 2 is in the second legion, in the same way that we moved the pilot to the second row way back in planar array notation. The prime block of a legion is \(b♦p\), so for example \(\{b, p / 3\} = \{b♦p / 2\}\).

\(\{b, p / 1, 2\} = \{b♦p / \{b, p - 1 / 2\}\}\)

Legions form a larger space than rows, planes, or any structure we've defined so far, so we can put multiple entries in the second legion.

\(\{b, p / 1 / 2\} = \{b♦p / b♦p\}\)

We can also throw in more than two legions...

\(\{b, p (/1) 2\} = \{b♦p / b♦p / \ldots / b♦p / b♦p\}\) with \(p\) legions

\(\{b, p (/0,1) 2\} = \{b♦p / b♦p / \ldots / b♦p / b♦p\}\) where the legions form a \(p^p\) structure

...and the legions themselves can take on dimensional structures of any size.

Another notation for \(\{b, p (/1) 2\} = \{b♦p / b♦p / \ldots / b♦p / b♦p\}\) is \(p \&\& b\), or p legion array of b. Similarly, \(\{b, p (/(1)1) 2\} = p^p \&\& b\), so the && operator works similarly to & but with legions instead of entries. We'll use b♦♦p to mean b&&b&&..&&b&&b p times, and we'll introduce "legion legion space" using the separator \(//\).

\(\{b, p // 2\} = b♦♦p = b \&\& b \&\& \ldots \&\& b \&\& b\)

\(\{b, p (//1) 2\} = \{b♦♦p / b♦♦p / \ldots / b♦♦p / b♦♦p\} = b \&\&\& p\)

\(\{b, p /^n 2\} = b♦^np = b \&^n b \&^n \ldots \&^n b \&^n b\)

\(\{b, p (/^n1) 2\} = \{b♦^np / b♦^np / \ldots / b♦^np / b♦^np\} = b \&^{n + 1} p\)

Extension is straightforward.

\(\{b, p (1)/ 2\} = \{b, p /^p 2\} = b (1)\& p\)

\(\{b, p ///(1)///(1)/// 2\}\)

Why not give the legions a multidimensional structure themselves? Trouble is, we need to define this. Let L be a legion structure, which is greater than all structures up to but not including legions. (So L is a legion in the same way that X is a row.) We could say that L = {X, X / 2}, but that's uncomfortably circular. Anyways, the prime block of a legion is \(b♦p\).

Two legions is a \(2L\) structure, a row of legions is an \(XL\) structure, a legion legion // is an \(L^2\) structure. From here we can put L inside an array the same way we wrote things such as {X, X, X}. We can write \(\{L, L\}\) or \(\{L, L, L\}\) or \(\{L, X (1) 2\} = X\&L\). Unfortunately, by this time we have no notation for separators, but Bowers supplied the notation \(\{L, L\}_{b, p}\) (say) to mean an \(\{L, L\}\) structure solved with b as the base and p as the prime.

We continue to drop L into larger and larger arrays until we reach the landmark \(\{L, L / 2\}\), or lugion space. Bowers also writes this \(L2\) using the separator \ and the operator \(a@b\), or a legiattic array of b.

Formalization

We will quickly catch up on the definition of legion arrays with ordinals. First, we'll notice that the array-of operator has three parts: a base, prime, and structure type. For example, \(3\&4\) has base 4, prime 3, and structure type X, and \(3 \uparrow\uparrow\uparrow 4 \& 5\) has base 5, prime 3, and structure type \(X \uparrow\uparrow\uparrow 4\). Bowers' minor abuse of notation can be mended with a three-argument array-of operator:

\(\lambda(b, p, \xi) = \{(0, b), (1, p), (\xi, 2)\}\)

That is, base \(b\), prime \(p\), and the number 2 in position \(\xi\). Normally \(\xi\) is a limit ordinal, but our new function allows any \(\xi > 1\).

The ordinal for legion space is the unnamed ordinal \(\vartheta(\Omega_\omega) = \{\omega, \omega / 2\}\), and its fundamental sequence is \(\vartheta(\Omega_\omega)[1] = \omega,\,\vartheta(\Omega_\omega)[2] = \lambda(\omega, \omega, \omega),\,\vartheta(\Omega_\omega)[3] = \lambda(\omega, \omega, \lambda(\omega, \omega, \omega)),\) and so and so forth. This defines the prime block of a \(\vartheta(\Omega_\omega)\) structure as defined before.

External links

• 3 entry arrays
• 4 entry arrays
• The World's Largest Numbers, Part One @ Things Of Interest (linear arrays)
• The World's Largest Numbers, Part Two @ Things Of Interest (planar arrays)
• Linear array notation