This is my array notation.

Well duh. You knew that if you read the title.

But seriously, here we go.

## Extension 0: Basic Array Notation (BAN)

The first part looks like this:

a[c]b

To solve it, it works like this:

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

It's not too terribly hard to show that a[c]b is equal to a^^^...^^^b with c ^'s.

a[0]b = a*b

a[1]b = a[0]a[0]...a[0]a for b a's = a^b

a[2]b = a[1]a[1]...a[1]a for b a's = a^^b

a[3]b = a[2]a[2]...a[2]a = a^^^b

...

This has limit w.

## Extension 1: Two-entry Array Notation (2enAN)

We can now have two entries inside the brackets.

- a[0,0]b = a[0]b = a*b
- a[c,d]1 = a
- a[c,d]b for c > 0, b > 1 = a[c-1,d](a[c-1,d]b-1)
- a[0,d]b for d,b > 1 = a[b,d-1]a

This has limit of w^2.

a[b,0]c = a[b]c

a[0,1]b = a[b]a ~ f_w(n)

a[1,1]b = a[0,1]a[0,1]...a[0,1]a for b a's ~ f_w+1(n)

a[2[,1]b ~ f_w+2(n)

a[0,2]b = a[b,1]a ~ f_w*2(n)

a[1,2]b ~ f_w*2+1(n)

a[0,3]b ~ f_w*3(n)

a[0,4]b ~ f_w*4(n)

## Extension 2: Linear Array Notation (LAN)

Now we can have full linear array notation.

The number before the array is the base, the number after it is the iterator.

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

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then decrease the entry by 1, change the entry before it into the iterator, and change the former iterator to the base.

a[0,0,1]b = a[0,b]a ~ f_w^2(n)

a[1,0,1]b ~ f_w^2+1(n)

a[2,0,1]b ~ f_w^2+2(n)

a[0,1,1]b = a[b,0,1]a ~ f_w^2+w(n)

a[1,1,1]b ~ f_w^2+w+1(n)

a[0,2,1]b ~ f_w^2+w*2(n)

a[0,0,2]b = a[0,b,1]a ~ f_w^2*2(n)

a[1,0,2]b ~ f_w^2*2+1(n)

a[0,1,2]b ~ f_w^2*2+w(n)

a[0,0,3]b ~ f_w^2*3(n)

a[0,0,0,1]b = a[0,0,b]a ~ f_w^3(n)

a[1,0,0,1]b ~ f_w^3+1(n)

a[0,1,0,1]b ~ f_w^3+w(n)

a[0,0,1,1]b ~ f_w^3+w^2(n)

a[0,0,0,2]b ~ f_w^3*2(n)

a[0,0,0,0,1]b ~ f_w^4(n)

a[0,0,0,0,0,1]b ~ f_w^5(n)

Limit is w^w.

## Extension 3: Planar Array Notation (PAN)

This will extend the notation to two dimensions.

The number before the array is the base, the number after it is the iterator.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{1}0]b = a[#]b
- a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a comma before it, decrease the entry by 1, change the entry before it into the iterator, and change the former iterator to the base.
- If it has a {1} before it, replace the 0{1}m with 0,0,...,0,0,m-1 with b 0's, and change the former iterator to the base.

a[0{1}1]b = a[0,0,0,...,0,0,1]a for b 0's ~ f_w^w(n)

a[1{1}1]b ~ f_w^w+1(n)

a[2{1}1]b ~ f_w^w+2(n)

a[0,1{1}1]b = a[b{1}1]a ~ f_w^w+w(n)

a[0,0,1{1}1]b ~ f_w^w+w^2(n)

a[0{1}2]b = a[0,0,...,0,0,1{1}1]b ~ f_w^w*2(n)

a[1{1}2]b ~ f_w^w*2+1(n)

a[0,1{1}2]b ~ f_w^w*2+w(n)

a[0{1}3]b ~ f_w^w*3(n)

a[0{1}0,1]b = a[0{1}b]a ~ f_w^(w+1)(n)

a[1{1}0,1]b ~ f_w^(w+1)+1(n)

a[0{1}1,1]b = a[0,0,...,0,0,1{1}0,1]a ~ f_w^(w+1)+w^w(n)

a[0{1}2,1]b ~ f_w^(w+1)+w^w*2(n)

a[0{1}0,2]b = a[0{1}b,1]a ~ f_w^(w+1)*2(n)

a[0{1}0,3]b ~ f_w^(w+1)*3(n)

a[0{1}0,0,1]b = a[0{1}0,b]a ~ f_w^(w+2)(n)

a[0{1}1,0,1]b ~ f_w^(w+2)+w^w(n)

a[0{1}0,1,1]b ~ f_w^(w+2)+w^(w+1)(n)

a[0{1}0,0,2]b ~ f_w^(w+2)*2(n)

a[0{1}0,0,0,1]b ~ f_w^(w+3)(n)

a[0{1}0{1}1]b = a[0{1}0,0,...,0,0,1]a for b 0's ~ f_w^(w*2)(n)

a[0{1}1{1}1]b ~ f_w^(w*2)+w^w(n)

a[0{1}0{1}2]b ~ f_w^(w*2)*2(n)

a[0{1}0{1}0,1]b = a[0{1}0{1}b]a ~ f_w^(w*2+1)(n)

a[0{1}0{1}0,0,1]b ~ f_w^(w*2+2)(n)

a[0{1}0{1}0{1}1]b ~ f_w^(w*3)(n)

a[0{1}0{1}0{1}0{1}1]b ~ f_w^(w*4)(n)

This has limit w^w^2.

## Extension 4: Dimensional Array Notation (DAN)

This will extend it to multiple dimensions.

The number before the array is the base, the number after it is the iterator. Separators are the comma and {n}. Any {0}'s can be turned into commas.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{n}0]b = a[#]b
- a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a comma before it, decrease the entry by 1, change the entry before it into the iterator, and change the former iterator to the base.
- If it has a {n} before it, replace the 0{n}m with 0{n-1}0{n-1}...0{n-1}0{n-1}m-1 with b 0's, and change the former iterator to the base.

This has limit w^w^w.

## Extension 5: Hyperdimensional Array Notation (HDAN)

This will extend it to linear separators.

The number before the array is the base, the number after it is the iterator. Entries are separated by separators. Separators are the comma and {a,b,c,...,z} (any linear array). Any {0}'s can be turned into commas.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{%}0]b = a[#]b
- {#,0} = {#}
- a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a comma before it, decrease the entry by 1, change the entry before it into the iterator, and change the former iterator to the base.
- If it has a {n#} before it (n > 0), replace the 0{n#}m with 0{n-1#}0{n-1#}...0{n-1#}0{n-1#}m-1 with b 0's, and change the former iterator to the base.
- If it has a {0#} before it (# is not empty), restart the process from the first entry of the separator (except replacing the iterator with the base), and turn the original iterator into the base.

This has limit w^w^w^w.

## Extension 6: Nested Array Notation (NAN)

This will extend it to full nested form.

The number before the array is the base, the number after it is the iterator. Entries are separated by separators. Separators are the comma and series of entries separated by more separators. Any {0}'s can be turned into commas.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{%}0]b = a[#]b
- {#,0} = {#}
- a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a {n#} before it (n > 0), replace the 0{n#}m with 0{n-1#}0{n-1#}...0{n-1#}0{n-1#}m-1 with b 0's, and change the former iterator to the base.
- If it has a {0#} before it (# is not empty), restart the process from the first entry of the separator (except replacing the iterator with the base), and turn the original iterator into the base.

This has limit e_0.

## Extension 7: Two-entry First-order Array Notation (2enFOAN)

This will extend it to separators of form {a,_{1}b}.

From this point it is useful to define some things. A "0-separator" is a separator with no high-order separators at the outer level. A 1-separator contains at least 1 separator with a subscript 1 at the outer level, but now higher orders.

Note, Zeroth-order is normal comma.

The number before the array is the base, the number after it is the iterator. Entries are separated by separators. Separators are the comma and series of entries separated by more separators, and {x,_{1}y where x and y are numbers separated by 0-separators. Any {0}'s can be turned into commas.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{%}0]b = a[#]b
- {#,0} = {#}
- {#,
_{1}0} = {#} - a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a {n#} before it (n > 0), replace the 0{n#}m with 0{n-1#}0{n-1#}...0{n-1#}0{n-1#}m-1 with b 0's, and change the former iterator to the base.
- If it has a {0#} before it (# is not empty), restart the process from the first entry of the separator (except replacing the iterator with the base), and turn the original iterator into the base.
- If it has a ,
_{1}before it, replace the {0,_{1}n%} with S_n where S_1 = {1,_{1}n-1#} and S_(a+1) = {0{S_a}1,_{1}n-1}, where b is the iterator. and change the former iterator to the base.

That last one looks more complicated so I will give some examples:

10[0{0,_{1}1}1]n = 10[0{0{...{0{1}1}...}1}1]10 for n braces

10[0{0,_{1}2}1]n = 10[0{0{...{0{1,_{1}1}1,_{1}1}...}1,_{1}1}1]n

Note that, if the number right after the ,_{1} is 0 and there's more after it, that it would expand normally. So 10[0{0,_{1}0,1}1]n is still 10[0{0,_{1}n}1]10.

This has limit z_0.

## Extension 8: First-Order-Comma Array Notation (foCAN)

This will extend it to general separators with m^{1}.

The number before the array is the base, the number after it is the iterator. Entries are separated by separators. Separators are the comma and series of entries separated by more separators, and {x,_{1}y...,_{1}z} where x y, .. z are numbers separated by 0-separators. Any {0}'s can be turned into commas.

- a[0]b = a*b
- a[#,0]b = a[#]b; a[#{%}0]b = a[#]b
- {#,0} = {#}
- {#,
_{1}0} = {#} - a[#]1 = a
- a[c#]b =a[c-1#](a[c#]b-1)

Otherwise start the process from the first number inside the brackets:

- If it's a 0, move on to the next entry.
- If it's more than zero, then:
- If it has a ,
_{1}before it, replace the {%0,_{1}n$} with S_n where S_1 = {%1,_{1}n-1$} and S_(a+1) = {%0{S_a}1,_{1}n-1$}, where b is the iterator. and change the former iterator to the base.

This has limit phi(w,0).

## Extension 9: First-Order 0-Separator Array Notation (fo0SAN)

This will extend it first-order 0-separators.

This has limit G_0.

## Extension 10: First-Order First-Order-Comma Array Notation (fofoCAN)

This will extend it to first-order separators where the component contains ,_{1}'s.

This has limit psi(W^W^W).

## Extension 11: Nested First-Order Array Notation (NfoAN)

This will extend it to general first-order separators.

This has limit psi(e(W+1)).

## Extension 12: Second-Order Array Notation (soAN)

this will extend the above to allow 2's in the subscript as well as 1's.

This has limit psi(e(W_2+1)).

## Extension 13: Higher-Order Array Notation (hoAN)

This will extend it to higher subscripts.

This has limit psi(W_w).

## Extension 14: 0-Separator-Subscript Array Notation (0sSAN)

This will extend it to 0-separator arrays (arrays without further subscripts) in the subscript.

This has limit psi(W_W).

## Extension 15: Higher-Order-Subscript Array Notation (hoSAN)

This will extend it to higher-order separators in the subscript.

This has limit psi(W_W_w).

## Extension 16: Nested Subscript Array Notation (NSAN)

This will extend it to general nested subscripts.

This has limit psi(psi_I(0)).

## Extension 17: Legion Array Notation (LGAN)

This will introduce the legion separator /. {x/y} will become {y}_{x}. But there can be more legions.

This has limit ???

## Extension 18: ???

What will be in the future of UNAN? I haven't planned that far yet!