Bird's array notation | |
---|---|

Type | Hyperdimensional |

Growth rate | \(f_{\vartheta(\Omega_\Omega)}(n)\) |

**Bird's array notation** is a googological notation invented by Chris Bird. It is an extension of Jonathan Bowers' Extended Array Notation, and is akin to BEAF both in its history and its definition.

## Contents

## "Simple" arrays

### Linear and multidimensional arrays

For linear and multidimensional arrays, BAN is the same as BEAF.

**Rule 1**. With one or two entries, we have \(\{a\} = a\), \(\{a,b\} = a^b\) (by the way, \(\lbrace a \rbrace = a\) follows from \(\{a,b\} = a^b\), since \(\{a\} = \{a,1\} = a^1 = a\) (inverse of rule 2)).**Rule 2**. If the last entry is 1, it can be removed: \(\{\# 1\} = \{\#\}\). (The octothorpe indicates the unchanged remainder of the array.)**Rule 3**. If the second entry is 1, the value is just the first entry: \(\{a,1 \#\} = a\).**Rule 4**. If the third entry is 1:- \(\{a,b,1,1,\cdots,1,1,c \#\} = \{a,a,a,a,\cdots,a,\{a,b-1,1,1,\cdots,1,1,c \#\},c-1 \#\}\)

**Rule 5**. Otherwise:- \(\{a,b,c \#\} = \{a,\{a,b-1,c \#\},c-1 \#\}\)

With multidimensional arrays, Bird uses \(\textrm` a \langle c \rangle b \textrm'\), which is equivalent to Bowers' \(b^c \& a\). These strings are written within the quote signs and have their own specific rules:

**Rule A1**. If \(c = 0\), we have \(\textrm` a \langle 0 \rangle b = a \textrm'\).**Rule A2**. If \(b = 1\), we have \(\textrm` a \langle c \rangle 1 = a \textrm'\).**Rule A3**. Otherwise, \(\textrm` a \langle c \rangle b \textrm' = \textrm` a \langle c - 1 \rangle b [c] a \langle c \rangle (b - 1) \textrm'\).

The main rules are:

**Rule M1**. If there are only two entries, \(\{a, b\} = a^b\).**Rule M2**. If \([m] < [n]\), we have \(\{\# [m] 1 [n] \#\} = \{\# [n] \#\}\). (This also removes ones from the end of an array.)**Rule M3**. If the second entry is 1, we have \(\{a,1 \#\} = a\).**Rule M4**. If there is a non-zero entry immediately after batch of unfilled separators:- \(\{a,b [m_1] 1 [m_2] \cdots 1 [m_x] c \#\} = \{a \langle m_1-1 \rangle b [m_1] a \langle m_2-1 \rangle b [m_2] \cdots a \langle m_x-1 \rangle b [m_x] (c-1) \#\}\)

**Rule M5**. If there is a non-zero entry after batch of unfilled separators and a 1.- \(\{a,b [m_1] 1 [m_2] \cdots 1 [m_x] 1,c \#\} =\)

\(\{a \langle m_1-1 \rangle b [m_1] a \langle m_2-1 \rangle b [m_2] \cdots a \langle m_x-1 \rangle b [m_x] \{a,b-1 [m_1] 1 [m_2] \cdots 1 [m_x] 1,c \#\},c-1 \#\}\)

**Rule M6**. Rules M1-M5 don't apply.- \(\{a,b,c \#\} = \{a,\{a,b-1,c \#\},c-1 \#\}\)

For example, \(\{3,3 [3] 1 [2] 1,1,1,4\}\) = \(\{3 \langle 2 \rangle 3 [3] 3 \langle 1 \rangle 3 [2] 3,3,\{3,2 [3] 1 [2] 1,1,1,4\},3\}\)

Bird uses \([m]\) as a dimensional separator; in Bowers' notation it is equivalent to an \((m - 1)\) separator. This resolves a minor issue in BEAF, where ones are default in the array and zeroes are default in the separators.

In the fast-growing hierarchy, linear and multidimensional array notations have limit ordinals \(\omega^\omega\) and \(\omega^{\omega^\omega}\), respectively.

### Hyperdimensional and nested arrays

Next, the bracket separators become arrays (such as \([1, 1, 2]\)). Rules M1 to M6 remain unchanged, except that we replace the \([m_n]\) with \([m_n \#]\).

The angle bracket rules require some modification. Rule A3 becomes A4, and a new rule A3 is created:

**Rule A3**. If the first entry in the angle brackets is zero, and there exists a non-zero entry after it:- \(\textrm` a \langle 0,1,1,\cdots,1,1,c \# \rangle b \textrm' = \textrm` a \langle b,b,b,\cdots,b,b,c-1 \# \rangle b \textrm'\)

This rule is visually similar to the Rule M4.

The next step is to allow strings inside arrays and thereby define nested array notation. Rule A3 becomes A4 and A4 becomes A5. We then add a new A3 and generalize A4:

**Rule A3**. If \([A] < [B]\), \(\textrm` a <\# [A] 1 [B] \#^*> b \textrm' = \textrm` a <\# [B] \#^*> b \textrm'\).**Rule A4**. If the first entry in the angle brackets is zero, and there exists a non-zero entry after it:

A_{n} and B are arrays and A_{i}-1 is identical to A_{i}, except the first entry is reduced by one.

#### Algorithm for ranking two separators

For rules A3 and M2, it is important to determine what separator has higher level. First, let the number of arrays that nested one another is the nested level of array. We can notate that Lev(A). For example, A = \(\{3,3 [1 [1 [2] 2] 2] 2\}\), then Lev(A) = 3, since there [2] nested in [1 [2] 2], which is nested in [1 [1 [2] 2] 2], which is nested in the main array. Informally speaking, Lev(A) is the number that we need to say "nested" to get to main array. The other function, Num(H,A) is defined to be number of separators [H] in the array A, e.g. A = \(\{3,3 [1 [2] 1 [2] 1 [2] 2] 2\}\), then Num(2,A) = 3.

Suppose we want to determine what separator has higher level, [A] or [B]. Formally, it can be described as follows:

- For the further purposes, let [A
_{1}]=[A], [A_{2}]=[A_{1}] and [B_{1}]=[B], [B_{2}]=[B_{1}]. - If Lev(A)>Lev(B), then conclude that [A]>[B], if Lev(A)<Lev(B), then [A]<[B]. If Lev(A)=Lev(B)>0, then go to step 3, otherwise go to step 6.
- Let [A*] and [B*] are highest ranking separators in the arrays A
_{2}and B_{2}respectively. If [A*]>[B*] then [A]>[B], if [A*]<[B*] then [A]<[B], otherwise take [H]=[A*]=[B*] and go to step 4. - If Num(H,A
_{2})>Num(H,B_{2}), then [A]>[B], if Num(A)>Num(B), if Num(H,A_{2})<Num(H,B_{2}), then [A]<[B], otherwise go to step 5. - In strings A
_{2}and B_{2}, delete [H] separator and remove all entries before it. - Under all rules above, the strings A
_{2}and B_{2}must be in form [a] and [b], where a and b are single numbers. So, if [a]<[b], then [A]<[B], if [a]>[b], then [A]>[B], otherwise go to step 7. - In the strings A
_{1}and B_{1}remove the very last entry and separator before it. If A_{1}and B_{1}are empty, then we conclude that [A]=[B], otherwise return to step 2.

## Hyper-Nested Arrays

### Backslash arrays

To continue beyond Nested Array Notation, Bird defined a special separator, [1 \ c], as follows:

- \(\{a,b [1 \backslash c \#] 2\} = \{a \langle 0 \backslash c \# \rangle b\} =\)

\(\{a \langle b \langle b \langle b \langle \cdots b \langle b \backslash c-1 \# \rangle b \backslash c-1 \# \cdots \rangle b \backslash c-1 \# \rangle b \backslash c-1 \# \rangle b \backslash c-1 \# \rangle b\}\) (with b b's from the centre to right).

- \(\{a,b [A \backslash 1] 2\} = \{a,b [A] 2\}\) (if A is an arbitrary array)

This notation allows us to make arrays preceding backslash like [1 [2] 2 \ 2] or [1 [1 \ 2] 2 \ 2]. Placing the backslash on the base level (without at least one pair of square brackets), such as {3, 3 \ 2}, is illegal.

Bird extended it so that it can handle not only arrays with single backslash, but also multiple backslashes and even backslash-arrays. He used the notation [A]\ to indicate array A around backslash. There are new set of 3 rules that handles backslash-arrays:

**Rule B1**. Backslash-dimensional level is either 0 or 1:- \(\textrm`a \langle 0 \rangle\backslash b\textrm' = \textrm`a\textrm'\)
- \(\textrm`a \langle 1 \rangle\backslash b\textrm' = \textrm`a \backslash a \backslash \cdots \backslash a \backslash a\textrm'\) (with b a's)

**Rule B2**. First entry of backslash angle brackets is not 0:- \(\textrm`a \langle c \# \rangle\backslash b\textrm' = \textrm`a \langle c-1 \# \rangle\backslash b [c \#]\backslash a \langle c-1 \# \rangle b \cdots [c \#]\backslash a \langle c-1 \# \rangle b\textrm'\) (with b \(a \langle c-1 \# \rangle b\)'s)

**Rule B3**. First non-zero entry is prior to a single backslash:- \(\textrm`a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_n]\backslash 1 \backslash c \# \rangle b\textrm'\)

\(= \textrm`a \langle b \langle A_1' \rangle\backslash b [A_1]\backslash b \langle A_2' \rangle\backslash b [A_2]\backslash \cdots b \langle A_n' \rangle\backslash b [A_n]\backslash R_b \backslash c-1 \# \rangle b\textrm'\) - \(R_n = \textrm`b \langle b \langle A_1' \rangle b [A_1]\backslash b \langle A_2' \rangle b [A_2]\backslash \cdots b \langle A_n' \rangle\backslash b [A_n]\backslash R_{n-1} \backslash c-1 \# \rangle b\textrm'\)
- \(R_1 = \textrm`0\textrm'\)

- \(\textrm`a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_n]\backslash 1 \backslash c \# \rangle b\textrm'\)

**Rule B4**. Otherwise:- \(\textrm`a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_m]\backslash 1 [B_1] 1 [B_2] \cdots 1 [B_n] c \# \rangle b\textrm'\)

\(= \textrm`a \langle b \langle A_1' \rangle\backslash b [A_1]\backslash b \langle A_2' \rangle\backslash [A_2]\backslash \cdots b \langle A_n' \rangle\backslash [A_n]\backslash b \langle B_1' \rangle b [B_1] b \langle B_2' \rangle b [B_2] \cdots b \langle B_n' \rangle b [B_n] c-1 \# \rangle b\textrm'\)

- \(\textrm`a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_m]\backslash 1 [B_1] 1 [B_2] \cdots 1 [B_n] c \# \rangle b\textrm'\)

The limit of the notation introduced so far is the Feferman-Schütte ordinal.

## Nested Hyper-Nested Arrays

### 2-hyperseparators

For now, we need a separator that will be powerful than any level of nesting around backslash-arrays. At the end of his document "Beyond Bird's Nested Arrays I", Bird proposed to use the forward slash as follows:

\(\{a,b [1 / 2] 2\} = \{a \langle 0 / 2 \rangle b\} = \{a \langle b \langle b \langle b \cdots b \langle b \rangle\backslash b \cdots b \rangle\backslash b \rangle\backslash b \rangle b\}\) (with b b's from the center to right, it leads to b-2 appended backslashes)

Next, Bird noted that separator [A]\ (backslash-array A) can be rewritten as \([A \neg 2]\), which allows us to rewrite forward slash as \([1 \neg 3]\). However, it will be more useful (for further purposes) to define \([1 \neg 3]\) in the following manner:

\(\{a,b [1 [1 \neg 3] 2] 2\} = \{a \langle 0 [1 \neg 3] 2 \rangle b\} = \{a \langle b \langle b \langle b \cdots b \langle b \rangle\backslash b \rangle\backslash b \cdots b \rangle\backslash b \rangle\backslash b \rangle b\}\) (with b+1 b's from the center to right, b-1 appended backslashes).

Then we can construct the arrays \([A \neg 3]\) around \([1 \neg 3]\) with the same manner as with backslash and \([1 A \neg 3]\). Note that backslash is \([1 \neg 2]\) separator.

So, we can create nested arrays with \(\neg 3\) appended to it, and the limit of all this will be \([1 \neg 4]\). It's not so hard to see the general pattern and define the \([1 \neg n]\) separator:

\(\{a,b [1 [1 \neg n] 2] 2\} = \{a \langle 0 [1 \neg n] 2 \rangle b\} = \{a \langle b \langle b \langle b \cdots b \langle b \neg n-1\rangle b \neg n-1\rangle b \cdots b \neg n-1\rangle b \neg n-1\rangle b \rangle b\}\) (with b+1 b's from the center to right, b-1 appearances of \(\neg n-1\)).

Generally, we need to define the set of rules that allows us to handle \([A \neg n]\). We don't need to rewrite Main Rules because they will be the same starting from Nested Array Notation. Only Angle Bracket Rules will be changed.

**Rule A1**. Number inside angle brackets is 0:- \(\textrm`a \langle 0 \rangle b\textrm' = \textrm`a\textrm'\)

**Rule A2**. b = 1:- \(\textrm`a \langle A \rangle 1\textrm' = \textrm`a\textrm'\)

**Rule A3**. [A] < [B]:- \(\textrm`a \langle\# [A] 1 [B] \#\rangle b\textrm' = \textrm`a \langle\# [B] \#\rangle b\textrm'\)

**Rule A4**. First entry is 0, c immediately after normal separator (not in the form \([1 \neg n]\) with n > 1):- \(\textrm`a \langle 0 [A_1] 1 [A_2] \cdots 1 [A_m] c \# \rangle b\textrm' = \textrm`a \langle b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] c-1 \# \rangle b\textrm'\)

**Rule A5**. First entry is 0, c immediately after backslash:- \(\textrm`a \langle 0 [A_1] 1 [A_2] \cdots 1 [A_m] 1 \backslash c \# \rangle b\textrm' =\)

\(\textrm`a \langle b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] b \langle R_b \rangle b \backslash c-1 \# \rangle b\textrm'\)

- \(R_n = \textrm`b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] b \langle R_{n-1} \rangle b \backslash c-1 \# \rangle b\textrm'\) (n>1)
- \(R_1 = \textrm`0\textrm'\)

**Rule A6**. First entry is 0, c immediately after \([1 \neg n]\) (n > 2):- \(\textrm`a \langle 0 [A_1] 1 [A_2] \cdots 1 [A_m] 1 [1 \neg n] c \# \rangle b\textrm' =\)

\(\textrm`a \langle b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] b \langle R \rangle b [1 \neg n] c-1 \# \rangle b\textrm'\)

- \(R = \textrm`b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] R_b [1 \neg n] c-1 \# \rangle b\textrm'\)
- \(R_n = \textrm`b \langle A_1-1 \rangle b [A_1] b \langle A_2-1 \rangle b [A_2] \cdots b \langle A_m-1 \rangle b [A_m] b \langle R_{b-1} \rangle b [1 \neg n] c-1 \# \neg n-1 \rangle b\textrm'\) (n>1)
- \(R_1 = \textrm`0\textrm'\)

**Rule A7**. Rules A1-A6 don't apply:- \(\textrm`a \langle c \# \rangle b\textrm' = \textrm`a \langle c-1 \# \rangle b [c \#] a \langle c \# \rangle b-1\textrm'\).

This notation has strength at \(\theta(\Omega^\omega)\), the small Veblen ordinal.

## Arrays of 2-hyperseperators

We define \(\textrm`a \langle 0 [1 \neg 1,2] 2 \rangle b\textrm' = \textrm`a \langle b [b \neg b] b \rangle b\textrm'\).

**Rule A1**. Base rule:

- \(\textrm`a \langle 0 \rangle b\textrm' = \textrm`a\textrm'\)
- \(\textrm`a \langle 0 \neg \# \rangle b\textrm' = \textrm`a\textrm'\)

**Rule A2**. b = 1:- \(\textrm`a \langle A \rangle 1\textrm' = \textrm`a\textrm'\)

**Rule A3**. Remove traling 1's and low seperators:

- \(\textrm`a \langle \# 1 \rangle b\textrm' = \textrm`a \langle \# \rangle b\textrm'\)
- \(\textrm`a \langle \# [A] 1 [B] \#^* \rangle b\textrm' = \textrm`a \langle \# [B] \#^* \rangle b\textrm'\)(when [A] < [B])