My Extended SI Prefixes
This is a list of all of my (Trakaplex) extended SI prefixes. The first below are the ones that are officially published that we frequently use.
Quantity
Name
Abbreviation
Reciprocal (10^{x})
10^{1}
Deca
D
Deci
10^{2}
Hecto
H
Centi
10^{3}
Kilo
K
Milli
10^{6}
Mega
M
Micro
10^{9}
Giga
G
Nano
10^{12}
Tera
T
Pico
10^{15}
Peta
P
Femto
10^{18}
Exa
E
Atto
10^{21}
Zetta
Z
Zepto
10^{24}
Yotta
Y
Yocto
For the rest I have borrowed xenna, weka, and vendeka
from other googologists; for most of the rest he borrowed the names
of Jonathan Bowers' illion numbers. For novemdecillion it was
originally ika, though it was changed due its minor phonetic
to the suffixes to be added. The name "trakaplex" indeed came from
traka which meant novemvigintillion, though it was
eventuall…
PAN 0.5: A longawaited update.
Ok, so I've gotten to work on fixing up PAN with some clarification, as well as a formalization. 1. PAN has been split in to two branches, or "stems". first is the Base Hyperstem, which deals with the basic layout of arrays, and second is the Extended Hyperstem, which addresses expressions with more than one operator. 2. I've updated the document to instead be a google slides presentation, which I'll link here: [1]
Hopefully this clears more things up, and I'll probably add more
Hyperstems in the future.
hmm
It appears my IP has changed or you reverted the IP part of the ban.
PhiExplodalihP (not banned) should be the same IP as LuckyLuxiuz (banned), right?
If not, what happened?
Edit: Checked if the accounts were still banned, and it says they
do not even exist. WTF?
A8 Ordinal Expansion for Nonsequential Functions
I got this idea as current edition of Googology Wiki doesn't show subscripts.
The definition is similar to ordinals as subscripts, so I'll just go straight to examples:
For positive integer n and nonnegative integer k, assign g(n) = n+1, then
 g^{ω}(2) = g^{2}(2) = g(g(2)) = 4.
 g^{ω+1}(2) = g^{ω}(g^{ω}(2)) = g^{ω}(4) = g^{4}(4) = 8.
 g^{ω+k}(n) = f_{k+1}(n) of FGH.
 g^{ϵ0}(2) = g^{ωω}(2) = g^{ω2}(2) = g^{ω+2}(2) = g^{ω+1}(g^{ω+1}(2)) = g^{ω+1}(8) = ...
Obviously all ordinals are applicable and g(n) can be any nonsequential function, including G(n), n(k), TREE(n), SCG(n), Tar(n), D(k), Σ(n), etc.
Now I wonder if Tar^{φ(ω,0)}(99) is larger than Loader's number ?...
Could Σ^{SVO}(10^{100}) be larger than Rayo's number ?...
If not, how about Σ^{LVO}(10^{100}) ? or even Σ^{BHO}(10^{100}) ?...
Sorry Mr. Beaver, you are much …
Tick Notation
Normally it would look like this.
T(a,b,c,[d,e,f,g,h,i . . . j,k]).
where a and b 2 variables in the hyperoperator, determined in the amount of steps in the brackets, which represent "layers"
When there is a single variable, (a), then it splits into a1,a1,a1 if the 1st number is 3. a1,a1,a1,a1 if it's 4, etc.
If you have T(2,2,2,[2]), then each step would go:
T(2,2,2[2])
T(4,2,2[1,1,1])
T(256,2,2[1,1])
T(3.23170060713*10^{616},2,2[1]) (Now that is a big jump!)
Even 1.5 might have a big jump.
After five steps, it explodes from about 30 to 1.351555741217 × 10^{45}
Could someone block Ivan Stepanov
As you can see in the recent wiki activity section, he started an edit war on a page with the name "Treeillion" with no source. He keeps reverting it back to the original state whenever we mark it for deletion.
Ascending Primitive Sequence System
This is an original (to my knowledge) notation that I created a while ago
Define a set of ordered tuples of natural numbers \(T\):
 An ordered tuple of natural numbers \(a=(a_i)_{0\le i\le l}\)
is a member of \(T\) if all of these conditions are true:
 \(a_0=0\)
 \(l\in\mathbb{N}\)
 \(\forall(i\le l)(a_i\in\mathbb{N})\)
For a sequence \(a=(a_i){0\le i\le l}\in T\), define \(\textrm{BR}(a)\), the bad root of \(a\):
 \(\textrm{BR}(a)\ :=\ \textrm{max}(\{k
Article comments
Can one of the admins add add main page comments to the wiki? I don't see any harm in it, and it would really help discussion on the wiki. Is it because it is a subject of the current vandals (because everything else here is too), or something else?
Splitting Array Notation
aAKA Splarnot (/sblɑɹnɔt̚/ is how I pronounce it), to not confuse it with Strong Array Notation. This is a v2.0 of LL+DEAF.
 1 Functions
 1.1 2entry arrays and "arraic" nesting
 1.2 Universes (Bidimensions, Tridimensions, Quadimensions, etc.)
 1.3 Biverses, Triverses, etc.
 2 Number Examples
(a) = a
(a,b) = a*b ≈
(a,b[c[{4,0}]2]) = Phitetnullic
(a,b[c[{5,0}]2]) = Phipentanullic
(a,b[c[{10,0}]2]) = Phidecanullic
Ordinals work like the FGH mixed with ExtensibleE. Now let's move on to...
(a,b[c[d][1]2]) = (a,b[c[(a,b[c[(a,b[c[(a,b[c[ . . . (a,b[c[d]2]) . . . ]2])]2])]2])]2]) with (a,b[c[d]2]) nests.
(a,b[c[d][2]2]) = (a,b[c[(a,b[c[(a,b[c[(a,b[c[ . . . (a,b[c[d]2]) . . . ]2])]2])]2])]2]) (with (a,b[c[(a,b[c[(a,b[c[(a,b[c[ . . . (a,b[c[d]2]) . . . ]2])]2])]2])]2]) …
Is Answers a good source
I created a page called nonimillinovemnonagintanongentillion, and I cited the Answers page "What is after a centillion". The article is now a deletion candidate and I am wondering if Answers is a good source at all? https://www.answers.com/Q/What_is_after_a_centillion Trakaplex, 10/12/2020.
The YETI function, Meamealokkapoowa oompa Utter Oblivion
) which is the the largest finite number that can be uniquely definable using Meamealokkapoowa Oompa symbols in a K(Meamealokkapoowa Oompa) system, So therefore I thought of defining utter oblivion using the same function:
Thus, Utter Oblivion=
YETI k1 (Meamealokkapoowa Oompa Oblivion) 1 system ,(comma means in some), k2 (Meamealokkapoowa Oompa oblivion) 2 system..................... k Meamealokkapoowa Oompa Oblivion(Meamealokkapoowa Oompa oblivion) Meamealokkapoowa Oompa oblivion system (Meamealokkapoowa Oompa oblivion symbols). where m= Meamealokkapoowa Oompa oblivion and n= k(n) system and Meamealokkapoowa Oompa oblivion= YETI (meamealokkapoowa Oompa system) (Meamealokkapoowa Oompa symbols).
Guys what do you think i think this is the larg…
LON (Luxius Ordinal Notation)
? = Addition
@ = Multiplication
$ = Exponent
$$ = Tetration
&n,n = Veblen Phi Function
(function)!n = Nesting in all variables in the function "n" times.
(function)!1,2,3,4 . . . n1,nm = Nesting in variables listed m times.
The separator (.) is so you can't have things like &3,3$2 being &3,9 instead of &3,3 squared.
1?1 = 2
1??2 = 1@2 = 2
2$31 = 2147483648
&1,0.$2 = \(\omega^{2}\)
(&1,0)!1&1,0 = &1,0,0
It's time to act to this mess
Recently, Fandom started to move wikis to UCP. It was a terrible decision, removing familiar features and lagging everything down. Even if criticisms and insults are coming in 24/7 to the blog post above, Fandom is doing NOTHING about it.
To respond to this issue, I would like every fellow googologist to help out here. A few days ago, somebody created a petition to get rid of UCP. I think that this is a great idea, but unfortunately not many have seen it...
So I would like everybody who sees this blog post to sign up to this petition, at least if it is convenient to do so.
3 variables ψ which is larger than EBOCF
This blog post is a translation from https://googology.wikia.org/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:Kanrokoti/%E3%81%8F%E3%81%BE%E3%81%8F%E3%81%BE3%E5%A4%89%E6%95%B0%CF%88
EBOCF(Extended Buchholz's OCF) is 2 variables function. So, I decided to extend it like ψ_A(B) => ψ_0(A,B). Please be careful that this 3 variables ψ is neither OCF nor Ordinal notation. I named this notation "Kumakuma 3 variables ψ". "Kuma" means "bear" in Japanese🐻. In order to make the definiton, I referred to the following pages. I appreciate p進大好きbot corrected my definitons.
https://googology.wikia.org/wiki/User_blog:P%E9%80%B2%E5%A4%A7%E5%A5%BD%E3%81%8Dbot/Ordinal_Notation_Associated_to_Extended_Buchholz%27s_OCF
https://googology.wi…
What happened to this wiki
I came back after several months of inactivity. What exactly happened here?
 MathJax has STOPPED WORKING, so does that mean that we would have to literally change EVERY MathJax to LaTeX BACK AGAIN?
 The page editor has become much clumsier and slower: all familiar features have gone away, and the space in which we can edit has severely shrunk. We used to have about 50~70% of the entire screen to edit pages. Now we only have 30~40%.
 Chat is now not a thing anymore.
This "weird wiki" feature was first noticed by me when I went to Ordinal Markup Wiki, which was fairly recently created. Back then I just thought that OM Wiki was a standalone wiki that was somehow created by magic. But it seems like the "weird wiki" has become a new trend that's consu…
A 2color Turing Machine can compute Goodstein Sequence
Here I announce that I developed a 2color Turning machine that can
compute Goodstein Sequence.
Some history information:
Early this year, I leaned that there are two kind of 'general' programming languages that can program on Turning machines. One is Laconic, the other one is NQL.Lacnoic supports list and is fast to run and debug, but the Turning machine it produces have much more states counter than NQL.
NQL produces less states TM, but it's much harder to debug a NQL program.
There is an interesting blog article from about above two languages.
Put asides of all those difference between Laconic and NQL, my main idea is to develop a 2state TM that can compute big numbers. The purpose of this is to give lower bound of Rado's Sigma function…
In The Year Myrillion
I am writing a song called "In The Year Myrillion". Here are the first few lyrics:
In the year octoquinquagintaducentillion, there will be nothing but darkness luck.
Upon an ocean of time and intelligence, where entropy has made time stuck.
Illions related:
Septenquadragintaquadringentillion \(10^{1,344}\)
Unnonagintaquingentillion \(10^{1,776}\)
Quattuorseptuagintasescentillion \(10^{2,025}\)
Unquinquagintaseptingentillion \(10^{2,256}\)
Tresexagintaoctingentillion \(10^{2,592}\)
Novemtrigintanongentillion \(10^{2,820}\)
Millillion (said as millinillion) \(10^{3,003}\)
Dumillinonagintanongentillion \(10^{8,973}\)
Trimillisexoctogintaoctingentillion \(10^{11,661}\)
Quadrimilliquattuordecicentillion \(10^{12,345}\)
Sexmillitredecisescentillion \(10^{19,…
I need a chance
Please? I am so sorry for what I did on that day, I was just so mad at you guys for banning me over something that is kinda simple. (Now that I think about it, I actually edited someone else's page, so...) Also, Hi Trakaplex, how are you doing?
Well, now that I have blown my cover, I will just tell you some stuff.
So, I am LuckyLuxius (Yes I did an Edwin move)
My mental health has finally gotten better since my new school doesn't have any goddamn bullies
How are you guys? (Cloudy, PsiCubed2, Username, etc.) I hope you are doing well today. You might ban me anyway, so my last words will be:
(ahem) \[ \text{lets we go amigo} \]
Deepest regards, LuckyLuxius The Ametuer Googologist
Edit: Somehow I am still not banned? Hey admins, you should see t…
Prototype array notation: An update!
Ok, so yesterday, I wrote a post about my indevelopment notation for large numbers, and I'd like to give you all an update.
Tying up some loose ends/Clarification:
 Hash marks now denote arrows. (This was to simplify it, as using hyperoperations was hard to use and hard to convert to other notations.). ex. 3#4 now equals 3^^^^3, not 3^^3
 More than one hash mark: (ex. 5##2) Sorry that I didn't explain this part. So basically, in the example a##b = a(c)##(b1)##(b1)##... with c1 sets of #s. This is what I meant by a(a)##b = a##b in the previous blog post. so 5##2 solves to 5##1##1##1##1.
 The previous rule applies to more than 2 #s as well (5(3)####5 = 5###4###4)
 On the document, I made some critical mistakes: 1) Graham's number is MUCH s…
Trakaplex's illions
Hello, I am Jaden Hartson aka Trakaplex. All my illions on on Googology Testing wiki, using the generalizations of Jonathan Bowers . https://googologytesting.fandom.com/wiki/Quadrimilliquattuordecicentillion
Prototype arrays
This is my first blog post, so if i look dumb, well, that's why
Three weeks ago, I prototyped a sort of extensible large number system, which anyone can extend. I'll post a link to the document explaining it later, but for now, here's the basic idea of how it's supposed to work.
 a#b = a[b]a, where brackets are hyperoperators, or arrows, depending on which you prefer (ex. 3#3 = 3[3]3 = 3^3 = 27
 (a)b#c = b[a]c
 a(b)#c = a[c]b
 a#(b)#c = a###.....###c where there are b #'s
 a#(b)#1 = a#(b1)#a#(b1)#a... where there are a copies of a
 a#(b)#c(k) = (a#(b1)#k#)a#(b)#c
 equations are solved from left to right.
If you find something that isn't explained clearly, find circular logic, or have something you want to add, feel free to suggest in the comments!
link …
T5 What happens when Ordinals are nested with up arrows?
This thought experiment is simple but interesting. I think this will enhance the ordinals expansion greatly as they are currenyly expanded based on multiplication and exponentiation only.
 1 1.0 Definition
 2 Examples
 3 2.0 Multinest
 4 Examples
 5 Questions
 The up arrow notation can be added to ordinals in the form of f_{α↑kβ}(n), where f is FGH fundamental sequence function, where k and n are positive integers; α and β are ordinals.
 Similar to expansion of ordinals, α↑^{k}β is right associative (expanding from right to left).
 f_{ω↑ω}(2) = f_{ω↑2}(2) = f_{ω2}(2) = ...
 f_{ω↑↑ω}(2) = f_{ω↑↑2}(2) = f_{ωω}(2) = f_{ω2}(2) = ...
 f_{ω↑↑(ω+1)}(2) = f_{(ω↑↑ω)(ω↑↑ω)}(2)) = f_{(ω↑↑ω)(ω↑↑2)}(2)) = f_{(ω↑↑ω)ω2}(2)) ...
 f_{ω↑↑ωω}(2)
 = f_{ω↑↑ω2}(2)
 = f_{ω↑↑ωω}(2)
 = f_{ω↑↑ω2}(2)
 = f_{ω↑↑(ω+ω)}(2)
 = f_{ω↑↑(ω+2)}(2)
 = f_{(ω↑↑(ω+1))(ω↑↑(…}
How far does this go up the FGH? Thanks
I have been making natural number recursions in an attempt to see how far I can go up the FGH, not to try to outdo anyone but myself. Here is my latest set of rules with examples and my best attempts at relating some expressions to the FGH. If anyone can look at this and tell me where the final expression falls, or if I have reached epsilonnought, I would be grateful. Thank you.
Domain:
All variables represent whole numbers. A string is a whole number or one or more whole numbers separated by bracketed expressions. The terms inside the brackets are indexes.
Function rules:
Any expression ending in a vertical bar is a function whose argument is the natural number (or expression that evaluates to a natural number) on the main line after the …
Fred: a sorta big number
first post, woo! please bear with me. Fred's definition is very pure, but it'll take some background to understand it. please let me know if i can clarify anything. terms are made of countably many variables \( x_{i\in\mathbb{N}} \) and nary identifiers \( S^{n\in\mathbb{N}}_{i\in\mathbb{N}}\) both 0indexed independently. a wellformed term is a variable or an nary identifier prefixing n wellformed terms.
rules are of the form \( \dfrac{[terms]}{[term]} \) interpreted as "to construct the term on bottom, construct the ones on top". when applying rules, tobeconstructed variables may be substituted for any wellformed term, with variables of the same index must be substituting for the same term.
ksystems are tuples of rules. k is the length …
Transfinite FGH Notation
This is an English translation of my Japanese blog post submitted to a Japanese googology event, which was suddenly held as a surprise only in one day without any announcement. Since nobody prepared for this event, participants, including me, tried their best with many errors :)
This is a notation "implementing" transfinite FGH. I note that there are so many trials in this community to define a transfinite FGH, but all of the resulting works are illdefined as far as I know. Therefore this is not an actual implementation of an existing work. One of the most common issues in existing works is the illdefinedness of fundamental sequences.
 If we define a system of fundamental sequences first, then the resulting transfinite FGH has either one of t…
PLANET(n) (Debatable name for this)
I'm back from a lemon tea drinking bout and I brought an improved version of the same notation I've been trying to pull off multiple times under multiple names.
 1 Part 0: Base info
 1.1 Recursion levels
 2 PLANET_M(N)
 3 =
 Level I: The most primitive recursion. f(n+1) = f(n) + 1
 Level II: Recursions that are built on higher hyperoperations with usage of one entry. f(n+1) = n*f(n) / f(n+1) = n^(f(n+1))
 Level III: Recursions that are built on higher hypeoperations with usage of multiple entries to stack Level II recursions on top of each other or increase their output in any other way. f(a,b) = f(a*a*a... (b) ...*a)
 Level IV: Recursions that are built on repeatedly stacking recursions on top of each other. f(a,b) = f(a, f(a, f(a,...(a) [b times] / f(a,b,c)…
Uncountable fundamental sequence
I define this function for use uncountable ordinal in countable ordinal hierarchies.
Find cofinality of \(\alpha\). Define \(Cofset(\alpha)\) as a set where the length of the set is \(Cof(\alpha)\) and the elements are the smallest possible ordinal or natural number larger than 0.
 If cofinality of \(\alpha\) is equal or below \(\omega\): \(\alpha[a,b] = \alpha[a]\).
 If cofinality of \(\alpha\) is equal to \(\Omega\): \(\alpha[a,b]\) is equal to \(\beta\) order in \(Cofset(\alpha)\) when sorted in ascending order, where \(\beta\) is a largest ordinal satisfies \(g_\beta(b) = a\).
 If cofinality of \(\alpha\) is equal to \(\Omega_n\) where n is a natural number larger than 1: \(\alpha[a,b]\) is equal to \(\beta\) order in \(Cofset(\alpha)\) when …
Some last digit patterns, explained
This is the post that Pbot has been waiting for. While I was not able to prove all the "patterns" I found, I was able to prove some.
While computing the last digits of certain very large numbers, I took advantage of certain patterns I noticed in small values, especially if a direct computation would require too many steps to feasibly perform. That naturally gave me the question: why?
1. The last 3 digits of a number ending in ...56 with an even hundreds place digit increment by 400 each time the number is raised to the power of itself.
When taking ...X56^...X56 (where X is an even digit), we add ...X56*(...X56^...X^55  1) to ...X56. Since (...X56^...X^55  1) is divisible by 25 (ending in ...75), and ...X56 is divisible by 4, it must end in…
Plusar array notation
 Not to be confused with Plusal array notation.
Plusar array notation (+ar) is an array notation that is faster than Plusal array notation defined by Khang2009. It's denoted as {(a1)b1(a2)b2(a3)b3...(an)bn}_x and definition and calculate steps are much like the Plusal array notation, but in the calculate step 4.2 has changed:
 Go the order that is (remembered order)[n+remembered base], where n is a smallest natural number that is the base of (remembered order)[n+remembered base] is 0 (if it's not possible then set n to 0), increase the base of order by 1, then go to step 4 again. (underlined part is changed or added part)
Plusal array notation
Plusal array notation (+al) is an array notation defined by Khang2009. It's defined as follows:
 Denoted as [(a1)b1(a2)b2(a3)b3...(an)bn]_x, where all a's are called bases and all b's are called order and b's can be numbers or ordinals and x is a timer.
 Like sets, bases and orders can be arranged in any way. Example: [(5)4(7)3(3)5]_x = [(7)3(5)4(3)5]_x

Orders can't have a number equal to other orders. Example: [(6)3(8)3(8)7]_x then it's illdefined.

Any base is 0, bases and orders can both be hidden. Example: [(5)8(0)5]_x = [(5)8]_x
It can be calculated as:
 If the timer is 0, output the base that ordered 0.
 Order bases and orders from lowest order to highest order. Example: [(5)9(3)6(7)7]_x = [(3)6(7)7(5)9]_x
 Go to the most right base and order.
 Rem…
The L function
A long time ago, i created a function that can express very large ordinals, but it's very complex and i didn't even know how to get to ε_{1}, so i didn't make a blog post about it until now.
It is a binary function L, and its domain is the set of
ordered pairs (f,x) such that the range of f is a subset of the
domain of f and x is in the domain of f.
L(f,x) = lim_{n→ω} f^{n}(x)
I would like to use supremum there, but i would need to define an
order on the range of every possible f. A limit is still probably
undefined for something like that, but maybe it's easier to
understand this way. There is one more thing we need in order to
get further than ω^{2}  two symbols i and j that turn any
binary function into a unary function:
f(a,i)(b) = f(a,b)
f(i,b)(a) = f(…
Everyordinal function
Everyordinal function is a function for creating uncomputable function created by Khang2009. It is defined as follows (currently illdefined):
 Denoted as EO_{m}(n) = x
 EO_{1}(n) = 1.
 EO_{m}(n) and m > 1 or m is an ordinal defined as a slowest function that is faster* than any function which is EOy(n) where y < m.
 n, m are natural numbers or m is an ordinal.
 EO_{m}(n) = g_{m}(n)
 EO_{Ω}(n) = BB(n) because EO_{Ω}(n) >* EO_{1}(n), EO_{2}(n), EO_{3}(n), EO_{w}(n), etc.
about the embi situation
I'm sure you all saw the spam today and I think quite a few Googology wikians would like an explanation about having the blog being spammed with DNA ordinals and random BMS stuff.
He is known as embi, from his discord username. His main wikia account is of course blocked, but I'll talk about it later.
Anyway, from what we know, embi is most noticably obsessed with BMS. He's not as good as googology as you would think, although his skills and knowledge are no worse than quite a few amateurs I know. But that's irrelevant. You already know that he believes he inherits a googologically small fraction of DNA from his mom, which is illogical to everyone except himself. I do however believe he sincerely believes these things and isn't a troll like …
Some questions regarding the BCH
Again, I'm making a new blog post because this community seems to ignore blog posts older than about a week. Last week I began to revisit the binomial coefficient hierarchy that I described in my March blog post, which in case you don't already know is defined as follows:
\(F_{\alpha+1}(n) = \sum^n_{m=1}F_\alpha(n)\),
If \(\alpha\) is a limit ordinal, \(F_\alpha(n) = F_{\alpha[n]}(n)\), assuming a given system of fundamental sequences, the most commonly used has w[n] = n, w^2[n] = w*n, e_0[n] = w^^n
\(F_0(n) = 1\) if n = 1, otherwise 0
F_1(n) is always 1, F_2(n) is just n, F_3 is the triangular numbers and F_4 is the tetrahedral numbers, etc. F_w is the central binomial coefficients 1, 2, 6, 20, 70, 252, 924, ...
Below are the first few values …
Extensible Factorial Rebuilt
My notation was too wordy, so I rebuilt it (Three first stages, more coming soon), but I've got some problems with FGH comparisons. Here's link:
https://sites.google.com/site/morethanfactorial/home
Here are some correct comparisons:
E!S
FGH
100!
\(f_2(100)\)
100!2
\(f_3(100)\)
100!k
\(f_{k+1}(100)\)
100!#
\(f_\omega(100)\)
100!#+1
\(f_{\omega+1}(100)\)
100!#+2
\(f_{\omega+2}(100)\)
100!#+k
\(f_{\omega+k}(100)\)
100!#2
\(f_{\omega2}(100)\)
100!#^2
\(f_{\omega^2}(100)\)
100!#^#^#
\(f_{\omega^{\omega^\omega}}(100)\)
100!#^^#
\(f_{\varepsilon_0}(100)\)
100!#^^^#
\(f_{\zeta_0}(100)\)
100![#,#]
\(f_{\varphi(\omega,0)}(100)\)
100![#,#,2]
\(f_{\varphi(1,0,0)}(100)\)
100![#,#,#,2]
???
100![#,#,#,...,#,#]
???
Hope you'll help. I got no clue about comp…
T4 ITTM vs Rayo's number vs Fish Number 7 vs LNGN
This is a thought experiment about Σ_{∞} vs. Rayo's number vs. Fish Number 7 vs. LNGN.
 1 Definition of function B
 2 Combat Round 1
 3 Combat Round 2
 4 Combat Round 3
 5 Combat Round 4
 6 Combat Round 5
For positive integers n and k, B is a positive integer function defined as:
 B_{0}(n) = Σ_{∞}(n)
 B_{k}(n) = B_{k1}^{n}(n)
From the above, is B_{n}(n) ≥ Rayo's number for n ≥ 10^{100} ?
For EBO = Extended Buchholz's OCF = ψ_{0}(Ω_{ΩΩ..}):
 What value n for B_{EBO}(n) ≥ Rayo's number?
 What value n for B_{EBO}(n) ≥ Fish Number 7?
 What value n for B_{EBO}(n) ≥ LNGN?
Assume Σ_{∞} allow ⍵ variables, i.e. Σ_{∞}(n◀⍵) or Σ_{∞}(n,n, ... ,n,n) (with ⍵ n's) is well defined (similar to how Σ(n,m) defines its 2 variables).
Now redefine B_{0}(n) = Σ_{∞}(n◀n):
 What value n for B_{n}(n) ≥ Rayo's number?
 What value n for B_{n}(n) ≥ Fish Number 7…
Calculating large numbers in JS
I have created a github repository (kind of like OmegaNum or Decimal) for working with large numbers in Javascript. It has scientific notation storage so it can represent numbers up to E(1.8E308). Here is an example of using it:
This should be useful for computing your average Class2 or 3 numbers that are larger than a googol, and for incremental games/physics. Planned updates:
hugenumber.js  Uses hyperoperators as the storage mechanism, numbers up to 10{1.8E308}1.8E308.
Please contribute to the repository.
Palace Function
Palace(n) is the largest possible output of any Palace program where:
 there are n functions, each taking up to n arguments
 no argument uses any function more than once
Valid: +0, f(a), f(g(h(+0))), f(+a,+a)
Invalid: ++0, f(g(f(a)), g(0,g(0,0))  input is all 0s
 the program must terminate
Examples:
Palace(1) = 1 f(0) = +0 f(0) 1Palace(2) ≥ 31 f(+a,+0) = g(+a,+a) f(+a,0) = f(g(+a,+a),+0) f(0,+a) = f(g(+a,+a),0) f(0,0) = f(0,g(+a,+a)) g(a,+b) = g(+a,b) g(a,0) = +a f(0,0) f(0,g(1,1)) f(0,g(2,0)) f(0,3) f(g(3,3),0) f(g(4,2),0) f(g(5,1),0) f(g(6,0),0) f(7,0) f(g(7,7),1) ... f(15,1) g(15,15) …
T3  Small Set Theory System vs Utter Oblivion
Further to Blog T2, I conceived third thought experiment.
Let's assume there exists a Set Theory System (STS) that is made of ω layers as described below, where y is a positive integer while a, b, c and z are nonnegative integers:
 Base layer, STS(ω) (where STS(0) = ZFC): C_{a}(n) = C_{0,a}(n) = C_{0,0,a}(n) = ... (this was defined in Blog T2)
 First layer, STS(ω,ω): C_{b,a}(n) = C_{0,b,a}(n) = C_{0,0,b,a}(n) = ...
 Second layer, STS(ω,ω,ω): C_{c,b,a}(n) = C_{0,c,b,a}(n) = C_{0,0,c,b,a}(n) = ...
 (y1)^{th} layer, STS(ω◄ω): C_{z◄y}(n) = C_{z,z,...,z,z}(n), with y of z's.
In short, all lower layers are subsets of immediate upper layer; in other words, any layer is much more powerful and more robust than all layers below it:
 {STS(ω)} = {STS(0), STS(1), STS(2), ...}
 {STS(ω,ω)} =
 {STS(0,0),…
Generalised Recursion
 1 Generalised Recursion
 2 The Generalised Recursion Function
 3 Scope of the Generalised Recursion Function
 4 Some Interesting Functions
 5 The \(Z()\) Function
 6 Evaluating the \(Z()\) Function
 7 Evaluating \(Z(2,1)\)
 8 Comparing \(Z(1,n)\) to \(f_{\omega}(n)\)
 9 Comparing \(Z(n,n)\) to \(f_{\omega^2}(n)\)
 10 Further References
Following on from my previous blog on Functional Notation, I have started to generalise the notation for recursion of functions.
Starting with
\(F(a_{[x]},b1,d_{[y]}) = F(a_{[x]},b,d_{[y]})\)
\(F(a_{[x]},bc + 1,d_{[y]}) = F(a_{[x]},\mathbb{C},d_{[y]})\)
We can repeat the use of the \(\) symbol and define the following:
\(F(a_{[x]},b1,d_{[y]}) = F(a_{[x]},b,d_{[y]})\)
\(F(a_{[x]},bc + 1,d_{[y]}) = F(a_{[x]},b\mathbb{C},d_{[y]})\)
Exampl…
My Functional Notation
 1 My Functional Function
 2 Cardinal Number of Functional Parameters
 3 Ordinal Position of a Functional Parameter
 4 Leading Zero Rule
 5 The Decrement Function
 6 Functional Recursion
 7 The Quantum Function
 8 Further References
I have developed Functional Notation that simplifies the presentation of functions and their rules. Especially when the functions are used recursively as is common for Googological functions.
\(F(a_{[x]}) = F(a_1,a_2,...,a_x)\)
This notation compresses the representation of functions with many parameters. Especially when the cardinal number of parameters may be a Googologically large number.
Examples:
\(F(1_{[2]}) = F(1,1)\)
\(F(a,0_{[4]}) = F(a,0,0,0,0)\)
\(F([x]a) = F(a,0_{[x]})\)
This notation further simplifies the representation of a fu…
Repetion notation
\[ \DeclareMathOperator{\Cl}{Cl} \DeclareMathOperator{\On}{On} \DeclareMathOperator{\swap}{swap} \DeclareMathOperator{\iter}{iter} \DeclareMathOperator{\if}{if} \DeclareMathOperator{\limit}{limit} \DeclareMathOperator{\dom}{dom} \DeclareMathOperator{\on}{on} \DeclareMathOperator{\ord}{ord}\] Set of formal strings X in the alphabet \( \{(, ), R_n,m : n,m \in \mathbb N \} \) we consider is recursively defined by:
 the empty string (represented by \( \_ \) ) is in \( X\)
 \( (a)b \in X \if ab\in X\) then for any string \( b \) and any string \(a\) with balanced brackets.
 \( R_{n, m}(a)(b) \in X \if a,b \in X, n,m \in \mathbb N\)
I define a partial function \( \bullet[\bullet] : X \times \mathbb N \to X \)
For \( x \in X, n \in N \)
 \( x[n] := ab \if …
C1.1 ω↑↑3 for 3
For reference.
 = f_{ωω23}(3)
 = f_{ωω22+ω3}(3)
 = f_{ωω22+ω2+3}(3)
 = f_{ωω22+ω2 }_{ω}_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{2}_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 }_{ω}_{2}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 }_{ω3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 }_{ω}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 }_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω2}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω+3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{2}_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{2}_{2 + ωω22+ω }_{ω}_{2}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{2}_{2 + ωω22+ω }_{ω3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{2}_{2 + ωω22+ω ω2 + ωω22+ω }_{ω}(3)
 = f_{ωω22+ω2 }_{ω}_{22 + ωω22+ω2 ω2 + ωω22+ω2 2 + ωω22+ω }_{ω}_{2}_{2 + ωω22+ω ω2 + ωω22+ω }_{3}(3)
 = f_{ωω22+ω2 }_{ω}_{22 +…}
Turing Complete Ordinal
Turing Complete Ordinal, or TCO, is equal to w1CK+e0*w. This ordinal is 100%, verifyingly correct. If you say otherwise, epic gamer moment
C1 Even omega cubed of 3 is so large !!
Whoever invented ordinals and diagonalizations was genius !!
 1 f_{ω3}(3)
 2 Inner most bracket, f_{ω2}(3)
 3 Inner most bracket, f_{3}(3)
 4 Selfreflection
 = f_{ω2}_{3}(3)
 = f_{ω22+ω3}(3)
 = f_{ω22+ω2+3}(3)
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+2}(3)))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(3)))))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2}(f_{ω22+ω2}(f_{ω22+ω2}(3)))))))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2}(f_{ω22+ω2}(f_{ω22+ω+3}(3)))))))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2}(f_{ω22+ω2}(f_{ω22+ω+2}(f_{ω22+ω+2}(f_{ω22+ω+2}(3)))))))))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2}(f_{ω22+ω2}(f_{ω22+ω+2}(f_{ω22+ω+2}(f_{ω22+ω+1}(f_{ω22+ω+1}(f_{ω22+ω+1}(3)))))))))))
 = f_{ω22+ω2+2}(f_{ω22+ω2+2}(f_{ω22+ω2+1}(f_{ω22+ω2+1}(f_{ω22+ω2}(f_{ω22+ω2}(f_{ω22+ω+2}(f_{ω22+ω+2}(f_{ω22+ω+1}(f_{ω22+ω+1}(f_{ω22+ω}(f_{ω22+ω}(f_{ω22+ω}(3)))))))))…
Algorithm that changes BMS matrices into ordinals up to SRO
SRO is Small Rathjen's Ordinal (name suggested by Plain'N'Simple), which is the limit of Extended Buchholz's OCF (EBOCF), and i'm using the version of BMS defined here.
This algorithm uses two binary functions v(M,n) and o(M,n), where o(M,0) is the ordinal corresponding to the matrix. It only works for standard matrices below SRO. A standard matrix below SRO is a matrix that appears in the expansion of (0,0,0)(1,1,1)(2,1,1)(3,1,0)(2,0,0).
The function v(M,n) returns the "value" of M_{n}, which is the nth column of the matrix M. M_{n,m} is the mth number in M_{n}. v(M,n) is defined as the smallest ordinal such that all of the following is true:
If M_{n,2} = 0, then1. v(M,n) ≥ v(M,P_{1}(n))+1
2. If ∃m(M_{m} = M_{n+1} ∧ P_{1}(n) < m < n), M_{n+1,2} = 1, and M_{n+1,1} = M_{n,1},…
Original content wikia has been created
As described on my previous post, I have created a new wiki for original content due to blog posts not being popular enough. I am also planning to create an illdefined number template as suggested by Nayuta Ito. The wiki is available on:
w:c:massivenumbers
Currently I have only 3 pages (Home,Zero,One), all of which aren't original/new numbers. Please start adding original googolisms there now, since the wiki is currently very small. Googology Wiki will obviously still remain for sourced unoriginal content.
PGP Function
 1 Introduction
 2 Extra
Information
 2.1 Overflow and Deep Recursion
 2.2 How will the character be counted?
 2.3 Why not use resources that allow the creation of symbols, events, functions etc., which are random?
 3 Some Values of
\(pgp()\)
 3.1 \(pgp(0)\)
 3.2 \(pgp(1)\)
 3.3 \(pgp(2)\)
 4 Some Values of
\(PGP()\)
 4.1 \(PGP(0)\)
 4.2 \(PGP(1)\)
 4.3 \(PGP(2)\)
 4.4 \(PGP(3)\)
 5 Proof that \(PGP(3) > G(64)\)
 6 FastGrowing Hierarchy in PARI
 7 New Number
In this post I will demonstrate two functions, which are based on the Constructor function created by C7X (see ).
To begin, we will define \(pgp(n)\) as the smallest positive integer greater than the largest finite value returned from a program, using the language PARI/GP, which does not use resources that allow the generation of symbol…