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. Unfortunately, the original definition of this notation is ill-defined by the reason explained in #Issues section and Googology Wiki user DeepLineMadom clarified in the talk page that the original definition and his ill-defined alternative definitions will be scrapped with the statement "I would make the notation much more well-defined by completely remaking this notation with many tweaks, but there isn't enough time here.".

## 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[note 1], 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 $$\omega$$.
• 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 $$\omega^2$$.
• Linear array notation: takes linear arrays. Intended FGH level $$\omega^\omega$$.
• Planar array notation: takes planar arrays. Intended FGH level $$\omega^{\omega^2}$$.
• Dimensional array notation: takes dimensional arrays. Intended FGH level $$\omega^{\omega^\omega}$$.
• Hyperdimensional array notation: takes arrays where separators can have linear arrays in them. Intended FGH level $$\omega^{\omega^{\omega^\omega}}$$.
• Nested array notation: takes arrays that contain arrays in separators. Intended FGH level $$\varepsilon_0$$.
• 2-entry First-order array notation: adds a separator called the first order comma. Intended FGH level $$\zeta_0$$.
• First-order comma array notation: more with the first order comma. Intended FGH level $$\varphi(\omega,0)$$.
• First-order dimensional array notation: adds more first order separator. Intended FGH level $$\Gamma_0$$.

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.

## Definition

### 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 ab equals a*b, it is intended to be effectively just a different notation for the same function.

• ab = 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 actualy 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 = ab = 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: ab = 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[note 1].

However, the first rule

• ab = a*b

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

• 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(21) is ill-formed because 21 is a'[c']b' for a' = 2, b' = 1, and c' = 1, and 2(21) is a'[c']b' for a' = 2, b' = 21, 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](21) is ill-formed because 21 is a'[c']b' for a' = 2, b' = 1, and c' = 1, and 2[-1](21) is a'[c']b' for a' = 2, b' = 21, 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](20) is ill-formed because 20 is a'[c']b' for a' = 2, b' = 0, and c' = 1, and 2[-1](20) is a'[c']b' for a' = 2, b' = 20, 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-1) is ill-formed because 2-1 is a'[c']b' for a' = 2, b' = -1, and c' = 1, and 2[-1](2-1) is a'[c']b' for a' = 2, b' = 2-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.

### Alternative definitions

Although the creator failed to make the notation well-defined and later abandoned, there are several solutions by setting complete case classification without overlapping. We note that such a trial does not necessarily solve all the issues.

For example, two Googology Wiki users: DeepLineMadom and HaydenTheGoogologist2009 suggested many alternative definitions of the basic array notation and other parts, which are known to be ill-defined. Since these works are not peer-reviewed, such a misfortune can occur.

#### First alternative definition

Here, we explain the first trial:

• Base rule: First, if the array is just 0, ab = a × b, for a greater than 0. If the array is 1, ab = ab, for a greater than 0.
• Prime rule: Second, for any a greater than 0, if the iterator b is 1, a[c]1 = a; If the iterator b is 0, a[c]0 = 1 for a greater than 0.
• Base zero rule: Third, in case of a = 0 (the base is equal to 0), 0b = 0 for all b, 0c = 0 for c greater than 0, 0[c]1 = 0 for all c, 00 is undefined (see also wikipedia:zero to the power of zero).
• Recursion rule: Finally, if the three rules above don't meet, a is greater or equal to 0, c is greater than 0, and b is greater than 1, then the result is a[c-1](a[c](b-1)). This rule do not conflict with the base rule on ab, since ab = a × ab−1, hence ab = a(a(b-1)), which returns the same value when we apply the base rule for ab.

This alternative definition also has the issue on the restriction of a, b, and c, because there is no definition of the domain of the notation. i.e. the set of valid expressions. Indeed, if we simply assume that the alternative definition employs the same setting that the expression a[c]b is valid if and only if a, b, c are positive numbers with a, b > 1, c > 0 as the original one[note 1], the base rule is referring to an ill-formed expression ab again. Also, the description "if the array is just 0, ab = a × b" are mixing case classification "if c is just 0, a[c]b = a × b" and the partial specialisation "ab = a × b", and hence the condition does not make sense. Such mixture appears in many other locations in the definition.

In later parts:

• Base rule: First, if the array merely contains 0 (excluding separators), a[0#]b = a × b, for a greater than 0, and # has no nonzero entries.
• Tailing rule: Second, if there are zeroes next to the last nonzero entry, it may be removed: a[#,0]b = a[#]b.
• Base zero rule: Third, in case of a = 0 (the base is equal to 0), 0b = 0 for all b, 0b = 0 for b greater than 0, 0[c]1 = 0 for all c, 00 is undefined.
• Recursion rule: Finally, if the first entry c in a[c#]b is greater than 0, a is greater or equal to 0, and b is greater than 1, then the result is a[c-1#](a[c#](b-1)).

In that case, if the four basic rules above don't meet, apply the new rules to the expression, such as hyperoperation rule, which are unchanged.

And defining some properties of this notation with respect to the alternative definition as follows:

• a0 = 0 for all a.
• 1[c]b = 1 for c > 0 and for all b.
• 0[c]b is always undefined if c > 1 and b ≠ 1 in the basic array notation.
• 1[#]b = 1 for all arrays # beyond the basic array notation.
• 2[#]b = 4 for all arrays # beyond the basic array notation (in the simplest case, 2[0,1]b = 2[b]2).
• 2[c]2 = 4 for all c (see circulation).
• a[c+1]2 = a[c]a for c > 0.
• 0[0,1]b = 0 for b = 0, and undefined for b > 0.
• 0[c#]1 = 0 for all c in c# greater than 0, where # is the rest of the array (in the simplest case, 0[1,1]1 = 0 (by the prime rule)).
• 0[0,d#]b is always undefined for all b and d greater than 0, where # is the rest of the array beyond the second entry, because 0[0,1]b = 0[b]0, which is undefined by the property above.
• 0[1#]b is equal to 0 for all b greater than 0, where # is the rest of the array (in the simplest cases, 0[1,1]1 = 0, and 0[1,1]2 = 0[0,1]0 = 0).
• 0[0,0#]b is equal to 0, where # is the rest of the array beyond the second entry that contains at least one nonzero entry.
• 0[c#]0 is always undefined for all c in c# greater or equal to 1, where # is the rest of the array (in the simplest case, 0[1,1]0)
• 0[c#]b is always undefined for all c in c# greater than 1, and for all b greater than 1, where # is the rest of the array (in the simplest case, 0[2,1]2 = 0[1,1]0, which is undefined by the previous property).

These parts also have the issue that the domain is not defined.

##### Issues

If we assume that the alternative definition employs the same restriction on variables, then the computation rules are referring to ill-formed expression, as we explained above. Therefore we need to know the precise definition of the domain, while it is not explicitly given.

##### Examples

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

###### Basic array notation
• 32
• = 3(31)
• = 33
• = 3(32)
• = 33(31)
• = 333
• In case of ab (assuming that there are two distinct rules applicable as follows):
1. If we apply the base rule, then 333 = 333 = 327 = 327 = 7,625,597,484,987
2. If we apply the recursion rule, then 333 = 33(32) = 333(31) = 3333 = 33(3×3) = 339 = 3(3×9) = 327 = 3(326) = 33(325) = ... = 33...33 with 27 3's = 327 = 7,625,597,484,987
• Hence if there are two distinct rules applicable to ab, 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.
• 23
• = 2(22)
• = 24
• = 2(23)
• = 22(22)
• = 224
• = 22(23)
• = 222(22)
• = 2224
• = 222(23)
• = 2222(22)
• = 22224
• = 2222(23)
• = 22222(22)
• = 222224
• = 222224
• = 222216
• = 222216
• = 22265536
• = 222(265535)
• = 2222(265534)
• = 22222(265533)
• ...
###### 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
• = 00
• = 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
• = 00
• = 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): ab = 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): ab = 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): ab = ab.
• 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.

## Footnotes

1. The last condition c > 0 automatically follows from the postivity, but we clarify it by following the original source.