Username5243's Array Notation

Username5243's Array Notation, also shortened to UNAN, is a notation made by Googology Wiki user Username5243. It has the format a[#]b where # is an array. It comes in multiple parts. An example of a valid array is 3[1, 2]5.

Parts

• Basic array notation: hardly even an array notation! Just the expression a[c]b for positive numbers a, b, c with a, b > 1 and c > 0, which is equal to {a,b,c}, a→b→c, and a↑^cb in BEAF, chained arrow notation, and up arrow notation respectively. Intended FGH level ω.
• 2-entry array notation: takes arrays with two entries. Close equivalence with BEAF, but a slight difference due to using 0 as a terminal value rather than 1. Intended FGH level ω².
• Linear array notation: takes linear arrays. Intended FGH level ω^ω.
• Planar array notation: takes planar arrays. Intended FGH level ω^ω2.
• Dimensional array notation: takes dimensional arrays. Intended FGH level ω^ωω.
• Hyperdimensional array notation: takes arrays where separators can have linear arrays in them. Intended FGH level ω^ωωω.
• Nested array notation: takes arrays that contain arrays in separators. Intended FGH level ε₀).
• 2-entry First-order array notation: adds a separator called the first order comma. Intended FGH level ζ₀.
• First-order comma array notation: more with the first order comma. Intended FGH level φ(ω,0).
• First-order dimensional array notation: adds more first order separator. Intended FGH level Γ₀.

As the notation is ill-defined, the "intended FGH level" just means an intention of the growth rate with respect to an unspecified system of fundamental sequences if all issues are solved, and hence does not mathematically make sense.

Original definition

The basic array notation uses pretty much the same rules as Arrow notation, except it uses 0 for c in the expression a[c]b as a terminal value, but as a[0]b equals a*b, it is intended to be effectively just a different notation for the same function.

• a[0]b = a*b
• a[c]1 = a
• a[c]b = a[c-1](a[c](b-1))

However, the basic array notation is ill-defined by the reason explained in #Issues section. In particular, it is not actually a different notation for the same function as Arrow notation.

Note that according to the list of numbers, arrays always solve from right to left. The second part adds a fourth rule:

• Base Rule: a[0,0]b = a[0]b = a*b
• Prime Rule: a[c,d]1 = a
• Recursion Rule: a[c,d]b = a[c-1,d](a[c,d](b-1))
• Hyperoperation Rule: a[0,d]b = a[b,d-1]a

Since it refers to the basic array notation, it is also ill-defined.

The number after the array is called the iterator, and the number before it the base. The third part generalizes to multiple entries:

• Base Rule: a[0]b = a*b
• Tailing Rule: a[#,0]b = a[#]b
• Prime Rule: a[%]1 = a
• Recursion Rule: a[c#]b = a[c-1#](a[c#](b-1))
• If none of them apply, do the following process:
  • Case A: If it is zero, go to the next entry.
  • Case B: if the entry is greater than 0, decrease it by 1, then change the previous entry to the iterator, and change the iterator to the base. End the process.

It has the same issues as the basic array notation, and hence it and other parts are also ill-defined.

The fourth part adds a new separator, {1}. Case B is changed, the rest remains unchanged.

• Case B: If it is greater than zero, then:
  • If there is a comma before it, then decrease it by one, change the previous entry to the iterator, and change the iterator to the base.
  • If there is a {1} before it, decrease it by one, then change 0{1}m to 0,0,...,0,1{1}m-1 with the iterator zeroes, then change the iterator to the base. End the process.

Case B is changed again in part 5:

• Case B: If it is greater than zero, then:
  • If there is a comma before it, then decrease it by one, change the previous entry to the iterator, and change the iterator to the base
  • If there is {n} before it where n ≥ 1, replace the previous 0{n}m with 0{n-1}0{n-1}0{n-1}...{n-1}1{n}m-1 with the iterator zeroes, then change the iterator to the base. End the process.

A comma is the same thing as {0}.

In hyper-dimensional and nested arrays, the rules are the same as each other, but in hyper-dimensional arrays, separators cannot contain separators other than commas. Again, all that changes is case B.

• Case B: If it is greater than zero, then:
• If there is a comma before it, then decrease it by one, change the previous entry to the iterator, and change the iterator to the base
  • If there is {n #} before it where n ≥ 1, replace the previous 0{n #}m with 0{n-1 #}0{n-1 #}0{n-1 #}...{n-1 #}1{n #}m-1 with the iterator zeroes, then change the iterator to the base. End the process.
  • If there is {0 #} before it, go into the separator and start the process from there.

Issues

According to the original source, the basic array notation assumes that the expression a[c]b is valid if and only if a, b, c are positive numbers with a, b > 1, c > 0.

However, the first rule

• a[0]b = a*b

refers to an expression a[0]b, which is ill-formed because it is a[c]b with c = 0. Namely, the originality that this notation allows a[0]b conflicts the restriction from the beginning.

In addition, the second rule

• a[c]1 = a

refers to an expression a[c]1, which is ill-formed because it is a[c]b with b = 1.

Further, the third rule

• a[c]b = a[c-1](a[c](b-1))

does not have any restriction, and hence allows the case a = 2, b = 2, c = 1. Then the resulting value 2[0](2[1]1) is ill-formed because 2[1]1 is a'[c']b' for a' = 2, b' = 1, and c' = 1, and 2[0](2[1]1) is a'[c']b' for a' = 2, b' = 2[1]1, and c' = -0.

We note that even if we replaced the positivity of c and the restriction c > 0 by the non-negativity, the third rule would cause the same problem: It allows the case a = 2, b = 2, c = 0. Then the resulting value 2[-1](2[0]1) is ill-formed because 2[0]1 is a'[c']b' for a' = 2, b' = 1, and c' = 1, and 2[-1](2[0]1) is a'[c']b' for a' = 2, b' = 2[0]1, and c' = -1.

Even if we in addition ignored the restriction b > 1, then the third rule would cause the same problem: It allows the case a = 2, b = 1, c = 0. Then the resulting value 2[-1](2[0]0) is ill-formed because 2[0]0 is a'[c']b' for a' = 2, b' = 0, and c' = 1, and 2[-1](2[0]0) is a'[c']b' for a' = 2, b' = 2[0]0, and c' = -1.

Even if we in addition replaced the postivity of b by the non-negativity, then the third rule would cause the same problem: It allows the case a = 2, b = 0, c = 0. Then the resulting value 2[-1](2[0]-1) is ill-formed because 2[0]-1 is a'[c']b' for a' = 2, b' = -1, and c' = 1, and 2[-1](2[0]-1) is a'[c']b' for a' = 2, b' = 2[0]-1, and c' = -1.

In this way, replacement of the restrictions on a, b, and c does not solve the problem, and hence there should be a restriction on the third rule depending on replacement of the restrictions. For example, if we replace the restriction "a, b, c are positive numbers with a, b > 1, c > 0" by "a, b, c are non-negative integers", then it is better to assume b > 0 and c > 0 for the third rule.

The same issues occur for other parts than the basic array notation, and hence the whole part of this notation is ill-defined.

Examples

Since the alternative definition also has an issue, we just give examples of intended values.

Basic array notation

• 3[3]2
  • = 3[2](3[3]1)
  • = 3[2]3
  • = 3[1](3[2]2)
  • = 3[1]3[1](3[2]1)
  • = 3[1]3[1]3
  • In case of a[1]b (assuming that there are two distinct rules applicable as follows):
    1. If we apply the base rule, then 3[1]3[1]3 = 3[1]3³ = 3[1]27 = 3²⁷ = 7,625,597,484,987
    2. If we apply the recursion rule, then 3[1]3[1]3 = 3[1]3[0](3[1]2) = 3[1]3[0]3[0](3[1]1) = 3[1]3[0]3[0]3 = 3[1]3[0](3×3) = 3[1]3[0]9 = 3[1](3×9) = 3[1]27 = 3[0](3[1]26) = 3[0]3[0](3[1]25) = ... = 3[0]3[0]...[0]3[0]3 with 27 3's = 3²⁷ = 7,625,597,484,987
  • Hence if there are two distinct rules applicable to a[1]b, the base rule must be used instead of the recursion rule, since the base rule is used first, and they also return the same value for both rules.
• 2[6]3
  • = 2[5](2[6]2)
  • = 2[5]4
  • = 2[4](2[5]3)
  • = 2[4]2[4](2[5]2)
  • = 2[4]2[4]4
  • = 2[4]2[3](2[4]3)
  • = 2[4]2[3]2[3](2[4]2)
  • = 2[4]2[3]2[3]4
  • = 2[4]2[3]2[2](2[3]3)
  • = 2[4]2[3]2[2]2[2](2[3]2)
  • = 2[4]2[3]2[2]2[2]4
  • = 2[4]2[3]2[2]2[1](2[2]3)
  • = 2[4]2[3]2[2]2[1]2[1](2[2]2)
  • = 2[4]2[3]2[2]2[1]2[1]4
  • = 2[4]2[3]2[2]2[1]2⁴
  • = 2[4]2[3]2[2]2[1]16
  • = 2[4]2[3]2[2]2¹⁶
  • = 2[4]2[3]2[2]65536
  • = 2[4]2[3]2[1](2[2]65535)
  • = 2[4]2[3]2[1]2[1](2[2]65534)
  • = 2[4]2[3]2[1]2[1]2[1](2[2]65533)
  • ...

Solution on base 0

• 0[0,3,1]2
  • = 0[2,2,1]0
  • = Undefined (see properties above)
• 0[0,0,2]3
  • = 0[0,3,2]0
  • = 0[0,2,2]0
  • = 0[0,1,2]0
  • = 0[0,0,2]0
  • = 0[0,0,1]0
  • = 0[0,0,0]0
  • = 0[0]0
  • = 0 (see properties above)
• 0[0{1}0,1]3
  • = 0[0{1}3]0
  • = 0[1{1}2]0
  • = Undefined (see properties above)
• 0[0{0,1}1]4
  • = 0[0{4}1]0
  • = 0[1{3}1]0
  • = Undefined (see properties above)
• 0[0{0{2}0{1}1}1]3
  • = 0[0{0{2}0,0,0,1}1]0
  • = 0[0{0{2}0,0,0,0}1]0
  • = 0[0{0{2}0}1]0
  • = 0[0{0}1]0
  • = 0[0,1]0
  • = 0[0]0
  • = 0 (see properties above)

Second alternative definition

Since the first alternative definition of UNAN is also ill-defined by the similar issues pointed out in the section above, a Googology Wiki user DeepLineMadom also suggested to reform the definition in his website as follows: This is also ill-defined as we will explained in #Issues 3.

A valid expression in UNAN's basic array notation is of the form a[c]b, where a, b, and c are non-integers. It has the following rules:

• Rule 1 (base rule): a[0]b = a×b.
• Rule 2 (prime rule): a[c]0 = 1.
• Rule 3 (recursion rule): a[c]b = a[c-1](a[c](b-1)) if b > 0 and c > 0.

If there are two or more distinct rules to apply to a single expression, the lowest-numbered rule which is applicable and whose result is a valid expression will be applied.

In later parts beyond the basic array notation, there will be a minor difference for the rule 2 (prime rule) as follows:

• Rule 2 (prime rule): a[#]0 = 1 for any array #.

The other rules remain unchanged.

Issues

The reformation is also ill-defined by a similar issue, i.e. a problem related to the domain. When we refer to a "non-integer", we need to specify what range of numbers we are considering, e.g. rational numbers, real numbers, complex numbers, and so on. Since the range is unspecified, the domain is still unclear.

Even when we ignore the problem on the domain, the base rule and the prime rule include ill-formed expressions, because 0 is not a non-integer. Therefore, we only have the recursion rule. Then for any of natural choices of the range of numbers listed above, the complement of the subset of integers is not well-founded with respect to the decrement in the recursion rule. Therefore, the notation is again ill-defined.

For example, if we consider the case where the range is the set of rational numbers, then 1.1[1.2]1.3 should be a valid expression because neither 1.1, 1.2, nor 1.3 is an integer. However, the computation of 1.1[1.2]1.3 has an infinite loop \begin{eqnarray*} 1.1[1.2]1.3 = 1.1[0.2](1.1[1.2]0.3) = 1.1[0.2](1.1[0.2](1.1[1.2]-0.7)) = 1.1[0.2](1.1[0.2](1.1[0.2](1.1[1.2]-1.7))) = \cdots \end{eqnarray*} and hence the resulting value is ill-defined.

Third alternative definition

As the second alternative definition is ill-defined due to issues related to the domain, since the creator mistook the domain in his website that he wrote "A valid expression in UNAN's basic array notation is of the form a[c]b, where a, b, and c are non-integers." but later the creator also fixed a typo from the second alternative definition from "non-integer" to "non-negative integer" in the same page, and hence the third alternative definition has been changed as follows (the underlined content is the difference):

A valid expression in UNAN's basic array notation is of the form a[c]b, where a, b, and c are non-negative integers. It has the following rules:

• Rule 1 (base rule): a[0]b = a×b.
• Rule 2 (prime rule): a[c]0 = 1.
• Rule 3 (recursion rule): a[c]b = a[c-1](a[c](b-1)) if b > 0 and c > 0.

If there are two or more distinct rules to apply to a single expression, the lowest-numbered rule which is applicable and whose result is a valid expression will be applied.

In later parts beyond the basic array notation, there will be a minor difference for the rule 2 (prime rule) as follows:

• Rule 2 (prime rule): a[#]0 = 1 for any array #.

The other rules remain unchanged.

Issues

Unfortunately, this notation again lacks the definition of the domain of later parts other than the basic array notation. If we follow the restriction in the original definition, which also lacks the domain, then we have the same issue as those explained in #Issues.

The rules also have issues similar to the ones for the first alternative definition explained in #Issues 2. Even if those issues will be fixed in other versions, it does not mean that all issues have been solved, because there can be other issues which have not been pointed out.

Forth alternative definition

A valid expression in UNAN's basic array notation is of the form a[c]b, where a, b, and c are natural numbers (1, 2, 3, ...). It has the following rules:

• Rule 1 (base rule): a[1]b = a^b.
• Rule 2 (prime rule): a[c]1 = a.
• Rule 3 (recursion rule): a[c]b = a[c - 1](a[c](b - 1)) if b > 1 and c > 1.

If there are two or more distinct rules to apply to a single expression, the lowest-numbered rule which is applicable and whose result is a valid expression will be applied.

In later parts beyond the basic array notation, there will be a minor difference for the rule 2 (prime rule) as follows:

• Rule 2 (prime rule): a[#]1 = a for any array #.

The other rules remain unchanged.

Unfortunately, Googology Wiki user DeepLineMadom pointed out that the fourth alternative definition of UNAN proposed by HaydenTheGoogologist2009 (Hayden Leung) has some "subtle problems".

References

This article "Username5243's Array Notation" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:Username5243's Array Notation. Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

---