home‎ > ‎4.3‎ > ‎

### 4.3.1 - Foray

4.3.1
A 2nd Graders Close Encounter with the Infinite
... or How I began my foray into Large Numbers

It all began with the Infinite

My first falling out with infinity, so to speak, had to do with a certain fraction. You may recall in grade school learning that 1/3 is "point 3 repeating". This struck me however as very disconcerting. Mathematics, the one absolutely exact science, the paragon of precision, now contained a number that could not be expressed "exactly". Yes I know that 1/3 can be expressed "exactly" as a fraction, but as a kid I didn't see it that way. The decimal representation was the "true" form of number, and yet 1/3 had no such representation. Stubbornly I refused to accept this as fact. So I performed the long division on 1/3 thinking I'd prove them wrong. Well the 3's kept coming until it became abundantly clear that it could never end. Here was infinity, not as some distant entity, or abstraction for the whole of mathematics, but as something immediately present in a finite number! After this I became more suspicious of infinity, and my attention turned directly to it.

As I understood it, infinity was a number, just like any other number. Although no one explicitly said this to me, I could gather it from this fact: infinity was by definition larger than any other number. How could it be "larger than" any other number, if it was not also a number? If I imagined a number line, infinity was that number always to the right of any point I might choose on it. "Infinity" was simply the "largest number possible". Of coarse a mathematician will tell you otherwise, but everyone knows that intuitively these ideas are in the back of the mind of the laymen and child alike.

If infinity was a number however, then there had to be a way to "reach" it. That is to say, there can be no gap between the "finite" and the "infinite" and therefore there must be some way to get from one end to the other. Yet, as I knew all to well, there wasn't. No matter how far out you went infinity still seemed infinitely far away.

To resolve this, one day at home (not school!), I came up with the following thought experiment:

Imagine a number line, scaled so that infinity is a finite distance to the right of the zero. Now the question is, where are the finite numbers, and how are they "progressing" towards the infinite. Well imagine a very large finite number, N. Say for argument sake that N is ever so slightly to the right of zero. Yet if it is at all to the right, then infinity is simply a finite multiple of N, which means its finite! But this is impossible, and therefore N can not be to the right of zero at all, and must in fact overlap! But this is true of ANY finite number no matter how large, so it turns out we are not progressing at all, but standing still!

This begs the question, ... then what is all this space in the middle represent? So I considered what might the mid-point to zero and infinity be ... half-infinity? Now is half-infinity finite or infinite. Well if half-infinity is finite, then it is reachable, but then so would be infinity! Therefore half-infinity must also be infinite (unreachable)! But this will be true of any fraction of infinity no matter how small, so all points to the right of the zero would be unreachable! Thus a paradox is discovered. If infinity is a number, it is not unique in its unobtainability. Yet infinity was suppose to be uniquely unreachable!

There is another problem with this supposed definition of infinity as "the largest number possible". A friend of mine was having a argument with another kid whether or not 40 infinity was more than infinity. Perceiving me as some kind of authority on math he asked me "40 times infinity is 40 infinity right?". I decided to agree with him, but not without misgivings. You see I was well aware that 40 times infinity, is also infinity, in so far as it is just as unobtainable. I also knew that this is the answer any "teacher" would give. I therefore gave the answer I wanted to be correct. Namely, that you could have numbers greater than infinity. Yet if that's true, what precisely is it that defines infinity. Is it the "smallest" unobtainable number? But then the line argument would say that half-infinity would come first! Infinity was starting to become quite a bundle of paradoxes at this point.

Another interesting conclusion to draw from the number line experiment is that there is a sharp divide between the finite and infinite. The finite all exists on the zero, and the infinite exists everywhere else. There is no in-between state between the two, and there is no way to get from one to the other, except by "crossing the border" instantaneously. This was something my young mind could just not except. There are no gaps between numbers, so there must be some royal road to infinity? Right?!

In any case, I decided to put the issue of infinity aside for the time being to focus on other things. I became fascinated by the operations of addition, subtraction, multiplication, and division. Then I learned about another operation they weren't talking about in class, and that's where things get really interesting ...

Enter the Googolgong

Some time in second grade I got very interested in large numbers. Keeping ahead of my class in math was something of a hobby. The furthest our discussion of numbers got in math class was adding and subtracting 6 digit numbers. The highest place value, as far as the text book was concerned, was hundred thousands. However from my dad I learned about a million. I remember in the math textbook how a thousand was represented as a 10x10x10 cube. I could therefore imagine a million as a 10x10x10 cube made of such 10x10x10 cubes! I kind of began to resent the fact that a million wasn't even mentioned in class, as if it didn't exist. Later I learned about even larger numbers from a Webster's 9th edition dictionary I had at home (it was my dads). I had discovered that under the entry for number was a whole page devoted to naming numbers, including very large numbers. In it I learned that a billion was 1 followed by 9 zeroes, a trillion was 1 followed by 12 zeroes, and that the names continued in this manner with...

quadrillion, quintillion, sextillion, septillion, octillion, nonillion, decillion, undecillion, duodecillion, tredecillion, quattuordecillion, quindecillion, sexdecillion, septendecillion, octodecillion, novemdecillion, and a vigintillion

The fact that I still remember the names and spellings of all these without consulting anything is testament to the fact that I read and re-read this list many times as a kid (I told you I was obsessed). After the vigintillion, came a number which quickly became my favorite: the centillion. The centillion was 1 followed by 303 zeroes. For me the "centillion" was kind of my Googol. As a kid I never heard of the googol. It apparently didn't appear on that page with the other numbers. So for me, the "centillion" was the largest named number I knew about.

Now here is where the story really begins. I remember, it was after school, and I was outside the school with my best friend waiting for her father to pick us up and walk us home. As a kid I had an easy time talking to adults. For whatever reason, when her father came by, I began talking about what I was learning about large numbers, and I must have mentioned a centillion, but I really don't remember anything I said. What I do know is that her father than told me about a very mysterious number that completely captivated my imagination. He told me that scientists had come up with some phenomonally large number called a "googolgong", which was something like 1 followed by a 100,000 zeroes! I was floored. The name envoked an image of a giant gong, so large that when hit it would chime for a googolgong years. I wondered what curious experiments the scientists must be working on to have need for such a large number. Having been thinking about large numbers recently, this revelation brought out a competitive streak in me. If "scientists" had come up with a googolgong, I was going to come up with even more unfathomable numbers!

Before I continue I should note that, there never was, or has been, such a number as a googolgong. There is a "googol" and a "googolplex", but not a "googolgong". I did not know it as a kid, but I had just been given some rather shoddy information. The number he probably meant was a googolplex, which is not 1 followed by 100,000 zeroes, but 1 followed by "1 followed by 100 zeroes" zeroes, which is A LOT LARGER! Furthermore, "scientists" didn't come up with it, a single mathematician did. It's rather absurd to think that scientists, those ever practical empiricists, would ever bother to name a very large number just for the sake of it! Even pure mathematicians seem to think its impractical (though they dabble in it none the less).

In any case, the stage was now set for me to return to my former quandary with infinity. Armed with the centillion, and the googolgong, and more importantly, the key to their construction, I was ready to build my own tower of babel, to reach the heavens!

Entering The Stargate

At the time that I had learned about the so called googolgong I had also known about the operation of exponents, and scientific notation. Scientific notation (S.N.), was of particular interest to me, because I could write really huge numbers like:

1,000,000,000,000,000,000,000,000,000,000,000

as something as compact as 1x10^33. It was clear that this was the most powerful tool in my mathematical tool box for generating large numbers, and so I began to experiment with them. That is, write such expressions out excessively instead of paying attention to class :)

It was around this time that I concieved of writing a treatise for myself. The idea was this. I was going to find out the "exact" value of infinity, by naming a finite number so large, that it was infinite. Absurd? I didn't care. I was fed up with all this infinity nonsense, and I was determined to resolve it once and for all. This treatise (or book as I would have called it) would be kind of journey. It would be titled "From One to Infinity" and would consist of starting from the beginning with 1,2,3 and then continuing on at an ever faster and faster pace until reaching infinity at the "end" of it. It was a futile notion from the getgo, but I probably sensed that to some extent. Was all this just an elaborate excuse to explore numbers MUCH MUCH larger than a googolgong, and thereby reach numbers larger than even the scientists ever dared to contemplate? Perhaps. But my obsession was as much fueled by a desire to "fill out" the infinite as it was to inflate the finite. Afterall, what fun is infinity without a little perspective, and that's precisely what large numbers provide.

So I soon began writing my treatise in ernest on a stack of stapled copy paper my dad got from work. Sadly (for me at least), I have no idea whatever happened to that stack of paper. Finding it would be like finding the holy grail for me, but its probably lost for good. The good news is I remember pretty well its contents.

After the perfunctory material dealing with numbers up to a million, my work quickly got up to speed on what I already knew about large numbers.

After the centillion it was clear what needed to be done. I would simply begin by adding more and more zeroes. But rather than write these numbers out in full, I could write them in Scientific Notation.

Thus one could go along with a progression like...

10^303 ... 10^1000 ... 10^10,000 ... 10^100,000 ... 10^1,000,000 ... 10^10,000,000 ... 10^100,000,000 ... ...

But why stop there? True 10^100,000,000 is extremely huge, much much larger than a googolgong, but its still finite. Why not have 1 followed by a billion zeroes! Or 1 followed by a trillions zeroes, or a quadrillion, quintillion, ... 1 followed by a centillion zeroes!

This would be 10^10^303 resolved from right to left. On the paper I would have written this in superscript notation as:

303
1x10
1x10

This was a number I had previously contemplated. It is written on the back of the same paper where I came up with names for all the powers of a thousand from a thousand to a centillion (See 2-4-3 : Saibian's old style -illions ). Having no real good ideas I called this number a "centillionillion". It was clear to me that if "1 followed by X" was the best paradigm for creating large numbers, then the best thing to do was plug in the largest number I could imagine for X. Thus a 1 followed by a centillion zeroes, was like the ultimate rebuttal to the googolgong. Now there WAS a unfathomably huge number! Yet it would still have to be finite (since I could reach it). Furthermore, it wasn't the "largest number", so couldn't be infinity. For I could have 1 followed by a googolgong zeroes!

100,000
1x10
1x10

It was clear what would happen next. I could continue with...

10^10^10^303

10^10^10^100,000

10^10^10^10^303

10^10^10^10^100,000

10^10^10^10^10^303

10^10^10^10^10^100,000

...

And gradually the stack would grow. A favorite large number of mine around this range is...

10^10^10^10^10^10^10^10^10^10

That's a power tower of 10s 10 terms high. Try imagining how large THAT is! A googolgong just can't compare.

But now what? What is to be done next? It is at this point that scientific notation itself has become unwieldy. This was about as far as I had gotten with idyll thoughts before working on my treatise, and now I was faced with the dilemma of where to go from here. This is where I actually get creative and discover something for myself for the first time...

IT'S FULL OF STARS!
Beyond Scientific Notation

Having reached an impasse on my way to infinity I stopped to retrace my steps. I considered what had happened.

I began by increasing the exponent in Scientific Notation indefinitely, beginning with 10^303. As the exponent got larger and larger eventually it got so large that it was no longer convenient to write it out in full as in ...

10^1,000,000,000,000,000,000,000,000,000,000,000

At that point the exponent becomes so large, that it itself can be expressed in Scientific notation!

10^10^33

Eventually this second exponent runs into the same problem, and becomes scientific notation. The result is a "stacked scientific notation".

I observed that scientific notation had served as a short hand for decimal representation. Whenever an exponent had become unwieldy in decimal it could be converted into S.N. But now the entire expression was becoming unwieldy as in:

303
1x10
1x10
1x10
1x10
1x10
1x10
1x10
1x10
1x10
1x10

The solution? A new shorthand, beyond scientific notation was needed to simplify these new kinds of expressions! This new shorthand I referred to as "Scientific notation notation". Admittedly I wasn't very good with names, but in my defense I wasn't all that interested in names, and was more interested in finding ways to make larger and larger numbers. A better name might be "Stack Notation" or "Super Scientific Notation".

So what was this "2nd stage notation"? Well I realized that the only salient information for the construction of my "stacks" was the number being repeated, the number of times it was repeated, and what the number at the top of the stack was. The number being repeated, which we can call the "base" was then inscribed in a square. This number was invariably "10" but I understood that I could choose any base, even though I was technically extending scientific notation. The number of times the base was repeated in the stack, which we can call the "replicator", was inscribed in a rectangle situated to the right of the square. Lastly the top exponent, which we can call the "determinant", was inscribed in a triangle to the right of the rectangle. The example number above which is a stack of 10 10s topped off by 303 would then be written as:

This was, for me, an unexpected discovery. I hadn't expected my exploration of large numbers to lead to completely new ways of expressing them, but it made a lot of sense. Without this handy shorthand, the large numbers would just grow rapidly out of control and out of sight. If I was going to reach infinity in any intelligible way I couldn't let the numbers run off without me.

I also recognized that there was a trade off that occurred with the new notation. Just as S.N. allowed one to describe very large numbers, at the cost of precision, so too "Stack notation" would allow one to express even larger numbers with an even more drastic loss of precision. Precision, as I understood it, was the space between the numbers you could express.

For example, in scientific notation, if we restrict ourselves to an exponent without a multiplier, then the difference between 10^79 and 10^80 is very vast. However this pales in comparison from the difference from say " 10, 9, 303" in stack notation, and "10 , 10 , 303 ". For convenience we can use the following ascii form for stack notation:

[base][replicator]<determinant>

This notation is very powerful, and makes it very easy to express some phenomenally large numbers. For example:

[10][100]<303>

This is a stack of a hundred 10s with a "determinant" of 303 on top. This number could be understood in this way. Let "centillion" be the first level. The 2nd level is 1 followed by a centillion zeroes, the 3rd level is 1 followed by the 2nd level zeroes, the 4th level is 1 followed by the 3rd level zeroes , ... and so on until you reach the hundredth level!

The "replicator" is the source of the notations greatest power, just as the exponent was the greatest source of S.Ns power. So just as I increased the exponent without bound in S.N. I was now prepared to increase the replicator without bound in Stack Notation (StN).

Therefore we might continue with:

[10][1000]<303>

[10][1,000,000]<303>

[10][1,000,000,000]<303>

[10][1,000,000,000,000]<303>

...

Eventually the replicator becomes too long as a decimal, so we switch to S.N.

[10][10^15]<303>

[10][10^18]<303>

...

[10][10^303]<303>

...

[10][10^1000]<303>

[10][10^10,000]<303>

[10][10^100,000]<303>

...

Next the exponent in the S.N. would become unwieldy and would itself be replaced by S.N.

[10][10^1,000,000]<303>

[10][10^10^9]<303>

[10][10^10^12]<303>

...

[10][10^10^303]<303>

...

[10][10^10^100,000]<303>

...

Now the 2nd exponent would eventually require S.N., and then the third and so on...

[10][10^10^10^303]<303>

[10][10^10^10^100,000]<303>

[10][10^10^10^10^303]<303>

[10][10^10^10^10^100,000]<303>

...

Finally the S.N. would become unwieldy with all the levels of embedded exponents and we would replace it with ... stack notation! That's right, we can have stack notation within stack notation!

It should be obvious what's next. Now stack notation will repeatedly embed into itself recursively just as S.N. did before!

[10][ [10][10]<303> ]<303>

...

[10][ [10][ [10][10]<303> ]<303> ]<303>

...

[10][ [10][ [10][ [10][10]<303> ]<303> ]<303> ]<303>

...

The visual effect of this is identical to when two mirrors are faced towards each other. In a sense, the very same process is occurring in both cases. "Recursion" is essentially a feedback loop, in which the output of a previous cycle becomes the input for the next. Thus we plug some number into the replicator, which generates a huge number which we plug into the replicator to get an even more tremendous number and so on...

Note the complexity at this point. It's not as clear what is going on as was the case when we simply had stacked exponents. What is the next logical progression after this?! You might think a kid might have had his fill at this point, but I wasn't ready to give up yet. I had already gone way further than I could have imagined. This was alien math, the likes of which I had never seen or heard before. Yet it was not incomprehensible. I knew that by virtue of achieving such olympian heights, they could not be infinite, else I could not have reached them. Therefore I would have to press further. But how? I knew that I was at the cusp of an even more profound revelation, because I could already sense the beginnings of an even grander pattern...

Monolith Hotel
The Grand Hierarchy of the Finite

If you have been following the development up to this point then you probably realize that what is needed at this point is a "3rd level notation". One that would simplify that multi-embedded Stack notation, just as it simplified the stacked scientific notation. This I would have called "Scientific notation notation notation". For reasons that will become clear, I now refer to it as "Diamond Notation" (DiN).

Here's how I got past the last injunction. Note that the key feature of the last few numbers we defined, is the 3 arguments in the innermost expression, and its depth. The "depth" becomes our 4th argument. The 4 arguments can then be written within the sections of a diamond. I am not a 100% sure how these arguments were originally arranged, though I am absolutely sure that the upper right corner was reserved for the "depth" argument. My guess is that they were ordered, as established in the previous notation by going clockwise from the bottom right corner. Therefore the "base" is written at the bottom right, the "replicator" at the bottom left, the "determinant" at the top left, and the "depth" or "2nd replicator" at the top right. The last expression could therefore be simplified as:

The "4" , highlighted in orange, tells us how many times StN is plugged into itself. Let's define the following ascii form of DiN:

/d | r2\
\r | b/

where b=base, r=replicator, d=determinant, and r2=2nd replicator.

Now we can say that:

/303|  1\
\10  |10/       =        [10][10]<303>

/303|  2\
\10  |10/       =        [10][ [10][10]<303> ]<303>

/303|  3\
\10  |10/       =        [10][ [10][[10][10]<303>]<303>]<303>

/303|  4\
\10  |10/       =
[10][ [10][[10][[10][10]<303>]<303>]<303>]<303>

etc.

The 2nd replicator indicates how many layers there are. It also tells you how many times each of the arguments (except for the 1st replicator) is repeated. Thus there are 4 10's, one for each base in each of the 4 StNs, and also 4 303s for each determinant. In the center rests the initial value of the 1st replicator.

When I first came up with diamond notation it was like stepping into another dimension. I couldn't even visualize the numbers anymore as stacked exponents. The stack would itself now need to be described by a diamond class number, so it becomes meaningless. It was as if all the familiar surroundings had vanished, and all that was left was this ominous mathematical machine. The numbers in the cells stare blankly out at you, but at this point their meaning escapes you. It actually takes an effort to understand what these numbers represent. They, collectively, describe an EXTREMELY LARGE NUMBER. A googolgong is now an infinitesimal dot in comparison to something like a "10,10,303,4" diamond. Were now working with numbers that would even boggle the minds of scientists. Yet let us not forget the axiom: "Whatever you can reach by finitary methods, is itself a finite number". So we must press forward, because we still have a long way until we reach infinity. Yet at this stage, the road is already paved, before we've layed a single stone. This is one of the paradoxical features of generating large numbers. You are as much being lead as leading the way. There is a kind of logic to it, and that logic leads you in a particular direction. Disobey that logic and your liable to get hopelessly lost within the tangled detours on the interstate infinity.

So let us follow the logic. Just as it was the exponent (determinant) that mattered in S.N., and the replicator that mattered in StN, it's the 2nd replicator that matters in DiN. Therefore we begin by increasing 4 without bound and seeing where this leads us. First the number will increase until it is unwieldy in decimal. It can then be converted into S.N. Eventually the exponent in the S.N. will become unwieldy and we will need to substitute it with S.N. Next the multi-embedded S.N. will become unwieldy, at which point we can substitute it for StN. Of coarse this too would eventually become multi-embedded and unwieldy, and would the 2nd replicator in DiN would itself be replaced by DiN. Eventually, just as S.N. and StN, DiN would become a multi-embedded nightmare...

/303| 5\
\10 | 10/

/303 | 10\
\10  |  10/

/303 |100\
\10  | 10/

/303 |1,000,0000\
\10        |       10/

/303 |10^33\
\10     |    10/

/303 |10^303\
\10      |    10/

/303 |10^100,000\
\10            |    10/

/303 |10^10^303\
\10            |    10/

/303 |10^10^10^303\
\10             |        10/

/303 |[10][10]<303>\
\10           |        10/

/303 |[10][[10][10]<303>]<303>\
\10               |                     10/

/303 |[10][[10][[10][10]<303>]<303>]<303>\
\10               |                                     10/

You can imagine zooming in as many levels as you like through the embedded DiN. Yet this will not get us to infinity, no matter how many levels we go inward (save infinity itself). By now the pattern should be clear. We need a 4th notation, which takes the 4 arguments of DiN, and adds a 5th, representing the "diamond depth". That is, we need a 3rd replicator. At this point I recognized that you could keep creating new notations, and each notation would require one additional argument from the last.

As I envisioned it, the next step was to break up a pentagon into 5 triangles. For consistency we can say that for every notation after DiN, we choose a polygon with the same number of sides as the number of arguments required. The newest argument will be listed in the upper right corner, and a corner of each polygon will always point upwards. Thus we could have something like:

Which would be a "10,10,303,10" DiN embedded 5 times. We can call this "5-Cell Notation" (5cN) because it contains 5 "sections" or "cells".

Now the "5" can become any number we can imagine. The largest number we have however is, "10,10,303,10,5" 5cN, so we can plug this into the 3rd replicator to obtain an even more unimaginable number. Again we can have embedded 5cN and next create a 6 argument notation. Each notation can then be embedded to form the basis for the next notation. Note that each notation represents a quantum leap, and represents a completely different league of numbers than the last! Thus we now have a hierarchy towards the infinite! The notations can continue in logical sequence:

Collectively we can refer to this as the Poly-Cell Hierarchy (PcH). A "Cell" here refers to the wedges where the arguments are stored. For every counting number, there is a corresponding notation with that many cells. Taking the whole sequence into perspective we can now think of Decimal Notation (D.N.) as a single argument notation. Scientific Notation (S.N.) can be treated as a two parameter notation, with a base, and a determinant. Stack Notation (StN) is simply the next step in the process, which continues with Dimond notation (DiN), 5-Cell Notation (5cN), and beyond all the way to infinity! For me, this was a kind of royal road to infinity. While I had stumbled upon numbers of unimaginable magnitude, MUCH MUCH greater than I ever thought I would find, I was beginning to really wonder about this reaching infinity bit. While the numbers were growing faster and faster, I none the less had the disconcerting feeling of infinity getting further and further away. Anybody who has explored large numbers with any diligence probably knows what I'm talking about. As one becomes more and more aware just how large some numbers are, it becomes apparent that much much larger numbers must also exist, and even larger ones after that! The journey to infinity is not a plodding affair. If one truly strives to create the largest numbers they can imagine, then one finds oneself accelerating towards infinity, and yet still getting nowhere!

STAR CHILD
Accelerating Towards the Infinite

The journey had been fun, but it was now time to come to some sort of conclusion. Was I going to reach infinity or not? And if so, how? After describing diamond notation in my treatise, I began to consider how I might continue. I remember that I was visiting family at the time, and I decided to go out for a walk in the neighborhood by myself to contemplate reaching infinity. It was a sunny day, and I was in the country, and I had plenty of time to think in leisure. So I imagined a great procession of notations, beginning with scientific notation, followed by Stack and Diamond Notation, and continuing out to infinity with polygons of ever more sides. I realized that as the number of sides increased to infinity, the wedge shaped cells would become so thin that it would become virtually impossible to write numbers inside of them. Essentially the notations would become untenable. How was I going to reach infinity then, if I couldn't even write out these numbers? Well even though I could not write them out, I could still imagine them. Why couldn't I have something like 100-Cell Notation, or million-cell, or centillion-cell, or googolgong-cell etc. I could let the "determinant" be 303, and let all the other entries be 10.

So I thought something along these lines: Imagine some tremendously high notation, say googolgong-celled, for argument sake. This would describe an unimaginably giant number. Now have THAT NUMBER OF CELLS! But wait that makes an even more tremendous number, so that you can have that many cells, and so on. But intuitively I already recognized that this was a sequence (a recursive one actually), and with any sequence I could "jump ahead" to any member of that sequence that I could imagine. So Now imagine some very large number, M that I could generate in the previously described way, and then go M steps up the sequence formed by repeatedly plugging back into the number of cells! That would by necessity form another sequence, beginning with M, then going M steps, then going "M steps" steps, and so on. Thus a second sequence would be formed. But for any sequence I can plug a number back into the sequence, forming another sequence and another and another! Faster and faster my mind raced, but I'd have to go EVEN FASTER to reach infinity. I was almost there; just a little FASTER!

Now these sequences would themselves form a sequence of sequences! But then this super sequence could be plugged into itself to form another sequence and another and another, thus forming a 2nd super sequence, a 3rd super sequence, but this WAS ALSO A SEQUENCE! SO there must be a sequence of sequential sequences! This just forms another sequence which just gets us into more levels of the entire process, and so on and so on ... and no sooner did my mind race through this unfathomable progression than the numbers escaped from my grasp and shot off towards some unknown place.

So I'd begin again, and again, but no matter how many times I tried, I just couldn't keep up with all the recursive sequences that rushed into my head. In order to reach infinity I'd have to rush past all of those sequences at virtually infinite speed! It was hopeless. So profound was my stubborness however that I tried to cheat myself into believing that I could imagine it. The sequences would just rush faster and faster until it instantly all would become clear: The pattern behind the infinite. The pattern that was leading me down these divinely inspired mental paths. So "I had reached it", I told myself. But I couldn't help the nagging feeling that I hadn't. Infinity, it would seem, is far far too complex for any human being to fully understand. Just as I was forced to begrudgingly accept defeat with 1/3, and with my infinite number line, I again had to admit that I hadn't succeeded in doing the impossible. Only in making it more clear to myself that it probably was.

It's hard for me to completely appreciate how I understood infinity then. To me, infinity was not some abstraction, it was a reality. It seemed entirely believable that it existed somewhere out there on the other end of infinity. And since it existed at the other end it seemed that there should be some bridge to cross over to it. Yet I now look at this paradox very differently. It is the product of a human imagination which longs to hold to contradictory positions at the same time. If I was going to insist that the definition of infinity was "the unreachable" how could I also insist that it could be reached? It's a simple contradiction, but one I was either unwilling or unable to acknowledge. Was I foolish in my attempt? I don't think so. Yes I could have just accepted the conventional wisdom, but then what would I have really learned? One really only understands something properly once they've experienced it. Most peoples concept of infinity is one of tedious progression. Forever adding one. But I now had a radical new perspective on infinity. One could in fact accelerate, ever and ever faster, and still never reach infinity. Large numbers don't progress in an orderly procession from one size to the next. Instead each new large number completely transcends the old, so that the new becomes inexpressible except in its own arcane language.

That day in the country I had tried to "imagine infinity" I decided to take a break from this Large Number business, having thoroughly exhausted my imagination. There was a cartharsis in this. None the less, I was not completely satisfied. I promised myself to return to this topic again one day, when I was more ready to tackle its complexities.

Although I thought about writing a "new edition" of my book over the years, and revisiting the topic of Large Numbers many times as I was growing up, I always kept postponing it as I was absorbed in many other interests.

It was only ten years ago that I finally made a serious return to Large Numbers. What I have learned since then has been even more of a revelation than my childhood excursion...

Next I will present a modern version of my Poly-Cell Notation, Called Hyper-E Notation, and a upgraded version called Extended Hyper-E Notation which allows me to define numbers I was only vaguely able to describe as a kid, as well as an entire naming scheme that extends the googol series using Hyper-E and Extended Hyper-E.

Poly-cells: A Modern Understanding

In my exploration of higher sequences of the Poly-Cell Hierarchy I realized that I had passed up
Graham's Number along the way! Graham's Number is often treated as the "Largest Number", because it is listed in the Guinness book of world records as the largest number ever used in a professionally recognized mathematical proof. But consider this: If even a 2nd grader could come up with numbers exceeding Graham's Number, how large can it really be in the scheme of large numbers? In fact, there is reason to think of "Graham's Number" as one of the smaller large numbers, when compared to how far one can really go with such things.

It turns out that Poly-Cells fit in among a class of well known large number notations, including, the Ackermann function, Knuth up-arrows, Steinhaus Polygons, and the Graham's function. I could also argue that I made my way through the first couple arguments of Chain Arrow Notation, although I have no definite way of knowing
exactly how far I got since I have no written record of my thoughts at the time. Poly-Cells are similar, but not identical to any of these notations. Therefore, I present it as a new notation for expressing large numbers.

The Poly-Cell notations however are cumbersome, and the definition just presented in the previous article is very informal. I basically expected intuition to guide understanding. Having learned a great deal more about large numbers, and large number notations than I knew back then, I eventually attempted to formalize my large number system, and find a better notational form. Let me now present a modernized version of my Poly-cells.

Essentially what "poly-cells" represents is a function that can take any number of arguments. Rather than fitting them into "cells" we can simply list the numbers out from left to right, and have them separated in some manner. I've used a few different forms over the years, but I've finally settled on a modern form that I think is very appropriate. In fact, I think my former self would be kind of annoyed I didn't think of it sooner :)

Since my large number system began as an extension of scientific notation, it seems fitting that the modern form should be directly related to this. On some calculators, a special form of Scientific Notation, known as "E Notation" is used. Basically we have the definition:

m E n = mx10n

"E" here stands for exponent. The number to the right of E specifies what power of ten to multiply the number on the left by.

For our purposes we can drop the number to the left and let En = 10n. In stack notation, I had originally allowed for an argument to specify the base. To allow for base changes we can use the following notation:

Ebd = E[b]d = bd

Ed = 10d

Alternatively we can simply use the notation b^d, for a base change. The b^d notation has become more standard than the E[b]d  notation because parentheses " ( ) " are often used for both arguments and delimiters in ExE and because the square brackets " [ ] " are used frequently for denoting the nth member of a fundamental sequence. One consequence of this definition is that 10^d may be used instead of Ed. When "b" (base) is not specified, it is 10 by default. In stack notation, recall that the order of the parameters was "base", "replicator", and "determinant". Although this order made sense to me at the time as it read "base b repeated r times with d at the top", it turns out that this breaks a very nice symmetry that is useful in defining the poly-cell in a recursive fashion. The order of arguments, as a general rule, should always be in either ascending or descending order of power. The "base" is the least powerful argument, and so remains as the first. The "determinant" or top exponent however, is more important than the base, and so goes second. The "replicator" goes last however because it plays the most significant role of the 3 arguments in determining the size of the result.

So I now establish the following modern form for Stack Notation. Let:

E[b]d#r = [b][r]<d> = b^b^b^ ... ^b^b^d (w/r b's)

One advantage of this new notation, is that we can remove the first parameter if it's a ten. We can also remove #r when r=1. Thus we can say...

E303 = 10303 = centillion

E303#2 = 1010^303 = 1 followed by a centillion zeroes

Now for each additional argument we want to add, we can simply add another "#" followed by the next argument. Thus we can say that diamond notation can be simplified as follows:

/ d  | r2 \

\ r1  | b  /  =   E[b]d#r1#r2

Alternatively we may write...

< b | d | r1 | r2 >

Notice that, unlike poly-cells, we don't run into a problem of the numbers being squeezed between infinitesimal wedges. All we have to do is increase the length of the expression to add arguments.

I call this modern form "Hyper-E Notation" (written E# for short). The "#" is known as the thorpe, hash or pound symbol in common usage. For the purposes of E# it will be known as either the

hyper mark, or hyperion.

With this basic form established it becomes much easier to define my multi-argument function. Here is a formal definition for E#:

Def. HYPER-E NOTATION (E#)*

Ea1#a2#a3# ... ... #an
where a1~an = Z+ and n = Z+:

1.
if n = 1 ; Ea1 = 10^(a1)

2.
if an = 1 ; Ea1#a2#a3# ... ... #a(n-1)#1 = Ea1#a2#a3# ... ... #a(n-1)

3.
Ea1#a2#a3# ... ... a(n-2)#a(n-1)#an = Ea1#a2#a3# ... ... a(n-2)#(Ea1#a2#a3# ... ... a(n-2)#a(n-1)#(an -1))

* Note that the zeroth argument, known as the base, has been omitted in the above definition. This is for the sake of simplicity. However, if the base, b , is any value other than 10, simply replace rule 1 with E[b]a1 = b^(a1)

If this sort of thing is unfamiliar to you it might seem complicated. This is simply the formal way of expressing the intuitive idea expressed with my poly-cell notation.

To understand how the above definition works, first understand that it is an algorithm. That is, it is a set of instructions for how to convert an expression in Hyper-E into ordinary numbers.

There are 3 rules used. If your given a E# expression, you first check to see if rule 1 applies. If it does not you check for rule 2. If that doesn't apply you go to 3. Once a rule has been applied, you check to see if the result is an ordinary numerical expression. If so, then your done. If not, then you must go through the list of rules yet again, and again until you reach a final "number".

This is the basic way I'll be defining all of the recursive functions in this chapter.

Note the basic form of the definition. First a expression type is presented. Then the variables within it are specified for specific values (usually counting numbers, though occasionally whole numbers are preferable). The rules are then written with the condition first. After the semicolon is a transformation. You will always take the left side of the equation and substitute it with the right side.

Here is the above definition in plain English:

Rule 1
says if you have one argument, raise 10 to that number. Ed = 10d

Rule 2
simply means, if the E# expression contains two or more arguments, and the last argument (called an) is equal to 1, then you can drop it. For example E303#1 = E303.

Rule 3
is the interesting rule. Basically if you have two or more arguments, and the last argument is greater than 1, then take the entire expression, chop off the last argument, and substitute the entire expression with the last argument decremented by 1 into the second to last argument. An example would be E303#4 = E(E303#3). Note how the "303#4" at the end was replaced by "E303#3". This is almost identical to the original expression, except the last argument is decreased by 1.

To help you better understand how this works, and example is usually best. Let's begin with a simple example:

E303#3

So we check rule 1. It applies only if n = 1. However in this example we would say n = 2. Therefore rule 1 does not apply. Does Rule 2 apply? No because the last argument, an
, does not equal 1. Therefore Rule 3 must apply. Just so you know, the last rule never has a condition. It's condition is simply that it applies when none of the others apply. Therefore the last rule is kind of the "default rule". The others are special cases.

So rule 3 tells us to drop the last argument "3", and replace "303" with the original expression with the last argument decremented by 1. Thus we have:

E303#3 = E(E303#2)

Now we bring our focus, not to the entire expression "E(E303#2)", but only to the portion in red. The reason is because we now have the E#N embedded into itself. The outer layer however can not be resolved until we figure our what E303#2 is first.

So again, does rule 1 apply. No. 2. So again we apply rule 3:

E(E303#2) = E(E(E303#1))

We again resolve the red portion first. Rule 1 doesn't apply. This time 2 does however, because the last argument = 1. Rule 2 tells us to simply discard this 1. Thus we have...

E(E(E303#1)) = E(E(E303))

The inner most E# expression is now E303. This means that rule 1 applies. Thus E303 = 10303. This implies:

E(E(E303)) = E(E(10303))

We now can resolve the next E# expression, E(10303). Again rule 1 applies:

E(E(10303)) = E(1010^303)

Finally we apply rule 1 to the final expression and obtain:

E(1010^303) = 1010^10^303

Now recall that E303#3 = [10][3]<303> and by definition [10][3]<303> = 1010^10^303. Thus our formal rules are able to provide a definite way to construct any such expression.

The interesting thing about this set of rules is that it doesn't apply to just one poly-cell notation. It applies to them all. This is possible because the same basic trick was being used to construct each notation from the previous notation.

Comparison with FGH

So just how strong is E#? Since E# diagonalizes over exponentiation using an arbitrary number of primitive recursions it is not unreasonable to conclude that E# is not primitive recursive, and is therefore loosely speaking of the same order as f_w(n). Informally this means that if we created a function: E#(n) = E100#100#...#100 w/n 100s, it would grow faster than every function in FGH below f_w(n), and be of roughly the same order as f_w(n) itself. More formally we say E# is of order-w, and by this we mean that for every function in FGH below f_w(n) there is a function in E# which grows at least as fast and that f_w(n) is the first member of E# to eventually dominate every function in E#. This can be formally demonstrated. For those who are willing to delve into the more technical details you can see a full proof of this claim here.

Comparison with BEAF

[coming soon]

Extended Hyper-E Notation

xE#

Now with a modern definition and notation we can experiment a little and create some interesting large numbers...

But what about describing the kinds of numbers I was only able to "imagine" as a kid? The one's that would have a googolgong arguments or more.

After some experimenting a little, I found a fairly natural way to extend Hyper-E notation to describe numbers of this kind. This requires a new notation known as "Extended Hyper-E Notation". This goes beyond what could be expressed with poly-cells.

The key difference with Extended Hyper-E Notation (xE# for short) is that we can now use multiple
hyperions between arguments, instead of just one. The more hyperions between the arguments the more powerful the effect. The best way to understand how Extended Hyper-E Notation works is to begin with the following new definition:

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

The "double-hash" , "##", is a new separator I refer to as the deutero-hyperion. It can be used to compactly express prohibitively long expressions in ordinary Hyper-E Notation. For example, if you wanted to compactly express having a googolgong 10s in Hyper-E Notation you could simply write:

E10##googolgong = E10#10#10# ... #10#10#10 w/googolgong 10s

Of coarse this is rather limited. For example, how would we express numbers in which the number of arguments in Hyper-E Notation were feed back into itself repeatedly? The trick is to recycle the rules from ordinary Hyper-E and apply them in as natural a manner as possible. Single hyperions, which we can retroactively call
proto-hyperions, will still operate on the last two arguments in the previously defined way. So for example:

E10##googolgong#2

[via E# Rule 3]

= E10##(E10##googolgong#1)

[via E# Rule 2]

= E10##(E10##googolgong

= E10#10#10# ... ... #10#10#10 w/(E10##googolgong) 10s

[via new xE# Rule]

The end result is a Hyper-E expression with as many 10s as a Hyper-E expression with a googolgong 10s. Sound familiar? We can now repeatedly plug in the number of arguments into itself by simply changing the last argument. So E10##googolgong#3 would be E10#10#...#10#10 w/ E10##googolgong#2 10s, E10##googolgong#4 would be E10#10#...#10#10 w/ E10##googolgong#3 10s, etc.

We needn't stop there however. We can add additional arguments, separate them with

proto-hyperions, and still use nothing but the original Hyper-E rules. Each additional argument will feed-back the previous entry into itself. This is equivalent to creating a new sequence by feeding the previous sequence into itself. Here are some examples:

E10##googolgong#1#2 = E10##googolgong#(E10##googolgong)

E10##googolgong#1#1#2 = E10##googolgong#1#(E10##googolgong)

etc.

To go even further we can apply the deutero-hyperion trick again, to shorten a series of

proto-hyperions after the first deutero-hyperion. For example:

E10##10##googolgong

E10##10#10#10# ... #10#10#10#10 w/googolgong 10's after "##"

We can cut to the chase, and it should be obvious that eventually we'll have a string of

deutero-hyperions. For example:

E10##10##10##10##10##10##10##10##10##10

To truncate these kinds of expressions, we simply create a "triple-hash separator", which I call a trito-hyperion, that will compactly express strings of deutero-hyperions, just as deutero-hyperions compactly expressed strings of proto-hyperions. So let:

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

We could continue this indefinitely, allowing for any number of hyperions in a row, always expressing strings of one less hyperion. How can we efficiently describe how this works in general?

It turns out that with the addition of just one more rule to how Hyper-E Notation works, we can turn it into Extended Hyper-E Notation (xE#). This notation allows for arbitrary strings of hyper marks, "###...###", between arguments.

The rule is fairly simple to explain. Let "@" represent the beginning portion of an E# expression. Assume that the last argument is preceded by two or more hash marks. Let "p" be the last argument, and "b" be the 2nd to last argument. Now apply the following transformation:

@ b ##..## p (w/x #s) =

@ b ##..# b ##..# b ##..# b ... ... ... ... b ##..# b (w/p "b"s & x-1 #s between them)

This rule can be defined recursively. Let #x = ###...### w/x #s. We can then say:

@b#xp = @b#x-1b#x(p-1)

@p##..##1 = @p

E10#10#10#10#5#5#5#5#3##6

Normally in E# we use rule 3 when the last argument is greater than 1. However, when the number of hash marks preceding it is greater than 1 we must first "expand" the expression. To do this simply ignore the rest of the expression ( referred to by the "@" in the above rule). Instead focus on the last two arguments, and have the second to last argument repeated a "last entry" number of times, separated by "hyper-strings" with 1 less hyper-mark. Therefore:

E10#10#10#10#5#5#5#5#
3##6 = E10#10#10#10#5#5#5#5#3#3#3#3#3#3

Just to be clear, the deutero-hyperion is not to be understood as some sort of short hand for repeat arguments anywhere within the expression, only at the end! Therefore:

E10##4#5##4#3##6 != E10#10#10#10#5#5#5#5#3#3#3#3#3#3

Instead only the first part "3##6" would be expanded in this manner. Only once the single marks have resolved to a single value, becoming the new last entry, can the next hyper-string be resolved. ie:

E10##4#5##4#
3##6 = E10##4#5##4#3#3#3#3#3#3 =

E10##4#5##
X (end of expression is resolved to X) =

E10##
4#5#5#5#5#5#5# ... ... ... ... #5#5#5#5#5 (w/X 5s)

E10##
X2 = E10#10#10#10#10#10#10# ... ... ... ... #10#10#10#10#10#10#10#10#10 (w/X2 10s)

Just so you know, this explanation may make it look like expanding E10##4#5##4#3##6 is a simple matter. In actuality it is physically impossible! X is itself an unimaginably large number (though necessarily smaller than the original expression), and X2 unimaginably more so. Even with two sets of deutero-hyperions, it would be impossible to expand it out into a simple E# expression with only proto-hyperions!

Although you should now have the general gist of how Extended Hyper-E Notation works, it is best to use a clear instruction set that generalizes the process to a few simple rules. The only time Extended Hyper-E Notation differs from ordinary Hyper-E notation is when there is more than a single hyperion between the last two arguments. This simply becomes an additional rule that we can insert in our previous rules. We will however have to come up with some additional notation to easily express these rules. Let:

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

And to simplify transformations let @ be any portion of the xE# expression we want to omit for brevity. With this in mind, here is a definition for Extended Hyper-E Notation:

Def. EXTENDED HYPER-E NOTATION (xE#)*

Ea1#h1a2#h2a3#h3 ... ... #h(n-1)an where a1~an , h1~h(n-1) = Z+ and n = Z+:

Let b = an-1 , p = an , and x = h(n-1)

1.
if n = 1 ; Ep = 10^p

2.
if an = 1 ; @#x1 = @

3.
if h(n-1)>1 ; @b#x p = @b#x-1 b#x(p-1)

4.
@b#p = @(@b#(p -1))

* Note that the zeroth argument, known as the base, has been omitted in the above definition. This is for the sake of simplicity. However, if the base, b , is any value other than 10, simply replace rule 1 with E[b]a1 = b^(a1)

So Extended Hyper-E notation can be defined with only 4 rules. Already our notation looks fairly technical. Just try not to let that phase you. In isolation each of the terms is fairly simple, its only all together that it appears complicated looking. The upshot of this is that although it seems complicated, it describes the rules of expanding an Extended Hyper-E expression in no uncertain terms.

Comparison with FGH

[Coming Soon]

Comparison with BEAF

[Coming Soon]

Conclusion

Now that we actually have a fully functioning notation for large numbers let's forge a ton of googolisms with it...

In the next article we do just that, starting with the E# numbers...