Strong array notation

Strong array notation is a notation for large numbers made by Wikia user Hyp cos.

The notation is currently composed of 7 parts, which is as follows:


 * Linear array notation (LAN)
 * Extended array notation (exAN)
 * Expanding array notation (EAN)
 * Multiple expanding array notation (mEAN)
 * Primary dropping array notation (pDAN)
 * Secondary dropping array notation (sDAN)
 * Dropping array notation (DAN)

They are not known to be well-founded, and hence large numbers defined by them are not known to be well-defined. The first attempt to go past DAN (under the assumption of the well-foundedness) created five parts that didn't work:

The second attempt didn't work either:
 * Nested dropper array notation (NDAN)
 * Dropper-expanding notation (DEN)
 * Multiple dropper-expanding notation (mDEN)
 * Second-order dropper-expanding notation (soDEN)
 * Higher-order dropper-expanding notation (hoDEN)


 * Nested dropper array notation (NDAN)
 * Weak dropper-expanding notation (WDEN)
 * Multiple weak dropper-expanding notation (mWDEN)
 * Weak dropper-multiexpanding notation (WDmEN)
 * Primary dropper-dropping notation (pDDN)

The definitions are based on natural language, although it looks like algorithms. Therefore they include a little ambiguity. For example, the set of valid expressions are not precisely defined.

Linear array notation
Linear array notation (LAN) is the first part of strong array notation. A valid expression in LAN is of the form s(@), where @ is a non-epmpty sequence of positive integers separated by comma. It has the following rules, where # is a part of the array:


 * Rule 1 (base rule): s(a,b) = a^b.
 * Rule 2 (recursion rule): If b and c are greater than 1, s(a,b,c#) = s(a,s(a,b,c+1#),c#)
 * Rule 3 (tailing rule): s(#,1) = s(#)

If none of these apply, start the process shown below, starting from the third entry:


 * If the entry is 1, then jump to the next entry.
 * If the entry is not 1, then:
 * Change the "1,n" into "b,n-1" where n is this entry and b is the second element of the array.
 * Change all entries before these two into the first entry.
 * This process ends.

Although this article included an additional rule s(a) = a, such a rule is not written in the source. Instead, applying Rule 3 to s(a) in an inverse direction, we obtain s(a) = s(a,1) = a^1 = a.

Examples
s(3,2,3) = s(3,s(3,1,3),2) = s(3,s(3,1,2),2) = s(3,s(3,1,1),2)= s(3,s(3,1),2) = s(3,3^1,2) = s(3,3,2) = s(3,s(3,2,2),1) = s(3,s(3,s(3,1,2),1),1) = s(3,s(3,3,1),1) = s(3,s(3,3),1) = s(3,27,1) = s(3,27) = 3^27 = 7625597484987

s(3,2,2,2) = s(3,s(3,1,2,2),1,2) = s(3,s(3,1,1,2),1,2) = s(3,s(3,3,1,1),1,2) = s(3,s(3,3),1,2) = s(3,27,1,2) = s(3,3,27) = 3^^^...^^^3 (27 arrows)

s(3,2,2,1,2) = s(3,s(3,1,2,1,2),1,1,2) = s(3,s(3,1,1,1,2),1,1,2) = s(3,s(3,3,3,1,1),1,1,2) = s(3,s(3,3,3),1,1,2) = s(3,3^^^3,1,1,2) = s(3,3,3,3^^^3,1) = s(3,3,3,3^^^3) (the result is equal to a Conway chain of threes \(3\uparrow\uparrow\uparrow3+2\) numbers long)

Comparisons
For 3-entry arrays, s(a,b,c) = \(a \underbrace{\uparrow\cdots\uparrow}_c b\), or \(\{a, b, c\}\) in BEAF.

For 4-entry arrays, s(a,b,c,d) = \(\underbrace{a \rightarrow \cdots \rightarrow a}_d \rightarrow b \rightarrow c\) using chained arrow notation.

Extended array notation
Extended array notation (exAN) is the second part of strong array notation. It adds separators between entries. The comma is a shorthand for {1}. Although it is not clarified in the original source, a valid expression in exAN is perhaps an "array" in the sense defined in the source. It has the following rules:


 * Rule 1 (base rule): s(a,b) = a^b
 * Rule 2 (recursion rule): s(a,b,c #) = s(a,s(a,b-1,c #),c-1 #)
 * Rule 3a (tailing rule) s(# A 1) = s(#) (A is any separator)
 * Rule 3b: {# A 1} = {#} (Again, A as a separator)
 * Rule 4: (if lv(A) < lv(B)) {# A 1 B #′} = {# B #′}

If none of these applies, start the process, which is as follows:


 * Start from the third entry. If it is a one, skip to the next entry.
 * If it is greater than 1, look to your left:
 * If it has a comma before it, decrease it by 1, change the previous entry into the current second entry, and change all the other entries at the outermost layer before the current entry into the original first entry. This works even if the second entry is a 1.
 * If it has a separator not comma A before it, change the "A n" to "A 2 A n-1", and move to the first entry of the first A.
 * If it has a { before it, change the {n#} to Sb where b is the current second entry, S1 = "{n-1#}", and Sn+1 = "{n-1#} 1 Sn".

We note the notion of a separator is explicitly defined in the original source. The term "next" is a little ambiguous, because an array in this context is not an actual array in the usual sense, but is a formal expression including separators. The function "lv" stands for "level" defined in a recursive way in the original source.

Examples
s(3,3{2}2) = s(3,3{2}2{2}1) = s(3,3,1,1,2{2}1) = s(3,3,1,1,2) = s(3,3,3,3)

s(3,2{2}1{2}2) = s(3,2{2}1,1,2) = s(3,3{2}3,2)

s(3,2{3}2) = s(3,2{2}1{2}2)

s(3,3{1,1,2}2) = s(3,3{1,1,2}2{1,1,2}1) = s(3,3{1,3}2) = s(3,3{3,2}2)