User blog:Syst3ms/Introduction and Analysis of Chained Array Notation

Hi again ! Today I will make a little walkthrough of Chained Array Notation. I'm doing this because over the past weeks there have been a slew of changes to the notation all over the place, and it's just been a mess in general.

Introduction
Expressions in CAN are of the form n[array]. n is called the base, and it's a number that is used nearly everywhere, so it's very important. The most basic expression in CAN is a[0]. This is equal to \(a^a\).

This is equal to \(g_{\omega^\omega}\) in the SGH and very roughly corresponds to \(f_2\) in the FGH. Then, n[1] is n[0] repeated the base times. \(n[1] = (\cdots((n\underbrace{[0])[0])\cdots[0])}_\textrm{the base}\). 3[1] alone is too big for me to show, so I won't both making a table here. It is comparable to \(f_3\) in the FGH. n[2] is where I literally cannot show any values at all. \(2[2] = 2[1][1] = 2[0][0][1] = 4[0][1] = 256[1] = 256\underbrace{[0]\ldots[0]}_\text{256 times}\). You may have recognized it already, but this is the Mega ! In fact, a[b] in CAN is exactly equal to a[b+3] in Steinhaus-Moser notation. n[2] is comparable to \(f_4\) in the FGH. The limit of only one entry is n[n], which reaches \(f_\omega\).

Arrays !
This is where we start introducing arrays. Arrays can nest in each other freely, meaning that \([0,1,[2,5],3,[4,1]]\) is a perfectly valid array. These arrays expand exactly like Hyperfactorial Array Notation. When the first entry is superior to 1, decrease it by 1 and "chain" it the base times. When we have a string of zeroes followed with a nonzero entry (which may be in any level of nesting), decrease that entry by 1, and replace the entry before it with a copy of the array where the nonzero entry is replaced with zero. [0] always transforms into the base.

This means that n[0,1] = n0 = n[n]. Then n[1,1] = n[0,1]...[0,1]. n[0,2] = n[n,1]. n[0,0,1] = n[0,n], etc...

Analysis :
The limit of linear arrays is thus \(\varphi(\omega,0)\).

Dimensions
A separator is between curly brackets. The comma is shorthand for {0}. [... 0 {A+1} b+1 ...] = [... 0 {A} 0 {A} ... {A} 1 {A+1} b ...] where there are the base zeroes. The first special separator is {1}.

Analysis:
The limit of dimensional arrays is \(\varphi(\omega^\omega,0)\)

Hyperdimensional
Now we allow everything we've defined before inside of separators. To account for this, change every "{A+1}" above to "{A+1,#}". Then, hyperdimensional separators expand the same way as linear CAN, except that they look for the innermost set of [] brackets. For example, [0{0,1}1] is not [0{[0,0],0}1] = [0{[0]}1], it's actually [0{[0{0,0}1]}1] = [0{[0,1]}1]. Also, whenever we do any transformation to a separator, we replace [...0{#0}b+1...] with [0...0{#1}1{#0}b...], where #0 and #1 represent the separator before and after applying the rules.

Analysis:
The limit of hyperdimensional arrays is \(\psi(\varepsilon_{\Omega+1})\)

Supradimensional
Let's introduce a new separator, the pipe ! The pipe diagonalizes over everything we've done so far, as it takes a fixed point of hyperdimensional separators. Let me show some examples of expansion so that you get an intuition for how it works : \(\begin{align*} [0\{0|1\}1] &= [0\{\{0|0\}|0\}1] \\ &= [0\{\{0\}\}1] \\ &= [0\{0\{0\{\cdots\}1\}1\}1] \end{align*}\)

\(\begin{align*} [0\{0|1\}2] &= [0\{\{0|0\}|0\}1\{0|1\}1] \\ &= [0\{\{0\}\}1\{0|1\}1] \\ &= [0\{0\{0\{\cdots\}1\{0|1\}1\}1\{0|1\}1\}1\{0|1\}1] \end{align*}\)

\(\begin{align*} [0\{0|2\}1] &= [0\{\{0|0\}|1\}1] \\ &= [0\{\{0\}|1\}1] \\ &= [0\{0\{0\{\cdots|1\}1|1\}1|1\}1] \end{align*}\)

\(\begin{align*} [0\{0|0|1\}1] &= [0\{0|\{0|0\}|0\}1] \\ &= [0\{0|\{0\}\}1] \\ &= [0\{0|0\{0|0\{0|\cdots\}1\}1\}1] \end{align*}\)

(yes, I really really CBA showing the formal rules. Also they're complex.)

But we can extend pipes use hyperdimensional separators, creating "dimensional pipes". So, for example, \([0\{0|\{1\}1\}1] = [0\{0|0|\ldots|0|1\}1]\). This way, the limit of pipes is the fixed point of \(a \mapsto \{0|a1\}\). To overcome this, we have the double pipe. The double pipe acts just like the pipe, except it takes fixed points of dimensional pipes. Then we have the triple pipe, taking fixed points of dimensional double pipes, and so on.

Analysis :
[WIP]

Metadimensional
We got to the limit of finitely many pipes, so now it's time to go past that. Introducing separator arrays. The most basic form is {n@}, where @ is a separator. This is equal to @@...@@ where there are n+1 separators. Why n+1 ? Well, if you didn't notice, 0 has always been a default value, so why change now ? Then, the limit of supradimensional separators (finitely many pipes) is {[0]|}. IMPORTANT : this is NOT equal to {0,1|}. Remember, we look for outwards for the closest set of square brackets. And, of course, we can use any array inside of separator arrays, pushing the limit all the way to \(a \mapsto \{0a1|\}\).

To overcome this, we need to introduce a brand new separator, \(|_2\), the 2-pipe. The 2-pipe acts just like the regular pipe, except that it takes fixed points of pipe arrays. And, in general, the (n+1)-pipe takes fixed points of n-pipe arrays. We can also chain these together just fine. So, for example :

\(||_2\) takes a fixed point of \(a \mapsto \{0|a1|\}\).

\(|_2|\) takes a fixed point of \(a \mapsto \{0\{0|_2a1|\}1\}\)

Note that, just like \(|\) is meaningless outside of a separator, \(|_2\) is meaningless outside of a pipe array, \(|_3\) is meaningless outside of a 2-pipe array, etc. When we have a "meaningless expression", like \([0|1]\), it's going to be nested in arrays of increasing strengths until it makes sense, putting the base on the right hand side. So, \([0|1] = [0\{0|1\}a]\) and \([0|_21] = [0\{0|_21\}a] = [0\{0\{0|_21|\}a\}a]\), where \(a\) is the base.

Analysis:
[WIP]

Hyperspatial
Here we're going to take a big step forward compared to what we've done before. First off, we're going to allow metadimensional arrays inside pipe subscripts. These arrays work exactly like NCAN. In fact, pipe subscript have an implicit pair of square brackets so that everything works according to the existing rules. The limit of \(|_n\) is just \(|_{0,1}\). Then the limit of \(|_{n,1}\) is \(|_{0,2}\), and so on. Eventually we come to a stop at \(a \mapsto |_{0a1}\).

Now I introduce a brand new type of arrays, called hyperspace arrays. They use floor brackets \(\lfloor\rfloor\) and also work exactly like NCAN. Floor brackets can be considered as a type of square brackets. The pipe is just \(\lfloor0\rfloor\). But then, \(\lfloor1\rfloor\) is the fixed point mentioned above. Let it be the slash \(/\). And then we can have the same thing as with pipes, meaning double slash, triple slash, slash arrays, 2-slash, (0,1)-slash, etc...

In fact, this can be visualized spatially, through something called separator hyperspace. The first two rows of separator hyperspace are made from pipes and slashes :

Row 1 :  \(|,|_2,|_3,\ldots,|_{0,1},\ldots,|_{0,2},\ldots\)

Row 2 :  \(/,/_2,/_3,\ldots,/_{0,1},\ldots,/_{0,2},\ldots\)

etc.

Row 3 can be expressed in terms of hyperspace arrays very easily : \(\lfloor2\rfloor,\lfloor2\rfloor_2,\lfloor2\rfloor_3,\ldots,\lfloor2\rfloor_{0,1},\ldots,\lfloor2\rfloor_{0,2},\ldots\).

In general, \(\lfloor n+1\rfloor = a \mapsto \lfloor n\rfloor_{0a1}\). We can continue this until we get to \(\lfloor 0,1 \rfloor\), which diagonalizes over all \(\lfloor n \rfloor\). This is the first planar separator, and you can picture it in your mind as being on the second plane of separator hyperspace. Then we can do all of the things mentioned above, except that our base is now \(\lfloor 0,1 \rfloor\). And then we diagonalize over it using \(\lfloor 0,2 \rfloor\), the second planar separator. To diagonalize over planar separators, we have \(\lfloor 0,0,1 \rfloor\), the first cubic separator, located on the second realm of hyperspace. To diagonalize over cubic separators, we have \(\lfloor 0,0,0,1 \rfloor\), the first tesseractic separator, etc.

Eventually we get to \(\lfloor 0\{1\}1 \rfloor\), which diagonalizes over all n-dimensional separators. And then we can use the full power of hyperspatial arrays to diagonalize over all of it wildly.

The limit of hyperspace arrays is the fixed point of \(\lfloor 0a1 \rfloor\).

Analysis:
[later]

And that's it for CAN at the moment ! If you didn't get somethinf or have any questions in general, make sure to leave a comment or tag me on Discord !