User blog:Lord Aspect/Astral Overload

Astral Overload Multilevel Function (AOMLF, or AO for short) is my most powerful notation yet. It has been made from a lot of my recent and old ideas, assembled together into something incomparably beyond all my previous notations... Ever. It can be sorta comedically described as "Psi-Notation with more levels, except it's not messy and some of the levels are recent slow functions that have been implanted as support". Regardless, let's begin.

Important info
This will be used because I couldn't explain something important in this notation
 * 2+2=4
 * 2+2 - Input row
 * 4 - Output row

Load 1: Linear arrays
The primary rule: Other rules:
 * X&[a] = a^(a-1)^...^2^1 (Reverse factorial of a, except multiplication is replaced by exponentiation.
 * X&[S, 1] = X&[S] (Regardless of the row S, if the last entry is 1, it can be ignored and/or removed)
 * X&[a,b] = X&[X&[X&...[a]...] with b "X"s. (Second entry is the amount of repetitions in the function's loop.)
 * X&[a,b,c] = X&[a,X&...X&[a,b] ... ] with c "X"s. (For any further entries, do the same, except:
 * Remove the last entry in the row you're going to repeat.
 * Insert every repetition instead of the pre-last entry of a previous one.
 * Include this entry in final repetition.
 * The entry you've removed earlier is the amount of repetitions.

Load 1.5: Linear array accelerator

 * X&&[a,b] = X&[a,a,a,a,a,a,a,a,... (b) ....] (Two & marks between X and an array with two entries equals X with one & mark and an array with first entry being repeated second entry times.)
 * X&&[a,b,...,z] = X&[a,b,...,a,b,...,a,b,... (z each) ....] (For more entries, do the same, except last entry marks the amount of repetitions of all entries (All of them are being included, but they are in the same array, which basically means:
 * m = Amount of entries in X&& array, n = Amount of entries in X& array and z - the last entry of X&& array, thus, n = (m-1)*z )
 * X&&&[a,b] = X&&[a,a,a,a,a... (b) ....] (For more & marks do the same, except the output row has one more less & than input row.)

Load 2: Polyarrays (Array Rows)

 * X&[...]&[1] = X&[...] (If the last row is just 1, it can be removed)
 * X&[a,b]&[a1] = X&...&[a,b] with X&[a1] "&"s (The second row with just one entry is the amount of &s used when boosting the first row.)
 * X&[a,b]&[a1] = X&...&[a,b] (X&[a1] &'s) (Same can be applied to more entries in the second row.)
 * X&[a,b,c]&[a1,b1,c1] = X&...&[a,b,c] (X&[a1,b1,c1] &'s) (The same but with three entries in both rows.)
 * X&[a,b]&[a1,b1]&[a2,b2] = X&...&[a,b] (X&...&[a1,b1] (X&[a2,b2] &'s) &'s) (n+2th row is related to n+1th row the way n+1th row is related to nth row. The example has three rows.)

Load 2.5: Polyarray accelerator

 * X@[a] = X&[a,a-1,...1]&[a-1,a-2,...1]& ... &[2,1]&[1] (For X@(a), do an X& row of arrays, that starts from [a, a-1, ..., 1] (a casually going down to one), then put another & and copypaste the same row, except you should reduce all numbers by 1 and remove any zeroes or negatives. Repeat until the row reaches 1.)
 * X@[a,b] = X&...&[a,a-1]... ... ...&[1] (b &'s) (Second entry equals amount of &s between arrays in the row.)
 * X@[a,b,c] = X&...&[a,a-1]... ... ...&[1] (X&[b,b-1]...&[1] (c &'s)) (Ordinary recursion applied.)

Load 3: Matrix

 * Martix.png@[S1] is Load 2.5 ordinary polyarray accelerator.
 * X@[S1]@[S2] defines the abomination to the left.
 * X@[S1]@[S2]@[S3] defines the same thing, except grid has one more dimension (Cube instead of square)