User blog:KthulhuHimself/What makes an array notation?

That's right. I'm back.

I've been offline for what feels like a number of years now. I've been doing many different things, and googology wasn't one of them for the most part.

But lately I've been thinking. What is, at its heart, an array notation?

The Basis
No sooner had I begun to ponder about the matter, an answer came forth. What is an array? A set of parameters. What makes it googological? It resolves down from a set of numbers into a single number.

Well, in order to resolve we need to kick the other parameters off in some way. Ah, I know! Let's have some basic set of rules dictate how our function kicks off parameters.

But that's not enough. Let me demonstrate why.

CWAN (Comically Weak Array Notation)
Where r is the rest of the array (can be empty), and a and b are the first and last entries:

(a,r,b)=(a+b,r)

(r,0)=(r)

(a) = a

Alright. So clearly this isn't a strong array notation. Even constructs such as (10,10,10,10) only end up being equal to 40.

So where did we go wrong? Well, there's a simple reason.

We know that in order for the array to resolve, as we render it down we need at least one parameter to never grow, and that at any given step in the resolution, at least one parameter will shrink. These two are given facts, in order for the array notation to resolve into one entry, and thus into a number. The problem with CWAN is that we do this too fast.

What do I mean? Well, for starters, we eliminate an entire entry every step. This is by no means necessary. Changing this, we get the following array notation:

PWAN (Pretty Weak Array Notation)
(a,r,b)=(a+b,r,b-1)

(r,0)=(r)

(a)=a

Alright! So this is still pretty pathetic. I mean, (10,10,10,10) is still only 175. So what's still wrong?

Well, we can start by having the resolution point (as in (a)) result in something stronger.

SPWAN (Still Pretty Weak Array Notation)
(a,r,b)=(a+b,r,b-1)

(r,0)=(r)

(a)=10!!!...!!! (with a factorials)

So what do we have here? well, obviously, nested factorials are pretty incredible, and are comparable to tetration in their strength... but the array notation itself isn't anywhat powerful. The simplest demonstration of this is the fact that the arrays (3,0,3) and (3,3,0) end up being identical.

Let's look back at our two initial conditions for an array notation to resolve:

1. At least one parameter must never grow.

2. At any given point, at least one parameter must shrink.

But nothing's saying we can't have several parameters grow while one shrinks. In fact, it makes sense to have one parameter grow as much as possible while another parameter shrinks only slightly.

This is how I came up with the following array notation. It is incredibly simple, and incredibly powerful. Let's look at the rules. I call it Chungus Array Notation because memes.

CAN (Chungus Array Notation)
Principle: Any array can be substituted into a number, and vice versa.

r refers to the rest of the entire structure (which resolves into the final answer), and not just the specific array within the structure (as entries can have ranks, which can also be substituted into arrays). r can include no entries. a is the second last entry, and b is the last entry.

The rules, written formally, are as follows:

[r,a(0),b(0)]=[r,[r,a(0),b(0)],b-1(0)]

[r,b(k)]=[r,10(k-1),10(k-1),10(k-1),...b...,10(k-1)]

[b(0)] = 10!!!...b...!!!

And that's it for now! I'll explore this further in another blog post, but bear in mind... It is quite powerful. In fact, it is extrememly powerful.