I would make the notation much more well-defined by completely remaking this notation with many tweaks, but there isn't enough time here.
Since the original definition of Username5243's Array Notation (UNAN) was ill-defined as P進大好きbot pointed out in the wiki, I decided to fix the definition of UNAN as follows:
Base rule: First, if the array is just 0, a[0]b = a × b, for a greater than 0. If the array is 1, a[1]b = a^b, 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), 0[0]b = 0 for all b, 0[1]c = 0 for c greater than 0, 0[c]1 = 0 for all c, 0[1]0 is undefined (see also 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 a[1]b, since a^b = a × a^(b-1), hence a[1]b = a[0](a[1](b-1)), which returns the same value when we apply the base rule for a[1]b.
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), 0[0]b = 0 for all b, 0[1]b = 0 for b greater than 0, 0[c]1 = 0 for all c, 0[1]0 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 fixed definition as follows:
a[0]0 = 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).
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):
If we apply the base rule, then 3[1]3[1]3 = 3[1]3^3 = 3[1]27 = 3^27 = 7,625,597,484,987
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^27 = 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^4
= 2[4]2[3]2[2]2[1]16
= 2[4]2[3]2[2]2^16
= 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)
...
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)
Since the alternative definition of UNAN is also ill-defined by the similar issues pointed out by P進大好きbot, I am going to reform the definition as follows:
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 (0,1,2,3,4,...)*. 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.
*Note: Fixed as the second alternative definition was ill-defined as 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." before P進大好きbot pointed out the similar issue again.
Since the fourth alternative definition of UNAN proposed by HaydenTheGoogologist2009 has some subtle problems, I will fix it again.
The basic array notation has the following form:
a[c]b
where all variables (a, b, c) are non-negative integers.
Rules:
Base Rule: a[0]b = a×b
Prime Rule: a[c]1 = a, a[c]0 = 1 if c > 0, a[0]0 = 0
Recursion Rule: a[c]b = a[c-1](a[c](b-1)) if b > 1 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.
The 2-entry array notation has the following form:
a[c,d]b
where all variables (a, b, c, d) are non-negative integers.
Rules:
Base Rule: a[0,0]b = a[0]b = a×b
Tailing Rule: a[c,0]b = a[c]b
Prime Rule: a[c,d]1 = a, a[c,d]0 = 1 if c > 0, a[0,d]0 = 0
Recursion Rule: a[c,d]b = a[c-1,d](a[c,d](b-1)) if b > 1 and c > 0
Hyperoperation Rule: a[0,d]b = a[b,d-1]a
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.
The linear array notation has the following form:
a[c,d,e,...,n]b
where all variables (a, b, c, d, n) are non-negative integers. It can be any number of entries.
The number before the array is the base, the number after it is the iterator.
Rules:
Base Rule: a[0]b = a×b
Tailing Rule: a[#,0]b = a[#]b
Prime Rule: a[%]1 = a, a[c,%]0 = 1 if c > 0, a[0,%]0 = 0
Recursion Rule: a[c#]b = a[c-1#](a[c#](b-1)) if b > 1 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.
Otherwise, you start the process described below from the first number inside the brackets:
Case I: If the first few entries are 0, move to the next entry until the nonzero entry.
Case II: If the entry next to the zero entry is greater than 0, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base:
a[0,0,0,...,0,0,0,n,#]b = a[0,0,0,...,0,0,b,n-1,#]a if n > 0. The process ends.
The last process ends, check if rules apply.
The planar/dimensional array notation has the following form:
a[c X d X e X ... X n]b
where all variables (a, b, c, d, n) are non-negative integers, and the X's are separators.
Now, what is a separator? Separators are the items that come between the entries. In the previous parts there was only one type of separator, the comma. Now I am making a second separator type, the brackets. In that case, the separators are the comma and {n}, where n is a non-negative integer. Commas indicate {0} separators.
The number before the array is the base, the number after it is the iterator.
Rules:
Base Rule: a[0]b = a×b
Tailing Rule: a[# X 0]b = a[#]b (X is a separator)
Prime Rule: a[%]1 = a, a[c X %]0 = 0 if c > 0, a[0 X %]0 = 0 (X is a separator)
Recursion Rule: a[c%]b = a[c-1%](a[c%](b-1)) if b > 1 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.
Otherwise, you start the process described below from the first number inside the brackets:
Case I: If the first few entries are 0, move to the next entry until the nonzero entry.
Case II: If the entry next to the zero entry is greater than 0:
II1: If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base:
a[0 X 0 X 0 ... X 0 X 0 X 0,n,#]b = a[0 X 0 X 0 X ... X 0 X 0 X b,n-1,#]a if n > 0. The process ends.
II2: If there are brackets {n} before it, where n > 0, replace the "0{n}m" with "0{n-1}0{n-1}...{n-1}0{n-1}0{n-1}1{n}m-1" where there are b zeroes between {n-1} separators, and change the iterator (b) to the base (a). In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas. The process ends.
The last process ends, check if rules apply.
The hyperdimensional array notation has the following form:
a[c X d X e X ... X n]b
where all variables (a, b, c, d, n) are non-negative integers, and the X's are separators.
In this extension, the separators are the comma and {a, b, c, ..., z}, where all a, b, c, ..., z are non-negative integers. Whenever you see a {0}, you can replace it by a comma.
The number before the array is the base, the number after it is the iterator.
Rules:
Base Rule: a[0]b = a×b
Tailing Rule: a[# X 0]b = a[#]b (X is a separator)
Prime Rule: a[%]1 = a, a[c X %]0 = 1 if c > 0, a[0 X %]0 = 0 (X is a separator)
Recursion Rule: a[c%]b = a[c-1%](a[c%](b-1)) if b > 1 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.
Otherwise, you start the process described below from the first number inside the brackets:
Case I: If the first few entries are 0, move to the next entry until the nonzero entry.
Case II: If the entry next to the zero entry is greater than 0:
II1: If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base:
a[0 X 0 X 0 ... X 0 X 0 X 0,n,#]b = a[0 X 0 X 0 X ... X 0 X 0 X b,n-1,#]a if n > 0. The process ends.
II2: If there are brackets {%} before it (% is not just 0):
II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas. The process ends.
II2.2: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same process analogous to the linear array notation: "If the entry next to the zero entry is greater than 0, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base." The process ends.
The last process ends, check if rules apply.
The nested array notation has the following form:
a[c X d X e X ... X n]b
where all variables (a, b, c, d, n) are non-negative integers, and the X's are separators.
In this extension, the separators are the comma and {m A n}, where x is an expression such that {x} is a separator, A is a separator, and n is a non-negative integer. Whenever you see a {0}, you can replace it by a comma.
The number before the array is the base, the number after it is the iterator.
Rules:
Base Rule: a[0]b = a×b
Tailing Rule: a[# X 0]b = a[#]b (X is a separator)
Prime Rule: a[%]1 = a, = a[c X %]0 = 1 if c > 0, a[0 X %]0 (X is a separator)
Recursion Rule: a[c%]b = a[c-1%](a[c%](b-1)) if b > 1 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.
Otherwise, you start the process described below from the first number inside the brackets:
Case I: If the first few entries are 0, move to the next entry until the nonzero entry.
Case II: If the entry next to the zero entry is greater than 0:
II1: If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base:
a[0 X 0 X 0 ... X 0 X 0 X 0,n,#]b = a[0 X 0 X 0 X ... X 0 X 0 X b,n-1,#]a if n > 0. The process ends.
II2: If there are brackets {%} before it (% is not just 0):
II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas. The process ends.
II2.2: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same cases analogous to the linear array notation: "If the entry next to the zero entry is greater than 0, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base." The process ends.
II2.3: If there are inner brackets nested inside outer brackets, do the same process analogous to the previous cases above. The process ends.
The last process ends, check if rules apply.
With all problems fixed up to the nested array notation, first, we could have some intended behavior for the fifth alternative definition based on the new processes right now.
A complex example:
3[0{0{0,1}1}1]3
= 3[0{0{3}1}1]3 <= Case II1+II2.1: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same cases analogous to the linear array notation: "If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base."
= 3[0{0{2}0{2}0{2}1}1]3 <= Case II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas.
= 3[0{0{2}0{2}0{1}0{1}0{1}1}1]3 <= Case II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas.
= 3[0{0{2}0{2}0{1}0{1}0,0,0,1}1]3 <= Case II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas.
= 3[0{0{2}0{2}0{1}0{1}0,0,3}1]3 <= Case II1+II2.1: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same cases analogous to the linear array notation: "If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base."
= 3[0{0{2}0{2}0{1}0{1}0,3,2}1]3 <= Case II1+II2.1: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same cases analogous to the linear array notation: "If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base."
= 3[0{0{2}0{2}0{1}0{1}3,2,2}1]3 <= Case II1+II2.1: If there are brackets {0%} before it (say, the first entry n = 0 in {n%}), move to the next entry until the nonzero entry, then do the same cases analogous to the linear array notation: "If there are commas before it, decrease the nonzero entry by 1 and change the last zero entry placed before the first nonzero entry into the iterator, and change the iterator to the base."
= 3[0{0{2}0{2}0{1}0,0,0,1{1}2,2,2}1]3
= 3[0{0{2}0{2}0{1}0,0,3{1}2,2,2}1]3
= 3[0{0{2}0{2}0{1}0,3,2{1}2,2,2}1]3
= 3[0{0{2}0{2}0{1}3,2,2{1}2,2,2}1]3
= 3[0{0{2}0{2}0,0,0,1{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{2}0,0,3{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{2}0,3,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{2}3,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0{1}0{1}1{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0{1}0,0,0,1{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0{1}0,0,3{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0{1}0,3,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0{1}3,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0,0,0,1{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0,0,3{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}0,3,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0{1}3,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0,0,0,1{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0,0,3{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}0,3,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{2}3,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0{1}0{1}1{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0{1}0,0,0,1{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0{1}0,0,3{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0{1}0,3,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0{1}3,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0,0,0,1{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0,0,3{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}0,3,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0{1}3,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0,0,0,1{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0,0,3{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{0,3,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{3,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3 <= Case II2.1: If there are brackets {n%} before it, where n > 0, replace the "0{n%}m" with "0{n-1%}0{n-1%}...{n-1%}0{n-1%}0{n-1%}1{n%}m-1" where there are b zeroes between {n-1%} separators, and change the iterator to the base. In that case, if there are brackets {1} before it, replace the "0{1}m" with "0,0,0,...,0,0,0,1{1}m-1" where there are b zeroes between commas.
= 3[0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{1,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{1,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{1,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
= 3[0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{1,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{1,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{0,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{0,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}0{0,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2{2}2,2,2{1}2,2,2{1}2,2,2}1]3
...
as the FGH approximation by fundamental sequence:
FS0: f_{ε0[6]}(3) = f_{ω^ω^ω^ω^ω}(3)
FS1: f_{ω^ω^ω^ω^3}(3)
FS2: f_{ω^ω^ω^(ω^2*3)}(3)
FS3: f_{ω^ω^ω^(ω^2*2+ω3)}(3)
FS4: f_{ω^ω^ω^(ω^2*2+ω2+3)}(3)
...
And ultimately, I decided to recreate this notation partially into the "Phenol notation", which fixes all the ill-definednesses of the original UNAN all the way to the extended array notation level (nested array notation level), except it diverges from a[0{0 / 1}1]b level since I don't want to introduce subscripts early on.