BEFORE ANYTHNIG, I NEED YOU TO ACKNOWLEDGE THAT THIS IS NOT REAL GOOGOLOGY, BUT RATHER MOSTLY A JOKE.
Before deleting the "Norminals" post, I have come up an idea for a function, that will outgrow every other function, computable or not, to date.
Definition is as follows: "Lib(n) is equal to the smallest integer larger than any number expressed by all the symbols after the last blank in a well-defined expression in 'definer' language with n symbols or less."
"Definer" language is defined as formal english, where the symbols allowed are blank, the letters of the english alphabet, the ten decimals, comma, period, and any other symbol whatsoever, as long as it is defined in "definer" somewhere else in the expression.
The formal definition of "English", for this case, is as described in the "Oxford advanced learner's dictionary", or any purposeful Dictionary for this point.
Paradoxes and their resolution
I already know that many of you readers will probably comment something about the fact that you can define Lib(n) in "definer" language itself, and hence, Lib(n) can generate Lib(m), where m>n.
This would mean that Lib(n) is ill-defined, as it could always generate larger expressions of itself, right?
Going according to this logic, Lib(n) used inside Lib(n) is ill-defined, and hence cannot be used, as the definition clearly states: "well-defined expression", and because Lib(n) cannot be used, Lib(n) is well-defined!
This means that we can use it, and hence Lib(n) is ill-defined again!!
To solve this, we simply need to assume that any instance of Lib(n), or any similar function inside the expression used to solve the external Lib(n), is ill-defined at all times.
As a matter of fact, any expression causing a paradox of "is or isn't well defined", is disqualified from being used as a solution.
Now, because this function can basically define any other function, it naturally outgrows them. This includes FOST, FOOT, and any other function that can be formally defined.
Lib(10^6) is probably the threshold of most definitions known to the public so far, and hence is considerably larger than most (if not all) the googologisms made by the community so far.
Needless to say, Lib(10^100) is quite large.
Notes and such
- There are many ill-defined and paradoxical expressions in Definer language, however, they do not imply that Lib(n) is ill-defined.
Now, I have been getting a lot of feedback regarding my function that I would like to put to mind, and so, will try to revise this function to fit the standards of logic.
These will be needed to understand the revision.
The first concept needed to realize is "Decent interpretations".
A decent interpretation is in reality, an interpretation of a definition that considers all and only the words presented in it, in any logical format.
An example would be BEAF, as it is ill-defined, yet still can be understood in a finite amount of ways, effectively allowing multiple interpretations.
To understand this concept, one must first understand one of the prime differences between formal languages and natural ones. That being, natural languages have a circular meaning, and if it can be defined without circularity, then it's a formal language (of course, there are other differences).
Now consider an L-system, whom constantly replaces old "sections" by new ones with each iteration. If each "section" in the L-system can be considered part of a definition, then surely the definition of a natural language (we'll call that a natlang from now on.) can be interpreted that way?
This leap of faith is required in order to make anything of the function, so bear with me for the time being.
We still need another term, which we will call "Sentence" (See bellow).
We can now proceed to give some definitions.
An interpretation is built as follows:
Suppose we have a much simpler natlang consisting only of the words "A", "B", "C", and "D" (lets call this A-lang).
The dictionary of A-lang goes as follows:
A > B D
B > A C
C > D A D
D > A C B
This means that each word on the left hand side of ">" can be replaced by the set of words placed on its right.
We now make a slightly different version of Definer, only that it uses A-lang, meaning that A-definer uses:
A, B, C, D, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ".", ",", as it's symbols (almanacs (#[n]) are still allowed).
An example of a sectence would be: "# A 9. #."
This can be made into "
-  B D 9. #.", "
-  A C A C B 9. #." But alas and alack, this is circular.
(I'll finish this soon! Stay tuned!!)
A sentence is defined as all the symbols between any blank after a period and the next period, or (if it is the first sentence,) all the symbols before the first period. Sentences can be empty.
The placement of words in a sentence affect the way certain words are defined, such as "this", or "that".
QWell-defined and undefined
We already know what well-defined and ill-defined are, and so we need to define a few new forms of definition-integrity.
Suppose we have a definition which is ill-defined, BEAF, for example. We agreeably have multiple interpretations of it, and given each is well-defined as itself, we can now redefine BEAF as Q-well-defined.
If there are no decent interpretations, the definition is ill-defined.
The last concept needed to be assimilated is undefined.
Suppose we have any defintion, that when attempting to terminate the function derived from it, will cause a paradox regarding which definition-integrity it belongs to. Assign it as Undefined.
An almanac is a new "symbol", not otherwise considered a symbol, that is valid only if it is defined (or has a decent interpretation) somewhere else in the expression.
Lib(n) is defined as "The smallest integer larger than any finite natural number expressed in all the symbols after the last blank in any decent interpretation of any Q-well-defined or well-defined, non-empty string with a finite number of decent interpretations in Definer language with n or less being the sum of all symbols or almanacs in the expression."
How on earth can any extensions be made to this function?
We know that the only factor preventing Lib(n), from creating infinite sub-expressions of itself, is the fact that we DON'T allow it to. An obvious extension would allow the use of Lib(n) and its counterparts in the sub-expression, but how do we define that without getting messed up with axioms?
Well, taking a second look at the definition of Lib(n), we can see that the rule we use to limit Lib(n), yet still let it be well-defined, is the one that assumes that even though Un-defined is well-defined (or Q-well-defined), we do not allow Un-defined notations to appear in it!
But what if we said that it can appear in the sub-expression of the "Arch-function", yet not in any other further sub-expression?
We'd get Lib2(n).
Effectively, we can call any sub-expression-generating (via a natlang) function "L(a)" in which "a" is the sub-expression generated, that will lead to some other function. Then we set the limit that states: "The string used to solve any specific L(a) cannot contain any L(a) in the sub-expression." Then, we say the limit to any L2(a) is "The string used to solve any specific L(a) cannot contain any L(L(a)) in the sub-expression."
Third-order to nth-order
Not much to say here, apart from that the limit also allows L(L(a)) to appear in the sub-expression of Lib3(n).
Limit Libw(n) as follows:
"The string used to solve Libw(n) can only contain L(a)'s with a finite order, which is stated somewhere else in the sub-expression."
Can contain Lw(a) in the sub-expression.
Limit Libw*2(n) as follows:
"The string used to solve Libw*2(n) can only contain L(a)'s with an omega+n order, for finite n, which is stated somewhere else in the sub-expression."
"The string used to solve Libw^2(n) can only contain L(a)'s with an omega*n+m order, for finite n and m, which is stated somewhere else in the sub-expression."
"The string used to solve Libw^^2(n) can only contain L(a)'s with an omega^n*m+a order, for finite n, m, and a, which is stated somewhere else in the sub-expression."
"The string used to solve Libe_0(n) can only contain L(a)'s with an omega^^n^m*a+b order, for finite n, m, a, and b, which is stated somewhere else in the sub-expression."
Extension is obvious.
Augumentation of TaN in the order
Next suppose we have a function, Lib<0,1>(n), which can contain L(a)'s of any order, which must be stated somewhere else in the sub-expression.
From here on, the definition of Lib<1,1>(n) is quite simple. Reminding ourselves of the definition of Lib2(n), we can pressume that the same logic applies.
i.e. L<1,1>(a) can contain any L<0,1>(a) in its expression.
Same logic from before, meaning that Lib<w,1>(n), Lib<e_0,1>(n), etc., can exist.
Could we not extend it? First, we will need to remember what Lib<0,1>(n), is. To generalize it, we should allow a new term to exist: X (It is to be used as an order). X means "Lib<#>(n), can allow any ordinal to be instead of this", meaning that Lib<X>(n) = Lib<0,1>(n).
Extension is obvious, but this time, we use a slightly tweaked version of TaN's rules to explain the TaN extension of Lib(n).
Formalization, you ask? Very well then.
- Successor rule:
L<n+1<#>#*>(a) can define any natlang of order L<n<#>#*>(a) or lower.
- Fundamental rule: L<E<#>#*>(a) (E being an ordinal) can define any natlang of order L<r<#>#*>(a) or lower, where r is any member of the FS of E, and all other smaller ordinals.
Most of the remainder of the rules are very similar to those of TaN, with n replaced with X.
For clarification, so you won't need to ask in the comments.
Sub-expression - the string of symbols generated by any function.
Arch-function - the function we attempt to solve, that is not in any sub-expression.
X - if X appears somewhere in the order of any L<#>(a), the function can generate any ordinal instead of it to represent that X.
The wise man theorem, or "Edgar theorem"
Before you read this, I want to warn you that even though this may make Lib(n) well-defined,
IT'S COMPLETE LUDACRIS!!!
A possible alternation on the definition of "Decent interpretation" could go like this:
Suppose we have the following: A room of infinite length (in one direction), a panel on one of the walls in which a person can type formal ASCII code into a small computer, and a single man, whom doesn't age, has infinite memory, and is unboundedly inteligent. (to make this mathematical, we can assume that we use a formal system which stimulates the laws of physics in a non-cellular-automata-like grid, simulating a "physical" language.)
For consistency's sake, we will call this man "Edgar".
To get this new definition of "Decent interpretation", we should first define "Interpretation".
On one of the two infinite walls, a string of Definer language spreads across it's length in large letters. On the panel which Edgar can enter the formal ASCII code, there is the option to "End" reception of more symbols.
An interpretation is the entirety of symbols entered by Edgar into the panel until he presses the "End" button.
We know what "Interpretation" is, so now all we have left to do is define a "Decent interpretation".
Suppose that at all times, we measure Edgar's brain activity (encoded as the atoms and interactions between them), to see if he actually attempts to interpret the Definer string. If at any point of time, he stops trying to interpret, or begins to enter symbols into the panel without connecting them to the Definer string, the interpretation is a "False interpretation" (as opposed to a "Decent interpretation").
"Who" Edgar is
In order to make this well-defined, we first need to understand "who" Edgar is, or in other words, specifications to his psyche and physique.
Edgar is a male, 35 year old man, who's genetics were modified to increase his mental and physical capacity to an unimaginable level. His "base" genes can be those taken from anyone, but for Edgar's specific case (and for the laughs), we will assume that they are those of Professor Albert Einstein (at the age of 35). Note that this means nothing of the knowledge or inteligence of Edgar.
All the knowlendge Humanity has accumilated as of the beggining of the year 2015, A.D., could suffice as Edgar's prior knowledge before attempting to "Interpret" the specific Definer string.