My maths blog! Probably the most popular part of my old site, so I'm moving it here! This whole blog and the journey I embarked on to discover and explain massive numbers was inspired by googologist Sbiis Saibian, you can read his blog here. https://sites.google.com/site/largenumbers
"Large Numbers have done vastly more to make infinity seem large than infinity has ever done to make large numbers seem small"
-- Sbiis Saibian, one of my role models in the field of mathematics
Welcome to my maths blog, where I usually write about huge/infinite numbers! I have an account on the googology wiki under the name User:Binary198.
Maths has always fascinated me, especially big and infinite numbers, so, a couple weeks ago, I decided to write a book/blog about it.
My backstory is similar to Saibian’s (a googologist). As soon as I learned to count, I counted all the time, and, in (German) kindergarten, was the only child who could count to one thousand. Later, on YouTube, I found many maths videos, boosting my knowledge even further, and I learned about exponentiation around two or three years before they taught it to us in school.
Around two years later, at a charity shop, I bought myself a textbook all about maths and by mid-next year, I had finished the algebra, trigonometry, calculus and statistics sections (not saying I understand it all 😂), in other words, the whole book at only the age of 9. Recently I have developed a strange habit of absent-mindedly doing random complicated mental mathematical calculations in my head while doing all sorts of things.
My first encounter with large and infinite numbers was around two years before that, when I saw a Vsauce video about counting to infinity. Before that, all my friends and I knew what infinity was and at school we would have little contests:
“Infinity.”
“Dualfinity.”
“Trifinity.”
“Infinity squared.” (which I now know is the same as infinity). Et cetera. This counting past infinity fascinated me and I did lots of research around the area, until, a couple days ago, I learned about googology (though I knew about the numbers googol and -plex much earlier). I quickly became familiar with the big faces such as Bowers and Saibian, numbers such as googolmekaplex and dossolplex and notations such as BEAF and cascading-E, until I decided to create my own notations such as Hyper-Robin and BIP-array, and make an impact on the future of googology.
When I first encountered googology, I barely played games, preferring to research and write about googology. Also, when doing other things mostly unrelated to maths, I still encountered massive numbers such as quinquagintillion and millinillion, which has, like many other things, only boosted my understanding of maths. When I learned about scientific notation, I was immediately in love, how you could express:
10,000,000,000 as just 1e+10 and one of my favorite numbers, 1,000,000,000,000,000,000,000,000 as 1e+24 (also known as septillion).
Until I learned of googology, the largest number (excluding googolplex) I knew was a Tretrigintatrecentillion Sexagintanongentillion, or 1e+3885 Note: not the most efficient way to express this number, and probably not its official name. But then I heard of googology. I was thinking, “What is BEAF? What is Hyper-E notation? How would these numbers be represented in scientific notation?” For the last question I immediately realized they couldn’t be, which created the realization that scientific notation isn’t as perfect as it seemed. So, now that you know how I first came into contact with these numbers, let us begin our journey.
The very first thing we need to get out of the way is the meaning of the arrows. Knuth's up arrow notation is a notation developed by computer scientist Donald Knuth. One arrow between the two numbers represents exponentiation (2↑2 = 4), two arrows represents tetration (repeated exponentiation, 2↑↑4 = 2↑2↑2↑2 = 2↑2↑4 = 2↑16 = 65536), three arrows represent pentation (2↑↑↑3 = 2↑↑2↑↑2 = 2↑↑4 = 65536), and so on.
First, I decided to make a very simplistic and unintuitive notation which at first I believed was incredibly amazing (hint: it wasn’t really). Here is how it works:
A number is represented as Bx.Py with a certain amount of #s on the end. Each # added a 10↑ to the beginning, then it was calculated from the right to left. So a number was 10↑10↑...(x↑y) with an arrow per #.
Million = B10.P6 or B6.P1#
Billion = B10.P9 or B9.P1#
Trillion = B10.P12 or B12.P1#
Tretrigintatrecentillion Sexagintanongentillion = B10.P3885 or roughly B1000.P3.5894#, I believe.
But then it got clumsy.
Googol = B10.P100 or B10.P2#
Googolplex = B10.P100# or B10.P2##
Googolduplex = B10.P100## or B10.P2###
...
Almost googolmekaplex = log(googolmekaplex) = B10.P100###... (with 1 decillion #s)
And I know this could be shortened to get B10.P100#B10.P33 but that’s still pretty inefficient. After a couple minutes, I had a solution. Add a third variable to significantly reduce the amount of required #s. That third variable was W, short for the bandwidth. It is difficult to explain, but if I give you some examples, I hope you can understand.
Almost googolmekaplex isn’t B10.P100#B10.P33, but rather B10.P100.W33#
I think you can see how efficient this is. Yet, I still wasn’t satisified. So I defined an even MORE efficient notation called BIP-array notation (I was oblivious to the fact that this notation, at least at the linear array level, was identical to Saibian’s stack notation. Great minds think alike, I guess.) And yes, you heard me right. LINEAR array. At the linear level, BIP was infinitely more efficient than BP, though maybe not Enhanced BP. Here is a comparison.
In BIP-array, {x, y, z} = x ↑↑ y with z at the very top of the power tower (which is different to x ↑↑ y ↑ z)
Googol = B10.P100 or B10.P2# = {10, 0, 100}
Googolplex = B10.P100# or B10.P2## = {10, 1, 100}
Googolduplex = B10.P100## or B10.P2### = {10, 2, 100}
...
Almost googolmekaplex = B10.P100.W33# = {10, {10, 0, 12}, 100}
Now, the extension to the planar level is fairly simple. Initially, I defined a planar array as the top row ↑ (the second row...↑ the bottom row)...). Now we could for some reason define googolplex as:
{10, 0, 1
10, 0, 1
100, 0 1}.
I don’t see why I did this as it was more efficient as a linear array. But now I realised how stupidly inefficient this is and changed it to:
{1st element of the first row, {{rest of array}, 2nd element of the first row, 1}, 3rd element of the first row}, so {10, 0, 1
10, 0, 1
100, 0, 1} is no longer 10↑(10↑100), which is googolplex, but instead:
{10, {{10, 0, 1
100, 0, 1}, 0, 1}, 1} =
{10, {{10, {{100, 0, 1}, 0, 1}, 1}, 0, 1}, 1} =
{10, {10, 100, 1}, 1}, which is 10↑↑(10↑↑100), which is literally googolplex but with double arrows instead of single arrows, and will therefore dub "doobolplex".
But then I had an excellent idea. Just like many previous mathematicians, I would invent my own numbers.
Alphagol = Written as {2, 3, 1} in BIP or B2.P16 in BP. Now watch this RIDICULOUS rate of change.
Betagol = Written as {3, 4, 1} in BIP and somehow is now written as B(6 ✕ B(3.6383✕B13.P1#).P1#).P1# in BP. How did we go from B2.P16 to that monstrosity by adding just 1 to 2 of the 3 array arguments? I have no clue, but it proves the efficiency of my BIP.
We can keep going to get Omegagol which is written as {25, 26, 1} in BIP, or {25, 25, 26} in BEAF (I think). This proves that Graham’s number, many of Saibian’s and Bowers’ numbers were all bigger than this (I think). But I wasn’t giving up.
I wouldn’t define Alphagolplex as {10, 0, {2, 3, 1}} aka 10↑Alphagol but rather {10, 11, 1}.
But then I wouldn’t define Betagolplex as {11, 12, 1} or {15, 17, 2}, but rather as a planar array of:
{10, 11, 1
10, 11, 1
10, 11, 1}
That’s right. Now omegagolplex would be a 25-dimensional matrix full of 847288609443 numbers. (The rules of going past planar is the same as linear, but instead of lines, you are operating on planes, and same for going further) Get wrecked xappol. To accelerate towards the infinite I would combine Omegagolplex with previous numbers to get Omegagolduplex, Omegagolmekaplex, Omegahyperalplex, et cetera.
And then there is apexplex. The holy apex of big numbers in my opinion. It is literally impossible to type it as an array without the computer crashing, so I will define it as a function.
f(x) = {1+x, 2+x, 1}, so f(1) = alphagol, f(2) = betagol, etc.
g(x) is an x-dimensional array with each row being {10, 11, 1}, so g(1) = alphagolplex, g(2) = betagolplex, etc.
h(f(x)) = g(x), so h(alphagol) = alphagolplex, h(betagol) = betagolplex
i(x) = h(g(x)
Apexplex = i(i(i(i(...(24)...) with i(i(i(i(...(24)...) - 1 i's with i(i(i(i(...(24)...) - 2 i's ... with i(24) i's
At this point I knew about Rayo’s number and that I had no hope of beating it, but then I heard about Bowers’ oblivion number, which gave me an idea. How about I totally rip Bowers off 🤣 and make my own oblivion, “Infinite Oblivion” which is the largest finite number that could be made using a apexplex amount of symbols in extended BIP notation. And yes, you heard me right. Extended BIP-array notation.
You see, its time for the much needed # among other symbols to return to BIP, with {x, y, z, ...}# is an {x, y, z, ...}-dimensional array with each entry being {x, y, z, ...}. Then there is extreme infinite oblivion which is the largest finite number that can be made with an infinite oblivion amount of symbols, except there is also another new symbol O which represents oblivion so we could create what used to take a apexplex amount of symbols to define in one symbol. But we’re just getting started.
You see, I had enjoyed googology, so I decided to make another notation: Hyper-Robin which was a combination of many of my previous notations as well as some new concepts such as the fast-growing hierarchy. Here is the definition:
f{0}(n) = 1
f{1}(n) = n
f{2}(n) = 2n
f{n}(n) = n↑2
f{n+1}(n) = n↑3, not (n+1)(n+1)
f{n+2}(n) = n↑4
f{2n}(n) = n↑(n+2)
f{3n}(n) = n↑(2n+2)
...
f{x, y}(n) = (2)(f{x}(n↑y))↑f{x}(n↑y) −1 n
I hope you understand how efficient this is. Using simply 2-entry arrays, I belive we can define numbers on par with the Ackermann and weak Goodstein functions (I think). And, like always, we’ll be able to extend this further down to get something like f{x, y} (n).
{z, a}{b, c}
The rest of the definition goes so:
f{x, y, z}(n) = f{{x, y}, {y, z}}(f{n, z}(n))
f{x, y, z, a}(n) = f{{x, y, z}, {y, z, a}}(f{n, x, z}(f{{x, y}, {y, z}, {z, a]}}(n))
f{x, y} (n) = f{f {z, a}}(f{x, y, z, a}(x↑(y↑(z↑a))))
{z, a} {x, y}
Just because, I decided to create some symbols to help this notation define complicated numbers (for the sake of time I removed the f from the arrays and put just the arrays):
{1, 2, 3, 4} ∀ {5, 4, 3, 2} = {6, 6, 6, 6}
{1, 2, 3, 4} ∃ {5, 4, 3, 2} = {1, 4, 6, 8}
{1, 2, 3, 4} ∧ {5, 4, 3, 2} = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}
{1, 2, 3, 4} ∨ {5, 4, 3, 2} = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}
{1, 2, 3, 4} ⟨ {5, 4, 3, 2} = {2, 3, 4, 5, 4, 3, 2, 1}
{1, 2, 3, 4} ⟨⟨ {5, 4, 3, 2} = {3, 4, 5, 4, 3, 2, 1, 2}
{1, 2, 3, 4} → {5, 4, 3, 2} = {5, 4, 3, 2, 1, 2, 3, 4}
{1, 2, 3, 4} ↔ {5, 4, 3, 2} = {5, 4, 4, 3, 3, 2, 2, 1}
{1, 2, 3, 4} ¬ {5, 4, 3, 2} = 5
{1, 2, 3, 4} ⊃ = {1, 2, 3000}
{1, 2, 3, 4} # = 10↑{1, 2, 3, 4}
{1, 2, 3, 4} #2 = ({1, 2, 3, 4} #) #
{1, 2, 3, 4} #3 = (({1, 2, 3, 4} #) #) #
...
{1, 2, 3, 4} ## {1, 2, 3, 4} = {1, 2, 3, 4}#{1, 2, 3, 4}
{1, 2, 3, 4} ##2 {1, 2, 3, 4} = ({1, 2, 3, 4}##)##
...
{1, 2, 3, 4} ### {1, 2, 3, 4} = {1, 2, 3, 4}##{1, 2, 3, 4}
...
{1, 2, 3, 4} ~ = {1, 2, 3, 4}↑10 (basically the opposite of #)
{1, 2, 3, 4} * x = x↑{1, 2, 3, 4} (similar to #, except the exponent varies)
{1, 2, 3, 4} *2x = ({1, 2, 3, 4}*x)*x
...
{1, 2, 3, 4} ** x = {1, 2, 3, 4}*xx
{1, 2, 3, 4} **2 x = ({1, 2, 3, 4} ** x) ** x
{1, 2, 3, 4} *** x = {1, 2, 3, 4}**xx
This is pretty complicated, so here are some examples to help both of us out (I’m too lazy to simplify any of these):
Million = f{14}(10)
Billion = f{17}(10)
Trillion = f{20}(10)
Tretrigintatrecentillion Sexagintanongentillion = f{3893}(10)
...
Googol = f{108}(10)
Googolplex = f{108}(10)#
Googolduplex = f{108}(10)#2
...
Almost googolmekaplex = f{108}(10)## f{20}(10) (Not as efficient as I would have thought, but still)
Now that we have a working notation, let’s get started on defining LOTS of numbers. Likewise to Bowers and Saibian, I am going to sort them into regiments. NOTE: The following section is just going to be a bunch of numbers and descriptions. If you consider that boring, which I think you would, skip to the next section, “Another notation!?”. Now let’s get started! We have a looooooooooot to cover! Also note that they might not all be in order.
Originally I was going to include the numbers here, but considering this blog is an entirely new website, if you want to check out my Hyper-Robin numbers, they will be on the list of numbers page. So, to be honest, we don't have that much to cover.
I am still having lotsa' fun with this, so let us define another notation out of all the ones I will create. We’ll call it Robin-Array notation.
If the last element is 0 or 1, it may be omitted. If the first element is 0, the whole array becomes 0.
{a} = a
{a, b} = ab
{a, b, c} = a↑c b
{a, b, c, d} = {a, b - 1, {a, b, c}, d-1}
{a, b, c, d, e} = {a - 1, b, {a, b, c}, d}↑e {a - 1, b, {a, b, c}, d}
{a, 0, b} = ab
{a, b, 0, c} = abc
{a, b, c, 0, d} = a↑d bc
{a, b, c, d, 0, e} = {a, bc - 1, {a, bc}, d-1}
{a, {b, 0}, c} = {a, b, c} (that’s intuitive, I only put it so you remember)
{a, 0, 1, c} = {a, c, 0, a}
{a, 0, b, c} = {a, b-1, 0, a} (slightly self-contradictory, but whatever)
{a, 0, 0, b, c, d} = {a, 0, d, 1, c, a}
{ax, b, c} = {ax, b, c}
{a, bx, c} = {a, bx, c}
{a, b, cx} = {a, b, cx}
{a{x, y}, b, c} = {ax, ay, b, c}
{a, b{x, y}, c} = {a, bx, by, c}
{a, b, c{x, y}} = {a, b, cx, cy}
{a{x, y, z}, b, c} = {ax, ay, az, b, c}
{a, b{x, y, z}, c} = {a, bx, by, bz, c}
{a, b, c{x, y, z}} = {a, b, cx, cy, cz}
{{x, y, z}a, b, c} = {{xa, ya, za}, {xa, ya, za}, ... {xa, ya, za}} with xyzabc {xa, ya, za}s
{a, {x, y, z}b, c} = {{xb, yb, zb}, {xb, yb, zb}, ... {xb, yb, zb}} with xyzabc {xb, yb, zb}s
...
{a, b, c, #} = {a, b, c, c, c, ... c} with a c’s
{a, b, c, #2} = {a, b, c, c, c, ... c, #} with a c’s
{a, b, c, #3} = {a, b, c, c, c, ... c, #2} with a c’s
...
{a, b, c, #, #} = {a, b, c, #a}
{a, b, c, #, #2} = {a, b, c, #a, #}
{a, b, c, #, #, #} = {a, b, c, #, #a}
...
{a, b, c, #^e} = {a, b, c #, #, #, ... #} with e #s
This allows you to make something like:
{a, b, c, d, #^{e, f, g}}
Rules for higher dimensions:
{a, b, c
d, e, f
g, h, i} = {a, b, c, #^{d, e, f,
g, h, i}} = {a, b, c, #^{d, e, f, #^{g, h, i}}}
Same applies for 3D so you get something like:
{a, b, c, #^{d, e, f, #^{g, h, i, #^{j, k, l, #^{...}}}}} with 8 #^ as opposed to 2, 4D has 26 #^s, etc.
To reach even further for infinity, let’s define some more operators.
{a, b, c, #^#} = {a, b, c, #^, #}
{a, b, c, *} = {a, b, c, #^#}
{a, b, c, *2} = {a, b, c, #^#, *}
{a, b, c, *3} = {a, b, c, #^#, *2}
...
{a, b, c, **} = {a, b, c, #^#, *a-1}
...
{a, b, c, /d} = {a, b, c, ***...*} with d *s
{a, b, c, /{d, e, f}}
{a, b, c, /{d, e, f, /g}}
{a, b, c, /{d, e, f, /{g, h, i}}}
...
{a, b, c, /#} = {a, b, c, /, /, /, ... /} with a /s
{a, b, c, /##} = {a, b, c, /#a}
...
{a, b, c, /#^d} = {a, b, c, /##...#e} with a #s
...
{a, b, c, /{d, e, f, /g}}
...
{a, b, c, /de} = {a, b, c, /(/(..(./e))...)} with d /s
{a, b, c, //d} = {a, b, c, /ad}
...
{a, b, c, //de} = {a, b, c, //(//...//(e))...)} with d //s
{a, b, c, /^de} = {a, b, c, //.../d} with d /s
...
{a, b, c, 0, \d} = {a, b, c, /ad}
{a, b, c, 0, \de} = {a, b, c, \ \ \...}
{a, b, c, 1, \d} = {a, b, c, 0, \\d}
{a, b, c, n, \d}= {a, b, c, 0, \^n+1 d}
Let’s get defining numbers and compare some already existing ones!
By defining them, I mean putting them on an alternate page. So go there if you wanna check it out.
Just for the sake of it, let’s define our best notation yet, Cataclysm notation (after the definition I will also compare the efficiency against other notations)
0[0]0 = 1[0]0 = 0[1]0 = 0[0]1 = 1
a[1]0 = 10↑a, e.g. 100[1]0 = googol
a[b]0 = 10a[b-1]0, e.g. 2[2]0 = 20[1]0 = 100 quintillion
a[b, c]0 = 10↑(a↑cb), e.g. 2[2, 2]0 = 10↑(2↑↑2) = 10 quadrillion?
a[b, c, d]0 = 10↑(a[b, c-1, d-1]0)
a[b, c, d, e]0 = 10↑(a[b, c-1, d-1, e-1]0)
a[b]c = a[b, b-1]c-1, e.g. 2[2]2 = 2[2, 1]1 = 2[2, 1, 2, 0]0 = 10↑(2[1, 1, 1, -1]0)
a[b]c#d = a[a[a[...b...]]]c with d a's
Now let’s compare efficiency.
Number: Million
BP / Enhanced BP: B10.P6 or B6.P1#
BIP-array: {10, 0, 6}
Cataclysm: 6[1]0
BEAF: {10, 6}
FGH: f₂(16)
Hyper-E: E6
Number: Googol
BP / Enhanced BP: B10.P2#
BIP-array: {10, 0, 100}
Cataclysm: 10[2]0
BEAF: {10, 100}
FGH: f₂(323)
Hyper-E: E100
Number: Googolplex
BP / Enhanced BP: B10.P2##
BIP-array: {10, 1, 100}
Cataclysm: 10[100]0
BEAF: {10, {10, 100}}
FGH: f₂(f₂(325))
Hyper-E: E100#2
Number: Googolduplex
BP / Enhanced BP: B10.P2### or B10.P2.W3
BIP-array: {10, 2, 100}
Cataclysm: 10[2]0#2
BEAF: {10, {10, {10, 100}}}
FGH: f₂³(324)
Hyper-E: E100#3
Number: Grangol
BP / Enhanced BP: B10.P2.W2#
BIP-array: {10, 99, 100}
Cataclysm: 10[100]0#50
BEAF: {10,101, 2}
FGH: f₃(100)
Hyper-E: E100#100
Number: Grangolplex (googolcentiplex)
BP / Enhanced BP: B10.P2.W101
BIP-array: {10, 100, 100}
Cataclysm: 10[2]0#51
BEAF: {10,102, 2}
FGH: f₃(103)
Hyper-E: E100#101
Number: Almost googolmekaplex
BP / Enhanced BP: B10.P2.W33#
BIP-array: {10, {10, 0, 33} - 1, 100}
Cataclysm: 10[100]0#(5×32[1]0)
BEAF: {10, {10, 33}+1, 2}
FGH: ?
Hyper-E: E100#E33
I developed a notation / hierarchy which isn't very precise at defining large numbers, but definitely creates very big ones. I'm not going to include it because just no lol. Now let’s head to and surpass infinity!
Describing infinity and numbers after it requires understanding of set theory.
First, what are cardinals? A cardinal is a number used to count the amount of elements in an array, such as 2, 3, 7, 100, googol, googolplex, whatever. The cardinality of a set is the amount of items in it. The way to prove if multiple sets have the same cardinality is if you are able to pair 1 to 1 each item in those sets.
Now, you may be wondering, how does this relate to infinity? You’ll see. For infinity isn’t, as I learned, a number, but rather a kind of number. Yes, there are multiple infinities that have different sizes. Most of the time, when people say infinity, they usually mean the smallest infinity, aleph null (the symbol is too hard to type). Aleph null is the cardinality of the natural numbers (which are 1, 2, 3, 4, 5, 6, ...).
Now, you would think that counting past aleph null is easy. But it’s not really. Say you drew an aleph null amount of lines, representing the natural numbers and draw another line after all those lines. What is represented by that number? You would think it is aleph null plus one, but it’s not. This line can represented as one and the first drawn line is two and so on. You could move that line to the beginning and you would notice you still only have aleph null lines despite drawing another one.
You could draw another aleph null amount of lines, and the first set could represent the even numbers and the second set of lines could represent the odd ones. Let’s dial back to when we had just one line after the aleph null lines. If we insist on labelling the lines in the order we drew them in, what is the value represented by the last line? Well it is clearly not one or two or anything because we have drawn those already. Finally we have reached the number beyond aleph null, omega. (ω) But don’t think this is the last number. Certainly not! For we can get ω+1, which doesn’t sound like a number but it is, ω+2, ω+3 ... Also, remember that because omega was achieved by labelling in order, it is not a cardinal, but an ordinal. Remember this, for it will be important.
Eventually we reach ω*2, ω*3, ... and ω2. We don’t have to stop there though! We can keep going until we get ω↑↑ ω (which is ω↑ω↑ω↑ω↑...↑ ω with ω ↑s). That number is called epsilon zero or Ɛ0. Now if we do Ɛ0↑↑Ɛ0 we get Ɛ1, Ɛ1↑↑Ɛ1 = Ɛ2, etc. Then once we get ƐƐ
Ɛ..., that number is called ζ0 (zeta zero). We repeat this to get η0 and Γ0. Now if you go far far far far... beyond this, you can eventually (yeah right) arrive at omega-one, written as ω1 or Ω. This number is the amount of the real numbers, which include the natural numbers, all the negative natural numbers, all the fractions, every single decimal, any finite number you can think of. You can quickly realize how big this is. If you were naive and listed 0.0000000000000000000000000000000000000000000000000000000000000000000000000001 as the first number, this is clearly more like the aleph nullth number because you can get 0.0000000000000000000000000000000000000000000000000000000000000000000000000001 to the power of googolduplex to the power of a meamealokkapoowa oompa and I don’t even know what.
Later on there clearly there must be ω2 somewhere and ω3 and something.
Let’s start describing numbers past that.
Inaccessible - A number that cannot be reached from below. Aleph null and ω1 are examples of this.
Large cardinal - Equal to ωω
ωω... with a literally unending amount of ωs. It can be more compactly described as:
ωa where a = ωa, which as you can clearly tell causes a causality loop that create an unending amount of ωs. What you used as the original value of a honestly doesn’t matter.
Weakly compact - “A cardinal κ is defined to be weakly compact if it is uncountable and for every function f: [κ] 2 → {0, 1} there is a set of cardinality κ that is homogeneous for f. In this context, [κ] 2 means the set of 2-element subsets of κ, and a subset S of κ is homogeneous for f if and only if either all of [S]2 maps to 0 or all of it maps to 1.” Not helpful wikipedia.
Maybe the googology wiki has something better. “Let [x]2 be all the 2-element subsets of x. Then an uncountable cardinal α is weakly compact if and only if, for every function f:[α]2→{0,1}, there is a set S⊆α such that |S|=α and f maps every member of [S]2 to either all 0 or all 1.”
I didn’t and still don't really get this. Neither do I think I would get anything past this, so let’s just ignore all that I0 and I3 and I don’t even know stuff and go back to the realm of the finite for the time being.
I have decided to make another notation that will hopefully be one of the most efficient notations. For its roots, I’m not building on BIP or cataclysm but the relatively old enhanced BP!
Super-BP notation
Bx.Py.Wz#a = (10↑↑(10↑↑a-1)↑z)↑(xy), I think
Bx.Py.Wz#a#b = Bx.Py.Wz#(Bx.Py.Wz#a#b-1)
Bx.Py.Wz##a = Bx.Py.Wz#a#a#a#a#a...#a with a repetitions of #a
Bx.Py.Wz#^#a = Bx.Py.Wz#####...#a with a repetitions of #
Bx.Py.Wz#^^#a = Bx.Py.Wz#^#^#^...^#a with a repetitions of #^
Bx.Py.Wz#^^^#a = Bx.Py.Wz((..((#^^#)^^#)..)^^#)^^#a with a repetitions of ^^#
Bx.Py.Wz#αb = Bx.P(Bx.Py.Wz#α(b-1)).Wz
Bx.Py.Wz#βa = Bx.Py.Wz#α(Bx.Py.Wz#β(b-1))
...
Bx.Py.Wz#Ωa = Bx.Py.Wz#ω(Bx.Py.Wz#Ω(b-1))
NOTE: The greek letter progression goes lowercase alpha, lowercase beta, lowercase gamma, capital gamma, lowercase delta, capital delta, lowercase epsilon, lowercase zeta, lowercase eta, lowercase theta, capital theta, lowercase lambda, lowercase xi, capital xi, capital phi, capital psi, lowercase omega, capital omega.
B10.P100.W100#100 = (10↑↑(10↑↑99))googol, I think
B10.P100.W100#10#100 = B10.P100.W100#(B10.P100.W100#10#99) ...
B10.P100.W100##10 = B10.P100.W100#10#10#10#10#10#10#10#10#10#10
B10.P100.W100#^#10 = B10.P100.W100##########10
B10.P100.W100#^^#10 = B10.P100.W100#^#^#^#^#^#^#^#^#^#10
B10.P100.W100#^^^#10 = B10.B100.W100#^^#^^#^^#^^#^^#^^#^^#^^#^^#10
B10.P100.W100#α10 = B10.P(B10.P100.W100#α9).W100 ...
Now that we have a greater understanding of ordinals, let’s define an array notation using them! :
[α] = α
[α, n] = αn
[α, ω] =α2 + 1
[α, ωn] =αn+1 + 1
[α, ωω] = αα2+1+1
...
Examples:
[2] = 2
[2, 2] = 4
[2, ω] = 5
[2, ω2] = 9
[2, ωω] = 33
[2, ε0] = 8.59 billion
[2, ε1] >> 2 ↑↑ 4.3 billion
[2, ε2] >> 2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2)
[2, ε3] >> 2 ↑↑ (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ÷ 2)
[2, εε0] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s
[2, εε1] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ 4.3 billion 2 ↑↑s
...
[2, εεε0] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s 2 ↑↑s
[2, ζ0] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s 2 ↑↑s 2 ↑↑s ... 2 ↑↑s with 8.59 billion 2 ↑↑s, I think
[2, ζ1] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s 2 ↑↑s 2 ↑↑s ... 2 ↑↑s with 2 ↑↑ 4.3 billion 2 ↑↑s, I think
...
[2, ζζ0] >> 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s 2 ↑↑s 2 ↑↑s ... 2 ↑↑s with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 2 ↑↑ ... (2 ↑↑ (2 ↑↑ 4.3 billion ÷ 2) ... ÷ 2) with 8.59 billion 2 ↑↑s 2 ↑↑s 2 ↑↑s ... 2 ↑↑s with 8.59 billion 2 ↑↑s, I think
... Now that’s absolutely massive. But of course you can always go higher. But of course I can’t be bothered to write more examples because it is starting to hurt my brain.
More (smaller) examples!
[10, ω] = 101
[10, ω2] = 1001
[10, ωω] = 10101 + 1 (which is already bigger than googol!)
[10, ε0] ~ 10↑↑10↑2
[10, ε1] ~ 10↑↑(10↑↑10↑2 ÷ 10)
[10, ε2] ~ 10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10)
[10, ε3] ~ 10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10)
...
[10, εε0] ~ 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s
[10, εε1] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑(10↑↑10↑2 ÷ 10) 10↑↑s
...
[10, εεε0] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s
[10, ζ0] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑10↑2 10↑↑s.
[10, ζ1] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑(10↑↑10↑2 ÷ 10) 10↑↑s.
[10, ζζ0] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s.
Oh my goodness. What monstrosity have I created? Let’s go further and create the most unimaginable numbers ever! My brain is starting to hurt again, so pardon me if the calculations are off.
[10, η0] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s ... 10↑↑s 10↑↑s 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑10↑2 10↑↑s. 10↑↑s
[10, η1] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s ... 10↑↑s 10↑↑s 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑(10↑↑10↑2 ÷ 10) 10↑↑s 10↑↑s.
[10, η2] = 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s ... 10↑↑s 10↑↑s 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s.
[10, η3] = 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s ... 10↑↑s 10↑↑s 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s ... 10↑↑s with 10↑↑ ... (10↑↑(10↑↑(10↑↑(10↑↑10↑2 ÷ 10) ÷ 10) ÷ 10) ... ÷ 10) with 10↑↑10↑2 10↑↑s 10↑↑s 10↑↑s.
I had an idea! Let’s define a couple more numbers using all our previous notations, starting with ordinal array notation (original, I know)
Hyper = [2, ω2] = 9
Hyperplex = [2, ω9] = 1025
Hyperduplex = [2, ω1025] ~ 7.2 × 10308
Hyper-n-plex = [2, ωHyper-(n-1)-plex] = 2Hyper-(n-1)-plex + 1
Super Hyper = [3, ω3] = 82
Super Hyperplex = [3, ω82] ~ 4 × 1039
Super Hyper-n-plex = [3, ωHyper-(n-1)-plex]
Ultra Hyper = [4, ω4] = Hyperplex
Ultra Hyperplex = [4, ω1025] ~ 5.2 × 10617
Ultimate Hyper = [5, ω5] = 15,626
Ultimate Hyperplex = [5, ω15,626] ~ 6.4 × 1010,922
Transcendent Hyper = [6, ω6] = 279,937
Transcendent Hyperplex = [6, ω279,937] ~ 1.3 × 10217,834
Meta Hyper = [7, ω7] ~ 5.8 × 106
Meta Hyperplex = [7, ω5.8 million] ~ 5.2 × 104.9 million
Ultra Meta Hyper = [10, ω10] ~ 1 × 1011
Ultra Meta Hyperplex ~ 1 × 10100 billion
Ultimate Meta Hyper = [ultra meta hyper, ωultra meta hyper] ~ 101.1 trillion
Ultimate Meta Hyperplex = [ultimate meta hyper, ωultimate mega hyper] ~ 101.1 ultimate meta hyper
(My lousy attempt at making a pop culture reference, where the "future" refers to the realm of the infinite)
I have achieved comedy.
In case you couldn't tell, today's section will have more memes and humour because I'm in that kind of mood. Jokes aside, let's do some stuff in infinity! Now that I have been away from writing my website for a while, I have a much better understanding of the infinite. But first, let’s describe what I have made to do with the infinite while I was away.
I learned about ordinal collapsing functions and discovered that previously I was wrong, ω = ℵ0 (that’s how you type aleph null), omega isn’t greater, they are equal. Anyway, back to the ordinal collapsing functions. As you can probably guess, my first one wasn’t so efficient. Here it is.
τ0(α) = ω+α
τ1(α) = ω·α
τ2(α) = ωα
τα+1(β) = ταβ(β)
τα(β, γ) = ταγ+1(β)
...
ω = τ0(0)
ω2 = τ2(2)
ε0 = τ3(ω)
...
I improved the function to make lambda! Until you get to the higher numbers, the difference isn’t too drastic.
λ(α, β) = τα(β)
λ(α, β, γ) = λ(α, λ(α, β, γ-1)) ≠ τα(β, γ)
λ(α, β, γ, δ) = λ(α, β, λ(α, β, γ, δ-1))
...
λ(α, β, γ, ... δ, 1) = λ(α, β, γ, ... δ)
ω = λ(0, 0)
ω2 = λ(2, 2)
ωω = λ(3, 1)
ε0 = λ(3, ω)
λ(6, 5, 4, 3) = λ(6, 5, λ(6, 5, 4, 2)) = λ(6, 5, λ(6, 5, λ(6, 5, 4))) =
λ(6, 5, λ(6, 5, λ(6, λ(6, 5, 3)))) = λ(6, 5, λ(6, 5, λ(6, λ(6, λ(6, 5, 2))))) =
λ(6, 5, λ(6, 5, λ(6, λ(6, λ(6, λ(6, 5)))))) =
λ(6, 5, λ(6, 5, λ(6, λ(6, λ(6, ω↑55))))) = λ(6, 5, λ(6, 5, λ(6, λ(6, ω↑5(ω↑55))))) =
λ(6, 5, λ(6, 5, λ(6, ω↑5(ω↑5(ω↑55))))) = λ(6, 5, λ(6, 5, ω↑5(ω↑5(ω↑5(ω↑55))))) ...
Such wow. Much amaze.
Now let’s create a dictionary for the large cardinals so we can define everything at once.
Set - This may be simple, but actually, all numbers are sets under the hood. For example, 0 = {}, 1 = {{}} = {0}, 2 = {{}, {{}}} = {0, 1}, then you can say 1 < 2 because 1 is a member of 2.
Cartesian product - If A = {1, 2, 3} and B = {4, 5, 6}, the cartesian product of A and B = {(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)}
Binary relation - A binary relation over A and B is a subset of their cartesian product.
Cofinal set - If A is a set and F is a binary relation on A, then a subset of A, called B, is said to be cofinal if and only if:
For every a which is an element of A, then there exists a b which is an element of B, and a F b.
Cofinality - For a set A, the cofinality of A is the smallest of the cardinalities of the cofinal subsets of A.
Regular cardinal - A cardinal is called regular if it is equal to its own cofinality. All cardinals below ω are regular.
Unbounded set - There does not exist a number α such that for any β which is an element of A, α > β.
Open set - I don’t really understand this, so I guess I’m not much of a help. You can look it up on Wikipedia or something.
Closed set - A set is called closed if the set of the elements not belonging to it is an open set.
Club set - A set that is both closed and unbounded.
Stationary set - For a cardinal κ with a cofinality equal to or above ω1, a subset S of κ is called stationary in κ if the intersection of all club subsets of κ is itself a subset of S.
Structure - A structure consists of a set along with finitary operations and relations defined on it.
Domain - The domain of a structure is an arbitrary set, apparently. Doesn’t make much sense, but I will trust Wikipedia on this.
Inner model - Larger infinities are based around model theory and logic, so you will hear this term a lot. Essentially, if L signifies the language of set theory, S is a particular set theory such as ZFC, and T (possibly the same as S) is a theory in L. Then if M follows the rules of L (the official term for it is, "M is a model for L") and N is an L-structure (no idea what this means), then N is an inner model of T if N is a substructure (like a subset, except it applies to models or structures) of M, N follows the rules of T, the domain of N is a transitive class of M and N contains all ordinals of M.
Weak limit - A cardinal κ is called a weak limit if for any λ below κ, κ cannot be obtained through any amount of +1 applied to λ. Aleph null is an example.
Strong limit - A cardinal is called a strong limit if for any λ below κ, κ is greater than 2λ. Strong limits are also weak limits. Aleph null is an example.
Weakly inaccessible - A cardinal κ is weakly inaccessible if it is a regular weak limit.
Strongly inaccessible - A cardinal κ is strongly inaccessible if it greater than the sum of up to κ cardinals below κ.
α-inaccessible - This term is ambiguous, but usually authors use it to mean that a cardinal κ is called α-inaccessible, for any ordinal α, if κ is inaccessible and for every ordinal β < α, the set of β-inaccessibles less than κ is an unbounded subset of κ.
Hyper-inaccessible - A cardinal κ is hyper-inaccessible if it is κ-inaccessible.
Weakly Mahlo - A cardinal κ is weakly Mahlo if it is weakly inaccessible and the set of weakly inaccessible cardinals less than κ is stationary in κ.
Strongly Mahlo - A cardinal κ is weakly Mahlo if it is strongly inaccessible and the set of strongly inaccessible cardinals less than κ is stationary in κ.
α-Mahlo - This term is also ambigious, but usually authors use it to mean that a cardinal κ is called α-Mahlo, for any ordinal α, if κ is strongly inaccessible and for every ordinal β<α, the set of β-Mahlo cardinals below κ is stationary in κ.
Hyper-Mahlo - A cardinal κ is hyper-Mahlo if it is κ-Mahlo.
Weakly compact - A cardinal κ is weakly compact if it is equal to or above ω1 and I will explain the rest using an analogy. Say you have a graph of κ many points, and you draw a line between each pair of points, and you give each line a colour: red or blue. Then there is a set of κ many points such that all the lines between the points of that set are of the same colour.
Today, I made the "new ordinal-based array notation" (NOBAN). The original version used the following rules, but they were inconsistent / self-contradictory:
[a, b] = ab
[a, ω] = aa
[a, ω+b] = ab
[a, ω·2] = a↑↑a
[a, ω·b] = a↑↑b-2
[a, ω2] = a↑↑↑a
[a, ωb] = a↑↑↑b-2
[a, ωω] = a↑↑↑aa-1
[a, ω↑ωω] = a↑↑↑↑a
Therefore, a googol would be written as [10, ω+100]. Then, I created NOBAN 2.0, which isn't self-contradictory and is more efficient:
[a, b] = ab
[a, ω] = aa
[a, ω+b] = a↑(a·ab)
[a, ω·2] = a↑(a·a↑↑a)
[a, ω·b] = a↑(a·a↑ba)
[a, ω2] = a↑(a·a↑(a↑a-1)a)
[a, ωb] = a↑(a·a↑(a↑(a↑...(a-1...))) with b-1 a'sa)
[a, ωω] = a↑(a·a↑(a↑(a↑...(a-1...))) with a↑a-1 a'sa)
Therefore, a googol would be written as [10, ω+1], making 2.0 at least 100 times more efficient than 1.0.
I also developed an array notation MU5 (Modified Username5243's Array Notation). I'll probably include it later.
I'm back! Let's include the definition of MU5!
{a, b}0 = ab
{a, 1}{c, d} = {a, 1}c = a
{a, b}c = {a, {a, b-1}c}c-1
{a, b}{c, d} = {a, {a, b-1}{c, d}}{c, d-1}
{a, b}{0, d} = {a, a}{b, d-1}
{a, b}{c, 0} = {a, b}c
{a, 0}b = 1
{a, b}{0, 0, c, d} = {a, a}{0, b, c-1, d} = {a, a}{a, b-1, c-2, d-1}
{a, b}{c#1, d} = {a, b}{c, c, c, ..., c#1, d-1}, with b c's
{a, b}{c#n, d} = {a, b}{c#n-1, c#n-1, c#n-1, ..., c#n-1, d-1) with b c#n-1's
{a, b}{c#[0, d], e} = {a, b}, {c#[0, d], e-1#[0,d], e-1#[0, d], ... e-1#[0, d]} with d [0, d]'s
{a, b}{c#[d, e], f} = {a, b}, {c#[d, e], f-1#[d, e], f-1#[d, e], ... f-1#[d, e]} with {d, e}d-1 [d, e]s
{a, b}{c, c, c, ... c#d, 0} # {a, b}{c, c, c, ..., c}
As you can tell, I like skipping between infinity and the realm of the finite, so let's go to infinity! I have learned more about ordinal collapsing functions recently, and have therefore invented some more of my own. It turns out OCFs are impredicative, so the previous "OCF"s I defined are actually just ordinal functions. First of all, let's showcase some already existing OCFs!
Buchholz's ψ function
C0ν(α) = Ων
Cn + 1ν(α) = Cnν(α) ∪ {γ | P(γ) ⊆ Cnν(α)} ∪ {ψν(ξ) | ξ ∈ α ∩ Cnν(α) ∧ ξ ∈ Cu(ξ) ∧ u ≤ ω}
Cν(α) = ⋃ Cnν(α)
ψν(α) = min({γ | γ ∉ Cν(α)})
Feferman's θ function
C0(α, β) = β ∪ {0, ω1, ω2, … , ωω}
Cn + 1(α, β) = {γ + δ, θξ(η) | γ, δ, ξ, η ∈ Cn(α, β); ξ < α}
C(α, β) = ⋃ Cn(α, β) ∀n < ω
θα(β) = min({γ | γ ∉ C(α, γ) ∧ ∀δ < β: θα(δ) < γ})
Weiermann's ϑ function
C0(α, β) = β ∪ {0, ω1}
Cn + 1(α, β) = {γ + δ, ωγ, ϑ(η) | γ, δ, η ∈ Cn(α, β); η < α}
C(α, β) = ⋃ Cn(α, β) ∀n < ω
ϑ(α) = min({β < ω1 | C(α, β) ∩ ω1 ⊆ β ∧ α ∈ C(α, β)})
Now it's my turn!
My ρ function
Ci0(α) = ωi ∪ {0, 1, ω, ω1} ∪ ρi+1(0)
Ciβ+1(α) = {δ + θ, δθ, δθ | δ, θ ∈ Ciβ(α)}
Ci(α) = ⋃ Ciβ(α) ∀β < ω
C(α) = ⋃ Ci(α) ∀i < ω
ρi(α) = min({γ | γ ∉ Ci(α)})
ρ(α) = min({γ | γ ∉ C(α)})
My Ξ function
α ∪ ωn ⊆ Cn(α)
μ, ν ∈ Cn(α) ⇒ μ + ν ∈ Cn(α)
C0(α) = α ∪ {0, 1, ω, ω1} ∪ ωα
Cn+1(α) = {γ + δ, Ξι(κ) | γ, δ, ι, κ ∈ Cn(α); ι < α}
Ξn(α) = min({λ < ωα | Cn(α) ∩ ωα ⊆ α ∧ α ∈ Cn(α)} ∪ ωα)
I know my blog has been inactive for a while, but finally I have returned! And with me, I have created a new very strong notation! It is called galaxy array notation.
So, it seems like everyone has their own array notation nowadays: time for me to break my brain, the brain of everyone else, and even reality itself. This array notation has lots of chunks, so I will split it into multiple sections, with 5 parts per section. The first section is Dimensional Galaxy Array Notation. Without further ado, let's get into it!
Linear and basic rules
Case M1 (2 entries) {a,b}=ab
Case M2 (tailing zero) {#0}={#}
Case M3 (replacement) {a,b#0,d+1}={a,b#b,d}
Case M4 (expansion) {a,b+1#c+1,d} = {a,{a,{…{a,a#c,d}…}#c,d}#c,d} w/ b layers
You can easily see that {a,b,c} = a{c}b using Bowers' operator notation. The limit of the system so far is ω^ω.
Separators
Case A1 (semicolon) {#x;y#}={#x,x,…,x#} w/ y copies of x
Case A2 (curly braces) {#x{0}y#}={#x;y#}
Case A3 (curly braces) {#x{n+1}y#}={#x{n}x{n}…{n}x#} w/ y copies of x
{x;y} is very similar to Bowers' y&x operator. The limit now is ω^ω^ω.
Coining numbers
I will coin some numbers, based off of threes and tens, with this system:
Superuntri: {3,3,3,3}
Superdutri: {3,3,3,3,3}
Supertritri: {3,3,3,3,3,3}
Ultrauntri: {3,3;3,3}
Ultradutri: {3,3;3,3,3}
Ultratritri: {3,3;3,3,3,3}
Hyperuntri: {3;3;3;3}
Hyperdutri: {3;3;3;3;3}
Hypertritri: {3;3;3;3;3;3}
Tetra-untri: {3{3}3}
Tetra-dutri: {3{3}3{3}3}
Tetra-tritri: {3{3}3{3}3{3}3}
Superundeca: {10,10,10,10}
Superdudeca: {10,10,10,10,10}
Supertrideca: {10,10,10,10,10,10}
Ultraundeca: {10,10;10,10}
Ultradudeca: {10,10;10,10,10}
Ultratrideca: {10,10;10,10,10,10}
Hyperundeca: {10;10;10;10}
Hyperdudeca: {10;10;10;10;10}
Hypertrideca: {10;10;10;10;10;10}
Tetra-undeca: {10{10}10}
Tetra-dudeca: {10{10}10{10}10}
Tetra-trideca: {10{10}10{10}10{10}10}
So it turns out that the previous notation is ill-defined. I will try to fix the mistakes:
Domain: All valid expressions are sets of nonnegative integers contained within curly braces, separated by commas, semicolons or curly braces with numbers within. For example, {3,2;5} is a valid expression, while [2[2]]5 is not.
a, b, c, d, x, y and n are intended to be nonnegative integers. # represents the (maybe empty) remainder of the array, which is currently unnecessary for the calculation.
+1 is the successor function, mapping a nonnegative integer to the smallest larger nonnegative integer.
#0 is shorthand for #&0, where & is one of the given separators. So, applying case M2 to {2,2,2,0} would not give {2,2,2,} but {2,2,2}.
All cases listed above are from most important to least important, so in a case like {1,3;3,1}, apply case M4 before A1.
P進大好きbot says that there is no rule applicable to {1;2;3;4}. This was the case, but now A1 is applicable as # may be empty.