**Username5243's Array Notation**, also shortened to UNAN, is a notation made by wiki user Username5243.^{[1]} It has the format a[#]b where # is an array. It comes in multiple parts.

## Parts

- Basic array notation: hardly even an array notation! Just the expression a[c]b, which is equal to {a,b,c}, a→b→c, and a↑
^{c}b in BEAF, chained arrow notation, and up arrow notation respectively. 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. FGH level \(\omega^2\).
- Linear array notation: takes linear arrays. FGH level \(\omega^\omega\)
- Planar array notation: takes planar arrays. FGH level \(\omega^{\omega^2}\)
- Dimensional array notation: takes dimensional arrays. FGH level \(\omega^{\omega^\omega}\)
- Hyperdimensional array notation: takes arrays where separators can have linear arrays in them. FGH level \(\omega^{\omega^{\omega^\omega}}\)
- Nested array notation: takes arrays that contain arrays in separators. FGH level \(\varepsilon_0\)
- 2-entry First-order array notation: adds a separator called the first order comma. FGH level \(\zeta_0\)
- First-order comma array notation: more with the first order comma. FGH level \(\varphi(\omega,0)\)
- First-order dimensional array notation: adds more first order separator. FGH level \(\Gamma_0\)

## Definition

The basic array notation uses pretty much the same rules as Arrow notation, except it uses 0 as a terminal value, but as a[0]b equals a*b, it is 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))

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

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.

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.