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\)

我們應該允許任意個參數的代入，並整理出規則。為了簡潔性，我們會引入一些術語。第一項\(a\)是底數，而第二項\(b\)是指數。在指數後，第一個非1項是駕駛員；它前面的項是副駕駛，再前面的所有項則是乘客。數陣的值被寫成\(v(A)\)。使用這些術語，我們可以描述出線性數陣記號。

線性數陣記號

設\(b\)為底數，\(p\)為指數。

基礎規則：如果沒有駕駛員（即指數後的項均為1），則\(v(A) = b^p\)。
指數規則：如果指數為1，\(v(A) = b\)。
災難規則：否則，
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），則\(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\)階數陣記號相關的新規則：

基礎規則：如果沒有駕駛員、且\(r = 1\)，則\(v(A) = b^p\)。
階規則：如果沒有駕駛員、且\(r > 1\)，則\(v(A) = p \&_{r - 1} b\)。
指數規則和災難規則不變。

那麼，如何發揮這個擴展的最大優勢？答案就是，讓\(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*}

三維[]

接著，我們將使用(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）則\(v(A) = b^p\)。
指數規則；如果指數為1，\(v(A) = b\)。
災難規則：否則，
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:

Base rule. If \(\pi\) does not exist, \(v(A) = b^p\).
Prime rule. If \(p = 1\), \(v(A) = b\).
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.

Base rule. If there is no pilot, \(v(A) = b^p\).
Prime rule. If \(p = 1\), \(v(A) = b\).
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\).
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\).
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