Since Aarex made the array notation here, I will make one too.

It is very similar to AAN at the beginning, but both notations eventually split paths.

You can find the analysis for this notation here.

WIP!

## Base rules

a is called the base.

- Let # is the rest of the expression.
- n(a) = a+1
- n(a|1) = n(a)
- n(a|# 1) = n(a|#)
- n(a|b #) = n(a|b #)[a]
- n(a|b #)[1] (b > 1) = n(a|b-1 #)
- n(a|b #)[c] (b,c > 1) = n(n(a|b #)[c-1]|b-1 #)
- Else, follow the process, starting from the second entry of the array.

## Simple AMAN (sAMAN)

**Growth Rate: **ω^{ω}

Here, arrays are of the form a,b,c,..., where a,b,c,... are positive integers.

### Process

Note that Case 2 is terminal but Case 1 is not.

Let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

## Extended AMAN (exAMAN)

**Growth Rate: **ω^{ωω}

Here, arrays are of the form a{b}c{d}e{f}..., where a,b,c,d,e,f,... are positive integers.

Note that the comma is the same as {1}.

### Process

Note that cases 2.1 and 2.2 are terminal but Case 1 is not.

Let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1, look to your left.**Case 2.1:**If there's a {1} inmediately before you:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

**Case 2.2:**If there's a {x} (x > 1) inmediately before you:- Decrease the value of the entry by 1.
- Make a copy of the separator inmediately before you. Call it S.
- Decrease the number inside of S by 1.
- Replace the previous entry by A[S|a], where a is the base.
- The process ends.

### Functions

Let % is a separator.

- A[%|1] = 1%2
- A[%|x] (x > 1) = 1%A[%|x-1]

## Nested AMAN (ntAMAN)

**Growth Rate: **ε_{0}

Here, arrays are of the form a{A}b{B}c{C}..., where A,B,C,... are arrays and a,b,c,... are positive integers.

Note that the comma is the same as {1}.

### Process

Note that cases 2.1 and 2.2 are terminal, but cases 1 and 2.3 are not.

A separator indirectly contains an array if the separator contains the array or if it contains an array with a separator that indirectly contains the array.

Let # is the rest of the array, and let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1, look to your left.**Case 2.1:**If there's a {1} inmediately before you:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

**Case 2.2:**If there's a {x #} (x > 1) inmediately before you:- Decrease the value of the entry by 1.
- Make a copy of the separator inmediately before you. Call it S.
- Decrease the value of the first entry of the array inside of S by 1.
- Replace the previous entry by A[S|a], where a is the base.
- The process ends.

**Case 2.3:**If there's a {1 #} (where # is not empty) inmediately before you:- Delete all of the entries with value 1 in the array inside of the separator inmediately before you (but only delete the entries before the last entry in that array with a value that is bigger than 1)
- Call the separator inmediately before you S. Then, replace the previous entry with 1S2. Call the new S as T.
- Jump to the second entry of the array inside of T.

### Functions

Let % is a separator.

- A[%|1] = 1%2
- A[%|x] (x > 1) = 1%A[%|x-1]

## Expanding AMAN (epAMAN)

**Growth Rate: **BHO

Here, arrays are of the form a%{A}b%{B}c%{C}..., where A,B,C,... are arrays, a,b,c,... are positive integers, and % can be empty or /.

Note that the comma is the same as {1} and / is the same as /{1}.

### Process

Note that cases 2.1, 2.2 and 2.3 are terminal, but cases 1 and 2.4 are not.

A separator indirectly contains an array if the separator contains the array or the separator contains another array with a separator that indirectly contains the array.

Let # is the rest of the array, and let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1, look to your left.**Case 2.1:**If there's a {1} inmediately before you:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

**Case 2.2:**If there's a /{1} inmediately before you:- Decrease the value of the entry by 1.
- Look at the array that the entry is on. Call it A.
- Find the separator of the form {B} (where B is an array) that indirectly contains A but the array that contains that separator isn't indirectly contained inside of another separator of the form {B} (if no such separator exists, then the separator will be the entire array inside of {}). Call that separator S.
- Call the entry X and the array that contains X as Y.
- Repeat this a times, where a is the base:
- Replace the previous entry with 1S2, then find the separator inside of S that contains Y, then find X in Y.
- Jump to the X that you found.

- The process ends.

**Case 2.3:**If there's a /{x #} or {x #} (x > 1) inmediately before you:- Decrease the value of the entry by 1.
- Make a copy of the separator inmediately before you. Call it S.
- Decrease the value of the first entry of the array inside of S by 1.
- Replace the previous entry by A[S|a], where a is the base.
- The process ends.

**Case 2.4:**If there's a /{1 #} or {1 #} (where # is not empty) inmediately before you:- Delete all of the entries with value 1 in the array inside of the separator inmediately before you (but only delete the entries before the last entry in that array with a value that is bigger than 1)
- Call the separator inmediately before you S. Then, replace the previous entry with 1S2. Call the new S as T.
- Jump to the second entry of the array inside of T.

### Functions

Let % is a separator.

- A[%|1] = 1%2
- A[%|x] (x > 1) = 1%A[%|x-1]

## Multiexpanding AMAN (mepAMAN)

**Growth Rate: **>> Ψ(Ψ(Ψ_{λ0}(0),1))

Here, arrays are of the form a/^{x}{A}b/^{y}{B}c/^{z}{C}..., where A,B,C,... are arrays, a,b,c,... are positive integers, and x,y,z,... are non-negative integers.

A separator indirectly contains an array if the separator contains the array or the separator contains another array with a separator that indirectly contains the array.

Note that the comma is the same as {1}, /^{x} is the same as /^{x}{1}, and a string of x /'s is the same as /^{x}.

### Process

Note that cases 2.1, 2.2 and 2.3 are terminal, but cases 1 and 2.4 are not.

Let # is the rest of the array, and let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1, look to your left.**Case 2.1:**If there's a {1} inmediately before you:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

**Case 2.2:**If there's a /^{x}{1} (x > 0) inmediately before you:- Decrease the value of the entry by 1.
- Look at the array that the entry is on. Call it A.
- Find the separator of the form /
^{x-1}{B} (where B is an array) that indirectly contains A but the array that contains that separator isn't indirectly contained inside of another separator of the form /^{x-1}{B} (if no such separator exists, then the separator will be the entire array inside of /^{x-1}{}). Call that separator S. - Call the entry X and the array that contains X as Y.
- Repeat this a times, where a is the base:
- Replace the previous entry with 1S2, then find the separator inside of S that contains Y, then find X in Y.
- Jump to the X that you found.

- The process ends.

**Case 2.3:**If there's a /^{x}{y #} (y > 1) inmediately before you:- Decrease the value of the entry by 1.
- Make a copy of the separator inmediately before you. Call it S.
- Decrease the value of the first entry of the array inside of S by 1.
- Replace the previous entry by A[S|a], where a is the base.
- The process ends.

**Case 2.4:**If there's a /^{x}{1 #} (where # is not empty) inmediately before you:- Delete all of the entries with value 1 in the array inside of the separator inmediately before you (but only delete the entries before the last entry in that array with a value that is bigger than 1)
- Call the separator inmediately before you S. Then, replace the previous entry with 1S2. Call the new S as T.
- Jump to the second entry of the array inside of T.

### Functions

Let % is a separator.

- A[%|1] = 1%2
- A[%|x] (x > 1) = 1%A[%|x-1]

## Nested Expanding AMAN (ntepAMAN)

**This part doesn't work.**

Here, arrays are of the form a/^{X}{A}b/^{Y}{B}c/^{Z}{C}..., where A,B,C,... are arrays, a,b,c,... are positive integers, and X,Y,Z,... are arrays or 0.

A separator indirectly contains an array if the separator contains the array or the separator contains another array with a separator that indirectly contains the array.

Note that the comma is the same as {1}, /^{X} is the same as /^{X}{1}, and a string of x /'s is the same as /^{x}.

### Process

Note that cases 2.1, 2.2 and 2.4 are terminal, but cases 1, 2.3 and 2.5 are not.

Let # is the rest of the array, and let the entry is the entry that you're on.

**Case 1:**If the value of the entry is 1, jump to the next entry.**Case 2:**If the value of the entry is bigger than 1, look to your left.**Case 2.1:**If there's a {1} inmediately before you:- Decrease the value of the entry by 1.
- Change the value of the previous entry to the base.
- The process ends.

**Case 2.2:**If there's a /^{x #}{1} (x > 0 if # is empty, x > 1 otherwise) inmediately before you:- Decrease the value of the entry by 1.
- Look at the array that the entry is on. Call it A.
- Find the separator of the form /
^{x-1 #}{B} (where B is an array) that indirectly contains A but the array that contains that separator isn't indirectly contained inside of another separator of the form /^{x-1 #}{B} (if no such separator exists, then the separator will be the entire array inside of /^{x-1 #}{}). Call that separator S. - Call the entry X and the array that contains X as Y.
- Repeat this a times, where a is the base:
- Replace the previous entry with 1S2, then find the separator inside of S that contains Y, then find X in Y.
- Jump to the X that you found.

- The process ends.

**Case 2.3:**If there's a /^{1 #}(where # is not empty) inmediately before you:- Delete all of the entries with value 1 in the array inside of the subscript of the separator inmediately before you (but only delete the entries before the last entry in that array with a value that is bigger than 1)
- Jump to the second entry of the array that is the superscript of T.

**Case 2.4:**If there's a /^{X}{y #} (y > 1 and X is an array or 0) inmediately before you:- Decrease the value of the entry by 1.
- Make a copy of the separator inmediately before you. Call it S.
- Decrease the value of the first entry of the array inside of S by 1.
- Replace the previous entry by A[S|a], where a is the base.
- The process ends.

**Case 2.5:**If there's a /^{X}{1 #} (where # is not empty and X is an array or 0) inmediately before you:- Jump to the second entry of the array inside of T.

### Functions

Let % is a separator.

- A[%|1] = 1%2
- A[%|x] (x > 1) = 1%A[%|x-1]

## Planned parts

- Simple Array Expanding AMAN (saepAMAN)
- Array Expanding AMAN (aepAMAN)
- Second-Order Expanding AMAN (soepAMAN)
- Second-Order Array Expanding AMAN (soaepAMAN)
- Higher-Order Expanding AMAN (hoepAMAN)
- Array-Order Expanding AMAN (aoepAMAN)