Tetration with non-integers

[anderscolingustafson]

In the same way that multiplication is iterated addition and exponents are iterated multiplication Tetration is iterated exponents. In Tetration if you have ⁿx, x is the base number that is in a power tower and n is the size of a power tower. For instance if you have ⁴3 that would be the same as 3^(3^(3^3)). I was wondering how do you do Tetration in which the size number of times a number is raised to the power of itself is not a whole number? I mean what if for instance you have ^2/56? I mean how do you evaluate a power tower in which the size of the power tower is not a whole number?

[quickfur]

This subject has been intensively studied in the tetration forum (google for it), and the short answer is, there are multiple possible definitions of the tetration of non-integers (in fact, infinitely many variations), all of which will give you a different answer. There has been lots of research into finding the "most natural" non-integral tetration, but so far, none of them stand out as being better than others, so there's still multiple choices which will give you different answers depending on which one you pick.

Also, don't forget that defining non-integral tetration for rational numbers is not good enough, since it will be discontinuous; you have to also consider what it means to write ^√5x. (Or, indeed, what the analogous irrational exponentation, like 2^√2, means. Which, btw, is well-defined, but is not as straightforward as one might think at first glance.)

[ICN5D]

You know, I've always wondered about iterated exponents, and now I just learned something. That's cool to see the syntax is a reversal. Also sounds like it would rapidly lead to crazy high numbers. And, of course, the potential functions of them, maybe something like ^x+nx-n ?

[Polyhedron Dude]

You know, I've always wondered about iterated exponents, and now I just learned something. That's cool to see the syntax is a reversal. Also sounds like it would rapidly lead to crazy high numbers. And, of course, the potential functions of them, maybe something like ^x+nx-n ?

This is a subject I have played around with a bit. Tetration is just the beginning, there's pentation (iterated tetration), hexation (iterated pentation), and so on. And that's still only the beginning!

Some time ago, I've generated one terrifying function called "Array Notation" (also called BEAF for "Bowers Exploding Array Function") that makes hexation, heptation, . . . . gigation, . . . . googleplexation, . . . . , etc look like they are standing still. In array notation {a,b,c} = a^^^^^^^^'''''''^^^^b, where there are c ^'s. a^^b is a tetrated to b, a^^^b is a pentated to b, etc. Four entry arrays can grow as fast as Conway's chained arrow notation, which only lands at w^2 (w stands for the ordinal - omega) on the Fast Growing Hierarchy (FGH). {a,1,1,2} = a. {a,2,1,2} = {a,a,a}. {a,3,1,2} = {a,a,{a,a,a}}. {a,4,1,2} = {a,a,{a,3,1,2}} = {a,a,{a,a,{a,a,a}}}. {a,b,1,2} can get past Graham's number and this is the smallest of the 4 entry arrays. Array notation not only can have large linear arrays like - {a,b,c,d,e,f,g,h,i,j} - but can take on multidimensional array structures. Linear array notation hits w^w on the FGH and dimensional array notation lands at w^w^w. I didn't stop there, for I came up with a way to extend into "tetrational array structures" - where dimensional structures have sizes like X^n arrays, tetration structures have sizes like X^^n arrays. Tetrational array notation hits epsilon naught (e0) on the fast growing hierarchy, e0 = w^^w. Next comes pentational array structures, their complexity reaches the Gamma naught ordinal on the fast growing hierarchy, which is now known to be equal to w^^^w (shown by Sbiis Saibian on his amazing web site on large numbers https://sites.google.com/site/largenumbers/home). The structures can become so complex that they themselves need to be described with array notation, leading to what I call legion arrays - which lands near the large Veblen ordinal on the FGH. More about array notation can be read on my website http://www.polytope.net/hedrondude/bnc.htm. I also coined many cool number names like tridecal, tetratri, xappol, gongulus, kungulus, and meameamealokkapoowa oompa.

[quickfur]

Actually, I hate the reversed syntax. Not only it's ugly and ambiguous (how do you interpret a^xb?), it also cannot be generalized, and fails to adequately convey that it's actually just one in an entire series of higher-level operations, the so-called Grzegorczyk Hierarchy. The first levels of this hierarchy are addition, multiplication, exponentiation, tetration, but it continues: pentation, hexation, heptation, etc.. Each level of this hierarchy represents an operator that's an iterated version of the previous operator in the hierarchy. So just as multiplication is iterated addition, and exponentiation is iterated multiplication, so tetration is iterated exponentiation, and pentation is iterated exponentiation, etc..

You may have heard that exponentiation grow extremely fast -- and you'd be right. But that's nothing compared to tetration. To use an infix notation that I invented for this purpose, we may write x{3}y = x^y, and x{4}y = x^x^x^...(y times). 2{4}3, for example, is 2^2^2 = 2^4 = 16, and 2{4}4 = 2^2^2^2 = 2^16 = 65536. So far so good. But look at 2{4}5 = 2^2^2^2^2 = 2^65536 = ... an insanely huge number with more than 20,000 digits. Then 2{4}6 = 2^(2{4}5) = 2^(that insanely huge number with 20,000+ digits). This monster has so many digits, that the number of digits in its number of digits is far too large to write down.

You may be impressed by how fast-growing the {4} operator is, but wait till you see the {5} operator. 2{5}3, for example, is 2{4}2{4}2, which is 2^(2^2) = 2^4 = 16. But 2{5}4 = 2{4}2{4}2{4}2 = 2{4}(2{4}2{4}2) = 2{4}(2{4}16). Remember how ridiculously huge 2{4}5 is? Well, here, we're not talking about 2{4}5; we're talking about 2{4}16, and not just 2{4}16 by itself, but 2{4}16 as the argument to another {4} operator!! The number of digits in the number of digits in the number of digits in ... (so many times I don't even know how to write it down) ... in the number of digits in 2{4}16 is a number so huge that it's beyond all description, and now we're taking that, and constructing not a power tower, but a tetrational tower, with that many levels in it. And by the way, this is just 2{5}4. Do you even want to know what 2{5}5 is?

But it doesn't stop there. 2{6}3, for example, is 2{5}2{5}2, which is 2{5}16. Now just pause for a second. I already have trouble explaining just how incomprehensibly huge 2{5}4 is, and now we're not talking about 2{5}5, or even 2{5}6; we're talking about 2{5}16. But this is merely 2{6}3...(!) Let's not even talk about 2{6}4 or 2{6}5... or, God forbid, 2{6}16 which is 2{6}2{6}2. But that's only 2{7}3. What about 2{7}4? Or, for that matter, 2{8}4? Or, since we're at it, 2{100}4?

But why stop there? We could easily construct 2{2{100}4}4. That is, the order of the operator between the outer 2 and 4, is 2{100}4. In other words, even the level of that operator is so unimaginably huge, that the only sane way to write it down, is as 2{100}4. (Now you know why I chose this notation: we need the level of the operator to be itself expressible in numerical terms. )

We could keep going, of course. But all of these operators, with a fixed number inside the {}, are only a part of the Grzegorczyk Hierarchy. This hierarchy actually has a limit (in the calculus sense not in the numerical sense, 'cos the numbers that these operators generate are so huge they will explode your perception of infinity several times over, and then some). This limit is an insanely fast-growing operator that corresponds with the notorious diagonalized Ackermann function, which you may have heard about. It can be defined as x{w}y = x{y}x (where w is my poor man's substitute for lowercase omega, representing the first transfinite ordinal), that is to say, the argument you pass to it determines the order of the operation performed. So 5{w}3 = 5{3}5 = 5^5, and 5{w}4 = 5{4}5 = 5^5^5^5^5, and 5{w}5 = 5{5}5 = ... well, you know how powerful the {5} operator it. But this only barely scratches the surface of the {w} operator. If you make the argument of the {w} operator variable, then it diagonalizes all the operators of the Grzegorczyk Hierarchy, and becomes an operator that surpasses all previous operators.

But, when it comes to these things, there is never an end, so you soon learn that actually, the Ackermann function is only but a tiny baby step up the so-called Veblen hierarchy of ordinals, or the initial segment of the so-called "fast-growing hierarchy" that map to these ordinals. In the Veblen hierarchy, an ordinal (or correspondingly, an operator) is assigned an ordinal index. The ordinal index of the {n} operators for finite n is simply the finite number n itself. The ordinal index of the Ackermann function is w (i.e., omega), the first transfinite ordinal. But there are many others to follow... for example, the iteration Ackermann function produces an operator of order w+1, and the iteration of that produces an operator of order w+2. But we can easily diagonalize the whole series of iterated Ackermann functions, and get w+w = w*2. (Caveat: this is transfinite ordinal arithmetic, not normal finite arithmetic, so operations like + and * do NOT commute.) w*2, therefore, represents an operator so far up the hierarchy, that it requires two infinite stretches of iteration to describe. But this is rather slow going... if we now diagonalize the process of diagonalization itself, we get w+w+w = w*3... or if we diagonalize the process of diagonalizing diagonalizations, we get w+w+w+... = w*w = w^2. But an operator of order w^2 is still only at the bottom section of the Veblen hierarchy. We can easily go to w^w, then w^w^w, then w^w^w^w, ... etc., and eventually we arrive at epsilon_0 = w^w^w^... (w times). But even epsilon_0 is still only at the very bottom rungs of the Veblen hierarchy.

To go up the Veblen hierarchy significantly, you have to start using the Veblen functions phi_y(x), where y and x are ordinals. This phi function grows so fast, that by the time you get to phi_w(1), you've already left epsilon_0 so far behind you've already forgotten what it was. But since the value of phi_y(x) is, itself, an ordinal, you can nest the phi function into itself, like phi_(phi_y(x))(x). This, of course, produces a ridiculously huge ordinal, with the corresponding ridiculously huge operator which I won't even attempt to describe because it's far beyond all description. But since phi_(phi_y(x))(x) is also itself an ordinal, you can substitute that back into the phi function again, and get a 3-level nesting phi_phi_phi_y(x..)...(x). It looks trivial on paper, but you have to keep in mind that every additional nesting of the phi function represents an absolutely enormous leap in magnitude, and that the size of this step between every successive nesting explodes in a way that makes all previous operators look smaller than a subatomic particle.

At the top of the Veblen hierarchy sits an absolutely ridiculously huge ordinal called the Fefermann-Schütte ordinal, usually referred to as Gamma_0, which equals to phi_phi_phi_phi...(x) where there are w levels of nestings of phi. The corresponding operator, let's call it {G_0}, is an operation so powerful, that while 2{G_0}2 = 4, 2{G_0}3 is something so indescribably huge, that we have no hope to even begin to write down its value. And just for comparison, 2{4}10 is already so huge that it has exceeded the number of particles in the universe, or, for that matter, the number of particle combinations in the universe throughout its entire lifetime... yet this is less than a puny speck compared to the rest of the Grzegorczyk Hierarchy, which is child's play compared to the Ackermann function, which is less than nothing compared to the 2-level nested phi function... and here we're talking about something that corresponds with an infinite number of nestings of the phi function! So, shall we talk about 2{G_0}4?

Ahahahaha... I see that Jonathan Bowers beat me to it... (saw his reply as I type mine)

But have no fear, these things have no end, as I said. According to what a mathematician told me, Bowers' BEAF notation is somewhere in the middle of the Veblen Hierarchy, meaning that Gamma_0 completely trumps it in terms of operator power. But it's far from being the end -- as the _0 subscript hints at. Now of course, it's trivial to construct Gamma_1, Gamma_2, or even Gamma_Gamma_Gamma_... (w times), but these are actually mere baby steps.

To get significantly beyond Gamma_0, we need to extend the Veblen phi function to take multiple arguments. So phi_z(x,y) would be a 2-argument version of phi_y(x), where the y serves as the equivalent of the original phi function's subscript. And now we get to nest the 2-argument phi function. But at this point, we might as well just give up distinguishing subscripts from non-subscripts, and write phi(x,y,z). But now that we're at it, why stop at 3 arguments? Why not 5, 6, nay, 100 arguments? But let's not hold back -- let's construct the limiting case of phi with w arguments.

The resulting ordinal, which is so ridiculously and indescribably huge, is the so-called "small Veblen ordinal". Ah, but did you notice the adjective "small"? Nevermind the fact that the operator corresponding with this hilariously huge ordinal is far beyond being beyond all description... We can go even higher by proceeding in this way: let's imagine a further extension of the phi function, in which the number of arguments is an ordinal. So the small Veblen ordinal corresponds with a phi function of w arguments, but now we can substitute w with any ordinal that we've previously constructed. Including the result of applying this insanely huge phi function to some other arguments.

For example, let's say we start with the small Veblen ordinal, let's call it v1 for convenience. We then construct a new phi function, that takes v1 arguments. Let me say that again. We're constructing an extended phi function, in which the number of arguments is the small Veblen ordinal -- which is an insanely huge transfinite ordinal. This isn't just an infinity of arguments; this is an infinity of infinities of infinities of ... infinities of arguments, where the structure of the the nesting of the word "infinity" in the previous sentence is equal to all those levels of nesting we built up starting from the Grzegorczyk Hierarchy to the Ackermann function to Gamma_0 all the way up to the small Veblen ordinal. This function is so ludicrously huge, that we don't even know how to describe the number of arguments it takes except as an abstract ordinal! Now imagine unpacking such a function, where each level of unpacking represents the entire construction from ground zero to Gamma_0, and the number of levels of unpacking is the small Veblen ordinal.

Well, the thing about these pesky ordinals, is that they never stop. The output of this insane function with (small Veblen ordinal) number of arguments, is just another ordinal. One that's so huge I don't even know how to describe it. Well, have no fear, we're going to now take this ordinal, far far beyond any means of description or comprehension, and make that the number of arguments to our next extension of the phi function. Are you starting to get some idea of where we're going now? Good, 'cos now we're going to really step on the gas pedal...

Let x be an ordinal representing the number of arguments our extension of the phi function has. Let's denote this as phi[x](...), where the ... represents x arguments (and remember x is not a finite number, but a transfinite ordinal that, by this point, is far beyond the small Veblen ordinal). Since the value of phi[x](...) is just another ordinal, say y, we can feed it back into the process and construct phi[y](...). We can, of course, do this repeatedly to the limit, i.e., do this w times. But that only actually gets us a few inches farther (relatively speaking, of course... even adding just one more argument to phi already makes it explode like there's no tomorrow in magnitude, and here we're talking about adding infinitudes of arguments). We now take a step back, and repeat this process an ordinal number of times, and keep going as long as the new phi functions keep giving us larger and larger ordinals.

We'd never stop, of course. However, no matter how crazily huge the ordinals we're getting at every step, even at every limit, they actually remain below a certain ordinal known as the large Veblen ordinal (finally, it shows its face!). Let's call the large Veblen ordinal v2. v2 is an ordinal that's so huge, that we actually cannot reach it from below using the phi functions. Or, more precisely speaking, in order for us to get v2 out of a phi function, the phi function would require v2 number of arguments. Put another way, v2 is so large that as long as the number of arguments to our phi function is less than v2 itself, the result of the phi function, no matter how large it is, is still smaller than v2. The only way we can get v2 out of a phi function, is if we have already constructed v2 beforehand, so that we can specify v2 as the number of arguments to our phi function. If we start building hierarchies from below using our extended phi functions and feeding the ordinals they produce back into the system as the number of arguments for the next phi function, we will never reach v2. We can only bridge this chasm if we were given v2 in the first place. And this, ladies and gentleman, is the large Veblen ordinal. Can you imagine what kind of monstrous operator v2 would produce??? I mean, sure we know 2{v2}2 = 4, but 2{v2}3 defies all description, to say the least. And 2{v2}10...

But wait, there's more!! (Didn't I tell you that when it comes to ordinals, there is no end? ) In spite of how crazily huge v2 is, it still belongs to the "small" class of countable ordinals, that is, ordinals with cardinality aleph_0. Not only so, v2 is actually only in the initial segment of this class, called the recursive ordinals. And it's not even anywhere near the end of the recursive ordinals; there are far huger ordinals, such as the Bachmann-Howard ordinal, that I won't even attempt to describe here. The Bachmann-Howard ordinal is so insanely huge, that you can't even define it from below. At least with v2, you can define it as the supremum of all the ordinals producible by the extended phi functions, but in order to get to the Bachmann-Howard ordinal, you have to actually leap to the uncountable ordinals and then "collapse" them back into the recursive set. Which, in a very real sense, is "cheating", because the uncountable ordinals include the Bachmann-Howard ordinal by definition, so you're actually implicitly assuming the construction of the Bachmann-Howard ordinal before you can begin to construct it. Now imagine the operator that corresponds with the Bachmann-Howard ordinal. What would 2{BH}10 be??

But these are still just recursive ordinals... The intrepid, or shall I say, the insane, would press on farther until they get to the so-called Church-Kleene ordinal, which is so huge that it is uncomputable. Um... but it's only the first in the set of non-recursive countable ordinals... and we know that the set of all countable ordinals is uncountable, yet the set of recursive ordinals is still countable, it means that there must be far more uncomputable ordinals than computable ones -- and yet each of them, by themselves, is countable. Meaning that it is still meaningful to speak of operators that we can generate from them -- in theory, anyways; since they're uncomputable, the operators they generate are also uncomputable -- uncomputably huge, that is. And these uncomputably huge operators exist in a hierarchy larger than the one we just visited -- they span a far, FAR larger range, than we did in going from +, *, ^ to the Bachmann-Howard ordinal.

But it never ends... If you're crazy enough, you can push beyond these uncomputable countable ordinals until you reach the first uncountable ordinal w_1. By which time you're all on your own, because now you're in territory so far out, that you're now at the far edges of set theory, and you can't even move forward without needing extensions to set theory But that's never a problem for the nutcases who just can't get enough of fast-growing functions or operators. I mean, since we've left constructibility behind a long time ago, we need no longer be held back by such dalliances as the fact that none of the things we're going to talk about can ever be computed, and perhaps not even defined in any computable sense. Since we're pushing far into the frontier, we might as well just take the liberty to adopt the Continuum Hypothesis as an axiom, which would allow us to translate any cardinal number into a corresponding ordinal in a well-defined way, which in turn lets us define operators that correspond with uncountable ordinals. Needless to say, there's no hope whatsoever -- not even in theory -- of ever computing anything with these operators, but hey, that's a small price for being able to boast that we absolutely, totally, trumped everybody and everything else, right? And since we're at it, let's just also assume a few Large Cardinal axioms, just for the fun of it. So we can, for example, take the initial ordinal of an n-superstrong cardinal, and make an operator out of it. This operator would be so hilariously huge, that not only it's uncomputable (and arguably nearly undefinable), it may not even be possible to compare whether it's larger than another operator or not.

But the kicker is, the result of even such an unimaginable operator is still a finite number. We'll never be able to say pretty much anything about this number, of course, but you can rest assured that it is absolutely guaranteed to trump any number anybody can ever name. (Well, until they beat you at your own game by finding a cardinal that's stronger than yours...)

Most people think they understand how huge infinity is. They have no idea...!!

[quickfur]

[...]
Tetrational array notation hits epsilon naught (e0) on the fast growing hierarchy, e0 = w^^w. Next comes pentational array structures, their complexity reaches the Gamma naught ordinal on the fast growing hierarchy, which is now known to be equal to w^^^w (shown by Sbiis Saibian on his amazing web site on large numbers https://sites.google.com/site/largenumbers/home). The structures can become so complex that they themselves need to be described with array notation, leading to what I call legion arrays - which lands near the large Veblen ordinal on the FGH.

Oh?? That's not what somebody told me (perhaps even on this forum, somewhere!). According to their analysis, your array notation falls below Gamma_0. But perhaps that's because they didn't get to tetrational and pentational arrays.

[ICN5D]

I remember when I once played around with large numbers, back in high school and some later years. I was interested in large exponents on large numbers, and I found a way to circumvent my poor TI-86's digit roadblock. I think it was around 6500 or so. But, anyways, I was curious to see how many digits something like 738456^3659387 would be, and I used logarithms to approximate it. Then, naturally, I got into naming them all, based off of how many factors of 1,000 with one million equaling one in the sequence. Then, using million, billion, trillion, as 1,2,3, I set out to numerically extrapolate the names like quindecatrillion or hexacentridecaheptillion. But, they start sounding like dinosaurs that we've just unearthed in Siberia


But, I suppose some way to " approximate " the ridiculous large numbers, would be to stack the number of digits upon number of digits. If the number used to describe the number of digits is too large in itself, then we have to explain it in another stacking. Which, I'm sure has already been done, and you also said so.

[quickfur]

I remember when I once played around with large numbers, back in high school and some later years. I was interested in large exponents on large numbers, and I found a way to circumvent my poor TI-86's digit roadblock. I think it was around 6500 or so. But, anyways, I was curious to see how many digits something like 738456^3659387 would be, and I used logarithms to approximate it. Then, naturally, I got into naming them all, based off of how many factors of 1,000 with one million equaling one in the sequence. Then, using million, billion, trillion, as 1,2,3, I set out to numerically extrapolate the names like quindecatrillion or hexacentridecaheptillion. But, they start sounding like dinosaurs that we've just unearthed in Siberia

But, I suppose some way to " approximate " the ridiculous large numbers, would be to stack the number of digits upon number of digits. If the number used to describe the number of digits is too large in itself, then we have to explain it in another stacking. Which, I'm sure has already been done, and you also said so.

Well, this is exactly what tetration does: it's the reverse of stacking logarithms upon logarithms -- it's stacking exponents upon exponents. So inverse tetration would correspond with stacking logs upon logs, i.e., an iterated logarithm (which you run into in statistics, I believe).

There's an interesting program written by Rob Munafo called "hypercalc", that instead of representing numbers as floating-point (i.e., mantissa + exponent), represents numbers as mantissa + height of power tower (i.e., tetrational exponent). That is, instead of storing numbers in usual scientific notation 1.23*10^123, it represents numbers as 10^10^10^...^(1.23). It's boasted as the calculator that cannot overflow. For example, you can calculate the factorial of the US national debt to the power of the number of particles in the universe, and the calculator handles it just as easily as your TI-86 handles 2+2. The calculator supports a built-in factorial function, and lets you write monstrosities like 1000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (that is, 1 million repeatedly factorial-ated however many times you can type "!"). Such insanely huge numbers are no problem for the calculator, since tetrationally speaking, it's just adding about 50 or so to the exponent at the top of a 3-level power tower. (Yes, such numbers are only 3- or 4-level tetrational towers!)

Of course, it's not completely true that the calculator can never overflow: it can, if you somehow manage to construct a monstrous number that exceeds a 8192-level power tower. But you'll be typing a LOT of "!"'s before you even begin to get near that point... chances are you'll run out of patience (or finger endurance (digital endurance )) long before then.

But all this is still just tetration. The crazy huge numbers that Bowers & I were talking about go waaaaaaaaaaaay beyond that, by a looooong shot! Imagine, for example, a calculator based on pentation. A monstrously huge 8192-level power tower that would overflow hypercalc, will only bump the tetrational tower by one level, that is, x{4}x{4}y instead of x{4}y. Which is only x{5}2. I think even if everyone on the whole earth came together and each contributed as many factorials, exponentiations, and multiplications, as they can to try to overflow this pentational calculator, we would not be able to even come close to overflowing it even after the lifetime of several hundred universes.

And this is only pentation(!) Let's not even talk about hexation, or heptation, or God forbid, the Ackermann function, which trumps n-ation for all finite n. (Now go back and re-read what I wrote about epsilon_0, the Veblen hierarchy, and large ordinals beyond that, all of which are far bigger than the Ackermann function, and get a sense of how incomprehensibly huge those monstrosities are. ) Truly monstrous, I tell ya.

[ICN5D]

Yeah, no kidding, it pushes the limits on what people think infinity means. It's too big to comprehend, almost. Every way you find to express even larger numbers, there's always bigger.

[Polyhedron Dude]

[...]
Tetrational array notation hits epsilon naught (e0) on the fast growing hierarchy, e0 = w^^w. Next comes pentational array structures, their complexity reaches the Gamma naught ordinal on the fast growing hierarchy, which is now known to be equal to w^^^w (shown by Sbiis Saibian on his amazing web site on large numbers https://sites.google.com/site/largenumbers/home). The structures can become so complex that they themselves need to be described with array notation, leading to what I call legion arrays - which lands near the large Veblen ordinal on the FGH.

Oh?? That's not what somebody told me (perhaps even on this forum, somewhere!). According to their analysis, your array notation falls below Gamma_0. But perhaps that's because they didn't get to tetrational and pentational arrays.

Tetration arrays go to epsilon_0, but many people has under-represented pentational arrays, usually by trying to use integer based tetration on the ordinals instead of ordinal based tetration. Sbiis Saibian has found a way to properly tetrate and pentate ordinals and it better represents pentational array notation. Some people has figured incorrectly that epsilon_1 would be equal to w^^(w*2), but closer inspection by Saibian and myself (I used the climbing method mentioned on my hyperpolynomial page) reveals that epsilon_w = w^^(w+1) and epsilon_w^w = w^^(w+2), epsilon_epsilon_0 = w^^(w*2). Gamma_0 = w^^^w and this is the speed of pentational arrays. 10 {gamma_0} 100 would be in the kungulus vacinity.

Epsilon_1 = limit of e0+1, w^(e0+1), w^w^(e0+1), w^w^w^(e0+1),.... - this is basically the climbing method as the +1 climbs the tower. At the limit it will be added to position w in the tower, it will not place an entire new tower of w^w^w^w^..... at position w. The climbing method will need to be done over and over again to get position w to take on value w, but this will not be reached until epsilon_w.

[quickfur]

Yeah, no kidding, it pushes the limits on what people think infinity means. It's too big to comprehend, almost. Every way you find to express even larger numbers, there's always bigger.

"Pushes the limits" sounds like the understatement of the year. Read up on Graham's Number sometime. I tried understanding how big it was at one time, and I must say, it exploded my concept of infinity several times over before I even got past the first few stages of its construction.

And then you learn that Graham's Number sits only one or two levels above the Ackermann function in the Veblen hierarchy (that is, it's close to the very bottom of the Veblen hierarchy), and your mind is just completely boggled as to what the upper levels of the Veblen hierarchy must look like...

[...]
Tetration arrays go to epsilon_0, but many people has under-represented pentational arrays, usually by trying to use integer based tetration on the ordinals instead of ordinal based tetration. Sbiis Saibian has found a way to properly tetrate and pentate ordinals and it better represents pentational array notation. Some people has figured incorrectly that epsilon_1 would be equal to w^^(w*2), but closer inspection by Saibian and myself (I used the climbing method mentioned on my hyperpolynomial page) reveals that epsilon_w = w^^(w+1) and epsilon_w^w = w^^(w+2), epsilon_epsilon_0 = w^^(w*2).

Yes, I've known that epsilon_1 is actually not that much bigger than epsilon_0.

Gamma_0 = w^^^w and this is the speed of pentational arrays. 10 {gamma_0} 100 would be in the kungulus vacinity.

Wait, Gamma_0 is only w^^^w??? That's not how I understand it. I tried unpacking the nested Veblen function before, and I found that the epsilon_x ordinals only go up to about 2-3 levels of nesting before flattening out. The thing is, each nesting level of the Veblen function represents a gigantic jump in speed over the previous nestings, such that adding +1 to the first nested subscript of the n'th nesting level is equivalent to iterating the entire process it takes to get to the n'th level, except each step is as big as a single leap from 1 to the n'th nesting level. In order to increment the n'th subscript, you have to repeat this so many times that the first nested subscript overflows to the second, and then the second to the third, ... etc.. And in order for each subscript to overflow, you have to repeat the process for as many times as the ordinal corresponding to the remaining (n-k) levels of subscripts.

So I think w^^^w, w^^^^w, w^^^^^w, ... etc., all fall below about 3-4 nesting levels of the Veblen function (I don't remember the exact level now), none of them is anywhere near Gamma_0!

Epsilon_1 = limit of e0+1, w^(e0+1), w^w^(e0+1), w^w^w^(e0+1),.... - this is basically the climbing method as the +1 climbs the tower. At the limit it will be added to position w in the tower, it will not place an entire new tower of w^w^w^w^..... at position w. The climbing method will need to be done over and over again to get position w to take on value w, but this will not be reached until epsilon_w.

Yes, that's what I thought. A similar thing applies to the nested Veblen function: iterating phi_(nested n times) n times (i.e. compose with itself n times) does not add +1 to the nesting level; it only increments the argument to the function by some constant (probably 1). Iterating it (phi_(nested n times)) times only adds +1 to the first nested subscript. It will take a LOT more to even get to the second subscript, nevermind the n'th subscript.

At least, that's how I understand it from the last time I looked into this. I constructed my Exploding Tree Function (which was intended to reach Gamma_0) based on the wrong understanding about the size of the leap between nesting levels of the phi function, and it turned out that it doesn't even get past phi_phi(x). From what I understand, Gamma_0 is a lot bigger than how you described it here.

Or am I missing something obvious??

[Polyhedron Dude]

Here's how I figured the ordinal sizes:

e0 = w^w^w^w^w'''''''''|1 - the 1 is at position w in the power tower, we can rewrite this as w^^w # 1 = w^^w
e1 = w^w^w^w^w''''''''|2 = w^^w # 2
ew = w^w^w^w^w'''''''|w = w^^w # w = w^^(w+1) = w^^(w+1) # 1
e(w+1) = w^^w # (w+1)
e(w*2) = w^^w # (w*2)
e(w^2) = w^^w # (w^2) = w^^(w+1) # 2
e(w^w) = w^^w # (w^w) = w^^(w+1) # w = w^^(w+2)
e(w^w^w) = w^^(w+3)
ee0 = w^^(w*2)
eee0 = w^^(w*3)
eeeeeeee0 = w^^(w*8)
z0 (zeta naught) = w^^(w^2) = w^^(w^2) # 1
z1 = w^^(w^2) # 2
zw = w^^(w^2) # w = w^^(w^2+1)
z(w^w) = w^^(w^2) # (w^w) = w^^(w^2+2)
ze0 = w^^(w^2+w)
zeeeee0 = w^^(w^2+w*5)
zz0 = w^^(w^2*2)
zzz0 = w^^(w^2*3)
psi1(k) = ek, psi2(k) = zk, psi2(psi2(k)) = zzk, etc.
psi3(0) = w^^(w^3) = w^^(w^3) # 1
psi3(1) = w^^(w^3) # 2
psi3(w) = w^^(w^3+1)
psi3(e0) = w^^(w^3+w)
psi3(z0) = w^^(w^3+w^2)
psi3(psi3(0)) = w^^(w^3*2)
psi4(0) = w^^(w^4)
psiw(0) = w^^(w^w)
psiw^w(0) = w^^(w^w^w)
psie0(0) = w^^(w^^w) = w^^^3
psie1(0) = w^^(w^^w # 2)
psiz0(0) = w^^(w^^(w^2))
psi-psi3(0) = w^^(w^^(w^3))
psi-psiw(0) = w^^(w^^(w^w))
psi-psie0(0) = w^^(w^^(w^^w)) = w^^^4
psi-psi-psie0(0) = w^^w^^w^^w^^w = w^^^5
psi-psi-psi-psie0(0) = w^^^6
gamma-0 = psi-psi-psi-psi-............ = w^^^w

[quickfur]

@PolyhedronDude: I've finally managed to dig out that old thread that talks about how your BEAF notation compares with the fast-growing hierarchy: it begins with this post, and the following replies. According to Deedlit, it is far below Gamma_0, but I didn't have the time/energy to dig into all the details of what he posted, so I wasn't able to verify whether his claim was correct or not. Maybe you might be interested to look at his analysis to see where things don't match up?

[Polyhedron Dude]

His analysis looks good. He mentioned that linear arrays are no where near gamma-0 and he's right, they only hit w^w. Dimensional arrays hit w^w^w, and tetrational hits e0. One problem with pentational arrays (and beyond) is that the X structures are getting more complex than e0, and Peano arithmetic can only reach e0 in complexity - in other words Peano ain't strong enough, we need to pull out the Electric Guitar , i.e. adding labels to the power tower - this is where each part of the power tower (which we can call "the beanstalk") has a label of how high up it is, and "Jack" (the +1, that grows into a *w) will need to climb the beanstalk, braking all of the infinite barriers on the way to the top.

Pentational arrays seem to hit gamma-0 = psi (1,0,0). Hexational arrays land around psi (2,0,0), higher n-ational arrays land around psi (n-4,0,0), so "operational" space arrays will land at psi (w,0,0). Expandational arrays will land at psi (1,0,0,0) = psi(psi(psi(psi(......(psi(1,0,0),0,0),....,0,0),0,0),0,0) which is called the Ackermann ordinal. I haven't thoroughly checked, but I suspect that multi-expandational arrays will land at psi (1,1,0,0) - power-expandational around psi(1,2,0,0) - explodational arrays may land at psi(2,0,0,0), detonational arrays at psi(3,0,0,0), pentonational arrays at psi(4,0,0,0), and "linear-array-notation-al arrays" at psi(1,0,0,0,0,0,.......) = small Veblen ordinal. "Dimensional-array-notation-al" arrays would land at psi(A) where A is an infinite dimensional array of 0's, with the first position being a 1 - this is where the number "golapulus" will land. Legion arrays should land at the large Veblen ordinal.

[quickfur]

Cool stuff. Any ideas of how to get past the large Veblen ordinal? Significantly past, I mean. Obviously, whatever it takes to get to the large Veblen ordinal won't get you very much farther from just re-applying what has been done before. Some kind of "new climbing style" will be needed for Jack to get significantly past the large Veblen ordinal.

Now I know about how you could get to the Bachmann-Howard ordinal by using collapsing functions on uncountable ordinals, but I'd like to figure out a way of getting there "from below", that is, without appealing to uncountable ordinals which also makes it algorithmically unreachable. Or is the large Veblen ordinal some kind of inherent limit to things that are reachable from below by iteration + diagonalization?

It's funny how, before I learned about the Veblen ordinals, I thought epsilon_0 was pretty close to the first uncountable ordinal w_1. Then I found out how laughably tiny epsilon_0 was, and then I thought, Gamma_0 must be pretty darn close. Nope, it's also laughably small compared to the "small" Veblen ordinal. And then there's the large Veblen ordinal, then the BH ordinal, etc., all of which, incidentally, are below the so-called uncomputable (but still countable) Church-Kleene ordinal. Then it appeared that the CK ordinal is pretty darn close to w_1 (in fact it shares some of its characteristics, and even its notation w^CK₁ suggests a close parallel). But then I realized that actually, the CK ordinal is "only" the first milestone in an uncountably long series of uncomputable countable ordinals that terminate at w_1 -- because the computable ordinals are countable, you see, but w_1 is uncountable, which means that there must be an uncountable number of uncomputable countable ordinals before you can get to w_1.

And I'm not even sure how close "huge" ordinals like the BH ordinal are to the CK ordinal -- I suspect it's still a long way off -- and once you get to the CK ordinal, that's only the first in an uncountable number of steps before you get reach w_1. My brain explodes at the very thought of it.

(What really gets to me, is that using the von Neumann definition of ordinals, every larger ordinal contains all of the preceding ordinals, and since every ordinal before w_1 is countable, it means that no matter how far along that uncountable sequence leading up to w_1 you get, you've still only made a countable number of steps (because the current ordinal must contain all preceding ordinals, yet it itself is still only countable unless you've already reached w_1, so that means there are only a countable number of preceding ordinals). So where along the way do can you fit these uncountable steps to get to w_1??? Every ordinal smaller than w_1 is countable, yet to get to w_1, you need to pass an uncountable number of countable ordinals, but each of them is reached after only a countable number of steps! My brain just boggles at this paradox. )

[Polyhedron Dude]

I have went beyond legion arrays into lugion arrays and beyond up to my crazy named number "meamealokkapoowa oompa" - but I have yet to see exactly where it lands on the hierarchy. I suspect it gets far beyond the LVO, but is no where near the BH ordinal. Chris Bird made a variant of my array notation and extended it several times and claims that his extensions beat the BH - but I haven't made any attempt to check if it is so. The w_1 paradox is similar to the w paradox, where every integer is finite, but there are an infinite number of integers before reaching w - however w_1 is MUCH further down the road .

[quickfur]

[...] The w_1 paradox is similar to the w paradox, where every integer is finite, but there are an infinite number of integers before reaching w - however w_1 is MUCH further down the road .

That thought made me shudder when I think about what it would take to get from w_1 to w_2.

[Polyhedron Dude]

Or even worse - w_w_w_w_w_w_.........

[quickfur]

Or even worse - w_w_w_w_w_w_.........

Ah, but once you start down that road, you're gonna hafta quantify the length of that nested subscript chain as an ordinal K. So w_w_w_... has K=w, but there's no reason to stop at mere w. You can, for example, set K to epsilon_0. Or, for a real brain-whammy, set K = Gamma_0, or the Bachmann-Howard ordinal.

But that's still countable. What if the length of the chain is K=w_w_w_...? Worse yet, one can imagine a horrifically huge ordinal L such that the length of its nested w subscript chain is equal to itself... If such an ordinal exists, it would completely explode your brain, L times over, just for attempting to comprehend what it is, because it will be unreachable from below via the subscripting operation, in the same way the large Veblen ordinal is unreachable from below via the Veblen function with an ordinal number of arguments, because you need (large Veblen ordinal) number of arguments in order to reach it. Here, you'd need L levels of subscripts in order to be able to reach L.

[Polyhedron Dude]

Sort of reminds me of Buzz Light Year's phrase "to infinity and beyond!" - actually its more like "to infinity and beyond and more beyond and infinitely more "mores" after an uncountable number of "beyonds" undergoing array notation, and then some, keep on going, ahhh- no end in sight!! ........aaaaaahhhhhh....end, where are you!!!! end!!!! are you even there!!!!........."

[quickfur]

Sort of reminds me of Buzz Light Year's phrase "to infinity and beyond!" - actually its more like "to infinity and beyond and more beyond and infinitely more "mores" after an uncountable number of "beyonds" undergoing array notation, and then some,

Yeah that about sums it up.

keep on going, ahhh- no end in sight!! ........aaaaaahhhhhh....end, where are you!!!! end!!!! are you even there!!!!........."

There is no end. That's kinda built-into the very definition of ordinal. As long as you can construct a sequence (of ordinal length) of increasing ordinals, there will be a limit ordinal that contains all of it, and therefore no matter what sequence of ordinals you try to construct, there will always be more.

There is a way to go beyond, though. The stuff we've talked about so far are all part of the von Neumann universe, where you start with the empty set, and iterate the powerset operation via transfinite induction. This universe is pretty darn big, and includes just about anything you can dream of that is constructed by some combination of operations on smaller sets. But there are certain axioms you can assume, the so-called "large cardinal axioms", that will produce entities so huge that they cannot be proven to exist, nor can they be proven to be sets (unless you assume said axiom, which states that such a thing exists and is a set). That is to say, these things are so unimaginably insanely huge, they cannot be constructed (or defined!) by any operation you can dream of from below, not even fixed-point operations like the w_ subscripting operation of L. The only way to have them is to be "given" such a thing (i.e., assume its existence as an axiom) -- they are unconstructible by definition!!! These "large cardinals" lie outside the von Neumann universe U, and, surprisingly enough, fall into a linear hierarchy of increasing strength. Which implies that the initial segment of a large cardinal is an ordinal. Now take that ordinal as the number of times you iterate the w_ subscript operation, and ...