Googology Wiki
Advertisement
Googology Wiki
"SAN" redirects here. It is not to be confused with SSAN or stage array notation.

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

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)

Although the definition is written in natural language, many googolists believe that there should be a formal definition which imitate the intention by the creator. They are not known to be well-founded in the sense that the expansion rule admits a compatible well-founded orderring if they will be formalised, and hence large numbers defined by them are not known to be well-defined under the same assumption. Readers should be careful that it does not mean that they are known to be ill-defined if their definitions will be formalised. We simply do not know whether the system terminates or not under the same assumption. It is strongly believed that they give quite powerful notations if they are proven to terminate with respect to a fixed formalisation.

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)

In particular, those attempts have not successfully formalised yet. The definitions are based on natural language, although it looks like algorithms. Therefore they include a little ambiguity, which is not counted as problems by many googologists. For example, the set of valid expressions are not precisely defined, but few googologists care about the issue.

Since the description is quite complicated, we only explain parts of the definitions of the first two systems, LAN and exAN.

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-empty 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-1,c #),c-1 #)
  • 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:
    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.

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 = 7,625,597,484,987

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

For Bowers' Extended Array Notation, see 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, but we omit the complete definition here. 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, and the comparison of the levels is also defined in a recursive way.

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)

Common misconceptions

SAN is frequently considered to be formalised, but its definition is written mainly in natural language, which actually includes ambiguity.

One reason why it is frequently considered to be formalised is due to how the programming-like definition looks. However, it is not actually written in an alogorithm, and is written by natural language. A similar issue is known for Bashicu matrix system version 1, 2, and 3, which are defined by a BASIC-like language, which is Bashicu's original language without a definition.

Another reason why it is frequently considered to be formalised is due to the existence of computer programs intended to perfectly imitate SAN. However, there is no computer program which the creator has agreed that is an official formalisation. Indeed, one of the most famous known computer programs is not agreed to be an official formalisation by the creator, and is considered to be incompatible, with the creator's intention due to the debug by Googology Wiki user ARsygo.[2]

SAN is frequently considered to be a well-founded notation, but there is no proof that a formalisation of SAN is well-founded.

Sources

Advertisement