User:Username5243/Introduction and analysis of UNAN

Why am I making this on here, rather than on my site?

Because here, you can edit by sections. On Google Sites (as far as I know) there is no way to edit one sectrion at a time. This will make it easier.

Pre-alpha stage
Pre-alpha stage UNAN covers from basic to nested arrays.

I: Basic
The basic rules of UNAN are:


 * a[0]b = a*b
 * a[c+1]b+1 = a[c]a[c+1]b
 * a[c]1 = a

It is easy to show that a[c]b = a^^^...^^^b for c arrows.

The limit of the notation so far is ordinal level \(\omega\).

II: 2-entry
We now introduce a new rule:


 * a[%,0]b = a[%]b

And also introduce a new thing called process. Process start from the fist number inside the brackets. If it's a 0, we move to the next entry. Otherwise, we change the number after the brackets (called iterator) to number before it (called base), and check to the left of the nonzero entry. Since the only thing that can be left of it is the comma, the rule is:


 * If it's not 0, change the "0,c+1" into "b,c" where b is iteraor and change iterator into base.

This means that a[0,1]b = a[b,0]a = a[b]a. Then, a[1,1]b iterates over 1[0,1]b, that's expansion. Then a[0,2]b = a[b,1]a, etc. In general a[c,d]b is equal to {a,b,c,d+1} in BEAF and a[0,d]b = {a,a,b,d}.

The limit of two-entry arrays is \(\omega^2\).

III: Linear
The rules we have defined so far - the four main rules and the process rule - can be generalized to higher linera arrays. For example, 3[0,0,2,5]8 = 3[0,8,1,5]3 (not how the last 0 was replaced by the 8 and the 2 after it decreasd).

The limit of linear arrays is \(\omega^\omega\).

IV: Planar
Now it's time to introduce a new thing, called separators. Separators are the things that come between entries, and usually have {} around them. I will introduce the {1} separator here. Let's add a new rule to the process (remember, we started at the start of the brackets and looking for nonzero entries):


 * If it's got a {1} before it, change "0{1}n" into "0,0,...,0,1{1}n-1" where there are b (the iterator) 0's and change the iterator to the base.

Also, x{...}0 = x, so any 0, if it's at the end, can be chopped off along with the separator before it.

Here are some examples:

3[0{1}1]4 = 3[0,0,0,0,1{1}0]3 = 3[0,0,0,0,1]3

10[0{1}2]3 = 10[0,0,0,1{1}1]10

5[0{1}0{1}1]5 = 5[0{1}0,0,0,0,0,1]5

This will allow us to reach many rows of entries.

The limit of planar arrays is \(\omega^{\omega^2}\).

V: Dimensional
Now we introduce a sequence of separators. The first is the comma, which is short for {0}. THen comes {1}, {2}, {3}, etc. the rule for decomposing an expressions like this is:


 * If you find a nonzzero entry, and it's got a {n} before it {n >= 1), change "0{n}m" into {0{n-1}...0{n-1}1{n}m-1" for b zeroes.

So, 3[0{2}2]3 = 3[0{1}0{1}0{1}1{2}1]3.

the limit of dimensional arrays is \(\omega^{\omega^\omega}\).

VI: Hyperdimensional
Here, the separators can be linear arrays. A new rule is needed to add to the process if we reach a nonzero entry with a {0,...} before it (other cases being handled with the rule introduced last section). Here it is:


 * If there's a nonzero entry with a {0#} separator before it, change the string "0{0#}n" to "0{0#}1{0#}n-1", then jump into the first entry of that copy of {0#} and start the process there.

Note: any {x,0} separator can be replaced by {x}, just like arrays.

An example is probably needed to show the process at work:

3[0{0,2}2]3 = 3[0{0,2}1{0,2}1]3 (now jumping into the first {0,2}) = 3[0{3,1}1{0,2}1]3.

The limit is now \(\omega^{\omega^{\omega^\omega}}\).

VII: Nested
With our current rules and process we can extend all the way up to full nested arrays. Let's continue with the analysis...

The limit of pre-alpha stage is \(\varepsilon_0\).

Alpha stage
In alpha stage, we introduce subscripted separators. This works similar to EAN and mEAN in strong array notation, but also continues to array subscripts.

VIII: Primitive expanding
To begin with, let's introduce a new separator, the ,1. The ,1 is a high ranking separator, meaning it is higher level than any other separator so far, and even higher ranking than separators that contain it. If you are familiar with EAN, it works like the grave accent. The ,1 is only allowed in separators, not arrays (so a[0,11]b is meaningless).

When we encounter a separator of type {0,1n#} in the process, we do this: Change the 0,1n into Sn, wher S1 is 0,1n-1 and S(n+1) = 0{Sn}1,11.

So, 3[0{0,12}1]2 = 3[0{0{0,11}1,11}1]3 (keep in mind that if that had been a 2 before the end of the end of the array, it would have been decreased by 1 and had another {0,2} before it, as it was sent to the last case).

Note: I will use both psi function and Veblen function in comparisons.

The limit is now up to \(\zeta_0 = \psi(\Omega)\).

IX: Linear expanding
Now we expand on the previous section: The new general rule is:


 * If there is a ,1 before it then change {#0,1m+1%} into Sn, while S1 = {#0,1m%} and S(n+1) = {#0{Sn}1,1m%}.

Examples:

4[0{0,12,11}1]2 = 4[0{0{0,11,11}1,11,11}1]4

3[0{0,10,11,1}1]3 = 3[0{0,10{0,10{0,10,10,1}1,10,1}1,10,1}1]3

Here are the comparisons:

The limit is now up to \(\varphi(\omega,0) = \psi(\Omega^\omega)\).

X: Dimensional expanding
Now we need to introduce more high ranking separators. After ,1 comes {1}1, {0,1}1, {0{0,1}1}1}1 etc. using all arrays up to this point. The process rules still apply, so that {1}1 becomes rows of ,1 separators, etc.

So:

3[0{0{2}11}1]2 = 3[0{0{1}10{1}11}1]3.

Here are the comparisons:

The limit is now \(\Gamma_0 = \psi(\Omega^\Omega)\).

XI: Hyperdimensional expanding
Now, we need to alow for general {x}1 separators. The limit of the previous section is {0,11}1. Then, the limit of {x,1}1}1 is {0,12}1. We need a general process rule for finding a ,1 before you in a separator, but it is complicated to define. First, we should define layers.. The separators in the main array are in layer 0, and the separators inside layer n are in layer n+1.


 * If there's a ,1 before you, then:
 * For each 1 < t <= n where n is the layer of the ,1 separator you are looking at, take At to be the separator at that layer that contains that ,1.
 * Find the maximum t such that the At has no subscript 1, and call it a
 * Define P and Q such that b = "p,1nQ"
 * Change A into Sb, where Sa = "P,1n-1 Q" and Sn+1 = "P Sn 1,1n-1 Q".

An example might help illustrate this better:

Let's take the separator {0{0,12}11}. A is that same separator, P is "{0{0" and Q is "}11}". S1 is "{0{0,11}11}", and S2 would be {0{0{0{0,11}11}1,11}11}.

Here are comparisons for the first part of this full expanding array notation:

COMING SOON