fgh_gamma0

4.2.6

The Fast Growing Hierarchy below Gamma-Naught

4.2.5 << PREV

Introduction

In the last article we took the epsilon numbers and treated them as an ordinal function and then took them to their natural extreme. In this article we explore an extended hierarchy of ordinal functions, which themselves can be indexed by ordinals. The result is an even vaster ordinal system ... and as a corollary even vaster numbers in FGH!

The Binary Veblen Function

The Veblen Functions were introduced by Oswald Veblen in a paper written in 1908. The Veblen functions are now a familiar part of computability theory and they will allow us, without too much additional difficultly, to go way way beyond Cantor's epsilon numbers, by generalizing the basic approach.

Recall that we defined ε(β) as the βth fixed point of:

α --> ω^α

This defines an ordinal function whereby β --> ε(β). In general every function from ordinals to ordinals will also have a transfinite number of fixed points. The first fixed point of the epsilonic map is Cantor's Ordinal "c", also sometimes referred to as ζ(0) (zeta-naught). Of coarse we can now define ζ(β) as the βth fixed point of the epsilonic map:

α --> ε(α)

What this means is that we can treat ζ(β), itself as a function from ordinals to ordinals. It therefore must also have fixed-points, enumerated by yet another function, which has fixed-points enumerated by yet another function ... etc. These functions quickly get difficult to enumerate, so a better notation is needed. Veblen suggested the following:

φ₀(β) = ω^β

φ₁(β) = ε(β)

φ₂(β) = ζ(β)

Now the enumeration becomes quite trivial. φ₃(β) enumerates the fixed points of ζ(β), φ₄(β) enumerates the fixed points of φ₃(β), φ₅(β) enumerates the fixed points of φ₄(β), etc. As you might imagine, this quickly leads to some massive ordinals, and even more incomprehensible numbers when plugged into FGH. Veblen didn't stop here though. Once we establish this hierarchy of ordinal functions we necessarily construct a new super-set of ordinals. In Veblen's system this is designated φ_ω(0). That's right! We can even enumerate the Veblen functions using the ordinals. This allows us to continue much much further.

First however let me make a note. Whenever the index is a limit ordinal we can observe that φ_α(0) can be defined as:

φ_α(0) = φ_α[0](0) U φ_α[1](0) U φ_α[2](0) U ...

When the argument is a successor ordinal, we can define it as:

φ_α(β+1) = φ_α[0](φ_α(β)+1) U φ_α[1](φ_α(β)+1) U φ_α[2](φ_α(β)+1) U ...

What this means in laymen's terms is basically that we take the ordinal φ_α(β), and we can extend it using any Veblen function φ_γ , where γ < α.

If on the other hand the argument to the function is itself a limit ordinal, we can simply take the union of the fundamental sequences as follows:

φ_α(β) = φ_α(β[0]) U φ_α(β[1]) U φ_α(β[2]) U ...

Altogether the following definitions can be used to define a much more extended hierarchy of Veblen functions. It is now possible for us to use any ordinal we can so far construct as an index to the function. To make matters easier we can also adopt the binary Veblen notation:

φ(α,β) = φ_α(β)

We can now construct ordinals such as:

φ(ω+1,0) , φ(ω+2,0), ... φ(ω*2,0), φ(ω*3,0), ... ,φ(ω²,0), φ(ω³,0), ... ,φ(ω^ω,0),

... , φ(ε₀,0) , φ(ε(ε₀),0) , ... ,φ(ζ₀,0), ... φ(φ(3,0),0), φ(φ(4,0),0), ...

φ(φ(φ(1,0),0),0), φ(φ(φ(φ(1,0),0),0),0), φ(φ(φ(φ(φ(1,0),0),0),0),0), ...

... and so on ... the limit of all these ordinal constructions is an ordinal called gamma-naught ( Γ₀ ). This is an important milestone for ordinal notations, and represents the next major development after ε₀. This is the most commonly described portion of Veblen's ordinal notation. As we'll learn later he went further than this still. For now let's try to make sense of the gamma-naught set and use it to generate an even more powerful subsystem of FGH.

A closer look at fundamental sequences below Γ(0)

We'll begin formalizing FGH_Γ(0) by first developing an understanding of how the sequences develop, after ε(0,1). In fact, I'll be using a binary epsilon-function instead of the more standard Veblen notation. Note that Veblen's notation places the most significant argument first, and then descends from there. The epsilon-function places the arguments in ascending order, the same as array notation, and Extensible-E. I'm going to be going with an ascending notation simply out of personal preference. The binary epsilon-function is virtually identical to the Veblen notation, except that it's second argument is exactly 1 unit behind. Once we get up to and past ω however, this difference no longer matters. Ex.:

ε(0,0) --> φ(1,0)

ε(0,1) --> φ(2,0)

ε(0,2) --> φ(3,0)

ε(0,3) --> φ(4,0)

...

ε(0,ω) --> φ(ω,0)

etc.

As you can see it is not strictly necessary to introduce yet another notation after the epsilon-numbers, one can simply extend them.

As usually we will need to develop the fundamental sequences, to both extend the set of ordinals, and also to simultaneously define FGH.

We'll begin with defining a new fundamental sequence for ε(0,1):

ε(0,1)[0] = 0

ε(0,1)[n] = ε(ε(0,1)[n-1])

This leads to the general form:

ε(0,1)[n] = ε(ε(ε(ε( ... ε(ε(ε(0))) ... )))) w/n ε's

In general when we are looking for an initial value for a new function, we will begin with the value 0, and then nest this inside of a previous function.

Once we define ε(0,1) we already can go beyond it. This is because the definitions for ω and ε can easily be generalized to any ordinal, not just the ordinals that can be constructed under them. So for example we already have the successor ordinals...

ε(0,1)+1,ε(0,1)+2,ε(0,1)+3, ...

We also have many many many limit ordinals we can create:

ε(0,1)+ω,ε(0,1)+ω², ... ε(0,1)+ω^ω,ε(0,1)+ω^ω^ω, ...,ε(0,1)+ε(0),ε(0,1)+ε(1), ...

ε(0,1)+ε(ε(0)),ε(0,1)+ε(ε(ε(0))) ...

In fact we can easily continue this all the way up to ε(0,1)+ε(0,1). This eventually leads to...

ε(0,1)+ε(0,1)+ε(0,1)+ε(0,1)+ ...

This set now needs a limit ordinal. This is easily supplied by the rules of ordinal arithmetic. Simply define:

ω^ε(0,1)+1

We know from the rules that this expands to...

ω^ε(0,1)+ω^ε(0,1)+ω^ε(0,1)+...+ω^ε(0,1)

Furthermore, ω^ε(0,1) is more or less the same as ε(0,1). The only difference is once ε(0,1) is done expanding to a power tower of ω's, it will have one more ω at the bottom. In the long run it makes little difference, and just provides a minuscule shift of the function (shifts are not considered increases in the growth rate of the function). From there we can eventually build a stack of ω's with ε(0,1)+1 on top. The limit of this set is ε(ε(0,1)+1). This can be verified by following the rule for epsilon numbers. ie:

ε(α+1)[n] = ω^ω^ω^ ... ^ω^ω^(ε(α)+1) /n ω's

Strictly following this rule we have:

ε(ε(0,1)+1)[n] = ω^ω^ω^ ... ^ω^ω^(ε(ε(0,1))+1) /n ω's

Again we get an additional passenger in the form of ε(ε(0,1)), but this is again negligible. We can go further still. As you can imagine we can now create a whole new class of epsilon numbers, which take ε(0,1) into the fold, along with all the construction rules we already established. We get things like ...

ε(ε(0,1)+2),ε(ε(0,1)+3), ... ε(ε(0,1)+ε(0,1)) ... ε(ω^ε(0,1)+1)

... ε(ε(ε(0,1)+1)), ε(ε(ε(ε(0,1)+1))) ...

This leads to the next fixed point of the function β-->ε(β). This second fixed point is labeled ε(1,1). Furthermore we can give it the following fundamental sequence:

ε(1,1)[0] = ε(0,1)+1

ε(1,1)[n] = ε(ε(1,1)[n-1])

So basically we are nesting ε(0,1)+1 inside the previous epsilon-function to get the next value for our ε(α,1) function. We can then proceed predictably in the following manner:

ε(2,1)[0] = ε(1,1)+1

ε(2,1)[n] = ε(ε(2,1)[n-1])

ε(3,1)[0] = ε(2,1)+1

ε(3,1)[n] = ε(ε(3,1)[n-1])

etc.

Eventually we hit a limit ordinal in the first argument. Simply let:

ε(ω,1)[n] = ε(n,1)

in general...

ε(λ,1)[n] = ε(λ[n],1)

This covers the ε(β,1) function. Next we define the ε(β,2) function. We begin with:

ε(0,2)[0] = 0

ε(0,2)[n] = ε(ε(0,2)[n-1],1)

ε(0,2) can then be extended via ω^β, ε(β), and even ε(β,1). This will eventually culminate in iteratively plugging in ε(0,2)+1 into function ε(β,1). In this manner we define the next value for our new function:

ε(1,2)[0] = ε(0,2)+1

ε(1,2)[n] = ε(ε(1,2)[n-1],1)

Again we continue in this manner until we hit a limit ordinal...

ε(λ,2)[n] = ε(λ[n],2)

It shouldn't be too hard to imagine how we might construct fundamental sequences, as long as the 2nd argument is < ω. How do we chose a fundamental sequence for ε(0,ω)? Simple ... just take the fundamental sequence of the limit ordinal. ie:

ε(0,ω)[n] = ε(0,n)

in general ...

ε(0,λ)[n] = ε(0,λ[n])

In this manner we can continually create new functions below the ordinal Γ(0). This is still quite informal however. What we want is to generalize these principles into a small set of simple transformations that we can use. Let's now formalize this system for use in FGH.

Formalizing FGH_Γ₀

After a little thought, one can reduce the implicit rules above to the following:

The Fast Growing Hierarchy Below Γ₀

(n)[β] | n∈ω, β∈Γ₀ :

1. (n)[0] = n+1

2. (n)[γ] = (n)ⁿ[γ']

3. (n)[λ] = (n)[λ[n]]

* where γ∈Γ₀_S, λ∈Γ₀_λ

Γ₀ Set

(1) {0,1}⊂Γ₀

(2) α,β∈Γ₀&& α,β≠0 → α+β∈Γ₀

(3) β∈Γ₀&& α,β≠0 → ω^(β)∈Γ₀

(4) α,β∈Γ₀→ ε(α,β)∈Γ₀

Γ₀_S Set

The Set of Successor Ordinals below gamma-naught

(1) 1∈Γ₀_S

(2) β ∈ Γ₀ → β+1∈ Γ₀_S

Γ₀_λ Set

The Set of Limit Ordinals below gamma-naught

β ∈ Γ₀_λ

if and only if

β ∈ Γ₀ && β ∉ Γ₀_S && β≠0

Definition of γ'

Here we formally define the predecessor of γ , called γ', assuming γ is a member of Γ₀_S.

(1) 1' = 0

(2) @+1' = @

Definition of λ[n]

λ[n] | n∈ω, λ∈Γ₀_λ :

LAWS OF ω

ω^(β)| β∈Γ₀ && β≠0 :

(1) β=0 ;

@ω^(0) = @1

(2) n = 0 , β∈Γ₀_S ;

ω^(β)[0] = 0

@+ω^(β)[0] = @

(3) β=1 ;

@ω^(1)[n] = @1+ω^(1)[n-1]

(4) n≠0 , β∈Γ₀_S ;

@ω^(β)[n] = @ω^(β')+ω^(β)[n-1]

(5) β∈Γ₀_λ;

@ω^(β)[n] = @ω^(β[n])

LAWS OF ε

ε(α,β) | α,β∈Γ₀ :

(1) α,β=0 ;

@ε(0,0)[0] = @1

else

@ε(0,0)[n] = @ω^(ε(0,0)[n])

(2) α∈Γ₀_S , β=0 ;

@ε(α,0)[0] = @ε(α',0)+1

else

@ε(α,0)[n] = @ω^(ε(α,0)[n-1])

(3) α=0 , β∈Γ₀_S ;

ε(0,β)[0] = 0 or @+ε(0,β)[0] = @

else

@ε(0,β)[n] = @ε(ε(0,β)[n-1],β')

(4) α∈Γ₀_S , β∈Γ₀_S ;

@ε(α,β)[0] = @ε(α',β)+1

else

@ε(α,β)[n] = @ε(ε(α,β)[n-1],β')

(5) α=0 , β∈Γ₀_λ ;

@ε(0,β)[n] = @ε(0,β[n])

(6) α∈Γ₀_S , β∈Γ₀_λ ;

@ε(α,β)[n] = @ε(ε(α',β)+1,β[n])

(7) α∈Γ₀_λ ;

@ε(α,β)[n] = @ε(α[n],β)

... and there you have it! This massive description describes FGH_Γ₀ in a very strict manner that would enable a computer program to be written which could evaluate any valid expression. The details however are a tad tedious for human operation.

Firstly I'd like to note how many rules we have at this point. We have 3 rules for the basic operation of FGH, as always, but in addition to this we have 5 rules to deal with ω^(β), and an additional 7 rules for ε(α,β) , not to mention the various sub-rules that come into play. That gives us at minimum 15 rules. This description is not really optimal. If we used φ(β,α) we could treat ω^(β) as the function φ(0,α), and thereby reduce the rules. However most people who are using ordinals below ε₀ use the Cantor Normal Form, so I have set up the rules to be compatible with earlier rule sets.

There is also some notable fine points to note about how ordinals are formally named here. If you look carefully you'll see that the rules above offer no support for decimal numbers. Things like "2", "3", "4", etc. are not recognized by the above algorithm. These must be written as "1+1", "1+1+1", and "1+1+1+1", respectively. The reason for this is because it simplifies the algorithm and makes it easier to describe a purely mechanical process. The finding of the predecessor then reduces to a simple act of removing a "+1". Thus we have:

(n)[1+1+1] = (n)ⁿ[1+1+1'] = (n)ⁿ[1+1]

(n)[1+1] = (n)ⁿ[1+1'] = (n)ⁿ[1]

What about the case when the ordinal = 1? This too is addressed in the rules. By definition 1' = 0. So:

(n)[1] = (n)ⁿ[1'] = (n)ⁿ[0]

The above rules also don't support superscripts for exponents. It does however automatically come with it's own set of parentheses. So for example we can have things like ... ω^(1) , ω^(1+1) , ω^(1+1+1), etc. The construction rules work by allowing us to take the sum of any two previously constructed ordinals, excluding zero, and take their sum as a new ordinal. Order here matters, so that 1+ω≠ω+1. However the rules do not support "fixed-points" in any way. That is to say 1+ω≠ω , ω^ε(0,0)≠ε(0,0), etc. It doesn't recognize these as equivalent. As a consequence, the set Γ₀ contains many many rogues. These non-standard expressions however, all have defined predecessors and fundamental sequences, depending on which subset of Γ₀they belong to. The main reason for the allowance of rogues here is that it means we don't need to eliminate them by devising additional rules for their exclusion. On the other hand rogues eventually must reduce to a canonical form. Why? This is because the canonical forms are essentially sorted by rank, with the largest ordinal coming first. Rogues always violate this by reversing the normal order. Let's say we have α<β, and we have the ordinal α+β. This is a rogue by default. Evaluation of ordinals must continually reduce β, while leaving α intact. Eventually β is reduced to a size commensurate with α. At this point the rogue form as been reduced to a member of the main sequence. We saw this earlier. This also applies in the case of fixed-points. If β is the fixed point of some ordinal function, β→ƒβ, and we have ordinal ƒβ, we again have a situation in which β eventually reduces to α, which is no longer a fixed point of ƒ. In general the rules are designed so as always to progress towards the base case of "0". Successor ordinals proceed to their predecessors, limit ordinals to the contents of their own set. Since we have defined ordinals as unions of the ordinals in it's fundamental sequences, we can also show that rogues aren't new sets, but just the same set with a different label. For example:

1+ω = 1+ω[0] U 1+ω[1] U 1+ω[2] U 1+ω[3] U ...

= 1 U 1+1 U 1+1+1 U 1+1+1+1 U ...

= {0} U {0,1} U {0,1,2} U {0,1,2,3} U ...

= {0,1,2,3,4,...} = ω

What's interesting about this is that it's implicit within the rules we've established. It's not something we have to declare, but is rather a natural consequence of the formal treatment. This means we don't have to guess what relations hold for ordinals, we can actually prove them. In this way, we could for example prove that ε₀ is a fixed point of β→ω^(β), as opposed to just assert it. With FGH however these details can essentially be ignored. It has little bearing on the actual evaluation process.

With a formal definition of FGH_Γ₀ in hand we now have something concrete to refer to in cases of confusion. However, once we get a handle for the rules, we can take various liberties to make evaluation easier for a human. We can think of 2,3,4, as just synonyms for the more cumbersome 1+1,1+1+1,1+1+1+1. We can use ω instead of the formal ω^(1), and we can use ε₀ instead of the formal ε(0,0).

First however, let's take a look at the formal evaluation of FGH_Γ₀ to make sure that our definition is in line with the expected behavior ...

Some Worked out examples of FGH_Γ(0)

We will begin with the most elementary cases and work our way up through the system. Keep in mind that there are vast gaps between the examples, and that between any two transfinite ordinals there are always ordinals far larger than we could ever actually write out in the universe.

The first thing to note is that the rules for FGH break up nicely into the 3 fundamental cases for ordinals (1) The zero-ordinal (2) The successor-ordinals and (3) The limit-ordinals. Each of these requires a unique rule. The zeroth-ordinal handles the base case, the successor-ordinals handle the applications of primitive-recursion on a previous function, and the limit-ordinals handle diagonalization over a set of functions. The diagonalization process is the most powerful and general of these, and can be continued as long as we can devise countable sequences whose union is equal to the limit ordinal. Let's begin with the zeroth-case:

(0)[0]

Here we apply FGH Rule 1:

(0)[0] = 0+1

The rules don't tell us how to add, but we can assume that the operations of the successor and predecessor are implicit, so we can say:

(0)[0] = 0+1 = 1

:: (0)[0] = 1

Simple. Now let's try some other values:

(1)[0] = 1+1 = 2

(2)[0] = 2+1 = 3

(3)[0] = 3+1 = 4

etc.

No surprises here. The zeroth-member of FGH is just the successor function, one of the four fundamental functions of googology. Next let's look at function [1]. This is the first one that requires FGH Rule 2:

(0)[1] = (0)⁰[1']

Firstly we see that in the rules for the precessor-function, γ' , that if γ=1 then γ' = 0. So we simply substitute:

(0)⁰[1'] = (0)⁰[0]

Again we are confronted with a situation which isn't dealt with explicitly within the rules. However we can assume that the operations of functional powers are implicit as well. We can use the following general definitions:

(n)^k[α] :

if k=0 ; (n)⁰[α] = n

otherwise ; (n)^k[α] = ((n)[α])^k-1[α]

Under these definitions it is clear that:

(0)⁰[0] = 0

We can think of this as zero-applications of the zero-function to zero. In otherwords, we haven't plugged zero into any functions and so we still have zero. Let's try some larger inputs to [1]:

(1)[1] = (1)¹[1'] = (1)¹[0] = ((1)[0])⁰[0] = (1+1)⁰[0] = (2)⁰[0] = 2

Note that at this point we are evaluating FGH in a completely atomic way. These are the most elementary steps possible. As such, just to evaluate the value of 2 here we had to carry out 6 transformations! While it's true that using the successor as our base case is an efficient way to encode large numbers, the catch is that the evaluation process is slower. This is a basic fact of computer science: recursive methods lead to simple programs but long execution times.

Another important thing to note is that NONE of the operations of FGH, even far very very very large values is very difficult. We basically only have 3 fundamental types of operations (1) find the successor (2) find the predecessor and (3) manipulate the text either by insertion, deletion, are copying and pasting existing text. The key upshot of the simplicity on which this truly humongous system is built is that we could actually implement such a program and it would work ... up to a point. It could only carry out the operations so long as the resulting text could be stored in memory. We will find that the examples will quickly outpace our ability to evaluate them on an atomic level.

Let's look at the next couple of values:

(2)[1] = (2)²[1'] = (2)²[0] = ((2)[0])¹[0] = (2+1)¹[0] = (3)¹[0] = ((3)[0])⁰[0] = (3+1)⁰[0] = (4)⁰[0] = 4

The expression (2)[1] solves to a mere value of 4, but it took 9 transformations to solve. The number of transformations can easily be assertained in this case by simply counting up the number of equal signs. Let's look at the next case:

(3)[1] = (3)³[1'] = (3)³[0] = ((3)[0])²[0] = (3+1)²[0] = (4)²[0] = ((4)[0])¹[0] = (4+1)¹[0] = (5)¹[0] = ((5)[0])⁰[0] =

(5+1)⁰[0] = (6)⁰[0] = 6

The expression (3)[1] solves to 6, but requires12 transformations. We can speed up the process considerably by skipping steps. We can for example automatically take a successor or predecessor when required rather than write out the intermediate steps. Here is an accelerated evaluation of (4)[1] :

(4)[1] = (4)⁴[0] = ((4)[0])³[0] = (5)³[0] = ((5)[0])²[0] = (6)²[0] = ((6)[0])¹[0] = (7)¹[0] = ((7)[0])⁰[0] = (8)⁰[0] = 8

On an atomic level this would have taken 15 transformations. We have now reduced it to 10. We can make it even easier if we recognize that when we expand a functional power, we are simply applying the function once to the argument. Since the function in this case is [0], we are simply finding the successor. Here is an accelerated evaluation of (5)[1]:

(5)[1] = (5)⁵[0] = (6)⁴[0] = (7)³[0] = (8)²[0] = (9)¹[0] = (10)⁰[0] = 10

On the atomic level this would have taken 18 transformations. We have reduced it to 7. In this form it shouldn't be too difficult to see what is happening. Every time the functional power decreases by 1, the argument increases by 1, until the functional power is empty (0) and a final evaluation is output. Therefore we can say that:

(m)ⁿ[0] = m+n

Since (n)[0] = (n)ⁿ[0] , it follows that (n)[0] = (n)ⁿ[0] = n+n = 2n. So [1] is just the doubling-function which doubles the input as output. So we have:

(6)[1] = 12

(7)[1] = 14

(8)[1] = 16

(9)[1] = 18

(10)[1] = 20

etc.

There is nothing surprising here. We can see that the rules we have established for FGH_Γ(0) can be used to evaluate (n)[1] in general, but that they are tedious for human operation. We can easily evaluate these things once we understand how they work. It should be noted however, that we only do that after we have figured out what [1] is encoding. If we don't know what a function is doing then we can't evaluate it except by carrying out it's algorithm. [1] is an elementary function, but let's look at [2]. How does the evaluation process work here. Let's look at the first few examples on an atomic level:

(0)[1+1] = (0)⁰[1+1'] = (0)⁰[1] = 0

Plugging in zero doesn't result in anything more difficult than for the previous function. We will find that in general (0)[α] will either evalute to 0 or 1. It evaluates to 1, whenever the α decays to 0, and it evaluates to 0, whenever α decays to a successor ordinal. Lets look at (1)[1+1]:

(1)[1+1] = (1)¹[1+1'] = (1)¹[1] = ((1)[1])⁰[1] = ((1)¹[1'])⁰[1] = ((1)¹[0])⁰[1] = (((1)[0])⁰[0])⁰[1] = ((1+1)⁰[0])⁰[1]

= ((2)⁰[0])⁰[1] = (2)⁰[1] = 2

That took 10 transformations this time, whereas (1)[1] only took 6. Also note that the output hasn't got any larger and (1)[2] = (1)[1] = 2. In general we will find that an argument of 1 produces an output of 2. This doesn't mean that the evaluation process won't get longer however. Now let's look at (2)[1+1] on an atomic level. How bad could that be? ...

(2)[1+1] = (2)²[1+1'] = (2)²[1] = ((2)[1])¹[1] = ((2)²[1'])¹[1] = ((2)²[0])¹[1] = (((2)[0])¹[0])¹[1] =

((2+1)¹[0])¹[1] = ((3)¹[0])¹[1]= (((3)[0])⁰[0])¹[1] = ((3+1)⁰[0])¹[1]= ((4)⁰[0])¹[1] = (4)¹[1] =

((4)[1])⁰[1] = ((4)⁴[1'])⁰[1] = ((4)⁴[0])⁰[1] = (((4)[0])³[0])⁰[1] = ((4+1)³[0])⁰[1] = ((5)³[0])⁰[1] =

(((5)[0])²[0])⁰[1] = ((5+1)²[0])⁰[1] = ((6)²[0])⁰[1] = (((6)[0])¹[0])⁰[1] = ((6+1)¹[0])⁰[1] =

((7)¹[0])⁰[1] = (((7)[0])⁰[0])⁰[1] = ((7+1)⁰[0])⁰[1] = ((8)⁰[0])⁰[1] = (8)⁰[1] = 8

Woah! Where did that come from ... it took 29 transformations to output a value of ... 8. This isn't even that bad of a case. The next case is worse ...

(3)[1+1] = (3)³[1+1'] = (3)³[1] = ((3)[1])²[1] = ((3)³[1'])²[1] = ((3)³[0])²[1] = (((3)[0])²[0])²[1] =

((3+1)²[0])²[1] = ((4)²[0])²[1] = (((4)[0])¹[0])²[1] = ((4+1)¹[0])²[1] = ((5)¹[0])²[1] = (((5)[0])⁰[0])²[1] =

((5+1)⁰[0])²[1] = ((6)⁰[0])²[1] = (6)²[1] =

((6)[1])¹[1] = ((6)⁶[1'])¹[1] = ((6)⁶[0])¹[1] = (((6)[0])⁵[0])¹[1] = ((6+1)⁵[0])¹[1] = ((7)⁵[0])¹[1] =

(((7)[0])⁴[0])¹[1] = ((7+1)⁴[0])¹[1] = ((8)⁴[0])¹[1] = (((8)[0])³[0])¹[1] = ((8+1)³[0])¹[1] =

((9)³[0])¹[1] = (((9)[0])²[0])¹[1] = ((9+1)²[0])¹[1] = ((10)²[0])¹[1] = (((10)[0])¹[0])¹[1] =

((10+1)¹[0])¹[1] = ((11)¹[0])¹[1] = (((11)[0])⁰[0])¹[1] = ((11+1)⁰[0])¹[1] = ((12)⁰[0])¹[1] = (12)¹[1] =

((12)[1])⁰[1] = ((12)¹²[1'])⁰[1] = ((12)¹²[0])⁰[1] = (((12)[0])¹¹[0])⁰[1] = ((12+1)¹¹[0])⁰[1] =

((13)¹¹[0])⁰[1] = (((13)[0])¹⁰[0])⁰[1] = ((13+1)¹⁰[0])⁰[1] = ((14)¹⁰[0])⁰[1] = (((14)[0])⁹[0])⁰[1] =

((14+1)⁹[0])⁰[1] = ((15)⁹[0])⁰[1] = (((15)[0])⁸[0])⁰[1] = ((15+1)⁸[0])⁰[1] = ((16)⁸[0])⁰[1] =

(((16)[0])⁷[0])⁰[1] = ((16+1)⁷[0])⁰[1] = ((17)⁷[0])⁰[1] = (((17)[0])⁶[0])⁰[1] = ((17+1)⁶[0])⁰[1] =

((18)⁶[0])⁰[1] = (((18)[0])⁵[0])⁰[1] = ((18+1)⁵[0])⁰[1] = ((19)⁵[0])⁰[1] = (((19)[0])⁴[0])⁰[1] =

((19+1)⁴[0])⁰[1] = ((20)⁴[0])⁰[1] = (((20)[0])³[0])⁰[1] = ((20+1)³[0])⁰[1] = ((21)³[0])⁰[1] =

(((21)[0])²[0])⁰[1] = ((21+1)²[0])⁰[1] = ((22)²[0])⁰[1] = (((22)[0])¹[0])⁰[1] = ((22+1)¹[0])⁰[1] =

((23)¹[0])⁰[1] = (((23)[0])⁰[0])⁰[1] = ((23+1)⁰[0])⁰[1] = ((24)⁰[0])⁰[1] = (24)⁰[1] = 24

That's a total of 77 transformations ... to evaluate 24. That may seem counter-intuitive at first. What good is a notation which takes more steps to evaluate than the number it's evaluating? The advantage is that it defines a number in principle because the algorithm is deterministic. So (3)[1+1] becomes a synonym for 24. It should also be noted that 24 is itself really shorthand for the number 24. To understand it we have to first already understand decimal notation. Think of large number notations as just an extension of decimal notation. They serve the same purpose: to provide a system of symbols to codify numbers in a compact way. Part of this codification involves being able to unpack them. For example, we know what the number 24 is because we can unpack it through counting. If you wanted to explain what 24 was to someone who knew nothing of number notations the easiest way would be to draw 24 lines or dots on a piece of paper. To do that yourself you would of coarse count them out in your head while writing them, or perhaps group them into 5's since this works evenly with the decimal base. In short this act of self-counting is actually the process of unpacking the meaning of 24. Seen this way it's not that surprising that it takes at least 24 steps to unpack any notational shorthand for 24.

Once we get past the "strangely" laborious nature of the evaluation process we can see that this actually is only natural for the algorithm. For any expression in FGH, the evaluation of that expression will require more transformations than the value of the expression itself! The reason is simple enough. The innermost argument never decreases because there is no rule for this ever occurring. It can only increase. More importantly it can only ever actually increase by 1 unit at a time! Everything else that happens is simply very elaborate copying and pasting! Only once the innermost function decays to [0] do we get to actually carry out a genuine operation on the argument. Getting to the base case eventually becomes so long-winded that it isn't even practical for us to reach it, and so it may seem that the argument never actually increases. This is not true, regardless of the example. The fact is that the argument will increase a unit at a time ... until it finally reaches the value of the original expression (in fact the value of ALL the intermediate expressions as well)! So at very least the number of transformations required for (n)[α] are at least (n)[α] - n. As it turns out, it will generally exceed the actual value because not every transformation increases the argument. In fact the above rules will only increase the innermost argument less than 1/3 of the time! So we should in theory find that the number of transformations involved in

(n)[α] is roughly 3*(n)[α]. So not so surprisingly we have 77 ~ 3*(3)[1+1] = 3*24 = 72. Of coarse with numbers as large as those that occur in FGH and googology in general a factor of 3 can essentially be ignored. So in a general sort of way we can make a blanket statement that for all googological notations the number of evaluation steps for any "number" will be roughly the number itself! So forget about whipping out a piece of paper in hopes of computing Graham's Number, or even a super computer for that matter. It can't be done in our tiny world of millions, billions, and trillions.

With that being said I won't bother to do a full evaluation of the next expression, (4)[1+1], as I can estimate it will take something like 192 steps. Even with expressions "this simple" the evaluation process will grow exponentially and will quickly fill up this entire article. Therefore I'll already start employing shortcuts. We previously established that (n)[1] = 2n, so we will substitute this instead of evaluating directly. This will speed up the evaluation considerably, at least for the time being. As we'll see later that won't be much help as we progress ...

(4)[1+1] = (4)⁴[1+1'] = (4)⁴[1] = ((4)[1])³[1] = (2*4)³[1] = (8)³[1] = ((8)[1])²[1]

= (2*8)²[1] = (16)²[1] = ((16)[1])¹[1] = (2*16)¹[1] = (32)¹[1] = ((32)[1])⁰[1]

= (2*32)⁰[1] = (64)⁰[1] = 64

I think it's worth noting that we have arrived at the value 64 here a little artificially. That is to say I'm not using FGH to actually evaluate it, I'm using decimal arithmetic to double the arguments. Nowhere in FGH does it explicitly say to double or how to double. It's just a natural consequence of the algorithm. This means that even if someone didn't know anything about arithmetic, one could learn FGH, follow it's rules and get the value of 64 eventually. Remember that all arithmetic really does ultimately break down to such a tedious algorithm. In any case I'll evaluate one more, though I'll skip some of the details ...

(5)[1+1] = (5)⁵[1] = (10)⁴[1] = (20)³[1] = (40)²[1] = (80)¹[1] = 160

At this point it's worth getting a general formula. It isn't too difficult to see that since (n)[2] = (n)ⁿ[1] , and each application of [1] doubles the argument we are going to double n a total of n times, hence (n)[2] = n*2^n. So we can see that [2] is just an exponential function. Moving on to the next level we get to some genuinely enormous values ...

(0)[1+1+1] = (0)⁰[1+1+1'] = (0)⁰[1+1] = 0

(1)[1+1+1] = (1)¹[1+1+1'] = (1)¹[1+1] = ((1)[1+1])⁰[1+1] = ((1)¹[1+1'])⁰[1+1]

= ((1)¹[1])⁰[1+1] = (((1)[1])⁰[1])⁰[1+1] = (((1)¹[1'])⁰[1])⁰[1+1] = (((1)¹[0])⁰[1])⁰[1+1]

= ((((1)[0])⁰[0])⁰[1])⁰[1+1] = (((1+1)⁰[0])⁰[1])⁰[1+1] = (((2)⁰[0])⁰[1])⁰[1+1] =

((2)⁰[1])⁰[1+1] = (2)⁰[1+1] = 2

Even an argument of 1 here leads to a rather long winded evaluation on the atomic level. All of this accomplishes the mere task of putting 1 and 1 together!

What about (2)[1+1+1]. Here I'll avail myself somewhat with explicit formulas, though it's still not quite a whopper yet ...

(2)[1+1+1] = (2)²[1+1+1'] = (2)²[1+1] = ((2)[1+1])¹[1+1] = ((2)²[1+1'])¹[1+1]

= ((2)²[1])¹[1+1] = (((2)[1])¹[1])¹[1+1] = ((4)¹[1])¹[1+1] = (((4)[1])⁰[1])¹[1+1]

= ((8)⁰[1])¹[1+1] = (8)¹[1+1] = ((8)[1+1])⁰[1+1] = ((8)⁸[1+1'])⁰[1+1] =

((8)⁸[1])⁰[1+1] = (((8)[1])⁷[1])⁰[1+1] = ((16)⁷[1])⁰[1+1] = ((32)⁶[1])⁰[1+1] =

((64)⁵[1])⁰[1+1] = ((128)⁴[1])⁰[1+1] = ((256)³[1])⁰[1+1] = ((512)²[1])⁰[1+1] =

((1024)¹[1])⁰[1+1] = ((2048)⁰[1])⁰[1+1] = (2048)⁰[1+1] = 2048

You should remember this value way back on the article about FGH_ω. The next value I'm not going to be able to evaluate completely, even using (n)[1] = 2n as a shortcut. You'll see why ...

(3)[1+1+1] = (3)³[1+1] = ((3)[1+1])²[1+1] = ((3)³[1])²[1+1] = ((6)²[1])²[1+1]

= ((12)¹[1])²[1+1] = (24)²[1+1] = ((24)[1+1])¹[1+1] = ((24)²⁴[1])¹[1+1] =

((48)²³[1])¹[1+1] = ((96)²²[1])¹[1+1] = ((192)²¹[1])¹[1+1] =

((384)²⁰[1])¹[1+1] = ((768)¹⁹[1])¹[1+1] = ((1536)¹⁸[1])¹[1+1] =

((3072)¹⁷[1])¹[1+1] = ((6144)¹⁶[1])¹[1+1] = ((12,288)¹⁵[1])¹[1+1] =

((24,576)¹⁴[1])¹[1+1] = ((49,152)¹³[1])¹[1+1] = ((98,304)¹²[1])¹[1+1] =

((196,608)¹¹[1])¹[1+1] = ((393,216)¹⁰[1])¹[1+1] = ((786,432)⁹[1])¹[1+1] =

((1,572,864)⁸[1])¹[1+1] = ((3,145,728)⁷[1])¹[1+1] = ((6,291,456)⁶[1])¹[1+1] =

((12,582,912)⁵[1])¹[1+1] = ((25,165,824)⁴[1])¹[1+1] = ((50,331,648)³[1])¹[1+1] =

((100,663,296)²[1])¹[1+1] = ((201,326,592)¹[1])¹[1+1] = ((402,653,184)⁰[1])¹[1+1] =

(402,653,184)¹[1+1] = (402,653,184)[1+1] = (402,653,184)^402,653,184[1] =

(805,306,368)^402,653,183[1] = (1,610,612,736)^402,653,182[1] = (3,221,225,472)^402,653,181[1]

= (6,442,450,944)^402,653,180[1] = ...

At this point the evaluation process becomes completely untenable. I would have to carry out an additional 402,653,180 doublings, by which time the number would have reached roughly 120,000,000 digits. This is beyond human reckoning, not because someone couldn't write out a 120,000,000 digit number, they could ... in a life time ... but because there would be hundreds of millions of such numbers to compute on the way to the final answer ... making it impossible for a human to ever compute the decimal expansion by hand! Let that sink in for a moment. That's just (3)[3]. It's not beyond machine reckoning but it would require about 400 MB of storage space. Not big enough to trouble the average persons hard drive, but pretty insanely sizable for a mere number on your hard drive. We can express it exactly however using exponential notation as 3*2^402,653,211. This is of coarse just a small tetrational number, and as the argument increases for [3] we'll get numbers whose magnitude must be expressed in power towers. In any case we've seen these results and values in the previous articles. The key thing to note here is that our algorithm works very well for these lower cases. Interestingly, despite all of the seeming complexity we've yet to even tap into the rules of FGH_Γ(0). We have only really used the first 2 rules of FGH and also used the definition of the predecessor of an ordinal. All the other stuff was just working out the functional powers and the successors.

Let's move on to the simplest case of a limit ordinal. Keep in mind that I'll be maintaining the strict rules of our definition to demonstrate that they behave as expected...

(0)[ω^(1)] = (0)[ω^(1)[0]] = (0)[0] = 0+1 = 1

There is actually a rule to deal specifically with this case, so there is no ambiguity here that ω[0] = 0. Let's see the next case:

(1)[ω^(1)] = (1)[ω^(1)[1]] = (1)[1+ω^(1)[0]] = (1)[1] = (1)[0] = 1+1 = 2

... again very explicit rules ensure that there is no ambiguity here. The case ω^(1)[n] and @+ω^(1)[n] are handled differently, taking additional terms into account in the evaluation of the ordinal. Let's look at the next case:

(2)[ω^(1)] = (2)[ω^(1)[2]] = (2)[1+ω^(1)[1]] = (2)[1+1+ω^(1)[0]]

= (2)[1+1] = (2)²[1] = 8

So far nothing too amazing. Let's try the next argument ...

(3)[ω^(1)] = (3)[ω^(1)[3]] = (3)[1+ω^(1)[2]] = (3)[1+1+ω^(1)[1]]

= (3)[1+1+1+ω^(1)[0]] = (3)[1+1+1] = a very large hundred million digit number

As you can see, the definition works well and diagonalizes over the primitive recursive members of FGH quite nicely. Let's try the next ordinal and see how it works out for the first few values:

(0)[ω^(1)+1] = (0)⁰[ω^(1)+1'] = (0)⁰[ω^(1)] = 0

(1)[ω^(1)+1] = (1)¹[ω^(1)+1'] = (1)¹[ω^(1)] = (1)[ω^(1)] = (1)[ω^(1)[1]] =

(1)[1+ω^(1)[0]] = (1)[1] = (1)[0] = 1+1 = 2

(2)[ω^(1)+1] = (2)²[ω^(1)+1'] = (2)²[ω^(1)] = ((2)[ω^(1)])[ω^(1)] =

((2)[ω^(1)[2]])[ω^(1)] = ((2)[1+ω^(1)[1]])[ω^(1)] = ((2)[1+1+ω^(1)[0]])[ω^(1)] =

((2)[1+1])[ω^(1)] = ((2)²[1])[ω^(1)] = ((4)[1])[ω^(1)] = (8)[ω^(1)] =

(8)[ω^(1)[8]] = ... = (8)[1+1+1+1+1+1+1+1]

Note the nice way the algorithm converts a positive integer in decimal notation into an ordinal notation composed only of the symbols 0,1,ω^() and ε(,). Everything so far seems to work quite nicely. Let's look at one more example before moving on...

(3)[ω^(1)+1] = (3)³[ω^(1)] = ((3)[ω^(1)])²[ω^(1)] =

((3)[ω^(1)[3]])²[ω^(1)] = ... = ((3)[1+1+1])²[ω^(1)]

= (120 million digit number)²[ω^(1)] = ((120 million digit number)[ω^(1)])[ω^(1)]

= ((120 million digit number)[ω^(1)[120 million digit number]])[ω^(1)]

= ... ... ... ...

= ((120 million digit number)[1+1+1+1+1+1+ ... ... ... +1+1+1+1])[ω^(1)]

w/ a 120 million digit number of 1's

... of coarse when the nightmare number , (120 million digit number)[1+1+1+1+ ... ... ... +1+1+1+1] , is finally solved just short of never, it will get feed into ω^(1)[n] producing an unfathomable number of 1's. And remember that the full evaluation of

(3)[ω^(1)+1] is going to take about as many steps as the number it eventually solves to. We can not imagine the full story of this process ... and yet there is nothing really incomprehensible here in the principle of it. The argument will just continue to tally up the applications of the [0] function, get feed into the next function, and so on. The sequence of ordinals created in the wake of the evaluation process are all very simple. There is ω^(1)+1, ω^(1), and then 1, 1+1, 1+1+1, 1+1+1+1, ... all the way up to the ordinal

((3)[3])[(3)[3]] expressed as a sequence of 1s. This is an absurdly long ordinal ... but it's still simple because it doesn't involving any kind of elaborate nesting pattern. We can describe it quite easily, even if we couldn't write it out in full. As we progress however even the story of how the ordinals involve will become obscured from sight. The process ... although long winded ... is still a quite comprehensible process. Don't worry that won't last...

Since we already tested several successor cases let's just test limit ordinals from here on out. The next limit ordinal is of coarse ω*2. Formally this is written ω^(1)+ω^(1) in our algorithm...

(0)[ω^(1)+ω^(1)] = (0)[ω^(1)+ω^(1)[0]] = (0)[ω^(1)] = (0)[ω^(1)[0]] =

(0)[0] = 0+1 = 1

(1)[ω^(1)+ω^(1)] = (1)[ω^(1)+ω^(1)[1]] = (1)[ω^(1)+1+ω^(1)[0]] = (1)[ω^(1)+1] = 2

(2)[ω^(1)+ω^(1)] = (2)[ω^(1)+ω^(1)[2]] = (2)[ω^(1)+1+ω^(1)[1]] =

(2)[ω^(1)+1+1+ω^(1)[0]] = (2)[ω^(1)+1+1]

Seems to be working quite well. We can imagine how this plays out through the ordinals ω*3, ω*4, ω*5, etc. Eventually we reach ω², which is written here as ω^(1+1). Here we get to use the successor rules for the ω^() function...

(0)[ω^(1+1)] = (0)[ω^(1+1)[0]] = (0)[0] = 0+1 = 1

Here the evaluation is straight forward ... any time the power of ω is a successor ordinal, we can simply replace it with 0 when plugging in 0. Simple. Let's see about the next case ...

(1)[ω^(1+1)] = (1)[ω^(1+1)[1]] = (1)[ω^(1+1')+ω^(1+1)[0]] = (1)[ω^(1)+ω^(1+1)[0]]

= (1)[ω^(1)]

Here we see the first case to involve nested ordinal operators. I have evaluated the predecessor first and then applied the bracket operator, [ ]. We get the expected result. Let's try the next case ...

(2)[ω^(1+1)] = (2)[ω^(1+1)[2]] = (2)[ω^(1+1')+ω^(1+1)[1]] =

(2)[ω^(1)+ω^(1+1)[1]] = (2)[ω^(1)+ω^(1+1')+ω^(1+1)[0]] =

(2)[ω^(1)+ω^(1)+ω^(1+1)[0]] = (2)[ω^(1)+ω^(1)] = (2)[ω^(1)+ω^(1)[2]] =

(2)[ω^(1)+1+ω^(1)[1]] = (2)[ω^(1)+1+1+ω^(1)[0]] = (2)[ω^(1)+1+1] =

(2)²[ω^(1)+1+1'] = (2)²[ω^(1)+1] = ((2)[ω^(1)+1])[ω^(1)+1] =

((2)²[ω^(1)+1'])[ω^(1)+1] = ((2)²[ω^(1)])[ω^(1)+1] =

(((2)[ω^(1)])[ω^(1)])[ω^(1)+1] = (((2)[ω^(1)[2]])[ω^(1)])[ω^(1)+1] =

(((2)[1+ω^(1)[1]])[ω^(1)])[ω^(1)+1] = (((2)[1+1+ω^(1)[0]])[ω^(1)])[ω^(1)+1] =

(((2)[1+1])[ω^(1)])[ω^(1)+1] = (((2)²[1])[ω^(1)])[ω^(1)+1] =

((((2)[1])[1])[ω^(1)])[ω^(1)+1] = ((((2)²[0])[1])[ω^(1)])[ω^(1)+1] =

(((((2)[0])[0])[1])[ω^(1)])[ω^(1)+1] = ((((2+1)[0])[1])[ω^(1)])[ω^(1)+1] =

((((3)[0])[1])[ω^(1)])[ω^(1)+1] = (((4)[1])[ω^(1)])[ω^(1)+1] =

(((4)⁴[0])[ω^(1)])[ω^(1)+1] = ((8)[ω^(1)])[ω^(1)+1] =

((8)[1+1+1+1+1+1+1+1])[ω^(1)+1] = etc.

Here I've actually gotten up to the part where the innermost argument actually starts to increase. This is not be possible as we progress to more complex ordinals because even the number of steps to that stage, a stage not even of the complete evaluation process, will become untenable. In fact we'll eventually find that even getting to a successor ordinal is difficult or impossible to full imagine!

In any case let's progress to some larger cases. From here on out I'll use an argument of 3. This is a nice smallish number which gives us a good idea of the general process and doesn't collapse to a trivial value like 0 and 1, and doesn't collapse to a much smaller ordinal as is the case with 2 (note that we went from ω² to a mere ω+2 as our first successor ordinal). Let's look at the case for ω³. I'll be skipping a lot of the tedious intermediary steps from here on out:

(3)[ω^(1+1+1)] = (3)[ω^(1+1+1)[3]] = (3)[ω^(1+1)+ω^(1+1)+ω^(1+1)] =

(3)[ω^(1+1)+ω^(1+1)+ω^(1+1)[3]] = (3)[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)] =

(3)[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)[3]]

= (3)[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1+1]

Here we reach our first successor ordinal. This marks the first time that we stop using Rule 3 of FGH and instead use Rule 2 which deals with successor ordinals. Getting to Rule 1 however takes a lot more work. Also notice how long our expressions are getting ... and it's going to get a lot worse starting here ...

= (3)³[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

= ((3)[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

... at this point the expressions will start getting too long to write on a single line. This is partly because of my rather unfriendly ordinal notation which doesn't allow for multiplication. However even if multiplication was allowed the expressions would still become increasingly unwieldy at this point, because we're going to have to start nesting a lot of intermediate functions and it will be a while before we reach the base case of [0] ...

= ((3)³[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((3) [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])

²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((3)³ [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+

1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((3) [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)

+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((3) [ω^(1+1)+ω^(1+1)+ω^(1)+1+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1

)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((3)³ [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)

+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((3)³ [ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+

ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+

ω^(1)+ω^(1)+1+1]

((((((3)³ [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+

ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+

ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((3) [ω^(1+1)+ω^(1+1)+1+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)

+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+

ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((3)³ [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)

+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+

ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((3)³ [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+

ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)

+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)

+ω^(1)+ω^(1)+1+1]

(((((((((3)³ [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+

ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)

+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((3) [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+

ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((3) [ω^(1+1)+ω^(1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+

ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+

ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)

+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((3) [ω^(1+1)+ω^(1)+ω^(1)+1+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+

ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+

ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+

ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((3)³ [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)

+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+

ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((3)³ [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((3)³ [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((3) [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((3) [ω^(1+1)+ω^(1)+1+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((3)³ [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((3)³ [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((3)³ [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((3) [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((3) [ω^(1+1)+1+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((3)³ [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((3)³ [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((3)³ [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((3) [ω^(1+1)])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((3) [ω^(1)+ω^(1)+ω^(1)])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((3) [ω^(1)+ω^(1)+1+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((3)³ [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((3)³ [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])²

[ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((3)³ [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])²

[ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])²

[ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((3) [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])²

[ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((3) [ω^(1)+1+1+1])² [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])²

[ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((3)³ [ω^(1)+1+1])² [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])²

[ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((3)³ [ω^(1)+1])² [ω^(1)+1+1])² [ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])²

[ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((((3)³ [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])² [ω^(1)+ω^(1)])²

[ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((3) [ω^(1)])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])²

[ω^(1+1)+1])² [ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)])²

[ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((3) [1+1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])² [ω^(1)+ω^(1)])²

[ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((3)³ [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])² [ω^(1)+ω^(1)])²

[ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((((((3)³ [1])² [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((((3)³ [0])² [1])² [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

((((((((((((((((((((((((((((3) [0])² [0])² [1])² [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((((3+1)² [0])² [1])² [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

(((((((((((((((((((((((((((4)² [0])² [1])² [1+1])² [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])²

[ω^(1)+ω^(1)])² [ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])²

[ω^(1+1)+1+1])² [ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

FINALLY ... the innermost argument changes from a 3 to a 4 ... the first of many such changes on the way to the value (3)[ω³]. Remember that the evaluation process has to COUNT to the massive value (3)[ω³], one at a time! So what we've seen here, itself a somewhat accelerated process ... is just the very tippiest tip of the iceberg. In fact it will be a very very long time until Rule 3 occurs again because we must first evaluate (3)[3] which is a 120 million digit number. The next occurence of Rule 3 will then be the evaluation of ((3)[3])[ω^(1)]. The 120 million digit number will then be converted to a mind-boggling string of 1+1+1+1 ... +1+1+1 with roughly 1xE120,000,000 1s. This will be the first point at which the expression reaches hyper-exponential size and can no longer actually be stored in the known universe! If however we use decimal notation we'll be okay for a while longer and the entire string could actually be stored on a hard drive. It would look something like ...

(((((((((((((((((((((((((6895...............................................................................................

.....................................................................................................................................

..........................................................................................7722374144 ) [6895..............

.....................................................................................................................................

...............7722374144] ) [ω^(1)])² [ω^(1)+1])² [ω^(1)+1+1])² [ω^(1)+ω^(1)])²

[ω^(1)+ω^(1)+1])² [ω^(1)+ω^(1)+1+1])² [ω^(1+1)])² [ω^(1+1)+1])² [ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1)+ω^(1)])² [ω^(1+1)+ω^(1)+ω^(1)+1])² [ω^(1+1)+ω^(1)+ω^(1)+1+1])²

[ω^(1+1)+ω^(1+1)])² [ω^(1+1)+ω^(1+1)+1])² [ω^(1+1)+ω^(1+1)+1+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)])² [ω^(1+1)+ω^(1+1)+ω^(1)+1])²

[ω^(1+1)+ω^(1+1)+ω^(1)+1+1])² [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)])²

[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1])²[ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1]

This massive string would be a file of roughly 231MB. The digits would account for the overwhelming majority of the string. Of the roughly 242 million characters in this ascii string, only about 500 of them would not be the digits! If we really did write a program to evaluate this string it could in fact continue ... but it would never again get to apply Rule 1 of FGH! That's because at this point we would start expanding out the massive [6895....4144] operator. Next we'd get the [6895....4143] operator, then the [6895....4142] operator, etc. and it would have to continue this way until reaching [0]. The computer will not have enough memory to reach this point because it the string would have to contain the full decimal expansion of every integer from 0 to 6895...4144! In fact the computer program wouldn't make it far past this point, because every time it expanded it would be adding roughly 120MB to the file size. Within the blink of an eye ( considered a very long time for a computer scientist) the hard drive would be completely full and the program would crash. In our minds eye we can go further still. The next time a limit ordinal occurs we would have a massive value of ((3)[3])[ω] to plug in. This number is far vaster than we can imagine. At this point the expression would expand beyond dimensions we have any hope of imagining. Beyond this our gaze becomes hazy. The algorithm will continue to dig itself out of all the nested functions ... but it will continue to generate smaller ones in it's wake so that it will seem like the process is inexhaustible. All the while the largest ordinal of ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1 will not have decayed at all. Finally ... after what can only be described as an eternity of eternities (because most peoples concept of eternity isn't all that long anyway) ... we reach the outermost function [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1] and it's replaced with an unimaginable number of copies of the predecessor [ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1]. In all of this we would have only just scratched the very surface of the evaluation process ... feel free to scream...

... and worse of all ... we're still only just talking about ω³. We haven't even gotten to the epsilons yet!

It's impossible to fully understand this stuff ... but yet a good googologist ambles on without fear. Let's go on to the next major rule for FGH_Γ(0) ... when ω is raised to a limit ordinal. The smallest case of this is ω^ω. This is the order type of Bowers' linear arrays. Let's look at the first few values for this function. At n=0 we have a fine point that comes up:

(0)[ω^(ω^(1))] = (0)[ω^(ω^(1))[0]] = (0)[ω^(ω^(1)[0])] = (0)[ω^(0)]

Here we get ω^(0) , which isn't even a rogue, it's an illegal construction not in the set Γ(0) as defined in our definition! To solve this hitch this expression is defined as a synonym for 1 (See Laws for ω Rule 1). The resolution is then straight forward:

(0)[ω^(0)] = (0)[1] = (0)⁰[0] = 0

Let's see what we get for n=1:

(1)[ω^(ω^(1))] = (1)[ω^(ω^(1))[1]] = (1)[ω^(ω^(1)[1])] = (1)[ω^(1)] =

(1)[ω^(1)[1]] = (1)[1] = (1)[0] = 2

Now let's try n=2, the first non-trivial value:

(2)[ω^(ω^(1))] = (2)[ω^(ω^(1))[2]] = (2)[ω^(ω^(1)[2])] =

(2)[ω^(1+1)] = (2)[ω^(1+1)[2]] = (2)[ω^(1)+ω^(1)] =

(2)[ω^(1)+ω^(1)[2]] = (2)[ω^(1)+1+1] = (2)²[ω^(1)+1] =

((2)[ω^(1)+1])[ω^(1)+1] = (((2)[ω^(1)])[ω^(1)])[ω^(1)+1] =

= (((2)[1+1])[ω^(1)])[ω^(1)+1] = ((8)[ω^(1)])[ω^(1)+1] =

((8)[1+1+1+1+1+1+1+1])[ω^(1)+1]

This value is already much larger than Graham's Number which is only about (65)[ω+1], where as...

(2)[ω^ω] = ((8)[8])[ω+1] ~ (E100#100#100#100#100#100#16)[ω+1]

In fact this is even larger than G(3^^^^3). That's quite a jump from 2! ... and this is a collapsing value for the function. To get a truly representative number for the power of the [ω^ω] we need to use an input of at least 3:

(3)[ ω^(ω^(1))] = (3)[ ω^(ω^(1))[3]]

The rule states that when the power is a limit ordinal, take the nth member of the fundamental sequence of the limit ordinal. Let's see what happens...

= (3)[ ω^(ω^(1))[3]] = (3)[ ω^(ω^(1)[3])] = (3)[ ω^(1+1+1)]

So here we get back to (3)[ω³]. Do note however that [ω^ω] actually diagonalizes over the integer powers of ω so that (4)[ω^ω] = (4)[ω⁴] , (5)[ω^ω] = (5)[ω⁵], etc. Each of these powers of ω is unimaginably more powerful than the last. We can continue the powers of ω past ω^ω with ω^(ω+1):

(3)[ω^(ω^(1)+1)] = (3)[ω^(ω^(1)+1)[3]]

Since the power, ω+1, is a successor ordinal, we use the previous rule for ω. The evaluation of the ordinal is as follows:

(3)[ω^(ω^(1)+1)[3]] = (3)[ω^(ω^(1)+1')+ω^(ω^(1)+1)[2]] =

(3)[ω^(ω^(1))+ω^(ω^(1)+1)[2]] = (3)[ω^(ω^(1))+ω^(ω^(1)+1')+ω^(ω^(1)+1)[1]]

= (3)[ω^(ω^(1))+ω^(ω^(1))+ω^(ω^(1)+1)[1]]

= (3)[ω^(ω^(1))+ω^(ω^(1))+ω^(ω^(1)+1')+ω^(ω^(1)+1)[0]]

= (3)[ω^(ω^(1))+ω^(ω^(1))+ω^(ω^(1))+ω^(ω^(1)+1)[0]]

(3)[ω^(ω^(1))+ω^(ω^(1))+ω^(ω^(1))]

Here we reach the next limit ordinal of ω^ω+ω^ω+ω^ω or (ω^ω)*3. It is still possible to actually get to the base case of [0] here, but it ends up being about 3 times as much work as it was for the case of (3)[ω³]. As you can imagine we don't have to go much further in the ordinals to reach examples that are completely untenable for direct evaluation. In fact we can get a pretty good guess at when this happens, because we can actually use the ordinal to measure the number of nested functions required to reach the base case of [0]. To do this we can simply replace ω with the argument. So ω³requires about 3³ or 27 nested types of functions. We can even see this in the previous example. If you count the number of pairs of parentheses , ( ) , used when we first reached the base case for (3)[ω³] that it's exactly 27. So to reach the base case for (3)[ω^(ω+1)] we would have 3^(3+1) or 81 pairs of parentheses. This is an interesting parallel to how BEAF expands, relating the array size to the number of entries. Here are a few more "nearby" examples along with the number of nested parentheses required to reach the base case:

(3)[ω^(ω^(1+1))] = (3)[ω^(ω^(1+1))[3]] = (3)[ω^(ω^(1+1)[3])]

= (3)[ω^(ω^(1)+ω^(1)+ω^(1))]

3^3^2 or 19,683 nestings required...

(3)[ω^(ω^(1+1+1))] = (3)[ω^(ω^(1+1+1))[3]] = (3)[ω^(ω^(1+1+1)[3])]

= (3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1+1))]

3^3^3 or 7,625,597,484,987 nestings required...

(3)[ω^(ω^(1+1+1+1))] = (3)[ω^(ω^(1+1+1+1))[3]] = (3)[ω^(ω^(1+1+1+1)[3])]

= (3)[ω^(ω^(1+1+1)+ω^(1+1+1)+ω^(1+1+1))]

3^3^4 or 443,426,488,243,037,769,948,249,630,619,149,892,803 nestings required...

In the second case only a super computer would be able to reach the base case... and for the third case no computer currently in existence has anywhere near that kind of capacity. Even just the parenthesis would overload the memory! Even the first successor ordinal is becoming prohibitively long. Consider the first case. ω^(ω^(1+1)) will eventually decay to ...

ω^(ω^(1)+ω^(1)+1+1)+ω^(ω^(1)+ω^(1)+1+1)+ω^(ω^(1)+ω^(1)+1)+ω^(ω^(1)+ω^(1)

+1)+ω^(ω^(1)+ω^(1))+ω^(ω^(1)+ω^(1))+ω^(ω^(1)+1+1)+ω^(ω^(1)+1+1)+ω^(ω^(1)

+1)+ω^(ω^(1)+1)+ω^(ω^(1))+ω^(ω^(1))+ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1+1

Suffice it to say that pretty soon even the first successor ordinal, and the first application of rule 2, will be impossible to reach ... and eventually even to understand. At that point the evaluation process becomes almost completely unknowable. We're not quite up to that point yet. Let's first consider some power towers of ω before we get to the smallest epsilons. I will use red to highlight the portion of the ordinal for which the bracket operator is applying...

(3)[ω^(ω^(ω^(1)))] = (3)[ω^(ω^(ω^(1)))[3]] = (3)[ω^(ω^(ω^(1))[3])] =

(3)[ω^(ω^(ω^(1)[3]))] = (3)[ω^(ω^(1+1+1))] =

(3)[ω^(ω^(1+1+1))[3]] = (3)[ω^(ω^(1+1+1)[3])] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1+1))] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1+1))[3]] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1+1)[3])] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1))] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1))[3]] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)[3])] =

(3)[ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1+1)] = ...

We're still a long way from obtaining a successor ordinal here. Also at this point the expression starts to grow faster. Notice that the bracket operator has to climb up the power tower a few times before it can reduce the ordinal to ground level. This gets worse for taller power towers ...

(3)[ω^(ω^(ω^(ω^(1))))] =

(3)[ω^(ω^(ω^(ω^(1))))[3]] =

(3)[ω^(ω^(ω^(ω^(1)))[3])] =

(3)[ω^(ω^(ω^(ω^(1))[3]))] =

(3)[ω^(ω^(ω^(ω^(1)[3])))] =

(3)[ω^(ω^(ω^(1+1+1)))] =

(3)[ω^(ω^(ω^(1+1+1)))[3]] =

(3)[ω^(ω^(ω^(1+1+1))[3])] =

(3)[ω^(ω^(ω^(1+1+1)[3]))] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1+1)))] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1+1)))[3]] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1+1))[3])] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1+1)[3]))] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)))] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)))[3]] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1))[3])] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+ω^(1)[3]))] =

(3)[ω^(ω^(ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1+1))] = ...

It's taken more steps here just to decay the lead exponent to "ω^(1+1)+ω^(1+1)+ω^(1)+ω^(1)+1+1+1". That's because more climbing was required this time. Even the climbing step can be made absurdly large given a tall enough power tower. For example if we use ω^^100 it will take a 100 steps to climb up to the top most exponent each time. Of coarse we can also have ω^^1000 or ω^^1,000,000 etc. In fact with the introduction of the epsilon numbers we can go much much further than this! The first epsilon number we introduce is ε(0,0). Basically we have that ε(0,0)[n] = ω^^n. I set it this way on purpose. Let's see how this works out for a large example with n=5 :

(5)[ε(0,0)] = (5)[ε(0,0)[5]] = (5)[ω^(ε(0,0)[4])] = (5)[ω^(ω^(ε(0,0)[3]))] =

(5)[ω^(ω^(ω^(ε(0,0)[2])))] = (5)[ω^(ω^(ω^(ω^(ε(0,0)[1]))))] =

(5)[ω^(ω^(ω^(ω^(ω^(ε(0,0)[0])))))] = (5)[ω^(ω^(ω^(ω^(ω^(1)))))]

With ε(0,0) the sky's no limit at all ... literally ... if we want a power tower of ω to go well past the clouds and into the starts we can use something like...

(1,000,000,000,000,000,000,000,000)[ε(0,0)]

... but even this will become obsolete with the next ordinal ...

(3)[ε(0,0)+1] = (((3)[ε(0,0)])[ε(0,0)])[ε(0,0)] =

(((3)[ω^(ω^(ω^(1)))])[ε(0,0)])[ε(0,0)]

(3)[ε(0,0)] is way way larger than 1,000,000,000,000,000,000,000,000. Now imagine ω^^(3)[ε(0,0)]. This power tower won't fit in the universe ... it completely transcends it ... and when solved it produces an even more massive integer. But we're not done, take that integer ... ((3)[ε(0,0)])[ω^^(3)[ε(0,0)]] ... call it N and then have ω^^N. So we have power towers of ω's describing the number of terms in another power tower of ω's. Pretty insane. Note that the growth rate of this is VASTLY greater than that of power towers of integers describing the number of terms in another power tower of integers. This does suggest that perhaps we can go further by extending the hyper-operators to apply to ω's. This is the extension which Jonathan Bowers' envisioned ... but which has yet to be fully realized by anyone. Bowers' does not provide explicit rules for arrays past dimensional arrays. This may have something to do with the fixed point property of ε₀. Chris Bird has offered some analysis on the comparison of ordinals past ε₀ and their relation to array structures, but even he admits that they are approximations. Perhaps an analysis of the decay of the ordinals past ε(0,0) will give us some insight into the matter. So let's continue with our analysis.

We can continue past ε(0,0) by simply adding to it any ordinal we've already constructed ... including ε(0,0) itself. For example...

(3)[ε(0,0)+ε(0,0)] = (3)[ε(0,0)+ε(0,0)[3]] = (3)[ε(0,0)+ω^(ω^(ω^(1)))]

The second tower will eventually decay so that the first ε(0,0) can decay to a massive power tower of ω's (and I mean MASSIVE ... (3)[ε(0,0)+1] just can't compare). We can also have as many of these ε(0,0) as we can muster to write out ...

(3)[ε(0,0)+ε(0,0)+ε(0,0)]

(3)[ε(0,0)+ε(0,0)+ε(0,0)+ε(0,0)]

(3)[ε(0,0)+ε(0,0)+ε(0,0)+ε(0,0)+ε(0,0)]

etc.

... of coarse there's an ordinal for that! To facilitate the copying of ε(0,0) to googological extremes we can use the ordinal ω^(ε(0,0)+1). Technically this ordinal will iterate ω^(ε(0,0)) , but this is just a rogue type which immediately collapses to a power tower of ω and is therefore a surrogate for ε(0,0). Here's an example of how this works...

(3)[ω^(ε(0,0)+1)] = (3)[ω^(ε(0,0)+1)[3]] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0))]

Because ε(0,0)+1 is a successor ordinal the omega rule for successor exponents kicks into gear. This causes the copying of ω to the predecessor ordinal, ε(0,0). Next the algorithm begins to decay the right most term...

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0))[3]] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0)[3])] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ω^(ε(0,0)[2]))] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ω^(ω^(ε(0,0)[1]))] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ω^(ω^(ω^(ε(0,0)[0])))] =

(3)[ω^(ε(0,0))+ω^(ε(0,0))+ω^(ω^(ω^(ω^(1)))] = ...

Notice that it decays not to ω^^3 but to ω^^4. Again this is do to having no synonym support, ... ie. ω^(ε(0,0))[n]≠ε(0,0)[n]. As a consequence the number of nestings that will result to get to the base case will be 3*3^3^3^3 or 3^(1+3^3^3). Notice how this form is eerily similar to the ordinal form ω^(ε(0,0)+1). This lends support to a theory of Chris Birds that holds that ε₁ could be interpreted as ω^^(ω*2) because ε₁expands to ω^ω^ω^ ... ^ω^(ε₀+1). Since ε₀ = ω^^ω it stands to reason that ε₁= E_ωε₀+1#ω ~

E_ωω^^ω#ω = E_ω 1#(ω*2) = ω^^(ω*2). You might notice however that we have to conveniently ignore the +1 in this case ... even though ordinal arithmetic says ε₀+1≠ε₀... large though ε₀ may be. Let's not be too hasty with this conclusion and instead explore additional examples. Some guiding principles are that ω^^k evaluates to n^^k nestings for an argument of n. Also that these nestings are additive in the usual sense so that if α has "a" nestings, and β has "b" nestings, then α+β has "a+b" nestings.

Let's look at some larger examples and see what sort of patterns emerge...

(3)[ω^(ε(0,0)+2)] =

(3)[ω^(ε(0,0)+1)+ω^(ε(0,0)+1)+ω^(ε(0,0)+1)] =

(3)[ω^(ε(0,0)+1)+ω^(ε(0,0)+1)+ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0))]

Based on the additive principle we see that this should be 3*3*3^^4 or 3^(2+3^3^3). Again we have the parallel. We can see that each new successor power will result in 3 times the number of nestings. Let's now diagonalize over that pattern and go to the next major limit ordinal ... ω^(ε(0,0)+ω^(1)) ...

(3)[ω^(ε(0,0)+ω^(1))] =

(3)[ω^(ε(0,0)+ω^(1))[3]] =

(3)[ω^(ε(0,0)+ω^(1)[3])] =

(3)[ω^(ε(0,0)+3)]

So this would result in 3^(3+3^3^3) nestings. At this point we can surmise part of the pattern ...

ω^(ε(0,0)+ω^(1)+1) --> 3^(3^3^3+3+1)

ω^(ε(0,0)+ω^(1)+ω^(1)) --> 3^(3^3^3+3+3)

ω^(ε(0,0)+ω^(2)) --> 3^(3^3^3+3^2)

ω^(ε(0,0)+ω^(ω)) --> 3^(3^3^3+3^3)

...

ω^(ε(0,0)+ε(0,0)) --> 3^(3^3^3+3^3^3)

ω^(ε(0,0)+ε(0,0)+ε(0,0)) --> 3^(3^3^3+3^3^3+3^3^3)

Now comes the critical point ... what happens when we try to expand ω^(ω^(ε(0,0)+1)). Well first it expands to ω^(ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0))).

In turn each ω^(ε(0,0)) decays to ω^^4. Finally we decay to ω^(ω^(ε(0,0))) which decays to ω^^5. So in all we get (3^^5)^3 or 3^(3*3^^4) or 3^3^(3^^3+1) nestings. So it appears that the ordinals collapse in the same way that Chris predicted. The reason for this is that although the ordinals are often treated as "infinities", in FGH they must always collapse to a finite expression ... and therefore the collapsing process is itself a finite process, related to the size of the argument. From this we can predict something of the nature of ε(1,0). Here is a partial evaluation for n=3:

(3)[ε(1,0)] = (3)[ε(1,0)[3]] = (3)[ω^(ε(1,0)[2])] = (3)[ω^(ω^(ε(1,0)[1]))]

= (3)[ω^(ω^(ω^(ε(1,0)[0])))] = (3)[ω^(ω^(ω^(ε(0,0)+1)))] =

(3)[ω^(ω^(ω^(ε(0,0)+1)))[3]] = (3)[ω^(ω^(ω^(ε(0,0)+1))[3])] =

(3)[ω^(ω^(ω^(ε(0,0)+1)[3]))] = (3)[ω^(ω^(ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0))))] = ...

This comes out to 3^3^3^(3^^3+1) nestings or approximately 3^^6. Let's try ε(2,0) and see what happens:

(3)[ε(2,0)] = (3)[ε(2,0)[3]] = (3)[ω^(ω^(ω^(ε(1,0)+1)))] =

(3)[ω^(ω^(ω^(ε(1,0))+ω^(ε(1,0))+ω^(ε(1,0))))] =

(3)[ω^(ω^(ω^(ε(1,0))+ω^(ε(1,0))+ω^(ω^(ω^(ω^(ε(0,0)+1))))))] =

(3)[ω^(ω^(ω^(ε(1,0))+ω^(ε(1,0))+ω^(ω^(ω^(ω^(ε(0,0))+ω^(ε(0,0))+ω^(ε(0,0)))))))] =

(3)[ω^(ω^(ω^(ε(1,0))+ω^(ε(1,0))+ω^(ω^(ω^(ω^(ε(0,0))

+ω^(ε(0,0))+ω^(ω^(ω^(ω^(1)))))))))] =

Here we can literally see the power tower of omega's growing. Note however that the epsilon numbers have not disappeared. Every time we manage to chop down a power tower, another one of these epsilon numbers will sprout another one like the magical sprouting heads of the legendary hydra. Eventually however we will get back to the root and then eventually to the base case. It will now take roughly 3^^9 nestings to get to the base case. So now even increasing the argument by 1 is an impossibly long winded process. Yet 3^^9 is small by comparison to numbers we were generating even way back a few articles. How much larger can this number get? Let's find out...

The next major case involves a limit ordinal in the first argument of our binary epsilon function. The smallest case for this is ω. Let's see what happens:

(3)[ε(ω^(1),0)] = (3)[ε(ω^(1),0)[3]] = (3)[ε(ω^(1)[3],0)] = (3)[ε(3,0)]

This will lead to roughly 3^^12 nestings. In general n will have n^^(n²+n). What about larger ordinals? We can surmise that (3)[ε(ω+1,0)] has 3^^15 nestings,

(3)[ε(ω+2,0)] has 3^^18 nestings, ... (3)[ε(ω+ω,0)] has 3^^21 nestings ...

(3)[ε(ω²,0)] has 3^^30 nestings ... (3)[ε(ω^ω,0)] has 3^^84 nestings ...

(3)[ε(ω^(ω+1),0)] has 3^^246 nestings ... (3)[ε(ω^(ω+2),0)] has 3^^(729+3) nestings

... (3)[ε(ω^(ω+ω),0)] has 3^^(3^7+3) nestings ...

... (3)[ε(ω^(ω²),0)] has 3^^(3^(9+1)+3) nestings

... (3)[ε(ω^(ω^ω),0)] has 3^^(3^(3^3+1)+3) nestings

... (3)[ε(ε(0,0),0)] has ~ 3^^(3^^3) nestings

... (3)[ε(ε(1,0),0)] has ~ 3^^(3^^6) nestings

... (3)[ε(ε(2,0),0)] has ~ 3^^(3^^9) nestings

... (3)[ε(ε(ω,0),0)] has ~ 3^^(3^^12) nestings

... (3)[ε(ε(ε(0,0),0),0)] has ~ 3^^(3^^3^^3) nestings

... (3)[ε(ε(ε(ε(0,0),0),0),0)] has ~ 3^^(3^^3^^3^^3) nestings

etc.

We can see that the number of nestings is approaching pentational numbers. The limit of the ordinals is ε(0,1). So let's see what this ordinal leads to...

(3)[ε(0,1)] = (3)[ε(0,1)[3]] = (3)[ε(ε(0,1)[2],0)] = (3)[ε(ε(ε(0,1)[1],0),0)] =

(3)[ε(ε(ε(ε(0,1)[0],0),0),0)] = (3)[ε(ε(ε(0,0),0),0)]

so we get 3^^3^^3^^3 or 3^^^4 nestings. We are still just getting started though. Note that all the previous rules still apply with our new epsilon number ε(0,1). Here are some examples...

(3)[ε(0,1)+1] = (((3)[ε(0,1)])[ε(0,1)])[ε(0,1)]

(3)[ω^(ε(0,1)+1)] = (3)[ω^(ε(0,1))+ω^(ε(0,1))+ω^(ε(0,1))]

(3)[ε(ε(0,1)+1,0)] = (3)[ω^(ω^(ω^(ε(ε(0,1),0))))]

etc.

It is this ability to apply previous ordinal functions to the new ordinals that gives this theory of fixed points so much power. The next epsilon number ε(1,1) is far far from ε(0,1). Here is the next example...

(3)[ε(1,1)] = (3)[ε(ε(ε(ε(0,1)+1,0),0),0)]

This will have something like 3^^3^^3^^(3^^^4) or 3^^^7 nestings. We can continue with these new values ...

(3)[ε(2,1)] = (3)[ε(ε(ε(ε(1,1)+1,0),0),0)]

(3)[ε(3,1)] = (3)[ε(ε(ε(ε(2,1)+1,0),0),0)]

and here we just keep getting the next fixed point of the function β→ε(β). Eventually we reach a limit ordinal...

(3)[ε(ω,1)] = (3)[ε(3,1)]

In a very lengthy process we can continue to climb the hierarchy of ordinals which we are in the very process of producing until we eventually get up to the epsilon numbers themselves beginning with ε(0,0) ...

(3)[ε(ε(0,0),1)] = (3)[ε(ω^ω^ω,1)]

eventually we get to ε(0,1)....

(3)[ε(ε(0,1),1)] = (3)[ε(ε(ε(ε(0,0),0),0),1)]

eventually we reach the ordinal we just created, namely ε(ε(0,1),1) ...

(3)[ε(ε(ε(0,1),1),1)]

at this point it should be obvious we can just nest ε(β,1). Above this is the limit ordinal ε(0,2). This will produce hexational nestings. We can apply the same trick to develop ε(0,3) (heptational nestings), ε(0,4) (octational nestings) etc. ...

Beyond all this would be ε(0,ω), the first instance of a limit ordinal in the second argument of our binary epsilon function. Here the number of nestings transcends any specific number of up-arrows, and can instead have roughly n up-arrows. We can go further still and let the second argument go through the ordinals we have so far generated eventually reaching back to the epsilon numbers again ... ε(0,ε(0,0)) ... at this point we're talking about a tetrational number of up-arrows!!! This eventually leads to the limits of FGH_Γ(0) as we nest the second argument of our binary epsilon function ... ε(0,ε(0,ε(0,0))) , ε(0,ε(0,ε(0,ε(0,0)))) , etc.

As for the number of nestings we get arrow numbers describing the number of arrows in another arrow number etc. Amazingly the number of nestingnow can exceed Graham's Number. It reaches roughly <n,n,1,2> in Bowers' Exploding array function!

Conclusion

Giants lurking out on the horizon...

We've come an incredibly long way already. At this point we've already gone beyond the popular discussion of large numbers and even gotten through most (but not all) of the kinds of numbers and functions which are of use to main stream mathematics. In fact there is no universally accepted ordinal notation after Γ₀. Instead there are several common notations. Yet we have not yet exhausted the ordinal tool kit ... not by a long shot. We can even go much much further with the Veblen notation! While you'd be hard pressed to see many examples of FGH beyond (n)[Γ₀] , they do exist! Harvey Friedmann has studied combinatorial functions whose growth rate is known to far exceed even these blasphemous heights! To even get close to describing a number Friedmann devised , called TREE(3), we must develop the ordinals even further. We can however say that (k)[Γ₀] marks a lower bound for TREE(k), so that we know TREE(3) >>> (3)[Γ₀]. In the meanwhile we can still create truly massive values like ...

(100)[ε(0,ε(0,ε(0,ε(0, ... ... ε(0,ε(0,ε(0,ε(0,100))))))))] w/100 ε's

Such a number will still be nowhere near TREE(3).

For most people however this probably satisfies any curiosity about just how big numbers have gotten in modern mathematics. But if you've been observant up to this point there are a number of hints that something much bigger ... much scarier ... is likely possible. For one, you might notice, that once you get used to it ... the rules aren't that complicated. Sure the execution might be impossible, but each of the individual steps isn't that hard ... and there aren't so many rules that it's difficult to memorize them. On the other hand the rules do now take up more than a page to write out in full ... so they aren't too simple either. Still, it should be too difficult to see that we can still continue with relative ease. Note that the key to continuing is always to diagonalize over the previous constructed subsystem. As long as this isn't difficult to do continuing is easy. How could we easily diagonalize over FGH_Γ₀. Simple. Just define the fundamental sequence:

Γ₀[0] = 0

otherwise...

Γ₀[n] = ε(0,Γ₀[n-1])

Using this it is now possible to evaluate (3)[Γ₀] ...

(3)[Γ₀] = (3)[Γ₀[3]] = (3)[ε(0,Γ₀[2])] = (3)[ε(0,ε(0,Γ₀[1]))] = (3)[ε(0,ε(0,ε(0,Γ₀[0])))] =

(3)[ε(0,ε(0,ε(0,0)))]

... and with that we're back within the confines of FGH_Γ₀.

So here's a scary question ... how big does a system have to be for it to be difficult to diagonalize? If we are to believe the conventional wisdom then continuing is always a cake-walk. But isn't this notion that we can continue leisurely as long as we wish born out of a naive experience with ordinary numbers? Just because we can always add 1, and that's easy... does it following that inventing newer, more terrifying, more mindblowing ways of extending numbers always remains at the same level of difficulty? I hope that even now you are beginning to see that something weird is going on as we get to larger and larger numbers ... namely that they are becoming ... very gradually ... more complex and challenging to define. Perhaps there are ways to describe numbers as large as (3)[Γ₀] which are simpler ... but how much simpler do you think they can get? Shouldn't there be a limit to how much you can compact the information in a number? But if that's true it leads to another scary implication ... numbers so big that even the algorithm is too big to be described! Clearly we haven't met this condition either. Then there is yet another scary idea ... if we got this far and the number of nestings only reached the vicinity of Graham's Number how much larger would we have to go to reach things like (3)[ω²] nestings, or (3)[ω^ω] or (3)[ε(0,0)]

Γαβγδεζηθικλ^μνξοπρςστυφχψω∈∉≠⊂→ƒ