User blog:Syst3ms/Chained Array Notation

Hi, this is my new attempt at making a powerful notation, and this time I think I got it.

Step 1 : Bare-bones (BBCAN) :

This has only one rule.

$$a[0] = a^a$$

The limit of this notation is n[0]...[0] with n [0]'s

Step 2 : Single Entry (SECAN) :

with a [b]'s (evaluated from left to right)

n[1] = n[0]...[0] with n [0]'s

Now it's pretty easy to see that this is basically Steinhaus-Moser notation, so 2[2] is the Mega. a[b] in CAN is equal to a[b+3] in Steinhaus-Moser notation.

The limit of this system in the FGH is.

Now let's add more entries.

Step 3 : Linear (LCAN) :

Let # be any string of numbers

$$a[0] = a^a $$ $$a[\#,0] = a[\#] $$ $$a[b+1,\#] = a[b,\#][b,\#]\cdots[b,\#] \text{ with a [b,#]'s} $$ $$a[0,\ldots,0,b+1,\#] = a[a,\ldots,a,b,\#]$$

Since n[0,1] = n[n], [0,1] has strength n[1,1] = n[0,1]...[0,1], so [1,1] has strength Hence, n[a,1] has strength Therefore, 64[1,1] > Graham's number

[0,2] has strength [a,2] has strength [0,3] has strength [a,b] has strength

The limit of LCAN is

Step 4 : Nested (NCAN) :

Now we can nest brackets. A valid array would be [1,[0,1],[3]]

The previous rules still apply. If none of the rules apply, start the following process, starting at the first entry : 1) If the entry is a 0, jump to the next entry. 2) Otherwise, it is an array : 2a) First, remove trailing zeroes, if any 2b) If the entry is [0], replace it with the base. 2c) If the entry is of the form [b+1,#], then remove decrease b by 1 and make a-1 copies of it, where a is the base. 2d) If the entry is of the form [0,...,0,b+1,#], replace it with [a,...,a,b,#], where a is the base. 2e) Otherwise, start the process inside the entry.

with n n's

Step 5 : Super-nested (SNCAN) :

This time we introduce more powerful brackets, the first of which being {}

Then we can have <>, etc. To generalize, we can have []_2 be {}, []_3 be <>, etc. []_0 are null brackets, which are just a fancy name for the absence of brackets.

All previous rules still apply. Inside the base rules, we add the following rule after the first one : $$ a[0]_{b+1} = a[ [ \cdots [a]_b \cdots ]_b ]_b $$

This rule replaces step 2a inside of the process.

Since we replaced step 2a altogether, what happens when we do n[￸[0]] ? Well, it is equal to n[((..(n)...))] where are null brackets. Since those mark an absence of brackets, it is really equal to n[n] with n brackets with n brackets n{0,1} = n{n}

We can even nest multiple types of brackets.

This means that [[{1}],3,[1,{0}],[1,1]_4] is a perfectly valid array.

The limit of this notation is n[0]_n

Now here's some stuff that I will properly define later :

$$n[0]_{0,1} = n[0]_{[0]} = n[0]_n$$ $$n[0]_{[1]} = n[0]_{[0]}[0]_{[0]} = n[0]_n[0]_{[0]}$$ $$2[0]_{[1]} = 22[0]_{[0]} = 22[0]_{22}$$ $$2[0]_{[0]_{[0]}} = 2[0]_{\{0\}} = 2[0]_{2} = \ldots = 2[0]_{[2,2,[1]]} = 2[0]_{[1,2,[1]]}[0]_{[1,2,[1]]} = \ldots$$

[WIP]