Bird's array notation

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.

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 frow \(\{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 \rangle b [m_1] a \langle m_2 \rangle b [m_2] \cdots a \langle m_x \rangle b [m_x] (c-1) \#\}\)
 * Rule M5. If there is a non-zero entry after batch of unfilled separators and string of 1's.
 * \(\{a,b [m_1] 1 [m_2] \cdots 1 [m_x] 1,1,\cdots,1,1,c \#\} = \{a \langle m_1 \rangle b [m_1] a \langle m_2 \rangle b [m_2] \cdots a \langle m_x \rangle b [m_x] a,a,\cdots,1,1,c-1 \#\}\)
 * Rule M6. If there is a string of ones starting on the first entry:
 * \(\{a,b,1,1,\cdots,1,1,c \#\} = \{a,a,a,a,\cdots,a,\{a,b-1,1,1,\cdots,1,1,c-1 \#\},c-1 \#\}\)
 * Rule M7. Rules M1-M6 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 <3> 3 [3] 3 <2> 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 M7 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:
 * \(\textrm` a \langle 0 [A_1] 1 [A_2] \cdots 1 [A_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_n-1 \rangle b [A_n] c-1 \# \rangle b \textrm'\)

An and B are arrays and Ai-1 is identical to Ai, 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] 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:


 * 1) For the further purposes, let [A1]=[A], [A2]=[A1] and [B1]=[B], [B2]=[B1].
 * 2) If Lev(A)>Lev(B), then conclude that [A]>[B], if Lev(A)0, then go to step 3, otherwise go to step 6.
 * 3) Let [A*] and [B*] are highest ranking separators in the arrays A2 and B2 respectively. If [A*]>[B*] then [A]>[B], if [A*]<[B*] then [A]<[B], otherwise take [H]=[A*]=[B*] and go to step 4.
 * 4) If Num(H,A2)>Num(H,B2), then [A]>[B], if Num(A)>Num(B), if Num(H,A2)[b], then [A]>[B], otherwise go to step 7.
 * 7) In the strings A1 and B1 remove the very last entry and separator before it. If A1 and B1 are empty, then we conclude that [A]=[B], otherwise return to step 2.

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 \rangle b \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:
 * \('a \langle 0 \rangle\backslash b' = 'a'\)
 * \('a \langle 1 \rangle\backslash b' = 'a \backslash a \backslash \cdots \backslash a \backslash a'\) (with b a's)

\(= '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-1} \backslash c-1 \# \rangle b'\)
 * Rule B2. First non-zero entry is prior to a single backslash:
 * \('a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_n]\backslash 1 \backslash c \# \rangle b'\)
 * \(R_n = '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'\)
 * \(R_1 = 'b'\)

\(= '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\)
 * Rule B3. Otherwise:
 * \('a \langle 0 [A_1]\backslash 1 [A_2]\backslash \cdots 1 [A_n]\backslash 1 [B_1] 1 [B_2] \cdots 1 [B_n] c \# \rangle b'\)

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

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] \rangle b\} = \{a \langle b \langle b \langle b \cdots b \langle b \rangle\backslash b \rangle\backslash b \cdots b \rangle b \rangle 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] \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 \(\{a \langle 0 [1 \neg 1,2] 2 \rangle b\} = \{a \langle b [b \neg b] b \rangle b\}\).

Nested Subscript Arrays

 * This section is empty. You can help by  [ expanding it]. 

Hierarchical Hyper-Nested Arrays

 * This section is empty. You can help by  [ expanding it].