Alpha Ultra Notation is the first stage of Ultra Notation. This stage includes 9 extensions, starting at Basic.
Extension: 1/9
Shorthand: BUN
This extension starts the development of Ultra Notation. In this extension, there is only the first rule called "Base rule".
- Rule 1 (Base rule): U<a> = a^2
Because this extension is simplest;
Extension: 2/9
Shorthand: 2eUN
Each extension extends the definition of the previous one. In this extension, I have added the second entry of Ultra Notation and so the second rule called "Nesting rule".
- Rule 1 (Base rule): U<a,0> = a^2
- Rule 2 (Nesting rule): U<a,b> = U<a,b-1>[a]
- Rule 2a (Leaf rule): U<a,b>[0] = a
- Rule 2b (Stem rule): U<a,b>[c] = U<U<a,b>[c-1],b>
Also, each extension have its' analysis continuing from the previous one.
- U<a,1> has FGH level 2
- U<a,2> has FGH level 3
- U<a,n> has FGH level n+1
The limit FGH ordinal of 2eUN is w.
Extension: 3/9
Shorthand: LUN
For this extension, there is an array that replaces the second entry. Now what is array? Array is the string of positive integers separated by the commas.
Starting from this extension, I have started terminology of Ultra Notation.
- Base: The first entry of Ultra Notation.
- Entry: A positive integer that is the part of array.
- Array: The string of entries that are separated by the commas.
There is also a list of shorthand starting from this extension:
- ○ - The rest of the array
I have added 2 more rules, trailing rule and process rule.
- Rule 1 (Base rule): U<a> = a^2
- Rule 2 (Nesting rule): U<a,b,○> = U<a,b-1,○>[a]
- Rule 2a (Leaf rule): U<a,○>[0] = a
- Rule 2b (Stem rule): U<a,○>[c] = U<U<a,○>[c-1],○>
- Rule 3 (Trailing rule): U<○,0> = U<○>
- Rule 4 (Process rule): Find the second non-zero entry. Then decrease that by 1 and change the preceding entry to the base.
(COMING SOON)
Extension: 4/9
Shorthand: BlUN
Starting from this extension, entries can be something else as a block. Blocks are represented as {n}, where n must be a positive integer. If n is 0, the entry is changed to 0.
(All extensions are related to Hyper Notation. Sorry Nish!)
Terminology:
- Entry: A positive integer or a block that is the part of array.
- Block: A type of entry that is represented as {n}, where n must be a positive integer.
Shorthands:
- If the last entry is a block, {n} = {n},1
Rules:
- Rule 1 (Base rule): U<a> = a^2
- Rule 2 (Nesting rule): U<a,b,○> = U<a,b-1,○>[a]
- Rule 2a (Leaf rule): U<a,○>[0] = a
- Rule 2b (Stem rule): U<a,○>[c] = U<U<a,○>[c-1],○>
- Rule 3 (Trailing rule): U<○,0> = U<○>
- Rule 4 (Process rule): Find the second non-zero entry that is not a block. Then:
- Decrease the entry by 1.
- Rule 4a (Integer rule): If the preceding entry isn't a block, change it to the base.
- Rule 4b (Block rule): Else:
- Let a be the base and c be the value in that block.
- Let S0 = 1 and S(n+1) = {c-1},Sn.
- Add Sa before the block {c}.
(COMING SOON)
Extension: 5/9
Shorthand: BaUN
To go further, values each block are turned to arrays. That's it.
Terminology:
- Block: A type of entry that is represented as {n}, where n must be an array.
Rules:
- Rule 1 (Base rule): U<a> = a^2
- Rule 2 (Nesting rule): U<a,b,○> = U<a,b-1,○>[a]
- Rule 2a (Leaf rule): U<a,○>[0] = a
- Rule 2b (Stem rule): U<a,○>[c] = U<U<a,○>[c-1],○>
- Rule 3 (Trailing rule): U<○,0> = U<○>
- Rule 4 (Process rule): Find the first non-zero entry that is neither base nor a block. Then:
- Decrease the entry by 1.
- Rule 4a (Integer rule): If the preceding entry isn't a block, change it to the base.
- Rule 4b (Block rule): Else if the first entry of the block is greater than 0:
- Let a be the base and c be the value in that block.
- Let S0 = 1 and S(n+1) = {c-1},Sn.
- Add Sa before the block {c}.
- Rule 4c (Array-in-block rule): Else, add {c} before that; where c is the result value of the block after applying rule 4.
(COMING SOON)
After this sentence, I haven't redefined the extensions yet! I warned you that you want to read these extensions later because these might be ill-defined.
Extension: 6/9
Shorthand: BnUN
Now I introduce a new special block as {L} and called it "Block Nester". You don't know what L means but I will explain in next extensions.
To go further, values each block are turned to arrays. That's it.
Terminology:
- Block: A type of entry that is represented as {n}, where n must be an array or L.
- Block Nester: A special block that the value must be L.
Rules:
- Rule 1 (Base rule): U<a> = a^2
- Rule 2 (Nesting rule): U<a,b,○> = U<a,b-1,○>[a]
- Rule 2a (Leaf rule): U<a,○>[0] = a
- Rule 2b (Stem rule): U<a,○>[c] = U<U<a,○>[c-1],○>
- Rule 3 (Trailing rule): U<○,0> = U<○>
- Rule 4 (Process rule): Find the first non-zero entry that is neither base nor a block. Then:
- Decrease the entry by 1.
- Rule 4a (Integer rule): If the preceding entry isn't a block, change it to the base.
- Rule 4b (Block Nester rule): Else if there is {L} block:
- Let c be the entry after that.
- Find the deepest block {A} such that '{L},c' is included in A. Let A = S {L},c E.
- Let D0 = 0 and D(n+1) = S Dn,{L},c E
- Add Da before the block {c}.
- Rule 4c (Block rule): Else if the first entry of the block is greater than 0:
- Let a be the base and c be the value in that block.
- Let S0 = 1 and S(n+1) = {c-1},Sn.
- Add Sa before the block {c}.
- Rule 4d (Array-in-block rule): Else, add {c} before that; where c is the result value of the block after applying rule 4.
Now we introduce a new sub-function called compare function. This was coming soon too.
(COMING SOON)
Extension: 7/9
Shorthand: CUN
Starting from this extension, L can be added, multiplied, or exponentiated to form structures. Structures also can be added, multiplied, and exponentiated by an array or an other structure.
Arrays are the members of structures and so L.
Terminology:
- Structure: A mathematical expression but replacing the values with arrays and L.
- Cascader: L (it expands the whole block to smaller blocks).
Rules:
PREVIEW: U<3,{L^(2,7)*5+4}>
(COMING SOON)
Extension: 8/9
Shorthand: xCUN
We can extend the structure to support up-arrow notation. Now we have L tetration (L^^x), L pentation (L^^^x), etc.
Terminology:
- Structure: A mathematical expression but replacing the values with arrays, L, and amount of up-arrows.
Shorthands:
- {1} = +
- {2} = *
- {3} = ^
- {n+2} = n up-arrows
Rules:
PREVIEW: U<3,{L^^L}>
(COMING SOON)
Extension: 9/9
Shorthand: nCUN
Starting from this extension, I'll not include the analysis because they will be harder to fully analyze.
PREVIEW: U<3,{U_L<L,0,1>}>