User blog:KthulhuHimself/Redefining and properly analysing Chungus Array Notation (CAN)

So, I've lately thought of an incredibly powerful array notation, and a very simple one at that.

BANANA (Branching Amplification Nested Array Notations Applied)
Basically, I'll forego the unnecessary introduction (how I came up with it), it's a cool array notation and that's what matters.

Principles
We have an array, which in turn can contain smaller arrays. When solving an entire array, one searches for an array with it which contains no smaller arrays, which will be called Q. (Example: in [a,b,[c,d]], [c,d] is considered Q, while [a,b,[c,d]] is considered A). We notate the entire array itself K. Lowercase r will refer to the rest of a given A, while g will refer to the entirety of A with the second last entry reduced by one. a and b are the two last entries of Q.

Linear Arrays
Pretty intuitive place to start, wouldn't you think?

Rules for Linear Arrays
For one entry: [a] = 10!!!...a...!!!

If last entry is zero: [a,0] = [a]

If second last entry is zero: [r...0,b] = [r...10,b-1]

Otherwise:

Given that Q = [r...a,b],

Q = [r...[K],b-1].

Simple enough, huh? Well, I'll let you know that this is an unusually powerful array notation, already at this point. Why you ask? It's simple, really, and hinges on the fact that when solving an array within the overall structure, we use the overall structure to solve it. I'll demonstrate this using FGH, as such:

FGH Analysis for Linear Arrays
Let's start simple, with

[n,1] = n-1,1],0] = [[n-1,1

Since [n] is nested factorials (FGH ordinal of 4), and since the second entry here basically nests that n times, we get that:

[n,1] ~ f5(n)

Next obvious stage, is

[[n,1],1]

Woah, woah, woah, I can already hear you asking, shouldn't [n,2] be the next obvious step? Well, in fact, that wouldn't be the case. Remember what I said about how arrays within the master array utilise the full structure itself? The resulting array is actually much larger than one would expect, since: n,1],1]=[[[[n-1,1],1,1]. We see that when replacing some given entry n in an array with the array [n,1], we increase its place in FGH by 1, since this effectively nests the surrounding structure n times within n. Compelling, isn't it? We get that:

[[n,1],1] ~ f6(n)

Clearly,

[[[n,1],1],1] ~ f7(n)

And so on.

Well, so what about [n,2]? The result is quite simple, and yet admirably powerful.

[n,2] = [[n-1,2],1]

Well, alright then. We get the [n,1] structure, nested n times. Since each nesting increases the FGH by 1,

[n,2] ~ fw(n)

Now, I'll give you a little spoiler here and tell you ahead of time that [1,n] corresponds with fw^w(n) in FGH, but don't believe me, as I'll show you it now!

[[n,1],2] ~ fw+1(n)

[[[n,1],1],2] ~ fw+2(n)

[[n,2],2] ~ fw*2(n)

[[[n,2],2],2] ~ fw*3(n)

[n,3] ~ fw^2(n)

[n,4] ~ fw^3(n)

[n,m] ~ fw^m(n)

Now we can see why [0,n] is so powerful. We're at two entries, and already at fw^w(n), wow!

Now, obviously, [0,[n,1]] ~ fw^w+1(n), but why not check what three entries gives us?

(A little fiddling with the notation showed me that I can replace any given entry n with [0,n] to increase the FGH by w^w, meaning that [0,[0,[0,n]]] would correspond with fw^w*3.)

[0,n,1] = [0,[0,n-1,1]]

This nests that little [0,n] structure n times, giving us an array, the strength of which reaches the fun fw^(w+1)(n) FGH value.

Now that some ground work has been placed down, it's time to just list a few other good examples, in general, linear arrays bring us to the following conclusion:

[0,0,0,...,0,n] with m zeros corresponds with the FGH function of fw^(w*m)(n). That's pretty strong, but still a bit limited. How can we extend this function in a meaningful way? I mean, we've only really touched on linear functions, and have already gone past a lot of other popular functions, not to mention popular array notations. Linear BANANA is already much stronger than many other linear array notations, but how can we make sure it doesn't fall behind once we hit other notatable dimensions? Stay tuned until the next update!

Trans-Linear Arrays
Stay tuned!