Beyond Graham's number

Welcome to the second part of the Large Numbers series! If you got here without reading part one first, I recommend starting with it. Here you are.

It's interesting to watch the reactions of people who find out about Graham's number (G). Almost everybody falls into one of three categories:

1) Some people don't get the idea. They try to calculate G or compare it to the real world, something we have shown to be pointless.

2) Some do. These people have the expected reaction of respect towards large numbers and walk away with food for thought.

3) Then, of course, somebody just states:

"G+1! Muhahahaha!!!"

And a new contest opens with other, larger numbers.

The first two reactions are covered by part one. Part two will discuss the various ways to get much larger numbers.

Bad ideas

It's easy to make serious mistakes when dealing with large numbers because they are too huge to be intuitively comprehensible. All the mistakes have in common the fact that they don't produce any new ideas.

(G!!*g(5)+A(8,8,9,3656541))↑↑↑↑↑↑↑↑↑↑↑↑999999999999999999999999!!!!!!

If you hear about several numbers or functions but have no idea how they work, you may attempt to combine them in a way similar to the monstrosity above. While combining several large numbers with factorials, arrows, multiplication etc. might seem promising, it's a mistake. You're matching things together at random without any idea what you're doing. A factorial is a very weak function at a similar level to exponentiation. The A is Ackermann's function, which, however, cannot be used like this and makes no sense. Even if we ignore this there's still the problem that you're using G, a number far too large to be seriously affected by the functions here. The strongest function is the bunch of arrows, which, however, is still nothing compared to the g₆₃ arrows in G. This means that the whole number mentioned doesn't make sense, and even if we remove the broken part, is just a little larger than G (and way smaller than g₆₅).

Lesson from this: Have some idea what you're doing.

Infinity!!!

It has been mentioned a hundred times that infinity is not a number. Even if it was, there are various types of infities (cardinal numbers, ordinal numbers and others), with so many infinities that it would break mathematics if not contained (this is not exaggeration, there are paradoxes related to the set of all ordinal numbers) and there are different kinds of infinities with different applications. If you play the infinity card, the better option is that you will be told that you don't understand infinities and the worse option is that people will try to educate you (infinities are confusing).

Lesson from this: Infinity shouldn't serve as a way to avoid thinking about real large numbers.

Your number+1!!! Nobody saw that coming!!!

In every discussion about large numbers there's that one person who keeps doing this. The only reason for it is a way to "win" without having to think too much. But of course, it leads nowhere, so it can be ignored.

Lesson from this: Be construcctive. If everybody did this, it would annoy you too.

These three mistakes typically just annoy everybody and embarass the mistake-maker. The next three aren't so serious, because they at least are done in good faith. However, they still do harm.

Function with no result

It is very important to make sure not to make a function that never ends. It's not necessarily bad if your function expands, takes up several sheets of paper and there's no result in sight. The problem happens if there's no result ever. All functions should, at least theoretically, be calculatable if you had enough time. A good way to spot a broken function is to look for the function appearing again with larger or same arguments. All fast-growing functions must have some mechanism that keeps slowly decreasing something, typically one number and outputs some result when that something reaches zero/is depleted. It doesn't have to be straightforward, it might for example be three numbers dependent on one another, but there must be some property, for example the sum of the numbers, that keeps decreasing.

This is an example of a never-stopping function:

f(a) = f(f(a-1)+1)

f(1)=2

So how much is f(2)?

f(2)=f(f(1)+1)=f(3)=f(f(2)+1)...

Lesson from this: Make sure that you actually present a number and not some eternal cycle.

Using others' work

It is okay to use up arrows to make your number. Unless you add some idea of yours, however, be prepared not to get much further than G. To get something truly large instead of writing what has been written hundreds of times before, you must make your own functions and numbers. You don't get anywhere by factorialing, arrowing and multiplying other people's numbers (as shown before). You can take somebody's function and make it stronger, just make sure that you're not making a "naïve extension", where you just complicate a function or make it just a little stronger.

Lesson from this: You must make your own functions, and once you have them, there's not much reason to use the old ones (e.g. multiplication).

Arguments from imagination

When you create a huge number, don't let yourself get too carried away by the fact that the result is unimaginably large. Humans are very bad at imagining large numbers and any number worth anything is unimaginably large.

Lesson from this: It's good to have some reference point to be sure that your number is truly large.

The next three mistakes don't usually break your number, but they can complicate needlessly:

Confusing definitions

Optimally, your creation should be comprehensible to other people. It's better to explain too much that to explain too little. If you show only examples of how a function works up to ten, it should be clear how to continue from there.

Lesson from this: Find clear rules of your function and explain them properly. You may catch a mistake or find a way to improve your function.

Using large numbers in functions

It may seem contraproductive to avoid using large numbers to define a function, but there's good reason to do so. If you, for example, multiply your number by G at the beginning of the function, it won't be clear if you get much further or if the rest of the function is useless.

Lesson from this: Don't make large what doesn't have to be large. Don't use multiple-digit numbers unless necessary.

Fractions and decimals

Using them is not a mistake, but it's easy to do so in a way that breaks the function. For example, your mechanism to stop the function using the sequence 5,4,3,2,1,STOP might turn into 1,1/2,1/4,1/8,1/16,1/32,1/64,1/128... and the function never stops. There's not much reason to leave the natural numbers.

Lesson from this: Only use fractions and decimals if it's really necessary and always exercise caution.

Good ideas

Having sorted this out, it's time to make some numbers. The first thing we can try is use the g(x)=g_x from part one. G is g(64), so we could create something like g(g(g(g(...64))) with 64 g. Then we could make g(g(g(g(...64))) with the previous number of g's (and we could continue).

A note: function f used a times on number x will be noted f^a(x). For example, f³(x) is f(f(f(x))).

This system with repeating g's is, however, confusing. We keep making new functions with questionable added value. Luckily, there's a way to write this concisely and to get much further.

Conway arrow chains

Gis an extension of addition (as discussed in part one). This has an advantage in that it's easy to understand. To get further, we'll have to ditch that. As you will see later, we still get an extension of addition, but it's easier to think of it in another way. We'll instead use a system, a notation, made by John Conway. It works like this:

This is an example of a correct chain:

3→5→7→8→4→11→9

It is a bunch of natural numbers connected to each other by right arrows (this has little to no relation to up arrows from part one). On the other hand, those are incorrect chains:

0→5→7 There can't be zero.

5→→7→9 It's always number→number→number, there cannot be two arrows next to each other. If there are, it's probably a typo.

0,5→7→0,789 The notation doesn't work with decimals.

Okay, but what do we do with a chain? If there are just two numbers, it's just exponentiation.

5→3=5³=125

If there's one anywhere in the chain, it and everything behind it is deleted.

5→3→1→8→7→65=5→3

If there's a chain where these don't apply, for example 7→5→4→6→3, this happens:

The penultimate number (here 6) is changed to the original chain in parentheses. Then, in this new chain, the penultimate number is decreased by one. After that the last number of the entire chain (the outside one) is decreased by one. Perhaps an example is clearer:

7→5→4→6→3=7→5→4→(7→5→4→5→3)→2

First you calculate the chain inside, then you write the reult instead of it and repeat. This is how a simple chain is evaluated:

3→3→3=3→(3→2→3)→2=3→(3→(3→1→3)→2)→2=3→(3→(3)→2)→2=3→(3→3→2)→2

As you can see, several inscribed chains appeared. (One disappeared because of the 1). If the penultimate number was larger, there would be more of them. First, we must evaluate 3→3→2.

3→3→2=3→(3→2→2)→1=3→(3→(3→1→2)→1)=3→(3→3)=3→3³=3→27=3²⁷

We got 3²⁷. Okay, let's put it inside the main chain.

3→3²⁷→2=3→(3→(3²⁷-1)→2)→1=3→(3→(3²⁷-1)→2)=3→(3→(3→(3²⁷-2)→2))=3→(3→(3→(3→(3²⁷-3)→2)))

After writing this out, we'd get 3²⁷ threes. We actually get a power tower of size 3²⁷ from threes. That's 3↑↑3²⁷, or, as you may remember from part one, 3↑↑↑3. Indeed, it turns out that:

a→b→c=a↑^cb=a↑↑↑↑↑...↑↑↑↑↑b (c arrows)

Even chains of length of only three numbers areas strong as up arrows. It would still be hard to write G using them, however. g₃ would look like this:

3→3→(g₂)=3→3→(3→3→g₁)=3→3→(3→3→(3→3→4))

We can simplify things a lot by pretending the four at the end isn't there.

3→3→3→2=3→3→(3→3→2→2)→1=3→3→(3→3→(3→3→1→2)→1)=3→3→(3→3→(3→3))

3→3→4→2=3→3→(3→3→3→2)=3→3→(3→3→(3→3→(3→3))) (see before)

That's almost g₄. G, or g₆₄ would therefore be 3→3→64→2. However, g₁ must be 3→3=27 for this to work. This means that g₈ in this version is just a bit larger than g₇ in the original one.

We don't have to limit ourselves to having 2 as the last number. If we accept 3→3→x→2 as g_x, this is what 3→3→3→3 will yield us:

3→3→3→3=3→3→(3→3→2→3)→2

3→3→2→3=3→3→(3→3)→2=g₂₇

3→3→g₂₇→2=g_g27

We have just passed G Let's go further.

3→3→4→3=3→3→(3→3→3→3)→2=g(g(g(27)))=g(g(g(g(1)))) Assuming g₁=27, of course.

Using the subscripts isn't really practical now. We arrived at the conclusion that 3→3→x→3 is g^x(1)=g(g(g(g(...x times g...(1))))

The strength of chains are beginning to show up. With every step the last number decreases by one. However, the penultimate number increases, and it increases a lot. The higher it is the more it increases with every other step. Ultimately, the last number decreases to one and disappears. The huge penultimate number now becomes the last number, so the new penultimate number increases a huge number of times. Eventually the chain shortens to two numbers which are exponentiated.

Any numbers except the last two ones aren't that important, but the most important thing is the chain's length. Before moving to chains of length five, we should increase the last number at our chain and see what happens.

Since 3→3→x→3=g^x(1),

3→3→3→4=3→3→(3→3→2→4)→3=3→3→(3→3→(3→3)→3)→3=3→3→(g²⁷(1))→3=3→3→(g^g1(1))→3

This is g^gg₁⁽¹⁾(1). We get 3 g's on top of each other (a bit confusing). Generally, 3→3→x→4 is a tower of g's of height x, always with a 1 in the parentheses. It's a bit hard to follow, so here's another attempt:

g^x(1) means g applied to 1 x times (as said above). g³(1) is g(g(g(1))).

Starting with 1, we do this for x times: we take the number from the last step (let's label it c) and calculate g^c(1). We get 3→3→x→4.

If we label 3→3→x→4 h(x), then 3→3→x→5 works in the exact same way, except that now we have h(x) everywhere where used to be g(x). If that is i(x), then 3→3→x→6 will iterate i(x).

Before getting started with chains of length five, we should try changing the first two numbers. If they are fours instead of threes, the only change will be that g(x) becomes 4→4→g(x-1). This means that g(x) will still have g(x-1) arrows, just between fours. That doesn't make much of a difference. If, however, we decrease the threes to twos, the chain collapses.

2→2→5=2→(2→1→5)→4=2→2→4=2→2→3=2→2→2=2→2=4

No matter what's after the twos, you get four as a result. This is why threes are used instead.

Now, finally, chains of length five:

A few definitions:

g(x,y) is g^x(y).

We define f_x(y) like this:

f₁(y)=g(y)

f₂(y)=h(y)=g(g(g(...,1),1),1) y times g

f₃(y)=i(y)=h(h(h(...,1),1),1) y times h

f_x(y)=f_x-1(f_x-1(f_x-1(...),1),1) y times f_x-1

f_x(y,z)=f_x(f_x(f_x(...z))) y times f_x

f(x,y)=f_x(y)

f(x)=f_x-1(3)

3→3→3→x=f_x-1(3)

While it may seem confusing, it's just a concise version of how this works. We generalised the functions g, h, i, etc. so that f₁(y) is g(y), f₂(y) is h(y), f₃(y) is i(y) atd. This ensures we don't run out of letters. Finally, we defined f(x) as f_x-1(3) because that's the result of 3→3→3→x.

3→3→3→3→2=3→3→3→(3→3→3→2→2)=3→3→3→(3→3→3→(3→3→3))=3→3→3→f(3→3→3)=f(f(3→3→3))

3→3→3 is huge by itself, but now we perform f(x), not once, but twice. It's getting hard to comprehend the hugeness of this number. We take the function number 3→3→3, which then calls lower functions through 3→3→3 levels, while we end at g(x), a function that's quite strong by itself. We get a huge result, which, however, becomes subject to this again.

3→3→3→4→2=3→3→3→(3→3→3→3→2)=3→3→3→f(f(3→3→3))=f(f(f(3→3→3)))

The penultimate number decides the number of times f(x) is used. 3→3→3 is actually f(1), because 3→3→3→1=3→3→3. This means that:

3→3→3→x→2=f(f(f(...f(1)))) x times f()

f(f(f(...f(y)))) x times f() is f^x(y) as per above

Continuing:

3→3→3→3→3=3→3→3→(3→3→3→2→3)→2=3→3→3→(3→3→3→(3→3→3)→2)→2=3→3→3→(3→3→3→(f(1))→2)→2=

=3→3→3→(f^f(1)(1))→2=f^ff(1)(1)(1)

We're getting the same thing again, just with stronger functions. We could continue like this. Technically, you could probably get from G to chain arrows using g(x), h(x), f^x(y) etc., but as you can see the chains are far more practical. It's time to make the first Large Numbers Function (we'll define the functions F₁(x), F₂(x) etc. as we get further). Using this function we will make the first Large Number (V₁, V₂ etc.)

F₁(x)=x→x→x→x→x→x... x times x, so (x-1) right arrows and x x's.

V₁ will be (to keep the rule against unnecessary multiple-digit numbers):

V₁=F₁(9)=9→9→9→9→9→9→9→9→9

This is huge, but compared to what will come later we've barely got anywhere.

Extending the arrows

We don't have to stop here. Let's say that

x→²y=x→x→x→x→x→x→x... (y times x)

F₁(x) is, therefore, x→²x.

Now how much is 3→²3→²3? We haven't defined it, but we can easily do that. Let it behave like ordinary arrows with the exception that x→²y isn't x^y like with plain arrows, but it's instead x→²y as defined above. Where does that lead us?

3→²3→²3=3→²(3→²2→²3)→²2=3→²(3→²(3→²1→²3)→²2)→²2=3→²(3→²3→²2)→²2=3→²(3→²(3→²2→²2))→²2=3→²(3→²(3→²3))→²2

So far, we've been ignoring the 2's above the arrows. Now we substitute 3→3→3 for 3→²3. 3→3→3 is 3↑↑↑3, which is 3↑↑(3↑↑3), which is 3↑↑3²⁷, a power tower of several trillion 3's. It results in some huge number. Let's label that number O.

3→²(3→²O)→²2

3→²O is O three's in an arrow chain. As shown before, the chains get incomprehensibly huge by length five. Now we have length O. We won't even pretend to do anything with it, it's here and we'll just have to cope with it somehow. Let's call the result of this massive chain U.

3→²U→²2=3→²(3→²(U-1)→²2)=3→²(3→²(3→²(3→²(...3)))) Now we have U 3's.

We'll start from the end. 3→²3 is 3→3→3. O.

3→²O is U.

3→²U is V.

3→²V is W.

And so on. The result of the original expression is the U-th number in this sequence. Every number has the previous one as the number of threes in its chain. It's analogous to the sequence of G, where every number serves as the next number's number of arrows. This is, of course, stronger.

Anyway, 3→²3→²3 apparently does have a result. Any chain made purely from →² has a result. Be careful not to mix →² with →.

3→²3→3 doesn't exist, while 3→²(3→3) does, because different types of arrows aren't in the same expression. They are separated by parentheses.

An important note: The superscript is gonna get very long over time, so at this point there will be a small change in notation. Instead of writing →², we'll write →²→. The same goes for any superscript defined later. The point is to clarify what is and what isn't a part of the superscript. It's only a notation change and it has no effect on the actual process of calculating the chains. Using pen and paper the best notation just takes the superscript and writes it above the arrow. Sadly, the text editor doesn't allow this, so the two arrows are needed.

We can continue..

x→³→y=x→²→x→²→x→²→x→²→x... y x's.

We can again create longer chains like 3→³→3→³→3. They work like →²→, they just call →²→ instead of →.

In this example the last number will be two because it's almost incomprehensible with three.

3→³→3→³→2=3→³→(3→³→2→³→2)=3→³→(3→³→3)=3→³→(3→²→3→²→3)

We get a chain from →²→ of length 3→²→3→²→3 made from threes. This eventually results in 3→²→V with V being very high. This means a huge chain from normal arrows, which has some result. This means that even 3→³→3→³→2 has a result. Any chain of any length with any single type of arrows has a result. .

→³→ can be used to define →⁴→, and so on to higher nummbers. The general rule:

a→^c→b=a→^c-1→a→^c-1→a→^c-1→a→^c-1→a→^c-1→a→^c-1→a... b times a

We can now define F₂ and V₂:

F₂(x)=x→^xx

V₂=F₂(9)=

=9→⁹→9= 9→⁸→9→⁸→9→⁸→9→⁸→9→⁸→9→⁸→9→⁸→9→⁸→9

Now it might seem that we got to the end. This is, however, far from true. We can define a subscript.

a→₂→b=a→^b→a

Now we can make longer chains much the same way as we did it with the superscripts.

3→₂→3→₂→2=3→₂→(3→₂→2→₂→2)=3→₂→(3→₂→3)=3→₂→(3→³→3)=3→₂→(3→²→3→²→3)=3→^L→3

L is 3→²→3→²→3, meaning a lot. 3→^H→3 is much higher than V₂.

Beware: A small change. Right now it seems that the regular arrows are →¹→ (as they're one level under →²→). But for reasons detailed below, it's better to make regular arrows →⁰→. All else moves a level. What used to be →⁹→ is now →⁸→. V₂ is to be interpreted this way.

We can, again, put larger numbers into the subscript.

a→₃→b=a→₂→a→₂→a→₂→a→₂→a... (b times a)

And so on. We can make another level.

a²→b=a→_b→a

With threes and larger numbers and so on.

We're running out of places to put the numbers (the last one was really awkward with no way to distinguish it from exponentiation), so let's generalize it.

a→^0,c→b=a→^c→b

a→^1,c→b=a→_c→b

a→^2,c→b=a^c→b

a→^c,d→b=a→^c,(d-1)→a→^c,(d-1)→a→^c,(d-1)→a... (b times a)

a→^c,0→b=a→^(c-1),b→a

The first number is the position of the second number. If there's a chain a→^c,d→b, one of these options happens:

If d is larger than zero, it decreases by one and a new chain is created, this time from a and of length b. If d is zero, c decreases by one and the 0 is substituted for b. B decreases to a (if a is larger than b, it increases to a).

There are two changes that need explaining:

1) Originally, the new position happened when the number was 2, not 0. However, we'll run into a similar situation many times again and it makes more sense to make the "downgrade number" 0. There's also the "zeroeth position". It's better not to think about it as a position, but rather as a second number (as much more will be added).

2) There seems to be no reason to decrease b. The reason to do so is the rule "don't make big what doesn't have to be big". B increases very fast and very much before it is ever decreased again. This means that it doesn't have to be large to begin with.

A few examples:

3→^2,5→7=3→^2,4→3→^2,4→3→^2,4→3→^2,4→3→^2,4→3→^2,4→3

The 3 repeats seven times and the second number in the superscript decreases.

4→^4,9→5→^4,9→3=4→^4,9→(4→^4,9→4→^4,9→3)→^4,9→2

All rules for normal arrows are kept, you just copy the superscripts.

3→^4,0→8=3→^3,8→3

This "loads" the 8 into the superscript.

What to do next? We can add a third number to the superscript:

a→^1,0,0→b=a→^b,b→a

a→^2,0,0→b=a→^1,b,b→a

a→^c,0,0→b=a→^(c-1),b,b→a

If the last two numbers are both ones, the first one decrements and both ones are increased to b. B decreases to a. If this doesn't apply, just use the old rules and copy the first number.

We can extend this to a list of any length:

X→^c,d,e...,f→a→^c,d,e...f→b=X→^c,d,e...f→(X→^c,d,e...f→(a-1)→^c,d,e...f→b)→^c,d,e...f→(b-1)

If there are more than two numbers in a chain, we obey the normal rules and copy the supercripts.

Example:

3→^2,4,3,7→2→^2,4,3,7→4→^2,4,3,7→6→^2,4,3,7→7=3→^2,4,3,7→2→^2,4,3,7→4→^2,4,3,7→(3→^2,4,3,7→2→^2,4,3,7→4→^2,4,3,7→5→^2,4,3,7→7)→^2,4,3,7→6

If there are just two numbers in a chain, there are more options. If the last number in the superscript isn't 0, it decrements and a new chain is created. It is from the number a and of length b.

a→^c,d,e...f→b=a→^{c,d,e...(f-1)}→a→^{c,d,e...(f-1)}→a→^{c,d,e...(f-1)}→a→^{c,d,e...(f-1)}→a→^{c,d,e...(f-1)}→a

(b times a)

Example:

4→^2,4,0,8→7=4→^2,4,0,7→4→^2,4,0,7→4→^2,4,0,7→4→^2,4,0,7→4→^2,4,0,7→4→^2,4,0,7→4

If there is a 0 or several zeroes at the end of the list, the first non-0 number before them decrements and all the zeroes increase to b. B, again, decreases to a.

a→^{...c,d,e,0,0,0...0,0,0}→b=a→^{...c,d,(e-1),b,b,b,...b,b,b}→a

Example:

11→^2,4,3,7,0,0→41=11→^{2,4,3,6,41,41}→11

If there's 0 at the beginning of the list, it is removed. The rest is kept.

a→^0,c,d,e...→b=a→^c,d,e...→b

Okay, but what does this do? The last number keeps decreasing. When it reaches 0, the number before it decrements and the last number is increased, typically to a large number (usually the result of a chain with lists itself). This large number keeps decreasing slowly, and when it reaches zero again, the penultimate number decrements again. When both the last and the penultimate numbers reach 0, the antepenultimate number decrements and the last two numbers increase to huge numbers. This goes on and on until the first number decreases to 0, which is then removed and all of this can start again, just with one less number. While this is happening, many subchains appear, typically also very long ones.

It's time to make another Large Number Function and another Large Number.

F₃(x)=x→^x,x,x,x,x...→x

(x times x in the superscripted list)

V₃=F₃(9)=9→^{9,9,9,9,9,9,9,9,9}→9

This was still pretty simple. The next step is nasty, but unfortunately we need it to be able to proceed past it. We need...

Multiple dimensions

Once again, we don't know how to continue. We could redefine tthe arrows, since their current system is quite inefficient. For instance, we could just remove the penultimate 1, leaving the number after it, or we'd make some other rules. This, however, inevitably runs into a limit, when we cannot improve anymore and everything just gets more complex. There's another option.

Just like a→²→b makes the chain longer, we can change the list length. First, we have to separate the list from stuff we're going to add. We'll write V before it. Everything before the list is going to be copied, unless the list dwindles down to just a single 0. At that point, normally, we'd get the first number to the power of the second, but instead, the number before the list decrements and a new list is created, with length the same as the second number. It will be made of the first number. In symbols:

a→^cV0→b=a→^{(c-1)Vaaaaa...}→a

(b times a in the list)

a→^0Vanything→b=a→^anything→b

Once it decrements to 1, the number before the list disappears and leaves the list alone.

Of course, we can put another list before our original list. This is how it's gonna work:

Arrow chains work as before. The only difference happens when there's a chain of just two numbers. First, the rightmost list is evaluated in the same way as if it were alone (The last number decrements. If it's already 0, the first non-0 number left of it decrements and all ones following it turn into the second number in the chain. If there's a 0 at the beginning of the chain, it's removed.). If it's empty (only a single 0), the second list from the right (or the rightmost nonempty list) is evaluated like this and the empty set turns into a new set (b times a, b being typically huge). Once the leftmost list is empty, it's removed.

You may have noticed that the last paragraph uses phrases like "second list from the right". As you may have deduced from this, there can be multiple lists. The principle is like with just one list. You start from the right and all the sets right from the first nonempty one "fill". This is like the situation with a sigle list, where all the non-empty (non-1) numbers right from the first nonempty one "fill" and the nonempty number decrements. Instead of the size of a number, we change list length here. That's it. After this, we fill the nonempty list (it may have ones right from the decremented number), just like the situation with a single list. A few examples:

4→^{8V5,7,3,0,0V0V0V0}→9=4→^{8V5,7,2,9,9V4,4,4,4,4,4,4,4,4V4,4,4,4,4,4,4,4,4V4,4,4,4,4,4,4,4,4}→4

(I said that the superscript gets long)

3→^4V7V5,5,3→6=3→^4V7V5,5,2→3→^4V7V5,5,2→3→^4V7V5,5,2→3→^4V7V5,5,2→3→^4V7V5,5,2→3→^4V7V5,5,2→3

It's important to understand this, since we're gonna continue and there will be some recursions of this.

We have created something like a 2D array. 7V4,8,6V3,3,3,3,3V7,4,2,5 can be viewed as this:

This is where the Multiple Dimensions come from. A list is 1D, numbers one after another. Here, we have a 2D array, just written line by line with V separators to fit above the arrows. Otherwise we could draw the arrays above them and it would be identical (but a bit impractical). In practice, the lower rows would be a lot longer than the higher ones. But we can go further than 2D.

To be able to go to 3D, we need a way to separate the 2D arrays ("squares" from now on). We could use W or some other letter, but let's think ahead. The original V becomes V₁. The new separator is V₂. The subscripted number tells us the number of dimensions of the separated structures. While we're at it, let's make the commas between numbers V₀. The important thing is that the separators are only between numbers and not before or after groups of them, so there are never two separators in a row.

7V4,8,6V3,3,3,3,3V7,4,2,5 becomes 7V₁4V₀8V₀6V₀3V₀3V₀3V₀3V₀3V₁7V₀4V₀2V₀5

It is a little confusing, but universal.

Now, onto 3D. We'll write down a few squares and add them together, getting a 3D array (cube). When a situation analogical to a 2D row filling occurs, instead of changing the length of a list (and the numbers in it), we turn all the "empty" squares (which have just one row of one number, 0) into squares NxN (N being the second number in the chain) where all the numbers are N. We could also have a half-empty square, so we fill its rows like with a single square. This means that the second number determines the size of the resulting square.

Then we can, of course, continue to 4D. The cubes, while technically "above" each other in the fourth dimension, are easier imagined next to each other. In 5D the number of these cubes becomes another dimension. We can continue like this. Of course, we cannot imagine a 20D structure like this, but we can write it down using separators and numbers, which can be evaluated using exact rules.

This is the general way to evaluate an nD structure, when a chain of length 2 appears:

If the last number isn't 0, decrement it and create a new chain of length... you know how it goes. If it is 0, it's more complicated. Find the rightmost non-0 number. Decrement it (This is the mechanism that ensures that the process terminates). All the numbers after it are zeroes. Start from the right end and end at the number we've just decremented (even if it turned into zero). Before each of the ones, there's a separator (the only separator-less number is the very first one, which would mean a completely empty structure). After the separator, there should be some structure (which is empty now). So fill it. For example: An empty square gets filled to a square bxb of number b (b being the second number in the chain we're still working with). This is an example full square (b=6):

Move left. Keep doing this to all structures there are, and stop at the decremented number. The entire empty part will get filled at the "price" of decrementing the number before it. The reason why this is so complicated is that we can, for example, have a cube with four empty squares, then a square with three empty rows and one with 15 ones at the end. We have to fill all of this. So we start with the squares, then the rows and last the individual numbers. This works even for 20D without needing you to imagine multidimensional cubes.

It's getting a bit complicated. The larger problem, though, is writing all these words into symbols. It looks like this:

First, we have to define a "full" strucure. In order to do this, we need a function k(x,y). It takes two numbers (x and y) and creates an x-dimensional structure of size y made of y (all the numbers in the structure will be y). We can define it recursively (this part is a bit technical and not necessary to understand the system, so if you don't get it, just skip it).

k(0,y) = y

If we have an 1D structure, it's just a single number. It would be 0D, but the lowest dimension was changed to 1 to avoid problems with the subscripted 0. In practice, the only thing it means is that k(4,8) won't be 4D, but just 3D, since all the dimensions were moved a level.

k(x,y) = k((x-1),y)V_x-1k((x-1),y)V_x-1k((x-1),y)V_x-1...k((x-1),y)V_x-1 (y times k((x-1),y))

A structure is made of y structures of one dimension less. A full cube is made of y full squares on top of each other. This way, we decompose the structure into smaller structures to fill.

An empty part looks like this:

0V₀0V₀0V₁0V₂0V₂0V₃0V₅0V₅0

There are a few empty structures of some dimension, then a few that are in one (or more) dimensions, a few even higher, etc. Some dimensions may be missing. Let's name the empty part E; it can contain pretty much anything not filled. The separator after the zero is its part, too.

NOTE: There may be a mistake in the following description. I'm working on it.

C is the part before whatever we need to fill. We don't need to care about it now.

Then (b is still the second number):

CV_n0E

turns to

CV_nk(n,b)E

And we can continue to the right. Still not a completely rigorous definition, but only details are missing.

Note: There is a small change here, since we used to fill in the first number and now we use the second number. We used to make our life simpler with that, but now it would only be confusing. This does not stop the second number from shrinking, since that doesn't complicate things and only changes a little.

Time for another function.

F₄(x)=x→^k(x,x)→x

k(x,x) is an xD structure made from x. For example, F₄(3) is

3→^3V₀^3V₀^3V₁^3V₀^3V₀^3V₁^3V₀^3V₀^3V₂^3V₀^3V₀^3V₁^3V₀^3V₀^3V₁^3V₀^3V₀^3V₂^3V₀^3V₀^3V₁^3V₀^3V₀^3V₁^3V₀^3V₀³→3

The structure is a cube made out of three squares like this:

Not very big, so the new large number will be:

V₄=F₄(9)

There's a reason not to write it all out. The text above the arrow would take 387 420 489 nines and 387 420 488 separators. Remember the 100 000 circles? Waaay longer than that.

So much for the higher dimensions. We managed to move from squares to multidimensional cubes, which made our function a lot stronger. The dimensions cannot do much more, however, so it's time for...

Fractals

So far we've just been creating a tool for this part. We can create structures of a variable number of dimensions. The next step is substituting numbers in these structures for substructures. Pulling that out of thin air could easily lead to mistakes, so let's start at the beginning. What did we do when we had lists? Added a number that affected the list length, because that was the most important factor in the result size. We can do something analogical here. The most important factor is now the number of dimensions. We can add a new number in front of the structure. When the structure depletes, the number decrements and the number of dimensions increases to the number after the arrow (still working with arrow chains, remember). An example:

If we have a cube and a 2 in front of it, everything will go normally, except that when there would have been exponentiation, this is calculated instead:

a→^k(b,b)→a

k(b,b) is a b-dimensional structure from b. B is typically very large, so we'll operate with structures of many, many dimensions. This gives us a massive boost. To create the massive numbers we used to get, you have to exponentiate many times. Now, instead of doing that, we do all the stuff we did before. But that means larger sub-results, therefore more levels of nesting brackets, longer chains and even more operations. This massive boost is similar to what happened every time before, but it's very easily visible here.

But we have a problem. A number in front of a cube is usually either a part of it or another cube. How do we separate our new number, which is in front of the whole structure? The answer is a new separator. Ordinary separators V_x are all taken up. We may use W or V_V or something similar, but there's a different option: V_1;0.

Let's "calculate" an example. K(x,y) is an xD structure made from y.

3→^2V_1;0¹→3→^2V_1;0¹→2=

3→^2V_1;0¹→(3→^2V_1;0¹→3)=3→^2V_1;0¹→(3→^k(3,3)→3)=3→^2V_1;0¹→K

(K is a huge number, F₄(3), that is 3→^k(3,3)→3)

3→^2V_2;1¹→K=3→^k(K,K)→3

As seen here, we got a K-D structure. And this example wasn't really worth anything, V_2;1 only got used once (there could have been a longer chain and it would go full boom).

We can separate entire structures using V_1;0, and we can list many of them in a structure list. It works like a simple list, you just substitute decrementing the last number for decrementing a structure (as explained before) and changing ones to higher numbers is for filling structures (as above). Now, we can make many-D structures out of structures (a square, cube, etc. of structures). We'll use V_1;1 to separate structure lists, V_1;2 to separate structure squares etc.

Now, to explain the fractals. A fractal is (simplified for our need) an object containing itself, like for example the Szierpinski's triange:

It's made out of three copies of itself (white is empty). We're making an almost-fractal. The next thing we do is make structures of structures of structures. We can go on until we have as many levels of substructures as we want.

V_1;x is taken, so start with V_2;0. 1V_2;00 turns to a bD structure made of bD structures filled with b. It's a bit complicated and unnecessary to write that out rigorously. If you want to, you're probably able to do it yourself.

V_2;x works like V_1;x, just a level higher. It's a structure of structure structures. We can go on till V_x;y. Time for another function. The problem is we still have to write it rigorously. Scrap what I just said. Never mind.

k(x,y,z) is a function creating a structure of structures of structures of structures... etc. with x levels of y dimensions (dimensions of all structures) and size z.

k(0,y,z)=k(y,z) as defined above.

Level zero is a point, which in our case means a structure. Level one is already a structure of structures, not just one structure.

k(x,y,z)=k(x,y-1,z)V_x;yk(x,y-1,z)V_x;yk(x,y-1,z)V_x;yk(x,y-1,z)V_x;yk(x,y-1,z)... (z times k(x,y-1,z))

This, for example, separates a cube of structure structures to squares of structure structures. By the way, this is why we use zeroes. If we used ones, there would be awkward separators like V_x+1;y.

k(x,0,z)=k(x-1,y,z)

If we have one point in a structure of structure structures, it's a structure of structures, i.e. we're one level deeper.

This defines a full structure of structures of structures... (That's too long. Let's call that a Kot from now on. For example, k(2,5,7) is a Kot with two levels, five dimensions and size 7.) with any amount of levels. We can define one more large number function.

F₅(x)=x→^k(x,x,x)→x

V₅=F₅(9)=9→^k(9,9,9)→9

It may be necessary to note that V₅ here means the fifth large number, not a separator. Maybe this notation isn't very smart.

I won't write out the Kot above the arrow. It has exactly 9⁸¹ nines in it. Just the amount of nines has 78 digits. There are of course, almost as many (exactly one fewer) separators.

Looking back

By now, this is getting confusing. Suddenly, the arrows, chains etc. are no longer important. To organise everything again, here's a recap of how all of this works:

Imagine this chain:

3→^k(3,3,3)→3→^k(3,3,3)→3

This first expands by standard arrow chain rules to this:

3→^k(3,3,3)→(3→^k(3,3,3)→(3→^k(3,3,3)→3))→^k(3,3,3)→2

First, we're interested in this:

3→^k(3,3,3)→3

The last three in the whole Kot decrements. This turns it into a decremented Kot (K-1). The chain expands into this:

3→^K-1→3→^K-1→3

This turns into the same chains in chains as above (just with the Kot decremented). Then once more, with a 1 at the end of the Kot. Then again, giving us a 0 at the end. Then, instead of decrementing, the three before it decrements. However, this is a part of a chain in a chain, so it loads into the last number. This huge number will keep slowly decrementing, creating long chains and subchains. Eventually, it reaches zero again. Then, the two before it decrements and we're back at the beginning. This time, the huge number will get in both of the zeroes at the end of the Kot. This huge number will, however, be the result of a chain with a Kot. The result of the entire Kot will affect the last two numbers. Behold the power of recursion. Once again, through the slow process, the last two numbers decrement to zero. As a result, the third number from the end decrements to one. Once more and we have three zeroes, an empty row. The three before it (in another row) decrements, giving us a massive row of massive numbers. It veeery slowly disappears (Many many more chains in chains... their number also a result of a Kot. They all load into each other as lengths of the last row of the Kot.), the two before it decrements again... Eventually we get an empty square. Then, through the same long process, the previous two squares empty as well. Then, the three before the now-empty cube (from another structure entirely) decrements and we get a massive-dimension structure at the end. We're still operating with many chains like this:

3→^{Kot without the last square}→(3→^{Kot without the last square}→(3→^{Kot without the last square}→(3...))

Each chain is the number of dimensions of the last structure of the next one. Finally, the last three structures deplete, the three before them decrements (Yes, again. This makes the whole thing a bit more confusing.), creating a long row of structures. After many more such depletions, only one strucure of many dimensions will remain. It will dwindle down to a single cube, then a square, one row and eventually a single huge number. This will lead to long chains, the number will slowly decrement, eventually giving us:

3→²→GIANT NUMBER

That is an unreasonably long chain of threes, eventually leading to 3→3→EVEN GIANTER NUMBER, that is 3↑↑↑↑↑↑↑...↑↑↑↑↑↑↑↑↑3 with EGN arrows. This leads to a tall power tower, which ends as 3^{A LOT}. Counting that results in the... result.

Now realise that all of this happened the first time we calcuated the number to be in the place of the first created 0.

The point of this is that for most of the calculation, the part above the arrow seems to grow, but eventually the first parts go away and we return in the direction opposite to how we invented. Each new function strengthened the one before, but we forgot the most basic process in which it happens. Now that we have figured this out, let's move on.

Just one more thing is interesting. One of the first superscripted structures was a list. The first step towards that were just two numbers. Which are now in the separator. It turns out that what used to be the entire superscript is now just the index of a separator. This can point the way. We could eventually get lists under the separator.

Lists again?

We could do that here. But at this point the road splits. If you want to continue, you'll probably manage that on your own. I present V₅ to you and leave here. One hint: Play around with the definition of arrows for three numbers. After that, there's just one correct way forward. The other road may be more interesting. What was the whole point of this? Well... Part three is your friend here.