Large Number Notes

or: How I Realised I'm Kind of Dumb

Last updated 06/07/21

Introduction

One of the things I've always been interested in since I was a wee lad is googology, the study of large numbers. I don't particularly remember it, but apparently I used to be the type to just point at numbers as I passed them on the street. As I've grown older I've slowly turned from one of those "super smart kids" to just a regular person, but I still find mathematical stuff like this fun. So I'd like to collate a few of the things I've done and discovered here on one page, both for me and for whoever may care enough to read. Enjoy!

Oh, and by the way, don't expect the rigorous definitions or expected lingo from a proper googological essay. I'm not smart enough for that, sorry.

Part 1 - Hyperoperators from A to Z

When I was around 10-ish, I discovered the Googology wiki. I learned that googology is the study of large numbers, and also that a lot of people are into it. Googology's not so much a proper area of mathematics, more of a side hobby for mathematicians and smart people to play around with. It was on this site that I learned of tetration, or repeated exponentiation. Multiplication is repeated addition, exponentiation is repeated multiplication, and likewise tetration is repeated exponentiation. Naturally, my first thought was "Well what's repeated tetration?" So I decided to just make it up. In a flash of true creativity, I named repeated tetration "A".

x(A)y = x^^x^^x^^x... (with y x's)

And of course, I then continued with "B"...

x(B)y = x(A)x(A)x(A)x... (with y x's)

And on and on and on, all the way to Z. To me, Z was the pinnacle of largeness. The pathway to the largest numbers ever devised. I thought of a number, 99(Z)99, and called it (MY LAST NAME)'s number. Obviously I can't call it that here, so I'm officialy renaming it to Demonin's number, or just Demoninber. So how big is Demoninber?

When I invented my arbitary system, the term I really should've known was "Hyperoperator". Exponentiation is a hyperoperator. So is tetration, as well as all of my letters to Z. It turns out that My "A" idea already had a name (pentation), and if I bothered I easily could've found that out. Although to be fair, if I did find it out I would've just defined "A" as repeated pentation, so whatever. In general, all hyperoperators starting with exponentation use a certain number of ^ symbols (tetration uses two, as I used above, pentation uses three, and so on). This means that x(A)y = x^^^y. Z requires 25 more ^s than that, making the full expansion of Demoninber...

99^^^^^^^^^^^^^^^^^^^^^^^^^^^^99

Yeesh. This can be compressed into 99 ↑²⁸ 99 using arrow notation, or {99,99,28} using array notation. This just about equivalent to Sbiis Saibian's googontritol. So it's good to see that my poor attempt at producing the largest number was at least well-defined enough to get the exact size of. Seeing the skill and finesse real mathematicians use when defining their numbers and noations makes me feel a bit inadequate by comparison. God, I don't even know how to properly define this new notation 10-year-old me created (If anyone reading this does know how to properly define number notations, please please get in contact with me!). But we're not here to be better than the experts, we're here to have fun! So now that we're here let's extend the notation.

Part 2 - Demonin's letter notation

Note: I didn't do this well. This notation is bad, it's ill-defined, and at times it makes no sense. Read at your own expense.

Although the standard English alphabet only has 26 characters, we can extend our notation (which I'm now calling Demonin's letter notation) infinitely by moving on to AA.

x(AA)y = x(Z)x(Z)x(Z)x... (with y x's)

And then AB, AC, AD and so on. I'd like to use this extended system to name a few more neat numbers:

DemoniNO = 99(NO)99 = 99 ↑³⁷⁹ 99
Bidemoninber = 99(ZZ)99 = 99 ↑¹³⁷⁸ 99
Tridemoninber = 99(ZZZ)99 = 99 ↑^54,106 99
Tetrademoninber = 99(ZZZZ)99 = 99 ↑^1,882,010 99
Quindemoninber = 99(ZZZZZ)99 = 99 ↑^61,288,890 99
Sexademoninber = 99(ZZZZZZ)99 = 99 ↑^{1,914,783,546} 99
Septademoninber = 99(ZZZZZZZ)99 = 99 ↑^{58,137,454,778} 99
Octademoninber = 99(ZZZZZZZZ)99 = 99 ↑^{1,728,753,971,386} 99
Nonademoninber = 99(ZZZZZZZZZ)99 = 99 ↑^{50,594,287,082,170} 99
Decademoninber = 99(ZZZZZZZZZZ)99 ≈ 99 ↑¹⁰¹⁵ 99 ≈ {99,99,{10,15}}

Weirdly, the letter system I'm using for this notation relates closely to my very bad number notation. Granted, this notation is also very bad, but it's not inefficient in the way my other notation's designed to be. Anyway, we can compress our growing list of Zs into a new format, like this:

x(y*Z)z = x(ZZZZZZZ... (with y Zs))z

For example, 99(10*Z)99 = 99(ZZZZZZZZZZ)99 = Decademoninber. Using this I can name a few more neat numbers:

Vigintidemoninber = 99(20*Z)99 ≈ 99 ↑¹⁰²⁹ 99
Centidemoninber = 99(100*Z)99 ≈ 99 ↑¹⁰¹⁴³ 99
Millidemoninber = 99(1000*Z)99 ≈ 99 ↑¹⁰¹⁴¹⁷ 99
Decamillidemoninber = 99(10,000*Z)99 ≈ 99 ↑^1014,153 99

Note: This also works with any other letter or letter combo (eg. 99(3*ABC)99 = 99(ABCABCABC)99)

What fun! We can also use Demonin's letter notation recursively for even bigger numbers.

Demoninberplex = 99(99(Z)99*Z)99 ≈ 99 ↑^{99 ↑28 99} 99 ≈ {99,99,{99,99,28}}
Bidemoninberplex = 99(99(ZZ)99*Z)99 ≈ 99 ↑^{99 ↑1378 99} 99
Tridemoninberplex = 99(99(ZZZ)99*Z)99 ≈ 99 ↑^{99 ↑54,106 99} 99
Tetrademoninberplex = 99(99(ZZZZ)99*Z)99 ≈ 99 ↑^{99 ↑1,882,010 99} 99
Quindemoninberplex = 99(99(ZZZZZ)99*Z)99 ≈ 99 ↑^{99 ↑61,288,890 99} 99 ≈ {99,99,{99,99,61288890}}
Decademoninberplex = 99(99(10*Z)99*Z)99 ≈ 99 ↑^{99 ↑10↑15 99} 99

Wow! We've now defined 21 distinct large numbers. Let's try something new:

x(Z^y)z = x(x(x(x... (Z) ...z*Z)z*Z)z*Z)z (with y x's and z's)

Unfortunately, if I extend the notation this far I can no longer with certainty provide an equivalent number for scale (because again, small brain. I'm still learning array notation). But what the hell, let's do it anyway.

99(Z^1)99 = 99(Z)99 = Demoninber
99(Z^2)99 = 99(99(Z)99*Z)99 = Demoninberplex
Demoninberduplex = 99(Z^3)99 = 99(99(99(Z)99*Z)99*Z)99 ≈ {99,4,1,2}??? (Not quite sure)
Demoninbertriplex = 99(Z^4)99 = 99(99(99(99(Z)99*Z)99*Z)99*Z)99 ≈ {99,5,1,2}???
Demoninbertetraplex = 99(Z^5)99 = 99(99(99(99(99(Z)99*Z)99*Z)99*Z)99*Z)99 ≈ {99,6,1,2}???
Demoninberdecaplex = 99(Z^11)99
Demoninbervigintiplex = 99(Z^21)99
Demoninbercentiplex = 99(Z^101)99
Demoninbermilliplex = 99(Z^1001)99
Demoninberdecamilliplex = 99(Z^10,001)99 ≈ {99,10002,1,2}???

Demoninber-demoninberplex = 99(Z^99(Z)99)99 ≈ {99,{99,99,28},1,2}???
Demoninber-demoninberplexplex = 99(Z^99(Z^2)99)99
Demoninber-demoninberduplexplex = 99(Z^99(Z^3)99)99

Demoninber-demoninber-demoninberplex = 99(Z^99(Z^99(Z)99)99)99 ≈ {99,{99,{99,99,28},1,2},1,2}???

I think that's a good place to stop. 33 unique defined numbers, that's cool. It's pointless... but still cool. Assuming I'm correct, demoninber-demoninber-demoninberplex would be considerably larger than Graham's number. I feel like if I properly understood array notation (And the other big notations) I could be more confident in this. Again, any math nerds out there please get in touch! I'm sort of afraid to ask... And now for something completely different.

Part 3 - BASIC programs

Not too long before writing this, I had an idea while bored in calculus class. See, there was this fun little contest held in 2001 called the Bignum Bakeoff, where the goal was "to write a C program with at most 512 characters (ignoring whitespace) that returns the largest possible number, assuming a computer with infinite resources". See, normal C programs cannot exceed 9,223,372,036,854,775,807 for variables of type long long, due to memory limitations. The programs produced for the Bakeoff assumed the computer used had infinite memory and could produce numbers infinitely large. Although I won't go into detail about the submissions, you can read them for yourself if you'd like. My idea was to attempt a similar idea using my calculator's in-built programming function, creating a program that took up x bytes or less while outputting the largest number on a theoretical calculator with infinite memory. The language my calculator uses is Casio BASIC, which is almost as ancient as C itself. I decided to create 3 programs: "NUM50", which uses 50 max bytes, "NUM100", which uses 100 max bytes, and "NUM150", which uses 150 max bytes. Luckily, since Casio BASIC can be converted into regular computer text, I am able to present the full programs here!

Note: One of the requirements I set for myself was for the program to print the number using "_" (Which looks like 𝅍 on the calculator).

--NUM50--
10^10^10^10^10^10^10^10^10^10^10^10^10^9->A_

So... 50 bytes isn't much space. All this program does is creates a massive number, set it to variable A, then print it. This would produce a value of about ~10^^14.

--NUM100--
9->A
10^10^10^10^10^9->B
Lbl 1
10^A->A
B-1->B
If B>0
Then Goto 1
IfEnd
If B=0
Then A+.5->B
IfEnd
If B<0
Then A_

Here's what this means: This program sets variable B to 10^10^10^10^10^9, then sets A to 10^A that many times. Then, it sets B to A and does it again. Then it prints A. This produces a much larger result of ~10^^10^^10^^6, or just under 10^^^4 (You could also say 10(A)4).

--NUM150--
9->A
10^9->B
-9->C
Lbl 1
10^A->A
B-1->B
If B>0
Then Goto 1
IfEnd
If B=0
Then A+.5->B
IfEnd
If B<0
Then If C<0
Then A->C
IfEnd
If C>0
Then A->B
C-1->C
Goto 1
IfEnd
If C=0
Then A_

This works similarly to NUM100, except after it's done it sets variable C to A and then does the whole thing again C more times. I believe this produces a result of around ~10^^^10^^^4, although I may be wrong. I've also converted these 3 programs into Javascript functions, for easier understanding:

function num50() {
a = 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 10 ** 9
console.log(a)
}

function num100() {
a = 9
b = 10 ** 10 ** 10 ** 10 ** 10 ** 9
function one() {
a = 10 ** a
b--
if (b > 0) {one()}
if (b == 0) {b = a + 0.5}
if (b < 0) {console.log(a)}
}
one()
}

function num150() {
a = 9
b = 10 ** 9
c = -9
function one() {
a = 10 ** a

b--
if (b > 0) {one()}
if (b == 0) {b = a + 0.5}
if (b < 0) {
if (c < 0) {c = a}
if (c > 0) {
b = a
c--
one()
}
if (c == 0) {console.log(a)}
}
}
one()
}

Looking back, there are a lot of things I could improve to cut down on space and improve these programs. For example, I didn't even need NUM50 to set the number to a variable. It could've just been:
10^10^10^10^10^10^10^10^10^10^10^10^10^10^10^9_
Which allows enough extra space to bump the result up to ~10^^16. With a bit of research I also could've shortened my loops and such (I'm not the greatest at Casio BASIC), but that'll have to happen another time. Since this is an extremely niche and specific thing to talk about, I doubt anyone plans to beat my records any time soon, which is a bit of a shame.

Update: Thanks to some newfound Casio BASIC knowledge I've made an updated version of NUM100:

--NUM100V2--
9->A
9->C
10^10^10^10^10^10^10^9->D
Lbl 1
For 0->B To C Step 1
10^A->A
Next
D>0=>D-1->D
D>0=>A->C
D>0=>Goto 1
A_

This program runs sets A to 10^A C times, sets C to A, then repeats that 10^10^10^10^10^10^10^9 more times (before printing A). I believe this produces a result of ~10^^^10^^8.

I intend to make more improvements to these programs, so a full version history can be found here.

Part 4 - A return to letter notation

As interesting and unique as Demonin's letter notation was, there were a lot of ways it wasn't particularly sleek or usable. This was due to the fact that it revolved around the original Demoninber (99(Z)99) and the original A to Z letter system 10-year-old me devised. I'd like to take the time to reinvent the notation with something more simple, intuitive and easily-defined. Let's begin.

First of all, I'd like to drop the letters from A to Y. although the original system allowed for use of all letters and letter combinations, leading to a higher range of possibilities using the notation, it was mostly redundant and only served to make defining it more complicated. So let's simplify the system this way:

Z(99) = 99{26}99 = {99,99,26}

Not only has the x(Z)y system been shortened to just Z(x), but the {26} now makes sense because Z is the 26th letter of the alphabet. This allows for a (probably) rigorous definition:

Z(x) = x ↑²⁶ x

I'd also like to start using 10 instead of 99 form now on, 99 was weird. Let's now continue to multiple Z's.

2Z(10) = 10{26²}10 = 10{676}10
3Z(10) = 10{26³}10 = 10{17576}10
For all cases: xZ(y) = y ↑^(26x) y
Alternate usage: x*Z(y) = y ↑^(26x) y

This new 26^x system is a lot simpler than the whole A to Z to AA to ZZ system, which used this formula:

Which I also used on my bad number notation page. Using these simple rules we can start naming a few numbers! I'd like to call this notation "Demonin's Z notation" because, well, it's just Zs.

Normalium Z = Z(10) = 10{26}10 = {10,10,26}
Binormalium Z = 2Z(10) = 10{676}10 = {10,10,676}
Trinormalium Z = 3Z(10) = 10{17576}10 = {10,10,17576}
Tetranormalium Z = 4Z(10) = 10{456976}10 = {10,10,456976}
Quinormalium Z = 5Z(10) = 10{11881376}10 = {10,10,11881376} ≈ {10,10,{10,7}}
Decanormalium Z = 10Z(10) ≈ 10{10¹⁴}10 ≈ {10,10,{10,14}}
Vigintanormalium Z = 20Z(10) ≈ 10{10²⁸}10 ≈ {10,10,{10,28}}
Centinormalium Z = 100Z(10) ≈ 10{10¹⁴¹}10 ≈ {10,10,{10,141}}
Millinormalium Z = 1000Z(10) ≈ 10{10¹⁴¹⁵}10 ≈ {10,10,{10,1415}}

Yes, I'm naming these after Z-crystals. Try and stop me. Anyway, a general formula can be determined here:

xZ(y) ≈ y{10^{(x * 1.415973)}}y

Let's move on to a new system, similar to the one implemented in the original letter notation.

Z¹(10) = Z(10) = 10{26}10
Z²(10) = Z(10)*Z(10) = 10{26^10{26}10}10 ≈ 10{10{26}10}10 ≈ {10,10,{10,10,26}}
Z³(10) = Z(10)*Z(10)*Z(10) ≈ 10{10{10{26}10}10}10 ≈ {10,10,{10,10,{10,10,26}}}
Base case: Z¹(y) = Z(y)
For all other cases: Z^x(y) = Z(y)*Z^x-1(y)

Ooh, nice! Let's use this to name some new numbers.

Normalium Z-plex = Z²(10) ≈ 10{10{26}10}10 ≈ {10,10,{10,10,26}}
Normalium Z-duplex = Z³(10) ≈ 10{10{10{26}10}10}10 ≈ {10,10,{10,10,{10,10,26}}}
Normalium Z-triplex = Z⁴(10) ≈ {10,5,1,2}
Normalium Z-tetraplex = Z⁵(10) ≈ {10,6,1,2}

Firium Z = Z¹⁰(10) ≈ {10,11,1,2}?
Bifirium Z = Z²⁰(10) ≈ {10,21,1,2}
Trifirium Z = Z³⁰(10) ≈ {10,31,1,2}
Tetrafirium Z = Z⁴⁰(10) ≈ {10,41,1,2}
Quinfirium Z = Z⁵⁰(10) ≈ {10,51,1,2}
Decafirium Z = Z¹⁰⁰(10) ≈ {10,101,1,2}
Centifirium Z = Z¹⁰⁰⁰(10) ≈ {10,1001,1,2}
Millifirium Z = Z¹⁰⁰⁰⁰(10) ≈ {10,10001,1,2}

In general: Z^x(y) ≈ {y,(x+1),1,2}

We now have 22 named numbers. The next symbol I'd like to implement is the hash (#). Here's how it works:

Z#1(10) = Z(10)
Z#2(10) = Z¹⁰(10) = Z(Z(Z(Z(Z(Z(Z(Z(Z(Z(10))))))))))
Z#3(10) = Z#2(Z#2(Z#2(Z#2(Z#2(Z#2(Z#2(Z#2(Z#2(Z#2(10))))))))))
Z#4(10) = Z#3(Z#3(Z#3(Z#3(Z#3(Z#3(Z#3(Z#3(Z#3(Z#3(10))))))))))

Z#1(y) = Z(y)
Z#2(y) = Z^y(y)
Z#3(y) = Z#2(Z#2(Z#2(Z#2... (y) ...))) y times
Z#4(y) = Z#3(Z#3(Z#3(Z#3... (y) ...))) y times

Basically, Z#x(y) is equal to Z#(x-1)(y) repeated inside itself y times. Although I don't know how to make a rigorous definition for this, I can make an average defintion:

Z#x(y) = Z#x-1(Z#x-1(Z#x-1(Z#x-1... (y) ...))) y times

It's not great, but it gets the point across informally. I understand that this makes all the following numbers ill-defined, but whatever. Maybe someday I'll figure out how to make a proper definition.

Note from the future: Yeah, this doesn't work. The exponential growth of this notation comes from the stuff outside the brackets, so recursively putting the number in the brackets barely makes it bigger. Or maybe I'm wrong. Who knows. Anyway...

Z#1(10) = Z(10) = Normalium Z = {10,10,26}
Z#2(10) = Z¹⁰(10) = Firium Z ≈ {10,11,1,2}
Electrium Z = Z#10(10) ≈ {10,11,1,10}??? (Maybe? I think I got this wrong so I'll stop using array notation)
Bielectrium Z = Z#20(10)
Trielectrium Z = Z#30(10)
Tetraelectrium Z = Z#40(10)
Quinelectrium Z = Z#50(10)
Decaelectrium Z = Z#100(10)
Centielectrium Z = Z#1000(10)
Millielectrium Z = Z#10000(10)

Hold on, is this even right? Is this the thing I'm going for? I don't think any of this recursion works. I know it's just an attempt, but I'm way out of my depth. I think I'll end off here, with this giant pile of proof that I'm not particularly smart. If I ever do figure it out, maybe I'll return to this, who knows.

If you really read all the way to the end, thank you! You're super cool. Maybe I'll put more parts here later, who knows. Bub-bye for now.