3.1.4. Poly-Cell and Hyper-E Notation

(back to 3.1.2)

Introduction

If BEAF is the most well-known of the Internet large number notations, then in second place probably falls Sbiis Saibian's Extensible-E (ExE) System. It's a large number notation much to the likes of BEAF, divided into subsystems each more advanced than the previous, but with a far greater amount of googolisms to its name—over 15,000, in fact. Just like we've spent the past few articles learning about Bowers' linear array notation (the first subsystem of BEAF), today we'll learn about Hyper-E notation (E#), the first subsystem of ExE. And just as we spent a good deal of time looking at the backstory of Bowers' legendary notation, we'll go into heavy detail on the origin of Saibian's system, which started as the adventures of an imaginative little second-grader.

Part 1: Poly-Cell Notation (Sbiis Saibian's childhood googology)

The Backstory: Googolgongs and the Path to Infinity

It all started when Sbiis Saibian was a second grader, which was around 1991. Saibian says in this article that he was fascinated with mathematics for as long as he can remember, and a concept that he found particularly invigorating was the notion of infinity. As we know, most people think of infinity as the number above all numbers, but since it's not a number in the way one or a googol or Graham's number is, if you really stop and think about infinity it isn't too hard for the layman to confuse the heck out of himself. Young Sbiis Saibian in particular was unable to accept the idea that infinity was unreachable no matter how big a number you devise, which was half of the motivation for his large number quest.

The second half of Saibian's motivation started when he became interested in really big finite numbers. In 2nd grade math class, the largest numbers his class worked with were in the hundred thousands, but from his father he learned about a million, a number that to his resent was almost kept a secret from his math class, not mentioned once in the second grade math textbooks. He then learned about the higher -illions from his father's dictionary, memorizing all the -illions from the everyday billion up to the obscure vigintillion, topped by the king of the dictionary -illions, the centillion, which if you recall, is 1 followed by 303 zeroes. The centillion became Saibian's favorite number, and he says that it was "kind of his googol", since he never learned about the googol as a kid.

Unaware of how botched up the googolgong was, Saibian was now inspired to generate the largest numbers he could, and wrote a book on large numbers titled "From One to Infinity" that would show readers through larger and larger numbers, starting with the basic numbers, going through the mechanics of scientific notation, and devising bigger and bigger numbers from there, until the intrepid second grader manages to fabricate a value so incredibly monstrous that it is exactly equal to the elusive mind-screwing "number", infinity!

Young Sbiis wrote this book on a stack of his father's copy paper. He didn't know at the time whether he successfully reached infinity, but now we all know he can't actually do that. Nonetheless, he did manage to come up with numbers that are way bigger than most adults conceive of in their lifetime. As you'll learn, he even managed to think up numbers that surpass Graham's number. Now think about that: Graham's number is commonly thought to be an ungodly large number impossible to surpass, and yet a second grader was able to beat it with his imagination. A second grader surpassing a number that is believed by many to be the world's biggest number. Does this give you an idea of just where Graham's number falls in the scope of large numbers, if an imaginative second-grader can beat it? Although Sbiis Saibian lost the papers on which he conjured all these numbers to who-knows-where, he still remembers the contents pretty well, and those contents happen to be the basis of his later Hyper-E notation.

Going Beyond Scientific Notation

Almost everyone is acquainted with scientific notation, one of few googological concepts that you'd find in a grade school curriculum, and one of even fewer that is rehashed in science classes. Scientific notation lets you write down large (or small) numbers in the form a*10x, where 1 ≤ a < 10 and x is any integer. For example, 3,500,000 written in scientific notation is 3.5*106. Young Sbiis Saibian was fascinated with scientific notation since it lets you write really big numbers compactly. For example, a decillion written out in full is:

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

but written in scientific notation it is:

1*1033

which is much more compact. Even Sbiis Saibian's two favorite large numbers, the centillion and the googolgong, can be written as 1*10303 and 1*10100,000 respectively, or more compactly, 10303 and 10100,000.

And so Saibian started to experiment with scientific notation during class time, and figured out how to make numbers that would leave centillions and googolgongs in the dust. He came up with a number equal to 1 followed by a centillion zeroes, which would be written out as 1010^303. He named this number a "centillionillion". In fact, this is the only name for a number Sbiis Saibian came up with as a kid. Note that "centillionillion" is not the most technically accurate name for 10 to the power of a centillion: a better name for it would be "centillionplex", and "centillionillion" should mean the centillionth -illion, equal to 103*10303+3. Sbiis Saibian now calls 10 to the centillionth power an "ecetonplex" - the name is a modification of the slightly awkward name "centillionplex", replacing "centillion" with "eceton", an alternate root name for that number.

He found out that you could go further than a "centillionillion" with 1 followed by a googolgong zeroes (10^10^100,000), or 1 followed by a centillionillion zeroes (10^10^10^303), or continuing with numbers like 10^10^10^100,000, 10^10^10^10^303, 10^10^10^10^100,000, and so on. It's not long until we'll get to unwieldy numbers like:

10^10^10^10^10^10^10^10^10^10^10^10^10^303

But young Sbiis came up with a notation to fix that. He called it "scientific notation notation"; he admits that he wasn't good with names, but didn't really care about names for his googological creations at the time. A bit ironic, since when he became an adult, he gave tens of thousands of names to the numbers he invented. He notes that better names for this notation would be "stack notation" or "super scientific notation", and we'll call his notation "stack notation" (same name Sbiis Saibian himself uses in articles to refer to that notation).

So how does stack notation work? It's really simple. It takes 3 numbers—the base, replicator, and determinant—and puts the base in a square, the replicator in a rectangle, and the determinant in a triangle. Those three numbers, which we'll refer to using the variables b, r, and d, are then plugged in to the expression:

b^b^ ... (r copies of b) ... ^b^d

This means that we can sum up stack notation in a picture as follows:

Since stack notation isn't easy to type, Sbiis Saibian created an ASCII version of the notation for his site, where you put the base inside a pair of square brackets [ ], the replicator also inside square brackets, and the determinant inside a pair of angle brackets < >, so that an expression in ASCII stack notation would look like [b][r]<d>.

For an example of stack notation, take the number 10^10^10^10^10^10^10^10^10^10^10^10^10^303 I mentioned earlier. You would write this in stack notation as [10][13]<303>: a power tower of 13 10's, topped off with a 303.

It should be pretty obvious that the replicator has the greatest effect on the size of numbers in stack notation. So why not cut to the chase and make the replicator be a massive number ... a centillion perhaps? Or a googolgong? Nope, not big enough. How about making the replicator a number where the replicator is a centillion:

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

In this, the base is 10, the replicator is a giant number, and the determinant is 303. More specifically, the replicator is a number where the base is 10, the replicator is a centillion, and the determinant is 303: a power tower of a centillion tens topped with a 303. This means that the number shown above is a power tower of "a power tower of a centillion tens topped with a 303" tens, topped off with a 303. You can visualize it as:

10^10^10^10^ ... ... ... ... ... ... ... ... ... ^10^303

       10^10^10^10^ ... ... ... ... ... ^10^303

                         10^303

Of course, you can make the replicator be that number as well, giving you the number:

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

Or even further:

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

and so on.

You can keep plugging numbers like this into the replicator of stack notation to produce bigger and bigger numbers, but this eventually becomes unwieldy. Why not come up with a compact notation for repeatedly applying this process? That's where we get to the second part of young Saibian's notation: diamond notation.

Diamond Notation

Diamond notation, or as young Sbiis called it, "scientific notation notation notation", is the 4-argument counterpart of stack notation. While stack notation uses three arguments (the base, replicator, and determinant), diamond notation adds a fourth argument, the second replicator (also called depth). The four arguments are arranged in a diamond like so:

Sbiis Saibian says that he doesn't remember exactly which argument went where in the diamond, except that the second replicator went in the upper-right corner. He guesses that the other three arguments (base, replicator, determinant) went clockwise from where the second replicator went. In other words, the base goes in the bottom right, the replicator in the bottom left, and the determinant in the bottom right. This means that for our purposes diamond notation will look like this:

NOTE: On his article on his childhood large numbers, Sbiis Saibian colors the top-right cell in diamond notation, apparently to signify that the colored cell is the most significant argument as you'll see.

We can write diamond notation in ASCII as:

/d|r2\
\r|b /

So what does the second replicator do? To understand it, think back to the sequence:

[10][10^303]<303>

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

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

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

The members in the sequence would be written as:

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

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

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

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

respectively. This is because diamond notation maps to stack notation like so:

with the general rule being:

5-Cell Notation and Beyond

From diamond notation easily follows a five-argument notation, which Sbiis Saibian calls 5-cell notation. In 5-cell notation, a pentagon is split up into five triangles, and each triangle holds a different argument, like so:

The argument r3, in the top-right cell, is called the third replicator. It works like so:

Now that's a really powerful notation - powerful enough that you can't directly relate it back to even stack notation, which is the largest notation in Saibian's system that can be easily understood in terms of standard math notation. In terms of hyper-operators it's on par with hexation. You can express a hexated to b in 5-cell notation by making the base equal to a, the third replicator b, and all other cells 1.

We can make more and more notations the same way - 6-cell notation, for instance, uses 6 arguments (all from 5-cell notation plus a fourth replicator), and it is to 5-cell notation what 4-cell notation is to diamond notation. After that comes 7-cell, 8-cell, 9-cell, 10-cell, and so on.

All these notations - stack notation, diamond notation, 5-cell notation, 6-cell notation, and so on - are collectively called the poly-cell hierarchy. It's in its entirety on par with up-arrow notation (or Bowers' 3-entry arrays), and in general, x-cell notation is on par with the (x+1)th hyper-operator (e.g. 10-cell notation is on par with 11-ation or a^9b).

Expanding upon the Poly-Cell Hierarchy

Now young Sbiis Saibian thought even further than that: one day when he was visiting family, he walked outside as he let a train of imagination start blasting through his head. You can go up from this and have 100-cell notation, or million-cell, or centillion-cell, or googolgong-cell ... you can have any number of cells you want, and that's where we get to the part of extending the poly-cell hierarchy.

If you can make a poly-cell notation with any number of cells, then just imagine where that can take you. We could have a 10 inside every cell of the notation, then make the number of cells anything. You could have a stack notation number of cells (like [10][10^303]<303> cells), a diamond notation number of cells, a 100-cell notation number of cells, or a x-cell notation number of cells where x is a 100-cell notation number, or keep feeding in the number of cells into itself

Why not define f(1) = a 100-cell notation number where all 100 cells are filled with 10, f(2) is a number like f(1) but with f(1) cells, f(3) with f(2) cells, and so on - f(1) would be comparable to the 100th hyper-operator, f(2) would be comparable to the f(1)th hyper-operator, and so on. With that direct expansion upon poly-cell notation, you could surpass Graham's number quite easily: f(1) is a 100th hyper-operator number much greater than G(1) which is a small hexational number, f(2) is a f(1)th hyper-operator number much greater than G(2) which is a G(1)th hyper-operator number, and so on: f(64) surpasses the so-called "world's largest number" quite easily. And you can also have not the 64th member of the sequence f(n), but the f(64)th member, the f(f(64))th member - that also forms a sequence, which you can jump to whatever member: if f(64) is the first member, f(f(64) the second, and so on, you can have the f(f(f(f(f(64)))))th member or whatever. You can progress further from that by defining maybe g(x) = f(f(f(...f(x)...) with x copies of f, define h(x) = g(g(g(...g(x)...) with x copies of g, i(x), j(x) ... or just f1(x) = f(x), f2(x) = g(x), and so on. Or fn(x) where n is f100(100)? It can go on and on...

Young Sbiis Saibian imagined all these sequences going further and further, so far that he became lost in his train of thought. He wondered: did he reach infinity? He felt like all these crazy large number sequences would eventually lead to what infinity really is, but part of him couldn't shake the feeling that infinity really is unreachable. He previously had thought of infinity as something real at the end of the number line, and he remarks that it's hard for him to appreciate how he thought of infinity back then. However, the pay-off was describing numbers way bigger than almost all others would ever dream up, leaving the measly googolgong in the dust! He says that he told his dad about stack notation and possibly diamond notation, but all the larger numbers were only something he knew about.

After that day where he thought up numbers that may go as far as Bowers' linear arrays (according to personal communication), he promised to himself that one day he will return to large numbers. That didn't really happen until 2004, when he researched large numbers, and was surprised to learn that others have devised large numbers much like he did, with notations like up-arrow notation and chained arrow notation. He fiddled around with the notations and devised his own extensions to them, and also compared them to his childhood large numbers. Eventually, in 2011, he decided to make a modernized version of his childhood poly-cell notation, and called it Hyper-E notation.

Part 2: The Creation of Hyper-E Notation

Just as there was a huge time gap between poly-cell notation and the creation of Hyper-E, I went through a big time gap before I wrote parts 2 and 3 of this article. I wrote part 1 of the article in September 2015, then slightly revised it in February 2025 and quickly started writing part 2, which you're reading now.

Starting around 2002, Sbiis Saibian dipped his feet back into large numbers and was surprised to have discovered all the large number notations that others have invented over the years. He learned of the googol and googolplex, Steinhaus-Moser notation, up arrows, chain arrows, and most strikingly of all, Jonathan Bowers' BEAF. Bowers' googology inspired him to make an ambitious number notation of his own and use it to name numbers on the way. But he didn't invent a new notation out of thin air: rather, he revived his poly-cell notation and modernized it for the digital age.

Reordering the Parameters

A significant change Sbiis made to his childhood notation was to swap the order of the replicator and determinant. It may seem logical to order the parameters as base, replicator, and determinant, but there are several reasons it makes sense to swap the latter two. It's not just that it's awkward to have the determinant between the first and second replicators. Just as numbers themselves are written in order from most to least significant digit, in a large number notation it's logical to order the parameters from least to most significant.

Out of the base, replicator, and determinant, which is most significant? To find out, let's take the expression:

This expression evaluates to 10^10^10^10^10^10^10^10^10^10^10 = 10^^11. A power tower of eleven 10's. Let's try changing each of the parameters to 100 while keeping the other two the same, and find out which has the biggest impact. First off, what happens when we change the base to 100?

A power tower of ten 100's, topped off with a 10. Robert Munafo's Hypercalc (more on that later) tells us it's approximately 10^10^10^10^10^10^10^10^10^(2*10^20), between [10][10]<20> and [10][10]<21>. That's smaller than [10][10]<10^10> = 10^^12.

Now let's change the base back to 10, and change the replicator to 100.

A power tower of 100 tens, topped off with an extra ten? Now THAT's a more impressive number. It's equal to 10^^101, surpassing Jonathan Bowers' giggol and just under a number you'll learn about in the next article, Sbiis Saibian's grangol.

Finally, what happens when we change the replicator back to 10, and the determinant to 100?

A power tower of ten tens, with a 100 on top. This is greater than 10^11 and surpasses [100][10]<10>, but is smaller than 10^^12 and MUCH smaller than [10][100]<10>. If we wanted to reach that value from [10][10]<10> only by changing the determinant, we'd have to put a gigantic number inside the triangle and write out [10][10]<10^^91>. But since young Sbiis Saibian didn't know up arrow notation existed, maybe it's more fitting to write it as [10][10]<[10][90]<10>>. A stack notation expression within the triangle.

As you can tell, the replicator is by far the most powerful parameter in stack notation, and since the later replicators of poly-cell notation are even more powerful, it makes sense to have the replicator after the determinant. Additionally, when the replicator is 1, the determinant functions as a replicator: it tells you how many times to multiply the base by itself. For instance, [10][100]<1> evaluates to 10^100, our trusty friend the googol.

Not only did Sbiis Saibian change the order of the parameters in stack notation. He also redesigned the notation to be easier to type on computers, and that is the birth of Hyper-E Notation.

Numbers with One Hyperion

[b][r]<d> in stack notation translates to b^d#r in Hyper-E. A power tower of b's of height r, with the number d on top. If the base is 10 (as is the case in most of Sbiis's googolisms), the number can instead be written as Ed#r. The E stands for exponent, as you typically see on a calculator when it can't store all the digits (e.g. 12E14 = 120 trillion). But I must admit, I always thought that the E stood for error as a kid, and even to this day I tend to read the E as "error". Also note that in Hyper-E notation, the # is not called a hashtag, number sign, or octothorpe, but rather a hyperion.

A googolplex (10^10^100) can be expressed as 10^100#2 or E100#2, a googolduplex (10^10^10^100) as 10^100#3 or E100#3, a googoltriplex as 10^100#4 or E100#4... noticing a pattern here? You can also express a googolplex as E2#3, which is 10^10^10^2 = 10^10^100. Or a googolduplex as E2#4, or a googoltriplex as E2#5.

In section 1 of my site, you learned about Skewes' Number, which can be approximated as 10^10^10^33.9705. That approximation can be written as E33.9705#3. The exact value of Skewes' number can be expressed as e^79#3. Note, however, that non-integers can be used in Hyper-E only if you have one hyperion. You'll see why in just a little bit. The second Skewes' number is exactly e^7.705#4, and approximately E963.52#3.

Let's try some more tetrational numbers and approximate them in Hyper-E.

4^^4 ≈ 10^(8.072*10^153) ≈ E154#2
5^^5 ≈ 10^10^(1.34*10^2184) ≈ E2184#3
2^^10 ≈ 10^10^10^10^10^19,728 = E19,728#6

Note that calculating tetrational numbers becomes easy if you use Robert Munafo's Hypercalc, although the symbols ^^ sadly don't work to represent tetration; you have to express the exponents individually. Hypercalc uses "x PT y" to mean Ey#x, as a matter of fact. PT stands for "powers of ten".

What else can we try? How about the factorial of ten, ten times?

10!!!!!!!!!! ≈ 10^10^10^10^10^10^10^10^10^22,228,111 = E22,228,111#9 (Yes, I know multiple exclamation points are supposed to mean smaller variants of the factorial, but in this large number site I don't think anyone will care.)

Or a power tower of the integers 20 to 1, in descending order from bottom to top?

20^19^18^17^16^15^14^13^12^11^10^9^8^7^6^5^4^3^2^1 ≈ 10^10^10^10^10^10^10^10^10^10^10^10^10^10^10^10^183,231 = E183,231#16

Basically, we've created an operator that's a bit like tetration, but with the bonus that you can pick which number goes on top of the power tower. It's very useful for approximating tetrational numbers and, as we'll soon see, pentational numbers. I even used Hyper-E to approximate some of the bounds for Graham's problem in this article, but to do that, I had to use more than one hyperion.

Multiple Hyperions

Now's a good point to introduce you to the formal definition of Hyper-E. I'll directly quote Sbiis Saibian here:

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).

To phrase these rules in plain English:

1. If the expression has no hyperions, then Ea evaluates to 10^a.

2. If the last number of a Hyper-E expression is 1, you can remove the 1 and the preceding hyperion.

3. If the last number of an expression is not 1, take the entire expression, remove the last number, and replace the second last number with the expression where the last number is decreased by 1.

Let's try a very simple expression and see for ourselves how rule 3 works: E1#1#2. The base is 10, the determinant is 1, the replicator is 1, and the second replicator is 2.

E1#1#2
= E1#(E1#1#1)
= E1#(E1#1)
= E1#(E1)
= E1#(10^1)
= E1#10
= 10^10^10^10^10^10^10^10^10^10^1
= 10^^10

How about we bump the second replicator up by one?

E1#1#3
= E1#(E1#1#2)
= E1#(10^^10)
= 10^^10^^10
= 10^^^3

Basically, E1#1#x = 10^^^x. Now what if we bump the determinant up to 2?

E2#1#2
= E2#(E2#1#1)
= E2#(E2)
= E2#(10^2)
= E2#100
= 10^10^10^ ... ^10^10^10^2, with 100 10's

This is a power tower of 100 tens, topped off with a 2, so it's between 10^^100 and 10^^101.

E3#1#2
= E3#(E3#1#1)
= E3#(E3)
= E3#1000
= 10^10^10^ ... ^10^10^10^3, with 1000 10's

A power tower of a thousand tens, topped with a 3. Suddenly the determinant seems like a powerful parameter! But believe me, that's only because the two replicators are so small. If x > 1, then Ex#1#2 is slightly greater than 10^^10^x. What if we bump up the first replicator instead?

E1#2#2
= E1#(E1#2#1)
= E1#(E1#2)
= E1#(E(E1))
= E1#(10^10)
= 10^^10^10 = 10^^10^^2

A power tower of 10^10 tens. That's quite a lot more than E1#1#2, and quite close to E10#1#2: that's a power tower of 10^10 + 1 tens.

E1#3#2
= E1#(E1#3#1)
= E1#(10^^3)
= 10^^10^^3

As we can see: Ex#1#2 = Ex#(10^x) = [10][10^x]<x>. E1#x#2 = 10^^10^^x. And E1#1#x = 10^^^x. Now what if we set all three parameters to 2?

E2#2#2
= E2#(E2#2#1)
= E2#(E2#2)
= E2#(10^10^2)
= 10^10^10^ ... ... ... ^10^10^10^2, with 10^100 10's

All parameters set to 3:

E3#3#3
= E3#(E3#3#2)
= E3#(E3#(E3#3#1))
= E3#(E3#(10^10^1000))
= 10^10^10^ ... ... ... ^10^10^10^3 with E3#(10^10^1000) tens

= 10^10^10^ ... ... ... ^10^10^10^3
    10^10^10^ ... ... ... ^10^10^10^3 tens
                    10^10^10^3 tens

Aha, now that's starting to look more like a pentational number! Take the expression b^x#y#z. The base (b) determines the number that the power towers in the expression above consist of. When b is 10, b^x is replaced with Ex. The determinant (x) indicates the number in blue on top of the power tower. The replicator (y) denotes the height of the power tower in red. And the second replicator (z) represents the height of the recursive power tower expression shown above. In fact, I'll show you what E4#4#4 looks like:

10^10^10^ ... ... ... ^10^10^10^4
10^10^10^ ... ... ... ^10^10^10^4 tens
10^10^10^ ... ... ... ^10^10^10^4 tens
            10^10^10^10^4 tens (4th line)

And E5#5#5:

10^10^10^ ... ... ... ^10^10^10^5
10^10^10^ ... ... ... ^10^10^10^5 tens
10^10^10^ ... ... ... ^10^10^10^5 tens
10^10^10^ ... ... ... ^10^10^10^5 tens
            10^10^10^10^10^5 tens (5th line)

And even E100#100#100:

10^10^10^ ... ... ... ^10^10^10^100
10^10^10^ ... ... ... ^10^10^10^100 tens
10^10^10^ ... ... ... ^10^10^10^100 tens
10^10^10^ ... ... ... ^10^10^10^100 tens

            :              :              :
            :              :              :
            :              :              :

10^10^10^ ... ... ... ^10^10^10^100 tens (100th line)
                    100 tens

Adding a third hyperion takes us into the realm of hexation. For instance, E100#100#100#2 is evaluates to E100#100#(E100#100#100), so it's like the expression above, but with E100#100#100 lines. Then for E100#100#100#100... imagine E100#100#100 is stage 1 (a series of power towers with 100 lines), stage 2 is the same series of power towers with "stage 1" lines, stage 3 is the series with "stage 2" lines, and so on... till you reach stage 100. You can express 10^^^b as E1#1#1#b and a^^^^b as a^1#1#1#b.

Four hyperions takes us to heptation, five hyperions to octation, and you get the pattern. This is basically a rehash of up-arrow notation, so no need to go into more detail here.

As you can see, Hyper-E notation keeps up with up-arrow notation, which means that young Sbiis Saibian's poly-cell notation kept up with it too. An amazing feat for an eight-year-old, but an adult googologist can do better than this. Saibian soon enough came up with a simple but powerful way to extend Hyper-E. Brace yourselves for...

Part 3: Extended Hyper-E Notation

My archive of updates tells me that part 3 of this page was originally going to cover the googolisms Sbiis invented using Hyper-E (E#). But since then, I've changed my mind and instead part 3 will cover Extended Hyper-E (xE#). I'm not sure if my plan was originally to cover only E# in this article or also xE#. I've decided to include Extended Hyper-E in this article, just as Saibian included it in the article where he introduced Hyper-E. I will save coverage of Sbiis's googolisms for a future article.

Introducing the Deutero-Hyperion

As a child, Sbiis Saibian imagined filling numbers into a 100-sided polygon, a million-gon, a centillion-gon, a googolgong-gon, and even iterating the number of sides of a polygon into itself. He couldn't think of a way to notate these iterations back then, but after having invented Hyper-E, he had a new idea. Enter the deutero-hyperion, a symbol that consists of two hyperions: ##. A single hyperion can retroactively be called a proto-hyperion.

The definition of Ex##y is Ex#x#x#x ... ... ... #x#x#x with y x's. More formally, you can define it like so:

if y = 1: x##y simplifies to x
x##y simplifies to x#x##(y-1)

Let's try some simple expressions and see what comes out, shall we? The simplest non-trivial expression with a deutero-hyperion is:

E2##2
= E2#2##1
= E2#2
= E(E2)
= 10^10^2 = 10^100

I just discovered a new way to express a googol, and I never even knew of it! I actually realized while writing this post that a googol in xE# is a bit like 4 in up-arrow notation. Just as 2^2, 2^^2, 2^^^2, E2^^^^2, and so on all equal 4, E2#2, E2##2, E2###2, E2####2, and so on all equal a googol. If I'm not mistaken, that should mean every expression in Cascading-E and beyond starting with E2# should equal a googol... but let's not get ahead of ourselves!

How about:

E2##3
= E2#2#2

This is an expression we saw before, it evaluates to:

10^10^10^ ... ^10^10^10^2, with 10^100 10's

E2##4
= E2#2#2#2
= E2#2#(E2#2#2#1)
= E2#2#(E2#(10^100))

= 10^10^10^ ... ... ... ^10^10^10^2
   10^10^10^ ... ... ... ^10^10^10^2 tens
   10^10^10^ ... ... ... ^10^10^10^2 tens
   10^10^10^ ... ... ... ^10^10^10^2 tens

            :              :              :
            :              :              :
            :              :              :

   10^10^10^ ... ... ... ^10^10^10^2 tens
                    10^10^2 tens (E2#2#2th line)

The real power of deutero-hyperions, however, comes when you put a proto-hyperion right after. Enough with trying to evaluate minimalist expressions, let's look at some big ones!

E100##100#2
= E100##(E100##100)
= E100#100#100#100# ... ... ... #100#100#100#100
    E100#100#100#100# ... ... ... #100#100#100#100
                                      100 100's

E100##100 is already quite a fearsome number, comparable to {10,102,100} in BEAF, or 10^^^...^^^102 with 101 up-arrows. But then E100##100#2 is comparable to {10,102,x} where x is E100##100. In his number list, Sbiis Saibian upper-bounds this in BEAF as {102,3,1,2} = 102{{1}}3.

E100##100#3
= E100##(E100##100#2)
= E100#100#100#100# ... ... ... #100#100#100#100
    E100#100#100#100# ... ... ... #100#100#100#100
    E100#100#100#100# ... ... ... #100#100#100#100
                                      100 100's

Now we have a number comparable to {10,102,E100##100#2}. Sbiis Saibian upper-bounds this as {102,4,1,2} = 102{{1}}4.

E100##100#100
= E100##(E100##100#2)
= E100#100#100#100# ... ... ... #100#100#100#100
    E100#100#100#100# ... ... ... #100#100#100#100

                                :              :              :
                                :              :              :
                                :              :              :

    E100#100#100#100# ... ... ... #100#100#100#100
    E100#100#100#100# ... ... ... #100#100#100#100 (100th line)
                                      100 100's

As you can see, E100##100#x is roughly equivalent to iterating the number of up-arrows, and therefore comparable to Bowers' operator expansion (a{{1}}b or {a,b,1,2}). Unfortunately, with a deutero-hyperions it's no longer possible to express exact values in up-arrow notation, or in BEAF for that matter. This is because {a,b,c} = a^1#1# ... #1#b with c-1 1's, and the expansion of Ea##b (Ea#a# ... #a#a with b a's) always has the same number between every hyperion.

This also means that we can't express Graham's number in Extended Hyper-E, because the number is calculated by iterating the number of up-arrows in 3{x}3 64 times. But we can express a number that we know for sure is larger than Graham's number with an alternative version of Graham's sequence, like so:

G1 = 3^3##4 = 3^3#3#3#3 > 3^1#1#1#3 = 3^^^^3
G2 = 3^3##4#2 = 3^3#3# ... #3#3 with G1 3's > 3{3^^^3}3
G3 = 3^3##4#3 = 3^3#3# ... #3#3 with G2 3's > 3{3{3^^^3}3}3
... Gx = 3^3##4#x = 3^3#3# ... #3#3 with Gx-1 3's ...
till we reach G64 = 3^3##4#64 > Graham's number

Now we have a nice little upper-bound for Graham's number in Extended Hyper-E, with a base of 3 instead of 10. This is less than 10^3##4#64 = E3##4#64, a number that barely scratches the surface of what we can do with deutero-hyperions. What about E3##4#1,000,000? That's an upper bound for the millionth value in Graham's sequence. And E3##4#64#2 evaluates to E3##4#(E3##4#64), which is an upper bound for GG64, the Graham's number-th entry in Graham's sequence and a common retort to Graham's number.

We can sort of speed through the rest: E100##100#100#2 is like E100##100#100 as you saw above, but with E100##100#100 lines instead of just 100 of them. Feed in that number of lines and you get E100##100#100#3, and so on till you reach E100##100#100#100, a number similar in scale to {10,100,2,2} = 10{{2}}100, 10 multiexpanded to 100 in Bowerian terms. E100##100#100#100 can also be written as E100##100##3, then you can go on to E100##100##4, or E100##100##100 which is a pretty awesome number. It expands to:

E100##100#100#100# ... ... #100#100
                              100 100's

And just to clear things up, you can only expand a deutero-hyperion if it's at the end of an expression. This means, for instance, that E10#2##3 = E10#2#2#2, but E10##3#2 does not equal E10#10#10#2. Instead, that equals E10##(E10##3), a much larger number. Expressions in Sbiis Saibian's notation are evaluated right to left, exactly like up-arrows.

You can iterate the number of 100's in the above expression to get E100##100##100#2—hopefully you're getting the hang of this notation. E100##100##100#x should get you on the same level of numbers as Bowers' operator called explosion—{a,b,1,3} in BEAF, or a{{{1}}}b. Likewise, E100##100##100#100#x matches multiexplosion ({a,b,2,3} or a{{{2}}}b), and E100##100##100##100#x matches detonation ({a,b,1,4} or a{{{{1}}}}b).

Before we know it, we reach the realm of the trito-hyperion.

Trito-Hyperions and Beyond

Now's a good time to show you the formalized definition of Extended Hyper-E, again in Sbiis Saibian's words:

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)

Just to be clear, @ refers to the rest of the expression, and #x refers to a hyperion repeated x times. Rules 1 and 2 are the same as the first two rules of E#, and rule 4 is the same as the third rule of E#. New to xE# is rule 3, which is a formalized definition of the multi-hyperion. Let's try evaluating E100###3 as an example:

E100###3
= E100##100###2 (rule 3)
= E100##100##100###1 (rule 3)
= E100##100##100 (rule 2)
= E100##100#100##99 (rule 3)
= E100##100#100#100##98 (rule 3)
...
= E100##100#100# ... ... #100#100
                                100 100's

That's a number we've seen before! Surely you can tell what's next: E100###100, for instance, equals:

E100##100## ... ... ##100##100
                     100 100's

That's a number comparable to {10,10,10,100} in BEAF, but while E100##100 exceeds {10,10,100}, E100###100 falls short of {10,10,10,100}. It's upper-bounded by {10,103,99,99}.

We start getting numbers comparable to five-entry arrays when we put something after the ###100. E100###100#100, for instance, is roughly comparable to {10,100,1,1,2}. E100###100#100#100 = E100###100##3 can be compared to {10,100,2,1,2}. The fourth entry starts changing when we reach E100###100##100#100, comparable to {10,100,1,2,2}. Then you can reach E100###100###100#100, and that's where the fifth entry starts changing: it's comparable to {10,100,1,1,3}. By the time you want to reach {10,100,1,1,10}, you'll have to write out:

E100###100###100###100###100###100###100###100###100###100#100

E100###100###100###100###100###100###100###100###100###100 can be expressed more compactly as E100####10, so you might think we can compactly express the above number as E100####10#100, but unfortunately we can't. E100####10#100 would be equal to:

E100###100###100### ... ... ... ###100###100###100
E100###100###100### ... ... ... ###100###100###100 100's
E100###100###100### ... ... ... ###100###100###100 100's

                                  :             :             :
                                  :             :             :
                                  :             :             :

E100###100###100### ... ... ... ###100###100###100 100's
E100###100###100### ... ... ... ###100###100###100 100's
E100###100###100### ... ... ... ###100###100###100 100's (100th line)
                                          10 100's

As you can see, some expressions that look compact in linear array notation can't be approximated so concisely in Extended Hyper-E. That's the main disadvantage xE# has over Bowers' arrays: in BEAF, all the numbers in the array clearly indicate the number of recursive steps.

You can go up to E100####100, or E100####100#2 = E100####(E100####100) ... now we've reached four hyperions in a row, or a teterto-hyperion. With four hyperions you can reach six-entry arrays, five hyperions take you to seven-entry arrays... but I'll save comparisons to BEAF for a future article. And if you felt I rushed through trito-hyperions and beyond, don't worry: I'll deep dive into the xE# googolisms in a future article.

How to Continue?

It isn't hard to guess what the next step is: can you have an operator for Ex##...##x with y #'s? I'll tell you right now: yes there is, and it's #^#. That means (for example) E100#^#5 = E100#####100. It's pretty easy to make numbers like E100#^#100#50, or E100#^#100###100, or even E100#^#100#^#100#^#100, but the question is... how do we extend upon the #^# operator? That's a question for another time, when we explore Cascading-E notation, or E^ for short. For now, let's conclude this post.

Conclusion

Maybe I'm biased because I know Sbiis Saibian personally, but Hyper-E notation and its follow-ups are my personal favorite of the major large number notations. It's a useful way to compare large numbers, the rules are intuitive and logical, and it goes hand-in-hand with naming large numbers, which in my opinion is the second most fun part about googology. The most fun part, I can't deny it, is making large number lists. An additional advantage of xE# over linear arrays is that while a learner of googology has to learn five-entry arrays separately from four-entry arrays, once you learn how the deutero-hyperion works (which keeps up with four-entry arrays), it's very obvious how the rest of xE# works (which keeps up with linear arrays of any length).

All that said, Jonathan Bowers deserves respect for his notation as well. I've always been a fan of his work and the way he describes his crazy mathematical creations while keeping a whimsical sense of humor. And his linear arrays have some nice features Sbiis's notation lacks. The biggest disadvantage of xE# over BEAF is that you can't express values in up-arrow notation (or recursive up-arrows) as cleanly as with Bowers' linear arrays, as we saw with the example of E100###100###100###100###100###100###100###100###100###100#100. And that's okay: different notations are useful for different things.

Perhaps in the future I'll make articles on E^ (Cascading-E) and beyond, but I already got a big mental workout covering just xE#. The next article planned after this is an overview of Saibian's E# and xE# googolisms.