xkcd

by **Quizatzhaderac** » Mon Aug 06, 2012 8:33 pm UTC

Deedlit wrote:It is "infinite" because (1,0) > (0,n) for any natural number n

Okay, I think I finally understand what you were doing. You're not computing Aleph-0 at all, you're taking it as a basic entity, isomorphic to another dimension. Looking back at your previous post "I take it you have no objections to using ordered pairs of natural numbers? Then you should have no objection to using the ordinal omega^2, which is exactly the same thing!" No serious objection, though it seems (to me) sloppy to conflate trees and numbers like that. Though seeing as you're drawing on existing work, I can hardly blame you.

What I mean is that, for any natural number n, we can call the function H_n or I_n and it will be defined. Are you saying that if one is concerned with computation, it is not normal to consider the set of functions H_n defined? Sure there is a cost of O(f(n)) to compute the function - that just confirms that the function is in fact defined for all n.

You have the first pass definitions of all of H_n and I_n (by virtue of all H_n sharing the same first pass definition), but not the second pass definitions. Or to rephrase, you effectively have two functions metaH(n) and metaL(n) that return H_n and L_n. You have the full definitions of metaH and metaL, but you don't have the second pass of H_i until you execute metaH on i, and so on with metaL and l_n. So in addition computing the result of H_n(X), one must compute the function H_n itself, so in the strictest sense you only "have" four functions so far (two meta functions and two base case functions). I'd say for pure math it's perfectly fine to call H_n and I_n "defined" (first past definitions and computable, if not computed, second pass definitions).

C(x,y,z) is a finite set whenever y and z are finite, which they always are when I call m(x,y,z). So we simply take the largest element of a finite set.

That's fine then.

No, it's not begging the question at all. I don't mean sticking in aleph0 into your function; I mean that your function is an ordered function on triplets of natural numbers, which is the same thing as omega^3.

By begging the question, I meant that you were defining transfinites as ordered tuples. When you originally said "...of the form omega*a + b, which we can think of as simply an ordered pair (a,b)" you seemed to be substituting the referent for the symbol; though now it seems (in context) omega represents "(1,0)", not the other way around.

Is the latter H function computable or not?

Yes, but the use of omega can be removed entirely. Which goes back to my original question "...that number is computable? You reference many uncomputable "numbers" and sets." It now seems that your number can be defined without dragging in the concept of infinity, although not preferable to one familiar with the same work as you.

Thank you for your explanations Deedlit.

by **orangedragonfire** » Tue Aug 07, 2012 12:06 pm UTC

Deedlit wrote:You then define f with a second sequence of natural numbers, but your definitions don't quite work. You start with two cases, k =1 and otherwise, then add two more cases even though "otherwise" should take care of everything.

The two first cases were about how to solve the x-bracket, while the rest is about the y-bracket.

Deedlit wrote:You don't define what "y" is.

It's the size of the y-bracket. Not sure why I forgot to mention that...

Deedlit wrote:And, in your third case, you say:

U_{0, 0, ... , 0, y_{l}, y_{l+1}, ...}(f) = G(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

f\{0, 0, ... , 0, y_{l}, y_{l+1}, ...\}_{[x_i]} = U_{[0, 0, ... , 0, y_{l}, y_{l+1}, ...]}(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

you convert from f to f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]} twice, which I'm pretty sure is a mistake.

I think that is correct. In each of those steps, I reduce the size of the first non-zero element by 1, so it should terminate.

Edited definition:

(lists are [x_i] and [y_j] of sizes x and y. k is the smallest non-zero index i x-list and l in y-list)

for k = 1 and x > 0:

f\{[y_j]\}_{x_1, x_2, x_3, ...} = U(f\{[y_j]\}_{x_1-1, x_2, x_3...})

for k > 1 and x >0:

f\{[y_j]\}_{0, 0, ..., 0, x_k, x_{k+1}, x_{k+2}, ...} = G(f\{[y_j]\}_{n, n, ..., n, x_k-1, x_{k+1}, x_{k+2}, ...})

for x = 0, y_l > 1 or y = 1:

U_{0, 0, ... , 0, y_{l}, y_{l+1}, ...}(f) = G(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

f\{0, 0, ... , 0, y_{l}, y_{l+1}, ...\}_{[x_i]} = U_{[0, 0, ... , 0, y_{l}, y_{l+1}, ...]}(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

for x = 0, y > 1 and y_l = 1:

U_{0, 0, ... , 0, 1, y_{l+1}, ...}(f) = G(f\{n, n, ... , n, 0, y_{l+1}, ...\}_{[n]})

f\{0, 0, ... , 0, 1, y_{l+1}, ...\} = U_{[0, 0, ... , 0, y_{l}, y_{l+1}, ...]}(f\{n, n, ... , n, 0, y_{l+1}, ...\}_{[n]})

by **Deedlit** » Wed Aug 08, 2012 7:19 am UTC

orangedragonfire wrote:
Deedlit wrote:And, in your third case, you say:

U_{0, 0, ... , 0, y_{l}, y_{l+1}, ...}(f) = G(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

f\{0, 0, ... , 0, y_{l}, y_{l+1}, ...\}_{[x_i]} = U_{[0, 0, ... , 0, y_{l}, y_{l+1}, ...]}(f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]})

you convert from f to f\{0, 0, ... , 0, y_{l}-1, y_{l+1}, ...\}_{[n]} twice, which I'm pretty sure is a mistake.

I think that is correct. In each of those steps, I reduce the size of the first non-zero element by 1, so it should terminate.

Your definition doesn't work when y_l = 1. First you reduce y_l to 0, then you reduce it to -1. I'm pretty sure you don't mean to reduce the same element twice.

for x = 0, y > 1 and y_l = 1:
U_{0, 0, ... , 0, 1, y_{l+1}, ...}(f) = G(f\{n, n, ... , n, 0, y_{l+1}, ...\}_{[n]})

f\{0, 0, ... , 0, 1, y_{l+1}, ...\} = U_{[0, 0, ... , 0, y_{l}, y_{l+1}, ...]}(f\{n, n, ... , n, 0, y_{l+1}, ...\}_{[n]})

This seems very confused to me. you define U_{0, 0, ... , 0, 1, y_{l+1}, ...}(f) when y > 1 and y_l = 1, but then your second line you apply U_{0, 0, ... , 0, 1, y_{l+1}, ...} to f where you hardcode n into the first argument, so y_l = n, which is not necessarily 1. I'm pretty sure you're not meaning what you are saying; your abstractions of U and G are throwing you off.

by **Deedlit** » Wed Aug 08, 2012 7:56 am UTC

Quizatzhaderac wrote:
Deedlit wrote:It is "infinite" because (1,0) > (0,n) for any natural number n
Okay, I think I finally understand what you were doing. You're not computing Aleph-0 at all, you're taking it as a basic entity, isomorphic to another dimension. Looking back at your previous post "I take it you have no objections to using ordered pairs of natural numbers? Then you should have no objection to using the ordinal omega^2, which is exactly the same thing!" No serious objection, though it seems (to me) sloppy to conflate trees and numbers like that. Though seeing as you're drawing on existing work, I can hardly blame you.

Yes, we do not "compute" any of the ordinals in the manner you describe. I'm not sure what you mean by "conflate trees and numbers". If you mean my identification of omega^2 with ordered pairs, my point was that they are equivalent structures, even if you choose to regard them as separate entities. One may as well regard ordered pairs in parentheses (a,b) as different from ordered pairs [a,b] in brackets. Why bother? Especially when the discussion is of whether a structure is somehow illegal because it brings in the notion of infinity; omega*a + b does not bring in infinity any more into play than (a,b), because they are equivalent structures.

What I mean is that, for any natural number n, we can call the function H_n or I_n and it will be defined. Are you saying that if one is concerned with computation, it is not normal to consider the set of functions H_n defined? Sure there is a cost of O(f(n)) to compute the function - that just confirms that the function is in fact defined for all n.

You have the first pass definitions of all of H_n and I_n (by virtue of all H_n sharing the same first pass definition), but not the second pass definitions. Or to rephrase, you effectively have two functions metaH(n) and metaL(n) that return H_n and L_n. You have the full definitions of metaH and metaL, but you don't have the second pass of H_i until you execute metaH on i, and so on with metaL and l_n. So in addition computing the result of H_n(X), one must compute the function H_n itself, so in the strictest sense you only "have" four functions so far (two meta functions and two base case functions). I'd say for pure math it's perfectly fine to call H_n and I_n "defined" (first past definitions and computable, if not computed, second pass definitions).

Eh, all that matters is that for any specific natural numbers n and x, one can compute H_n(x) and I_n(x). You would accept that, right?

No, it's not begging the question at all. I don't mean sticking in aleph0 into your function; I mean that your function is an ordered function on triplets of natural numbers, which is the same thing as omega^3.
By begging the question, I meant that you were defining transfinites as ordered tuples. When you originally said "...of the form omega*a + b, which we can think of as simply an ordered pair (a,b)" you seemed to be substituting the referent for the symbol; though now it seems (in context) omega represents "(1,0)", not the other way around.

I don't really think of it like that. Omega does not require (1,0) for its definition, any more than (1,0) requires omega for its definition. But in the isomorphism between omega^n and ordered n-tuples, omega is identified with (1,0), and both are greater than an infinite number of elements, so in that sense both are equally "infinite".

Is the latter H function computable or not?
Yes, but the use of omega can be removed entirely. Which goes back to my original question "...that number is computable? You reference many uncomputable "numbers" and sets." It now seems that your number can be defined without dragging in the concept of infinity, although not preferable to one familiar with the same work as you.

Yes, any mention of ordinals can be removed from the definition. However, my point is that infinity is nonetheless _implicit_ in structures such as ordered tuples (or even the natural numbers, which has order type omega). If you don't regard a structure having an infinite order type an introduction of infinity, then recursive ordinals do not introduce infinity either. So I could not use the word "ordinal" anywhere, and always use "finite tree structures", but the thing is these "finite tree structures" would be exactly equivalent to ordinals. So it's just a matter of calling a spade a spade. Note that to define the larger ordinals that I need, you need to do things like define normal functions on ordinals, and take fixed points. So we really need a definition equivalent to ordinals; I could, say, define "well-ordered finite tree structures", and then take equivalence classes of order types - but that is exactly what an ordinal is! So avoiding ordinals is really just playing with words.

Thank you for your explanations Deedlit.

No sweat! I think we are starting to converge here.

by **Quizatzhaderac** » Mon Aug 13, 2012 6:52 pm UTC

Deedlit wrote:Yes, we do not "compute" any of the ordinals in the manner you describe. I'm not sure what you mean by "conflate trees and numbers". If you mean my identification of omega^2 with ordered pairs, my point was that they are equivalent structures, even if you choose to regard them as separate entities. One may as well regard ordered pairs in parentheses (a,b) as different from ordered pairs [a,b] in brackets. Why bother? Especially when the discussion is of whether a structure is somehow illegal because it brings in the notion of infinity; omega*a + b does not bring in infinity any more into play than (a,b), because they are equivalent structures.

"omega^2", "(a,b)", and "[a,b]" are not equivalent, they are isomorphic for the operations you were performing. Being as that we had difficulty establishing common context, the gap between equivalence and isomorphism is important. When I first saw "Limit cardinal" it was defined with aleph-0, which was in turn defined with |natural numbers|, a computationally impossible operation.

Eh, all that matters is that for any specific natural numbers n and x, one can compute H_n(x) and I_n(x). You would accept that, right?

Yes, I will. However I (personally) wouldn't "say" we have an infinite number of functions (in past or present tense). However we've narrowed that down to an issue of semantics.

I don't really think of it like that. Omega does not require (1,0) for its definition, any more than (1,0) requires omega for its definition. But in the isomorphism between omega^n and ordered n-tuples, omega is identified with (1,0), and both are greater than an infinite number of elements, so in that sense both are equally "infinite".

"Omega = |set of 2-tuples of natural numbers < (1,0) under this ordering|" and "Omega^2 = |set of 2-tuples of natural numbers|" seems to be the connections you're making. This connection can be made validly and consistently, but it's not necessary under the definitions of either; it's a subjective choice. One could also have made the connection "Omega = |set of computer programs more inefficient than windows calculator|", therefore "Omega = windows calculator"

Yes, any mention of ordinals can be removed from the definition. However, my point is that infinity is nonetheless _implicit_ in structures such as ordered tuples (or even the natural numbers, which has order type omega).

Is it implicit up (can be derived from) or implicit down (part of the definition or derivation of a tuple)? If up, several problems are raised: First, indicating which implication you have chosen to equal tuples. Second, does going from A to B do anything needed? Third, if a reader assumes the A -> B connection's inclusion means that it is both relevant and strictly necessary, what might they presume?

So we really need a definition equivalent to ordinals; I could, say, define "well-ordered finite tree structures", and then take equivalence classes of order types - but that is exactly what an ordinal is! So avoiding ordinals is really just playing with words.

I agree we need a definition isomorphic to how you're using ordinals. But I don't see it a necessary to describe the order types, then the equivalence class of said order types, when one could start with modded out definitions.

BTW, I'm working out a rephrasing of your number post for 1) making sure I understand you correctly 2) providing you with examples of why rephrasing without reference to infinity would be beneficial. However I'm stuck on the line "?(y, z) = min{a : z ? C(y,a,?), C(y,a,?) n z ? a}", and having trouble looking up that usage of the question mark.

by **tastelikecoke** » Sun Aug 19, 2012 11:59 am UTC

I'll be ignoring the first few passages with this one:

Let function M(x) be Ackermann function(Ackermann function(Ackermann function(x))).

let D be the number of distinct solutions of the N-queens puzzle in the 9235th dimension, where N is

M(M( M( M( M( M(9325) ) ) ) ) )

Now, let function K(x) be the xth digit of D in decimal.
Let there be D nodes, where every node is connected other nodes such that the edge between Node_a and Node_b is equal to K(b) - K(a).

Let P be the amount of paths from Node₁ to Node_D where the total weight sum of all edges crossed is greater than 0.

let Q is the amount of possible tickets to draw on a P/P lottery (where the you can choose one out of P numbers for P sections of the ticket)

My number is M(M(Q)).

(by the way, I haven't checked what the upper bound of my number would be

)

by **Deedlit** » Tue Sep 11, 2012 3:40 am UTC

Quizatzhaderac wrote:"omega^2", "(a,b)", and "[a,b]" are not equivalent, they are isomorphic for the operations you were performing. Being as that we had difficulty establishing common context, the gap between equivalence and isomorphism is important. When I first saw "Limit cardinal" it was defined with aleph-0, which was in turn defined with |natural numbers|, a computationally impossible operation.

I think you are using isomorphic in the same way I am using equivalent.

Yes, I will. However I (personally) wouldn't "say" we have an infinite number of functions (in past or present tense). However we've narrowed that down to an issue of semantics.

Would you say the function H_0(x) has an infinite domain?

I don't really think of it like that. Omega does not require (1,0) for its definition, any more than (1,0) requires omega for its definition. But in the isomorphism between omega^n and ordered n-tuples, omega is identified with (1,0), and both are greater than an infinite number of elements, so in that sense both are equally "infinite".

"Omega = |set of 2-tuples of natural numbers < (1,0) under this ordering|" and "Omega^2 = |set of 2-tuples of natural numbers|" seems to be the connections you're making. This connection can be made validly and consistently, but it's not necessary under the definitions of either; it's a subjective choice. One could also have made the connection "Omega = |set of computer programs more inefficient than windows calculator|", therefore "Omega = windows calculator"

I'm unsure of your argument here. The structures omega^n and ordered n-tuples are isomorphic, so I'm making the "subjective choice" of pointing that out. So if one structure is acceptable, so is the other. It sounds like you are saying "you don't have to make the argument you are making, so it doesn't necessarily hold." Like if I presented a proof, and you replied, "well, you don't have to follow the steps of that proof, its a subjective choice, so it's not really a proof." Or something like that.

Yes, any mention of ordinals can be removed from the definition. However, my point is that infinity is nonetheless _implicit_ in structures such as ordered tuples (or even the natural numbers, which has order type omega).

Is it implicit up (can be derived from) or implicit down (part of the definition or derivation of a tuple)? If up, several problems are raised: First, indicating which implication you have chosen to equal tuples. Second, does going from A to B do anything needed? Third, if a reader assumes the A -> B connection's inclusion means that it is both relevant and strictly necessary, what might they presume?

I don't really understand this either. Implicit up and implicit down?

So we really need a definition equivalent to ordinals; I could, say, define "well-ordered finite tree structures", and then take equivalence classes of order types - but that is exactly what an ordinal is! So avoiding ordinals is really just playing with words.

I agree we need a definition isomorphic to how you're using ordinals. But I don't see it a necessary to describe the order types, then the equivalence class of said order types, when one could start with modded out definitions.

Sure. But, as you say, we need a definition isomorphic to ordinals.

BTW, I'm working out a rephrasing of your number post for 1) making sure I understand you correctly 2) providing you with examples of why rephrasing without reference to infinity would be beneficial. However I'm stuck on the line "?(y, z) = min{a : z ? C(y,a,?), C(y,a,?) n z ? a}", and having trouble looking up that usage of the question mark.

I think maybe your browser is not showing symbols correctly or something - I don't use question marks at all. The line in question is

ψ(y, z) = min{a : z ∈ C(y,a,ω), C(y,a,ω) ∩ z ⊆ a}

If you can't read that, try:

psi(y, z) = min {a : z is an element of C(y, a, omega) and (C(y, a, omega) intersect z) is a subset of a}

by **Vytron** » Tue Nov 20, 2012 1:34 am UTC

Okay, I've read the entire thread, it took a while. I just thought about a uncompressing function that seems huge in my head. It depends on the first numbers that appear in the number, so that all of them uncompress until you're left with a 1 followed with a lot of zeroes.

So, let's define the levels:

Level 1: On this level, if the first digit is higher than 1, you decrease it, and add a number of copies of this number equivalent to itself+1. If the first number is a one, you move to the next one. If the next one is a 0, you move to the next one. If the next one is a 1, you copy the whole sequence but change it so that each number is decreased by 1, unless it's a 0. Example:

232

First digit is >1, so it decreases, and adds 2 ones to the end.

13211

First digit is a 1, so it doesn't decrease. The next one does, it's a 3, so it decreases, and adds 3 2's at the end.

Spoiler:

So, eventually, the 2's disappear, all the copies add 0's, and it halts.

Of note is that the uncompression doesn't depend on the starting value, but on the highest number of its decimal representation. So 9 uncompresses like this:

Spoiler:

Okay, so that's a very puny, let's look at Level 2.

In level 2, you do the same thing, but the number of copies are multiplied by the previous number in the chain, and the number of steps, so:

Spoiler:

Level 3: As Level 2. But the previous number in the chain is squared, and the number of steps is exponentiated by that number, and this is the number of copies.

Spoiler:

Level 4: As level 3. But the previous number in the chain is exponentiated by itself, and the number of steps builds a tower of exponentations of that length that contain themselves. This is the number of copies.

Spoiler:

Level 5: As level 4, but the previous number in the chain builds a tower of exponentiations of its length that contains itself, and that's the number of up-arrows that the steps use on themselves, and that's the number of copies.

Spoiler:

Level 6:

Spoiler:

And so on, and so forth. Now, I'd like to call the xkcdth step of the level xkcd of the xkcdth step of the level xkcd-1 of the xkcdth step of the level xkcd-2...of the xkcdth step of the level 6 of the xkcdth step of the level 5 of the xkcdth step of the level 4 of the xkcdth step of the level 3 of the xkcdth step of the level 2 of the xkcd'th step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call in the step xkcdth-1 of the level xkcd of the step xkcdth-1 of level xkcd-1 of the xkcdth-1 step of the level xkcd-2 of the xkcdth-1 step of the level xkcd-3 ... of the xkcdth-1 step of the level 2 of the xkcdth-1 step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call in the step xkcdth-2 of the level xkcd of the xkcdth-2 step of the level xkcdth-2 of the level...

...keep talking like this for xkcd more paragraphs...

...provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call the first step of the level xkcd of the first step... (all these are 9's, so I only end adding 9 nines at the end of the number, but remember every nine is very important in the explosion) ... of the first step of the level 2 of the first step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, and I call this number A'.

Now, I'd like to call the A'th step of the level A' of the A'th step of the level A'-1 of the A'th step of the level A'-2...of the A'th step of the level 6 of the A'th step of the level 5 of the A'th step of the level 4 of the A'th step of the (this is a copy of paragraph 1, but instead of using xkcd I'm using a much larger number)

...keep talking like this for A' more paragraphs...

... of the first step of the level 2 of the first step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, and I call this number B'.

Now, I'd like to call the B'th step of the level B' of the B'th step of the level B'-1 of the B'th step (this is a copy of paragraph 4, but instead of using A' I'm using a much larger number)

...keep talking like this for B' more paragraphs...

...added to the number of 9's that a number has, and I call this number C'.

Now, I'd like to call the C'th step...
...keep talking like this for C' more paragraphs...
...and I call this number D'.
...keep talking like this for D' more paragraphs...
...keep talking like this for E' more paragraphs...
...keep talking like this for F' more paragraphs...
.
.
.
keep adding symbols, until you have xkcd symbols, let the last symbol be called A''. Now, repeat this whole process (not just the first part) xkcd times, but now, keep adding symbols until you have A' symbols. Now, repeat this whole process until you have 'B symbols. Now, repeat this whole process until you have 'C symbols...

...Now, repeat this whole process until you have A'' symbols, let the last symbol be called B''.
...Now, repeat this whole process until you have B'' symbols, let the last symbol be called C''.
...Now, repeat this whole process until you have C'' symbols, let the last symbol be called D''.
.
.
.

Keep repeating the repetitions, until you have Z'''(Y'''(X'''...A'(xkcd 's)')... 's)... 's)... 's)... 's. Let this symbol be subscript °, so that that last number is equal to A°. Repeat this process until you run out of subscripts (ie. the number of subscripts is A°), and let this be A_A which continues like A_B ... A_A' ... A_B' ... A_A'' ... A_A°, until A_{Z°(Y°(X°...A°(xkcd °s)°)... °s)... °s)... °s)... °s}, which is equal to B_A. Continue like this, until you run out of letters (ie., the number of symbols is A_A), and this will be equivalent to A[0]. A[A[0]] = B[0]. Continue like this until you run out of symbols (ie. the number of symbols is A[0]), and the last number will be A<0>. A<A<0>>=B<0>.

...

Continue like this until you run out of symbols to encapsulate the 0 (the number of symbols is some finite amount x so that Z<Z<Z<Z...Y<0> times ...Z<Z<Z<0>>...>> < x < ‽ ), and let the highest number of the last symbol be ‽().

Finally, I'll send my number:

V=‽(‽(...x times]...(‽(‽(999)))))

I just hope this humongous mastodon is at least as big as the numbers people were posting back in page 11...

by **Deedlit** » Wed Nov 21, 2012 4:09 am UTC

Vytron wrote:Okay, I've read the entire thread, it took a while. I just thought about a uncompressing function that seems huge in my head. It depends on the first numbers that appear in the number, so that all of them uncompress until you're left with a 1 followed with a lot of zeroes.

So, let's define the levels:

Level 1: On this level, if the first digit is higher than 1, you decrease it, and add a number of copies of this number equivalent to itself+1. If the first number is a one, you move to the next one. If the next one is a 0, you move to the next one. If the next one is a 1, you copy the whole sequence but change it so that each number is decreased by 1, unless it's a 0. Example:

232

First digit is >1, so it decreases, and adds 2 ones to the end.

13211

First digit is a 1, so it doesn't decrease. The next one does, it's a 3, so it decreases, and adds 3 2's at the end.

Spoiler:
1221122
112112211
102112211001001100
10111221100100110011
10011221100100110011000001100000000000001001122110010011001100000110000000000000
10001221100100110011000001100000000000000000011000000000000000000000000000000000
...

So, eventually, the 2's disappear, all the copies add 0's, and it halts.

Okay, let's compute an upper bound to the final number. Let's say you start with n numbers, the largest of which is k. Each number is decreased at most k times, adding at most k numbers to t he sequence, and we do this n times. So we have a maximum of nk². In addition, we copy the whole sequence at most n times, so we get an upper bound of nk²2ⁿ. So we have a sequence of length at most nk²2ⁿ with the largest number k-1. Since n < 2ⁿ and k² <= 2^k for k >= 4, we have nk²2ⁿ <= 2^2n+k. We know apply the same procedure to the longer sequence; by the same argument, we get a sequence of length at most 2^2*2[sup]2n+k + k - 1[/sup] < 2^4*2[sup]2n+k[/sup] = 2^2[sup]2n+k+2[/sup], of which the largest number is k-2. Applying the same argument again, we get 2^{2*2[sup]2[sup]2n+k+2}[/sup]+ k - 3[/sup] < 2^{2[sup]2[sup]2n+k+2} + 2[/sup][/sup] < 2^{2[sup]2[sup]2n+k+3}[/sup][/sup], the largest of which is k-3. After k steps, we get a sequence 1000...000 of length less than 2^2^2^...^(2n+2k), with k 2's in the tower.

At later levels you add f(previous number) numbers at each step, where f keeps increasing as you go up levels. Again, starting from n numbers the largest of which is k, we add less than f(10^n) numbers. For the next step, our whole number is less than 10^f(10^n), so we add less than f(10^f(10^n)). Letting F(n) = f(10^n), we have F²(n) = f(10^f(10^n)). After k steps, we get a number at most 10^F[sup]k(n)[/sup]. If f(n) is about n↑↑↑...↑↑↑n with m ↑'s, then 10^F[sup]k(n)[/sup] will be about n↑↑↑...↑↑↑k with m+1 ↑'s. More generally, if f is at the level of F_alpha in the fast-growing hierarchy, then 10^F[sup]k(n)[/sup] will be at the level F_alpha+1 in the fast-growing hierarchy.

Level 5: As level 4, but the previous number in the chain builds a tower of exponentiations of its length that contains itself, and that's the number of up-arrows that the steps use on themselves, and that's the number of copies.

Spoiler:
Step1:9
Step2:888...((...(x=9^{9)^9)^9)^9)^9)^9)^9)^9)^9)}); 2↑↑↑...(x times)↑↑↑x 8's)...888
Step3:788...(as step 2)...888777...(y=S2^{S2)^S2)...(S2 times)...^S2)};(...((3↑↑↑...(y times)↑↑↑y 7's)...777

Level 6:

Spoiler:
Step1:9
Step2:888...((...(x=9↑↑↑↑↑↑↑↑↑9); 2(↑↑↑...(x times)↑↑↑x↑↑↑...(x times)↑↑↑x↑↑↑...(x times)↑↑↑x[...x times...]x↑↑↑...(x times)↑↑↑x)x 8's)...888
Step3:788...(as step 2)...888777...(y=S2↑↑↑...(S2 times)...↑↑↑S2); 3(↑↑↑...(y times)↑↑↑y↑↑↑...(y times)↑↑↑y↑↑↑...(y times)↑↑↑y[...y times...]y↑↑↑...(y times)↑↑↑x)y 7's)...777

And so on, and so forth.

Well, your levels don't really follow a pattern here. The f(n) in levels 2, 3, and 4 correspond more or less to F₁, F₂, and F₃ in the fast-growing hierarchy. Then, at level 5 you jump to step↑↑↑...↑↑↑x with x ↑'s which is equivalent to F_ω in the fast-growing hierarchy. In level 6, you take y = previous number↑↑↑...↑↑↑ previous number with previous number ↑'s, then take 3↑↑↑...(y times)↑↑↑y↑↑↑...(y times)↑↑↑y↑↑↑...(y times)↑↑↑y[...y times...]y↑↑↑...(y times)↑↑↑x ~ y↑↑↑...↑↑↑y with y+1 ↑'s. This is less than F_ω+1(n), which takes x -> x↑↑↑...↑↑↑x n times, whereas level 6 just takes it twice.

Now, I'd like to call the xkcdth step of the level xkcd of the xkcdth step of the level xkcd-1 of the xkcdth step of the level xkcd-2...of the xkcdth step of the level 6 of the xkcdth step of the level 5 of the xkcdth step of the level 4 of the xkcdth step of the level 3 of the xkcdth step of the level 2 of the xkcd'th step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call in the step xkcdth-1 of the level xkcd of the step xkcdth-1 of level xkcd-1 of the xkcdth-1 step of the level xkcd-2 of the xkcdth-1 step of the level xkcd-3 ... of the xkcdth-1 step of the level 2 of the xkcdth-1 step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call in the step xkcdth-2 of the level xkcd of the xkcdth-2 step of the level xkcdth-2 of the level...

Not sure what you mean by this. Taking the xkcdth step of level xkcd is not as good as taking the final number of level xkcd - that is the whole point of having a terminating process. I don't know what " xkcdth step of the level xkcd of the xkcdth step of the level xkcd-1" means - the xkcd step of the level xkcd is a number, not a function, so you can't apply it to something else.

...keep talking like this for xkcd more paragraphs...

...provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, that I use to call the first step of the level xkcd of the first step... (all these are 9's, so I only end adding 9 nines at the end of the number, but remember every nine is very important in the explosion) ... of the first step of the level 2 of the first step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, and I call this number A'.

Now, I'd like to call the A'th step of the level A' of the A'th step of the level A'-1 of the A'th step of the level A'-2...of the A'th step of the level 6 of the A'th step of the level 5 of the A'th step of the level 4 of the A'th step of the (this is a copy of paragraph 1, but instead of using xkcd I'm using a much larger number)

...keep talking like this for A' more paragraphs...

... of the first step of the level 2 of the first step of level 1, provided all of them are increased until all their digits are 9's at the time that number is called, and this number is added to the number of 9's that a number has, and I call this number B'.

Now, I'd like to call the B'th step of the level B' of the B'th step of the level B'-1 of the B'th step (this is a copy of paragraph 4, but instead of using A' I'm using a much larger number)

...keep talking like this for B' more paragraphs...

...added to the number of 9's that a number has, and I call this number C'.

Now, I'd like to call the C'th step...
...keep talking like this for C' more paragraphs...
...and I call this number D'.
...keep talking like this for D' more paragraphs...
...keep talking like this for E' more paragraphs...
...keep talking like this for F' more paragraphs...
.
.
.
keep adding symbols, until you have xkcd symbols, let the last symbol be called A''. Now, repeat this whole process (not just the first part) xkcd times, but now, keep adding symbols until you have A' symbols. Now, repeat this whole process until you have 'B symbols. Now, repeat this whole process until you have 'C symbols...

...Now, repeat this whole process until you have A'' symbols, let the last symbol be called B''.
...Now, repeat this whole process until you have B'' symbols, let the last symbol be called C''.
...Now, repeat this whole process until you have C'' symbols, let the last symbol be called D''.
.
.
.

Keep repeating the repetitions, until you have Z'''(Y'''(X'''...A'(xkcd 's)')... 's)... 's)... 's)... 's. Let this symbol be subscript °, so that that last number is equal to A°. Repeat this process until you run out of subscripts (ie. the number of subscripts is A°), and let this be A_A which continues like A_B ... A_A' ... A_B' ... A_A'' ... A_A°, until A_{Z°(Y°(X°...A°(xkcd °s)°)... °s)... °s)... °s)... °s}, which is equal to B_A. Continue like this, until you run out of letters (ie., the number of symbols is A_A), and this will be equivalent to A[0]. A[A[0]] = B[0]. Continue like this until you run out of symbols (ie. the number of symbols is A[0]), and the last number will be A<0>. A<A<0>>=B<0>.

...

Continue like this until you run out of symbols to encapsulate the 0 (the number of symbols is some finite amount x so that Z<Z<Z<Z...Y<0> times ...Z<Z<Z<0>>...>> < x < ‽ ), and let the highest number of the last symbol be ‽().

Finally, I'll send my number:

V=‽(‽(...x times]...(‽(‽(999)))))

I just hope this humongous mastodon is at least as big as the numbers people were posting back in page 11...

This could all be made much more clear.

by **Darvince** » Wed Nov 21, 2012 5:29 am UTC

Ok how about this:

A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, A(g₆₄, g₆₄)))))))))

by **Vytron** » Thu Nov 22, 2012 12:14 am UTC

Okay, thanks for your analysis Deedlit, I think my number is very unclear a this point, I just had to write all that before I forgot about the idea. I think the levels could be made a lot more powerful very easily, but the main power of the number is the recursions that come up later, so I'm not even sure the Levels have to be that strong.

Deedlit wrote:Not sure what you mean by this. Taking the xkcdth step of level xkcd is not as good as taking the final number of level xkcd - that is the whole point of having a terminating process.

Okay, let me clarify. You have Level xkcd, then, you feed some number into it, again, I don't know if the number you feed it matters much, because at some point functions are so strong that they grow to the same size whether you feed them g64 or 2

But just in case, let's define a function. In my above post I said that "provided the number is increased until all of them are nines", which means that if a step returned 1000, this step returns 9999. This is necessary because the levels run on 9's, a 8 on there makes the whole of it much less powerful, but I think I can do better:

9(x)

Returns x times 9. So, 9(9), returns 999999, and 9(1000) returns a string of 1000 9's. Now I define the initial seed as:

۹=9(xkcd)

A string of xkcd 9's. This would be feed into Level 1 instead of just a 9. Just in case this matters at the end.

Now, when I say "take the xkcdth step", I mean, you put ۹ into level xkcd, you take the last number (the uncompressed one, a 1 with a bunch of zeroes) and call it x. You run 9(x), to get a string of 9's that is the length of that number, you call it, huh, ۹[1]. Then you feed ۹[1] into Level xkcd, you take the last number, call it x, run 9(x), to get a string of 9's of that length which is ۹[2]. You feed ۹[2] into Level xkcd. You continue on and on until you get ۹[xkcd]. Let's call it ۶.

Now, for the "xkcdth step of the level xkcd-1", you take ۶ into level xkcd-1, you take the last number x, call 9(x), get ۶[1], feed it into level xkcd-1, and repeat another xkcd times. You get ۶[2]

Now that I (think) I have some clarified recursion, I notice that the levels are getting weaker while the seed is getting bigger. That may not be optimal, maybe the number would be larger if I kept feeding it to level xkcd all the time, but did it one time less.

No, actually, I can keep increasing the levels and decreasing the times, so the number of nines I add at every recursion is greater than the last time, instead of less, and I ensure that it halts.

So, lets redefine "xkcdth step of the level xkcd-1" to be: you take ۶ into level 2xkcd, you take the last number x, call 9(x), get ۶[1], feed it into level 2xkcd, and repeat another xkcd-1 times. You get ۶[2]. Yes, this sounds better. You continue until you get ۶[2xkcd], this will be ۹ (yeah,I don't think people have used colors in the thread to define numbers, I think I'll use that for an extra set of recursive recursions at the end).

Now, for "xkcdth step of the level xkcd-2", use ۹ as the seed, feed it into level xkcd², call 9(x), get ۹[1], and repeat (by repeat I don't mean you feed ۹ into itself that many times, you have to take ۹[1], for the next repetition, and then ۹[2], for the next repetition) another xkcd-2 times. At the end, you get ۶.

"xkcdth step of the level xkcd-3", is like that, but it's feed to the level xkcd^xkcd xkcd-3 times. "xkcdth step of the level xkcd-4" is feed on level (...((xkcd)^xkcd)^xkcd)^...(xkcd times)...^xkcd)^xkcd xkcd-4 times. "xkcdth step of the level xkcd-5" feeds on level xkcd↑↑↑...(xkcd times)↑↑↑xkcd xkcd-5 times. "xkcdth step of the level xkcd-6" feeds on level xkcd↑↑↑...(xkcd times)↑↑↑xkcd↑↑↑...(xkcd times)↑↑↑xkcd↑↑↑...(xkcd times)↑↑...[xkcd times]...↑↑↑xkcd xkcd-6 times.

Note that I'm doing these progressions in the same way that I did the Level progressions, so this isn't also well defined, but eventually, you'll get to "the xkcdth step of the level 6", which is to be defined as the last number 9(x) as seed, that is feed on the level xkcd^{somethinghuge that would take xkcd paragraphs to explain, or something} 6 times. Decreasing like this until the last number 9(x) is used as seed on a higher and higher and higher and higher and higher level, 5, 4, 3, 2, and finally, once, on (higher and higher)*5 9(x)'s, until everything collapses on a number. That number is x. Use 9(x). This number will be ۹[1][1]

That's for the first part of my confusing paragraph.

"Step xkcdth-1 of the level xkcd", would then no longer start at level xkcd, it would start at the last level used to produce ۹[1][1], which I'll call level ߖ. And while Level ߖ would increase as,ߖ ߖ2, ², ߖ^ߖ, ߖ ^ ߖ ^ ߖ^ ( times ߖ ,( ߖ↑↑↑... Man, the ߖ character sucks when writing, I don't know where a character will end up next, but it follows the progression of above; 9(x) is no longer used, instead, at this point, 9(9(x)) is used, but it grows as below. And the times of repetitions would no longer be xkcd times, they would be 9(ߖ) times.

So, put ۹[1][1] into level ߖ, get x, call 9(9(x)), get ۹[2][1], put it into level ߖ, call 9(9(x)) get ۹[3][1]... repeat until you get to ۹[9(*)][1], this is ۶[1][1].

*ߖ

"Step xkcdth-1 of the level xkcd-1": Put ۶[1][1] into level 2ߖ, get x, call 9(9(9(x))), get ۶[2][1], put it into level ߖ2, repeat 9(*)-1 times call 9(9(9(x))) get ۶[3][1]. Repeat that until you get to ۶[9(**)-1][1], this is ۹[1][1].

*ߖ

**
ߖ2

"Step xkcdth-1 of the level xkcd-2": Put ۹[1][1] into level ߖ^ߖ, get x, repeat 9(*)-2 times call 9(9(9(9(x)))), get ۹[2][1], put it into level ߖ^ߖ, repeat 9(*)-2 times call 9(9(9(9(x)))) get ۹[3][1]... repeat until you get to ۹[9(**)][1], this is ۶[1][1].

*ߖ

**
ߖ^ߖ

Okay, you should get the drift by now about that goes on, and this only scratches the surface.

First, I think I need to define the progression of the levels, what's wrong with this progression?

x, 2x, x^x, (((x^)x^)...x times...^x)^x)^x, x↑↑↑...x times...↑↑↑x, x↑↑↑...x times...↑↑↑x↑↑↑...x times...↑↑↑x↑↑↑...x times... [x times] ...↑↑↑x

It's meant to be a progression faster than A(), or something, so every step things get a lot more enormous than last time, surely the should be a way to formalize this growth unambiguously?

Anyway, I know that even if I made a clear definition of the idea and produced a definite number, it wouldn't dare to dream catching up to the numbers posted up to page 17, I believe, but maybe something can be done about that...

by **Deedlit** » Tue Dec 04, 2012 1:48 pm UTC

Sorry for the late reply. The problem with finding a "formalizing the growth unambiguously" is that the sequence doesn't seem to follow any set pattern. The fourth term in the sequence seems to be an iterate of the third, but then the fifth function jumps all the way to the Ackermann function. Then the sixth function is just x [x+1] x, where [x+1] means x+1 up arrows, so it's less than an iterate of the fifth function.

Let's let f(m, n) be mth function in your sequence evaluated at n, and let f(n) = f(n, n). If I had to guess, I would say that f(5 + m, n) is less than F_{omega + m} (n) where F is the fast-growing hierarchy. So f(n) is no more than F_{omega*2} (n) in the fast-growing hierarchy.

You do a lot of evaluating at various levels, but the higher levels will completely dominate the lower levels, so we only really need to consider the highest level you evaluate. That level is about f(xkcd, xkcd), and the number that is evaluated will be less than f(f(xkcd, xkcd), f(xkcd, xkcd)) = f(f(xkcd)). You then set this equal to ۹[1][1], and perform the same procedure. The number you produce will therefore be less than f(f(f(f(xkcd)))). You call this ۶[1][1]. Each new symbol adds to f's to the upper bound, so if you have m symbols you get an upper bound of f^2m(n). Note that, if f is at level omega*2, f²ⁿ(n) is at about level omega*2 + 1, just one level higher! So there is still a long way to go.

Looking at your previous post, it looks like the sequence A', B', C' function much like your sequence of symbols in your most recent post, so the mth letter will generate about f^2m(n), which is at level omega*2 + 1. It's not clear from your post, but it seems like the symbols A'', B'', C'' either represent f^{2n + 2m}(n) or they represent one level further up the hierarchy. I'll be generous and assume they are one level further up the hierarchy. I'm not sure what Z'''(Y'''(X'''...A'(xkcd 's)')... 's)... 's)... 's)... 's means, but it looks like you are diagonalizing over the 's, which would take you to omega*3, or omega*3+1 if you iterate the diagonalization. You then define a new superscript °, and n ° superscripts will get you omega*3 + n, and as we add more superscripts we will get omega*m + n. You then switch to subscripts, but it's rather confusing since you use previous symbols as subscripts, which won't work. But it seems like m kinds of subscripts will get you to omega^2 + omega*m + n.

So it looks like you are well below omega^omega, which keeps you below Actaeus's best effort, which was at level omega^omega^3.

by **eculc** » Tue Dec 04, 2012 4:11 pm UTC

let x = "myNumber"
limit of x as x approaches infinity.

by **tomtom2357** » Wed Dec 05, 2012 4:41 am UTC

eculc wrote:let x = "myNumber"
limit of x as x approaches infinity.

Not well defined.

by **WarDaft** » Wed Dec 05, 2012 4:43 am UTC

Well defined, but illegal. The limit of x as x goes to infinity is infinity. Which is banned.

by **Vytron** » Thu Dec 06, 2012 7:31 am UTC

Deedlit wrote:Sorry for the late reply. The problem with finding a "formalizing the growth unambiguously" is that the sequence doesn't seem to follow any set pattern.

Yes, I have to work on this, the idea is to have an exponential pattern instead of a "lineal" or "diagonal" one, so every Level+1 is much more powerful than the last one, so a jump from level 95 to level 96 would advance a hierarchy higher than what level 94 to level 95 did. If some f(xkcd, xkcd) is reached at level n, level n + 1 will contain f(f(xkcd)).

Anyway, this currently feels like a car without fuel, because without the starting pattern, the full power of the levels can't be perceived, and the way the number of recursions need to be increased isn't shown properly (which is clear from your "You then set this equal to ۹[1][1], and perform the same procedure", which I'm not because applying the same procedure on ۹[1][1] would get to ۹[xkcd][1], which is a long way from ۹[*][1], and ۶[1][1] requires ۹[9(*)][1] - every time you repeat the procedure, the times you have to repeat it increase. - Just like when we reach A', it seems to me you're jumping from A' to A'' in the way it's meant to jump from A' to B', And jumping like that from A'' wouldn't be B'', but [A'th symbol]'', a long way from [A''th symbol]''=B''. A'(xkcd 's)' means an A with xkcd number of 's, which would be the number of 's that B has, which would be the number of 's that C has... which would be the number of 's that Z has, which is A°, which I think you're greatly underestimating. Repeating this whole process gets us to [A'th symbol]°, a long way from [B'th symbol]° ... [A''th symbol]° ... [A°th symbol]°=B°, a long way from A°'...)

*ߖ

Anyway, I'll leave this hanging in there for now, without the starting pattern this is just fluff. That's for trying to understand what I wrote.

by **Deedlit** » Sat Dec 08, 2012 6:13 am UTC

Vytron wrote:
Deedlit wrote:Sorry for the late reply. The problem with finding a "formalizing the growth unambiguously" is that the sequence doesn't seem to follow any set pattern.

Yes, I have to work on this, the idea is to have an exponential pattern instead of a "lineal" or "diagonal" one, so every Level+1 is much more powerful than the last one, so a jump from level 95 to level 96 would advance a hierarchy higher than what level 94 to level 95 did. If some f(xkcd, xkcd) is reached at level n, level n + 1 will contain f(f(xkcd)).

Anyway, this currently feels like a car without fuel, because without the starting pattern, the full power of the levels can't be perceived, and the way the number of recursions need to be increased isn't shown properly (which is clear from your "You then set this equal to ۹[1][1], and perform the same procedure", which I'm not because applying the same procedure on ۹[1][1] would get to ۹[xkcd][1], which is a long way from ۹[*][1], and ۶[1][1] requires ۹[9(*)][1] - every time you repeat the procedure, the times you have to repeat it increase.

Yes, I know. I didn't mean "perform the same procedure with xkcd", I meant "perform the same procedure, but with xkcd replaced everywhere by ۹[1][1]." That definitely wouldn't produce ۹[xkcd][1].

- Just like when we reach A', it seems to me you're jumping from A' to A'' in the way it's meant to jump from A' to B',

I assumed that if g(n) = (nth letter)', then A'' would be something like g(g(g(...g(n)...))) with A' g's. If it's even stronger than that, you'll have to spell out what it is.

And jumping like that from A'' wouldn't be B'', but [A'th symbol]'', a long way from [A''th symbol]''=B''.
[\quote]
Wait, isn't B the second symbol? How then can [A''th symbol]''=B''? This is all very confusing.

A'(xkcd 's)' means an A with xkcd number of 's, which would be the number of 's that B has, which would be the number of 's that C has... which would be the number of 's that Z has, which is A°, which I think you're greatly underestimating.

You're doing the same thing that you're doing with the levels, which is making this really long chain, when the strongest level of the chain will dominate all the others anyway. Anyway this is just diagonalizing over the number of 's, and since each ' goes one level up the fast-growing hierarchy, ° will be one omega level up the fast-growing hierarchy.

by **Darvince** » Sat Dec 08, 2012 6:42 am UTC

f(x)=your equation
g(x)=f(x)+1
mine will always be bigger.

by **tomtom2357** » Sat Dec 08, 2012 7:14 am UTC

Illegal, using previous definitions. Also, you're not actually defining a number.

by **Darvince** » Sat Dec 08, 2012 7:35 am UTC

ok mommy
f(x)=the next number to be posted
g(x)=f(x)+1
g(x)=largest number

iwin.

by **orangedragonfire** » Sat Dec 08, 2012 7:39 am UTC

1

Just to thwart Darvince.

Also, why do you use f(x) to represent a number? It's customary to let f(x) be a function.

by **Vytron** » Sat Dec 08, 2012 8:09 am UTC

Deedlit wrote:Yes, I know. I didn't mean "perform the same procedure with xkcd", I meant "perform the same procedure, but with xkcd replaced everywhere by ۹[1][1]."

But I'm not just replacing every xkcd for ۹[1][1], I'm actually replacing xkcd for ߖ, which is... huh, let ❶=the xkcdth step of the progression of that I have yet to define, then ߖ= ❶^❶(((...(xkcd^xkcd)^❶((xkcd²)^❶((2xkcd^❶((xkcd^❶))...))), with each parenthesis being the times you have to repeat the whole thing to remove a layer (yes, I still have to define the progression...)

I'm not just getting a new symbol and feeding it again to the loop, I'm increasing the loop length needed to get to the next symbol, and I'm increasing the times the loop is increased to get to the next symbol, and I'm increasing the times I increase the times, and I'm increasing the times I increase the times I increase the times (keep talking like this for ߖ times). And each increment is following the undefined progression.

So ۹[xkcd][1] is the upperbound of the highest number you could get if you repeated the whole process but used ۹[1][1] itself in the place it mattered the most, and if you fed ۹[xkcd][1] in the whole process (which is now much larger), you'd get ۹[2xkcd][1], because the distance from ۹[95][1] to ۹[96][1] requires a progression of repetitions much higher than what jumping from ۹[94][1] to ۹[95][1] required. So just getting a new symbol and feeding it into the whole process advances one step in the progression. Repeating the whole process (not the other whole process, but the process of repeating the whole process) ۹[1][1] times gets you to ۹[xkcd^❶][1], the times you require to repeat the whole process to repeat the whole process to repeat (repeat as necessary) increase up exponentially, so * is much harder to reach than this, and 9(*) is 9(10x10¹⁰⁰) orders of magnitude higher than the difference from 1000 and a 90 Googols. You need to reach ۹[9(*)][1] for ۶[1][1], and the distance to ۹[1][1] is much larger, because if you repeated the whole process (the whole process up until now) with ۶[1][1] in there, it wouldn't even reach ۶[2][1], because ۶[2][1] requires repeating the whole process (the whole process up until now) 9(*) times, while the number grows in a much faster fashion. Reading again what I wrote, it seems this is very unclear, but at each symbol the times "repeating the whole process" need to be repeated increase faster and faster.

*ߖ

I think the power you're assuming A' has actually should have been surpassed at about ۹[n][n][n]...xkcd [n]s...[n][n][n], so now I think once I really come back to this, your underestimation of my number would be much greater, what you think is A'' would turn out to be about ۶[n][n][n]...xkcd [n]s...[n][n][n]. The "...keep talking like this for xkcd more paragraphs..." in my original post isn't making my number justice...

I really sound like an old man babbling, without the base progression, all my attempts to explain how the number grows seem futile.

by **Deedlit** » Sat Dec 08, 2012 9:05 am UTC

Vytron wrote:
Deedlit wrote:Yes, I know. I didn't mean "perform the same procedure with xkcd", I meant "perform the same procedure, but with xkcd replaced everywhere by ۹[1][1]."

But I'm not just replacing every xkcd for ۹[1][1], I'm actually replacing xkcd for ߖ, which is... huh, let ❶=the xkcdth step of the progression of that I have yet to define, then ߖ= ❶^❶(((...(xkcd^xkcd)^❶((xkcd²)^❶((2xkcd^❶((xkcd^❶))...))), with each parenthesis being the times you have to repeat the whole thing to remove a layer (yes, I still have to define the progression...)

You said that ߖ is the last level in the definition of ۹[1][1], so that ۹[1][1] is greater than ߖ. Your expression ❶^❶(((...(xkcd^xkcd)^❶((xkcd²)^❶((2xkcd^❶((xkcd^❶))...))) is the same process you described before, except that you go up to ❶, which is less than ۹[1][1]. So if ۹[1][1] is f(f(xkcd)), then the next number will be less than f(f(f(f(xkcd)))).

I'm not just getting a new symbol and feeding it again to the loop, I'm increasing the loop length needed to get to the next symbol, and I'm increasing the times the loop is increased to get to the next symbol, and I'm increasing the times I increase the times, and I'm increasing the times I increase the times I increase the times (keep talking like this for ߖ times). And each increment is following the undefined progression.

Yes, I know. The same is true of the fast-growing hierarchy. By using f(n) to stand for the number you get when you apply your level-growing procedure n times, it sounds like I am diminishing your notation; really it is just simplifying your notation to make it more understandable, but the effect is to make the procedure sound less grandiose. f(f(n)) is, as you say, more than just feeding it again into the loop, itg increases the loop length and all that. And f(f(f(n))) increases the loop length even more, and so on. All these functions will be dominated by fⁿ(n) = f(f(f(...f(n)...))) with n n's, which we can call g(n). This represents one level up the fast-growing hierarchy. And then you can go to g(g(...g(n)...)), which is barely describable in terms of the original f(n). I think you would be surprised just how big gⁿ(n) would be in terms of your original level-growing procedure. And this is just two levels up the fast-growing hierarchy.

So ۹[xkcd][1] is the upperbound of the highest number you could get if you repeated the whole process but used ۹[1][1] itself in the place it mattered the most,

۹[xkcd][1] is the number you get if you repeat the process xkcd times, but clearly if you repeat the process more you will get a higher number, right?

and if you fed ۹[xkcd][1] in the whole process (which is now much larger), you'd get ۹[2xkcd][1], because the distance from ۹[95][1] to ۹[96][1] requires a progression of repetitions much higher than what jumping from ۹[94][1] to ۹[95][1] required. So just getting a new symbol and feeding it into the whole process advances one step in the progression. Repeating the whole process (not the other whole process, but the process of repeating the whole process) ۹[1][1] times gets you to ۹[xkcd^❶][1], the times you require to repeat the whole process to repeat the whole process to repeat (repeat as necessary) increase up exponentially, so * is much harder to reach than this, and 9(*) is 9(10x10¹⁰⁰) orders of magnitude higher than the difference from 1000 and a 90 Googols. You need to reach ۹[9(*)][1] for ۶[1][1], and the distance to ۹[1][1] is much larger, because if you repeated the whole process (the whole process up until now) with ۶[1][1] in there, it wouldn't even reach ۶[2][1], because ۶[2][1] requires repeating the whole process (the whole process up until now) 9(*) times, while the number grows in a much faster fashion. Reading again what I wrote, it seems this is very unclear, but at each symbol the times "repeating the whole process" need to be repeated increase faster and faster.

You definitely need to be more exact. Give precise definitions of your numbers, and could you please use regular symbols instead tiny little symbols and changing colors? It is very hard to distinguish your symbols.

I think the power you're assuming A' has actually should have been surpassed at about ۹[n][n][n]...xkcd [n]s...[n][n][n], so now I think once I really come back to this, your underestimation of my number would be much greater, what you think is A'' would turn out to be about ۶[n][n][n]...xkcd [n]s...[n][n][n]. The "...keep talking like this for xkcd more paragraphs..." in my original post isn't making my number justice...

I haven't seen you talk about "۹[n][n][n]...xkcd [n]s...[n][n][n]" before, everything was with two brackets.

Anyway, do you understand the fast-growing hierarchy well enough to determine that my comparisons are wrong?

I really sound like an old man babbling, without the base progression, all my attempts to explain how the number grows seem futile.

You can simply start with a base set of functions f_m(n) for the nth number of level m. Really, you're not going to get all that far with a base progression without using massive recursion, so you might as well just pick a reasonable function and go with it. It's all about the amount of recursion you're able to extend the notation with. That's why the fast-growing hierarchy starts with just f₀(x) = x+1; it's good enough to get where we're going.

by **Vytron** » Sat Dec 08, 2012 11:05 am UTC

Deedlit wrote:You said that ߖ is the last level in the definition of ۹[1][1], so that ۹[1][1] is greater than ߖ. Your expression ❶^❶(((...(xkcd^xkcd)^❶((xkcd²)^❶((2xkcd^❶((xkcd^❶))...))) is the same process you described before, except that you go up to ❶, which is less than ۹[1][1]. So if ۹[1][1] is f(f(xkcd)), then the next number will be less than f(f(f(f(xkcd)))).

Ahh, I see now. ۹[1][1] is so big that ۹[1][1]th level of ߖ is completely dominated by ۹[1][1]th level of ۹[1][1], and no matter how many layers of repetitions I add, ۹[۹[1][1]][1] will be much bigger than ۶[1][1], and ۹[۹[۹[1][1]][1]][1] will be MUCH bigger than ۹[1][1], so even if you were generous and made them equal, ۹[1][2] would just be ۹[۹[۹...xkcd times...۹[۹[۹[1][1]]]...]]][1] (not even ۹[۹[۹...۹[1][1] times...۹[۹[۹[1][1]]]...]]][1]). Told like this I agree this sounds a lot less grandiose.

You definitely need to be more exact. Give precise definitions of your numbers, and could you please use regular symbols instead tiny little symbols and changing colors? It is very hard to distinguish your symbols.

Sorry about that, the original idea was to make the symbols resemble a 9, and it seems I succeeded but I don't remember what was the point in doing that...

I haven't seen you talk about "۹[n][n][n]...xkcd [n]s...[n][n][n]" before, everything was with two brackets.

Oh, the same way ۹ eventually became ۹[n], and ۹[n] eventually became ۹[n][n], it would eventually get a new bracket and become ۹[n][n][n]. The idea here is that it's increasingly hard to move to ۹[n+1][n][n], increasingly increasingly harder to get to ۹[n][n+1][n], increasingly increasingly increasingly harder to get to ۹[n][n][n+1], and increasingly increasingly increasingly increasingly harder to get to ۹[n][n][n][n] (actually, the 4 "increasinglies" would be for ۹[n][n][n+2], but you get the idea).

This is what I meant with "this only scratches the surface", as the way this thing grows should surpass the fast growing hierarchy at some point. Say, ۹ with k [n]s matches the fast growing hierarchy's power, so that f(f(n)) matches with ۹ with k [n+1]s, g(n) would match with ۶ with k [n]s, g^x(n) would match with ۹ with k [x]s, and this is a long way to go to ۹ with k+1 [n]s.

Since you are making a jump from ۹[1][1] to A' in your analysis, I have a feeling that your analysis of A' holds for ۹[1][1][1], so in the above k=3.

Anyway, do you understand the fast-growing hierarchy well enough to determine that my comparisons are wrong?

You tell me, if I rewrote your analysis to be like this, would it make sense?:

Spoiler:

Really, you're not going to get all that far with a base progression without using massive recursion

I think the way the brackets are defined have already built-in massive recursion (as, I haven't even increased the value of the third bracket), unless I just fail at understanding the fast-growing hierarchy. What's funny, if this is really the case then I wonder if I need to define the base progression and the way the levels work, that would give precise numbers but If I can match number of brackets to omega how small or big the base seeds are doesn't seem to matter because I seem to reach about the same size anyway.

Now, I'll be ditching the ۹/۶/۹ symbols (and specially the backwards 7 symbol I can't even get to work in the middle of the sentence), I promise.

by **WarDaft** » Mon Dec 10, 2012 4:48 am UTC

Any recursion you insert by hand, compared to ordinal collapse, is rather like putting in more +1s against the very recursion you are trying to define there. It really is. In sort, counting to ω^{ω^{ω}} is quite simply far easier than counting to ω^{ω^{ω^{ω}}}, by more than you realize. Here's an illustration of why:

Spoiler:

But to really grasp how big they are, work through it slowly, trying to figure out where your notation fits in.

by **Vytron** » Tue Dec 11, 2012 6:11 am UTC

WarDaft wrote:The limit of ε_{0}, ε_{0}^{ε_{0}}, ε_{0}^{ε_{0}^{ε_{0}}} ... (amongst a few other effectively equivalent sequences) is ε_{1}, do the same thing with ε_{1} to get ε_{2}, where the 0, 1, 2, etc can extend to any ordinal number, including epsilons. And these are *small* ordinals. Very small. And every time we started counting up and then swapped in an omega, whatever strategy you were stacking to increase that number just got incorporated into the structure of the ordinal.

I see. However, I think my brackets already are having that power? The change of symbol before the brackets needs to get much and much higher for a bracket to change number, and a bracket needs to reach higher and higher numbers to change the symbol, and each change in the bracket and symbol to require more and more recursions, which makes it a lot more recursive. So the power of epsilon should be reached at some k brackets (If ε_{0} is reached at the bracket that has the power of the limit of ε_{0}, ε_{0}^{ε_{0}}, ε_{0}^{ε_{0}^{ε_{0}}}, the next symbol would be the limit of ε_{x}, and an extra bracket would be the limit of ε_{ε_{ε_{ε_{...}}}}), and I don't see why it can't be reached at 5 brackets.

So, apparently, the original base progression doesn't need to be defined, because Deedlit was able to analyze my numbers without it.

Instead of the hard to read progression ۹/۶/۹, I'll just use blue numbers. So that ۹=1, ۶=2, ۹=3.

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, 1², in the next 1¹, 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.

2 increases of the same way of above, but if you used it as seed and repeated the whole process changing the 1s for 2s, you would only reach the next level. So now the distance from 1 to 2 is the distance from 2 to level 1 2, and the distance to the next level grows at double the magnitude as above. To reach 2a, you need twice the distance of levels as before, to get 2b. You get 2c, 2d, 2e... There will be a 2th symbol, which we'll call 2ζ, you keep repeating the recursions until you get to the 2ζth symbol, which we can call 2ζ1, and you keep repeating the recursions until you reach the 2ζ1th symbol, which will be 2ζ2. You keep going like this until you reach 2ζ2ζ. That will be 3.

If there was a function to get from 1 to 3, and it was used on 3, you'd get a number that would be half the number you would get if you put 3 at the first level. And the distance from 3 at first level to 3 at second level would be the magnitude squared of above. The number progressions go as before, but the symbol needed to be reached for 4 would be 3ζ3ζ...3ζ3ζ3ζ3ζ times...3ζ3ζ.

The distances between the blue numbers should keep growing like this.

The highest level evaluated would be 1[1], which, if I'm understanding Deedlit's analysis right, should be equal to the power of ω. Then, to reach 1[2], we need to use it as seed and repeat the whole process increasingly more times, so that when 1[1[ζ]] is reached, that's equal to 2[1], which would be about 2ω.

This keeps being repeated, with the distances of the number in the brackets increasing all the times, and the number required in the first bracket to be much higher for a symbol change, until some ζ[1] is reached, which will be 1[1][1], or about ω².

Does my progression make sense up to now? I know it looks very slow, but I want to know if at least it's understandable to this point. At least, instead of three brackets to get to 2ω+1, I'm using 2 to get to ω².

by **Darvince** » Tue Dec 11, 2012 6:20 am UTC

Wait, so if I've got this right, then at 2*omega or whatever you're already at like 10^100 digits?

by **Vytron** » Tue Dec 11, 2012 7:03 am UTC

No, I have surpassed that with 1, considering it's powered by xkcd, which is A(g64, g64), 9(10^100) (of my 9(x) function) is much lower than g64, as is 9(10^100^100...64 towers...^100), anyway.

With 1 I just wanted to start with a huge seed, because the seed becomes the number of hierarchic recursions at the second symbol, but 1 was defeated by Mouffles at the second page (heh, he beat 1[1][1]as well).

A number with 10^100 digits would have been beaten at the first page.

by **WarDaft** » Wed Dec 12, 2012 11:31 am UTC

I see. However, I think my brackets already are having that power? The change of symbol before the brackets needs to get much and much higher for a bracket to change number, and a bracket needs to reach higher and higher numbers to change the symbol, and each change in the bracket and symbol to require more and more recursions, which makes it a lot more recursive. So the power of epsilon should be reached at some k brackets (If ε_{0} is reached at the bracket that has the power of the limit of ε_{0}, ε_{0}^{ε_{0}}, ε_{0}^{ε_{0}^{ε_{0}}}, the next symbol would be the limit of ε_{x}, and an extra bracket would be the limit of ε_{ε_{ε_{ε_{...}}}}), and I don't see why it can't be reached at 5 brackets.

That's not quite how it works. If you have some pattern which grows as the limit of ε_{0}, ε_{1}, ε_{2}, then the next layer of recursion you add onto that is ε_{ω}. The whole thing I described about counting from ω^^3 to ω^^4 (to shortcut notation because that's a lot of brackets otherwise) is now how many 'layers' per sey, of the recursion stacking that got you to ε_{ω} that you have to do to get to ε_{ω^^4}. And even if you reach the point where you're equivalent to ε_{ε_{ε_{ε_{...}}}}), ... it's so much easier to define bigger ordinals than to specifically describe more effective recursion. Though I'm probably going to side with Deedlit on your notation being somewhere in the low ω^^2 ish region. If you're repeating your descriptions, you're probably not actually defining numbers that particularly huge.

Wait, so if I've got this right, then at 2*omega or whatever you're already at like 10^100 digits?

In the fast growing hierarchy, you surpass that size number at somewhere around F₄(3).

by **Vytron** » Thu Dec 13, 2012 2:36 am UTC

WarDaft wrote:Though I'm probably going to side with Deedlit on your notation being somewhere in the low ω^^2 ish region. If you're repeating your descriptions, you're probably not actually defining numbers that particularly huge.

That's because I have used a few number of brackets, but I claim I should be able to reach the power and surpass the power of any number in the thread (at least up to page 17) just by adding more and more of them, so that when A' is actually reached, it'll be particularly huge.

Stop me at the point it no longer makes sense (ζ stands for the limit of the function, which gets bigger every time):

1[1][1] ≈ {ω}²
1[2][1] ≈ {2ω}²
1[ζ][1] ≈ 2[1][1] ≈ {ω}^ω
2[2][1] ≈ {{ω}^ω}^ω
2[3][1] ≈ {{{ω}^ω}^ω}^ω
2[ζ][1] ≈ 3[1][1] ≈ {ω}↑↑ω
3[2][1] ≈ {ω}↑↑↑ω
3[3][1] ≈ {ω}↑↑↑↑ω
3[ζ][1] ≈ 4[1][1] ≈ {ω}↑↑↑...ω ↑s...↑↑↑ω

by **Darvince** » Thu Dec 13, 2012 7:03 am UTC

okay then is 2*omega A(g64, g64)^A(g64, g64) digits?

by **WarDaft** » Fri Dec 14, 2012 3:45 am UTC

You haven't described anything that would make just increasing those numbers give you such fundamentally more powerful recursion. You're also still not getting very far. There's no evidence that the process you're describing would continue to grow at the rate I'm about to credit it with, but even if it did, the limit would be ζ₀. Which is still a small ordinal, compared to most in the thread.

Ordinals really are extraordinarily recursive in nature. So much so that you don't actually need to use recursion your actual function in the long run. You can make your function f₀(x) = x+1, f_a+1(x) = f_a(x) + 1, f_a(x) = f_a[x](x). Note that x never increases here. But yet, there are ordinals sufficiently large that this catches up to the same growth rate as the fast growing hierarchy, which has definitons f₀(x) = x+1, f_a+1(x) = f_a^x(x), f_a(x) = f_a[x](x). If these don't sound very different, tell me what the rough scale of f_{ε_{0}+ω}(4) is in each. Use 0,1,ω,ω^ω... as your fundamental sequence for ε₀, and 0,1,2,3... for ω.

Darvince wrote:okay then is 2*omega A(g64, g64)^A(g64, g64) digits?

That's around F_ω+1(65)
Technically, you should write ω*2 rather than 2*ω (which is actually just ω), but that's not terribly important for this, we know what you mean.

by **Vytron** » Fri Dec 14, 2012 1:41 pm UTC

WarDaft wrote:You haven't described anything that would make just increasing those numbers give you such fundamentally more powerful recursion.

It's because it would take several pages to write, and it's meant to be deduced from the blue numbers progression.

There's an original base progression similar to the one depicted in this post, to which each biggest number is feed again increasingly more times (with the number of times increasing as the number of the first bracket increases), increasingly more times (as the blue number increases)... ... ... (increasingly more times which themselves increase as these x[x] does) (...) (...) (...) [which themselves increase the biggest number times...]

This produces the new level of recursions a, b, c, d, e...ζ...ζth symbol, which increase the blue numbers by one, but, this time the original base progression gains this power, so, feeding this into it all over again is level 1 of the levels, which is feed into itself much more times than before (the magnitude difference between 1 and 2, times... (times...) [times...] {times...})

This all isn't well defined, but I haven't bothered because from what I understood from Deedlit, doing all these recursions will not get me past ω. So the limit of doing this, which would be ζ or 1[1], would be ω.

Now, 1[1] is being used itself to increase the level of recursions, so the power of ω is gained in the original base progression. 1[1]a, 1[1]b, 1[1]c, 1[1]d, 1[1]e... would contain ω + n, so that 1[1]ζ = ω + ω = 2ω = 1[2].

And now the original base progression gains the power of 2ω, so 2[1], 3[1], 4[1] contain nω, so that ζ[1] = ω * ω = ω² = 1[1][1].

Now, the original base progression power of ω² is gained, and the number of times the recursions are added become exponential. So, 1[1][1]a, 1[1][1]b, 1[1][1]c, will contain ω² + n, ω² + ω + n, ω² + 2ω + n, ω² + nω + n, so that 1[1][1]ζ = ω² + ω² = 2ω² = 1[2][1].

However, now the distance from 1[1][1] to 1[2][1] will be the first level of the original base progression, so 1[3][1], 1[4][1], 1[5][1] will contain ωⁿ, so that 1[ζ][1] = ω^ω = 2[1][1].

Now the original base progression gains the power of ω^ω, so that the number of times 2[1][1] needs to be feed into itself to reach 2[1][1]a needs to be high enough that we count to 2ω^ω, 2[1][1]b to ω^ω+1, 2[1][1]c to ω^2ω, 2[1][1]d to ω^{ω^2}, so that 2[1][1]ζ = {{ω}^ω}^ω = 2[2][1]

Now the original base progression gains the power of {{ω}^ω}^ω...

WarDaft wrote:You're also still not getting very far. There's no evidence that the process you're describing would continue to grow at the rate I'm about to credit it with, but even if it did, the limit would be ζ₀. Which is still a small ordinal, compared to most in the thread.

But you're talking about the limit of ζ[1][1], right? Also, I think that'd be the limit of ω[1][1], which, if we used blue {}'s to describe the xth blue symbol of the value, would just be {1[1][1]}[1][1]. ζ[1][1] would actually be ζ₁ = 1[1][2].

Otherwise, it doesn't make sense to talk about ζ, because the limit of the function grows indefinitely, so the ζ in 1[ζ] is much more smaller than the ζ in 2[ζ].

WarDaft wrote: Use 0,1,ω,ω^ω... as your fundamental sequence for ε₀, and 0,1,2,3... for ω.

If it isn't clear enough yet, the main idea with my number is that whatever growth x+1[x][x][x] shows, will be gained by y[x+1][x][x], and when you reach the limit of the blue digit, you get x[x][x+1][x], which becomes the new growth of x[x+1][y][x]. It may be confusing because the number of the first bracket is increased before the blue number can increase, but I'd rather have it like this because the next level of hierarchies can clealy be seen in the next blue digit.

If you meant to turn my original base progression into that fundamental sequence, I think it'd get so big that I wouldn't be able to compare it, because, I don't even know what's the xkcdth level of that sequence.

I also don't know if using 0,1,ω,ω^ω instead of 0,1,ω,2ω,ω²,ω^ω would help the internal sequences, as that would just require to use less symbols, but I'm not spelling out all of them anyway.

by **WarDaft** » Sun Dec 16, 2012 5:01 am UTC

The sequence 0, 1, ω, ω^ω, is the iteration of the function f(x) = ω^x starting at 0. ω⁰ = 1, ω¹ = ω, etc. You can use any strictly increasing countable sequence of ordinals less than ε₀ with order type ω, so long as for every ordinal less than ε₀ is less than some ordinal in your sequence, but these can be arbitrarily difficult to compute, and without using a simple relation, you can make f_{ε_0}(3) arbitrarily large, or even arbitrarily small.

Also, every time you take the xkcdth level of something, you're making your function constant. Which is bad.

And no, ζ₀ is the already named limit of the sequence 0, ε₀, ε_{ε_(0)}, ε_{ε_(ε_(0))}, ε_{ε_(ε_(ε_(0)))}... each of which is far more recursive than the last. These are not trivial jumps, in the slightest.

The levels you describe in your previous post are minor at best up to level 5, at which point you obtain growth rate just below f_ω+1(n). At which point the xkcd number becomes irrelevant. Every single time thereafter that you use it, you're shooting yourself in the foot. Furthermore, you've defined no clear progression past level five. You've gone from repeated exponentiation at level four to repeated up-arrows at five to... something else at level six. There's no clear growth rate to extrapolate to higher levels. The recursive rate you define in your paragraphs is odd, but also not that much either. Suppose item x of level x in your first heirarchy is <= f_a(x) for some ordinal a (which will exist). Then if we let a_1 = the xcd'th item of the xkcd'th level, a_2 = the a_1th item of the a_1th level, etc, then a_n = f_a+1(n). Note that this is more powerful than what you did in your first paragraph, because we started at the xkcd'th level and iterated up by the number we most recently reached n times, rather than down iterated down a constant number of times. Most of the rest of what you said in that post is overshadowed by this one thing.

by **Darvince** » Sun Dec 16, 2012 6:53 am UTC

i like how this thread has turned into recursing A(g64, g64)^A(g64, g64) enough times that the number seems to approach infinity

by **WarDaft** » Sun Dec 16, 2012 7:13 am UTC

No it doesn't. Compared to infinity, every finite number, even the largest in this thread, is effectively indistinguishable from zero.

by **Yakk** » Sun Dec 16, 2012 1:00 pm UTC

I dunno about zero. That might be going too far. How about seven?

by **WarDaft** » Sun Dec 16, 2012 2:26 pm UTC

Well, if we had infinitesimals, that would do, but I don't think we've bothered introducing them to this thread yet... kind-a haven't seemed useful.

by **Vytron** » Sun Dec 16, 2012 5:27 pm UTC

WarDaft wrote:Also, every time you take the xkcdth level of something, you're making your function constant. Which is bad.

Oh, I stopped doing that long ago. Originally, I was using 3 different counters, that increased in three different ways, each every time more powerful than the last. However, Deedlit made me realize that one of the counters was completely dominating the other ones, so that x[ [x][1] ][1] was already dominating any number of recursions that I was having on the second bracket.

From that point out I stopped stopping at the xkcdth level and going up to the highest number discovered level and going to higher and higher levels than it (say, if one goes up to level 1[1], the next will go up to level 2[1]*2, the next to level 3[1]², the next to level 4[1]^4[1]... so that when 1[1][1] is reached, it would already be going to level 1[1][1]↑1[1][1]), though, in my recent re-tellings of the story, I haven't bothered to explain at what level is stopped, because the times the number is feed into itself, and the number of recursions and recursive hierarchies that are added into it are completely dominating any reached level. Multiply 2*2 enough times and it will reach ω at some point, and the number of multiplications will completely dominate if you started with that or 2*2.1.

WarDaft wrote:And no, ζ₀ is the already named limit of the sequence 0, ε₀, ε_{ε_(0)}, ε_{ε_(ε_(0))}, ε_{ε_(ε_(ε_(0)))}... each of which is far more recursive than the last. These are not trivial jumps, in the slightest.

Ah, my bad, I was using the ζ symbol for something else... That's why originally I was using ۹/۶, unused symbols but the problem with them was they looked too similar. Oh well, let's use ¶ as the limit of the function.

¶ grows in this manner:

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 ε₀ to ε_{ε_(0)} is "non trivial", because if you were able to jump from ω to ε₀, and from ε₀ to ε₁, then, at some point in the brackets, the "non" trivial jumps will be trivial.

Let's go back to:

ω[1][1] = {1[1][1]}[1][1], and say that by this point, things are so recursive that ε₀ is reached.

By this point there are a lot of recursions going on. First, there's the original level progression that advances with the power of ε₀ in the levels. Then, there's the ω[1][1]a, ω[1][1]b, ω[1][1]c... sequence, that is adding a new level of ε₀ hierarchies and ε₀ levels of levels, and ε₀ {levels of levels of levels...} with each progression.

Then there's {1[1][1]}[n+1][1], which keeps doing all this until ω+1[1][1] is reached. However, by this point, what you expect to be ω+2[1][1] (if everything else was repeated), would actually be reached as soon as ω+1[2][1] is reached. So adding to ω becomes harder and harder.

Then there's also {1[n+1][1]}[1][1], following the same rules, and {n+1[1][1]}[1][1], following the same rules.

Eventually {ω[1][1]}[1][1] is reached, or, {{1[1][1]}[1][1]}[1][1], which would be ε_ω

Now, you may think that if everything was repeated again, {{ω[1][1]}[1][1]}[1][1] would be reached, and it would be just ε_ω+1. However, the original progression already has the power of ε_ω, so that ε_ω+1 is reached at {{1[1][1]}[1][1]}[2][1]. ε_ω2 would be reached at {{1[1][1]}[1][1]+1}[1][1]. ε_ω3 at {{1[1][1]}[1][1]+1}[2][1], ε_ω^2 at {{1[1][1]}[1][1]+2}[1][1], ε_ω^3 at {{1[1][1]}[1][1]+2}[2][1], ε_ω^ω at {{1[1][1]}[1][1]+3}[1][1], ε_{{ω}^ω}^ω at {{1[1][1]}[1][1]+3}[2][1], and so on.

By this point, the level of recursions would be higher, so there's {{1[1][1]}[n+1][1]}[1][1], {{1[1][1]+1}[1][1]}[1][1], {{1[n+1][1]}[1][1]}[1][1], {{n+1[1][1]}[1][1]}[1][1], and the sequence:

{{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]

Eventually you reach

{{... ω[1][1] {'s...{{1[1][1]}... ω[1][1] }[1][1]'s...}[1][1]

AKA

¶[1][1]

Or

1[1][2] = ε_{ε_(0)}

And now, you could say, "if you repeated all that, then, at 1[1][¶] you would reach ε_{ε_(ε_(0))})", or something. However, the recursive power of ε_{ε_(0)} is gained at the level progressions, so that ε_{ε_(ε_(0))} is reached at 1[2][2], ε_{ε_(ε_(ε_(0)))} at 1[3][2], ε_{ε_(ε_(ε_(ε_(0))))} at 1[4][2], and so on.

WarDaft wrote:There's no clear growth rate to extrapolate to higher levels.

There's no clear growth rate at the original levels either. But, I think it doesn't matter, because when analyzing the numbers, if I managed to count to ω with the original undefined progression, then I just need to add layers of recursion using the number that counted to ω, to reach ω+1, and do that enough times to reach ω+ω, and do THAT enough times to reach ω*ω, and so on.

Suppose my progression was off the mark, and that what I call the 1[1][1], 2[1][1], 3[1][1] progression couldn't be attained, and it required some 1[1][1], 10[1][1], 100[1][1], 1000[1][1]... progression. I don't think it would matter, because the way to access to ε₀ would remain the same, because these number are so far away from ω that all it matters is how fast ¶ grows.

¶ looks at how fast the number moved since the last time a change happened (like going from 1[1][1] to 1[1][2]), and then becomes so big that for accessing the next blue number, the first bracket has to reach the limit of the sequence of that change.

So 1[¶][2], or 2[1][2], would reach ζ₀. 2[2][2] would access the next ordinal in the sequence ω₀, ε₀, ζ₀... 3[1][2] would reach the limit of the ordinals, and 3[2][2] would access the limit of the limit. If you think this is impossible, I'll be happy to move these powers to 1[1][3], 1[1][4], 1[1][5] or even to 1[1][1][1], 1[1][1][1][1], 1[1][1][1][1][1], but remember that whatever power 1 with k [1]'s has, will be gained, and instead of having to add an extra bracket to reach the next limit, you do that by adding 1 to the first bracket.

So I think my mistake was linking to my original post where I was sticking to xkcd levels, because my number has gotten much more powerful since then, I think.

by **ShyRayq13** » Tue Dec 18, 2012 7:05 am UTC

Hey guys. I wanted to try creating my own function to create extremely large numbers. I know it won't beat the numbers now, but I just want to know how big you think my number compared to the others in this thread. Note that this function features the use of Tricky's Extended Ackermann Function

Define P(n):
P(n) = A(n, n, n, n, n, n.....,n ,n) with "n" occurences of n
P(0) = 1
P(1) = 2

So: P(2) = A(2, 2) and P(3) = A(3, 3, 3)
This is fairly simple and would create rather small numbers. So let's up the ammunition

Define P^m(n):
P^m(n) = A(P(n), P(n), P(n).....P(n), P(n)) with "m" occurences of P(n)
P⁰(n) = P(n)
P¹(n) = P(n) + 1

Therefore: P² (2) = A(P(2), P(2)) which in turn equals A(A(2, 2), A(2, 2))

Now define P_q (n):
P_q(n) = P(P(P(P(P(P(.....P(n)))))) with "q" sets of brackets
P₀(n) = P(n)
P₁(n) = P(n) + 1
P^m_q(n) = P^m(P^m(P^m....(n))))) with "q" occurences of n

Here we can see that this grows quite large quite quickly.
As an example: P²₂(2) = P²(P²(2))
This then results in: P²(A(A(2, 2), A(2, 2)) = P²(A(7, 7))
Now A(7, 7) is already a large numbers, but there's still a bracket left to deal with!
The result of this would be A(P(A(7,7)), P(A(7,7)) and P(A(7,7)) is the ackermann function with A(7,7) occurences of A(7,7)!
As you can see, this is huge, with a large m, n, and q

But, I'm not done yet.

Define &(n):
&(n) = Pⁿ_n(n)

Also define &^m(n):
&^m(n) = &(&(&(&(&(&(&(&(...(n)))))))... with "m" sets of brackets

And define &_q(n):
&_q(n) = &^q(P(A(n, n, n....n)) with "q" occurences of n
&^m_q(n) = &_{&^m(P(A(n, n, n..., n))}(P(A(n, n, n, n...n)) with "q" occurences of n

Using this last function, I can create this monstrous number which I call my own.
&^&_xkcd(xkcd)_&^xkcd(xkcd)(xkcd)
I wonder how monstrous this number is...

Who is online