## My number is bigger!

For all your silly time-killing forum games.

Moderators: jestingrabbit, Moderators General, Prelates

WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

Vytron wrote:We have n[n][n]. For n to change, you need to reach n[¶][n], which will be n+1[n][n]. However, by that point ¶ will be n+1[n][n], so any kind of growth you'd expect from adding to n, will now happen when adding to o[n+1][n], which now requires a much higher ¶ to advance. So, it doesn't matter that the jump from ε0 to εε_(0) is "non trivial", because if you were able to jump from ω to ε0, and from ε0 to ε1, then, at some point in the brackets, the "non" trivial jumps will be trivial.

It really doesn't work that way. It gets harder and harder to count up to the next epsilon number, majorly so. Its not that the process that got you to εa will get you to εa2 if you layer it again, or even εa2. It will get you to εa2, which is very, very much different.

If you really think that's not the case, try defining your number more clearly... try to avoid any English descriptions and define as few new symbols as you can. Make the description as short as you can.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

WarDaft wrote:It really doesn't work that way. It gets harder and harder to count up to the next epsilon number, majorly so.

Its not that the process that got you to εa will get you to εa2 if you layer it again, or even εa2. It will get you to εa2, which is very, very much different.

And I'm meant to count to that on the original level progression, which repeats the whole process n times, and add n layers of recursion.

So, if I have finally reached εa at some n[n][n] number (and, the key to my persistence is that you and Deedlit have told me I can reach it like that), the next thing I do is increasing the power of the original level progression (what I mean with "gains the power") to be the whole process of going from 1 to n[n][n], at every step.

So we have the progression of Level 1 (which should be at least this strong, because it's applying the whole process at every step):

Step 1: εa2
Step 2: εa3
Step 3: εa4

And the εath step of that would be level 2 (or, the "last step of that is" level 2, because Deedlit told me I can just take the limit of that progression)

Level 2:

Step 1: εaa
Step 2: εaaa
Step 3: εaaaa

Now we take the εath step (or the last level), of level εa (or, the last level). The sequences should be recursive enough that εa+1 will be reached, which will be n[n][n]a, however, at this point, the power of εa+1 has been reached (because the power of the levels isn't the distance from n[n][n] to n[n][n]a, it's the distance from 1 to n[n][n]a), so the levels advance like this:

Level 1

Step 1: εa+12
Step 2: εa+13
Step 3: εa+14

Level 2:

Step 1: εa+1a+1
Step 2: εa+1a+1a+1
Step 3: εa+1a+1a+1a+1

Now we take the εa+1th step (or the last level), of level εa+1 (or, the last level). This will be n[n][n]b, and the level progression now gains the power of what was done when counting from the distance from 1 to n[n][n]b.

It continues like this until n[n][n] is reached, where will be the εath symbol of that sequence. However, will now be what n[n][n] was. And n[n][n] (with a new value for ) will be reached. And this keeps going, until has become n[n][n] εa times. This will be n[n+1][n], and I think, the very limit of this, will at least be εω.

WarDaft wrote:If you really think that's not the case, try defining your number more clearly... try to avoid any English descriptions and define as few new symbols as you can. Make the description as short as you can.

I'll try again later, I'll give up for now. Thanks for your patience. I just kept going because despite my definitions being greatly ambiguous and fuzzy, you and Deedlit were able to compare the growth of my number to the fast growing hierarchy and with the ordinals, so I was like a spoiled child ("why bothering making clear definitions if WarDaft told me the limit of my progression is ζ0? I'll just explain how  is the limit of my progression, so that 1 = ζ0).

PS - My number was never meant to compete with the latest numbers posted, I remember seeing some big number on a previous page and thinking "man, this idea of mine could beat that number, but the thread still has 15 more pages, so I guess all I can hope is to really beat this old posted number."
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! Darvince
Posts: 15
Joined: Wed Oct 10, 2012 1:59 am UTC
Location: Some weird alternate reality

### Re: My number is bigger!

I'll jump in here and define a couple things and see if I can get anywhere near how large your numbers are.

I am defining ↑x to be the number of ↑'s between the numbers, for example, ↑3 is equal to ↑↑↑.
I am defining & to be equal to the highest integer that is A(g64, g64)^A(g64, g64) digits long (aka 99999999...seemingly infinite...999).
I am defining Ý to be equal to the result of &^&, stacked in a power tower & times.
I am defining Ù to be equal to the result of (Ý^Ý)↑A(g64, g64)(Ý^Ý)

Now, Ù*10^Ý is my number that I hope is larger than yours. It's most likely infinitesimally small compared to yours, but it's worth trying.
If it's Good enough for Randall, it's Good enough for Me

(he/him/his)

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

At some point, the level of recursions that you have will be what matters and not your initial seed, because A(g64, g64)^A(g64, g64) will be nothing compared to a number A(g64, g64)^A(g64, g64)... A(g64, g64)^A(g64, g64) times ...^A(g64, g64)^A(g64, g64) digits long, which I think will dominate Ý.

I think level xkcd of my original progression would be higher than Ù. Level xkcd+1 would be higher than Ù↑ÙÙ. Level xkcd+2 would be higher than {{..{{Ù↑Ù↑^{Ù}Ù}Ù↑^{Ù}Ù}... Ù↑ÙÙ times...}Ù↑^{Ù}Ù}Ù↑^{Ù}Ù.

So if you continued the & -> Ý -> Ù progression for another {a number with xkcd digits} symbols, you'll reach about 1a.

So I defeated your number at this post, at this part *:

Vytron wrote:At level a, the limit of that number will be b, and you repeat the process but adding a hierarchies of iterated recursions, and increasing them as above. You get c, d, e... There will be a 1th symbol, let's call it *ζ. You keep repeating the recursions until you reach the ζth symbol. That's 2.
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

Ù is approximately g66.

It's not at all clear what you mean by the curly braces there. If it's just exponentiation, then there's no point in saying anything other than Ù↑Ù↑^{Ù}. Manually repeating the braces like that is completely dominated by just doing Ù↑Ù↑^{Ù+1}Ù, aka g68. That's why it's rather annoying when you include that sort of thing in your definition, if it's defined properly in the first place, the very next stage unrolls to much more than what you typed out anyway. Definitions do not need to be large for the numbers defined to be large.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

How would you rewrite this:

Vytron wrote:1 is the base seed, which is just a 9 followed by xkcd 9s, which is feed into some kind of hydra function that feeds on 9s on every level, and returns 9(x) (which turns it into a number that only have 9s and has x number of them) which is feed into the next level. Every level adds a new hierarchy of recursion, and iterative recursion, but the next level adds twice that, and the next adds the number of recursions exponentiated, with each new level increasing the level of recursions following the undefined progression.

Eventually, you'll reach level 1, and the limit of that number will be a, which is the new seed. The process of above is repeated, but instead of adding one hierarchy, and one iterated recursion, at every step, you add 1 hierarchy, and 1 iterated recursion, in the next level, 2*1 for both, in the next, 12, in the next 11, and so on.

At level a, the limit of that number will be b, and you repeat the process but adding a hierarchies of iterated recursions, and increasing them as above. You get c, d, e... There will be a 1th symbol, let's call it ζ. You keep repeating the recursions until you reach the ζth symbol. That's 2.

To avoid "any English descriptions" and to making the descriptions "as short as you can" and "using as few symbols as possible" so that 1 would be the limit of:

A(g64, g64)
A(A(g64, g64), A(g64, g64))
A(A(A(g64, g64), A(g64, g64)), A(A(g64, g64), A(g64, g64)))
...

And 1{1¶} would be the limit of:

A(g{1}, g{1})
A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))

Spoiler:
A(A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}) A(A(g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}, g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}), A(g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}, g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}})), A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}) A(A(g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}, g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}), A(g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}}, g{g{g{A(g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}}, g{g{A(A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}), A(g{g{A(g{1}, g{1})}}, g{g{A(g{1}, g{1})}}))}})}}})))

...

And 2 is the limit of:

1{1{1{1¶}}}
1{1{1{1{1{1{1{1¶}}}}}}}
1{1{1{1{1{1{1{1{1{1{1{1{1{1{1{1¶}}}}}}}}}}}}}}}
...

And what is the point in being precise in all that, if (the limit of the blue number progression) = 1 will only hit ω?
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

Backtracking to something I missed.
Vytron wrote:So we have the progression of Level 1 (which should be at least this strong, because it's applying the whole process at every step):

Step 1: εa2
Step 2: εa3
Step 3: εa4

And the εath step of that would be level 2 (or, the "last step of that is" level 2, because Deedlit told me I can just take the limit of that progression)
Let's assume you have hit some epsilon number (whether you have or not does not affect what follows). If you have some recursive scheme A with base function f(x), such that f(x) has growth rate comparable to the collapse of ordinal a. Let the recursive function that results from applying scheme A to f() be g(). Then g(x) has the growth rate of some ordinal a+b. If we reapply scheme A to g() and call the result h(), then h(x) has growth rate a+b2. So if one step at our current level is applying the recursive scheme A to the function produced by the previous step, and the b of this scheme is εa, then the above follows just fine. If you have properly extended this to infinite number of steps (not sure you have, but we'll ignore that too) then step εa would be εa2, which is indeed where you started at level 2, and is correct if and only if all of our above assumptions hold.

Level 2:

Step 1: εaa
Step 2: εaaa
Step 3: εaaaa
Here's where you're going off the tracks. In terms of collapse here, multiplying one ordinal by another is a lot different than adding one to another. Is it your intent to say that going from step 1 to step 2 of level one is equivalent to the entire scheme defined by level 1 to the procedure in step 1 to produce step 2? If so, then your progress actually looks like this:
Level 2:

Step 1: εaa
Step 2: εaa2
Step 3: εaa3
See, we just substitute "applying all of the things we did in level 1" into whatever recursive scheme A was before, and we once again hit the a, a+b, a+b2... pattern. To get the pattern you described, for level two, from what you've offered in English, you'd have to extend recursive schemes which you observe for two steps into infinite length schemes, and there is simply no obvious choice on how to do that (there are uncountably many ways in fact).

How would you rewrite this:
If I rewrote it to be completely unambiguous, then you won't learn how to make it even bigger very well at all.

And please, don't substitute values into both sides of the Ackermann function recursively, it's utterly pointless and kinda suggests that you don't understand how these functions actually work. The reduction for A(x+1,2) looks like this:
A(x+1,2)
A(x,A(x+1,1))
A(x,A(x,A(x,A(x+1,0))))
A(x,A(x,A(x,A(x,1))))
...
A(x,A(x,A(x,y))), for some y clearly greater than x (Much greater in most cases)
...

A(x,A(x,z)), for some z > y
...
A(x,w), for some w > z.
If a < b, we see that A(m,a) < A(m,b) for all m.
So A(x+1,2) = A(x,w) > A(x,y) > A(x,x), for any x.

One last note... the limit of the first sequence is infinity, so every item in the second sequence doesn't make sense.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Okay, thanks for the review. I've been thinking about this thread off and on over the last weeks, I'll probably need to start from scratch, and make sure the base of the concept is well defined, because otherwise knowing some progression reaches ζ0 doesn't really mean anything.

WarDaft wrote: Here's where you're going off the tracks. In terms of collapse here, multiplying one ordinal by another is a lot different than adding one to another.

Okay, the idea here is that I'm not really working with ordinals, I'm having a separate function that grows in some manner, and then just using the growth of ordinals to compare my function with, so people can get a general idea of how my number grows.

So, when I say I have a number matching εa, and next I have a number matching {εa}2, I don't mean that I'm actually using the ordinals in any way in my function, only that the number of recursions at this point are so high, that some level or step is comparable to some value of the ordinals.

Now, I've realized this is probably not possible, because the way the ordinals work is by using ordinal operations, while I'm stuck with normal operators.

So, ω reaches ω2 at ω*ω, but if I have some 1 symbol that matches ω, then, I can't just do 1*1 to reach ω2, because my multiplication is incredibly weaker than the normal multiplication, so I'm wasting a lot of steps, levels, symbols and recursions just to get to ω2. I think this is the reason my number is growing so slowly.

But I have thought about a solution, blue operators. These operators have built in recursion on themselves. Let's say that * is not multiplication, but an iteration of multiplications of length n.

Say then, that 1*1 would be equal to

1*1*1... 1*1 times... *1*1*1

Or

1^1^1... 1^1 times... ^1^1^1

Or

1↑↑↑... [1↑↑↑... 1 times ...↑↑↑1] times ...↑↑↑1

Or

1 → 1 →... [1 → 1 →... 1 times ... 1 → 1 → 1] times ...1 → 1 → 1

If 1 already matches ω, how many times do I need to do this to match ω*ω? Because, if I get the * to be strong enough, then I can reach ε0 as soon as I hit 1, because any combination of ω would be reached in the 1a, 1b, 1c... progression (provided I use the relative power of , as * to → compare to * and , and this powers gets stronger with every symbol change.)

WarDaft wrote:Is it your intent to say that going from step 1 to step 2 of level one is equivalent to the entire scheme defined by level 1 to the procedure in step 1 to produce step 2?

That's the first time it's done. The second time around, the biggest number discovered starts a counter, and this counter decreases by 1 with every time the whole procedure is applied to the new seed (what you'd expect to get you to step 2 decreases the counter by 1), and you don't move to Step 2 until the counter hits zero, and then, a new counter starts with the last number discovered in Step 1, and you don't move to Step 3 until it hits 0.

The third time around, the last number creates that number of such counters, so the whole procedure is repeated that many times just to decrease the number of counters, and Step 2 is reached when all the counters hit zero.

The fourth time around, you don't just create a number of such counters n times (which would be 2 layers of counters), you create a n layers of counters, where n is the biggest number reached. And now Step 2 is reached when the layers hit zero.

And so on.

I don't know how to write this with symbols and no English. I'm thinking about using images to show the growth of the recursions, as it seems at level 1 I have linear growth, at level 2 I build a square of such lines of growth, at level 3 I build a cube of such squares of growth. then a hypercube. So 1a would just be the 1th dimensional growth.
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

Vytron wrote:Okay, the idea here is that I'm not really working with ordinals, I'm having a separate function that grows in some manner, and then just using the growth of ordinals to compare my function with, so people can get a general idea of how my number grows.

So, when I say I have a number matching εa, and next I have a number matching {εa}2, I don't mean that I'm actually using the ordinals in any way in my function, only that the number of recursions at this point are so high, that some level or step is comparable to some value of the ordinals.
It really doesn't actually matter if you're working with them or not, and if you look carefully, I'm not assuming you are either.

If 1 already matches ω, how many times do I need to do this to match ω*ω? Because, if I get the * to be strong enough, then I can reach ε0 as soon as I hit 1, because any combination of ω would be reached in the 1a, 1b, 1c... progression (provided I use the relative power of , as * to → compare to * and , and this powers gets stronger with every symbol change.)
Okay, 1, as I understand it, is a value, not a function, correct? If so, then it doesn't 'match' an ordinal at all, functions match ordinals. Values match ordinal collapse applied to certain numbers. We can choose some n such that F1(n) matches 1. What you really need to say is that something like 1[x] matches Fa(x) for some ordinal a. Then, whichever part of your function lets you have growth rate equivalent to g(1) =1, g(2) = 1[(1)], g(3) = 1[(1[(1)])] ... then g(x) = Fa+1(x), and so on.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

WarDaft wrote: Okay, 1, as I understand it, is a value, not a function, correct?

Yes. It's the last member of the Blue Number Progression (1, 2, 3 ... = 1), and should reach at least ω (but not ω+1, etc.)

Hmmm, maybe I don't need so many recursions in order to reach ω.

Okay, I'm starting from scratch right now. With Level 0 Step 0, which is just 1=9(xkcd), the first blue number. The 9(n) checks n and creates a number with that number of digits. So 9(1000) becomes a 9 followed by 1000 9s.

1 is a 9 followed by xkcd-1 9s. It's not big, but it's very precise.

Now, level 1 is very weak, it just piles on the 9()s. 1 starts a counter that decreases by 1 for every step.

Level 1:
Step 1: 9(9(xkcd))
Step 2: 9(9(9(xkcd)))
Step 3: 9(9(9(9(xkcd))))
...

So by level 1 we have:

Step 9(xkcd): 9(9(9(...9(xkcd) times... 9(9(9(xkcd)))...)))

Let n = 9(9(9(...9(xkcd) times... 9(9(9(xkcd)))...)))

Let n() be a function that when you feed it a 2, it outputs = 9(9(9(...9(xkcd) times... 9(9(9(xkcd)))...)))

Now, to understand how Level 2 behaves, we enter into "imaginary space" (denoted by "bolded quotes"), in where we repeat the whole process of level 1, but with n() instead of 9(), and n as the seed, instead of 1.

It would look like this:

"Level 2"
Step 1: n(n)
Step 2: n(n(n))
Step 3: n(n(n(n)))
...
Step n(n): n(n(n(... n(n) times ...n(n(n(n(n))...)))

Let o = n(n(n(... n(n) times ...n(n(n(n(n))...)))
Let o() be a function that when you feed it a 2, it outputs a n(n(n(... n(n) times ...n(n(n(n(n))...)))

Back to reality, this whole process that created o() is what is applied at each step of level 2.

Level 2 (for real)

Step 1: n(n)
Step 2: o(o)
Step 3: p(p)
...
Create a n(n) counter that is decreased by one every time I say Hammertime! The first time I do it is at Step n(n).
Step n(n): x(x) Hammertime! <- The symbols don't matter at this point.

The next time it happens is when I reach steep x(x)
Counter n(n)-2.
Step x(x): c(c) Hammertime!

And now, I go to step c(c)...

And so on.

When the n(n) reaches 0, I have some z(z). Then, I make a=z(z), and a() a function that if given 2 as input outputs z(z).

That's for level 2.

Level 3 introduces a(a) layers of "imaginary space", and repeats the process of level 1 so it looks like this:

"""... a(a) times ..."""Level 3"""... a(a) times ..."""
Step 1: a(a(a))
Step 2: a(a(a(a)))
Step 3: a(a(a(a(a))))
...
Step a(a): a(a(a(... a(a) times ...a(a(a(a(a))...)))

ñ=a(a(a(... a(a) times ...a(a(a(a(a))...)))
ñ(2)=a(a(a(... a(a) times ...a(a(a(a(a))...)))

ñ(ñ) is taken and feed into imaginary level 2.

Spoiler:
"Level 2"
Step 1: ñ(ñ)
Step 2: ñ(ñ(ñ))
Step 3: ñ(ñ(ñ(ñ)))
...
Step ñ(ñ): ñ(ñ(ñ(... ñ(ñ) times ...ñ(ñ(ñ(ñ(ñ))...)))

ó=ñ(ñ(ñ(... ñ(ñ) times ...ñ(ñ(ñ(ñ(ñ))...)))
ó(2)=ñ(ñ(ñ(... ñ(ñ) times ...ñ(ñ(ñ(ñ(ñ))...)))

Level 2 is done for real
Spoiler:
Step 1: ñ(ñ)
Step 2: ó(ó)
Step 3: d(d)
...
Create a ñ(ñ) counter that is decreased by one every time I say Hammertime! The first time I do it is at Step ñ(ñ).
Step ñ(ñ): y(y) Hammertime!

The next time it happens is when I reach step y(y)
Counter ñ(ñ)-2.
Step y(y): p(p) Hammertime!

And now, I go to step p(p)...

And so on.

When the ñ(ñ) reaches 0, I have some s(s). Then, I make á=s(s), and á() a function that if given 2 as input outputs s(s).

The progression from a(a) to á(á) is what is really happening at the next layer, so, I remove a quote, and show the progression.

"""... a(a)-1 times ..."""Level 3"""... a(a)-1 times ..."""
Step 1: a(a)
Step 2: á(á)
Step 3: b(b)
...

Once all bolded quotes are removed one ends with real level 3, and a last value once all steps are done would be called t(t).

Level 4 introduces layers of layers (let's call them, "stories") of imaginary space.

"""... t(t) times ..."""Level 4"""... t(t) times ..."""
"""... t(t) times ..."""Level 4"""... t(t) times ..."""
.
.
t(t) times
.
.
"""... t(t) times ..."""Level 4"""... t(t) times ..."""
"""... t(t) times ..."""Level 4"""... t(t) times ..."""

(imagine a square)

And on the inside, it repeats the whole of Level 1 to produce u(u), the whole of Level 2 to produce v(v) and the whole of level 3 with its own layers (that aren't a(a), or t(t) but v(v) layers)) to produce w(w), which is really the first step of the first story of the first layer of level 4 in the t(t)-1 space.

Once all stories and layers of level 4 are over, we end with k(k). Level 5 will not add just an extra layer of layers of imaginary space (which would look like a cube), but layers of layers of layers of layers... repeat k(k) times... of layers of layers. So we'd need k(k) words to refer to the reality -> Imaginative space -> Layer -> Story progression.

This goes up to level 1 (level 9(xkcd)), which is 1a, which opens its own imaginary space, in where, you repeat everything again, but this time, you use 1a as seed (and u(), the last function produced at level 9(xkcd), instead of 9()), and reach level 1a. This will be "1b", which in reality, will be the first value reached in the first step of level 1 of 1a, with 1b, 1c, 1d adding more and more of such layers, stories and what level 5 did in the original layer progression.

Then follows 2, 3, 4... and the limit is , AKA 1, such that the function (2) would produce a value matching ω, and (¶) is being used as the first step of the first level of the first ....... of the first story of the first layer of imaginary space. Once all that is removed and 1a, 1b, 1c is over and 1, 1, 1 is over and 2, 3, 4 is over, we end with , so that a function (2) would produce ω2, that is 1, and from here on, since you repeat the WHOLE process in some building of imaginary space to reach 1, which becomes the real step 1 of level 1 of some story of imaginary space where you repeat the WHOLE process in some story of imaginary space to reach 2, which becomes the real step 1 of level 1 of some layer of imaginary space where you repeat the WHOLE process in some layer of imaginary space to reach 1, which becomes the real step 1 of level 1 of some imaginary space where you repeat the WHOLE process in some imaginary space to reach 1 which is REALLY step 1 of level 1 of 1, by the time you REALLY reach 1, it's already a value matching ε0.

WarDaft wrote:If so, then it doesn't 'match' an ordinal at all, functions match ordinals. Values match ordinal collapse applied to certain numbers. We can choose some n such that F1(n) matches 1. What you really need to say is that something like 1[x] matches Fa(x) for some ordinal a. Then, whichever part of your function lets you have growth rate equivalent to g(1) =1, g(2) = 1[(1)], g(3) = 1[(1[(1)])] ... then g(x) = Fa+1(x), and so on.

Well, in this new definition (which shouldn't be fuzzy anymore), if 1 is reached with function e(x), then e(e(x)), e(e(e(x))) e(e(e(e(x)))) is implicitly happening at the inner levels of imaginary space recursions to just figure out what is the real first step to get things going, so what you'd expect to be 1[(1)], would be happening early on, and value 1a would be way higher than that. The real 1[(1)], and 1[(1[1[(1)]])] (for 1 such recursions) would be lower than 2.
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! EliezerYudkowsky
Posts: 6
Joined: Sun Jan 20, 2013 5:20 am UTC

### Re: My number is bigger!

I haven't read this whole thread, but I know about the fast-growing hierarchy so I'm not going to present anything naive. My actually-computable finite number - albeit nobody knows its actual structure - is as follows:

Let T be the first-order theory of Zermelo-Fraenkel set theory plus the Axiom of Choice plus the axiom that there exists an I0 rank-into-rank cardinal. This is the most powerful known large cardinal axiom, AFAIK. I think that one such cardinal implies the existence of an infinite number of them, but if not, consider that condition added.

Starting with P = 10:

• Search through all Turing machines with at most P states.
• Search through all proofs in T of length at most 2^^P that the program halts.
• Run all programs such that a halting proof exists, until they halt.
• Add up all the running times of all those programs.
• Set P to this sum.

Repeat 10 times.

The end result should be roughly equal to the fast-growing hierarchy at the proof-theoretic ordinal of T, plus 1, applied to 10. Since nobody can constructively characterize the proof-theoretic ordinal for second-order arithmetic, let alone ZFC, let alone ZFC plus large cardinal axioms, this computer program should compute a larger number than the fast-growing hierarchy for any ordinal for which we could directly write a computable ordering. Despite that, so long as you can formalize ZFC in first-order logic (already done) and formalize the rank-into-rank cardinal axiom (I see no reason why that shouldn't be doable) you could actually write the above computer program and run it, given unbounded finite computing power (with no need for any halting oracles).

Can anyone who's been keeping track of this whole thread tell me whether I won?

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

How does your number compare to the collapsing ordinals ω, ε0, ζ0 progression?
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! EliezerYudkowsky
Posts: 6
Joined: Sun Jan 20, 2013 5:20 am UTC

### Re: My number is bigger!

That's just the Veblen function sub 0, 1, 2 right? This is overwhelmingly huger than the fast-growing hierarchy at the small Veblen ordinal, so there shouldn't be any comparison there.

So far as I know this should be the largest sort of number humanity can currently specify a program for computing, without new mathematics being done. You can add one to the resulting number, or run the program on 11 instead of 10, or play other trivial games like adding a copy of the small Veblen ordinal to the fast-growing hierarchy level or whatever, but you can't go significantly further until a significantly larger large cardinal is invented.

Basically, this should win unless (a) somebody came up with exactly the same idea, (b) I missed some crucial way of going even further without a halting oracle, or (c) the fact that I haven't actually written out the computer program makes the number legally underspecified.

Um, a brief explanation of the technique in case it wasn't obvious: First, running the longest Turing machine of size N that can be proven to halt in Peano Arithmetic using a proof of some bounded size as a function of N, will basically increase at the rate of the fast-growing hierarchy for epsilon-zero, because the proof-theoretic ordinal of PA is epsilon-0. I.e., PA can prove the well-ordering of any ordinal w, w^w, etc. up to but not including epsilon-0, so PA can prove Turing machines total that grow at any rate up to epsilon-0 but no further. You can prove any particular Goodstein sequence terminates, but not that Goodstein sequences terminate in general. So iterating over the largest functions provably total in PA using proofs of less than size N, basically grows at the same rate as iterating the Goodstein sequence, i.e., if you iterate over the largest functions provably total in PA 10 times, that's around the fast-growing hierarchy at epsilon-zero plus 1, applied to 10.

Now to PA adjoin a schema which says: "If for all N, it's provable in base-PA that PHI(N), then for all N, PHI(n)". This new, more powerful proof system can prove the consistency of base PA. Call this system PA+1 - basically, it's the system which believes for every formula PHI that if base-PA proves PHI, then PHI is true, i.e., the system that trusts base-PA. I believe that in base-PA, it's provable that for every Goodstein sequence, there exists a proof in base-PA that the sequence terminates. Base-PA can't prove all Goodstein sequences terminate just because PA doesn't trust base-PA. PA+1, which does trust base-PA, can prove that all Goodstein sequences terminate and hence has a larger proof-theoretic ordinal. (I think that it would take you up to at least epsilon-1, possibly zeta-0.)

In PA+1, you'd be able to prove that iterated Goodstein functions like Goodstein(Goodstein(Goodstein(4)) terminate, without having to prove out the individual steps - you could just prove that Goodstein was total, hence iterated-Goodstein was total. Or, equivalently, since PA+1 believes all proofs in base PA, PA+1 could diagonalize over functions provably total in PA, and run a function similar to the one I gave with PA as a base system. Making the proof system more powerful in a Godelian sense - allowing it to prove the base system trustworthy - increases its proof-theoretic ordinal, and increases the level of the fast-growing hierarchy that functions provably total in the system can occupy. (Because if you trust the base system it's provably total to look for the fastest-growing function provably total in the base system, i.e., you can diagonalize over the fastest-growing functions provably total in the base system.)

Full second-order arithmetic has a proof-theoretic ordinal so large that nobody has given a combinatorial characterization of it, and then ZFC has an even larger ordinal. So if you diagonalize over the fastest-growing functions that are provably total / longest-running Turing-machines that provably halt, with either second-order arithmetic or ZFC as the proof system, the resulting computable function should increase faster than the fast-growing hierarchy for any ordinal that has yet been exactly characterized.

An inaccessible cardinal is a cardinal whose existence is not provable in ZFC because the large cardinal's existence implies the consistency of ZFC. For example, suppose there's a set large enough to provide a model of ZFC - a set large enough to contain the complete set-theoretic universe of ZFC inside itself. The rank of this set is an inaccessible cardinal. If you add an axiom saying that an inaccessible cardinal exists, that means that there's a set which models ZFC, so this new theory can prove base-ZFC consistent, and hence must have a larger proof-theoretic ordinal. The way in which we strongly increase the proof strength of a set theory (and hence let it diagonalize over lesser systems like base-ZFC) is by adding larger and larger large cardinal axioms, each of which implies the consistency of lesser systems.

So if you look for proofs in "ZFC plus the largest known large cardinal axiom" that a function is total, you get a system that can prove functions total if they grow no faster than the fast-growing hierarchy up to some very large ordinal that nobody has come remotely close to combinatorially characterizing, and yet the whole operation is still computable. In fact, I don't know of any way to get significantly larger computable numbers than that. But I'm not a mathematician, so it's possible that I'm missing something. There might also be a flaw in the method or the reasoning. Or somebody else might've thought of it earlier. But as far as I can tell, my number or something like it should be the size of the largest computable number that anyone has ever thought of, or can ever think of, until an even more powerful large cardinal axiom than I0 rank-into-rank is invented.

Of course, as I understand it, people aren't sure that I0 rank-into-rank is compatible with ZFC, so we might have to retreat to I1 or an even lower large cardinal axiom if it turns out that I0 doesn't work. So it's more like that the number I named probably exists - the computer program probably won't prove that a machine halts when in fact it doesn't halt and hence run forever - and if my number does exist, it's as large as it gets (for a while, without doing new basic mathematics).

Can anyone confirm whether I got all that remotely correct?

cjquines
Posts: 61
Joined: Thu Jul 21, 2011 5:30 am UTC

### Re: My number is bigger!

I don't care if I win anymore. Numbers are fun!
Let x→xy = x→x→x→x ... x times ... →x→x→y.
Let x→xy = x→xx→xx→xx→x ... x times ... →xx→xx→xy.

Let f(x) be a meta-function such that it makes functions. The functions will be noted as f1(x), f2(x), etc.
f(x) is defined such that fx(x) = x→xx.

Let g(x) be a meta-meta-function such that it makes meta-functions f(x). The meta-functions will be noted as g1(x), g2(x), etc.
g(x) is defined such that gx(x) = g→xx.

Let this inane drivel continue to a meta-meta-meta-meta-meta-something-function z(x).

Let A(x) be an operator on meta-something-functions.
A(f(x)) is defined as f1(x)→f2(x)→f3(x) ... →fx(x).
Thus, my number is
A(A(A(...how many As are required...A(z(xkcd number))))...how many parentheses are required.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

cjquines wrote:g(x) is defined such that gx(x) = g→xx.

Let this inane drivel continue to a meta-meta-meta-meta-meta-something-function z(x).

I think the problem with your number is that it's not going very far here, you're going from g to z. That's 19 stories of layers of recursion, why don't you go to the nth symbol so that the g(), h(), i() progression goes on for, say, the f(xkcd)th symbol of the progression (f(xkcd) stories of recursions instead of 19), and take the last story, say e(x), and repeat the whole process to create e(x) building of stories, take the last building d(x), build d(x) streets of such buildings, etc., and repeat until the function goes long enough that you'd need z(x) words to describe the recursion -> layer -> story progression (so that z(x) itself is the last function)?

I don't have a clean way to write it, but I think some b(xkcd) would be bigger than your number, and if you applied A(z(x)) on this z, my imaginary space is going to eat your number, so that, my 100 would already cover all such kind of recursions.

I think this is because you're relying on the → arrow as your basis of power, and just using it again and again on further recursions, while I start with a much slower power (the 9()) but the number of imaginary space I add keeps increasing the power, so at some point, some o()=n(n(...n times...(n(n))...n times...)) will be stronger than n→n→...n times...→n, AND in the next recursive level I don't go back to →'s, but use o() as the power, while in your last level you are still relying on the f1(x)f2(x)f3(x) ... fx(x).
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! Surfer
Posts: 54
Joined: Sat Aug 11, 2012 6:26 pm UTC

### Re: My number is bigger!

At this point, it seems to me that EliezerYudkowsky has basically solved the original problem that was posed. So this might be a fun time to summarize the thread, writing everything in a common notation (Mathematica) to allow comparisons. The summary is long, and so hidden in a spoiler:
Spoiler:
The first "big numbers" were long strings digits, because a number like 3333333333 is unimaginably larger than a number like 3. But the group soon tired of that and decided to use basic arithmetic operations, like these:

Code: Select all

`(*successor*)      f1[x_] := x + 1;(*addition*)       f2[x_, 0] := x;                   f2[x_, y_] := f1[f2[x, y - 1]];(*multiplication*) f3[x_, 0] := 0;                   f3[x_, y_] := f2[x, f3[x, y - 1]];(*exponentiation*) f4[x_, 0] := 1;                   f4[x_, y_] := f3[x, f4[x, y - 1]];`

Now, there was no longer any point in writing long digits strings like 3333333333, because we could just write things like 3^3^3, which is already larger than that, and is easier to type.

So now that 3333333333 was practically the same size as 3, we moved on to constants like Graham's number g_64, which is unimaginably larger than 3.

The arithmetic operations above follow a clear pattern, so an obvious next step is to generalize that pattern to get the hyperoperations, or the related Ackerman function:

Code: Select all

`(*Ackerman's Function A(x,y)*)f[0, y_] := y + 1;f[x_, 0] := f[x - 1, 1];f[x_, y_] := f[x - 1, f[x, y - 1]];`

This is far more powerful than any of the previous functions. The previous functions were defined in terms of a single recursive call, but this is defined in terms of two. So instead of expanding into a chain of calls to itself, it expands into a whole tree of calls to itself. That's much more powerful. In fact, it grows so fast that no primitive recursive function can even implement it.

This new power now allows us to define new constants, like "xkcd", which is Ack(g_64,g_64). Of course, xkcd is unimaginably larger than g_64, which in turn is still unimaginably larger than 3.

Ackerman's function can be written exactly in terms of Knuth's up arrow notation, so the up arrow notation is at least as powerful, and a little more elegant:

Code: Select all

`(*Knuth's up arrow notation, y upArrowXtimes z *)f[1, y_, z_] := y^z;f[x_, y_, z_] := f[x - 1, y, f[x, y, z - 1]];`

But why stop there? Conway invented the chained arrow notation, which is even more powerful:

Code: Select all

`(*Conway's chained arrow notation, listed in reverse order*)f[x_] := x;f[x_, y_] := x^y;f[1, y_, z__] := f[y, z];f[x_, 1, z__] := f[z];f[x_, y_, z__] := f[x - 1, f[x, y - 1, z], z];`

This is far more powerful. The z__ parameter has two underscores, which means it can match an arbitrary number of parameters. So now, instead of a binary operator, we have an n-ary operator, for any finite n, and all those parameters are passed down through recursion. Using chained arrow notation with just a few arrows, we can easily express Ackerman's function exactly, express multiple up arrows exactly, or concisely write specific numbers far larger than g_64 or xkcd.

At this point, xkcd and g_64 are practically the same size as 3. They differ only by a handful of arrows. So from now on, there's really no point in using any named constants rather than just constants like 3 or 33. But, of course, we'll continue using xkcd and g_64 for the rest of this thread, because of the illusion that they feel much bigger than 3.

At this point, it became clear that the goal was to find functions that grow fast, and so the group turned to the fast-growing hierarchy. The hierarchy in some ways reaches an important turning point at the ε0 level, so it's useful to look at a function that's roughly on that boundary, and then pause for a moment. The most famous such function might be Goodstein's:

Code: Select all

`(* f is Goldstein's function.  f(3)=7.  f(4) is pretty big. *)f[x_] := f[2, x];f[n_, 0] := n;f[n_, x_] := f[n + 1, g[n, x] - 1];g[b_, x_] := If[x < b, x, Block[{t, d},    t = Floor[Log[b, x]];    d = Floor[x/b^t];    d (b + 1)^g[b, t] + g[b, x - d b^t]]];`

In this implementation, g is a recursive function that converts integer x into hereditary base b, then replaces the b with b+1 everywhere, then converts back to an integer. The f function simply iterates g-1 until it reaches 0, then returns the number of iterations.

At this point, we're talking about functions that run for so long, that we have to start worrying about whether they ever halt at all. We can't even prove that Goldstein is total (i.e., that it halts for all n) in Peano Arithmetic (assuming PA is consistent). We actually have to go to something stronger than PA. From this point on, our real problem is no longer to find functions that recurse more and more times before halting. Our problem is now to show that they halt at all.

There was then much discussion of higher levels of the fast-growing hierarchy, and all the complexities that are involved in representing the ordinals involved and building total functions from them. But ultimately, the real problem was having programs that provably halt. So EliezerYudkowsky basically jumped to the ultimate answer by proposing something reminiscent of the Busy Beaver function, but limited to programs with bounded-size proofs that they halt:

Code: Select all

`(* f is a simplification of the EliezerYudkowsky function *)f[n_] := Sum[    If[provenQ[p, t, n], runningTime[t], 0],        {p, 0, 2^n},        {t, {set of all Turing machines with n states}}];provenQ[p_, t_, n_] := return whether proof p shows that Turing machine t halts within the first n steps;`

The proposed number was f10(10). The proposed f actually used a proof length of 2^^n instead of the n used above, but that seems like a fairly trivial extension to the simpler f function shown above. The proposed definition of "proof" was said to be in ZFC with an additional axiom that there exists an I0 rank-into-rank cardinal. The above pseudocode glosses over details of how the proofs will be numbered, but that has no real effect on the power, other than the fact that you might have to evaluate the function at something like 2^10 or 2^2^10 instead of 10, depending on choice of notation. Obviously, we can get bigger numbers by trivial changes to the function, or by extending the axiom system further. But aside from that, this is, in some sense, the best that can be done now.

At this point, it isn't clear that there's anything that is both bigger and interesting. But it was certainly an interesting ride to reach this point. And it's interesting to compare all the recursive functions above. All but the last are written out completely, with no pseudocode. In some ways, they all look similar, yet they differ remarkably in power. It isn't clear that we could easily rank them by power by just looking at them, if we didn't already recognize them as famous functions.

Reading this thread has been fun.

Draco18s
Posts: 89
Joined: Fri Oct 03, 2008 7:50 am UTC

### Re: My number is bigger!

Sorry to jump in on something so old, but:

Blatm wrote:Let [imath]f_k (n)[/imath] be the least number not expressible with n characters in kth (or lower) degree logic.

My number is [math]f_{f_{f_{999!}(999!)} (999!)}(f_{f_{999!} (999!)}(f_{999!}(999!)))[/math]

Unfortunately this number is expressible with only 66 characters, ergo your function is undefined (that is, if the function did exist, it could only return infinity, as any non-infinite value that your function returned could be expressible with fewer characters than was passed as the function parameter...by referencing the function itself).

Yakk
Poster with most posts but no title.
Posts: 11129
Joined: Sat Jan 27, 2007 7:27 pm UTC
Location: E pur si muove

### Re: My number is bigger!

The issue with using large ordinal based proofs is that they may not be consistent. If we can presume consistency of an as-yet-unknown-to-be-consistent axiom system, wouldn't it be rather easy to produce a large number whose size is non-commensurate with the large ordinal one?

Ie, we start with something like "assuming busy beaver(6) is at least xkcd", and add that to some base axiom system. Then we prove the halting of Turing machines in that axiom system. And any axiom we take that isn't known to be provable works -- assuming the existence of an inaccessible cardinal via an axiom, that P=NP, that P!=NP, the earlier busy beaver assumption, etc.

Without being able to prove one in another, I cannot think of a way to order the strengths of the axiom systems, and hence the rate of growth TMs can be proven to grow within.

Or is there something special about the existence of an inaccessible cardinal assumptions I'm missing? Ie, do we know that the existence of those particular inaccessible cardinal is independent of ZFC? That places them in a different category than "things we don't know are consistent or not". Is that what using a "smaller inaccessible cardinal" is about, until you reach one that is smaller, yet provably independent?
One of the painful things about our time is that those who feel certainty are stupid, and those with any imagination and understanding are filled with doubt and indecision - BR

Last edited by JHVH on Fri Oct 23, 4004 BCE 6:17 pm, edited 6 times in total.

r.e.s.
Posts: 0
Joined: Mon Jun 14, 2010 2:49 pm UTC

### Re: My number is bigger!

EliezerYudkowsky wrote:Let T be the first-order theory of Zermelo-Fraenkel set theory plus the Axiom of Choice plus the axiom that there exists an I0 rank-into-rank cardinal. This is the most powerful known large cardinal axiom, AFAIK. I think that one such cardinal implies the existence of an infinite number of them, but if not, consider that condition added.

Starting with P = 10:

• Search through all Turing machines with at most P states.
• Search through all proofs in T of length at most 2^^P that the program halts.
• Run all programs such that a halting proof exists, until they halt.
• Add up all the running times of all those programs.
• Set P to this sum.

Repeat 10 times.

It seems counter-productive that each pass in your procedure restricts the searching to TMs with at most P states. Removing this restriction should give a very significant growth-rate increase; e.g., among the TMs that are T-proven to halt using at most 2^^10 symbols, it seems likely that by far the greatest running times occur for those with far greater than a mere 10 states. Without the restriction, the number corresponding to your final P-value would be ι(11), where ι() is defined recursively as follows to match your procedure:

• ι(0) = 10
• ι(k+1) = sum of the running times of all TMs (irrespective of the number of states) that halt T-provably using at most 2^^ι(k) symbols.

NB: Assuming my interpretation is correct ... If, in the above definition of ι(), we were to use (ZFC, 1000, 2^ι(k), maximum) instead of the respective (T, 10, 2^^ι(k), sum), then ι(1) would be the smallest of what Harvey Friedman calls transcendental integers ("Enormous Integers in Real Life", p. 11).

Draco18s
Posts: 89
Joined: Fri Oct 03, 2008 7:50 am UTC

### Re: My number is bigger!

I bumped into the XKCD blag on large numbers trying to Google this thread to link to a friend.

Randell's largest number (in 32 characters) is:

H(n)=BB^n(n);H(H(H(H(H(H(9))))))

Which before reading the comments I thought "I can do better" (turned out my solution had been arrived at by someone else). But I figured I'd post the proof.

B(n) here equals BusyBeaver(n). I shortened BB(n) to B(n) only to more easily show the equivalent complexity between Line 1 and Line 3. Function letters are unique between the two statements to avoid confusion.

Proof that G(n)=B^n(n);F(n)=G^n(n);F(F(9)) > H(n)=B^n(n);H(H(H(H(H(H(9))))))
1. The first step in the original algorithm recurses to
H(9) = B(B(B(B(B(B(B(B(B(9)))))))))
2. The first step in the new algorithm recurses to
F(9) = G(G(G(G(G(G(G(G(G(9)))))))))
3). The second step is to resolve this into a stacked B(n) notation, the first iteration of which is solvable:
G(9) = B(B(B(B(B(B(B(B(B(9)))))))))

4) As line 3 is the same value as line 1 (Line 1 == Line 3), we look at how many iterations each of this is stacked. The original function:
H(H(H(H(H( Line 1 )))))
And line 2:
G(G(G(G(G(G(G(G( Line 3 ))))))))
(Which is, itself, also stacked, but not relevant to the proof)
Which are of comparable complexity (that is, H(n) == G(n)), thus the new statement is at least 5 orders of magnitude larger.

-----------------------------------------------

I don't think you can get any larger in 32 characters without using G (Graham's Number, 3↑↑↑↑3) as the initial seed (which requires additional explanation, as it is, we're already explaining that BB(n) is the busy beaver function) or converting ^n to n which isn't doable in plaintext.

Edit:
Actually n is possible...using UTF8.
In which case, we can save 2 characters and get this:
F(n)=BBⁿ(nⁿ);H(n)=Fⁿ(nⁿ);H(H(9))
As the new largest value.
If we had 3, we could stack H() one more time, but there isn't anything else we can steal a character from without losing recursion elsewhere. Knuth's Up Arrow Notation doesn't help, as a↑b == ab (e.g. n↑n == nⁿ and uses more characters). We also can't do nnⁿ as that isn't doable even in UTF8 without extra formatting characters (ie. the <sup> tag).

Alternatively, we could use ₙ (that would be n if you don't have that UTF8 extension installed, which I do not) on our Busy Beaver function, referencing super-Turing machines. Although this gets onto shaky ground, as BB2(2) doesn't even have a theoretical value, as it requires a hypothetical machine capable of solving the halting problem for regular Turing machines. Also, I know of only one article in which this is used.
Alternatively, it could mean multidimensional Turing machines, which would explode, value-wise, very quickly (BB2(n) grows faster than BB1(n)). We, however, cannot conclude if BBn(n) grows faster than BB(nn) or not.

r.e.s.
Posts: 0
Joined: Mon Jun 14, 2010 2:49 pm UTC

### Re: My number is bigger!

@ Draco18s

Restricting to 32 characters is somewhat off-topic, but it's still an entertaining challenge, obviously depending on the meaning of "character" and on notational conventions. For definiteness, I'll assume that only ASCII printable characters are allowed. By using operator notation, 21 characters are enough to define all finite levels of a "fast iteration hierarchy" that starts with some chosen initial function S:

=S;[k+1]n=([k]^n)n

Here's a specific large number defined using 32 characters, with S being, say, the running-time Busy Beaver function:

=S;[k+1]n=([k]^n)n;[[9]9]9

This is much larger than the number you define above, which is only FF9 = 9 in the present notation. Note that your G and F are just  and , respectively.

If S were merely the successor function (Sn=n+1) then this simply defines the "standard" fast-growing hierarchy, for which [k]n > 2^^...^n with k-1 up-arrows, and hence

9 > 2(8 up-arrows)9 > g_1 + 1
[9]9 > 2(g_1 up-arrows)9 > g_2 + 1
[[9]9]9 > 2(g_2 up-arrows)9 > g_3 + 1
etc.

where the g_1, g_2, g_3, ... is the well-known sequence in which g_64 is Graham's number.

In 29 characters, an "Ackermann functional" can be defined by

=S;[k+1]n=([k]^n)n;An=[n]n

such that if Sn=n+1 then (A^64)6 exceeds Graham's number (with the whole definition using a total of 37 characters).

WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

Basically, this should win unless (a) somebody came up with exactly the same idea, (b) I missed some crucial way of going even further without a halting oracle, or (c) the fact that I haven't actually written out the computer program makes the number legally underspecified.
I believe someone has done such things before, but there isn't really any way of comparing them. Furthermore, I believe I recall, though I am not certain, that others in the thread have mentioned other works including numbers based on the Calculus of Constructions or related Coq theorem proofing assistant can reach far larger values as they are equivalent to the union of finite order logics.

Furthermore, if we assume the consistency of your axiomatic system, we can create a higherarchy of A, A+Con(A), A+Con(A+Con(A)), ... which is much larger. If we assume even more about it's consistency, then we can create an ordinal heirarchy of such statements which gets even more bizarre, but quite obviously given it's more powerful axioms can make better proofs of the halting of various TMs. There's really no end to it. I'm mostly satisfied that once I introduced one construct (collapsing ordinals to finite numbers without the fuss of defining fundamental sequences), it began to be used in every entry of it's kind.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

dudiobugtron
Posts: 1098
Joined: Mon Jul 30, 2012 9:14 am UTC
Location: The Outlier

### Re: My number is bigger!

Draco18s wrote:Sorry to jump in on something so old, but:

Blatm wrote:Let [imath]f_k (n)[/imath] be the least number not expressible with n characters in kth (or lower) degree logic.

My number is [math]f_{f_{f_{999!}(999!)} (999!)}(f_{f_{999!} (999!)}(f_{999!}(999!)))[/math]

Unfortunately this number is expressible with only 66 characters, ergo your function is undefined (that is, if the function did exist, it could only return infinity, as any non-infinite value that your function returned could be expressible with fewer characters than was passed as the function parameter...by referencing the function itself).

Only for n=4 or more.

f(3) may still be defined.

Amida
Posts: 2
Joined: Thu Feb 21, 2013 6:02 am UTC

### Re: My number is bigger!

As a new guy to this, I'm just gonna try something I came up with and see where it lands me in all this.

To start off, I'm going to define some operations with functions. It starts off simple with f2(x) = f(f(x)) along with f3(x) = f(f(f(x))) and so on. Next I will define 2f(x) to be equal to ff(x)(x). That is if f(x) = 2x then 2f(2) = ff(2)(2) of f4(2) or 32. 3f(x) would then be ff[sup]f(x)(x)[/sup](x).

If we then move on to up arrows, f^2(x) = f2(x)
f^^2(x) = 2f(x)
It will simplify in a similar manner to normal up arrow notation because f^^3(x) would equal f^f^f(x)(x)(x)
These would still apply to higher numbers of arrows. (f^^^2(x) = f^^f(x)(x)).

We can then take this and start to work with chained arrows. f→2→2(x) = f→f(x)(x). f→3→3(x) = f→(f→f(x)→2(x))→2(x).

Now let's define the function g(x) = 3→3→x
g(4) would be g_1
g64(4) would be Graham's Number
2g(4) = gg(4)(4) or the g_1 th element in that series (alternatively g_g_1).
g^^^2(4) = g^^g(4)(4) which would have g_1 g_'s (g_g_...g_1)
g^^^3(4) = g^^g^^g(4)(4)(4) which would have g^^^2(4) number of g_'s in the sequence.
If we carry on with this logic, we can get to g→g64(4)→g64(4)(4) which I will call my number. I hope it can at least make a dent when compared to some of these numbers, I couldn't keep up with all of it.

itaibn
Posts: 142
Joined: Mon Dec 29, 2008 7:06 pm UTC

### Re: My number is bigger!

EliezerYudkowsky wrote:I haven't read this whole thread, but I know about the fast-growing hierarchy so I'm not going to present anything naive. My actually-computable finite number - albeit nobody knows its actual structure - is as follows:

Let T be the first-order theory of Zermelo-Fraenkel set theory plus the Axiom of Choice plus the axiom that there exists an I0 rank-into-rank cardinal. This is the most powerful known large cardinal axiom, AFAIK. I think that one such cardinal implies the existence of an infinite number of them, but if not, consider that condition added.

Starting with P = 10:

• Search through all Turing machines with at most P states.
• Search through all proofs in T of length at most 2^^P that the program halts.
• Run all programs such that a halting proof exists, until they halt.
• Add up all the running times of all those programs.
• Set P to this sum.

Repeat 10 times.

The end result should be roughly equal to the fast-growing hierarchy at the proof-theoretic ordinal of T, plus 1, applied to 10. Since nobody can constructively characterize the proof-theoretic ordinal for second-order arithmetic, let alone ZFC, let alone ZFC plus large cardinal axioms, this computer program should compute a larger number than the fast-growing hierarchy for any ordinal for which we could directly write a computable ordering. Despite that, so long as you can formalize ZFC in first-order logic (already done) and formalize the rank-into-rank cardinal axiom (I see no reason why that shouldn't be doable) you could actually write the above computer program and run it, given unbounded finite computing power (with no need for any halting oracles).

Can anyone who's been keeping track of this whole thread tell me whether I won?

Just barely. Back in page 7:

itaibn wrote:What is the sum of the results of all algorithms that are provably computable in ZFC+I0 with a proof of length less than A(9,9)?

At the time, my proposal was disputed because the other posters weren't convinced that it represented an actual number. I had to resort to a more straightforward (and vastly smaller) entry to gain my place.

Though thinking about it, neither of these entries are valid, because neither of them fully specify what a proof is and how to measure its length, and so they don't fully specify what the number is.
I NEVER use all-caps.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Long time I don't see people comparing numbers here. Amida, I belive you're very far behind (just like I am, heh), but I think that we can compare our numbers. I had sent The blue number progression.

Amida wrote:To start off, I'm going to define some operations with functions. It starts off simple with f2(x) = f(f(x)) along with f3(x) = f(f(f(x))) and so on.

Okay, here, h=f(f(f(...f(x) f('s...f(f(f(x)))... f(x) )'s ...))) matches with my 2. f(f(f(...h f('s...f(f(f(x)))... h )'s ...))) matches with my 2a, and f(f(f(...z f('s...f(f(f(x)))... z )'s ...))), where z corresponds to the last character in the f->h->?->?->y->z progression, where z is the yth character (for 2 stories of imaginary space), equals 3.

Amida wrote: Next I will define 2f(x) to be equal to ff(x)(x). That is if f(x) = 2x then 2f(2) = ff(2)(2) of f4(2) or 32. 3f(x) would then be ff[sup]f(x)(x)[/sup](x).

Still below 2d

Amida wrote:If we then move on to up arrows, f^2(x) = f2(x)
f^^2(x) = 2f(x)
It will simplify in a similar manner to normal up arrow notation because f^^3(x) would equal f^f^f(x)(x)(x)
These would still apply to higher numbers of arrows. (f^^^2(x) = f^^f(x)(x)).

So if there's a n= f^^^2(x), and o for f^^...n ^'s...^^2(x), then f^^...o ^'s...^^o(x) would be below 2o (where o is the 1th symbol in the sequence.)

Amida wrote:We can then take this and start to work with chained arrows. f→2→2(x) = f→f(x)(x). f→3→3(x) = f→(f→f(x)→2(x))→2(x).

Here, for i=f^^...o ^'s...^^o(x), i→i→i→... i arrows...→i→i→i (going up to f→33(x)), would be below 4.

Amida wrote:Now let's define the function g(x) = 3→3→x
g(4) would be g_1
g64(4) would be Graham's Number
2g(4) = gg(4)(4) or the g_1 th element in that series (alternatively g_g_1).
g^^^2(4) = g^^g(4)(4) which would have g_1 g_'s (g_g_...g_1)
g^^^3(4) = g^^g^^g(4)(4)(4) which would have g^^^2(4) number of g_'s in the sequence.
If we carry on with this logic, we can get to g→g64(4)→g64(4)(4) which I will call my number. I hope it can at least make a dent when compared to some of these numbers, I couldn't keep up with all of it.

And here:

g→gi(i)→gi(i)(i)→gi(i)(i)(i)→... gi(i)(i) [... g→gi(i) (i)'s ...] ... (i)(i)

Would be below 64.

(Here, where I talk about thinks like 3, I meant that once we're up to 2, where is the last character in the sequence, there's some v(x) power that was reached, which is used to power 3 in the beginning by 2 hierarchies of recursions. This v(x) matches some f(x).)
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Okay, I think my blue number progression has been largely ignored. It's probably my fault as I haven't been able to show its value properly. But it's because it runs on "Imaginary Space", and I don't know if there's a mathematical analog.

It's also hard to describe when the numbers start huge and become much huger as you add more imaginary space. So what I'm going to do is putting an example in where I go back to the bare bones in trying to explain how it works. I'll go back to 1+1. With pictures.

We start at Level 1. It had 10 steps. These steps are all the same, they just repeat the process of the first step, so it looks like this: And we go to Level 2. Level 2 looks at the power of the first floor, and applies it at the first number of the first step. So the first step returns 100. However, at step 2, it doesn't just repeat it once, it repeats it 100 times. So step 2 returns 100^100. Step 3 repeats step 2 100^100 times, so we have 100↑↑(100^100). Step 4 repeats Step 3 100↑↑(100^100) times. We have 100↑↑↑(100↑↑(100^100)). It goes up to Step 100, so by the last step we have 100↑↑... 100 ↑'s ...↑↑(100↑↑... 99 ↑'s ...↑↑(100↑↑... 98 ↑'s ... [keep reducing the arrows] ... 100↑↑(100↑↑(100^100), this is the last step. This gets used to power up level 3. Level 3 starts adding Layers of imaginary space. Here, it means, that for the "First step" (note the quotes) of Level 3. We just apply the power of the last two floors 100↑↑... 100 ↑'s ...↑↑(100↑↑... 99 ↑'s ...↑↑(100↑↑... 98 ↑'s ... [keep reducing the arrows] ... 100↑↑(100↑↑(100^100) times. With the ↑n notation, this is just like having n be the last step of level 2. The "Second step" just has a tower of ↑n↑n↑n↑n... "First Step" times ...n↑n↑n↑n, or ↑n↑↑o, where o is the number of the "First step". So Level 3 is straight forward: So the "100↑nth" step of level 3 has a value of 100↑n↑↑o↑↑↑p↑↑↑↑q... ... ...↑↑↑z, where z is the value of the "100↑n-1th step" of Level 3.

However, this is just imaginary space, this last value of the step, the one that would be expected to be the highest value of Level 3, in reality is the true value of Step 1. Which is what is used to power the value of Step 2, as if it was Level 4.

So, to compute level 3, we imagine how this progression would continue, for what would be 100↑n Levels. So, if the progression continued like this, and for every Level we increased the increase rate by the magnitude we've showed so far, we'd end with the y value on the yellow box on the picture. This, really, is the last step of Level 3

But, so far, we're just added a layer of recursion by step. On Level 4, we add r layers of such imaginary space by step, where r is the largest number found yet. So what was done to know what was the highest value of Level 3, would be done to see what is the highest value of level 4. And that would be the """... y quotes...""" real step 1 """... y quotes...""" of level 4. To know the real step 1 of level 4, you have to build the whole store y times, with every increasing numbers and steps required. By then you have some y(y) power, the power used to know the true value of Level 4 Step 1. Used to power up Level 4 step 2, with y(y) layers of quotes.

I imagine some sort of cube. That white C on the green square at the end of the chain, is really, the value that we have at Level 4 Step 2. Which is now used to power up Step 3, which repeats the same process for C stories of imaginary space, to reach the true value of Step 3. And so on. This goes up to y(y) real step, which by then has some z value, which we can feed into the whole process again z times for z(z).

On Level 4 we reached some kind of "dimensionality", by the process being a square, then, every step of the square was a square itself. Then, every square on the square was a cube itself (3 dimensions). By Level 5, we put on it z(z) dimensions of imaginary space. This time I don't have enough graphs to show all the effort required just to get what's the value of Level 5 Step 2.

But the idea is that I'm kind of cheating. I show you a progression, then, you see how big it can get, and then I tell you. "Well, thanks for imagining it, that's actually the next step in the progression." And then I do it again. And then I do it n times, where n is the biggest number encountered to find o. Then, I add o layers of "times" on themselves, to find p. Then, I add p stories (like the above cube) of o layers of "times", to find q. By the next level, I need q words to describe the "step -> layer -> story -> ... -> q" progression. And so on.~

And that's how imaginary space works.

But this was +1 simple sum. The real blue number progression starts with the base 9(xkcd), where 9(x) returns a number with x digits (9(1000) returns a number with 1000 digits), and the base progression is 9(xkcd), 9(9(xkcd)), 9(9(9(xkcd)))... with the last number of level 1 being 9(9...9(xkcd) times...(9(xkcd))), used to power level 2. Much better than multiplying by 10. This process will be repeated 9(9...9(xkcd) times...(9(xkcd))) times to reach the value of step 1 of Level 2, and off it goes.

When Level 9(xkcd) is truly reached, that'll be 1a, then comes 1b, with the same process going to Level 1a. Up to 1, where is the 1ath symbol of the progression. 1 is 2, and the same is repeated, with much bigger progress, for 2a, 2b, 2c. Then 3, 4, 5...

Up until 9(xkcd), which by this point, if we remove all imaginary space, is really 1b. For 1c, we imagine counting to {1b} 1b times. And those times get upped up in the above fashion, so the real 2 is humongous, and the real 9(xkcd) = 1 surpasses ω.

When I continue like this and then skip from ω↑ωω to ε0 and I'm told "you can't do that, because there's this intermediate point here and you're still far away to it", I claim I pass that point in imaginary space.

No matter what's the growth of something, I think I have the power to surpass it with this progression, I think I pass the fast-growing hierarchy at about 1, and by that point, you'd need to compute all the way up to 1...1 times... [as many times as necessary], to really reach 1a (in your way to 1.)
Go! Go! You can do it username5243!
Cheers Marsh'n!

Your ad here. No, seriously! It's free! PM me if interested.
THANKS KARHELL!! Deedlit
Posts: 91
Joined: Sun Mar 08, 2009 2:55 am UTC

### Re: My number is bigger!

Is "imaginary space" some sort of blanket term that automatically covers all possible ideas and extensions? If so, then that is obviously cheating - one could be much simpler and simply say "for any number n you pick, I'll say n+1", which is the same sort of thing.

1 obviously doesn't pass the fast-growing hierarchy, since it is a specific number, so it doesn't pass even f_0 = x + 1, which is a function. x won't pass the fast-growing hierarchy either, since the fast-growing hierarchy goes arbitrarily far, as far as one cares to define ordinals. I'll take a closer look sometime, but I still don't think you pass epsilon_0 at any point. (unless you cheat and invoke a nonspecific "imaginary space")

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

>Is "imaginary space" some sort of blanket term that automatically covers all possible ideas and extensions?

No, it's just a term that repeats the whole process getting to this number more and more and more times, depending on the given number. So, if a common progression follows like a(1)=ω, a(2)=2ω, a(3)=ω2, a(4)=ωω, I don't see why can't something like a(1)=ω, then "imagine this number follows the other progression, so when a(ω) is reached, THAT is actually a(2)" be done. It's not cheating because the number of times a(2) is redefined is preset, and it doesn't just "get +1 higher than yours". Once the real a(ω) is reached=b(1), the "y is actually x" stacks, and then it takes more and more effort to define c(1).

(here, switching to alphabetical examples because they may be more clear.)

>x won't pass the fast-growing hierarchy either, since the fast-growing hierarchy goes arbitrarily far, as far as one cares to define ordinals. I'll take a closer look sometime, but I still don't think you pass epsilon_0 at any point. (unless you cheat and invoke a nonspecific "imaginary space")

The imaginary space is specific and depends on the highest number reached, the number of times x in x needs to be increased depend on the highest number that 1[x] reached, which depends on the highest number that 1[x-1] reached, and 1[n] depends on the highest value 1n reached, etc.

There's no magic or "increase the number of times the whole thing is repeated until you pass this value", but "if you increase the times the whole thing is repeated, you should pass this value" is what is happening. That this number is able to reach ω at some point means it should be able to reach any arbitrary high value of any system, and I just need to see when, and how, to give a precise definition of the biggest number.

Now, that you say x won't pass the fast-growing hierarchy is fine, but once we can agree to some values, if it's possible it eventually passes it, then, it should be able to define any arbitrary high value with precision, which is what this thread was about.

Now, for the sake of discussion, let's say that 1 (which is what you'd expect the limit of x to be) reaches ε0. What do you get when you repeat the whole process once? (say, what would you expect to reach on x of the whole process above, which here would be 1).

That's the answer to the question that defines how the imaginary space should behave, because, all we'll do is repeating that whole process 1 times, for the first step of level 1 to get a new value (x), reach level (x) and get some value (y), reach some 1(y)th symbol number (z), reach 1[(z)] which is (a)=2, reach (a), and that is 1

Now, you stop there, and say "oh, but that 1 is actually the number of times the first step of level 1 needs to repeat the whole thing (including getting to this imaginary 1)", and do it again. And add imaginary space for 1 dimensions (see drawn cube for an example of 3 dimensions), to get the real value of (x), and on and on and on, until the real 1 is reached.

This all has mathematical precision, the same one that uses the 1+1 progression to turn 1 into 100↑100 at the end of level 2 of my graphics. Where was the cheating on that?

The question is, when 1 is finally reached, does it equal ε1? Because we have to agree that 1+1+1+1... for enough times will equal any number that matches any large countable ordinal. So this progression has to match it somewhere, and, knowing exactly what 1 matches will give an answer to that.

But here's an estimation:

1 ≈ ε0
1x ≈ ε0 + x
1n ≈ ε0 + (ω + n)
1n ≈ ε0 + (nω)
1n ≈ ε0 + (ωn)
1n ≈ ε0 + (ωω)
1[x]n ≈ ε0 + (ω^...n...^ω)
...
2 ≈ ε02
2x ≈ ε0x
2n ≈ ε0(ω + n)
...
3 ≈ ε02
3x ≈ ε0x
3n ≈ ε0(ω + n)
...
4 ≈ ε00
n ≈ ε0^...n...0
1 ≈ ε1

I know I said the imaginary space is basically cheating, but not in the way it's just "your number +1", but in the way I don't do anything new at one point, just keep repeating the first basic operation and keep stacking imaginary space to make the number big.

It doesn't cover any possible ideas and extensions, and, huh, EliezerYudkowsky's number will probably be "incomparably" larger when this is done, but still, how large can this concept go?

1 would be ζ0, and 1[x] would give access to φx(0), 1 would reach Γ0, 1 would reach φ(0,0,0,1), 1[x] would equal ψ(ΩΩ^x), etc.

What the imaginary space does in the end, is turning the whole process so far into a function, and then nesting it on itself for number of times that keep growing as the number grows and do it while the nests are being resolved.

phillip1882
Posts: 145
Joined: Fri Jun 14, 2013 9:11 pm UTC
Location: geogia
Contact:

### Re: My number is bigger!

man i love this thread. okay my turn. first let 1+1+1 = 3. then let 3++3 = 3+(3+3).
then let 3+++3 = 3++(3++3).
and so on.
now i'll define my mega function.
let a(n) be the number of concatenated additions, with two 3's on each end.
let b(n) be the number of times a(n) is applied to itself. b(2) = a(a(n))
let c(n) be the number of times b(n) is applied to itself.
once you reach z, also define the space character as z applied n times, the newline as space applied n times, then start up on aa, ab, ac. ignore numbers, adds, equals, parenthesis, and punctuation. apply this function to this post(3).

WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

### Re: My number is bigger!

I think the problem here is that you're not quite grasping how recursive exponents are in ordinals.

You can't just jump from ω*n to ωn as easily as I think that you think that you can. You have go to ω2*n first. And then ω3*n. If you can show specifically why you think that particular jump, between 1 and 1 is going from ω*n to ωn, we might get closer to a mutual understanding.

That is, suppose f(x) = 1x, express g(x) = 1x in terms of this f.

If you're trying to say that you have a function f, such that f(0) is something, then f(1) takes that something and recurses on it, and then f(2) recurses on the process demonstrated by f(0), f(1), and f(3) recurses on the process of f(0), f(1), f(2), and etc... then that function is extraordinarily hard to define so that it actually produces a reasonable number. I've tried, very hard, to find something that concretely does that, and failed. We won't just accept a claim that your function will do that computably without some demonstration that it is, in fact, possible.

And yes, Eliezer's number is in an entirely different category from yours. Actually I think it's at least two entire categories up, maybe three. I had a concept a while back for something that might stomp even that, but it's veering much too close to non-well-defined numbers, so I'm not actually going to suggest it seriously, ever.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

WarDaft wrote:You can't just jump from ω*n to ωn as easily as I think that you think that you can. You have go to ω2*n first. And then ω3*n. If you can show specifically why you think that particular jump, between 1 and 1 is going from ω*n to ωn, we might get closer to a mutual understanding.

Okay, I think I've been repeating myself way too many times in how my number works, because all these intermediate points ωx*n would be happening in the inner steps and levels and layers so that when the x after the brackets increases we're already "in the next hierarchy", and then that is used to increase the next number of steps of the first level, which is now more powerful.

All this process creates functions that, if applied to a low number, would produce this result, because it would go into the process of recursions, and the starting seed isn't as important as the number of recursions it's feed on.

So, whenever a number that matches a power of growth is reached, say, 1 ≈ ω, you have two things, a function that was used, that carries all the recursive functions used on the seed to reach that power, and a number "1", which is a counter that is applied on the first levels on iterations to access bigger numbers, which are used on subsequent levels of iterations to access bigger ones, etc.

So, let's say there's a function f(x)=1. What do you get when you do f(1)? Because, the very first thing that happens is starting back from level 1 of step 1, as in the "+1" progression, but using f(x).

Level 1 Step 1:
f(f(f(...1 times ...f(1)...)))

Step 2 just iterates that.

f(f(f(...f(f(f(...1 times ...f(1)...))) times ...f(1)...)))

And so on and so forth. This continues to step 1, where some new number is reached, and a function that can be used on a seed to turn it into this number. Let's call the number 1L1 (the limit of the first level), and the function g(x).

Now Level 2 applies the whole of level 1 at every step, but for 1L1 steps, and starting with the g(x) power. This causes every step to change the function, so, h(x), i(x), j(x) and so on, are all surpassed on Level 2, up until the 1L1th(x) function. Let's call this f1(x). And the highest number reached, 1L2.

The number will not get very far like this, so Level 3 introduces a layer of "imaginary space", which is just, doing a lot of work just to define what will be step 1. In imaginary space, we just continue doing what we've been doing so far, applying Level 2 which applies Level 1 at every step. This produces f2(x), f3(x), f4(x)... up until f1L2(x), let's call this g1(x), the number reached will not be 1L3, but 1L3i, for imaginary space.

Imaginary Level 4 applies Level 3 at every step, until g1L3i(x) is reached, imaginary Level 5 applies Level 4 until h1L4i(x) is reached, and so on, up until reaching imaginary Level 1L2, which produces 1L2th1L1L2i(x), let's call it f1(x), and the number 1L3S1, because this is, really, the result of the first step of Level 3.

Level 3 Step 2 does the same, but instead of applying imaginary levels at every step once, they are applied n number of times, where n is the highest number reached. So, instead of advancing like f1(x), f2(x), f3(x) at every level, one advances like f1(x), g1(x), h1(x)... up until imaginary level 1L3S1, which produces 1L3S1th1(x) (let's call it 1f(x)) and 1L3S2 (what is really the result of Level 3 Step 2.)

This goes up until real Step 1L2, producing a function that can get the seed directly to this number, and the number 1L3 (the limit of Level 3). So far we've used numbers around the f to denote higher hierarchies, but for this function, we'd need 1L2 places around the f to put the 1 on the last one.

That was with one layer of recursion, Real Level 4 opens 1L3 of such layers (which I've referred to as "a story"), applies Level 3 in each imaginary step as many times as the highest number reached, and requires reaching imaginary Level 1L3 for the first time, Level 1L4i for the second time, 1L4ii for the third time, and up to 1L3 times, producing 1L4iii... 1L3 times ...iii, which gets rid of one of the imaginary layers, and repeats the whole process with higher numbers and functions, until there's no layers left, and that is, really, what is done at the first step of level 4.

When you reach the real step 1L3 of Level 4, you have real 1L4, and a function.

Level 5 adds an extra dimension, so that, instead of adding 1L4 "buildings" (recursive stories) of imaginary space, it goes and adds as much as 1L4 words for the "steps (word 1) -> level (word 2) -> layer (word 3) -> story (word 4) -> building (word 5) -> ... x (1L4th word)", and requires getting rid of all that 1L4 times to get 1L5S1 (what is really the very first step of Level 5). Step 2 requires as much as 1L5S1 words, etc.

This goes up to real Level 1, producing 1ai (which is imaginary), and 1L1 (the limit of the levels) which goes back at level 1 step 1 with the new values. 1bi, 1ci, etc. are reached in this way, up until the 1L1th symbol, which is what you'd expect 1 to be, but is the real 1a. The distance to the real 1b increases in the same way that level 2 increased, so you need to reach what you'd expect 1 to be 1a times, and for the real 1c, you add a layer of imaginary space. Real 1d adds a story. Real 1e adds as many words as needed. And at the 1ath symbol, you have the real 1.

So when you ask "where's ω2*n, ω3*n, ω4*n and the others?", the answer is imaginary 1's are reached more and more times to cover those, so when the real 1 is finally reached, there's a function as powerful as f(n)=ωn (for the real 1a, 1b, 1c... progression on the way to real 1).

>We won't just accept a claim that your function will do that computably without some demonstration that it is, in fact, possible.

But if only new functions and counters of how many times they're applied are created, why can't it be computable?

Here's pseudocode, first, the seed, which, I guess it's not important but I like using it better than using a +1 function as in the examples, then, code that calls in previous code recursively for the first few levels:

Code: Select all

`Define xkcd=A(64, 64)Define 9(){Get number(x).n=x in binary.a=Count digits in (n)Return b; //b is a number with as many digits as a. So, if a is 1000, b is a number with 1111101000 digits (or a nine followed by 1111100999 nines).}Define Level1.Step1(){Get number(x).for(i=0; i < 9(xkcd); i++) { 9(x); return x;} return x.}Define Level1.Step2(){Get number(x).for(i=0; i < Level1.Step1(x); i++) {Level1.Step1(x); return x;} return x.}Define Level1.Step3(){Get number(x).for(i=0; i < Level1.Step2(x); i++) {Level1.Step2(x); return x;} return x.}Etc...Define Level1.Stepxkcd(){Get number(x).for(i=0; i < Level1.Stepxkcd-1(x); i++) {Level1.Stepxkcd-1(x); return x;} return x.}y=x;Define Level2.Step1(){ for(i=0; i < Level1.Stepxkcd(y); i++) {y=Level1.Step1(y); y=Level1.Step2(y); y=Level1.Step3(y); ... Etc... y=Level1.Stepxkcd(y);}z=y;Define Level2.Step2(){for(i=0; i < Level2.Step1(z); i++) {z=Level1.Step1(z); z=Level1.Step2(z); y=Level1.Step3(z); ... Etc... z=Level2.Step1(z);}a=zDefine Level2.Step3(){for(i=0; i < Level2.Step2(a); i++) {a=Level1.Step1(a); a=Level1.Step2(a); a=Level1.Step3(a); ... Etc... a=Level2.Step2(a);}...Etc...Define Level2.Stepy(){for(i=0; i < Level2.Stepy-1(b); i++) {b=Level1.Step1(b); b=Level1.Step2(b); b=Level1.Step3(b); ... Etc... b=Level2.Stepy-1(b);} //here, a step is added for every number between xkcd and x, and x and y.c=b;Define Level3.Step1i()           {for(i=0; i < Level2.Stepy(c); i++){ for(i=0; i < Level2.Stepy(d); i++){  for(i=0; i < Level2.Stepy(e); i++){   ...       for(i=0; i < Level2.Stepy(Level2.Stepy(c);); i++){       h=run Level1.Step1(Level2.Stepy(c)) to Level2.Stepy(Level2.Stepy(c))}      g=run Level1.Step1(Level2.Stepy(c)-1) to Level2.Stepy(Level2.Stepy(c-1))}     f=run Level1.Step1(Level2.Stepy(c)-2) to Level2.Stepy(Level2.Stepy(c-2))}   ...  run Level1.Step1(e) to Level2.Stepy(Level2.Stepy(e))} d=e; run Level1.Step1(d) to Level2.Stepy(Level2.Stepy(d))} c=d;run Level1.Step1(c) to Level2.Stepy(Level2.Stepy(c))}j=h;}Define Level3.Step2i()           {for(i=0; i < Level3.Step1i(j); i++){ for(i=0; i < Level3.Step1i(k); i++){  for(i=0; i < Level3.Step1i(l); i++){   ...       for(i=0; i < Level3.Step1i(Level3.Step1i(j);); i++){       o=run Level1.Step1(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...))) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...)))}      n=run Level1.Step1(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...)))-1) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...)))-1)}m=run Level1.Step1(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...)))-2) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(... Level3.Step1i(j) times) ...(j)... Level3.Step1i(j) times ...)))-2)}   ...  run Level1.Step1(l) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(l))))))))} k=l; run Level1.Step1(k) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(k))))))} j=k;run Level1.Step1(j) to Level3.Step1i(Level3.Step1i(Level3.Step1i(Level3.Step1i(j))))}p=o;}`

Soon, the code gets really hard to write (heh, for Level3.Step3i I think I'd need to use for loops inside of the functions to know how many times it needs to be recursive before outputting a number), but all programs call a previous program that halts, so they all should eventually halt.

>And yes, Eliezer's number is in an entirely different category from yours. Actually I think it's at least two entire categories up, maybe three.

Well, first, it's not millions of categories ahead of mine so that gives some hope. Second, I call EliezerYudkowsky's number "fuzzy", everyone knows it's the largest number on the thread, but not quite exactly how big, and comparisons with it are hard (as in "your x is < EliezerYudkowsky's number. End of story", which doesn't sound much different from "EliezerYudkowsky number is yours +1").

So, at least, I'd like to attempt to beat the last "tangible" number posted on the thread, the last one that could be compared with other numbers. But first, I have to get my number out of fuzzy territory, which at least, it seems to be growing at a nice pace that is hard to explain (at some point I claimed I reached ζ0 as soon as hitting 3, further revisions made me move that up to 1, but I just had to add an extra bracket to reach that - if the non-fuzzy version reaches ζ0 at a blue one with 8 brackets, I'd consider that a success, since, once the growth is established, I should be able to reach a precise value with a x number in a n bracket.)

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Anyway, I'd like to thank WarDaft and Deedlit for all the patience they've had with me. My only regret was not finding about this thread sooner because by the time I joined my number ideas were mostly irrelevant (the first thing I tried was seeing if I could beat the numbers back from 20 pages ago or something.)

However, I just had another idea yesterday, and it's that, people are referencing my number as just "1" instead of as 1, and the question is, why does the number need to still be blue after starting adding brackets? And the answer is: it doesn't!

However, it allows me to double the rate at which my number increases. And "doubling the rate" may sound insignificant, but it isn't.

The idea here is to, instead of increasing the number to the next state whenever a previous state reaches its limit, that state can just turn blue! And then do what the next state was going to do, just to finally increase it. So whatever value I reached in the next landmark, I can do it in half the effort, but at the deepest level, which then propagates the efficiency significantly.

Because, I can also do it in steps, i.e. Instead of having to reach Level 2 to apply Level 1 at every step, I can reach the steps of Level 1, which do that. Level 2 can start adding imaginary space already, the steps of Level 2 can start adding n layers of space, instead of having to wait for Level 4. Level 3 can start adding n-dimensions of imaginary space.

What this means is that the value that x[...]ai previously reached can be reached halfway through the levels! But wait, it's not really "halfway" through the levels, it can be 1/4 through the levels, because, after the normal levels are done, I can add levels. Level 1 already does all the stuff that was done when reaching x[...]a for real, so, when the levels are done, and x[...]ai is really reached, it already is as high as x[+1...] used to be (so, if I had some value increase from 1 to 1, it can now happen as soon as 1a), this is because the steps necessary and levels necessary are already increasing in the next hierarchy.

But wait, what about imaginary space? If at any point imaginary space is needed, and done I ask for imaginary space instead of increasing the step, then, what used to be x[...]ai can be reached 1/8 on the way of the levels, so, the real x[...]a can reach the power of x+1[...] (1 to 2 can now happen as soon as 1a).

Then, after the real x[...]a, x[...]b, x[...]c progression is done, instead of going to x[+1...], I go for another x[...]a, x[...]b, x[...]c progression. So the limit of that progression is what the limit of the first bracket used to be.

I do the same with the brackets and the numbers inside of the brackets, so, 1 is a real value, 1x is increased, reaches 1x, its limit produces 1[n+1], but when the limit of 1[x] is reached, goes to 1 instead of n+1, which is produced at the limit of 1[x].

The limit of x is not x[n+1], but 1. 1 is now a distinct entity from 1, and a much larger one. By how much?

1 used to be, for the sake of discussion, ε0, now, with all state changes doubling their power at each step internally, 4 should be enough to equal that value.

The previous estimations would move down to inner levels like this:

4 ≈ ε0
4 Level x ≈ ε0 + x
4ni ≈ ε0 + (ω + n)
4n ≈ ε0 + (nω)
4n ≈ ε0 + (ωn)
4 ≈ ε0 + (ωω)
4 Level n ≈ ε0 + (ω^...n...^ω)
...
4 ≈ 2ε0
4 Level x ≈ xε0
4ni ≈ ε0(ω + n)
...
4 ≈ ε02
4 Level x ≈ ε0x
4ni ≈ ε0(ω + n)
...
4 ≈ ε0^ε0
4[n] ≈ ε0^...n...^ε0
5 ≈ ε1

1 would be ζ0, x would give access to φx(0), 1 would reach Γ0, 4 would reach φ(0,0,0,1), x would equal ψ(ΩΩ^x), etc.

Deedlit
Posts: 91
Joined: Sun Mar 08, 2009 2:55 am UTC

### Re: My number is bigger!

Vytron wrote:>Is "imaginary space" some sort of blanket term that automatically covers all possible ideas and extensions?

No, it's just a term that repeats the whole process getting to this number more and more and more times, depending on the given number. So, if a common progression follows like a(1)=ω, a(2)=2ω, a(3)=ω2, a(4)=ωω, I don't see why can't something like a(1)=ω, then "imagine this number follows the other progression, so when a(ω) is reached, THAT is actually a(2)" be done. It's not cheating because the number of times a(2) is redefined is preset, and it doesn't just "get +1 higher than yours". Once the real a(ω) is reached=b(1), the "y is actually x" stacks, and then it takes more and more effort to define c(1).

But here's the thing - no fixed system can diagonalize out of all possible progressions. As long as your system is a fixed, well-defined system, then there is some function that represents the limit of your system, or some infinite sequence of functions a_i(n) that represent the limit, and in the latter case you can define f(n) = max_{i,j <= n} {a_i(j)}, and it will surpass all the a_i(n). If you mean to say that "imaginary space" will automatically surpass that limit, no matter what the limit is, then you are trying to co-opt all possible extensions, and that's cheating.

Note that I don't mean to say that you can't have an infinite sequence of infinite sequences, or an infinite sequence of infinite sequences of infinite sequences; in fact, that's represented by omega^2 and omega^3 in the fast-growing hierarchy. Or you can have an infinite chain of "infinite sequences of infinite sequences of..."; that's just omega^omega. But there's no mechanical process that will take you through all ordinals; any mechanical process will fit in a certain box, and you have to think outside to box to go beyond and get larger ordinals, or stronger functions.

So, if "imaginary space" is a well-defined system that can be described in a finite number of words, then it fits in a certain box and you can go beyond it with a new extension. If "imaginary space" covers all possible extensions, then it's cheating.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

"Imaginary space" doesn't surpass all limits, it just reaches the limit of the function many many many times before the next number is reached, making the next number much bigger than just reaching the limit of the function.

I used pictures, please tell me what is undefined on the way imaginary space works. Without the improvement of "doubling the power of the inner levels", with the function "n+1", Level 1's limit returns f(n)=n*10, Level 2's limit returns f(n)=(n*10)↑((n*10)-1)((n*10)-2)((n*10)-3)... Level 3 Step 1's limit returns what, if you followed this progression, would you expect Level xkcd's limit to return (Where xkcd is 9(9(9)... 9(xkcd) times ...(9(xkcd)))), and 9(n) is a function that used the code shown in the first line of the code of my other post.)

So, all imaginary space is doing is "jumping to the limit of some x(n) function because that function would eventually be reached if you continue increasing the powers of the functions in this way, up until this precise point in the future - call that power the real power of the function at the present time", but it doesn't cheat by saying "wherever there's a limit, use as many recursions as necessary to pass that limit".

The problem I'm having is, that I don't think there's anything similar to imaginary space in mathematics, and it has proven incredibly difficult to explain. Let me try a different approach, with sets.

There's a function f(n)=n*2

There are levels and steps that apply this function repeatedly.

Level 1 has the set that used f(n) at every step, this set is: [2, 4, 8, 16, 32...], we're going to stop ASAP so that the number doesn't get too big too soon. Let's say, that the first member returns a number which is used on the function, this number is 4 (f(2)=2*2). Now, this repeats 4 times, and the result is the member that tells you which member to look at in the set. This is what Level 1 outputs.

[2, 4, 8, 16, 32...] (4 times = 16)

[1:2, 2:4, 3:8, 4:16, 5:32, 6:64, 7:128, 8:256, 9:512, 10:1024, 11:2048, 12:4096, 13:8192, 14:16384, 15:32768, 16:65536]

So, 65536 is the limit of level 1.

Now, Level 2 takes a look at that, and redefines the function to return that limit. The seed was 2, so the function must return f(2)=65536. This means the new power is f(n)=n16.

This creates a new set [216, (216)16, ((216)16)16, (((216)16)16)16...]

Or an exponentiation set 2^[16, 256, 4096, 65536...]. So, what we do, is doing what was done at level 1 but shifting to the new values. We pick the 65536th member of this set, and put it on the function, then, we get a number that says which member to look at, to know which value is returned by Level 2 Step 1.

The 65536th member of the exponentiation set above is:

2^(1665536), so, the 2^(1665536)th member is 2^(16^(2^(1665536))), this is the number Level 2 Step 1 outputs.

And that's it, whenever I say "Level 1 is applied at every level", all I mean is that what was done at level 1 is done now at every step, but with higher values, so, for Level 2 Step 2, the function becomes f(n)=n^(16^(n^(1665536))), a set is built that applies it at every step, the 2^(16^(2^(1665536)))th member is found, and that member is used to find a member on the set, who is the limit of Level 2 Step 2.

Is all that clear? Is it well defined? Is it computable?

Because, it goes on to Level 2 Step 65536, it'll have some limit, output a function, and output a value, this is used for Level 3.

Finally we get to imaginary space: [Imaginary Space]There's a number which was the limit of Level 2, let's call it L1, what imaginary space does is creating a meta set, this meta set contains what would happen if Level 2 was applied at every step (in the same way that Level 1 was applied at every step of Level 2) indefinite times, so, it'll have:

[Level 3 Step 1, Level 3 Step 2, Level 3 Step 3...]

You find the L1th member of that set. This is, if the progressions that have been seen continued until Level 3 Step L1, we'd reach some value, let's call it L2, what would be understood as the limit of Level 3, used to power up Level 4, with new numbers, new functions and new sets. There exists a Meta set that contains this meta set, and looks like this:

[Limit of Level 3, Limit of Level 4, Limit of Level 5...]

What is the limit of Level L2? Well, whatever it is, is the value that is really the value that Level 3 Step 1 outputs. [/Imaginary Space]

And I'll stop there. Previously I was hopelessly trying to explain how Levels beyond 3 worked, but all they are doing is stacking [Imaginary Space] these brackets [/Imaginary Space] more and more and more times, so you keep reaching new functions, defining new numbers, and new sets, and reaching new steps and levels within imaginary space, to define the actual values that are used at every real step.

The concept here is, that once you have a function that grows at some speed, you use it to speed itself up like this in the above levels.

Limit of Level 1: n + ω

Level 2 Step 1: n + ω + 1
Level 2 Step 2: n + ω + 2
Level 2 Step 3: n + ω + 3

Limit of Level 2: n + 2ω

[Imaginary Space]

Level 3 Step 1 contains: {
Level 2 Step 1: n + 2ω + 1
Level 2 Step 2: n + 2ω + 2
Level 2 Step 3: n + 2ω + 3}

Level 3 Step 2 contains: {
Level 2 Step 1: n + 3ω + 1
Level 2 Step 2: n + 3ω + 2
Level 2 Step 3: n + 3ω + 3}

Level 3 Step 3 contains: {
Level 2 Step 1: n + 4ω + 1
Level 2 Step 2: n + 4ω + 2
Level 2 Step 3: n + 4ω + 3}

...

Limit of Level 3: n + ω*ω

Level 4 Step 1 contains: {
Level 3 Step 1 contains: {
Level 2 Step 1: n + ω*ω + 1
Level 2 Step 2: n + ω*ω + 2
Level 2 Step 3: n + ω*ω + 3}

Level 3 Step 2 contains: {
Level 2 Step 1: n + ω*ω + ω + 1
Level 2 Step 2: n + ω*ω + ω + 2
Level 2 Step 3: n + ω*ω + ω + 3}

Level 3 Step 3 contains: {
Level 2 Step 1: n + ω*ω + 2ω + 1
Level 2 Step 2: n + ω*ω + 2ω + 2
Level 2 Step 3: n + ω*ω + 2ω + 3}}

...

Level 4 Step 2 contains: {
Level 3 Step 1 contains: {
Level 2 Step 1: n + ω3 + 1
Level 2 Step 2: n + ω3 + 2
Level 2 Step 3: n + ω3 + 3}

Level 3 Step 2 contains: {
Level 2 Step 1: n + ω3 + ω + 1
Level 2 Step 2: n + ω3 + ω + 2
Level 2 Step 3: n + ω3 + ω + 3}

Level 3 Step 3 contains: {
Level 2 Step 1: n + ω3 + 2ω + 1
Level 2 Step 2: n + ω3 + 2ω + 2
Level 2 Step 3: n + ω3 + 2ω + 3}}

Limit of Level 4: n + ωω

Level 5 Step 1 contains: {
Level 4 Step 1 contains: {
Level 3 Step 1 contains: {
Level 2 Step 1 contains: {
...}}}}

Go up to the Limit of Level n + ω*ω
[/Imaginary Space]

That is really Level 3 Step 1

Deedlit
Posts: 91
Joined: Sun Mar 08, 2009 2:55 am UTC

### Re: My number is bigger!

Just to clarify: I didn't say "imaginary space" wasn't well-defined, I said that, if it was well-defined, it has a limit and can be extended. It can't surpass all growth rates.

Now, Level 2 takes a look at that, and redefines the function to return that limit. The seed was 2, so the function must return f(2)=65536. This means the new power is f(n)=n16.

The problem I have is that it looks like you are starting from f(2) = 65536, and concluding that f(n) = n16. But there are lots of functions such that f(2) = 65536! So you need to be clearer on how you derive f(n) = n16; f(2) = 65536 is not enough.

The concept here is, that once you have a function that grows at some speed, you use it to speed itself up like this in the above levels.

Well, that's how the fast-growing hierarchy works! Once you reach a function f(n), you can bootstrap the function to get f(f(...f(n)...)) with n f's, or f(n) f's. Or, you can define f^f^f^f...f^(n)...(n)(n)(n) as the next step. Even if your version of "level" is much stronger than the above rules, it could be that the nth level is F_{omega^n} in the fast growing hierarchy, or F_{omega^^n}. I don't think you get that each level gets you to the next ordinal notation, as you have described. But I need to understand how you are forming the newer functions from the old ones.

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Deedlit wrote:The problem I have is that it looks like you are starting from f(2) = 65536, and concluding that f(n) = n16. But there are lots of functions such that f(2) = 65536! So you need to be clearer on how you derive f(n) = n16; f(2) = 65536 is not enough.

Well, the new function just iterates the first function until the power of the new function is achieved. So, with the starting function being n*2, new recursions just add n*2*2*2..., so, the new f(n) happens to be f(f(f( ...16 f's...(f(f(n)) (because f(f(f( ...16 f's...(f(f(2))=65536). The key element is that when a function is redefined, so is the old function's values, so that we have n*n*n... going on here, and this was the reason the starting seed was the same that was used on the first function (2) and not 1.

Extra levels just become recursive in the same way.

I used pseudocode last time to prove my number was computable, the way the new function gets redefined is creating a loop to count how many times the old function needs to loop so that the seed becomes the new value, then, you define a function that runs the whole program up until now that many times, and redefine the old function with new values.

The result here would be:

2*2 n times = 65536

n=16

x*x n times = y

New function = xn

Deedlit wrote:
The concept here is, that once you have a function that grows at some speed, you use it to speed itself up like this in the above levels.

Well, that's how the fast-growing hierarchy works!

At what point? Because if you say I match the fast-growing hierarchy's growth rate at every real level, then, I should pass the fast-growing hierarchy's growth at Level 4 Step 1, because it already computes up the rest of the levels n times at every step (what I call a story of layers of imaginary space), I think somewhere here my number gets fuzzy again, because, the idea is not to show that the number grows in some manner, but that this manner is passed on the next Level.

The key here, is that, at the point n + ω is reached, the highest value the limits of the levels is going to get is ω. However, when ε0 is reached, the limit of each level isn't going to stop until Step ε0.

Hopefully it doesn't turn out I broke my own number somewhere (i.e. if some layer of imaginary space at some imaginary step of Level 3 correlates to some value of the fast-growing hierarchy, that'd mean Level 4 Step 1 has some value that is beyond all those, infinite, and invalid.)

Deedlit wrote:Even if your version of "level" is much stronger than the above rules, it could be that the nth level is F_{omega^n} in the fast growing hierarchy, or F_{omega^^n}. I don't think you get that each level gets you to the next ordinal notation, as you have described.

Wait, really? If this is true then I've made great progress in showing how the number works if we can finally get comparisons from precise values of the fast growing hierarchy. Because, at the end of the levels we just reach xai (where x is undefined as of yet, since I don't quite know at what point the limit of Level 1 reached the n + ω power), and restart the whole levels up with the highest function found up to xai real levels. I figure that if the levels only go up to F_{omega^n}, the levels after xa would have to reach F_{omega^^n}, but then, considering x+1 is reached many many times within imaginary space, can I ever have xnth symbol equal F_{omega^^^...n times^^^n}?

Thanks again for taking a look at my number, I think at some point we should be able to take a look back at 1 and see exactly how it compares to other numbers on the thread, I still have the crazy idea that once well defined, from some k number of brackets after the blue one I should be able to get the 3rd or 4th biggest number on the thread, or something.

Deedlit
Posts: 91
Joined: Sun Mar 08, 2009 2:55 am UTC

### Re: My number is bigger!

Vytron wrote:
Deedlit wrote:The problem I have is that it looks like you are starting from f(2) = 65536, and concluding that f(n) = n16. But there are lots of functions such that f(2) = 65536! So you need to be clearer on how you derive f(n) = n16; f(2) = 65536 is not enough.

Well, the new function just iterates the first function until the power of the new function is achieved. So, with the starting function being n*2, new recursions just add n*2*2*2..., so, the new f(n) happens to be f(f(f( ...16 f's...(f(f(n)) (because f(f(f( ...16 f's...(f(f(2))=65536). The key element is that when a function is redefined, so is the old function's values, so that we have n*n*n... going on here, and this was the reason the starting seed was the same that was used on the first function (2) and not 1.

I'm afraid I'm not following. The first sentence makes perfect sense - we iterate f(n) = 2n a certain number of times. fi(n) = 2in, so if we want fi(2) = 65536, we want i = 15, and we have g(n) = 215n. Okay, fine. But you lose me when you say you "redefine the old function's values so we have n*n*n...." How would that work for a general function?

At what point? Because if you say I match the fast-growing hierarchy's growth rate at every real level, then, I should pass the fast-growing hierarchy's growth at Level 4 Step 1, because it already computes up the rest of the levels n times at every step (what I call a story of layers of imaginary space), I think somewhere here my number gets fuzzy again, because, the idea is not to show that the number grows in some manner, but that this manner is passed on the next Level.

Like I said before, you can't pass the fast-growing hierarchy's growth, since it goes "all the way up", as far as you define ordinals. You seem to be thinking that, since your system bootstraps itself at every level, it must surpass every level of the fast-growing hierarchy, but the fast-growing hierachy does the same thing, so it's not obvious to me that your system passes epsilon_0, for instance, since 1... with n 1's could have level omega^^n, or something like that.

The key here, is that, at the point n + ω is reached, the highest value the limits of the levels is going to get is ω. However, when ε0 is reached, the limit of each level isn't going to stop until Step ε0.

Don't the steps go up to a finite number? If you want to base them on transfinite ordinals you have to explain how you do that.

Wait, really? If this is true then I've made great progress in showing how the number works if we can finally get comparisons from precise values of the fast growing hierarchy. Because, at the end of the levels we just reach xai (where x is undefined as of yet, since I don't quite know at what point the limit of Level 1 reached the n + ω power), and restart the whole levels up with the highest function found up to xai real levels. I figure that if the levels only go up to F_{omega^n}, the levels after xa would have to reach F_{omega^^n}, but then, considering x+1 is reached many many times within imaginary space, can I ever have xnth symbol equal F_{omega^^^...n times^^^n}?

Well, I didn't mean to suggest that I had established any comparisons yet - I need to understand your notation first!

Vytron
Posts: 432
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

### Re: My number is bigger!

Deedlit wrote:I'm afraid I'm not following. The first sentence makes perfect sense - we iterate f(n) = 2n a certain number of times. fi(n) = 2in, so if we want fi(2) = 65536, we want i = 15, and we have g(n) = 215n. Okay, fine. But you lose me when you say you "redefine the old function's values so we have n*n*n...." How would that work for a general function?

I'll try with pseudo code again.

Int seed=2; int x=seed; int step=0; int actualstep=0;

Int func() {do=seed; x=do*seed}

main y(){

for (iters=0; iters < func(do*seed); iters++) {func(x); if (step>0) {step+1; if(step==actualstep) goto exit;}}}

actualstep=iters;

step+1;

Redefine func() {func(); main y();}

main y(x);

exit;

What this does is starting at 2*2, until reaching 65536 (the for loop just gets the x multiplied by 2 4*4 times), then, the times this needed to be done become the new seed, and this whole process becomes the new function, so, whenever a number enters the loop again, it'll be multiplying by itself that many times, because, func() just added main y(), at every loop the function will be calling itself.

The number of times this is done depends upon step, if it's >1 it means the function has been redefined, so it starts to increase until it reaches actualstep, which mimics the number of times the function had to be used. So we go from 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2, to a function main y(n) that returns n*n*n*n*n*n*n*n*n*n*n*n*n*n*n*n, or n16.

Deedlit wrote:Like I said before, you can't pass the fast-growing hierarchy's growth, since it goes "all the way up", as far as you define ordinals.

What I meant by "passing its growth" is, that the fast-growing hierarchy grows in some manner and has some landmarks. You can tell that when you reach some ordinal, there's some distance to get to the next one, and there's several "ordinal lines" that you can build that show the ordered set of ordinals. What I'm trying to do, is first, equaling its weakest line, so that, I have some function that equals that growth, and then, instead of keeping growing like that, taking a shortcut, via imaginary space, to the next landmark. These shortcuts keep piling up, so, whenever it's found that if I repeated the same step n times I'd reach some landmark, then I can open this portal and redefine the step so that it calls itself n times, so I can reach the next landmark in one step.

If that's possible, and I believe it is, then, passing its growth just means that if you drew the fast-growing hierarchy as a diagonal in a square from south-west to north-east, and a line showing the blue number progression, then my number will curve and "pass its growth" by the time the blue line is above it, like this: Because while the fast-growing hierarchy would just keep diagonalizing over its hierarchies, I can fit such diagonalizations within imaginary space.

You seem to be thinking that, since your system bootstraps itself at every level, it must surpass every level of the fast-growing hierarchy, but the fast-growing hierachy does the same thing, so it's not obvious to me that your system passes epsilon_0, for instance, since 1... with n 1's could have level omega^^n, or something like that.

When in a previous post you imply that xb (which means a blue number without brackets, on its second real symbol) could be F_omega^^n, and in the next you say 1...n 1's... could be F_omega^^n, then it makes me lose all the confidence that was gained in the entire thread about my number being understood. It's like you see what's the maximum symbol I can use to describe my number and just say "yeah, that's definitively < F_epsilon_0"...

Don't the steps go up to a finite number? If you want to base them on transfinite ordinals you have to explain how you do that.

What I meant by that is that, whenever I reach some power, I have some function and some big value that can be feed to the function n times. At the point I reach n + ω, I have some function that can be used recursively to increase ω by that much because it has the power of all the recursions leading to it. By the time I reach ε0, the function has gotten stronger by that many orders of magnitude, so the finite number that the steps need to reach to reach the limit of the levels would be strong enough to turn n + ω into ε0 in a single level by their inbuilt number of recursions.

tomtom2357
Posts: 563
Joined: Tue Jul 27, 2010 8:48 am UTC

### Re: My number is bigger!

I think that what you're trying to say is that, given that at one step, you have a function that is at level F_w on the fast growing hierarchy, then you can create a new function transformation that can take F_w to F_2w using this "imaginary space". I think you can do that, but what Deedlit is trying to say is that, no matter how powerful your function(s) are, there a some function on the fast growing hierarchy that it will never pass.
I have discovered a truly marvelous proof of this, which this margin is too narrow to contain.

Return to “Forum Games”

### Who is online

Users browsing this forum: Google [Bot] and 41 guests