Post-Omega Ordinals

>10kB Large Page
We are to inform you, "Post-Omega Ordinals" is a very large page. Pages longer than 10 ~ 20kB may lag on lower-end devices. Proceed with risk if you have such a device!
"Who actually reads these?" - fish (2023)

Note: This is not taken from anywhere, this is made by me. It is not an official page nor meant to be official. Inspired by Mathis R.V. and NO!. So, welcome to My Ideas for numbers Beyond Absolute Infinity (Ω)! Feel free to add comments and extend this! The only rule is DON’T DELETE ANYTHING without the collaborators’ permission and also try not to disrupt the flow of the page too much, but if you’re extending a series, suggesting ideas, defining a section or anything else really please go ahead!! All of my concepts will be here. JOIN ME ON MY QUEST FOR THE ULTIMATE Π!!!!!

Tip: {x} is used to denote a ‘package’, which is an independent number. These are useful for grouping functions together to define things and prevent the confusion of 1 Greek Letter with the other. Look out for curly brackets!

Tip 2: [Scope - x] = The number of this list is a size of Mathis RV's number.

• Byte Count: 43 kB (Let’s get to 50 kB!) THIS PAGE CURRENTLY HOLDS THE TITLE OF LARGEST PAGE IN THIS WIKI.
• Current Collaborators: Someone who owns a fish, AdjectiveNounNumber69, Xenoshey

Beyond Absolute Infinity

Ω, Ω*2, Ω*3, … Ω*∞, … Ω*Ω, Ω², Ω³, Ω⁴, … Ω^∞, … Ω^Ω … Ω^ΩΩ, Ω^ΩΩΩ, … Ω^^Ω, Ω^^^Ω, Ω^^^^Ω … Ω↑^ΩΩ, Ω₁, Ω₂, Ω₃ … Ω_Ω … Ω_ΩΩ, Ω_ΩΩΩ … Ω↓2^#, Ω↓3, Ω↓4 … Ω↓Ω … Ω↓²Ω, Ω↓³Ω,Ω↓⁴Ω … Ω↓^ΩΩ … ΩL_Ω*2^†, ΩL_Ω*3 … ΩL_Ω*Ω … ΩL_Ω² … ^‡ … ΩF₂, ΩF₃ … ΩF_ΩF1 … ΩRL₃ … and so on and so forth...

^#Do note x↓x in this case means x_x, where x is a transfinite numeral.

^† L means level. Addition is 0, multiplication is 1, exponentiation is 2, and so on. Subscript is level Ω, down-arrow is level Ω+1, you see where I’m going. Once you get through all the down arrow chains, you get to Ω*2. And so on and so forth.

^‡ This goes through ALL the previous versions of Omega. Once you reach meta-levels you go to a different floor. Then you go through the absolute infinity of things beyond floors and such. Each type is denoted as a Recursion (RL). Until...

Symbolfinities

Ω↔I (Absolute Inaccessible) [Scope - Absolutely Everything] The inaccessible version of Absolute Infinity. Just like the original I, it cannot be reached by any amount of recursions, powers sets or arithmetic. This function can be applied for all the transfinite ordinals between I and Ω. Effectively Ω↔I to Absolute Infinity is the same as I to Regular Infinity.

Note: I’m not defining finities with this part, I’m just defining functions that could be used to generate unimaginably large finities. Feel free to use my notations! Just link to this page so people don’t get confused.

This also includes THE ENDLESS QUEST FOR Π.

Sigma Notation & Sigmafinity (ς) [Scope - Absolutely Infinity Ultimate Universe]

DO NOTE THAT FUNCTIONS AND NUMBERS IN THIS ENTIRE SECTION ARE INDEPENDENT FROM ONES OUTSIDE THIS PAGE UNLESS STATED OTHERWISE.

• Assume ⓵ is equal to Ω↔I, for simplicity’s sake.
• The function ς(x) is defined as (x↑^xx)&^x. (where you make x repetitions of (x↑^xx) and put BEAF &s between them).
  • ⓶ = ς(⓵), ⓷ = ς(⓶), and so on...
• A special feature of ς is that when you increase the circled number by one, if there are multiple inputs, you put the entire thing in itself.
• Now define ς*(x) as ς(ς(ς(... x copies of ς(x)... (x))), and ς**(x) as ς*(ς*(ς*(... x copies of ς*(x)... (x))), and so on.
• For simplicity’s sake, ς*n(x) is ς*(x) with n asterisks.
  • {⓶*⓶} = ς*⓵(⓵), {⓷*⓷} = ς*{⓶*⓶}({⓶*⓶}), and so on...
• After that, ς*[n](x) is ς*n(x), but in the slots of n and x, put ς*n(x), n times.
• You can see where I’m going with this. You could replace the [n] slot, over and over. Each time you do this, add one to the level. And, starting at 0 here, you can set the level like this ς*L{n}(x), where {n} is the level.
  • {⓶*[⓶]} = ς*[⓵](⓵), {⓷*[⓷]} = ς*[{⓶*[⓶]}]({⓶*[⓶]}), and so on...
  • {⓶*L[⓶]} = ς*L{⓵}(⓵), {⓷*L[⓷]} = ς*L{{⓶*L[⓶]}}({⓶*L[⓶]}), and so on...
• Now we can define {ς.x} as {ⓧ*L[ⓧ]}. Each subsequent ς. in the chain puts everything in front of it in the formula. As is tradition, for writing convenience, let’s define {ς.[n]x}, where [n] is the number of ς.s.
  • {ς.[⓶]⓶} = {ς.[⓵]⓵}, {ς.[⓷]⓷} = {ς.[{ς.[⓶]⓶}]{ς.[⓶]⓶}}, and so on...
• Now, let’s define λ(x) as {ς.[ⓧ]ⓧ}. λ*(x) will mean do λ(ⓧ), λ(ⓧ) times. Now you can see how we can just define all the variants of λ just like ς. Let’s denote ς(x) as ς₀(x), λ(x) as ς₁(x) and so on.
• Now let’s go on to define some more notation before we start defining new numbers.

Properties

• Coin conversion: To put a number in a coin, (ie. x to ⓧ), the function is {ⓧ_n(x)}. The n signifies coin stage, since for every function in ς the coin numbers are different in relation to each other. So the stage indicates what demonstration # you are on.
• Function nesting: When defining functions of coins > 2, nest the functions in their own inputs.

Super ς and other variants

With SUPER ς, ς#₀(x) = {ⓧ_c(c)}, c being σ↓^σ_⓵σ_⓵. (↓, of course, meaning repeated σ_σσσ...s). Then, repeatedly apply ς#₀(x), σ_{ⓧx(x)} times. Let’s call the whole function ς#₁(x). Keep applying σ_{ⓧx(x)} times, defining, & repeating, in fact, σ_{ⓧx(x)} times. Define a NEW sigmafinity, let’s call it σ_x[1]. And define it using ς#[1](x) instead of ς, which is ς#_σ{ⓧx(x)}(x). Then use this NEW sigmafinity in the definition of ς#, which turns into ς#[1]_σ{ⓧx(x)}(x), which turns into ς#[2](x), and so on, until you reach ς#_σ{ⓧz(z)}(z), where z is σ_{{ⓧ⓵(⓵)}}, using the original sigmafinity. That is SUPER ς, or ς#_#(x).

Sigmafinity 2 (σ) [Scope - Absolutely Infinity Complex-Ultimate Universe]

At the very start set σ₀ to ς_⓵(ς_⓵(ς_⓵... ⓵ copies...(⓵), but replace all the ⓵s with ς_{{ⓧ⓵(⓵)}}(ς_{{ⓧ⓵(⓵)}}) {ⓧ_⓵(⓵)} times. The formula for generating new sigmafinities is:

1. First, generate the first deltafinity like so: δ_x = ς_σx-1(ς_σx-1(... σ_x-1 copies ... (σ_x-1)
2. Then, generate σ_x-1 new deltafinities, like so.
3. Generate a function that goes as such for generating deltafinities: δ_x = ς_δx-1(δ_ςδx-1) Set Δ to {ⓧ_δ(δ)}.
4. σ_x = ς_{ⓧz(z)}(ς_{ⓧz(z)}), where z is (ς_{ⓧΔ(Δ)}({ⓧ_Δ(Δ)})).
5. Do this over and over for more sigmafinities.
6. For SUPER SIGMAFINITY (σ#_x), generate σ_x-1 new layers of deltafinity, so that on each layer, σ_x just becomes the first deltafinity in another series, and also replace all the ςs with SUPER ςs.

You can also get deltafinities like so: δ_[x,y], where x is the level of σ and y is the level of δ.

Pifinity - The better ς [Scope - Absolutely Infinity Never-Ultimate Universe]

• Define a π function that goes as follows: π(x) = a_x = ς#_#ax-1(a_ς#ax-1), where a₀ is ς#_#σ#b(ς#_#σ#b), replaced ς#_#σ#x(ς#_#σ#x) times. Then replace the ‘b’s at the end with σ#_x.
• Make π*(x) equal to π(x) repeated x times. Then π*(2)(x) means instead of repeating π* like in ς, you put x asterisks!. (3) next to the will mean you repeat the (2) nest to the asterisks and so on.
• Then, π*[n](x) is π*(n)(x) but in the place of n and x put π*(n)(x) in of themselves, [n] times. At the end, just put π*(x)(x).
• After that, define the variations of π just like you would with ς, until you get to π_n(x) and beyond.
• Finally, {πⓧ_n(x)} is the same as regular {ⓧ_n(x)}, but you put the entre function in itself {πⓧ_n(x)} times. x, of course, is the number you turn into a coin, and n is n in π_n(x). The coination process is different too. For each higher coin, (lets say the coin # is x) you nest π_n(x) {ⓧ_x(x)} times, (this stacks!) then you nested regular coinate them using {ⓧ_x(x)}, {ⓧ_x(x)} times. THEN, for each next coin, you replace all the last coin’s greater method of coinating (in this case the one listed), and set that to THIS COIN’S REGULAR coination method (takes the place of regular coination), which makes things grow real fast.
• However, the actual π_n(x) is defined like Super ς, except for Super π and the coins are {πⓧ_πn(x)(π_n(x))}. So, this Super Pi Notation is π#_#n(x). Applying it to itself increases n by one.
• Then, switch between doing step 5 & SUPER sigmafinity, and step 6 with replacing the previous coin alg with the current one. Cycle between 5 and 6 m times, in the form of π#_#[n,m](x). This, is finally the definition of SUPER PI FUNCTION. Let’s just write it as π#(x) = π#_#[x,x](x).

The Great Π

First, we define ◉ function, which essentially just means the rank of the Πfinity version. Every version increases the ◉ number by 1.

STEP 1: Primifinity (σΠ or ◉₀) [Scope - Absolutely End]

• Now, we define a sort of primitive pifinity that goes similar to Sigmafinity, but replaced with our newly defined functions. So, first, of course, we set *σ₀ to π#_{{πⓧ⓵(⓵)}}(ς_{π#{πⓧ⓵(⓵)}}(ς_{π#{πⓧ⓵(⓵)}}... π#_{{πⓧ⓵(⓵)}} copies...(π#_{{πⓧ⓵(⓵)}}), but replace all the ⓵s with ς_{{πⓧ⓵(⓵)}}(ς_{{ⓧ⓵(⓵)}}) π#_{{πⓧ⓵(⓵)}} times. The formula for generating new primifinities is:
  1. First, generate the first deltafinity like so: *δ_x = π#_*σx-1(π_*σx-1(... *σ_x-1 times ... (*σ_x-1)
  2. Then, generate *σ_x-1 new deltafinities, like so.
  3. Generate a function that goes as such for generating deltafinities: π_x = π_δx-1(δ_πδx-1) Set Δ to {ⓧ_δ(δ)}.
  4. σ_x = ς_{ⓧz(z)}(ς_{ⓧz(z)}), where z is (ς_{π#({ⓧz(z)}}({ⓧ_z(z)}))). Keep replacing Δ times, then z = Δ

• Then, replace the formula for generating deltafinities with the formula for generating primifinities, like in Super Sigmafinity. Denote this as {σπ₁}. You can keep doing this with {σπ₂}... and so on. However, we can go further. Define the extensions of this just like pifinity notation, with everything identical until you get to σπ#(x). Now, make a modified version of primifinity where this new {σπ#(x)} is used. Replace all the numbers with σπ#_{{πⓧ⓵(⓵)}}(ς_{σπ#{πⓧ⓵(⓵)}}(ς_{σπ#{πⓧ⓵(⓵)}}... σπ#_{{πⓧ⓵(⓵)}} copies...(σπ#_{{σπⓧ⓵(⓵)}}), but replace all the ⓵s with ς_{{σπⓧ⓵(⓵)}}(ς_{{ⓧ⓵(⓵)}}) σπ#_{{πⓧ⓵(⓵)}} times. And replace all π notations with its σπ counterpart. NOW, define a NEW σπ, called L2σπ, which is the LEVEL 2 version based on Level 1 σπ. You can see where I’m going, right? Now, let’s just shorten {Lxσπ#(x)} to just σΠ(x). And its coin counterpart as well. Now that it’s all very excessive, we are now ready to construct the next step.

STEP 2: Protofinity (ρ or ◉₁) [Scope - Absolutely Endless]

1. First, define a as the last value of the level, b as the value of the previous level, and c as the last value of ρ.
2. Now, define σΠ(ⓧσΠ ... repeated x times ... (c), as @σΠ(x), and define it again using @σΠ(x), in fact, do it (original) @σΠ(x) times until you have the actual one to use. Then, define @σΠ(x) again, just like π, making it super just like π, substituting @σΠ(x) for ς#, over and over, in fact, (original) @σΠ#(x) times, until you have the one to use. We’re not done yet though, since now we define it like a primifinity, substituting THIS function, over and over, AND doing the last thing, (original) @σΠ(x) times, to finally get here, to define @σΠ(x) again. But we are EXCESSIVE people. Redefine & substitute it again to get here, and we’ll call it @σΠ₁(x). Again for @σΠ₂(x). And over and over until you get to something like @σΠ_{@σΠ@σΠ1(@σΠ1(x...))(@σΠ1(x...))}(x.)... all nested until you get to @σΠ↓^@σΠ@σΠ, re-nesting again, and again! Until you get to Recursive layers. But, let’s just cap it at @σΠRL_x(x). Set this to the new @σΠ and we’re ready.
3. Now, set ρ₀ as σΠ(ⓧσΠ ... repeated ⓵ times ... (⓵).
4. Set the first level of this tower to @σΠ(c). Then, set @σΠ(c) more floors of this Π tower to @σΠ(b). Now begins a relay race. The first floor will keep incrementing using @σΠ(a). Once the step # becomes the value of a the last time this happened (at first just set it to @σΠ(c), the next step becomes @σΠ(b). And this goes for the one after the second one. And so on... until you reach the last floor, where @σΠ(b) is the next ρ. Do this step again and again for more Πs.

STEP 3: Huntofinity (▩ or ◉₂)

Huntofinity is based off a hierarchy, where each element has a layer that interacts with the ones below it. The rows of Huntofinity are like towers, and each subsequent level will be a row of rooms that’s affected by its corresponding rooms. Let’s take an input, x.

• So first, let’s build a row! The first row will have rooms of numbers, which will be the Protofinities. The first room in this row will be the regular Protofinities. And this room will extend off to infinity. Now, we define Hunto Room Function, or ▒, for building the rooms. Hunto function dictates that for the nth element, you generate the function that was used to generate the previous room, in this case it’s Π, and replace the first coin in ς with the coin parallel (n,n in both inputs) and replay everything from that function to this. Now, just get the new function and apply it to your new n. Do this for the infinite list of items in this list. And congrats! You’ve just generated the second room! Now run this function until the entire row of length x is filled.
• Now for the second row! This is where it gets complicated. Because now we’ll have to take input from the two rows below it. (this is like a pyramid). So, take the first room. It will have to take input from both rooms 1 & 2 of row 1. The way we do this is simple. For an element n, take both elements n from below and run Hunto Room Function on the second one below, as many times as the first one’s n dictates. Then, merge this list and the room before it. (if you’re on a first room of a row, merge with the last one on the previous row). Using this, you can build the entire pyramid, until you have a list of elements at the top. This is PROTO Rintofinity. p▩(x) is just the xth element in the final room. For the REAL Huntofinity, we use p*▩(x) for p▩(x), ah who am I kidding. You know what we’re about to do, define it just like ς, ALL THE WAY BACK TO ▩. And again, and again, until you get ▩₁ and ▩₂ and ▩_▩... Until you get to ▩RL_x(x) and of course, we can’t do this forever, we cap it at that. That is Rintofinity (▩). So ▩_fx is ▩ with a function f and input x. Also, you can do ▩_fx_[a,b,c] for specific elements, f being the function, x being the input, a being the row, b being the room and c being the element in the room.
• Note: Also, the reason why it’s called Hunto is because it’s the smallest unit of measurement in the Bower’s Extended SI Prefixes. Yup, only 105 prefixes to go! (I’ll also be doing Uni, Multi, Meta, Xeno, Hyper, and Omni). But for the next stage, we need to go through the Endless Finities first.

The Endless Finities & 2 more

The Endless Plexes [Scope - Absolute A]

• First, define the Plex Function, where PF₀ is ▩↓^▩_ρρ_⓵▩(▩↓^▩_ρρ_⓵▩(▩↓^▩_ρρ_⓵▩( ... ▩_▩▩_ρρ_⓵ times ... ▩_ρρ_⓵. Then PF₁ is PF₀ but with itself as the ρ and ρ_⓵. Then, we, as is tradition, go through all the down arrows and whatever just like we did with Ω, until we get to PFRL_PF0(PF₀). But we DO NOT STOP THERE! OH NO! We define that as Super Plex. And denote it SP₀. To get to the next SP level, all we have to do is repeat it, denote it as something_something, go through all the down arrows, get to the regular cap and ONE TWO THREE HYPERPLEX! Or SP₁. But wait! Can’t we just do SP_SPSP..., forever? Well, the answer is f**k yes we can. We can do get to the repeated down arrown just like Ω, to the classic cap and BANG we haven’t just got a Superplex, we have got a Super-SUPERplex! I’d love to do this over and over, but we have Π variants to define. So, we do X Supers. Now it’s gone from the Plex function to the FLEX functions (sorry that was a cheesy joke).
• Now time to get to the real stuff — The Plex Numbers. The Plex Numbers are based off a system of chained prefixes. It starts with Kilo, Mega, Tera, whatever, and then there is a chain of Greek prefixes, like quad and penta, such as the ones you may find in -illions. When a prefix reaches ⓵, it carries over and another prefix in the chain is made. Keep going until you have a chain of length ⓵, then increase the first prefix by a factor of 1. (ie. Kilo would become Mega, and the chain would reset.) For example, it would go Kiloplex, Kilobiplex, Kilotriplex, Kiloquadplex, Kilopentaplex, Kilohexaplex, Kiloseptaplex ... then Kilobibiplex, Kilotribiplex, Kiloquadbiplex ... and so on and so forth until Megaplex, Megabiplex... and so on. The formula for going from one to the other is simple: Super_xplex(x), where x is the previous one. (Kiloplex is Super_⓵plex(⓵).
• Now on to define ✪, the OMNIPLEX. It’s about time we define a new standard number for our transfinite operations. The Omniplex is Super_xplex(x), re-nested, denoted as a down arrow and going through all that Ω did, to reach x-times nested SuperRL_xplex(x). Input Heva{+Hevaplex}plex and you’re done! (+ in brackets means that many iterations after Heva-).

The Endless Tower of Functions [Scope - Absolute One]

• The first thing we do is create a FUNCTION ENHANCER, where for a function f, △f(x) is equal to Heva{+Heva{+x}plex}plex where f is ς. Let’s call this △0f(x). △1f(x) is △△△...△f(x)...f(x). Then, we put this entie thing in the slots of the (x)s. Say, how about △f(x) times? Let’s call doing this △[1]f(x) (the regular of course being △[0]f(x)).Now what if we were to do this again? Then, of course, we’d have △[2]f(x). Now, if we treat the number in the square brackets as the subscript (ie. △[y]f(x) ≡ △y|f(x)), then, just like that, we can go through all that Ω went through, THEN, do the equivalent of what you did from PFRLPF0(PF0) to Superxplex(x), but for △y|f(x),  times,  being{Superxplex(x), re-nested ✪ times, with each input at the end alternating between Super✪plex(x) and Superxplex(✪)}. This will give us △{1}f(x). Do everything from the original △f(x) back to here for △{2}f(x). Set △R1f(x) to △{x}f(x), re-nested  times. △R2f(x) being △R1f(x), re-nested in x’s place & f’s place  times. △R3f(x) being △R2f(x), re-nested in x’s place & f’s place  times, and so on, but, the meaning of  changes every iteration, for an iteration x (aka the number in the superscript),  becomes △Rx-1f(x). Let’s denote x as the value of  at iteration x. Let’s stop at △R0f(x), and call it ▲f(x). Now, what if we did ▲▲... ▲f(x) times ...▲(x), re-nested in its (x) spots as well, then defined and re-nested again, defined & shortened, ▲f(x) times? Well, let’s call that ▲⇒f(x). And for the final act, we use ▲f(x) arrows (⇒), and let’s just re-define it as △f(x) for simplicity. THAT is the improving function. AND GUESS WHAT, we haven’t even started the tower. Crazy!
• Let’s start the tower with our favourite function, △ρ(x). In fact, we fill a 0 by 0x grid of functions. Now, for each square, a function is applied to it by all adjacent squares (including diagonals), in clockwise order. To make this function, we generate a random number between 0 and 8 while generating a step-based function (max length 0). So, this is what each number means.
  • 0: Apply △f(x).
  • 1: Construct a new △f(x) if ς(x) is △f(x).
  • 2: Random function (ς, σ, ρ... and all variants, if they have a second input, it’s 0.)
  • 3: Re-nest 0)
  • 4: Re-define ⍟ as [All the combinations of ⍟ functions previously defined applied to ⍟, and if doing this for the first time, the first ⍟ = 0 and any future 0s are replaced by ⍟.
  • 5: All the other functions in the entire grid applied to this one.
  • 6: All the other spaces’ randomised function versions applied to this one.
  • 7: This grid space’s function is now counted as a single function and can be used by other functions AND is also applied.
  • 8: All the steps!
• Apply each of those in succession. Then, apply it to all adjacent grid spaces and itself every tick. Next tick you overlay another function as well.
• After 0 ticks, (NOT ⍟ ticks), do the Great Collapse. Each tick, the outer layer of spaces is destroyed and added to the next layer. Keep doing this until you have 1 grid space. Now, this function, in the next iteration, will fill every space for another iteration. Each remaining square is added to a tower where it influences the adjacent cells on the tower every tick and every single other space every tick, using the random functioniser. Collapsen(x) is the function in the nth space on the Collapsetower (the one with all the remainers), after n Collapses.

The Endless Arrays [Scope - Absolutely Absolute Infinity]

• Ⓐ(x) to x is the same as x to ⓵. Effectively, everything up to X will be done for X, just will be replaced with ⓵.
• Ⓐ(x,y) is Ⓐ(Ⓐ(Ⓐ(... y copies ... (x).
• Ⓐ(x,y,z) is z nested copies of Ⓐ(x,y) in the Y & X slots.
• Ⓐ(x,y,z,w) is w repeats of Ⓐ(x,y,z), ie. x, y & z become Ⓐ(x,y,z).
• Ⓐ(x,y,z,w,v) is v variables that each equal x, such that if a is the number of variables, Ⓐ(a) is a repeats of Ⓐ(a-1).
  • Infiniverse Array (ψ): Ⓐ(⓵,⓵,⓵,⓵,⓵) or Ⓐ(⓵&)
  • Multiverse Array (Ψ): Ⓐ(ψ,ψ,ψ,ψ,ψ) or Ⓐ(ψ&) or Ⓐ(⓵&&)
  • Metaverse Array (θ): Ⓐ(Ψ,Ψ,Ψ,Ψ,Ψ) or Ⓐ(Ψ&) or Ⓐ(⓵&&&)

• & is used to denote ‘all variables are’. So 1 & and x means all variables are x. 2 &s and that means all variables are x&. And so on... Not to be confused with the BEAF &.
• &x is used to denote x &s.
  • Truefinity Array (§₁): Ⓐ(⓵&⓵)
  • Truefinity Duarray (§₂): Ⓐ(§₁&§₁&§₁)
  • Truefinity Triarray (§₃): Ⓐ(§₂&§₂&§₂&§₂)
  • Truefinity Quadrray (§₄): Ⓐ(§₂&§₂&§₂&§₂&§₂)
  • Truefinity Quinrray (§₅): Ⓐ(§₂&§₂&§₂&§₂&§₂&§₂)

• &_x is used to denote x of x&s.
  • Truefinity Truarray (§_§1): Ⓐ(§₁&_§1)
  • Truefinity Dutruarray (§_§2): Ⓐ(§₂&_§2)
  • Truefinity Tritruarray (§_§3): Ⓐ(§₃&_§3)
  • Truefinity Tetratruarray (§_§4): Ⓐ(§₄&_§4)

I can go on and on with this... [will be extended soon]

The Endless Algorithm [Scope - Absolute PI]

Alg(1)

Alg{2}

Alg₂

Alg x 2

Alg xx 2

Alg xX 2

A.L.G(1)

Func(1)

Inf(1)

The First I_I Number

The First I_II Number

The First I_III Number

The First I_IV Number

The First I_V Number

Indescribable (ill-defined)

Note: Numbers beyond this point may be ill-defined.

• Ω↔Ω (ABSOLUTE TRUE INFINITE) [Scope - Absolute Never] The ABSOLUTE TRUE INFINITE can destroy all numbers. All modifications immediately collapse to The ABSOLUTE TRUE INFINITE. Assumed to exist.
• ΩΔ (Absolute Delta) Overpowers all transfinite combinations.
• Ω● (Absolute Void) If the End ordinals had a number line, this would be the Infinity. Even on a transfinite scale, this numeral is impossible. Anything you can think of beyond ΩΔ is contained in the Void. Its mind-boggling scale defies all laws of existence.
• Ωθ (Absolute Beyond) What could possibly beat the Void? The answer, is the Absolute Beyond. A scale so large that it defies every single law of the transfinite world.
• Ωθ℧ (True Beyond) After the Beyond, exists the True Beyond.
• Ω◎ (The Final) The final point for all cardinals.
• The Eternal
• The Great Last
• The Absolute Never

The END (Beyond Π): Loops, Holes & Floors [Scope - Absolutely Eternal]

The End is the stopping point for all transfinite ordinals. You can’t break this. Attempting to break this sends you back to the beginning. Every time you reset, you gain ↺ Power, as each ↺ gets you further and further...

• ↺₁, ↺₂, ↺₃ … ↺_Ω … ↺_↺0 … ↺_↺↺0 … ↺_↺↺↺0 … ↺⁴, ↺⁵ … ↺^↺0 … It essentially goes through the same thing as the Recursion Array with Ω.

PREVIEW:

A hole is an extremely large transfinite ordinal that allows loops to loop once their timeline ends and gain more power. Every time a Loop passes through a Hole, it loops and gains a new form which allows more powers to be applied and rules to be bent. A floor will be like the Xie-Nya Pagoda, but it’s not a list of independent numbers that have ranks and groups. It’s more like a self-generating tower of numbers and notations that interact to get even bigger numerals.

Limits and Logic-Defying

• ① (Enfinity Limit) [Scope - Ytinifni Etulosba]: Cannot be reached using loops. To break the Limit, you must bypass it by doing a True Cycle. This means you go through all the numbers, including Loops, over again.
• ② (Suhtasefinity Limit) [Scope - Transed Infinity]: No amount of True Cycles will break this. You will need a Trans-TRANS-finite amount of cycles to bypass the Suhtasefinity Limit.
• ③ (Multifinity Limit) [Scope - Delta-Stack]: The Multifinity Limit requires a Trans-TRANS-TRANSfinite amount of Absolute Cycles. These are cycles such that to reach them you have to start over at the SAME SPEED, aka like the very beginning, so this means no skipping.
• ④ (Tetrafinity Limit): The Tetrafinity Limit requires a ③ amount of Omega Restarts. On a Restart, ALL CYCLE BOOSTS ARE LOST. No cycles add up, which means you have to break all the previous limits again, over and over.
• ⑤ (Pentafinity Limit): The Pentafinity Limit is simple. You have to reset ④ times. But you also lose your restart levels so you need an OMEGA BYPASS to keep your resets.
• ⑥ (Hexfinity Limit): This finity is unknown. Nobody knows how to bypass it, no matter how many time you reset. On the scale of limits, this is another limit.
• ⑦ (Heptafinity Limit): Even with omega editing, transfinite warp, bypass and limit skipping, this will still take a transfinite amount of time to complete. In fact, it will take ⑥ years.
• ⑧ (Octofinity Limit): You can’t even do this. Even if you wait transfinite years. It is absolutely, undisputably, impossible.
• ⑨ (Enneafinity Limit): This number doesn’t even exist. You can’t even reach it, let alone bypass it. It exists impossibly far away, even with unlimited transfinite recursion. And even if you get there, you will have to reset absolutely everything, rebuild everything, and since it resets your resets, you can’t even use any bypass, you’ll have to bypass, the anti-bypass, which is incredibly difficult (and will be reset!). And you will STILL have to do the resets ⑧ times, which is absolutely ridiculous, and each reset makes it exponentially harder as the limit moves further and further away...
• ⑩ (Decafinity Limit): This number is so large, it surpasses all logic, everything logical and illogical, Every fiction and imaginarium, every multiverse and reality, every loop and limit. Everything is bypassed. There aren’t any steps to bypass this. There aren’t any bypasses you can use. There is nothing that can bypass this. Because it is final... or is it?
• ⑪ (The Unlimit) The great Bypass. So powerful it overpowers even the Decafinity Limit.

The REAL END (Beyond Limits): The Great Bypass [Scope - Infinity Universe]

The Real End is an unbreakable set of Ends that bypass all logic.

The Great Bypass

The Greater Bypass

The Greatest Bypass

The Greatestestestest Bypass

The Great 1000-est Bypass

The G.R.E.A.T Bypass

The G-R-E-A-T Bypass

The G>R>E>A>T Bypass

The G<R<E<A<T Bypass

The Great Bypass Limit

The True End - Omega Bypass [Scope - Onefinity]

The Omega Bypass

The True Omega Bypass

The End Bypass

The O.M.E.G.A Bypass

The Huntofinity 2.0

...Microfinity

Millifinity

Centifinity

Decifinity

Unifinity

Decafinity

Hectafinity

Kilofinity

Megafinity

Gigafinity

Terafinity

...

Multifinity

Metafinity

Xenofinity

Hyperfinity

Superfinity

Omnifinity

Infinity Universe

Omega Arrays [Scope - Infinifinity]

Omega Array 1

Omega Array 2

Omega Array 1,2

Omega Array 1,2[2]2

Omega Array 10,1000/2

Omega Array [LIMIT OF BAN]

Epsilon Array

Zeta Array

Eta Array

Alpha Array

O.M.E.G.A Array

Omega x Array

Omega-Array

Omega^Array

Omega=Array

The arrays go on forever...

Beyond Arrays, Limits & Finities (Ineffable to Omega-Ineffable)

• Array Limit (⑫) [Scope - Terminusfinity]: A limit so large no amount of arrays, & substiutions or arithmetic will ever compete with it.
• Alphafinity ({α}) [Scope - Symbolfinity]: No amount of arrays, loops, chains, notations or substitutions will ever reach the ALPHAFINITY. This officially marks the end of all notation, and all manipulations to any transfinities beyond this will immediately collapse to the original.
• Betafinity ({β}) [Scope - Ariesfinity]: Being the largest known absolute, it overpowers all Beyonds, Absolutes, Bypasses and Limits. Any transfinite number you can possible hope to define will always be smaller than Betafinity.
• Gammafinity ({γ}) [Scope - Taurusfinity]: The primordial bypass. All written things, all logic, illogic, fictions, imagenariums, all can be bypassed. After getting past the Betafinity, you can bypass all the rules. At Gammafinity all sense of scale is lost, time devolves into an indistinguishable mess and reality and logic are no more. The line of transfinite ends here. Here comes, the BEYONDFINITE.
• Deltafinity ({δ}) [Scope - Geminifinity]: The era of Beyondness takes over. Now, all edits mean nothing. Everything is meaningless. The Deltafinity removes all existence from the scene.
• Epsilonfinity ({ε}) [Scope - Cancerfinity]: After enough recursions, Oblivions and bypasses, you reach Epsilonfinity, which is absolutely massive. In fact, you can’t reach it. You’ll need a beyondfinite iterations and beyond jumps to get here.
• Zetafinity ({ζ}) [Scope - Leofinity] : Zetafinity is, for lack of a better word, bruh. An ultimate limit, reaching this is a massive milestone. No amount of Beyond Jumps can get you here.
• Etafinity ({η}) [Scope - Virgofinity]: Etafinity is the turning point of Beyond Numbers. Reached when you run out of ideas for these, Etafinity is a continuum of progressively harder and inaccessible milestones, each one needing a new level of bypass. At this point in the limit continuum, limits can’t be achieved as loops, as these lose all meaning. Instead you have to REALLY push the laws of what makes sense.
• Thetafinity ({θ}) [Scope - Ophiuchusfinity]: Thetafinity reaches into the realms of TRUE nonexistence. Being transcendental on a Beyond scale, it transcends all description. It cannot be imagined or described in any way.
• Iotafinity ({ι}) [Scope - Xennafinity]: The Iotafinities are not only indescribable, but are unique in the way that they are an Everything number. On a scale of all existence, it transcends everything. Anything above it is below it. Anything further ahead is actually smaller. This mind-bending ability to be both larger and smaller allows for much larger numbers to be formed.
• Kappafinity ({κ}) [Scope - Q-doxfinity]: Kappafinity uses a new class of bypasses and jumps called the TRUE CLASS. The TRUE CLASS is much more powerfuland has paradoxical powers that overpower any level of their predecessors. This allows even larger integers that don’t align to anything because they stop being in our plane of existence. They become ascended.
• Lambdafinity ({λ}) [Scope - Homeworksfinity]: The Lambafinity uses even higher classes of TRUE CLASS to constantly better itself. It constantly is overpowering itself and uses meta-paradoxical theories to overpower even the paradoxes. It really is the largest integer there is... for now...
• Mufinity ({μ}) [Scope - Fertofinity]: Mufinity is the first unstable cardinal. It doesn’t really exist at all and its value is ambiguous. However, its class and relative size can be known, it cannot be reached due to its high instability.
• Nufinity ({ν}) [Scope - Zderfyufinity]: Nufinity is a highly unstable cardinal. It is so unstable it doesn’t exist and its value cannot be measured or described. It becomes incredibly unstable as a result of its high value. At Nufinity, all the cardinals mix up and the ordering of value starts to break down. Some numerals may mix up, break down or simply stop existing.
• Xifinity ({ξ}) [Scope - Qwertyfinity]: Xifinity is so incredibly unstable that its status changes. In fact, it’s so unstable it stops being unstable and doesn’t exist at all. Its class is so high it’s undefined. Even on a Beyond Scale it can’t be defined.
• Omicronfinity ({ο}) [Scope - Uiopfinity]: Omicronfinity goes up so high it can bypass its own instability. It is so absolutely large that no notation or extreme jumps can get here. Omicronfinity exists in the Great Void of Finity, The void exists, doesn’t exist, is infinitely large, is infinitely small. Contains everything, contains nothing, Is unstable, is not. Omicronfinity is so high up it not only can’t be described, but can’t exist in ANY plane or class, neither can it not.
• Pifinity 2 ({π}) [Scope - Lionuiopfinity]: Pifinity has the unique power to overpower any level of paradoxes. It can’t be paradoxed, because at the scale of the Pifinity, paradoxes lose all meaning. Even the notion of losing all meaning loses all meaning. It is so incredibly large that no amount of words, description or scales can define it, making it an ABSOLUTE PARADOXFINITY.
• Rhofinity ({ρ}) [Scope - Womanuiopfinity]: Not to be confused with CAPITAL Rhofinity, Rhofinity is a recursive version of Pifinity that uses paradoxes and universes to constantly better itself, using bypasses, replacements and power sets constantly and forever and ever. In fact, not just forever, but ABSOLUTE FOREVER. This omega infinite recursion makes Rhofinity a force to be reckoned with.
• Sigmoidfinity (Sigmafinity 3) ({σ}) [Scope - Mysterfinity]: Much like Etafinity, Sigmafinity is an impossibly impossible milestone to reach. The elements all blend together making it impossible to move any meaningful amount, even with Paradoxical Jumps. Each element in the Sigmafinity is a finity of its own, getting more impossibly impossible, every time becoming a new layer of impossibility.
• Taufinity ({τ}) [Scope - Jektofinity]: Taufinity makes NOTHING make sense. All logic about bypasses and beyond vanishes. Like Pifinity, it is impossible and doesn’t exist, but this time EVEN MORE IMPOSSIBLE. It removes the entire notion of being defined. It paradoxes itself out and creates meta-metas that cause more impossibility.
• Upsilonfinity ({υ}): NO!
• Phifinity ({φ}) [Scope - piscesfinity]: The great Phifinity creates a great reset that consumes all. Progressing beyond this point is impossible since this is the end of anything. Progressing past this point will never happen and will always take you back to the beginning. No loops are counted and it does nothing.
• Greekfinity Limit (⑬) [Scope - Heninity]: The 13th limit marks the end for all Greek letters. Bending reality is not enough. The 13th limit marks teh end of the line, which means nothing can exist in the slightest here.
• Chifinity ({χ}) [Scope - Januaryfinity]: But what if we could go beyond? The Chifinity occurs after a Phi Bypass happens, allowing it to break the 13th limit, which is the Greek Limit. The Greek Limit marks the end of all Greek letters, but there are a few in front, and beyond it lies the Great Chifinity.
• Psifinity ({ψ}): ??????????????? (not to be confused with Mathis R.V.’s Psifinity).
• Omegafinity - The 14th Limit (⑭) [Scope - Instafinity]: Not to be confused to omegfinity, even the Beyond Greek Letters cannot breach it. Even the breach of existence cannot bypass it. The 14th limit is the final limit until the absolute end.
• The Absolute Limit (⑮) [Scope - Zettifinity]: The Absolute End. Being the end of the timeline, the only bypass that can bypass it is itself, thus creating a 1=0 error that prevents any prospecting transfinite traveler from passing this. It may not be the end after all... but we may never know.

The Errorverse Beyond Transfinite Bypass

• peeg (♣) [Scope - Termifinity]: After a proof, it was discovered that ‘Peeg’ was actually the first "Amount" > TAL. Assumed to exist.

• E̶̢̋͆̌͊̇̂̒͗̌̄͋͒͆͝R̷͕̽̅̐́̈̋̒͝Ŗ̴̜̫͍̣̺̲͚̥̱̰̦̠͈̽O̶͓̗̍̽̎̓̓̈́́̅́͒͆͆͠R̴̨̘̤̳͇̩̞̝̮̮̈́ͅ: No symbol, exists after the transfinities. Assumed not to be a “Amount”. Unknown.
• Omega Beyond Limit (⑯) [Scope - Omega-Programmerfinity]: The Omega Beyond Point is the end for all description. Nothing can be described anymore. At this point you have reached the ERROR Peninsula, where all description makes no sense. In the ERRORverse, all rules are abandoned, and you can use loopholes to constantly get higher and higher Amount. Beware though, the higher you get, the more unstable the numbers become, until they can’t even be measured anymore, and trying to get to them will make you dissolve into timeless ERROR MATTER.
• scrunkly: 1+total XNP
• scrimblo: a number larger than notations and functions built on OBL.
• scronkly: limit of scrimblo
• Xionslasrconk: Largest number definable using Scronkly symbols.
• Spinkledorp: N₀ Dimension Xionslasrconk-meta (might be equal to fauzouhdaide)
• Fauzouhdaide: First number unusable with meta-Xionslasrconk arithmetic
• ⑰ Normalcy Limit: Quantum Amount, point where Amounts have no set point on the line, but rather probabilities due to the sheer size
• ⑱ Amount Limit [Scope - Psifinity]: Last Amount, point where Amounts are useless, since they are probably between 0 and ULTIMATE Π. We now use a new word: Quantity. This is the end of Amounts, and Numbers have already been finished a long time ago. "Smaller" numbers are now non-existent. We can only go up from now, thus making -⑱ the Smallest number.

Beyond Numbers, Amounts, and Word loops to Ineffable objects on the numberline

This is the point where we go beyond what can be negative, we are only able to go up from now.

The End?

• ㊈ TrueNoEnd's Breakdown: This number, if you can call it that at this point, is so extremely large, it is larger than 1/*Θe, No physics can define this, because it just breaks down at this point.
• Quantoquantodingleberrydingleberrycornhole [Scope - Lunate-Sigmafinity]: limit of function > TNEB(N_x Dimensional ultArray) l
• Dinkledick: Quantoquantodingleberrydingleberrycornhole fictional symbols (largest number defined with a Q...cornhole fictional / real symbols)
• Nyka: Qsystem(Dinkledick,Dinkledick...) (69,420 entries)
• Dykkil: Qsystem(Qystem iteration N) (>N entries) >>
• Finus: function limit > Dykkil (2) con
• OnePlusN: literally defined as "n+1" with n being any value.
• Poststeus: defined as "for any set, in an all-inclusive definition of set, Poststeus is greater than that set. This applies to sets that contain poststeus."
• XCCP: Second post-paradoxical number.
• Successor XIV: Post-Post.
• BBeyond: Beyond the concept of going beyond itself

Utter Nonsense

This is where numbers stop having definitions that can actually be written in full.

Beyond it is...

• Cross + [Scope - Pampian-digammafinity]
• Tallcross †
• Doublecross ‡
• Tall-Doublecross ☨
• Truecross ☦
• Cross Limit ⑲ [Scope - Hetafinity]
• Trip-arrow ⫷
• Arrow-trip ⫸
• Godsina of All Gods ᥤ [Scope - Unixfinity]
• Ascended Infinity ᥫ
• The Last ᥪ
• Transcending Infinity ᥦ
• Ytinifni ᥥ
• Ytinifni Etulosba Ʊ [Scope - Existensfinity]
• The Final Number Limit ⑳
• ㉚
• ㊵
• ㊿
• ⑥⓪
• ①⓪⓪
• ①⓪⓪⓪
• ①⓪⓪⓪⓪⓪⓪
• ①⓪⓪⓪⓪⓪⓪⓪⓪⓪⓪⓪
• ①⓪^①⓪③⑦
• ①⓪{{{{①}}}}①⓪
• ⓉⓇⒺⒺ(③)
• ⓉⒶⓇ(③)
• ♾
• (Ω)
• (Ω↔I)
• (⓵)
• Yalimit ᝌ = ⓵ [Scope - Neverfinity]
• Kalimit ᝃ
• Balimit ᝊ
• Dalimit ᝇ
• Palimit ᝉ
• Malimit ᝋ
• Lalimit ᝎ [Scope - Unknownfinity]
• Nalimit ᝈ
• Galimit ᝄ
• Walimit ᝏ
• Ngalimit ᝅ
• Ralimit ᝍ
• Halimit ᝑ
• Salimit ᝐ
• Talimit ᝆ
• Ultimolimit ᝂ
• Proximalimit ᝀ
• Ultimalimit ᝁ [Scope - Endingfinity]
• ᝁ>ᝁ
• ᝁ>ᝁ>ᝁ
• ᝁ><ᝁ
• ᝁ><"ᝁ
• ᝁ><":ᝁ
• [ᝁ]ᝁ
• [[ᝁ]]ᝁ
• [[[ᝁ]]]ᝁ
• {[ᝁ]}ᝁ
• ({[ᝁ]})ᝁ
• /({[ᝁ]})/ᝁ
• |/({[ᝁ]})/|ᝁ
• |||/({[ᝁ]})/|||ᝁ
• .|/({[ᝁ]})/|.ᝁ
• ...|/({[ᝁ]})/|...ᝁ
• ᝁ x 100 [100 different types of brackets]
• ᝁ x 1000000
• ᝁ x ∞
• ᝁ x Ω
• ᝁ x Ω↔I
• ᝁ x ①
• Never ↇ = ᝁ x ᝁ

Things beyond the purpose of the fictional googology wiki

• Incoherently Ineffably Unarguably Unquestionably Incorrigibly Immutable Trans-transcendental Limit

The Replacement Array (recursions & stuff)