KthulhuHimself
Well, let's cut right to the chase; as all I really care about adding here are definitions and coined terms.
Let's start with a general description of what norminals do. Norminals are a method used to create laughably large numbers; or to be precise, a method used to create functions for laughably large numbers. They themselves are, to be concise, variables; each has its own properties, each its own capabilities at defining smaller norminals, and each more mindbogglingly tiresome than the last. (Quoted from my blog post on the subject:) "Norminals are a method, not a single function or variable; and, being never well-defined as a whole, yet always as individuals, can always, without even the slightest effort, go ahead and diagonalise above any other function... ...Being never well-defined as a whole, it is thus impossible to diagonalise over all norminals as a whole.
To put it short, the norminals are the Fast-Growing-Hierarchy of uncomputable functions... ...some of the most simple norminals I have coined are already capable of producing numbers far greater than BIG FOOT and its likes, simply demonstrating its overall helpfulness when sorting uncomputable functions into categories."
TL;DR: To cut it short, norminals are a series of variables that serve as defining limits for functions.
IMPORTANT: It is necessary to note that even though I will be referring to the different norminals as "large" and such, they do not in fact inhibit any of these properties, as not being ordinals, they have no direct comparison to ordinals and the word "large" is only used here in a figure of speech, for both my ease of understanding and yours. The actual meaning is explained below.
Norminal languages are defined simply as follows:
N$ (for any well-defined norminal $):
If a subformula of form x(y) exists, where x and y are variable symbols where y takes some norminal value smaller than $ in some assignment, then we interpret x as y-th order variable.
The rest of the language functions identically to FOST (mutatis mutandis), only that we can predicate over all lower orders of norminal languages, as explained above.
The symbols added to the languages are different for each norminal; but to generalise, for some norminal $, the symbols added to N$ are the symbols needed to express all smaller norminals (changes from case to case, I will elaborate on the examples sooner or later), we also have all the symbols needed to express predicative variables (basically, what we have in SOST and so forth). The reason to all this, is that for the separate norminals, we will need to have the necessary symbols to to express smaller norminals, which is why we have our predication in the mix.
(For example, "<" and ">" for the N<0<0>1> language (which happens to be nearly identical to FOOT).)
Really, they're just the FOST(n) function only replacing FOST with N<$> (for whatever $).
They are notated N<$>(n).
(The $ here will be referred to the "norminal predication variable of the language" from here on out.)
Whenever it appears in the context just mentioned, it will be effectively interchangeable with "the norminal predication variable such that when it used in a norminal language, said language can predicate over any smaller norminal predication variable and derived languages". To clear up some possible confusion, though norminals are ill-defined as a whole; when a specific, standalone norminal is defined (well-defined, to be precise), all "smaller" norminals are, by requirement, also well defined.
Sometimes I will refer to "limit of a" as "LoN(a)".
Very simple. $a < $b, if $b is defined using $a (and vice versa with "larger"). For example, <3> is larger than <1>, as <3> ultimately contains <1> in its definition.
Oh, baby. Here. We. Go.
The first norminals are very simple to both define and to understand.
We start with N<1>, the first and simplest norminal. It is defined simply as the smallest variable larger than any ordinal; or in other words, part of a formal system in which all ordinals are set into a category, AO(0) (the reason why it's called that is explained in my blog, but it's not important for this purpose), while N<1> is in the AO(1) category. In this system, for any and all AO(a+1), the AO(a+1) will always be greater than any AO(a). These are variables, yet not ordinals.
Now, <2> is so easy to define it actually hurts. Simply put, it is the limit of all well-defined expressions defined using regular ordinals (all AO(0)) and any instance of <1>. This would include things like "<1>1", that being what the relation between omega_1 and omega would do to <1>; making <2> rather considerably large. To be more precise and clear, it is of the AO(1) category, and is effectively the limit of all things <1> related.
We can go onto <3>, <4> and so on without going into detail, as they all use the same definition, mutatis mutandis. To generalise:
<a> is the limit of any norminal <b>, where b is some norminal smaller than a.
In this case, a can be any previously defined norminal, then nested any number of times within <> brackets as above.
So to clarify, in effect, a here can take on the form of any <a> (for some other a) norminal or smaller.
Now, this isn't the most powerful stuff on the market, even for excruciatingly high values of a (something like <<...<<1>>...>> with <<1>> nested brackets), but the obvious question is, why can't we just diagonalise over it all with another norminal; I mean, it's what they're meant for.
We thus get to <0<0>1>, the limit of all expressions using <a> and smaller. Traditionally, I'd use "," instead of "<0>" to separate the different entries, but knowing what's ahead, I'll just use <0> for coherency's sake. Now that we have a second entry, we can create far more powerful norminals than anything we have had so far; but TRUST ME, we haven't even gotten CLOSE to the depth of the rabbit hole.
(From this point until I get to murs, murals and so on, most other norminals will be trivial to define and rather uninteresting overall.)
For all different cases of <a<0>1>, the definition is the same, mutatis mutandis, as <a> (<a<0>1> is the limit of any norminal <b<0>1>, where b is some norminal smaller than a.)
We thus get to <0<0>2>, the limit of all well-defined <a<0>1>. We go on, and eventually reach <0<0>3>, being the limit of all <a<0>2>.
So to generalise, <0<0>a> is the limit of all <c<0>b>, where b is smaller than a.
We can now extend to <0<0>0<0>1>, being the limit of all well-defined <0<0>a>; and extension for all other regular <0> separator arrays is trivial (<0<0>0<0>0<0>1> = LoN(<0<0>0<0>a>), etc.).
So we can now extend to <0<1>1>, that being the limit of all regular <0> separator arrays.
We can also extend not only to <1> separator arrays, but also to <2> separator arrays, <3> and so on. You may have noticed that I didn't actually bother defining any of these well, but that's because we won't be needing to with what's coming next.
TL;DR:
<1> is the limit of all ordinals.
<2> is the limit of all things which use <1> and smaller.
<a> is the limit of all things which use <b> and smaller, where a > b.
<0<0>1> is the limit of all <a>.
<b<0>a> is the limit of all <d<0>c>, where b > d && a > c.
<0<0>0<0>0<0>...a entries...<0>1> is the limit of all <0<0>0<0>0<0>...b entries...<0>1>, where b is smaller than a.
<0<a>1> is the limit of all array norminals that use separators lower than a.
Of course, we could go on to define array norminals with multiple entries at the separators, etc.; but ultimately, that's making it just another array notation; and those would still be within the realm of AO[1].
Introducing AO[2], a new type of norminal variable identical to AO[1], only that we specify two things: One, all AO[2] are larger than all AO[1]; and two, they are within a different category than AO[1]. This, inevitably, allows us to create languages so useful, hence functions so powerful, and hence numbers so large that the mind cannot even begin to conceive of them.
Of course, we can go onto AO[3] without problem, and thus to AO[4], AO[<1>], etc.
Note that these aren't individual norminals, but rather categories of norminals. If I ever refer to something like [7] as if it were a norminal, what I would mean is "the smallest norminal of category [7]. From this point onward, that will be the standard notation for norminals derived from these categories.
TL;DR:
[1] is really just <1>.
[2] is the limit of all norminals of category AO[1].
[a] is the limit of all norminals of category AO[b], where a>b.
So far, everything we've discussed can be assigned into categories; ones we will now name murs. AO[1] is a mur, as is AO[2], etc.
Whenever we have a norminal that is the smallest in such a category, it will be named the "class ordinary" of that mur, or otherwise the "mur-norminal" of it.
Now, what is a mural? apart from the wall-painting, murals are in effect "categories to predicate over the behaviour of categories", if you will, which would allow us to define and construct far greater murs than normally commonplace.
I should expand a bit. After we finish with things like [[2]] (the class ordinary of AO[<(the class ordinary of AO[2])>]), we can of course create things like [0<0>1], which would be the limit of all AO[a] for a single entry. This, however, is still a AO[#], so we now create a new category for the categories.
This category is still in the first mural, and will be dubbed the "mur-mur", i.e. the concept of murs applied to murs themselves. We thus get everything coined until now to be placed within the first mur-mur, and the very next thing to be the class-ordinary of the second mur-mur. We can of course expand this to something, say, like the tenth mur-mur, or the omega'th mur-mur, until we get to the limit of everything constructable with that, and have ourselves the limit of the first mur-mur-mur, or the class-ordinary of the second mur-mur-mur.
TL;DR:
Just read it.
Ok, let's get some numbers up in here!
The DARK ROSEN (The Definitely Arbitrarily and Rampant King of Randomly Ordinary and Specifically Epic Numbers) - N<0<1>1>^100(10^100)
The DANK PEPE GOD (The Definitely Arbitrary and Nasty King of Pricelessly Epic, Particularly Educated and Googologically Ordinary Disasters) - N[[1]]^(10^100)(10^100)
(This is a work in progress, and I am constantly adding more to the site, including many norminals I have defined prior to the creation of it.)