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:

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

The second attempt didn't work either:

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

Linear array notation

Linear array notation is the first part of strong array notation. It has the following rules, where # is a part of the array:

• Rule 1 (base rule): s(a,b) = a^b. In partial case, s(a) = a.
• Rule 2 (tailing rule): s(#,1) = s(#)
• Rule 3 (recursion rule): s(a,b+1,c+1#) = s(a,s(a,b,c+1#),c#)

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:
  1. Change the "1,n" into "b,n-1" where n is this entry and b is the second element of the array.
  2. Change all entries before these two into the first entry.
  3. This process ends.

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

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 is the second part of strong array notation. It adds separators between entries. The comma is a shorthand for {1}. It has the following rules:

• Rule 1 (base rule): s(a,b) = a^b
• Rule 2a (tailing rule) s(# A 1) = s(#) (A is any separator)
• Rule 2b: {# A 1} = {#} (Again, A as a separator)
• Rule 3 (recursion rule): s(a,b,c #) = s(a,s(a,b-1,c #),c-1 #)

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 S_b where b is the current second entry, S₁ = "{n-1#}", and S_n+1 = "{n-1#} 1 S_n".

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)