Hacker News Reader

Comment by speakeron | Hacker News Reader

> k(1) = TREE(1), K(2) = TREE(TREE(2)), K(3) = TREE(TREE( <(repeats (TREE(3) time (TREE(3)))

What you've made here is what's known in googology circles as a 'salad number'. It doesn't make a conceptual leap above what the TREE function can do anyway and is kind of similar to saying TREE(3) + 1.

SCG(13) is much bigger than your K(3) and Loader's number is much bigger than SCG(13). There are (computable) numbers bigger than Loader's number which are mentioned in the googology link in my previous post (Greedy clicque sequences and finite promise games).

View on HN

Yea, the point was to pick something trivial. K(3) is larger than TREE( any obvious function to a non mathematician of any printable number).

But it's the m(x) that's actually large in that example.

> But it's the m(x) that's actually large in that example.

Sure, it's large (mindblowingly so), although I'm not quite clear exactly how you define m(x).

It's hard to get a grasp on just how much vastly larger each of these 'rockstar' numbers is to the previous one when you ascend this conceptual hierachy. (To a certain extent, that's the point of the article.)

You could make a K(K(K(...(n)...) function where you painted a K on each particle in the visible universe (about 10^80) and it still wouldn't come close to Loader's number. The point is that you can't simply recurse TREE and hope to get a number that's conceptually any bigger than TREE itself.

Yea, at some point you really can't tell if function 1 grows faster than function 2. Anyway to pick a large m(x).

m(0) = 1; m(x) is the recursion of all finite functions defined using k(m(x-1)) symbols that produce larger numbers than their input defined at stage m(x-1).

So a 1 step function F1(x) = X + X and F2(x) = X ^ X,... including any function that has been included in a mathematical paper to this point that takes one ore more finite numbers as an input.

And because these are all finite functions call them recursively in whatever order produces the largest output starting with the initial input (x). Now, to size this depends on what initial notations are allowed, so m(1) is a finite number.

Next level could then include F#(x) where F1(F2(x)) etc.

PS: The above is roughly equivalent to saying infinity +1 and is not interesting IMO. I can also drop the k from the above, but again the point is to use the dumbest approach that works.

Sounds a bit like Yudkowsky's number[1] (your main step is the first one, everything else is salad), which is a computable version of Rayo's number[2])

[1] http://googology.wikia.com/wiki/Yudkowsky%27s_Number

[2] https://en.wikipedia.org/wiki/Rayo%27s_number

Sure, but you need a large seed number at some point for functions like this. ex: Rayo's used 10^100.

So, they are all going to be take large value and use it to boost some other function m(x). I just happen to pick a large f(x).

Reply on news.ycombinator.com