home‎ > ‎4.3‎ > ‎

4.3.6 - Extended Cascading-E Notation

4.3.6
Extended Cascading-E Notation



Introduction

                    When we last left off we had reached something of an impasse with where to continue after Limited Extension Cascading-E Notation (LECEN). After a preliminary overview of what lay ahead I concluded that the details would have to be worked out before we could continue properly. After some independent research of my own into Jonathan Bowers' X-Structures and ordinals notations I believe I have finally "worked out" some of those details, and we can now take a look at a continuation of Cascading-E Notation (E^) to a full fledged Extended Cascading-E Notation (xE^)!

                    The system I have worked out provides an interesting new theory of ordinal hyper-operations and is more powerful than extensions suggested by others. In fact the xE^ system I've developed goes beyond Γ0 (Gamma-Zero) and some preliminary work leads me to believe it has order-type φ(ω,0,0).

                    We'll be covering a lot of ground in this article. First I go over some other attempts to Extend my Cascading-E Notation, then we'll look into some of the theory of hyper-operators applied to ordinals, and from this we'll build, from the ground up, a fully functional xE^. After that we'll forge another massive set of googologism's (and I mean massive!) for the new notation. Lastly I'll discuss in brief the next development underway! Due to the incredible length of this article and certain technical limitations with google sites it has been broken into 3 parts. The first part deals with developing the notation, and the next 2 parts are all the new googolism's! Let's get started ...

Other Attempts

                    At the end of my previous article (Cascading-E Notation), I asked the question: how do we continue Cascading-E Notation? Some have attempted to answer that very question. Here I'll consider only the major attempts at a continuation within the googologist community.

                    First up we have Aarex Tiaokhiao (username googleaarex on the googology wiki) a young googologist who has gained notoriety mainly by hosting a personal website in which he attempts to expand upon the work of others. Our main interest at the moment is Tiaokhiao's attempts to extend Cascading-E Notation. He actually made 2 attempts. I'll be examining both briefly. 

                    In Aarex's first attempt (which I have archived here), he forgo's the use of up-arrows for continuing, as I had always intended, and instead opts to use numbers within ordinary parentheses. He begins with the definition:

@a#(2)#b = @a#^#^...^#a w/b #s

                    Which is identical to my use of #^^# in the Cascading-E Notation article. Without explaining too much he goes on to provide the predictable expansion:

@a#(n)#b = @a#(n-1)#(n-1)# ... #(n-1)#a w/b #s

                     He provides a number of number names using this system. The fatal flaw of this system, is the same problem I already cited in the previous article! Namely, that these rules only define the broad strokes, or milestone sequences of a possible system. These rules can not resolve expressions such as @a#^^##b. Because the decompositions for such delimiters are not defined in Tiaokhiao's system, none of his higher expressions are properly defined in terms of the lower ones. The result is an "empty system", which only represents the skeletal structure of a possible system. This is equivalent to having an ordinal notation for the Fast Growing Hierarchy without defining all the fundamental sequences.

                    Although not well defined, Tiaokhiao continues his system beyond this level with the following:



#(#)# --> #(b)#

#(#)^# --> #(#)#(#)#...#(#)#(#)# (b #'s)

#(#)(2)# --> #(#)^#(#)^#...#(#)^#(#)^# (b #'s)

#(#)(3)# --> #(#)(2)#(#)(2)#...#(#)(2)#(#)(2)# (b #'s)

...

#(#)(#)# --> #(#)(b)#

#(#)(#)(#)# --> #(#)(#)(b)#

#(#)(#)(#)(#)# --> #(#)(#)(#)(b)#

...

#(##)# --> #(#)(#)...(#)(#)# (b #'s)

#(##)^# --> #(##)#...#(##)# (b #'s)

#(##)(#)# --> #(##)(b)# (b #'s)

#(##)(##)# --> #(##)(#)(#)...(#)(#)# (b #'s)

#(##)(##)(##)# --> #(##)(##)(#)(#)...(#)(#)# (b #'s)

...

#(###)# --> #(##)(##)...(##)(##)# (b #'s)

That all!
But there more!
#(#^#)#
#(#^#*#)#
#(#^#*#^#)#
#(#^##)#
#(#^#^#)#
#(#(2)#)#
#(#(#)#)#
#(#(##)#)#
#(#(#^#)#)#
#(#(#(#)#)#)#
#(#(#(#(#(... with (c #('s)!




                     This goes beyond the concept of an Extended Cascading-E Notation. While the "rules" are fairly clear here, they again are incomplete. Interestingly, Tiaokhiao anticipates the next level of my Extensible-E System after xE^. In the final article of this series I'll show how to create a fully functional version of this system, as well as a system give some of the outline of a system that goes way way beyond that!

                    Tiaokhiao's 2nd attempt (archived here) at first glance appears to be better defined. The first thing of note however is that he does not make use of my Limited Extension Cascading-E Notation (LECEN) but opts for another extension of E^. As I'll show momentarily, his choices actually waste a lot of potential from the system and also lead to some ambiguities. 

                    He calls his new system Nested Cascading-E Notation. He then begins with a rather unorthodox interpretation of hyperion tetration with these following examples:

#^^# = #^#

#^^## = #^#^#

#^^### = #^#^#^#

...

and in general...

#^^#k = #^#^ ... ^# w/k+1 #s

                    Tiaokhiao then assigns #^^#^# to the same purpose as #^^# in my own LECEN. Notice also the offset of +1. This means a tethrathoth would be equivalent to E100#^^#^#99 not E100#^^#^#100. Furthermore this is an awefully wasteful choice, since #^^#,#^^##,#^^### etc. are not serving as new delimiters but merely as synonyms for existing delimiters. Next he assigns further examples in terms of Bowers' X-Structures ONLY:

#^^(#^#*#) --> X^^(X+1)

#^^(#^#*##) --> X^^(X+2)

#^^(#^#*###) --> X^^(X+3)

#^^(#^#*#^#) --> X^^2X

#^^(#^#*#^#*#^#) --> X^^3X

#^^(#^##) --> X^^(X^2)

#^^(#^###) --> X^^(X^3)

#^^(#^#^#) --> X^^(X^X)

#^^(#^#^#^#) --> X^^(X^X^X)

#^^#^^#^# --> X^^X^^X

#^^#^^#^^#^# --> X^^X^^X^^X

                    The problem with this is that Bowers' system itself is not fully understood, so defining another function in terms of it doesn't help us build a well defined function! It does however at least give us the gist of the strength of such a system, since these follow Bowers' suggestions for X-Structures as mentioned on his hypernomial's page, and we can generally match these up with the epsilon numbers.

                    Again Tiaokhiao has the same fundamental problem here. He hasn't actually defined the decompositions, only the hierarchy of separators. For example, what does #^^(#^#*#) decompose into? How precisely does this relate back to #^^#^#, and what are the separators between them?! Tiaokhiao continues along with Bowers' X-Structures without discussing anything of the details.

                    Tiaokhiao does however provide a definition for his notation as a whole:

E(a)b = a^b
# 1 = #
# n#m = # (# n#m-1)
# #1m = # #m
# n #m = # n #l-1 n...n #l-1 n (m n's)
# n #^# m = # n #...# m (n #'s)
# n #^^@ m = n #^#...#^# (@ #^#'s)
# n #^...^@ m = # n #^...(#^...^@-1) m

                Here he establishes 8 rules for working with Nested Cascading-E expressions. The rules are somewhat confusing to read due to his use of "#" as both a separator and to stand in for "rest of expression". The first 5 rules merely re-establish xE#. Rule 6 only explains the expansion of the "#^#" separator, and also gets the definition wrong. Rule 7 only establishes the rule for hyperion tetration for integer powers of the hyperion and is ill-defined if "@" is something other than an integer power. Rule 8 attempts to define the general hyper-operations on hyperions, but again has the same draw back. Again we find that Tiaokhiao's definitions are incomplete. He doesn't appear to understand the difference between ordinary hyper-operators and hyper-operators acting on ordinals. The details for ordinals are much more complex.

                There are also a number of minor problems. For example Rule 7 lacks an ending argument and note that "m" plays no role in the transformation.

                But even assuming it was complete and well defined, it still would not be the best choice because he is unnecessarily weakening the system. For example, he wastes the possible separators #^^#, #^^##, #^^###,#^^####, ... giving them meanings already covered by other delimiters within Cascading-E, where as I hadn't even defined #^^## at the end of LECEN. Furthermore, he only manages to reach the limit ordinal φ(ω,0) (he mentions this on site and I've verified it independently). However, I'll show how xE^ can be given a boost which I believe increases it's limit ordinal to φ(ω,0,0).

        A far better system is described by Ikosarakt1. It's better defined than Tiaokhiao's suggested extension. He begins with the following definition:

#^^## = ((...((#^^#)^^#)...)^^#

                  Although he doesn't provide a rationale for choosing this definition he notes that this allows for a natural continuation. We can define:

(#^^##)^# = #^^##*#^^##* ... *#^^##

(#^^##)^^# = (#^^##)^(#^^##)^ ... ^(#^^##)

(#^^##)^^## = ((...((#^^##)^^#)^^#)...)^^#

...

#^^### = ((...((#^^##)^^##)...)^^##

#^^#### = ((..((#^^###)^^###)...)^^###

...

#^^#^# = #^^###...###

#^^#^## = #^^(#^#*#^#* ... *#^#)

...

#^^#^^# = #^^#^#^#^...^#^#

#^^^# = #^^#^^#^^ ... ^^#^^#

#^^^## = ((...((#^^^#)^^^#)...)^^^#

#^^^### = ((...((#^^^##)^^^##)...)^^^##

...

#^^^^# = #^^^#^^^#^^^ ... ^^^#

etc.

                    The sequence is easy to follow and well-defined. Paradoxically, despite the more efficient use of delimiters, the notation ends up having no more than limit ordinal φ(ω,0), just like the hypothetical strength of a well-defined Tiaokhiao system. The reason for this is that the improvement only seems large for relatively small ordinals. For example in Tiaokhiao's notation #^^#^# is equivalent to ε1 while in Ikosarakt1's it's equivalent to ε(ω^ω). This difference vanishes however as we approach the delimiter #^^^#. At this point Tiaokhiao's delimiters "catch up" to Ikosarakt1's for the first time.

                    Ikosarakt1 goes on to define an extension very similar to Tiaokhiao's extension. Here he opts to use curly braces to avoid confusion with parentheses. He establishes the following:

#{#}# = #^#

#{##}# = #^^#

#{###}# = #^^^#

#{####}# = #^^^^#

etc.

                    He then allows for arbitrary nesting:

#{#^#}#

#{#{##}#}#

#{#{#{#}#}#}#

#{#{#{#{#}#}#}#}#

etc.

                    Again this would have the same strength as Tiaokhiao's extension. Specifically the limit ordinal here is Γ0 or φ(1,0,0). Later I'll show how this can be boosted all the way up to φ(1,0,0,0).

                    Lastly and perhaps most interestingly is FB100Z's attempt to extend Cascading-E through ordinals. It is certainly the most unique of the three attempts. 

                    The idea begins by converting all expressions of Hyper-E into an ordinal. He does this by applying the "Bower's paradigm" to my Extensible-E system. That is, he imagines an Extensible-E expression as something describing a "space of entries". Default entries are held to have a value of 1. As he notes later, Extensible-E doesn't really work this way and leads to problems because E100#1##2 is not the same as E100##2, for example. None the less we can begin by applying this rule to obtain ordinals for any expression in Hyper-E

E1 --> 0

E2 --> 1

E3 --> 2

E1#2 --> ω

E2#2 --> ω+1

E3#2 --> ω+2

...

E1#3 --> ω*2

...

E1#4 --> ω*3

...

E1#1#2 --> ω2

E1#1#1#2 --> ω3

E1##2 --> ωω

E1#2##2 --> ωω+ω

etc.

                    In this way every expression of Cascading-E can be represented by an ordinal. Next he defines the function which takes the ordinal and returns the value of the Expression it represents. For this he uses:

S(α)

                    where α is an ordinal. He splits the function up into 4 rules:


1. Base case: If α < ω , S(α) = 10^α+1

2. Default case: If δ=1 (ie. L(α)=P(α)+1)




3. Hyper-band expansion: If δ is of the form ωη x ω


4. Hyper-product expansion: Otherwise:



                    
                He defines his rules using seemingly very technical notation. Here L(a) refers to the last non-zero entry and P(a) refers to the 2nd to last non-zero entry. The rules are meant to overlap perfectly with the rules of Cascading-E with the advantage that they are hypothetically extendable to all ordinals. However, as FB100Z admits, these rules don't perfectly match Cascading-E. 

                It's trivial to see that the first rule matches my base case rule, since E(n+1) --> 10^(n+1) and S(n) = 10^(n+1). The second rule applies typically in cases where the last two arguments are separated by a single hyperion. For example:


E100#100#2

In this case we have the following application of rule 2:

S(ω2+99ω+99) = S(0ω2+S(0ω2+99ω+99)ω+99) = S(S(99ω+99)ω+99)

                    So Rule 2 is just an example of what happens when the last separator is a hyperion. While these rules will work there is one important caveat: FB100Z's definition relies on the fundamental sequences defined for the Fast Growing Hierarchy when he makes a call to δ[p]. What this means is that we would still have to define those fundamental sequences, so that this rule set, in and of itself, is not enough to define Extensible-E to all recursive ordinals. This is similar to the way that the Fast Growing Hierarchy only has "3 rules", but can only work for as long as fundamental sequences are defined. As I understand it, the task of the googologist IS to define those fundamental sequences. This turns a theoretical FGH into a concrete system which can define exact values (a task perhaps comparable to grunt work in the minds of professional mathematicians). While FB100Z's system provides an interesting connection between the notation and ordinals, it still doesn't technically define anything beyond what's already been defined (in either my Cascading-E or in the professional literature for FGH). 

                    Beyond FB100Z's ordinal framework he also attempts to extend the native notation of Extensible-E.  Here FB100Z defines a rather weak interpretation of post Cascading-E delimiters. For example he establishes that:

#^^α*# = (#^^α)^(#^^α)^ ... ^(#^^α)

#^^α = #^^α[p]

By this interpretation we have:

#^^## = (#^^#)^^# ε1

#^^### = ((#^^#)^^#)^^# ε2

...

#^^#^# = ((...((#^^#)^^#)...)^^# = ε(ω)

#^^^# = φ(2,0)

#^^^^# = φ(3,0)

etc.

                    Once again, with this system Extended Cascading-E Notation would reduce only to limit ordinal φ(ω,0). FB100Z also continues this notation using the Bowers' bracket notation, as I myself suggested in the previous article:

<#,#,2> = #^^#

<#,#,3> = #^^^#

<#,#,4> = #^^^^#

...

<#,#,#>

<#,#,<#,#,#>>

<#,#,<#,#,<#,#,#>>>

...

FB100Z also comes to the conclusion that the ordinal of <#,#,1,2> is Γ0. He goes on to speculate all the way to the limit of applying arrays to hyperions. In theory this would terminate at the ordinal ' L ' which is the limit of sub-legion array notation. It is however not even known what the exact size of L is. In any case these only suggest a continuation, they do not provide a concise definition for all fundamental sequences.

Recently Lawrence Hollom wrote an article on an Extended Cascading-E Notation. He suggests using Extensible-E's own operators to continue rather than opt for using up-arrows. To avoid the issue with nesting the notation into itself he suggests using square brackets. For example #^^# could be written as E(#)#[#]#. " [#] " is acting as a delimiter between the two arguments which are themselves hyperions. He also seems to have a problem with multiplication being the base operation for hyperions, though there is nothing really fundamentally wrong with this. He opts to reformat all the existing delimiters by replacing multiplication with addition. He notes an interesting connection between the "plus notation" and his separators, namely that:

## --> +

##+# --> ++

##+#+# --> +++

##+#+#+# --> ++++

etc.

                While the suggestion of nesting Extensible-E into itself is an interesting idea Hollom doesn't develop it into a proper system mainly because it would require a reworking of the existing Cascading-E Notation. As we'll see extending using the standard hyper-operators works perfectly well and can also be nested in the way Hollom suggests, and has the upshot of providing some definition for ordinal hyper-operators, an important pre-requisite for formalizing Bowers' X-Structures.

                    While these were some interesting preliminary looks at a possible Extended Cascading-E Notation and beyond, it looks like all the work is still ahead of us. We still need to be able to reduce the complexity of such a system to a small set of well-defined transformations. We also need to come up with a natural definition for extending Hyperions to higher operators. Tiaokhiao, Ikosarakt1, FB100Z, and Hollom each offer a distinct interpretation. We need some way to select the most appropriate definition out of the many possible definitions we could use

                    It might be tempting to jump right in and just define yet another system. However it would be better if we first determine exactly what we're looking for first, and then use that as a selection mechanism for our developing system...

Objectives for Extended Cascading-E Notation

                First and foremost, the idea of Extended Cascading-E Notation is to extend the notation to allow the use of all the primitive recursive hyper-operators on hyperions, and by extension, ordinals. Cascading-E Notation introduced hyperion multiplication and exponentiation. The intention was always to extend this to the full set of P.R. hyper-operators. The beginnings of this were seen in LECEN where a limited definition of hyperion tetration was presented. Our first goal is therefore to define a general hyperion tetration, so that expressions like #^^##, #^^###, #^^#^#, #^^#^^# etc. have meaning. It was always my intention to use up-arrows for the hyper-operators here, so other notations should only be used as synonyms. Alternatives may be described for the sake of simplifying rules, but these should always be able to be converted back into canonical form.

                    The second important objective that I had for Extended Cascading-E from it's inception was that it should define, in as natural a way as possible, what it means to apply the hyper-operators to ordinals. It was also always meant to provide a foundation of a theory of Bowers' X-Structures, or some strong interpretation of them.

                    ...and herein lies perhaps the greatest difficultly: Bowers' X-Structures have never been completely formalized, and applying hyper-operators on the ordinals is undefined. It then becomes important to consider precisely what these X-Structures are anyway.

                    So we have two objectives with xE^:

(1) Extend E^ to include all the hyper-operators

(2) Develop a general theory of X-Structures

                    So before we can delve into the full development of xE^ we must look at hyper-operator ordinals and how they should work. Recently I have come with some breakthroughs which will be instrumental in our development of xE^. Let's look a bit at the theory of hyper-operator ordinals...

A New Theory of Ordinal Hyper-Operations

                    The continuation of ordinals using the hyper-operators was not carried out by Georg Cantor, the inventor of the ordinals. He observed a problem with defining ordinals beyond exponents and introduced his epsilon-numbers as a work around. Since the work of Bowers' however googologist's have tried to puzzle out how tetration, pentation, and beyond, could be defined for ordinals. Bowers' provides an important clue via the climbing method. The idea here is that when we have a power tower of X's we don't simply keep stacking X's immediately. Instead we gradually climb the tower until we can add yet another X on top. Cantor did essentially the same thing to get from epsilon-zero to epsilon-one. This suggests the following comparison:

X^^(X+1) --> ε1

                This has been the popular choice of most googologist's and is advocated by Bowers' himself. This leads to a system in which we find that each hyper-operator corresponds to a different operator of the Veblen Hierarchy. One problem however is a lack of a strong justification. Basically the climbing method has the limit X^^(X+1) simply because it seems like the smallest structure after all the structures involving X, X^^X, along with addition, multiplication and exponentiation. How does this actually work though? According to Bowers' the number of entries for a structure is the result by substituting the prime entry for X. Thus X^^(X+1) --> p^^(p+1). The problem here is simply this: what structures is X^^(X+1) actually composed of, and how do they result in p^^(p+1) entries (this is an issue we'll look into in greater detail in 4.1 in future articles).

                    Rather than get bogged down with the details of Bowers' array notation, which for technical reasons is more difficult to define precisely than the fundamental sequences of the Fast Growing Hierarchy, we can instead set up a system which is guaranteed to grow at least as fast as the comparable arrays (if not faster). We do this by taking only the maximizing interpretation of the climbing method, that is, we'll assume it has the most maximal effect possible.

                    Chris Bird has already done some work in this area. He defines ε(1) as ω^^(ω*2) based on the following interpretation. Since ε(1) = ω^ω^ω^...ω^ω^(ε0+1) and ε0 = ω^ ω^ ω^... ω^ ω it follows that ε(1) =  ω^ω^ω^...ω^ω^(1+ ω^ω^ω^...ω^ω) ~ ω^ω^ω^...ω^ω^(ω^ω^ω^...ω^ω) = ω^^(ω*2). Notice that this is even a worse case than Bowers defining ε(1) = ω^^(ω+1)! Yet these both produce roughly the same system. It leads to the same size for ω^^^ω.


                    Here I will offer an alternative interpretation for ε1 which actually DOES lead to a stronger set of ordinal hyper-operators.
I will begin by making two important observations. First, we may use the following fundamental sequence for epsilon-zero:

ε0[0] = 0

ε0[1] = ω^0

ε0[2] = ω^ω^0

ε0[3] = ω^ω^ω^0

...

ε0[n] = ω^ω^ ... ^ω^ω^0 w/n ω's = E[ω]0#n

                    This leads to the following interpretation of ε0:

ω^ω^ ... ^ω^ω^0 w/ω ω's = E[ω]0#ω

In other words ε0 can be envisioned as a power tower of omega omega's topped off with a zero. We now consider the climbing method via the fundamental sequence for ε1:

ε1[0] = ε0+1

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

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

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

...

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

So we can imagine the "climb" to epsilon-one as being the ascent of a single +1. Note that since epsilon-zero is of infinite height, as long as the +1 has climbing up a finite number of terms there is still an infinite number of terms left to go. Hence in all of these instances the last term is still ε0+1. What happens however if we "reach" epsilon-one? What happens to the +1? We can imagine it as appearing somewhere on the "other end" of the infinite (an apocryphal notion, but bare with me). Note that, where precisely it shows up can be chosen freely. For example we might have:

...

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

εω^ω^ ... ^ω^(1+ω^ω^ω^0) = ω^ω^ ... ^(ω*ω^ω^ω^ω^0)

εω^ω^ ... ^ω^ω^(1+ω^ω^0) = ω^ω^ ... ^ω^(ω*ω^ω^ω^0) = ω^ω^ ... ^(ω^ω^ω^ω^0)^ω

εω^ω^ ... ^ω^ω^ω^(1+ω^0) = ω^ω^ ... ^ω^ω^(ω*ω^ω^0) = ω^ω^ ... ^ω^(ω^ω^ω^0)^ω

εω^ω^ ... ^ω^ω^ω^ω^(1+0) = ω^ω^ ... ^ω^ω^ω^(ω*ω^0) = ω^ω^ ... ^ω^ω^(ω^ω^0)^ω

So we see that the +1 can travel at most up to the leading exponent (traveling higher leads to some technical ambiguities). Here we have that:

εω^ω^ ... ^ω^ω^ω^ω^(0+1) = ω^ω^ ... ^ω^ω^ω^ω^1 = E[ω]1#ω

So we seem to have here a natural interpretation for the climbing method and the epsilon numbers. We can imagine that every time the climbing method is applied to reach the next epsilon-number, a +1 travels up to the top and increases the leading exponent by 1. This leads to the definition:

ε(α) = E[ω]α#ω

At this point we can show that this is the maximum interpretation of the climbing method. Why? Because it makes no difference how high or low the +1 travels as long as it's a finite distance from the top. We can see this occurrence as α itself approaches ε0:

           ε(ε0) = ω^ω^ ... ^(ω^ω^ω^ω^0+ε0) = ω^ω^ ... ^(ε0) = ω^ω^ ... ^(ω^ω^ω^ω^ε0) =

ω^ω^ ... ^ω^ω^ω^ω^(ε0) = E[ω]ε0#ω = E[ω](E[ω]0#ω)#ω = E[ω]0#2ω

                    Although presented a little informally here, the conclusions are still valid. ω^ω^ω^ω^0 would become absorbed into ε0 since the limit of ω^ω^ω^ω^0+0 , ω^ω^ω^ω^0+ω^0ω^ω^ω^ω^0+ω^ω^0ω^ω^ω^ω^0+ω^ω^ω^0 , ω^ω^ω^ω^0+ω^ω^ω^ω^0ω^ω^ω^ω^0+ω^ω^ω^ω^ω^0, etc. is still just ε0. Since ε0 ω^ε0 ω^ω^ε0 = etc. we see that we lose absolutely no height in the power tower. It is reasonable then, regardless of where the +1s are accumulating to conclude the ε(ε0) is the equivalent of ω^^(ω*2). Note that ω^^(ω*2) now represents a much larger ordinal than it did for Chris Bird. Thus we see that the height doesn't matter and we have already achieve the maximum interpretation. Note how much smaller is this than the standard interpretation. By the standard interpretation where ε1ω^^(ω+1) we have ε(ε0) = ω^^ε0 ω^^ω^^ω = ω^^^3. We can cut to the chase and reach the first fixed point of the epsilon-function. By the standard interpretation the first fixed point of the epsilon-function would correspond to ω^^^ω. By the maximum interpretation however this would only amount to ω^^ω2. This might not seem enough to make a big difference in the long run, but as I'll show, we can set up things so that each operator takes much much longer to grow than the previous one leading to a significant boost in power.

                    You may be surprised that the Cantor ordinal only amounts to ω^^ω2 in this system. I'll explain the idea here. The key is to treat ω not as if it were an infinite number, but rather to act as if it's some very large unknown quantity. One can then think of ordinal tetration in a natural way so that ω^^ω, ω^^(ω+1), ω^^(ω+2), etc. have some meaning. By default each of these towers has a lead exponent of 0, and the climbing method always ascends a single +1 up along ω ω's. We can see that by these definitions it follows that:

If ε(α)-->E(ω)α#β then it follows that ε(α+1)-->E(ω)(α+1)#β.

                    This get's us as far as ...

ε(0)--> E(ω) 0#ω --> ω^^ω

ε(1)--> E(ω) 1#ω

ε(2)--> E(ω) 2#ω

ε(3)--> E(ω) 3#ω


etc.

                    The limit of this sequence is of coarse ε(ω). In a likewise manner I can define the limit of my ordinals as E(ω) ω#ω. This would also be E(ω) 1#(ω+1) also known as ω^^(ω+1). From here we can establish the following rule:

If ε(α [n])--> E(ω) α [n]#β for all n then ε(α)--> E(ω) α#β

                        This allows us to go much further ... at least up to the first fixed point of the epsilon function. To facilitate this climb I'd like to introduce a more convenient notation for this purpose. It's based on Bowers' own structural notation.  Here we will use the braces, { }, as Bowers' does, not to represent ordinary parenthesization, but rather as a way of "grouping" terms in an extended power tower of ω's. So we let {ω^^ω}^{α} represent E(ω) α#ω. With this in mind the following should be relatively clear...

{ω^^ω}^{0} -->  ε(0)

{ω^^ω}^{1} -->  ε(1)

{ω^^ω}^{2} -->  ε(2)

...

{ω^^ω}^{ω} -->  ε(ω)

{ω^^ω}^{ω+1} -->  ε(ω+1)

{ω^^ω}^{ω+2} -->  ε(ω+2)

...

{ω^^ω}^{ω*2} -->  ε(ω*2)

...

{ω^^ω}^{ω2} -->  ε(ω2)

...

{ω^^ω}^{ωω} -->  ε(ωω)

...

{ω^^ω}^{ω^^ω} -->  ε(ε(0))

                        Note here that {ω^^ω}^{ω^^ω} is just a mere ω^^*2). Going further we can say that...

{ω^^ω}^{ω^^ω}^{ω^^ω} -->  ε(ε(ε(0)))

{ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω} -->  ε(ε(ε(ε(0))))

...

                    The limit for the epsilons is ε(0,1), usually denoted by φ(2,0) using Oswald Veblen's fixed-point notation. The limit for the hyper-operator ordinals shown on the left can be defined based on the observation that {ω^^α}^{ω^^β} -->  ω^^+β). Thus we have...

{ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω}^... -->

{ω^^+ω)}^{ω^^ω}^{ω^^ω}^... -->

{ω^^+ω+ω)}^{ω^^ω}^... -->

{ω^^+ω+ω+ω)}^... -->

...

--> ω^^+ω+ω+ω+...) --> ω^^*ω) --> ω^^ω2
So we have:


ω^^ω2 --> φ(2,0)

                    For our purposes, we can used an extended epsilon-function which allows for an arbitrary number of arguments. This function is identical to the Veblen function except in the case of the binary Veblen function in which the 2nd argument is an integer. Here we have:

ε(α) = φ(1,α) : when the epsilon-function takes a single argument

ε(α,n) = φ(n+1,α) : when n is a non-negative integer, and ε takes two arguments
   
otherwise...

ε(α0,α1,α2,...,αn) = φ(αn,...,α2,α1,α0)

We'll primarily be using the epsilon notation from here on out, but remember that it's virtually identical to the Veblen functions, just with the arguments reversed. 

                    So we now have:

E[ω]α#ω --> ε(α)

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

                    To make the hyper-operator ordinals easier to notate we'll adopt the following extended conventions. Let {α} represent a "tower group". When we write {α}^β it will be interpreted as β stacked on top of α expressed as a power tower. That is:

if α = ω^^X

then {α}^β = E[ω]β#X
                  
                    Furthermore we can interpret the rest of the hyper-operators in a similar fashion:

if α = ω^^^X

then {α}^^β = E[ω]0#β#X

if α = ω^^^^X

then {α}^^^β = E[ω]0#0#β#X

and in general...

if α = ω<k>X

then {α}<k-1>β = E[ω]0#0#...#0#β#X w/k-2 0s

                    With these definitions we can get the following hierarchy of ordinals quite naturally:

^^ω}^{0} --> ε0

{ω^^ω}^{1} --> ε1

{ω^^ω}^{2} --> ε2

{ω^^ω}^{3} --> ε3

...

{ω^^ω}^{ω} --> εω

{ω^^ω}^{ω+1} --> ε(ω+1)

{ω^^ω}^{ω+2} --> ε(ω+2)

{ω^^ω}^{ω+3} --> ε(ω+3)

...

{ω^^ω}^{2ω} --> ε(ω*2)

{ω^^ω}^{2ω+1} --> ε(ω*2+1)

...

{ω^^ω}^{3ω} --> ε(ω*3)

{ω^^ω}^{4ω} --> ε(ω*4)

...

{ω^^ω}^{ω2} --> ε(ω2)

{ω^^ω}^{ω3} --> ε(ω3)

...

{ω^^ω}^{ωω} --> ε(ωω)

{ω^^ω}^{ω^ω^ω} --> ε(ω^ω^ω)

...

{ω^^ω}^{ω^^ω}^{0} --> ε(ε0)

{ω^^ω}^{{ω^^ω}^{0}+1} --> ε(ε0+1)

...

{ω^^ω}^{ω^^ω}^{1} --> ε(ε1)

...

{ω^^ω}^{ω^^ω}^{ω} --> ε(εω)

...

{ω^^ω}^{ω^^ω}^{ω^^ω}^{0} --> ε(ε(ε0))

{ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω}^{0} --> ε(ε(ε(ε0)))

...

ω^^ω2 --> ε(0,1)

{ω^^ω}^{ω^^ω2+1} --> ε(ε(0,1)+1)

{ω^^ω}^{ω^^ω}^{ω^^ω2+1} --> ε(ε(ε(0,1)+1))

{ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω2+1} --> ε(ε(ε(ε(0,1)+1)))

...

{ω^^ω2}^{1} --> ε(1,1)

{ω^^ω}^{{ω^^ω2}^{1}+1} --> ε(ε(1,1)+1)

{ω^^ω}^{ω^^ω}^{{ω^^ω2}^{1}+1} --> ε(ε(ε(1,1)+1))

{ω^^ω}^{ω^^ω}^{ω^^ω}^{{ω^^ω2}^{1}+1} --> ε(ε(ε(ε(1,1)+1)))

...

{ω^^ω2}^{2} --> ε(2,1)

{ω^^ω2}^{3} --> ε(3,1)

...

{ω^^ω2}^{ω} --> ε(ω,1)

...

{ω^^ω2}^{α} --> ε(α,1)

...

{ω^^ω2}^{ω^^ω} --> ε(ε0,1)


{ω^^ω2}^{ω^^ω2} --> ε(ε(0,1),1)

{ω^^ω2}^{ω^^ω2}^{ω^^ω2} --> ε(ε(ε(0,1),1),1)

...

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

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

ω^^ω5 --> ε(0,4)

...

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

                    We've only reached ω^^ω^ω and already we're up to the ordinal φ(ω,0), which was all the hyper-operator structures in the other systems! Yet we haven't even reached pentational ordinals yet! Next we have...

ω^^ωα --> ε(0,α) : α>=ω

...

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

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

...

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

...

ω^^εα --> ε(0,εα)

...

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

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

...

ω^^^ω --> ε(0,0,1) = φ(1,0,0) =  Γ0 (Gamma-naught)

                    Not bad! We've reached gamma-naught at pentational ordinals! We can continue further...

{ω^^ω}^{ω^^^ω+1} --> ε(Γ0+1)

{ω^^ω2}^{ω^^^ω+1} --> ε(Γ0+1,1)

{ω^^ω3}^{ω^^^ω+1} --> ε(Γ0+1,2)

...

{ω^^ω^ω}^{ω^^^ω+1} --> ε(Γ0+1,ω)

{ω^^ω^^ω}^{ω^^^ω+1} --> ε(Γ0+1,ε0)

{ω^^ω^^ω^^ω}^{ω^^^ω+1} --> ε(Γ0+1,ε(0,ε0))

{ω^^ω^^ω^^ω^^ω}^{ω^^^ω+1} --> ε(Γ0+1,ε(0,ε(0,ε0)))
...

{ω^^^ω}^{1} --> ε(1,Γ0)

                    The interpretation of this may require some explanation. When the second argument of the binary epsilon-function is a limit ordinal, the next fixed point is found via the fundamental sequence:

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

Next we have that Γ0 = ε(0,0,1) and is also ε(0,Γ0) since it's the (gamma-zero)th binary epsilon-function. Combining this with the first statement we obtain:

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

Thus we obtain that {ω^^^ω}^{1} --> ε(1,Γ0). Note that we haven't even yet reached the next fixed point of the gamma-function. Moving on we have...

{ω^^ω}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1)

{ω^^ω2}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1,1)

{ω^^ω3}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1,2)

...

{ω^^ω^ω}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1,ω)

{ω^^ω^^ω}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1,ε0)

{ω^^ω^^ω^^ω}^{{ω^^^ω}^{1}+1} --> ε(ε(1,Γ0)+1,ε(0,ε0))

...

{ω^^^ω}^{2} -->  ε(2,Γ0)

{ω^^^ω}^{3} -->  ε(3,Γ0)

...

{ω^^^ω}^{α} -->  ε(α,Γ0)

...

{ω^^^ω}^{ω} -->  ε(ω,Γ0)

{ω^^^ω}^{ω^^ω} -->  ε(ε0,Γ0)

{ω^^^ω}^{ω^^^ω} -->  ε(Γ0,Γ0)

{ω^^^ω}^{ω^^^ω}^{ω^^^ω} -->  ε(ε(Γ0,Γ0),Γ0)

{ω^^^ω}^{ω^^^ω}^{ω^^^ω}^{ω^^^ω} -->  ε(ε(ε(Γ0,Γ0),Γ0),Γ0)

...

                    What happens next is that we now have a power tower which contains (ω^^^ω)*ω ω's. This is notated:

ω^^(ω^^^ω*ω) --> ε(0,Γ0+1)

            YIKES! Despite all that work we've just barely begun with post pentational ordinals! It will be a while yet until we reach ω^^^(ω+1), or even {ω^^^ω}^^{1} for that matter. Next we have:

{ω^^ω}^{ω^^(ω^^^ω*ω)+1} --> ε(ε(0,Γ0+1)+1)

...

{ω^^^ω}^{ω^^(ω^^^ω*ω)+1} --> ε(ε(0,Γ0+1)+1,Γ0)

{ω^^^ω}^{ω^^^ω}^{ω^^(ω^^^ω*ω)+1} --> ε(ε(ε(0,Γ0+1)+1,Γ0),Γ0)

...

{ω^^(ω^^^ω*ω)}^{1} --> ε(1,Γ0+1)

{ω^^(ω^^^ω*ω)}^{2} --> ε(2,Γ0+1)

...

{ω^^(ω^^^ω*ω)}^{ω} --> ε(ω,Γ0+1)

{ω^^(ω^^^ω*ω)}^{ω^^ω} --> ε(ε0,Γ0+1)

{ω^^(ω^^^ω*ω)}^{ω^^(ω^^^ω*ω)} --> ε(ε(0,Γ0+1),Γ0+1)

{ω^^(ω^^^ω*ω)}^{ω^^(ω^^^ω*ω)}^{ω^^(ω^^^ω*ω)} --> ε(ε(ε(0,Γ0+1),Γ0+1),Γ0+1)

...

ω^^(ω^^^ω*ω2) --> ε(0,Γ0+2)

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

...

ω^^(ω^^^ω*ωω) --> ε(0,Γ0+ω)


ω^^(ω^^^ω*ω^^^ω) --> ε(0,Γ0+Γ0)

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

...


ω^^(ω^^^ω)ω --> ε(0,Γ0*ω)

...

ω^^(ω^^^ω)(ω^^^ω) --> ε(0,Γ0*Γ0)

ω^^(ω^^^ω)(ω^^^ω)*(ω^^^ω) --> ε(0,Γ0*Γ0*Γ0)

...

ω^^(ω^^^ω)^(ω^^^ω)^ω --> ε(0,Γ0^ω)


ω^^(ω^^^ω)^(ω^^^ω)^(ω^^^ω)^ω --> ε(0,Γ0^Γ0^ω)

ω^^(ω^^^ω)^(ω^^^ω)^(ω^^^ω)^(ω^^^ω)^ω --> ε(0,Γ0^Γ0^Γ0^ω)

...

ω^^{ω^^ω}^{ω^^^ω+1} --> ε(0,ε(Γ0+1))

...

ω^^ω^^{ω^^ω}^{ω^^^ω+1} --> ε(0,ε(0,ε(Γ0+1)))

ω^^ω^^ω^^{ω^^ω}^{ω^^^ω+1} --> ε(0,ε(0,ε(0,ε(Γ0+1))))

...

{ω^^^ω}^^{1} --> ε(1,0,1)

{ω^^^ω}^^{2} --> ε(2,0,1)

...

{ω^^^ω}^^{ω} --> ε(ω,0,1)


{ω^^^ω}^^{ω^^ω} --> ε(ε(0),0,1)

{ω^^^ω}^^{ω^^^ω} --> ε(Γ0,0,1)

{ω^^^ω}^^{ω^^^ω}^^{ω^^^ω} --> ε(ε(Γ0,0,1),0,1)

{ω^^^ω}^^{ω^^^ω}^^{ω^^^ω}^^{ω^^^ω} --> ε(ε(ε(Γ0,0,1),0,1),0,1)

...

ω^^^ω2 --> ε(0,1,1)

            Feel free to scream ...

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

...

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

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

ω^^^ω^^^ω --> ε(0,Γ0,1)

ω^^^ω^^^ω^^^ω --> ε(0,ε(0,Γ0,1),1)

ω^^^ω^^^ω^^^ω^^^ω --> ε(0,ε(0,ε(0,Γ0,1),1),1)

...

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

                    Thus we reach hexational ordinals. These ordinals can be extended further and we get these various levels of comparison:

Let ω^^^^ω be a synonym for the ordinal ε(0,0,2). We have that:

{ω^^ω}^{ω^^^^ω+1} --> ε(ω^^^^ω+1)

{ω^^^ω}^{ω^^^^ω+1} --> ε(ω^^^^ω+1,Γ0)

{ω^^^^ω}^{α} --> ε(α,ω^^^^ω)

ω^^(ω^^^^ω*ω^α) --> ε(0,ω^^^^ω+α)

{ω^^^^ω}^^{α} --> ε(ω^^^^ω+α,0,1)

ω^^^(ω^^^^ω*ω^α) --> ε(0,ω^^^^ω+α,1)

{ω^^^^ω}^^^{α} --> ε(α,0,2)

ω^^^^ωα --> ε(0,α,2)

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

ω^^^^^^ω --> ε(0,0,4)

...

etc.

                    The limit of this system of ordinal notation is ε(0,0,ω) or ϕ(ω,0,0). This is the ordinal we are going to reach in Extended Cascading-E Notation using our new ordinal hyper-operators as a guide... 

Extending Cascading-E

                    Now that we have the theory in place we can finally continue Cascading-E Notation into the higher hyper-operators. Recall that we began first by defining:

@a#^^#b = @a#^#^#^...^#a w/b #s

                    Furthermore we allowed all the previous rules for hyperion multiplication and exponentiation to apply so that delimiters (separators) such as #^^#*# , #^^#*## , #^^#*#^#, #^^#*#^^# , (#^^#)^# , (#^^#)^##, (#^^#)^(#^^#), etc. inherently have meaning. The limit of these delimiters is:

{#^^#, (#^^#)^(#^^#) , (#^^#)^(#^^#)^(#^^#) , ...}

                    In LECEN I chose to use (#^^#)^^# as the limit ordinal of this sequence, since A^^B = A^A^A^..^A w/B As. Here we have implicitly introduced a new rule. If & is a delimiter than &^^# is a delimiter as well with the decomposition &^&^&^ ... ^&^&. This leads to the delimiters (#^^#)^^#, ((#^^#)^^#)^^#, (((#^^#)^^#)^^#)^^#, etc. This marked the limit of LECEN.

                    We can now finally overcome this barrier however. Note that every time we apply the "^^#" operator we are simply applying the climbing method. Therefore each application of ^^# is equivalent to increasing the epsilon number by 1. Thus we have the following conversion to hyper-operator ordinals:

#^^# -->  {ω^^ω}^{0}

(#^^#)^^# --> {ω^^ω}^{1}

((#^^#)^^#)^^# --> {ω^^ω}^{2}

(((#^^#)^^#)^^#)^^# --> {ω^^ω}^{3}

((((#^^#)^^#)^^#)^^#)^^# --> {ω^^ω}^{4}

...

The limit ordinal for LECEN is therefore {ω^^ω}^{ω}, or ε(ω). At this point I'll introduce a new element to the system. The " > " symbol will be used to denote when something is being "stacked" on top of a previous hyperion tower. It also implies that some previous operation is being iterated a specified number of times. If we have &*>α where & is an epsilon-number in hyperion form, * is some operator and α is some ordinal in hyperion form, then this notation means operator * applied to & α times. In otherwords...

&*>n = (( .. (((&*)*)*) ...*)*)* w/n *s

&*>
α represents an ordinal number of applications. In actuality this isn't itself a number, but rather it describes a sequence of recursions in which the * operator is used as the fundamental unit of the recursion!

 For the purposes of Extended Cascading-E Notation the " > " symbol will be known as the caret top. It's function, and the power it confers to the notation, we'll become more clear as we progress. In any case we define the following new delimiter:

@a#^^#>#b = @a((..((#^^#)^^#)..)^^#)^^#a w/b ^^#s

                    This already makes the biggest numbers in LECEN easy to express. We have:

tethrathoth ba'al = E100#^^#>#100

Great and Terrible tethrathoth = E100#^^#>#100#2

                It is at this point that we make an important shift in perspective that will enable us to extend much much further than this. We reinterpret hyperions as just another notation for ordinals. Specifically we can interpret the hyperion, # , as a synonym for ω. We have the following relation:

# -->  ω

## --> ω2

### --> ω3

...

#^# --> ωω

#^#*# --> ωω+1

...

#^#*#^# --> ωω*2

...

 #^## --> ω^ω^2

#^### --> ω^ω^3

...

#^#^# --> ω^ω^ω

...

#^^# --> ω^^ω

etc.

The importance of this is we can now treat the expression after the caret top as a transfinite ordinal counter. Think of ^^#># as acting as a whole unit. Here we have that ^^#>α can be interpreted as meaning α applications of the ^^# operator. So #^^#># means we have applied the ^^# operator "#" or "ω" times. To continue even further we can apply ^^# even more times to our new #^^#># delimiter (remember that ^^# can be applied to any epsilon-numbered delimiter). So continuing we have:

(#^^#>#)^^# --> {ω^^ω}^{ω+1}

((#^^#>#)^^#)^^# --> {ω^^ω}^{ω+2}

(((#^^#>#)^^#)^^#)^^# --> {ω^^ω}^{ω+3}

...

                    After all of these will be #^^#>(#+#). Note the use of addition here. The idea here is that #+# represents the ordinal ω*2 and we have now applied the ^^# operator ω*2 or #+# times. When we want to expand such an expression we simply remove the last hyperion being added and create a series of "n" ^^# operators, where "n" is the value of the last argument:

@m#^^#>(#+#)n = @m((..((#^^#>#)^^#)^^# ...)^^#)^^#m w/n ^^#s applied to #^^#>#

                    At this point the following continuation should be readily apparent:

#^^#>(#+#) --> {ω^^ω}^{ω*2}

(#^^#>(#+#))^^# --> {ω^^ω}^{ω*2+1}

((#^^#>(#+#))^^#)^^# --> {ω^^ω}^{ω*2+2}

...

#^^#>(#+#+#) --> {ω^^ω}^{ω*3}

#^^#>(#+#+#+#) --> {ω^^ω}^{ω*4}

#^^#>(#+#+#+#+#) --> {ω^^ω}^{ω*5}

...

Predictably we can have limit #^^#>## for this last sequence since ## = #*# = #+#+#+..+#. Based on that the following should be clear:

#^^#>## --> {ω^^ω}^{ω2}

#^^#>(##+#) --> {ω^^ω}^{ω2+ω}

(#^^#>(##+#))^^# --> {ω^^ω}^{ω2+ω+1}

...

#^^#>(##+##) --> {ω^^ω}^{ω2*2}

#^^#>(##+##+##) --> {ω^^ω}^{ω2*3}

...

#^^#>### --> {ω^^ω}^{ω3}

#^^#>#### --> {ω^^ω}^{ω4}

...

#^^#>#^# --> {ω^^ω}^{ωω}

...

#^^#>$(#) --> {ω^^ω}^{$(ω)}

...

#^^#>#^^# --> {ω^^ω}^{ω^^ω}

#^^#>(#^^#)^^# --> {ω^^ω}^{ω^^ω}^{1}

#^^#>((#^^#)^^#)^^# --> {ω^^ω}^{ω^^ω}^{2}

...

#^^#>#^^#># --> {ω^^ω}^{ω^^ω}^{ω}

...

#^^#>#^^#>#^^# --> {ω^^ω}^{ω^^ω}^{ω^^ω}

#^^#>#^^#>#^^#>#^^# --> {ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω}

...

(note that caret tops are to be resolved from right to left)

at this point we introduce a new rule to the system. We know that the limit for the hyper-operator ordinals here is ω^^ω2 from our previous work with them. This suggests the use of #^^##. Finally we've reached this delimiter, but we've delayed it as long as possible while staying within the logic of hyper-operator ordinals. We can interpret the caret top as adding the values of the operators to obtain this result. For example:

#^^#>#^^# = #^^(#+#)

#^^#>#^^#>#^^# = #^^(#+#+#)

etc.

In general we have:

&{k}α>&{k}β = &{k}(α+β)

                    Thus we have the following decomposition:

@a#^^##b = @a#^^(#+#+...+#)a w/b #'s inside the parentheses 

@a#^^#>#^^#> ... >#^^#a w/b #^^#s

                        With this established we continue in the following manner:

#^^## --> ω^^ω2

(#^^##)^^# --> {ω^^ω}^{ω^^ω2+1}

((#^^##)^^#)^^# --> {ω^^ω}^{ω^^ω2+2}

(((#^^##)^^#)^^#)^^# --> {ω^^ω}^{ω^^ω2+3}

...

(#^^##)^^#># --> {ω^^ω}^{ω^^ω2+ω}

(#^^##)^^#>(#+#) --> {ω^^ω}^{ω^^ω2+ω*2}

...

(#^^##)^^#>## --> {ω^^ω}^{ω^^ω2+ω2}

(#^^##)^^#>### --> {ω^^ω}^{ω^^ω2+ω3}

...

(#^^##)^^#>#^# --> {ω^^ω}^{ω^^ω2+ωω}

...

(#^^##)^^#>#^^# --> {ω^^ω}^{ω^^ω2+ω^^ω}

...

(#^^##)^^#>#^^## --> {ω^^ω}^{ω^^ω2+ω^^ω2}

(#^^##)^^#>(#^^##*#) --> {ω^^ω}^{ω*ω^^ω2}

(#^^##)^^#>(#^^##)^^# --> {ω^^ω}^{ω^^ω}^{ω^^ω2+1}

(#^^##)^^#>(#^^##)^^#>(#^^##)^^# --> {ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^ω2+1}

...

Here we apply our previously established caret top rule...

(#^^##)^^## --> {ω^^ω2}^{1}

((#^^##)^^##)^^## --> {ω^^ω2}^{2}

(((#^^##)^^##)^^##)^^## --> {ω^^ω2}^{3}

...

we now reach # (ω) applications of the ^^## operator. We truncate this using the caret top:

#^^##># --> {ω^^ω2}^{ω}

#^^##>(#+#) --> {ω^^ω2}^{ω*2}

#^^##>(#+#+#) --> {ω^^ω2}^{ω*3}

...

#^^##>## --> {ω^^ω2}^{ω2}

#^^##>### --> {ω^^ω2}^{ω3}

...

#^^##>#^# --> {ω^^ω2}^{ωω}

...

#^^##>#^^# --> {ω^^ω2}^{ω^^ω}

...

#^^##>#^^## --> {ω^^ω2}^{ω^^ω2}

#^^##>#^^##>#^^## --> {ω^^ω2}^{ω^^ω2}^{ω^^ω2}

...

#^^### --> ω^^ω3

#^^#### --> ω^^ω4

...

#^^#^# --> ω^^ωω

                    Here we finally reach Tiaokhiao's #^^#^# delimiter, but this time with much greater power. We've already reached the ordinal ϕ(ω,0) which was the limit ordinal of Tiaokhiao's extension. Yet we've only begun with Extended Cascading-E Notation. We can now hurry on to the end of tetrational arrays and the beginning of pentational arrays...

#^^#^#^# --> ω^^ω^ω^ω

#^^#^^# --> ω^^ω^^ω

#^^#^^#^^# --> ω^^ω^^ω^^ω

#^^#^^#^^#^^# --> ω^^ω^^ω^^ω^^ω

...

#^^^# --> ω^^^ω

                    At this point we are guaranteed to have reached Jonathan Bowers' pentational arrays because I've used the maximal interpretation of them (using sequences suggested by Bowers' in his hypernomial page would actually lead to drastically smaller pentational arrays). We've also reached Γ0 (Gamma-Zero) of the Fast Growing Hierarchy. This is a  weak lower bound on the growth rate of the TREE function. Not bad, and we still have the rest of the hyper-operators to get through.

                    To continue we simply allow all previous "operators" to now be applied to #^^^#. The caret top is used to count transfinite applications of the operators and this forms the basis for the next operator. The tetrational operators , ie. ^^#, ^^##, ^^###, ^^#^#, ^^#^#^#, ^^#^^#, etc. each represent fixed points of different members of the binary Veblen Hierarchy. There is no highest tetrational operator just as there is no highest member of the binary Veblen Hierarchy. Anytime we "run out" of binary functions, we just invent a new ordinal notation to continue. Every Veblen function is therefore represented via a tetrational operator along with a caret top ie. #^^#>α --> ϕ(1,α) , #^^##>α --> ϕ(2,α) , #^^###>α --> ϕ(3,αetc. 

                    The tetrational operators can be applied to any epsilon-numbered hyperion-ordinal. So we can simply continue as follows:

(#^^^#)^^# --> {ω^^ω}^{ω^^^ω+1}

((#^^^#)^^#)^^# --> {ω^^ω}^{ω^^^ω+2} 

(((#^^^#)^^#)^^#)^^# --> {ω^^ω}^{ω^^^ω+3} 

...

(#^^^#)^^#># --> {ω^^ω}^{ω^^^ω+ω} 

((#^^^#)^^#>#)^^# --> {ω^^ω}^{ω^^^ω+ω+1} 

...

(#^^^#)^^#>(#+#) --> {ω^^ω}^{ω^^^ω+ω+ω} 

...

(#^^^#)^^#>## --> {ω^^ω}^{ω^^^ω+ω2}

(#^^^#)^^#>### --> {ω^^ω}^{ω^^^ω+ω3}

...

(#^^^#)^^#>#^# --> {ω^^ω}^{ω^^^ω+ωω}


(#^^^#)^^#>#^^# --> {ω^^ω}^{ω^^^ω+ω^^ω}

(#^^^#)^^#>#^^^# --> {ω^^ω}^{ω^^^ω+ω^^^ω}

(#^^^#)^^#>(#^^^#+#^^^#) --> {ω^^ω}^{ω^^^ω+ω^^^ω+ω^^^ω}

...

(#^^^#)^^#>(#^^^#*#) --> {ω^^ω}^{ω^^^ω*ω}

(#^^^#)^^#>(#^^^#*#^^^#) --> {ω^^ω}^{(ω^^^ω)2}

(#^^^#)^^#>(#^^^#)^^# --> {ω^^ω}^{ω^^ω}^{ω^^^ω+1}

(#^^^#)^^#>(#^^^#)^^#>(#^^^#)^^# 

--> {ω^^ω}^{ω^^ω}^{ω^^ω}^{ω^^^ω+1}

...

(#^^^#)^^## --> {ω^^ω2}^{ω^^^ω+1}

...

(#^^^#)^^### --> {ω^^ω3}^{ω^^^ω+1}

...

(#^^^#)^^#^# --> {ω^^ωω}^{ω^^^ω+1}

...

(#^^^#)^^#^^# --> {ω^^ω^^ω}^{ω^^^ω+1}

(#^^^#)^^#^^#^^# --> {ω^^ω^^ω^^ω}^{ω^^^ω+1}

(#^^^#)^^#^^#^^#^^# --> {ω^^ω^^ω^^ω^^ω}^{ω^^^ω+1}

...

                    At this point we are quickly exhausting our current supply of tetrational operators (think of the whole expression ie. ^^#^^#^^#^^# as a single massive tetrational operator. In fact it's the #^^#^^#^^# operator). Note that we didn't devise any tetrational operators after these. We simply used #^^^# as the limit ordinal of all of these tetrational operators as applied to "#". To continue we devise a new operator ... the ^^#^^^# tetrational operator! Note that #^^^# is itself really just the first application of the ^^#^^^# operator on "#". In other words we can say that #^^#^^^# is virtually synonymous with #^^^#, although there is a slight technical difference (we'll look into the details of formalization later, for now I only want to note that we've already applied this tetrational operator once). So we now apply the ^^#^^^# operator to #^^^# and obtain:

(#^^^#)^^(#^^^#) --> {ω^^^ω}^{1}

                    We did all that just to climb an additional 1 on top of a power tower of omegas ω^^^ω terms high! We've barely begun extending beyond pentational arrays. Next we apply all of the same tetrational operators again ... 

((#^^^#)^^(#^^^#))^^# --> {ω^^ω}^{{ω^^^ω}^{1}+1}

((#^^^#)^^(#^^^#))^^## --> {ω^^ω2}^{{ω^^^ω}^{1}+1}

((#^^^#)^^(#^^^#))^^### --> {ω^^ω3}^{{ω^^^ω}^{1}+1}

...

((#^^^#)^^(#^^^#))^^#^^# --> {ω^^ω^^ω}^{{ω^^^ω}^{1}+1}

((#^^^#)^^(#^^^#))^^#^^#^^# --> {ω^^ω^^ω^^ω}^{{ω^^^ω}^{1}+1}

...

We can now apply the ^^(#^^^#) tetrational operator to #^^^# twice:

((#^^^#)^^(#^^^#))^^(#^^^#) --> {ω^^^ω}^{2}

and thrice...

(((#^^^#)^^(#^^^#))^^(#^^^#))^^(#^^^#) --> {ω^^^ω}^{3}

and after applying ^^(#^^^#) "#" times we obtain:

(#^^^#)^^(#^^^#)># --> {ω^^^ω}^{ω}

... and now we have a new function in which we can plug in any of the previously constructed hyperion ordinals...

(#^^^#)^^(#^^^#)>(#+#) --> {ω^^^ω}^{ω+ω}

...

(#^^^#)^^(#^^^#)>## --> {ω^^^ω}^{ω2}

...

(#^^^#)^^(#^^^#)>### --> {ω^^^ω}^{ω3}

...

(#^^^#)^^(#^^^#)>#^# --> {ω^^^ω}^{ωω}

...

(#^^^#)^^(#^^^#)>#^^# --> {ω^^^ω}^{ω^^ω}

(#^^^#)^^(#^^^#)>#^^^# --> {ω^^^ω}^{ω^^^ω}

...

(#^^^#)^^(#^^^#)>(#^^^#)^^(#^^^#)>#^^^# --> {ω^^^ω}^{ω^^^ω}^{ω^^^ω}

...

and now we've gotten all the way up to ...

(#^^^#)^^(#^^^#*#) --> ω^^(ω^^^ω*ω)

PRACTICALLY NOWHERE! We've still only just begun our climb out of pentational arrays!

As you can now probably imagine we have a slew of new tetrational operators we can create. These go on for a very long time but they form the basis of the next level of the notation...

(#^^^#)^^(#^^^#*##) --> ω^^(ω^^^ω*ω2)

(#^^^#)^^(#^^^#*###) --> ω^^(ω^^^ω*ω3)

...

(#^^^#)^^(#^^^#*#^#) --> ω^^(ω^^^ω*ωω)

(#^^^#)^^(#^^^#*#^^#) --> ω^^(ω^^^ω*ω^^ω)

(#^^^#)^^(#^^^#*#^^^#) --> ω^^(ω^^^ω*ω^^^ω)

...

(#^^^#)^^(#^^^#)^# --> ω^^(ω^^^ω)ω

(#^^^#)^^(#^^^#)^^# --> ω^^({ω^^ω}^{ω^^^ω+1})

(#^^^#)^^(#^^^#)^^(#^^^#)^^# --> ω^^ω^^({ω^^ω}^{ω^^^ω+1})

(#^^^#)^^(#^^^#)^^(#^^^#)^^(#^^^#)^^# 

--> ω^^ω^^ω^^({ω^^ω}^{ω^^^ω+1})

...

                Finally we reach the 2nd application of the first pentational operator...

(#^^^#)^^^# --> {ω^^^ω}^^{1}

              AAAAAHHHHHHH!!!

                    ...and we aren't done with the tetrational operators either ... more keep being invented to pad out the values between the applications of the pentational operators! For example...

((#^^^#)^^^#)^^((#^^^#)^^^#) --> {{ω^^^ω}^^{1}}^{1}

((#^^^#)^^^#)^^((#^^^#)^^^#)># --> {{ω^^^ω}^^{1}}^{ω}

((#^^^#)^^^#)^^((#^^^#)^^^#*#) --> ω^^({ω^^^ω}^^{1}*ω)

...

madness quickly ensues. Beyond the fray however we eventually reach...

((#^^^#)^^^#)^^((#^^^#)^^^#)^^((#^^^#)^^^#)^^((#^^^#)^^^#)^^...

which has limit ordinal ((#^^^#)^^^#)^^^#. Look familiar? This is the same pattern we saw in the build up to LECEN, only now we are building tetrational towers in order to repeatedly apply a pentational operator! And it gets crazier because we've still barely begun. Now it should be clear that we can create a whole hierarchy of pentational operators just as we orginally created a whole hierarchy of tetrational operators (which is still technically growing in the "background noise" of this complex notation)...


((#^^^#)^^^#)^^^# --> {ω^^^ω}^^{2}

(((#^^^#)^^^#)^^^#)^^^# --> {ω^^^ω}^^{3}

...

#^^^#># --> {ω^^^ω}^^{ω}

                Here we have the first use of the caret top in conjunction with a pentational operator, ^^^#>α. As you can imagine we can now recursively nest this new function to obtain the next pentational operator...

#^^^#>(#+#) --> {ω^^^ω}^^{ω+ω}

#^^^#>## --> {ω^^^ω}^^{ω2}

#^^^#>#^# --> {ω^^^ω}^^{ωω}

#^^^#>#^^# --> {ω^^^ω}^^{ω^^ω}

#^^^#>#^^^# --> {ω^^^ω}^^{ω^^^ω}

#^^^#>#^^^#>#^^^# --> {ω^^^ω}^^{ω^^^ω}^^{ω^^^ω}

#^^^#>#^^^#>#^^^#>... --> {ω^^^ω}^^{ω^^^ω}^^{ω^^^ω}^^...

#^^^## --> ω^^^ω2

... it is at this point that we finally see the light at the end of the tunnel. We've finally effected the right side of the ordinal pentation which means we can finally recursively apply pentation to itself to form the basis of hexation...

#^^^### --> ω^^^ω3

...


#^^^#^# --> ω^^^ωω

#^^^#^^# --> ω^^^ω^^ω

...

#^^^#^^^# --> ω^^^ω^^^ω

#^^^#^^^#^^^# --> ω^^^ω^^^ω^^^ω

#^^^#^^^#^^^#^^^... --> ω^^^ω^^^ω^^^ω^^^...

                    finally we transcend the pentational arrays and reach the beginning of hexational arrays...

#^^^^# ---> ω^^^^ω 

                    At this point we've reached all the way to ϕ(2,0,0) in the Fast Growing Hierarchy. We can still go much further. Let's look at how hexational hyperions are extended to achieve heptational hyperions.

                Note that everything that has come prior is still in effect. We can still apply all of the tetrational operators that we've "created" so far (basically we can have a tetrational operator for every ordinal we've created up to this point including #^^^^# and anything we create beyond that). We can still apply all of the pentational operators that we've created. Only after we've taken everything we've done so far to the limit do reach reach the beginnings of the hexational operators. So we begin with...

(#^^^^#)^^# --> {ω^^ω}^{ω^^^^ω+1}

 (#^^^^#)^^## --> {ω^^ω2}^{ω^^^^ω+1}

...

(#^^^^#)^^#^# --> {ω^^ωω}^{ω^^^^ω+1}

(#^^^^#)^^#^^# --> {ω^^ω^^ω}^{ω^^^^ω+1}

(#^^^^#)^^#^^^# --> {ω^^^ω}^{ω^^^^ω+1}

(#^^^^#)^^#^^^#^^^# --> {ω^^^ω^^^ω}^{ω^^^^ω+1}

(#^^^^#)^^#^^^#^^^#^^^... --> {ω^^^ω^^^ω^^^...}^{ω^^^^ω+1}

...

(#^^^^#)^^#^^^^# --> {ω^^^^ω}^{1}

(#^^^^#)^^(#^^^^#)># --> {ω^^^^ω}^{ω}

(#^^^^#)^^(#^^^^#)>#^^^^# --> {ω^^^^ω}^{ω^^^^ω}

(#^^^^#)^^(#^^^^#)>(#^^^^#)^^(#^^^^#)>#^^^^# --> {ω^^^^ω}^{ω^^^^ω}^{ω^^^^ω}

...

(#^^^^#)^^(#^^^^#*#) --> ω^^(ω^^^^ω*ω)

(#^^^^#)^^(#^^^^#*#^^^^#) --> ω^^(ω^^^^ω*ω^^^^ω)

(#^^^^#)^^(#^^^^#)^^# --> ω^^({ω^^ω}^{ω^^^^ω+1})

(#^^^^#)^^(#^^^^#)^^(#^^^^#)^^# --> ω^^ω^^({ω^^ω}^{ω^^^^ω+1})

...

(#^^^^#)^^^# --> {ω^^^ω}^^{ω^^^^ω+1}

((#^^^^#)^^^#)^^^# --> {ω^^^ω}^^{ω^^^^ω+2}

(((#^^^^#)^^^#)^^^#)^^^# --> {ω^^^ω}^^{ω^^^^ω+3}

(#^^^^#)^^^#># --> {ω^^^ω}^^{ω^^^^ω+ω}

(#^^^^#)^^^## --> {ω^^^ω2}^^{ω^^^^ω+1}

(#^^^^#)^^^### --> {ω^^^ω3}^^{ω^^^^ω+1}

(#^^^^#)^^^#^# --> {ω^^^ω^ω}^^{ω^^^^ω+1}

(#^^^^#)^^^#^^# --> {ω^^^ω^^ω}^^{ω^^^^ω+1}

(#^^^^#)^^^#^^^# --> {ω^^^ω^^^ω}^^{ω^^^^ω+1}

(#^^^^#)^^^#^^^#^^^# --> {ω^^^ω^^^ω^^^ω}^^{ω^^^^ω+1}

(#^^^^#)^^^#^^^#^^^#^^^# --> {ω^^^ω^^^ω^^^ω^^^ω}^^{ω^^^^ω+1}

...

(#^^^^#)^^^(#^^^^#) --> {ω^^^}^^{1}

Here we have applied the ^^^(#^^^^#) twice already. Just to be clear about what happens next we'll quickly go through the operators until we reach the third application of the ^^^(#^^^^#) operator:

((#^^^^#)^^^(#^^^^#))^^# --> {ω^^ω}^{{ω^^^}^^{1}+1}

...

((#^^^^#)^^^(#^^^^#))^^(#^^^#) --> {ω^^^ω}^{{ω^^^}^^{1}+1}

(
(#^^^^#)^^^(#^^^^#))^^(#^^^#^^^#) --> {ω^^^ω^^^ω}^{{ω^^^}^^{1}+1}

...

((#^^^^#)^^^(#^^^^#))^^#^^^^# --> {ω^^^^ω}^{{ω^^^}^^{1}+1}

((#^^^^#)^^^(#^^^^#))^^((#^^^^#)^^^(#^^^^#)) --> {{ω^^^}^^{1}}^{1}

...

((#^^^^#)^^^(#^^^^#))^^((#^^^^#)^^^(#^^^^#))># --> {{ω^^^}^^{1}}^{ω}

((#^^^^#)^^^(#^^^^#))^^((#^^^^#)^^^(#^^^^#)*#) --> ω^^({ω^^^}^^{1}*ω)

((#^^^^#)^^^(#^^^^#))^^^# --> {ω^^^ω}^^{{ω^^^}^^{1}+1}

(((#^^^^#)^^^(#^^^^#))^^^#)^^^# --> {ω^^^ω}^^{{ω^^^}^^{1}+2}

...

((#^^^^#)^^^(#^^^^#))^^^## --> {ω^^^ω2}^^{{ω^^^}^^{1}+1}

((#^^^^#)^^^(#^^^^#))^^^### --> {ω^^^ω3}^^{{ω^^^}^^{1}+1}

...

((#^^^^#)^^^(#^^^^#))^^^#^# --> {ω^^^ω^ω}^^{{ω^^^}^^{1}+1}

((#^^^^#)^^^(#^^^^#))^^^#^^# --> {ω^^^ω^^ω}^^{{ω^^^}^^{1}+1}

((#^^^^#)^^^(#^^^^#))^^^#^^^# --> {ω^^^ω^^^ω}^^{{ω^^^}^^{1}+1}

((#^^^^#)^^^(#^^^^#))^^^#^^^#^^^# --> {ω^^^ω^^^ω^^^ω}^^{{ω^^^}^^{1}+1}


...

((#^^^^#)^^^(#^^^^#))^^^(#^^^^#) --> {ω^^^}^^{2}

and now we've reached 3 applications of the ^^^(#^^^^#) operator. As you can see this is related to the number of times we multiply ω^^^^ω by itself. Thus we continue with...

(#^^^^#)^^^(#^^^^#)># --> {ω^^^}^^{ω}

(#^^^^#)^^^(#^^^^#)>#^^^^# --> {ω^^^}^^{ω^^^}

(#^^^^#)^^^(#^^^^#)>(#^^^^#)^^^(#^^^^#)>#^^^^# --> {ω^^^}^^{ω^^^}^^{ω^^^}

...

(#^^^^#)^^^(#^^^^#*#) --> ω^^^(ω^^^^ω*ω)

(#^^^^#)^^^(α) --> ω^^^(α)

...

(#^^^^#)^^^(#^^^^#)^^^(#^^^^#) -->
ω^^^(
{ω^^^}^^{1})

(#^^^^#)^^^(#^^^^#)^^^(#^^^^#)^^^(#^^^^#) --> ω^^^ω^^^({ω^^^}^^{1})

Eventually we reach...

(#^^^^#)^^^(#^^^^#)^^^(#^^^^#)^^^ ...

which has limit ordinal (#^^^^#)^^^^# --> {ω^^^^ω}^^^{1}

...

((#^^^^#)^^^^#)^^^^# --> {
ω^^^^ω}^^^{2}

...

#^^^^#># --> {
ω^^^^ω}^^^{
ω}

#^^^^#>#^^^^# -->
{ω^^^^ω}^^^{ω^^^^ω}

...

#^^^^## -->
ω^^^^ω2

#^^^^### --> ω^^^^ω3

#^^^^#### --> ω^^^^ω4

...

#^^^^#^# --> ω^^^^ω^ω

...

#^^^^#^^# --> ω^^^^ω^^ω

...

#^^^^#^^^# --> ω^^^^ω^^^ω

...

#^^^^#^^^^# --> ω^^^^ω^^^

...

#^^^^^# --> ω^^^^

#^^^^^^# --> ω^^^^^^ω

...


Formalization of Extended Cascading-E Notation

                    We can generally get through most of xE^ intuitively, however there are a few difficult spots that require further clarification. More importantly we need to know that everything functions properly to know for certain that the function does indeed terminate and is logically constructed. Towards that end we can first make the observation that despite the added complexity the basic principles have not changed at all from Cascading-E Notation, suggesting that the basics of Extensible-E were already worked out there.

                        Essentially we can see that 5 general rules are all that is needed for all further Extensions within Extensible-E. These 5 rules can be codified as follows:

1. BASE RULE : If there is a single argument ; Ea = 10^a

2. DECOMPOSITION RULE : If the last cascader of the last hyper product is not of the form ###...###, then apply a transformation on the hyperion expression ; @a&b --> @a&[b]a (where &[b] is the bth member of the fundamental sequence for &)

3. TERMINATION RULE : If Rules 1 and 2 don't apply, the last argument =1 ; @a&1 --> @a

4. EXPANSION RULE : If Rules 1,2, and 3 don't apply and the last delimiter =! # ; @a&*#b --> @a&a&*#(b-1)

5. RECURSIVE RULE : If Rules 1,2,3, and 4 don't apply  ; @a#b --> @(@a#(b-1))

                    That's it! Much like the 3 basic rules for BEAF or the 3 basic rules for FGH, these rules never change and can be extended as long as the delimiters and their decompositions can be defined.  

                    The key to having a well defined system is therefore to have a well defined sequence of delimiters, and a clear set of rules for their decomposition. This is in fact the hardest part of defining the function. In order to have a well defined function built from delimiters we need to meet the following conditions:

I. The main sequence delimiters must form a well-ordered set

II. Every non-consecutive delimiter (limit ordinal) must have a well defined decomposition and fundamental sequence

III. Every delimiter must eventually decompose into the base case delimiter

                    Satisfying this conditions is more difficult than it might initially seem. The idea that delimiters form a well-ordered set means that we should be able to determine in a finite number of computational steps which of two delimiters is of a higher "rank". This is usually pretty easy in elementary cases, but for complex cases there should be an algorithm that a computer could theoretically run to automatically check which is larger. Decompositions are important and if there is ever any doubt about a particular decomposition that should be a red flag that something is amiss. It's important to remember that a googological function is very much like a over-complicated piece of mathematical machinery. If we want it to produce numbers however we must ensure that it's in proper working order. This is the actual challenge and this is what makes googology more than a shouting match.

                There are also some additional issues particular to the Extensible-E system we should address. There is the possibility for ambiguity for complex hyperion expressions. For this reason it is important that we establish some kind of order of operations for the resolution of such expressions. 

                Another important issue is defining a main sequence of delimiters. Note that it is possible to create "rogue-type" delimiters, ie. #^^#^^^#, (#^^^#)^^^(#^^^^#), etc. These are actually nothing new. In Cascading-E some rogues would include #*#^#, #^#*#^## , etc. and generally anything that doesn't occur along the main sequence. Despite the fact that these don't occur in the main sequence, the rules, as established, work equally well for these cases. There are two ways that we can deal with rogue-types. One way is to explicitly define a class of legal delimiters and disallow rogues entirely. Another option is to simply define a main sequence and not worry about rogues ones way or another. We can expect that rogues may follow non-standard sequences for awhile but eventually merge with the main sequence at some point, and behave in generally well defined ways. Since we'll make limited use of them the issue of whether or not they are well defined is largely a moot point. In the case of Cascading-E it's fairly clear that rogue-types are well defined, and will eventually return to the main sequence, even if this takes a long time. For example #^#*##*#^##, will take a long time for #^## to reduce to a string of hyperions, but when it does the delimiter will again be part of the main sequence ie. #^#*#####...####. 

              Let's look at order of operations

Order of Operations

                    The first thing we'll establish is the order of operations. Firstly note that the "operations" in this case operate on ordinals instead of numbers. To carry out any operation we are simply applying a decomposition rule and substituting a member of the fundamental sequence. Defining the order of operations is therefore part of providing well defined decompositions. Another important function of defining order of operations is to avoid ambiguity in the interpretation of delimiters.

                    For any delimiter we want to be able to say which operator is to be applied in its decomposition first.

                    Cascading-E already established some basic principles intuitively, but we'll now extrapolate those principles to xE^ explicitly.

When resolving a delimiter we will generally follow right to left resolution, for all operators with the sole exception being that of addition and multiplication. In other words, addition and multiplication always act as separators (delimiters within the delimiters!). For this reason parentheses are often needed when these operations are involved. The only exception is when hyperions are written next to each other. This strong multiplication treats the string of hyperions as single unit. This is why for example there is no ambiguity between #^## versus #^#*#. Similar ambiguities can be resolved in this manner in xE^. For example:

#^^#>## means ## applications of the ^^# operator

while...

#^^#>#*# means #^^#># times #

                    As for the hyper-operators, right to left resolution always applies so that we can write:

#^^^#^^#^^#^^#^^#^#^#^#

...without any confusion, even when are not in size order. For example...

#^^#^^^#^#

is still evaluated as #^^(#^^^(#^#))

Caret tops act from right to left as well. They always apply to the previous operator ie. ^^..^^(&)>. For this reason parantheses are required for complex operators. For example:

^^(#^^^#)>

we wouldn't write ^^#^^^#> because then the caret top will only apply to ^^^# instead of ^^(#^^^#). The parentheses however can be omitted in a case like (#^^^#)^^#^^^# because we know #^^^# on the right must be resolved first.

We can use parentheses in this way to parse complex applications of the caret top. For example:

(#^^^#)^^#^^#^^#^^#^^#^^#>#

means ...

(#^^^#)^^(#^^#^^#^^#^^(#^^#>#))

while:

(#^^^#)^^(#^^#^^#^^#^^#^^#)>#

means # applications of the ^^(#^^#^^#^^#^^#^^#) operator.

To codify the rules we need some terminology.

Begin with &+&+ ... +&+&

the & are called hyper-terms in this case. Resolution of hyper-terms is always from right-to-left. That is, the rightmost must be fully decomposed to a base case of the empty hyperion ( 0 ) , before we can begin decomposing the next hyper-term.

Within each hyper-term, we have a series of hyper-factors ...

&*&*&* ... *&*&

again hyper-factors are resolved from right-to-left. The rightmost hyper-factor must be fully decomposed to the base case of the identity hyperion ( 1 ) before we can begin decomposing the next hyper-factor.

Lastly, in each hyper-factor the operations of cascades ( ^ ) and caret tops ( > ) are always to be evaluated from right-to-left regardless of rank. Parentheses are the only exception to this, and act as expected to specify the exact order of operations when they do not follow simply from right-to-left.

So for example ...

#^^#>#^^#>#^^#

should be understood as implicitly meaning...

#^^#>(#^^#>(#^^#))

Note that there will be many similar expressions which carry out the operations in some other order and will mean drastically different things. For example we might have ...

#^^#>(#^^#>#)^^#

(#^^#>#^^#>#)^^#

                    Note that these can be ranked. Can you figure out the correct order of #^^#>#^^#>#^^#, #^^#>(#^^#>#)^^# , and (#^^#>#^^#>#)^^#?

Ans.

(#^^#>#^^#>#)^^# is the smallest as it is smaller than #^^#>(#^^#>#+#)

this is much smaller than #^^#>(#^^#>#)^^# and this in turn is smaller than #^^#>#^^#>(#+#) which is much smaller than #^^#>#^^#>#^^#.


Defining the Operators

                Because hyper-operators are to be resolved from right to left, parentheses are needed to emphasize the left to right resolution of them. 

                The idea that we can perform "operations" on ordinals is perhaps not so strange if understood as an extension of ordinal exponentiation. We can think of "^" as an ordinal operator. For example, the ^# operator, the smallest exponential operator, has the following definition:

&^# --> &*&*&*&*...*&

                Furthermore we have higher exponential operators:

&^## --> &^#*&^#*&^#*...*&^#

&^### --> &^##*&^##*&^##*...*&^##

etc.

                Based on this we define the following hyper-operator operations:

(&)^^# --> (&)^(&)^(&)^ ... ^(&)^(&)

(&)^^^# --> (&)^^(&)^^(&)^^ ... ^^(&)^^(&)

(&)^^^^# --> (&)^^^(&)^^^(&)^^^ ... ^^^(&)^^^(&)

etc.

                Each operator then simply applies repetitions of the previous operator. 

                    Despite the seemingly endless variety of operators for xE^ it turns out that the entire system can be reduced to a set of binary ordinal operators, and a set of ternary ordinal operators. There is a binary operator for each of the traditional operators and they can all be generalized to work with any of the ordinals we can generate within the xE^ system. These operators are 

ordinal addition

α+β

ordinal multiplication

α*β

ordinal exponentiation

α^β
        
ordinal tetration

α^^β

ordinal pentation

α^^^β

ordinal hexation

α^^^^β

... and the general ordinal hyper-operators

α^^...^^β
           
In addition to these we have an infinite set of ternary operations which help to fill out the in-between stages and build from one binary operation to the next. These are the caret top operators. They apply only to the operators above exponents:

tetrational caret top ordinal function

α^^β>γ

pentational caret top ordinal function

α^^^β>γ

hexational caret top ordinal function

α^^^^β>γ

and the general hyper-operator caret top ordinal functions

α^^...^^β>γ

                    The set of legal delimiters for the xE^ system are created recursively:

1. # is a legal delimiter

2. if α,β, and γ then any binary or ternary ordinal function with α,β, and γ is a legal delimiter.

                    This forms the complete set, along with the main sequence and many many more rogue-types. The rogue types however won't be of much concern however since I'll define the system so that rogue-types can be evaluated as well. Thus we can treat the operators as total functions. One thing to note: none of the operators are commutative. Order is always important. 

                    Applying the definition note that all the main sequence delimiters of Cascading-E can be generated. This simply requires repeat applications of ordinal multiplication and exponentiation. For example:

## is a legal delimiter since ## = #*# and # is a legal delimiter.

#^# is a legal delimiter since # is a legal delimiter.

#^#^# is a legal delimiter because #^#^# = #^(#^#) and it was previously established that # and #^# are legal delimiters.

#^#*#^# is a legal delimiter since #^#*#^# = (#^#)*(#^#) and it was previously established that #^# is a legal delimiter.

#^(#^#*#^#) is a legal delimiter since it was previously established that # and #^#*#^# are legal delimiters.

#^#^#^# is a legal delimiter since #^#^#^# = #^(#^#^#) and it was previously established that # and #^#^# are legal delimiters.

etc.

                    Note that many unusual rogue-types are also constructable using this method. For example ##^# or (#^#)^# or (##^#*#)^## etc. How do these kinds of delimiters work? This can be established by simply defining the operators to apply to any case within the legal set of delimiters (this will be explained shortly).

                    For the purposes of this explanation I'll be using the following terminology:

A hyper-factor is the generalized version of a cascader. A hyper-factor contains no ordinal additions or weak multiplications (signified by the asterisk * ) at the outermost nest. Additions and multiplications however can be carried out nested inside other operators. Some examples of hyper-factors are:

#^# , #^(#^#*#^#) , #^(#+#) , #^^# , #^^#># , etc.

                A hyper-term is the generalized version of a hyper-product. A hyper-term is a product of hyper-factors using weak multiplication that contains no additions at the outermost nest. Once again additions can be carried out nested inside other operators. Some examples of hyper-terms are:

#^#*# , #^^#*#^^# , #^^#>(#+#)*# , #^^^#*#^^#^^# , etc.

                A delimiter is the sum of hyper-terms. Some examples of delimiters are:

#+# , #^#*#+### , #^##+#^#+#+#+# , etc.

            The sum of hyper-terms is a hyper-sum. An ampersand ( & ) will generally be used to represent a hyper-term.

            So how are rogue-cases taken care of? Well take something like ##^# for example. What we are saying is that we want to repeat ## an arbitrary number of times. In otherwords ...

##^#[n] = ##*##*##* ... *##*##*## w/n copies of ##

            When we go to evaluate this we can simply remove the hyperions in succession regardless of whether there is strong or weak multiplication between them. In fact...

##*##*##* ... *##*##*## = ###### ... ###### w/2n copies of #

similarly in the case of (#^#)^#, we can expand as follows ...

(#^#)^#[n] = #^#*#^#*#^#* ... *#^#*#^#*#^# w/n copies of #^#s

So (#^#)^# actually reduces to a main sequence delimiter! We see that the "base" of any of the operators (exponentiation,tetration,pentation,hexation,etc.) shouldn't matter and is always simply repeated. I make some use of this with a few scattered examples of regular googolism's (see part 2 and 3).

With this in mind it becomes possible to incorporate many many rogues. As long as the base is a hyper-term and not a hyper-sum then the sequences are well defined.

Defining xE^

That's basically the gist of xE^. After some thought I was able to codify it in the following definition ...

              

Extended Cascading-E Notation
(xE^)


Let Ea1&(1)a2&(2)a3&(3) ... &(k-2)ak-1&(k-1)ak

where a1~ak are k positive integers

and &(1)~&(k-1) are k-1 delimiters from the set x^

and k∈{1,2,3,4,5,...}

be defined as follows:



Let

m denote ak-1

n denote ak

@ denote the unchanged remainder of an expression

& denote any portion of a delimiter we chose to omit

and &[n] denote the nth member of the fundamental sequence defined for the delimiter &



BASE RULE

            1. k=1 ;

En = 10n



DECOMPOSITION RULE

            2. &(n-1)  x^_lim ;

@m&n = @m&[n]m



TERMINATING RULE
            3. ak=1 ;

@m&1 = @m



EXPANSION RULE
            4. &(n-1) ≠ # ;

@m&*#n = @m&m&*#(n-1)



RECURSIVE RULE
            5. no condition ;

@m#n = @(@m#(n-1))


Definition of  &[n]


            Let & represent any portion of a delimiter we want to omit. Let every delimiter be known as a hyper-product in the form &*&*&*&*...&*&*& where each & is a hyper-factor. The last hyper-factor will be denoted L. 

                For the purposes of this definition let ^..k..^ = ^^^...^^^ w/k ^s

            The Sequence operator , &[n] , always operates on the last hyper-factor using the following rules:



        I. L =  (α)^(β) where α,β x^ ;

                        A. When β = # :

IA1. &(α)^(#)[1] = &α

IA2. &(α)^(#)[n] = &α*(α)^(#)[n-1]

                        B. When  β =ρ*# :
            
IB1. &(α)^(ρ*#)[1] = &(α)^(ρ)

IB2. &(α)^(ρ*#)[n] = &(α)^(ρ)*(α)^(ρ*#)[n-1]

                        C. When β x^_lim :

IC1. &(α)^(β)[n] = &(α)^(β[n])



        II. L =  (α)^..k..^(β) where α,β  x^ and k>1 ;

                        A. When β = # :

IIA1. &(α)^..k..^(#)[1] = &α

IIA2. &(α)^..k..^(#)[n] = &(α)^..k-1..^((α)^..k..^(#)[n-1])

                        B. When β ρ*# :
            
IIB1. &(α)^..k..^(ρ*#)[1] = &(α)^..k..^(ρ)

IIB2. &(α)^..k..^(ρ*#)[n] = &(α)^..k..^(ρ)>((α)^..k..^(ρ*#)[n-1])

                        C. When β ∈ x^_lim :

IIC1. &(α)^..k..^(β)[n] = &(α)^..k..^(β[n])



            III. L (α)^..k..^(β)>(γ) where α,β ∈ x^ , γ x^+, and k>1 ;

                        A. When γ = # :

IIIA1. &(α)^..k..^(β)>(#)[1] = &(α)^..k..^(β)

IIIA2. &(α)^..k..^(β)>(#)[n] = &((α)^..k..^(β)>(#)[n-1])^..k..^(β)

                        B. When γ=ρ+# :
            
IIIB1. &(α)^..k..^(β)>(ρ+#)[1] = &((α)^..k..^(β)>(ρ))^..k..^(β)

IIIB2. &(α)^..k..^(β)>(ρ+#)[n] = &((α)^..k..^(β)>(ρ+#)[n-1])^..k..^(β)

                        C. When γ ∈ x^_lim :

IIIC1. &(α)^..k..^(β)>(γ)[n] = &(α)^..k..^(β)>(γ[n])

                        D. When γ ρ+δ where ρ x^+ and δ x^_lim :

IIID1. &(α)^..k..^(β)>(ρ+δ)[n] = &(α)^..k..^(β)>(ρ+(δ[n]))

                        E. When γ δ*# where δ ∈ x^ :

IIIE1. &(α)^..k..^(β)>(δ*#)[1] = &(α)^..k..^(β)>(δ)

IIIE2. &(α)^..k..^(β)>(δ*#)[n] = &(α)^..k..^(β)>(δ+δ*#)[n-1]

                        F. When γ ρ+δ*# where ρ ∈ x^+ and δ ∈ x^ :

IIIF1. &(α)^..k..^(β)>(ρ+δ*#)[1] = &(α)^..k..^(β)>(ρ+δ)

IIIF2. &(α)^..k..^(β)>(ρ+δ*#)[n] = &(α)^..k..^(β)>(ρ+δ+δ*#)[n-1]


 The x^ Set


                I. #  x^ 

                II. If α,β ∈ x^ , γ ∈ x^+ , and  k∈{2,3,4,5,...} then :

α*β

(α)^(β)

(α)^..k..^(β)

(α)^..k..^(β)>(γ)

            are members of the x^ Set.


The x^+ Set


                    I. If α ∈ x^ then α ∈ x^+

          II. If α,β ∈ x^+ Set then:

 α+β

                    are members of the x^+ Set.


The x^_scs Set


                    I. If α ∈ x^ then α*# ∈ x^_scs Set.


The x^_lim Set


                   I. If α  x^ and α  x^_scs ∪ {#} then α  x^_lim



                   That is a complete formalization of xE^. The formal definition gives somewhat clunky names for the delimiters, and operates in a rather strict fashion. For example, the delimiters #, ##, ###, etc. would be written # , #*#, #*#*#, etc. This is mainly to facilitate in the formal operations of the definition. However for human readability we can omit many of the formal elements and use #,##,###,etc. as synonyms for the formal counter-parts.

                    The definition is fairly lengthy. It requires 5 rules for xE^, and an additional 12 rules for &[n]. If we count all the transformation rules, counting the base cases and general cases as distinct, we get 20 transformation rules for &[n]. Along with the transformations for xE^ this gives a total of 25 tranformations, and that's not even factoring in the definition for the various sets. Still it's rather neat that we now have a fully functional system which goes up to
 ϕ(ω,0,0).

Comparison with FGH

        (UNDER CONSTRUCTION)


Proceed to xE^ Numbers


                    Now that we have defined xE^, let's invent some new googolisms. Proceed to Part II to begin ...