home‎ > ‎4.3‎ > ‎

4.3.4 - Cascading-E Notation

4.3.4
Cascading-E Notation

PREV>> 4.3.3 - Extended Hyper-E Numbers (1142 - 2684)

 Introduction 

            As we have seen in the previous chapters, Bowers' exploding array function (BEAF) is very powerful and very general, if extremely difficult to define precisely. It is possible however to construct other systems of equal power, and some of these are easier to define than others. Due to the popularity of my Hyper-E and Extended Hyper-E Notation, I have decided to develop a major extension to my "Extensible-E System" (ExE for short) which brings it to the next level of sophistication. One motivation for this is that my Extensible-E System is heavily inspired by my original work with large numbers as a kid, so it's natural that I should develop it further with the hindsight of several years of study. This new extension to Extensible-E is called "Cascading-E Notation" ( E^ for short). The reasons for this choice will be made clear as we work out it's details. Before we look into this, I'd first like to address a weak extension to my Extended Hyper-E which was used briefly on the googology wiki (it has since been deleted due to their citation policy).

Plus Notation

            On the googology wiki, there was an attempt to extend my Extended Hyper-E Notation, and a few numbers were even devised. This extension begins by inventing a new separator, " + ", and giving it the following definition:

 

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

 

                Keep in mind that the notational conventions we will be using here are those that have already been established in my Hyper-E Notation article. So "@" is just short hand for the rest of the expression. Remember that in the E System only the last two entries are ever part of the transformation. Only once the two arguments have been reduced to a single argument can the evaluation proceed to the next step. Thus, we can truncate our expression to only the last two arguments.

 

                With this separator and definition established we can write certain numbers more compactly. For example:

 

grangol = E100+1 = E100#100

 

gugold = E100+2 = E100##100

 

throogol = E100+3 = E100###100

 

tetroogol = E100+4 = E100####100

 

...

 

godgahlah = E100+100 = E100####...####100 w/100 #s

 

grand godgahlah = E100+100#2 = E100+(E100+100) = E100+godgahlah

 

grand grand godgahlah = E100+100#3 = E100+(E100+100#2) = E100+(grand godgahlah)

 

                Using this notation a few numbers were devised, not by me, but by other users. Here are some examples:

 

bodgahlah = E100+100+100

 

trodgahlah = E100+100+100+100

 

                On the googology wiki, a double plus was used at one point with the following definition:

 

@a++b = @a+a+ ... +a+a w/b a's

 

Only a single number was defined using this notation. namely:

 

godmegalah = E100++100 = E100+100+100+ ... +100+100+100 w/100 100s

 

                This suggests that we could create strings of multiple plus marks to create a "2nd level" extended Hyper-E Notation. For example let:

 

@a+++b = @a++a++ ... ++a++a w/b a's

 

@a++++b = @a+++a+++ ... +++a w/b a's

 

and in general

 

@a+nb = @a+n-1a+n-1 ... +n-1a w/b a's

 

where +k = ++ ... ++ w/k +s

 

            Despite the fact that this might seem like the "next level" of the system, this is actually a rather weak extension of the system. Ironically, before the Plus notation even appeared on the googology wiki I had already developed the basics of a much more powerful extension. In the next part we'll start building this extension from the ground up...

Building Cascades 

                We will now begin to develop "Cascading-E Notation" (E^). The system begins by re-interpreting a string of hyperions as a product of hyperions. That is:

 

###...### w/a #s = #*#*#*#* ... *#*# w/a #s = #^a = #a

 

                Note that this gives us a nifty shorthand for writing out certain numbers in Extended Hyper-E:

 

godgahlah = E100#### ... ####100 w/100 #s =

 

E100#^(100)100 = E100#100100

 

                Note that " ^ " is a new symbol being introduced to our E System. Initially the only symbols being used were "E" and "#". We now add the third symbol "^" to the system. This is normally known as the "caret" symbol. For the purposes of Cascading-E Notation it will be called a carrier markcarrier or carrion. In addition to this we will also be adding the " * " asterisk as a punctuation symbol, with the usual multiplicative meaning. Note however that multiplications are not commutative in E^. We will also use " ( " and " ) " in the usual way to clarify order of operations.

 

                The next step is crucial. Rather than simply allowing us to raise a hyperion to any power, we also allow the exponent to itself be a expression composed of hyperions. The simplest case of this would be "#^#". This becomes our next separator after the infinite set of separators , { # , ## , ###, #### , ... }. We begin with this new definition for the new separator:

 

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

 

                As you can see the hyperion within the exponent gets replaced by "b". Furthermore, we can think of this new separator as a generic power of the hyperion:

 

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

 

                This notation allows us to write numbers in the  godgahlah group as:

 

godgahlah = E100#^#100

 

grand godgahlah = E100#^#100#2

 

grand grand godgahlah = E100#^#100#3

 

...

 

hundred-ex-grand godgahlah = E100#^#100#101

 

godgahlah-ex-grand godgahlah = E100#^#100#(godgahlah+1

 

                As you can see, all the rules of Hyper-E and Extended Hyper-E carry over to the new notation. Note that the separator " #^# " is equivalent to " + ".

 

                We continue by extrapolating a pattern observed with the existing separators within a new "hash-product" paradigm. Observe that every succeeding separator is multiplying the previous separator by a hyperion.

 

ie.

 

#*# = ##

 

##*# = ###

 

###*# = ####

 

etc.

 

Thus we conclude that the next separator after " #^# " should be " #^#*# ". To determine how the operator should work we again observe the pattern established in Extended Hyper-E Notation:

 

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

 

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

 

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

 

So we conclude that in general any hash-product is expanded by removing one hyperion (dividing it by #) and using this as a separator of b arguments of a. So it follows that:

 

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

 

                So here we have repetitions of the #^# separator. #^#*# is equivalent to " ++ ". We can go further and define ...

 

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

 

... by following the same logic.

 

#^#*## is equivalent to " +++ " 

 

In general:

 

@a#^#*#kb = @a#^#*#k-1a ... a w/b a's

 

where #^#*#k is equivalent to ++...++ w/k+1 "+"s

 

                So already we have reached the end of the Plus Notation. However Cascading-E Notation is just getting started! 

 

                So that we can have some terms to describe what happens next, let a hyper band be defined as any product of simple hyperions, ie. anything of the form ### ... ### is a hyper band.

 

                To continue with our notation we can truncate the second hyper band into another #^#.

 

                Thus beyond all separators of the form { #^# , #^#*# , #^#*## , #^#*### , ... } we have the #^#*#^# separator.

  

                Next we define:

 

@a#^#*#^#b = @a#^#*#^(b)a

 

                Much the same way with multi-hyperion marks, we must resolve the last most part of the hyper product first. Any expression of the form #^X*#^X*...#^X is known as a hyper-product or alternatively as a hyper-term. Each of the individual terms, #^X, of the hyper-product are called cascaders (the rationale for this will be made clear as we progress). So every hyper-product is just the product of cascaders. Whenever resolving a Cascading-E Expression, remember to always resolve the last cascader before proceeding to the next.

 

                With this logic established, the following continuation should be obvious:

 

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

 

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

 

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

 

...

 

@a#^#*#^#*#^#b = @a#^#*#^#*#^(b)a

 

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

 

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

 

...

 

@a#^#*#^#*#^#*#^#b = @a#^#*#^#*#^#*#^(b)a

 

...

 

@a#^#*#^#*#^#*#^#*#^#b = @a#^#*#^#*#^#*#^#*#^(b)a

 

...

 

@a#^#*#^#*#^#*#^#*#^#*#^#b = @a#^#*#^#*#^#*#^#*#^#*#^(b)a

 

etc.

 

                    This brings us to the limit of this idea. To go beyond this, as always, all we need is a new separator. Here we can use the idea of exponential laws to devise a new separator. Recall that:

 

ax * ay = ax+y

                

                With this in mind we can say that:

 

## * ## * ## * ... ## * ## * ## = ##+#+#+ ... +#+#+# = ##*# = ###

 

                Therefore we conclude that the next separator is #^##. We can then establish the following rule:

 

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

 

 

                In order to keep things as simple as possible I'll establish the following special notation:

 

 

Let (#^X)^b = #^X*#^X*#^X* ... #^X*#^X*#^X w/b #^Xs

 

 

This will allow us to simplify definitions somewhat. We can now say:

 

 

@a#^##b = @a(#^#)^(b)a

 

                We can multiply #^## by any hyper-product we have yet devised including #^##. The limit of this would be:

 

#^##*#^##*#^##* ... *#^##

 

                When resolving a hyper-product such as this, we would begin by expanding the last #^## into a series of #^#s. Each of these would then be expanded into hyper-bands in turn, until you eventually got to the next #^##. So here we now have two levels of expansions. As you can imagine, it would take a really really REALLY long time to resolve expressions of this form!                

 

                 And it only gets worse (first rule of googology). By the same principles we've used up to this point we can devise the #^### separator and define it as:

 

 

@a#^###b = @a(#^##)^(b)a

 

 

                You can probably guess what happens next. We now can generalize this result to say that:

 

@a#^#kb = @a(#^#k-1)^(b)a

 

                Have we reached the end? Not at all, but we are now prepared to take these principles to their natural conclusion.

 

 

                We can just create a new separator #^#^#, which expands to #^#b before continuing downwards. Thus we can say:

 

@a#^#^#b = @a#^#^(b)a

 

                 Note the similarity of this rule to the rule for #^#. At this point all the basic principles we have so far established keep being recycled. As some examples:

 

 

@a#^(#^#*#)b = @a(#^#^#)^(b)a

 

@a#^(#^#*##)b = @a(#^(#^#*#))^(b)a

 

@a#^(#^#*###)b = @a(#^(#^#*##))^(b)a

 

...

 

@a#^(#^#*#^n)b = @a(#^(#^#*#^(n-1)))^(b)a

 

@a#^(#^#*#^#)b = @a#^(#^#*#^b)a

 

@a#^(#^#*#^#*#^#)b = @a#^(#^#*#^#*#^b)a

 

...

 

@a#^#^##b = @a#^((#^#)^b)a

 

@a#^#^###b = @a#^((#^##)^b)a

 

...

 

@a#^#^#^#b = @a#^#^#^(b)a

 

@a#^#^#^#^#b = @a#^#^#^#^(b)a

 

etc.

 

                Although the expressions are starting to get somewhat complicated and hard to read, there does seem to be only a few simple principles that are being used to resolve these expressions. It is not immediately obvious what is going on. All we have is a wealth of examples and a vague understanding for how to resolve them at the moment. Is there some way that we can capture the essence of what is going on and develop a more formal definition?  After some reflection I was able to isolate the fundamental principle used implicitly to resolve these expressions. 

A Formal definition of Cascading-E 

                The first thing we can observe that there are really 5 basic rule types that are occurring in our resolution of the Cascading-E. These are:

 

1. The base case:

 

 ie. Ea=10^a

 

2. The hyper-product Expansion:

 

If there is a complex hyper-product between the last two arguments whose last cascader is not of the form ###...###, then Let & be the hyper-product and &'(b) be the transformation with base b; we can then say @a&b = @a&'(b)a

 

3. The Truncation Rule:

 

 If there is a hyper-product between the last two arguments whose last cascade is of the form ##...## and the last argument=1, then let & be the hyper-product; we can then say @a&1 = @a

 

4. The hyper-band Expansion:

 

 If last argument > 1 but last cascade is of the form #^n where n>1, then Let & be the hyper-product and &/# be the hyper-product with one less hyperion at the end; we can then say @a&b = @a&/#a ... a w/b a's

 

5. The default case:

 

 If none of these apply than the last argument must be greater than 1, and the last separator must be the proto-hyperion, "#"; we then just say that @a#b = @(@a#(b-1))

 

                Two important tasks remain however until this is properly formulated. Firstly we need to develop proper terminology and symbolism to reduce the amount of wordiness as much as possible. Words can be very useful in the development of a new googological function, just as pseudo-code is a great aid for programmers. However this should only serve as a rough draft. If at all possible a formal definition should be sought out. In the search for better notation, formalism, and terminology, one often gets much practice in the concepts and eventually this leads to a drastically simplified perspective on how the system actually works.

 

                The Second task, and perhaps even the more important one, is to figure out how to solve for X'(b) for the general case.

 

                The principle for solving X'(b) turns out to be fairly simple, though a bit tricky to explain. To understand it we need to establish some notation and terminology.

 

                Firstly, let & be any hyper-product, and let X be either a positive integer or a hyper product. We now make the following statements:

 

X = & or Z+

 

& = #^X * #^X * #^X * ... * #^X

 

"cascader" = #^X

 

                To determine how to transform & into &'(b) we first determine the last cascader of &. If rule 2 applies we know the last cascader can not be equal to #^n. Next we look at the X portion of #^X for the last cascader. X must itself be a hyper-product. Find the last cascader of this hyper-product, check to see if it's equal to #^n, If it's not check it's exponent which must also be a hyper-product, and continue in this fashion until you reach something of the form #^n. Since the hyper-product is a finite hash-structure this must exist. When you have reached it, take the portion #^(X#^n) and replace it with (#^(X#^(n-1)))^b, without changing any other part of the expression. Although this description captures what's going on I doubt what I have said would be very clear to anyone on a first reading, so allow me to elaborate on this idea to provide a more symbolic explanation of the process.

 

                What we are trying to do when resolving a hyper-product is to find the key band . The key band is the hyper-band , ###...### or #^n, situated at the right most position of the hyper-product. Invariably it will be the last uninterrupted string of hyperions within the separator. Every cascader has a exponent. The exponent can be a hyper-product or a simple positive integer (pinteger).

 

                One can also describe what level the key-band is on in the structure based on the number of cascade marks that lie below the current position. Ground level is therefore level 0.

 

Remember that every hyper-product has a last cascader. With these definitions we can define a key band:

 


DEF. Key Band


            To find the Key Band of any Hyper-Product follow these instructions:

 

0. Begin at level 0, proceed to step 1

1. For the current level find the last cascader of the current hyper-product, proceed to step 2

2. Check to see whether last cascader=#^n. If so, this is the "Key Band", if not proceed to step 3

3. Go up one more level to the exponent of the last cascader and go to step 1

 


 

                This algorithm describes the process by which we find the key bar. An example would probably be a good idea at this point.

 

                Say we want to find the Key Band for the following hyper-product

 

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

 

We first begin at level 0, or the ground level. We can then observe that the hyper-product breaks up into 3 cascaders:

 

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

 

We can see what the last cascader is. This completes step 1.

 

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

 

Step 2 asks us to verify whether the last cascader is of the form #^n. It is not, since the exponent itself contains a complex hyper-product. So we proceed to step 3 which tells us to go up to the next level and return to step 1:

 

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

 

            Again we look for the last cascader, which is #^## in this case, and we proceed to step 2. Is #^## of the form #^n? No. So we proceed to step 3 which tells us to go up another level. This leaves at:

 

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

 

            The red "##" still constitutes a hyper-product by our definitions, but it's simply a single cascader. Consequently when we reach rule 1 again, we simply conclude that this is the last cascader. Rule 2 asks us if ## is of the form #^n. In this case it is, so we conclude that the red portion is the key band. Why is all this relevant to our problem? What is the key band actually used for? The key barnd addresses where we are to edit the separator when we need to transform it. Let k be the key band. This must be the exponent of some cascader. So we can imagine there is a part of the separator of the form #^(Xk) where X is the rest of the hyper-product (if there is more than one cascader. #^(Xk) is simply replaced with (#^(Xk/#))^b. " /#" is just short hand for removing the last hyperion (by dividing by a hyperion and canceling one according to our product paradigm). Let's see what would happen in the above example in an actual problem:

 

@a#^###*#^##*#^(#^###*#^##*#^##)b

 

=

 

@a#^###*#^##*#^(#^###*#^##*(#^(##/#))^b)a

 

=

 

@a#^###*#^##*#^(#^###*#^##*(#^#)^b)a

 

=

 

@a#^###*#^##*#^(#^###*#^##*#^#*#^#* ... *#^#*#^#)a w/b #^#s

 

            At this point we are very close to properly formulating Cascading-E. To make it complete we will adopt the following convention. Let "X" represent any portion of a hyper-product we wish to omit. So we could simplify are complex expression to highlight only the key band as follows:

 

#^###*#^##*#^(#^###*#^##*#^##) = X#^(#^###*#^##*#^##

 

= X#^(X#^##)

 

            This looks much simpler, and it highlights the key band nicely.

 

            It seems that we have isolated the principle to Rule 2, but does it really work in all cases? What about the most basic case "#^#". Is this also simply a manifestation of this principle? Let's follow the rule strictly and see if we can make sense of it. By definition we can say:

 

@a#^#b = @a(#^(#/#))^(b)a

 

            Strictly following the rule we obtain the result above. Does this make sense? Firstly we should recognize that #/# simply means removing the single hyperion within the exponent. It also makes sense to interpret #/# as being equal to 1. With this idea we have:

 

@a(#^(#/#))^(b)a = @a(#^1)^(b)a = @a#^(b)a

 

            As you can see, this rule even applies in the simplest of cases, so it seems that we have captured the fundamental principle. In order to make things easier to define we will agree that by definition:

 

#0 := 1

 

            This allows us to interpret #^# as #^#^1 and say that #^#^1 --> (#^#^0)^b.

 

            The choice of "Cascading-E Notation" is based on the idea that the hyperions are cascading down the power tower. We can think of the hyperions as gradually growing in number as they "cascade" down to the base level:

 

ie.

 

@a#^#^#^#^#b

 

@a#^#^#^##...##a

 

@a#^#^#### ... ####x 

 

@a#^########## ... ... ... ... ... ... ... ... ##########x2

 

@a######################## ... ... ... ... ... ... ... ... ... ... ... ... ############x3

 

(Hence why I refer to the power-towers here as "cascaders") 

 

            In any case, with these definitions in place it is now possible to give a formal definition for 

Cascading-E.

 


Def. Cascading-E Notation (E^)


 

Ea1&a2& ... &an 

 

: a1~an = Z, n=Z,

& = #^x1*#^x2* ... *#^xk , k=Z+ ,

x1 ~ xk = Z+ or & ,

L(&) = #^xk , 

a := a(n-1) , b := an , #0 := 1 ;

 

@ represents rest of E^ expression

X represents rest of hyper-term


 

1. n=1 ; 

Eb := 10^b

 

2. L(&n-1) =! #i : i=Z

@aX#^(X#K)Xb := @aX(#^(X#K-1))bXa

where #K is the "key band"

 

3. an = 1 ; 

@aX#i1 = @a

 

4. L(&n-1) = #i , i>1 ;

@aX#ib = @aX#i-1aX#i(b-1)

 

5.

@a#b = @(@a#(b-1))

 


 

            What's remarkable is that this system only requires 5 rules, and is not difficult to fully explain. Although Chris Bird was able to, more or less, formalize Bowers' system up to tetrational arrays and beyond, the definitions do in fact get fairly complex, even up to this level. It appears that Cascading-E manages to be simpler while sacrificing virtually nothing in terms of power!!!

 

            We now have a well defined and very powerful notation for naming some incredibly large numbers. In fact, as we'll discuss in the next part, this system is powerful enough to define numbers comparable to many of Bowers' numbers.

Comparison to Array Notation

            It turns out that the addition of each new separator, is equivalent to adding one new argument to a comparable array. 

 

Roughly speaking:

 

Ea##b ~ <b,b,b> = 3 & b

 

Ea###b ~ <b,b,b,b> = 4 & b

 

Ea####b ~ <b,b,b,b,b> = 5 & b

 

...

 

Ea#^#b ~ <b,b,b,b, ... ,b,b,b> w/b b's = X & b

 

            So the #^# separator is roughly equivalent to the power of linear arrays. With each additional separator, the comparable array increases by an entry, so we have this comparison to array structures:

 

#^# --> X

#^#*# --> X+1

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

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

...

#^#*#^# --> 2X

#^#*#^#*# --> 2X+1

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

...

#^#*#^#*#^# --> 3X

...

#^#*#^#*#^#* ... *#^#*#^# w/n #^#s --> nX

 

            Next we have #^## --> XX = X2. So the #^## has the same power as planar arrays. Continuing on we have:

 

#^## --> X2

 

#^##*# --> X2+1

 

#^##*## --> X2+2

 

...

 

#^##*#^# --> X2+X

 

#^##*#^#*# --> X2+X+1

 

...

 

#^##*#^#*#^# --> X2+2X

 

#^##*#^#*#^#*#^# --> X2+3X

 

...

 

#^##*#^## --> 2X2

 

#^##*#^##*#^## --> 3X2+X

 

...

 

#^### --> X3

 

#^#### --> X4

 

...

 

#^#^# --> XX

 

Here we observe an interesting property of the comparison. The number of hashes in the exponent is also the number of dimensions of the comparable array. We can say if we have #^$(#) where $(#) is some expression composed of hyperions, replace all of these with X and we can say:

 

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

 

Hence...

 

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

 

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

 

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

 

...

 

                    Thus Cascading-E notation has the same power as X^X^...^X arrays (tetrational arrays). In the fast growing hierarchy this is comparable to the epsilon-zero functions growth rate. The epsilon-zero structural level is in many ways an important benchmark for large number notations because there seems to be a fairly natural progression up to this point, but after it there are several variant ways to continue.

Non-commutative Property of Hash Product

                It should be noted that despite the fact the separators in Cascading-E are modeled after the notation of a "product" of terms, this does not mean they are necessarily commutative. In fact, it isn't difficult to come up with a wealth of examples where such products are non-commutative. I will provide a simple example here to substantiate the non-commutativity of hash products. Consider the evaluation of 

 

E3#^#*#3

 

  This would evaluate to:

 

E3#^#3#^#3 =

 

E3#^#3###3 =

 

E3#^#3##3##3

 

On the other hand:

 

E3#*#^#3 =

 

E3#*###3 =

 

E3####3 =

 

E3#^#4 <

 

E3#^#3#2 <

 

E3#^#3#3 <

 

E3#^#3#3#3 =

 

E3#^#3##3 <

 

E3#^#3##3##3 =

 

E3#^#*#3

 

                Thus we conclude that:

 

E3#*#^#3 < E3#^#*#3

 

                In general the best order is the one in descending order, with the most powerful cascades coming first.


What's Next...

A ton of new googolism's for our new E^ notation of course! Just continue on to the next article...

NEXT>> 4.3.5 - Cascading-E Numbers (2685 - 5109)