FANDOM


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)
      • 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 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:
      • 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]

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)

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.