I have invented a new notation called GoogolX. It's earlier parts are on my user page, but here I'd like to post the definition up to linear arrays.

## Definitions

A valid expression is two numbers seperated by a capital X in curly brackets which has a subscript consisting of a number or a linear array in square brackets. For example: 39{X_{[1,2,3]}}48 is a valid expression.

"#" means 0 or more entries in an array.

"&" means a number *or* a linear array composing of one or more entries.

In the expression a{X_{&}}b, "a" is the base, "b" is the prime (I swear, I looked for half an hour for an original name and didn't find anything good) and "&" is the dimension.

In the array [#,x,y], "x" is the nester and "y" is the conductor. If there is only one number, as in [n] then it is the guide.

## Formal rules

1. a{X_{1}}b = a^^{b}a

2. a{X_{&}}1 = a^a

3. a{X_{n+1}}b+1 = a{X_{n}}(a{X_{n+1}}b)

4. a{X_{[0]}}b = a{X_{n}}b

5. a{X_{[n+1]}}b = a{X_{a{Xa{X..[n]bb}b with a{X_{[n]}}b nestings.

6. a{X_{[#,0,0]}}b = a{X_{[#,a]}}b

7. a{X_{[#,n+1,0]}}b = a{X_{[#,n,a]}}b

8. a{X_{[#,x,y+1]}}b = a{X_{[#,(a{X[#,(a{X[..a{X[#,x,y]}b..]}b}b}}b with a{X_{[#,x,y]}}b nestings.

Rules are meant to be carried out in order. If rule 1 doesn't fit, move to rule 2, if rule 2 doesn't fit, move to rule 3 and so forth.

## Informal rules

There are three types of rules here (no, I'm not talking about base, prime and catastrophic rules): rules for expressions with the dimension as a number, with the dimension as a one number "array" and as a linear array of any length.

*Dimension is a number*

1. Base rule. If the dimension is equal to 1, then the expression is equal to a^{b}a

2. Prime rule. If the prime is equal to 1 than the expression is equal a^a. This rule holds for arrays as well, but is not necessary, as all arrays will decompose to a single number.

3. Catastrophic rule. Otherwise, reduce the prime by one, change the prime into the whole expression and reduce the dimension by one. Order is important.

**Example**

3{X_{3}}3

= 3{X_{2}}(3{X_{3}}2) by rule 3

= 3{X_{2}}(3{X_{2}}(3{X_{3}}1)) by rule 3

= 3{X_{2}}(3{X_{2}}3^3) = 3{X_{2}}(3{X_{2}}27) by rule 3. This will reduce to a very big number, and is in fact equal to Conway's Tetratri, a fact I will talk about more later.

*Dimension is a number in a square bracket*

4. Prime rule. If the guide is 0, change the dimension to the base.

5. Catastrophic rule. Otherwise, nest the expression repeatedly inside the dimension, but reduce the guide by 1. The amount of nestings is equal to the whole expression with the guide reduced by 1. (Informal definitions sure can be hard).

**Example**

The example here is a bit trickier, as we must solve previous expressions first.

2{X_{[1]}}3

= 2{X_{2{X..[0].}3}3 by rule 5.

Now we have to figure out how many nestings there are to continue.

2{X_{[0]}}3

= 2{X_{2}}3 by rule 4

= 2{X_{1}}(2{X_{2}}2) by rule 3

= 2{X_{1}}(2{X_{1}}(2{X_{1}1)) by rule 3

=2{X_{1}}(2{X_{1}}2^2) = 2{X_{1}}(2{X_{1}}4) by rule 1

= 2{X_{1}}2^^{4}2 = 2{X_{1}}4 = 4 by rule 1

In fact, it's easy to show that inserting 2 as the base in a numbered dimension always results in 4 (equal to chained arrow), and since the base doesn't change, any expression that starts with a 2 will **always** be equal to 4.

*Dimension is an array*

6. Prime rule. If both the nester and the conductor are equal to 0, then cut off the conductor and change the nester to the base.

7. Prime rule. If the conductor is equal to 0, reduce the nester by 1 and change the conductor to the base.

8. Catastrophic rule. Otherwise, nest the expression repeatedly inside the nester and reduce the conductor by 1. The amount of nestings is equal to the whole expression with the conductor reduced by 1.

**Example**

Examples get very hard, but I'll do as much as I can.

3{X_{[0,1]}}3

= 3{X_{[3{X[3{X..[0,0]..3]3]}}3 = 3{X_{[3{X[3{X..[3]..3]3]}}3 with 3{X_{[0,0]}}3 = 3{X_{[3]}}3 by rule 8. How many nestings is that?

Well, 3{X_{[3]}}3 is equal to 3{X_{3{X3{X..[2]..}3}3}}3 with 3{X_{[2]}}3 nestings, which is equal to 3{X_{3{X3{X..[1]..}3}3}}3 with 3{X_{[1]}}3 nestings, which is equal to 3{X_{3{X3{X..[0]..}3}3}}3 = 3{X_{3{X3{X..3..}3}3}}3 with 3{X_{[0]}3 = 3{X_{3}}3, which is that big number we started solving before. That's pretty big!

You've solved that? Great. That's not our number with a long shot. The expression we just solved is an expression with base and prime 3 where the guide is 3. The number we need is an expression with base and prime 3 where the guide is "an expression with base and prime 3 where the guide is "an expression..."" where you say that sentence a huge number of times. In fact, the amount of times you say it is equal to an expression with base and prime 3 where the guide is 3, that number I just commented about how big it is. Woah.

## Strength

Now that you've all (hopefully) understood my notation, it's a good time to estimate it's strength.

The limit for expressions where the dimension is a nuumber is f_w2(n), just like 4 length chained arrows. In fact, the expression a{X_{n}}b is exactly equal to a->a->b->n.

The limit for expressions where the dimension is a guide (a number in square brackets) is slightly above f_w3(n), and I think around f_w3+1(n). You can see this because the nesting in the expression a{X_{[n+1]}}b is not a times, but a{X_{[n]}}b. Stronger, but maybe not enough to reach f_w3+1(n). Can anybody help here?

Now for linear arrays. As we can see, with smaller dimensions we're at the same pace as chained arrow notation, and just slightly passing it with a guide. It's easy to prove that they have at the very least the strength of chained arrows, as we are nesting the second last argument and reducing the last argument by one. However, it is stronger because of two reasons.

A) The obvious reason is that we're not nesting it once each time, we're nesting it much much more.

B) Less obvious is the the way we chop off entries. Instead of chopping off an entry when it reaches a trivial value (1 in chained arrows, 0 here) we merely reduce the entry before it by one, turn it into the base and continue nesting. Furthermore, when finally both of the last entries reduce to 0, we don't chop them both off, we chop the last one off, change the second last to the base and continue.

I hope it's clear that my notation passes chained arrow notation with ease, and so is at least f_w^{2}(n). I'm fairly sure that it passes f_w^{2}+w(n) and I think that it passes f_w^{2}2(n). f_w^{3}3(n) is my best guess for an upper bound. I'd be happy if anybody could prove me right, happier if anybody could prove that it's stronger, and grudgingly accept fate if anybody proved it weaker. Just joking. Can anybody guess something here?

### Source of strength

Now here I found an oddity. In most notations, the order of importance is: length of array, last number, second last number...prime and base. In GoogolX the thing that matters most obviously is the amount of entries in the array, then the last number, the second last number and so forth. However, due to the focus on the base in arrays, the base is actually far more important than the prime!

Furthermore, as the later entries matter most, we need to nest them as much as possible. The base is what allows us to keep nesting the important later entries, regardless of the previous entries. Therefore, with enough entries, the base will overtake the first entry entry in importance. This might happen quite early, around 4/5 entries. I think that a good lower bound is that the base passes the first 1/5th of the entries in the dimension, rounded down, and I'm sure it's possible to improve this. Anybody have a guess?

## Possible continuations?

I might continue it till basic separators, but that's probably it. I understand the charm of array notations with their beauty, complexity and strength, but I don't want to turn this into something that resembles BEAF more than my original notation. As far as I know, my array notation, while not the strongest, is pretty unique with how it decomposes entries. I aim for my notations to stay like this.

One thing I can see doing though, is changing the rules a bit. Currently, the main weakness is that the base stays the same and does not change, which is not the best option in a notation that relies so heavily

Thanks for (hopefully) reading! Thoughts, comments and corrections are welcome!