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[3][4][1] and 1[4][4][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[1][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[1][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[1][1]. What do you get when you do f(

1[1][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[1][1] times ...f(

1[1][1])...)))

Step 2 just iterates that.

f(f(f(...f(f(f(...

1[1][1] times ...f(

1[1][1])...))) times ...f(

1[1][1])...)))

And so on and so forth. This continues to step

1[1][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

1[1][1]L1 (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

1[1][1]L1 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

1[1][1]L1th(x) function. Let's call this f

^{1}(x). And the highest number reached,

1[1][1]L2.

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 f

^{2}(x), f

^{3}(x), f

^{4}(x)... up until f

^{1[1][1]L2}(x), let's call this g

^{1}(x), the number reached will not be

1[1][1]L3, but

1[1][1]L3i, for imaginary space.

Imaginary Level 4 applies Level 3 at every step, until g

^{1[1][1]L3i}(x) is reached, imaginary Level 5 applies Level 4 until h

^{1[1][1]L4i}(x) is reached, and so on, up until reaching imaginary Level

1[1][1]L2, which produces

1[1][1]L2th

^{1[1][1]L1[1][1]L2i}(x), let's call it f

_{1}(x), and the number

1[1][1]L3S1, 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 f

_{1}(x), f

_{2}(x), f

_{3}(x) at every level, one advances like f

_{1}(x), g

_{1}(x), h

_{1}(x)... up until imaginary level

1[1][1]L3S1, which produces

1[1][1]L3S1th

_{1}(x) (let's call it

^{1}f(x)) and

1[1][1]L3S2 (what is really the result of Level 3 Step 2.)

This goes up until real Step

1[1][1]L2, producing a function that can get the seed directly to this number, and the number

1[1][1]L3 (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

1[1][1]L2 places around the f to put the 1 on the last one.

That was with one layer of recursion, Real Level 4 opens

1[1][1]L3 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

1[1][1]L3 for the first time, Level

1[1][1]L4i for the second time,

1[1][1]L4ii for the third time, and up to

1[1][1]L3 times, producing

1[1][1]L4iii...

1[1][1]L3 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

1[1][1]L3 of Level 4, you have real

1[1][1]L4, and a function.

Level 5 adds an extra dimension, so that, instead of adding

1[1][1]L4 "buildings" (recursive stories) of imaginary space, it goes and adds as much as

1[1][1]L4 words for the "steps (word 1) -> level (word 2) -> layer (word 3) -> story (word 4) -> building (word 5) -> ... x (

1[1][1]L4th word)", and requires getting rid of all that

1[1][1]L4 times to get

1[1][1]L5S1 (what is really the very first step of Level 5). Step 2 requires as much as

1[1][1]L5S1 words, etc.

This goes up to real Level

1[1][1], producing

1[1][1]

ai (which is imaginary), and

1[1][1]L

1[1][1] (the limit of the levels) which goes back at level 1 step 1 with the new values.

1[1][1]

bi,

1[1][1]

ci, etc. are reached in this way, up until the

1[1][1]L

1[1][1]th symbol, which is what you'd expect

1[2][1] to be, but is the real

1[1][1]

a. The distance to the real

1[1][1]

b increases in the same way that level 2 increased, so you need to reach what you'd expect

1[2][1] to be

1[1][1]

a times, and for the real

1[1][1]

c, you add a layer of imaginary space. Real

1[1][1]

d adds a story. Real

1[1][1]

e adds as many words as needed. And at the

1[1][1]

ath symbol, you have the real

1[2][1].

So when you ask "where's ω

^{2}*n, ω

^{3}*n, ω

^{4}*n and the others?", the answer is imaginary

1[3][1]'s are reached more and more times to cover those, so when the real

1[3][1] is finally reached, there's a function as powerful as f(n)=ω

^{n} (for the real

1[3][1]

a,

1[3][1]

b,

1[3][1]

c... progression on the way to real

1[4][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=z

Define 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[1][2], further revisions made me move that up to

1[1][1][2], 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.)