Username5243's Array Notation

Username5243's Array Notation, also shortened to UNAN, is a notation made by wiki user Username5243. 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↑cb in BEAF, chained arrow notation, and up arrow notation respectively. 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. FGH level ω2.
 * Linear array notation: takes linear arrays. FGH level ωω.


 * Planar array notation: takes planar arrays. FGH level ω^ω^2.


 * Dimensional array notation: takes dimensional arrays. FGH level ω^ω^ω.
 * Hyperdimensional array notation: takes arrays where separators can have linear arrays in them. FGH level ω^ω^ω^ω.
 * Nested array notation: takes arrays that contain arrays in separators. FGH level ε0.
 * 2-entry First-order array notation: adds a separator called the first order comma. FGH level ζ0.
 * First-order comma array notation: more with the first order comma. FGH level φ(ω,0).
 * First-order dimensional array notation: adds more first order separator. FGH level Γ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. The second part adds a fourth rule: The number after the array is called the iterator, and the number before it the base. The third part generalizes to multiple entries: The fourth part adds a new separator, {1}. Case B is changed, the rest remains unchanged. Case B is changed again in part 5: A comma is the same thing as {0}.
 * a[0]b = a*b
 * a[c]1 = a
 * a[c]b = a[c-1](a[c](b-1))
 * 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
 * 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.
 * 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: 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.

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.