User:Vel/pu/suprultra

A new notation! Due to the corner my extended arrow notation has pushed me into, I will start developing this notation instead.

Originally called super notation but changed because Username5243 has a notation with the same name.

Extension 0 - basic suprultra notation (BSuN)
[1](n) = nn

[x](n) = [x-1]n(n) if x > 1

This notation is equivalent to Steinhaus-Moser notation.

Extension 1 - linear array suprultra notation (LASuN)
You can now have arrays in the notation.


 * 1) is any string, $ is any string of ones.

[#,1](n) = [#](n)

[1](n) = nn

[x](n) = [x-1]n(n) if x > 1

[x,#](n) = [x-1,#]n(n) if x > 1

[1,x](n) = [n,x-1](n) if x > 1

[@,1,x](n) = [@,n,x-1](n) if x > 1

[1,x,#](n) = [n,x-1,#](n) if x > 1

[@,1,x,#](n) = [@,n,x-1,#](n) if x > 1

This reaches $$\omega^{\omega}$$. The typical approach next is to have n-dimensional structures which diagonalize over the sizes of each previous one. But here I will take an approach more similar to alemagno12's hyper notation.

On a sidenote, the notation was originally defined "flipped" so [a,b,c,...,y,z] becomes [z,y,...,c,b,a]. I changed it to be easier to work with.

Extension 2 - subblock suprultra notation (SBSuN)
Arrays can now contain arrays. It would be too difficult to type up symbolic rules so I will rewrite the definition. First, here are some definitions of things:


 * The active entry of an array is the first non-one entry if that entry is a number, or that entry's active entry if it is an array. The active entry is that of the entire array.
 * The active array of an array is itself if the first non-one entry either does not exist or is a number, if it is an array the active array is the active array of that array. The active array is that of the entire array

n is the number inside the parentheses. The active entry should always be in the active array.

Now for the rules:


 * If the entire array has no non-one entries, the expression is equal to nn.
 * If the active array has no non-one entries and it is not the entire array, replace it, and everything to the left of it in the array it is in (if such exists), with 1,1,...,1,1,2 with n 1's.
 * If the active entry is the first entry in the active array, and the active array is not the entire array, replace the active array and everything to the left of it in the array IT is in (if such exists) with n copies of it with the active entry decreased by one
 * Otherwise, decrease the active entry by one and replace the entry before it with n

This should get us to $$\varepsilon_0$$. Next stop, $$\psi(\Omega_{\omega})$$!

Extension 3 - subscripted array suprultra notation (SSASuN)
Arrays can now have subscripts - like [12] (subscripts do not count as entries in the array - yet...). They act like big omegas for an OCF to collapse. Such an OCF is built in to the notation.

We only need one new rule, but it will be complicated.

First, a definition:

Good. Now on to the rules:
 * The Nesting Block is calculated as follows: set p to the subscript of the active array. Move out into the array it is in. If its subscript is not less than p, repeat until it does. That array is the block. Non-subscripted arrays are considered to have a subscript of one. Only exists when the active array has a subscript.


 * If the entire array has no non-one entries, the expression is equal to nn.
 * If the active array has no non-one entries and it is not the entire array,...
 * If it has no subscript or that is equal to one, replace it, and everything to the left of it in the array it is in (if such entries exist), with 1,1,...,1,1,2 with n 1's.
 * If it has a subscript, set a counter z to n. Replace the active array with the nesting block with the subscript replaced with the subscript of the active array, minus one. Decrease z by one. Repeat until z is equal to 1, then replace the active array with 1.
 * If the active entry is the first entry in the active array, and the active array is not the entire array, replace the active array and everything to the left of it in the array IT is in (if such entries exist) with n copies of it with the active entry decreased by one
 * Otherwise, decrease the active entry by one and replace the entry before it with n

That should get us to $$\psi(\Omega_{\omega})$$, the strength of my entire up-arrow system. Hang on, it will get crazier.

Extension 4 - extended subscripted array suprultra notation (ESSASN)
First of all, we need a way of ranking arrays.

a < b if a < b

a > b if a > b

a = b if a = b

These are numbers.

First remove any ones directly before the end or a block.

Here is how to rank subblocks:

[A] > [B] if A > B

[A] < [B] if A < B

[A] = [B] if A = B

Good. Any block is greater than any number. Now here is how to deal with subscripts:

[A] = [A1]

[Aq] < [Br] if q < r

[Aq] > [Br] if q > r

[Ap] < [Bq] if p = q and A < B

[Ap] > [Bq] if p = q and A > B

Good.

If the arrays have no blocks, they are compared like this:

If the length of one array is greater than another, the former array is greater. than the latter one. Same goes with less. Generally, if A > B, B < A, and vice versa. A = B means B = A and vice versa.

Let X and Y be the rest of the arrays and x and y be numbers:

X,a > Y,b if a > b

X,a < Y,b if a < b

X,a > Y,b if a = b and X > Y

X,a < Y,b if a = b and X < Y

Find the highest ranking block in A and B. Call them z(A) and z(B)

A > B if z(A) > z(B)

A < B if z(A) < Z(B)

If z(A) = z(B), remove last instance of said block and call it c(A) and c(B)

A > B if c(A) > c(B)

A < B if c(A) < c(B)

A = B if c(A) = c(B)

This was quite a lot. Now for some definitions...


 * The pseudo-active entry of an array is the active entry if the active array has no subscript, or the pseudo-active entry of the array in the subscript if not.
 * The pseudo-active array of an array is the active array if it has no subscript or a subscript with only ones or a numerical first non-one entry, or the pseudo-active array of the array in the subscript otherwise.
 * The pseudo-nesting block is like the block but calculated from the pseudo-active array, not the active array. When you leave a subscript to go into the array it is in, set z to the subscript array you left.

The new rules are analogous to rules that are already in place.


 * If the entire array has no non-one entries, the expression is equal to nn.
 * If the active array has no non-one entries and it is not the entire array,...
 * If it has no subscript or that is equal to one, replace it, and everything to the left of it in the array it is in (if such entries exist), with 1,1,...,1,1,2 with n 1's.
 * If it has a subscript where the first entry is non-one, set a counter z to n. Replace the active array with the nesting block with the subscript replaced with the subscript of the active array, with the first entry decreased by one. Decrease z by one. Repeat until z is equal to 1, then replace the active array with 1.
 * Otherwise,...
 * If the pseudo-active entry is preceded by a one, decrease the entry by one and set said one to n.
 * If the pseudo-active entry is the first in the pseudo-active array, replace that array and everything to the left of it in the array IT is in (if such entries exist) with n copies of the pseudo-active array with its first entry decreased by 1.
 * If the pseudo-active entry does not exist and the pseudo-active array has no subscript or a one-only subscript, replace said array and everything to the left of it in the array it is in (if such entries exist), with 1,1,...,1,1,2 with n 1's.
 * If the pseudo-active entry does not exist and the pseudo-active array has a subscript, set a counter z to n. Replace the pseudo-active array with the pseudo-nesting block with the subscript replaced with the subscript of the pseudo-active array, with the first entry decreased by one. Decrease z by one. Repeat until z is equal to 1, then replace the active array with 1.
 * If the active entry is the first entry in the active array, and the active array is not the entire array, replace the active array and everything to the left of it in the array IT is in (if such entries exist) with n copies of it with the active entry decreased by one
 * Otherwise, decrease the active entry by one and replace the entry before it with n

And if everything works the way it should, it should reach the power of $$\psi(\psi_{I}(0))$$.

Extension 5 - planar array super notation (PASuN)
Preview:

[12] is a diagonalizer of [...]

[13] is a diagonalizer of [...2]

[14] is a diagonalizer of [...3]

[15] is a diagonalizer of [...4]

[1x] if x > 1 is a diagonalizer of [...x-1]

[1x,#] if x > 1 is a diagonalizer of [...x-1,#]

[AB] will change to [A;B]. So that becomes:

[1;2] is a diagonalizer of [...]

[1;3] is a diagonalizer of [...;2]

[1;4] is a diagonalizer of [...;3]

[1;5] is a diagonalizer of [...;4]

[1;x] if x > 1 is a diagonalizer of [...;x-1]

[1;x,#] if x > 1 is a diagonalizer of [...;x-1,#]

[1;1;2] is a diagonalizer of [1,...]!

Numbers

 * Vincol = [1](20)
 * Viterincol = [2](20)
 * Vithrincol = [3](20)
 * Viterrincol = [4](20)
 * Vipetincol = [5](20)
 * Vigectincol = [6](20)
 * Vigeptincol = [7](20)
 * Vigogdincol = [8](20)
 * Vignovincol = [9](20)
 * Viddekincol = [10](20)
 * Vinsomega = [1,2](20)
 * Vinsogiga = [1,3](20)
 * Vinsotera = [1,4](20)
 * Vinsopeta = [1,5](20)
 * Vincexa = [1,6](20) (vin-sexa)
 * Vinzetta = [1,7](20)
 * Vincotta = [1,8](20) (vin-sotta)
 * Vincxena = [1,9](20) (vin-seena)
 * Vinsodeka = [1,10](20)
 * Vinsquarel = [1,1,2](20)
 * Vincubel = [1,1,1,2](20)
 * Vintessarel = [1,1,1,1,2](20)
 * Vinpentil = [1,1,1,1,1,2](20)
 * Vintexon = [1,1,1,1,1,1,2](20)
 * Vintepton = [1,1,1,1,1,1,1,2](20)
 * Vintogdon = [1,1,1,1,1,1,1,1,2](20)
 * Vincennon = [1,1,1,1,1,1,1,1,1,2](20) (vin-sennon)
 * Vindekon = [1,1,1,1,1,1,1,1,1,1,2](20)
 * Toprincol = 1(20)
 * Duotoprincol = 1],[1(20)
 * Triotoprincol = 1],[1],[1(20)
 * Boprincol = 2(20)
 * Troprincol = 3(20)
 * Toquarpincol = 1,2(20)
 * Tocupincol = 1,1,2(20)
 * Toterpincol = 1,1,1,2(20)
 * Thropincol = [1](20)
 * Vropincol = [[1]](20)
 * Fropincol = [[[1]]](20)
 * Stropincol = [[[[1]]]](20)
 * Vepsillia = 12(20) = [[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]](20)

Tiers
The idea of tiers is that they divide a part of a notation into portions limited at the end of the part. In other words, tiers are a sequence from the start of the part of the notation to the end of the part. This can be applied to any notation that can be divided into parts or ranges.

Here are the tiers of super notation:

...
 * BSN Tier 1: [1]
 * BSN Tier 2: [2]
 * BSN Tier 3: [3]
 * BSN Tier 4: [4]
 * BSN Tier 5: [5]

...
 * LASN Tier 1: [1,2] to [1,1,2]
 * LASN Tier 2: [1,1,2] to [1,1,1,2]
 * LASN Tier 3: [1,1,1,2] to [1,1,1,1,2]
 * LASN Tier 4: [1,1,1,1,2] to [1,1,1,1,1,2]
 * LASN Tier 5: [1,1,1,1,1,2] to [1,1,1,1,1,1,2]

...
 * SBSN Tier 1: 1 to [1]
 * SBSN Tier 2: [1] to [[1]]
 * SBSN Tier 3: [[1]] to [[[1]]]
 * SBSN Tier 4: [[[1]]] to [[[[1]]]]
 * SBSN Tier 5: [[[[1]]]] to [[[[[1]]]]]

...
 * SSASN Tier 1: 12 to  13
 * SSASN Tier 1: 13 to  14
 * SSASN Tier 1: 14 to  15
 * SSASN Tier 1: 15 to  16
 * SSASN Tier 1: 16 to  17

...
 * ESSASN Tier 1: 1[1] to  1[1 [1 ]]
 * ESSASN Tier 2: 1[1 [1 ]] to  1[1 [1 [1 ] ]]
 * ESSASN Tier 3: 1[1 [1 [1 ] ]] to  1[1 [1 [1 [1 ] ] ]]
 * ESSASN Tier 4: 1[1 [1 [1 [1 ] ] ]] to  1[1 [1 [1 [1 [1 ] ] ] ]]
 * ESSASN Tier 5: 1[1 [1 [1 [1 [1 ] ] ] ]] to  1[1 [1 [1 [1 [1 [1 ] ] ] ] ]]

...
 * PASN Tier 1: 1;1;2 to 1;1;1;2
 * PASN Tier 2: 1;1;1;2 to 1;1;1;1;2
 * PASN Tier 3: 1;1;1;1;2 to 1;1;1;1;1;2
 * PASN Tier 4: 1;1;1;1;1;2 to 1;1;1;1;1;1;2
 * PASN Tier 5: 1;1;1;1;1;1;2 to 1;1;1;1;1;1;1;2