Hyper4 Iterated Exponential Function

Addition a+b = a^①b

Multiplication a×b = a^②b

Exponentiation a^b = a↑b = a^②b

The "Lower" Hyper4 Function a_④b

An Exact Solution of the Inverses of a_④b

The Higher Hyper4 Function ("tetration") a↑↑b = a^④b

My Extension to Real-Valued "Height"

The Power-Tower Paradox

Finding Final Digits Using Modular Arithmetic

Interactive Exploration

A Lifetime Interest in hyper4

The main topic of this page is a function, hyper4, that takes two arguments and performs a repeated exponentiation operation. hyper4 is to ordinary exponentiation as exponentiation is to multiplication. Becase it is a function of two arguments, I also sometimes call it an operator.

For completeness I wrote this page on exponentiation, which also discusses addition and multiplication. Together these make a hierarchy of two-argument functions which naturally extends to hyper4.

Lower Hyper4 Function a_④b

There are two ways to extend the series to a fourth operator beyond exponentiation, depending on how you group the terms². Because of this I need to use different symbols to avoid confusion, and for one of the definitions there are two alternative symbols. To explain my "number in a circle" symbols, I should point out that in discussing these operators in general, it is useful to have an unlimited set of operator symbols. For this reason I sometimes use these alternate symbols for the three operators that have already been discussed:

a+b = a^①b

a×b = a^②b

a↑b = a^③b

The defintions of the two types of hyper4 are:

a_④b = ((a↑a)↑a)↑...↑a

and:

a↑↑b = a^④b = a↑...↑(a↑(a↑a))

where in each case there are b copies of a on the right-hand side.

Both versions produce the same answer for a↑↑1 and a↑↑2 (a and a↑a respectively) but they differ beyond that. The first one produces smaller values so I call it the "lower hyper4 operator"; the other is the "higher" hyper4 operator. When necessary to distinguish between the two I use a_④b and a^④b respectively. For the latter function, the notation a↑↑b is more common in other literature.

Here is a table of the "lower" hyper4 function for arguments from 0 to 6:

a_④b	0	1	2	3	4	5	6

0	1	0	1	1	1	1	1
1	1	1	1	1	1	1	1
2	√2	2	4	16	256	65536	4294967296
3	³√3	3	27	19683	7625597484987	4.434265×10³⁸	8.718964×10¹¹⁵
4	√2	4	256	4294967296	3.402824×10³⁸	1.340781×10¹⁵⁴	3.231701×10⁶¹⁶
5	⁵√5	5	3125	2.980232×10¹⁷	2.350989×10⁸⁷	7.182121×10⁴³⁶	1.911013×10²¹⁸⁴
6	⁶√6	6	46656	1.031442×10²⁸	1.204121×10¹⁶⁸	3.048039×10¹⁰⁰⁸	8.019051×10⁶⁰⁵⁰

By antidiagonals, this table is sequence A171881 (more terms here).

The first row is not in OEIS; second is A0012. Ignoring the 0 column, the next four rows are A1146, A55777, A137840, and A137841. The following rows are not in OEIS.

The first column is not an integer sequence. The next three columns are A0027, A0312, and A2489; the following columns are not in OEIS.

The main diagonal (without the initial term) is A89210.

The superdiagonal is A2488, and the subdiagonal is not in OEIS.

a_④b can be generalized easily to real and even complex arguments through the identity a_④b=a↑(a↑(b-1)). So for example, π_④e is 3581.875516... and e_④π is 4979.003621...

An Exact Solution of the Inverses of a_④b

One might wonder how to compute the a_④b function "backwards", computing the equivalent of a hyper₄ "logarithm" or "root". More precisely, given the equation:

z = x_④y = x^{x^(y-1)}

derive a solution for y in terms of x and z (the "hyper₄logatithm") and a solution for x in terms of y and z (the "hyper₄root").

The first one (getting y in terms of x and z) is pretty straightforward. Starting with z = x^{(x^(y-1))}, we merely need to take a (normal) logarithm to base x twice, then add 1:

z = x^{x^(y-1)}

log_x(z) = x^(y-1)

log_x(log_x(z)) = y-1

y = 1 + log_x(log_x(z))

That was pretty easy. How about the hyper₄root?

Solving for x is a little trickier, because we have an x to the power of x (a "self-exponential" or "coupled exponential" function) which has no closed-form root in the standard elementary functions. However there is always a root to y=x^x, even if x is negative or complex (in which case the root is usually complex). You just have to use the Lambert W function, which is defined to be the inverse of a=b e^b:

a=b e^b if and only if b = W(a) (see footnote⁴)

To solve z = x_④y for x in terms of y and z, begin by defining k=y-1 (which will be easy to undo later). This gives us

z = x^{x^k}

Next, define l to be ln(x) (the latural logarithm of x), or equivalently x=e^l. Substituting this in for the x's, we get

z = (e^l)^{(e^l)^k} = e^{(l e^{k l})}

We can take the latural log of both sides:

ln(z) = l e^{k l}

than multiply by k, giving us

k ln(z) = k l e^{k l}

This is now recognizably similar to the definition of the Lambert W function above, with a=k ln(z) and b=k l. So we can go ahead and use the W function to express the relation as:

k l = W(k ln(z))

Now replacing k and l with their definitions in terms of y and x respectively, we have

(y-1)ln(x) = W((y-1)ln(z))

which readily leads to

x = e^{(W((y-1)ln(z)) / (y-1))}

Since the Lambert W function is defined for (almost) any complex argument, as are the logarithm ln(a) and exponential e^a, the lower hyper₄ function can be used just as freely as each of those other functions.

The Higher Hyper4 Function ("tetration") a↑↑b = a^④b

As described above, the higher hyper4 operator defines a↑↑b as:

a↑↑b = a^④b = a↑...↑(a↑(a↑a))

where there are b copies of a on the right-hand side.

Here is a table of values:

a↑↑b = a^④b	0	1	2	3	4	5	6

0	1	0	1	0	1	0	1
1	1	1	1	1	1	1	1
2	1	2	4	16	65536	2.003530×10¹⁹⁷²⁸	10^{6.0312×10¹⁹⁷²⁷}
3	1	3	27	7625597484987	1.26×10^{3638334640024}	10^{6.0×10^{3638334640023}}	10^{10^{6.0×10^{3638334640023}}}
4	1	4	256	1.340781×10¹⁵⁴	10^{8.0723×10¹⁵³}	10^{10^{8.0723×10¹⁵³}}	3 PT 8.0723×10¹⁵³
5	1	5	3125	1.911013×10²¹⁸⁴	10^{1.335740×10²¹⁸⁴}	10^{10^{1.3357×10²¹⁸⁴}}	3 PT 1.3357×10²¹⁸⁴
6	1	6	46656	2.659120×10³⁶³⁰⁵	10^{2.0692×10³⁶³⁰⁵}	10^{10^{2.0692×10³⁶³⁰⁵}}	3 PT 2.0692×10³⁶³⁰⁵

In the right column are three values beginning with "3 PT". This is an abbreviation for "three powers of ten". For example, "3 PT 8.0723×10¹⁵³" is 10^{10^{10^{8.0723×10¹⁵³}}}.

Reading across each row, it is easy to see that, once b gets large enough, each time you increase b by one, the value of a↑↑b increases to 10^a↑↑b. But of course, it should be a^a↑↑b, not 10^a↑↑b. In fact the values are different, but they are so close that the first few digits of the number at the top of the "power tower" are the same. This is due to the power tower paradox described below.

By antidiagonals, this table is sequence A171882 (more terms here).

First four rows are A0035, A0012, A14221, and A14222; following rows are not in OEIS.

First four columns are A0012, A0027, A0312, and A2488; following columns are not in OEIS.

The higher hyper4 operator cannot be extended in any obvious and self-consistent way to the reals (to compute, for example, π^④e). This issue is discussed at length below, with possible solutions.

My Extension of the hyper4 Function to Real-Valued Arguments

The hyperexponential (also called "tetration" or "power tower") x^④y is defined for integer y>0 by:

x^④1 = x
x^④y = x↑(x^④(y-1)) for y>1

The symbol ^④ is explained above; see also this description) of the hyperN family of operators.

Several times, people have asked me: how can one define x^④y for real y? For example, what is π^④e)?

There are three other functions that have been extended to the reals in ways that seem promising: the factorials by the Gamma function, hyperfactorials by the K-function, and the lower (Simon and Plouffe 1995) superfactorial by Barnes' G-function. All of these are defined in terms of an integral or an infinite product and they all have a "recurrence relation" like Gamma(x+1) = x Gamma(x).

Defining x^④y in terms of an infinite product, or even an infinite product of infinite products of integrals, seems like it will not work since it needs to behave more like an infinite exponential "tower". Using this method for the hyper4 function would probably require using an integral that acts like the x^y function in one asymptote and like a lower function in the other.

Daniel Geisler has collected a lot of information related to this issue at his website, tetration.org.

The best solution I have found so far was developed by I.N. Galidakis ³. It uses the concept of a power tower with gradually growing exponents — for example, it definines x^④0.8=x^0.8, x^④0.9=x^0.9, x^④1.0=x^1.0=x^{x^0.0}, x^④1.1=x^{x^0.1}, x^④1.2=x^{x^0.2}, etc. While this function is continuous, its 1^st, 2^nd, etc. derivatives are not, except for the 1^st derivative when x=e.

Here is my own attempt at the problem:

Begin by imagining an infinite power tower of the form:

x^④y = x↑(x↑(a↑(b↑(c↑...↑(1↑(1↑(1)))...))))

where there are a finite number of x's on the bottom, and an infinite number of 1's on the top. The 1's can be completely ignored, and all you need to look at are the x's and the special terms a, b, c, ... in the middle. These terms have values between 1 and x and are called "transition terms". (Galidakis' method fits this model but only has one transition term.)

Now imagine that the x's at the bottom are actually just a tiny bit smaller than x, and that the 1's at the top are actually a tiny bit larger than 1. In fact, every term of the power tower is between 1 and x. The terms shown as x are just very very close to x.

We want something that is well-behaved, continuous and smooth. That means, essentially, x>a>b>c>1 and as y increases, the values of a, b, c increase gradually until eventually a=x. To achieve this result I decided to use the error function erf(z) = (²/_√π)integral_(0...z)[e^-(z²)dt]

The terms in the power tower need to vary from x to 1 in a smooth manner with two asymptotes and an exponential bias. This is accomplished by the function:

g(x,z) = x^{((1+erf(2z-1))/2)}

This function increases monotonically from 1 for z<<0 to x for z>>1, and most of the transition from 1 to x occurs in the range 0<z<1. Here are examples for x=2 and x=3:

g(2,-1.0) = 1.00001		g(3,-1.0) = 1.00001
g(2,-0.8) = 1.00008		g(3,-0.8) = 1.00013
g(2,-0.6) = 1.0006		g(3,-0.6) = 1.0010
g(2,-0.4) = 1.0037		g(3,-0.4) = 1.006
g(2,-0.2) = 1.017		g(3,-0.2) = 1.027
g(2, 0.0) = 1.056		g(3, 0.0) = 1.090
g(2, 0.2) = 1.147		g(3, 0.2) = 1.243
g(2, 0.4) = 1.309		g(3, 0.4) = 1.533
g(2, 0.6) = 1.528		g(3, 0.6) = 1.957
g(2, 0.8) = 1.743		g(3, 0.8) = 2.413
g(2, 1.0) = 1.894		g(3, 1.0) = 2.752
g(2, 1.2) = 1.967		g(3, 1.2) = 2.922
g(2, 1.4) = 1.992		g(3, 1.4) = 2.982
g(2, 1.6) = 1.9987		g(3, 1.6) = 2.9969
g(2, 1.8) = 1.99984		g(3, 1.8) = 2.99961
g(2, 2.0) = 1.99998		g(3, 2.0) = 2.99996

All terms end up being between 1 and x, and there are none that are precisely equal to 1 or to x. However, they get arbitrarily close.

Then I define a finite approximation power-tower:

T(x,y,n) = g(x,y) ↑ (g(x,y-1) ↑ (g(x,y-2) ↑ (... ↑ (g(x,y-n+1)))))

for example: T(x,y,3) = g(x,y)↑(g(x,y-1)↑g(x,y-2))

Then finally, the first approximation to a real-valued hyper4 or "tetration" operator is:

x^④y ≈ H(x,y) = limit_{(n->infinity)} T(x,y,n)

Here are some examples:

to approximate	use
x^④y	x^{a^{b^c¹}}
2^④2.0	2^{1.894^{1.056^{1.00001^1.00000}}}
2^④2.2	2^{1.967^{1.147^{1.00008^1.00000}}}
2^④2.4	2^{1.992^{1.309^{1.0006^1.00000}}}
2^④2.5	2^{1.997^{1.414^{1.002^1.00000}}}
2^④2.6	2^{1.9987^{1.528^{1.0037^1.00000}}}
2^④2.8	2^{1.99984^{1.743^{1.017^1.00000}}}
2^④3.0	2^{1.99998^{1.894^{1.056^1.00001}}}

Notice that when y is an integer, there are two terms (1.894 and 1.056 in this example) that are almost equivalent to an x. (But not exact: 1.894^1.056 is a little less than 2; more on this later.)

Also notice that when y is a half-integer, one of the terms is the square root of x and two others (1.997 and 1.002 in this example) just about "cancel out".

Finally, notice that the example for 2^④3 is the same as the one for 2^④2, except that all the values have moved up one step in the power tower.

Computer implemenation of this function yields the following values:

H(2, 1.0) = 1.962860044952	H(3, 1.0) = 3.01484034768
H(2, 1.2) = 2.173179457529	H(3, 1.2) = 3.792914579042
H(2, 1.4) = 2.466135238417	H(3, 1.4) = 5.340372413507
H(2, 1.6) = 2.885294328336	H(3, 1.6) = 8.646517688235
H(2, 1.8) = 3.385703944243	H(3, 1.8) = 15.08586176829
H(2, 2.0) = 3.898340329384	H(3, 2.0) = 27.44381034902
H(2, 2.2) = 4.510162634986	H(3, 2.2) = 64.5178910787
H(2, 2.4) = 5.525615740224	H(3, 2.4) = 353.1873877405
H(2, 2.6) = 7.388565694475	H(3, 2.6) = 13348.65068561
H(2, 2.8) = 10.45197695863	H(3, 2.8) = 15768315.29971
H(2, 3.0) = 14.91136402023	H(3, 3.0) = 1.241724436834×10¹³
H(2, 3.2) = 22.78737180478	H(3, 3.2) = 6.065367827881×10³⁰
H(2, 3.4) = 46.06553106953	H(3, 3.4) = 3.259939872799×10¹⁶⁸
H(2, 3.6) = 167.5636835838	H(3, 3.6) = 8.41325266884×10⁶³⁶⁸
H(2, 3.8) = 1400.743379664	H(3, 3.8) = 2.40222047×10^7523398
H(2, 4.0) = 30815.4026169	H(3, 4.0) = 2.43×10^{5924531213185}

Immediately you should notice that H(3,1), H(2,3) etc. do not have the expected integer values. This results from the fact that the terms given by the g() function do not cancel out in the way that they need to, and for sufficiently low values of y, the first term is not x. To compensate for this, two techniques are used.

The first technique relies on the expected property that

x^④(y-1) = log_x(x^④y)

The technique is to calculate x^④y2 for y2=y, or y2=y+1, or y2=y+2, using whatever value of y2 is high enough to ensure that the power tower has at least one term equal to x, then take the log of the result an appropriate number of times. More formally:

H2(x,y,0) = H(x,y),
H2(x,y,n) = log_x(H2(x,y+1,n-1)) for n>0
and
x^④y ≈ H3(x,y) = limit_(n->inf) H2(x,y,n)

The second adjustment that needs to be done is to add a constant bias to y:

H4(x,y) = H3(x,y+K_x)

The bias K_x depends on x but not on y; it corrects for the fact that the transition terms do not "cancel out" perfectly. To compute K_x any value of y can be used, for simplicity set y=1 and find the value of K_x such that H4(x,y)=x.

Results

Applying these techniques yields the following:

H4(2, 0.5) = 1.455433238907	H4(3, 0.5) = 1.719569993279

H4(2, 1.0) = 2	H4(3, 1.0) = 3
H4(2, 1.2) = 2.220044044808	H4(3, 1.2) = 3.767454385038
H4(2, 1.4) = 2.535796688385	H4(3, 1.4) = 5.286052796168
H4(2, 1.6) = 2.976545041727	H4(3, 1.6) = 8.533218056394
H4(2, 1.8) = 3.48226088408	H4(3, 1.8) = 14.87566955748
H4(2, 2.0) = 4	H4(3, 2.0) = 27
H4(2, 2.2) = 4.659076583142	H4(3, 2.2) = 62.73827352165
H4(2, 2.4) = 5.798970054811	H4(3, 2.4) = 332.7270753606
H4(2, 2.6) = 7.870989644306	H4(3, 2.6) = 11786.360106
H4(2, 2.8) = 11.17544894536	H4(3, 2.8) = 12516938.66315
H4(2, 3.0) = 16	H4(3, 3.0) = 7.625597484988×10¹²
H4(2, 3.2) = 25.26514549836	H4(3, 3.2) = 8.585464199454×10²⁹
H4(2, 3.4) = 55.67547493765	H4(3, 3.4) = 5.638449242549×10¹⁵⁸
H4(2, 3.6) = 234.1013825216	H4(3, 3.6) = 3.33366805307×10⁵⁶²³
H4(2, 3.8) = 2312.838710271	H4(3, 3.8) = 3.02141334×10^5972097
H4(2, 4.0) = 65536	H4(3, 4.0) = 4.89×10^{3638334640024}
H4(2, 4.2) = 40324281.68316	H4(3, 4.2) = 10^{4.096307451195×10²⁹}
H4(2, 4.4) = 5.754240098335×10¹⁶	H4(3, 4.4) = 10^{2.690223977285×10¹⁵⁸}
H4(2, 4.6) = 2.961680223745×10⁷⁰	*
H4(2, 4.8) = 1.713274395209×10⁶⁹⁶	*
H4(2, 5.0) = 2.003529934×10¹⁹⁷²⁸	*

* In the second column, the entries that have * instead of a number represent values larger than 10^{2^2¹⁰}≈10^10³⁰⁸. This was the limit of my computer program, which handles large numbers by computing their logarithm to base 10; 10³⁰⁸ is the limit of IEEE double-precision floating point.

Other special values:

H4(e,0.5) = 1.654052630799

H4(e,e) = 3713.155056406

H4(e,π) = 4341201053.37

H4(π,0.5) = 1.750536646695

Although this function definition seems to work well, more work is needed before it can be considered a true extension of x↑↑y:

The limit needs to be well-defined for arbitrarily large y. The error function converges quickly, but since it's being used for terms in a power tower, it might not converge fast enough if the power tower is tall. Due to this, even when the "bias" is perfectly adjusted for a small value of y the same bias will not produce the expected result for larger y. However, the formulas seem to behave well for the values I have tested, which all fall within the range 1 < x^④y < 10^10³⁰⁸.

The bias is different for different values of x. For x greater than about 2.834 the bias is positive, otherwise it is negative. Beyond establishing that this crossover point is not e=2.71828... I have not investigated further. Perhaps there is a "better" g(x,z) would involve a function similar to the error function but with a slightly different shape so that a bias is not necessary. If the bias is unavoidable, a convincing argument of that fact would be needed.

Further extension would be needed to handle y<1, x<1 or for complex x and y.

The Power-Tower Paradox

This section is largely based on an earlier explanation I wrote specifically for HyperCalc entitled Non-Intuitive Results When Working With Huge Numbers.

In his 1948 article Large Numbers ⁵, John E. Littlewood defines the series N₁ = 10¹⁰, N₂ = 10^10¹⁰, N₃ = 10^{10^10¹⁰}, etc. and points out that N₂ "is 'practically unaltered' by being squared", and that N₃ "may fairly [be] called 'unaltered' by being raised to the power of" u = 10⁷⁹ (a contemporary estimate of the number of particles in the universe). He calls this "the principle of crudity":

"We may sum up these considerations as the 'principle of crudity': the practical upshot is that in estimating a number a^{b^{c^...}} it is worth taking trouble to whittle down the top index, but we can be as crude as we like about things that bear only on the lowest ones."

If you spend a while exploring the values of a↑↑b using an unlimited-range program like HyperCalc, you will probably start noticing some paradoxical results and might even start to think the calculator is giving wrong answers.

For example, I will use HyperCalc to compute 27 to the power of googolplex:

Go ahead -- just TRY to make me overflow! _ _ |_| . . ._ _ ._ _ ._ | _ | | | | | ) (-` | ( ,-| | ( ~ ~ 7 |~ ~' ~ ~ `~` ~ ~ -' Enter expressions, or type 'help' for help. C1 = googol = 10^100 R1 = googol: 1 x 10 ^ 100 C2 = googolplex = 10^googol R2 = googolplex: 10 ^ ( 1 x 10 ^ 100 ) C3 = 27^googolplex R3 = 10 ^ [ 10 ^ ( 1 x 10 ^ 100 ) ]

Apparently HyperCalc thinks that

27^{10^10¹⁰⁰} = 10^{10^10¹⁰⁰}

This is clearly wrong — and it doesn't even seem to be a good approximation. What's going on?

First of all, note that HyperCalc, like any normal calculator, is trying to display all its answers in a form that involves using 10 as the base. A standard form like 10^{10^{...^X}} is useful because it makes different types of calculations easily comparable. A user might want to know which is bigger: 100! or 4^4⁴. 100! is about 9.33×10¹⁵⁷. Is that bigger than 4^4⁴? We need to either convert 100! to some power of 4, or convert 4^4⁴ to some power of 10. If you have a calculator that goes high enough, it will tell you that 4^4⁴ is about 1.34×10¹⁵⁴.

Let's assume that HyperCalc cannot be trusted and calculate the correct answer ourselves. In order to compare the two, we need to express them in terms of the same base. Let's use base 10, because one of the numbers, 10^{10^10¹⁰⁰}, is already expressed in terms of base 10. So we need to determine the values of A and B such that:

27^{10^10¹⁰⁰} = 10^{10^{A×10^B}}

The first step is express the power of 27 as a power of 10 with a product in the exponent, using the formula x^y = 10^{(log₁₀(x)×y)} :

27^{10^10¹⁰⁰} = 10^{(log₁₀27×10^10¹⁰⁰)}

log₁₀27 is about 1.4313637641589, so we have

27^{10^10¹⁰⁰} = 10^{1.4313637641589×10^10¹⁰⁰)}

Now we have a base of 10 but the exponent still needs work. The next step is to express the product as a sum in the next-higher exponent; this time the formula we use is x×y = 10^{(log(x)+log(y))} :

10^{1.4313637641589×10^10¹⁰⁰} = 10^{10^{(log₁₀1.4313637641589 + 10¹⁰⁰)}}

log₁₀1.4313637641589 is about 0.1557500185891, and if we add this to 10¹⁰⁰ we get

10^{10^{(0.1557500185891 + 10¹⁰⁰)}}
= 10^{10^{1000...000.1557500185891}}
= 10^{10^{(1.000...0001557500185891×10¹⁰⁰)}}

where there are 94 more 0's in place of each of the "...". Now we have:

27^{10^10¹⁰⁰} = 10^{10^{(1.000...0001557500185891×10¹⁰⁰)}}

again with 94 missing 0's.

Now we've expressed the value of 27^googolplex precisely enough to see HyperCalc's error — and look how small the error is! The error manifests as the digits "155" in "1.000...000155". To even be able to see this "155", we need to use 104 digits of precision because that "1.000...000155" is 104 digits long. In the original calculation giving 27^{10^10¹⁰⁰} = 10^{10^10¹⁰⁰}, HyperCalc used the default precision which is the native precision of the system, which is typically 16 digits of accuracy. Those 16 digits are taken up by the 1 and the first 15 0's — so when it gets to the step of adding 0.155 to 1.0×10¹⁰⁰, it just rounds off the answer to 1.0×10¹⁰⁰.

R3 = 10 ^ [ 10 ^ ( 1 x 10 ^ 100 ) ]

HyperCalc can also use the arbitrary-precision bc to do its math at higher precisions, accessed by setting the special variable scale. We can use that to get a more accurate answer for 27^googolplex. Here is the result:

C1 = scale=120 C1 = 27^(10^(10^100)) R1 = 10 ^ ( 1.43136376415898731186 x 10 ^ 10000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000 )

Two things happened here: Because 120 digits of precision have been specified, HyperCalc can now express googol exactly, so it displays it as a 1 followed by 100 zeros. This means in turn that we no longer get our desired values of A and B, but instead get the intermediate result 1.4313637641589×10^10¹⁰⁰ that we encountered during the derivation above.

To get the actual value of our desired A, we can take the logarithm to base 10 twice. Continuing the above session:

R1 = 10 ^ ( 1.43136376415898731186 x 10 ^ 10000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000 ) C2 = log(%) R2 = 1.43136376415898731186 x 10 ^ 100000000000000000000000000000000000000\ 00000000000000000000000000000000000000000000000000000000000000 C3 = log(%) R3 = 100000000000000000000000000000000000000000000000000000000000000000000\ 00000000000000000000000000000000.1557500185891198647

Here we went to 120 digits of precision to get an answer that is pretty close to the original paradoxical answer. That requires a fair amount of computational work, and if the original problem statement had been greater, it would take even more work. Resolving the difference between 27^{10^{10^1000000}} and 10^{10^{10^1000000}} would take over 1000000 digits of calculation, and resolving the difference between 27^{10^{10^{1000000000000}}} and 10^{10^{10^{1000000000000}}} would require over 1000000000000 digits. And clearly if we just add one more 10 to those towers of exponents, all hope of avoiding roundoff-error is lost. This point is explored further on my large numbers page as part of the uncomparably larger discussion.

Finding Final Digits Using Modular Arithmetic

If you are interested in only the last few digits, values of X↑↑Y can be computed more easily. The algorithm is explained on my page for OEIS sequence a092188. If you want the last N digits, then it could take about 10^N steps to calculate the value of a power-tower A^{B^{C^...}}, but typically it goes a little faster. Here is a little table:

Last 6 digits of x^^y, for 2<=x<=27 and 1<=y<=9 1 2 3 4 5 6 7 8 9 2^^ 000002 000004 000016 065536 156736 428736 748736 948736 948736 3^^ 000003 000027 484987 739387 355387 595387 195387 195387 195387 4^^ 000004 000256 084096 392896 208896 328896 728896 728896 728896 5^^ 000005 003125 203125 203125 203125 203125 203125 203125 203125 6^^ 000006 046656 878656 438656 238656 238656 238656 238656 238656 7^^ 000007 823543 132343 172343 172343 172343 172343 172343 172343 8^^ 000008 777216 126656 449856 945856 825856 225856 225856 225856 9^^ 000009 420489 177289 865289 945289 745289 745289 745289 745289 10^^ 000010 000000 000000 000000 000000 000000 000000 000000 000000 11^^ 000011 670611 906611 066611 666611 666611 666611 666611 666611 12^^ 000012 448256 094016 596416 172416 412416 012416 012416 012416 13^^ 000013 592253 549053 325053 645053 045053 045053 045053 045053 14^^ 000014 558016 651136 510336 782336 302336 502336 502336 502336 15^^ 000015 859375 859375 859375 859375 859375 859375 859375 859375 16^^ 000016 551616 255616 015616 415616 415616 415616 415616 415616 17^^ 000017 764177 229777 125777 485777 085777 085777 085777 085777 18^^ 000018 575424 542976 395776 315776 315776 315776 315776 315776 19^^ 000019 123979 459179 483179 363179 963179 963179 963179 963179 20^^ 000020 000000 000000 000000 000000 000000 000000 000000 000000 21^^ 000021 124421 492421 452421 652421 652421 652421 652421 652421 22^^ 000022 723584 785856 092096 608896 784896 104896 504896 504896 23^^ 000023 910567 988647 606247 078247 918247 718247 718247 718247 24^^ 000024 843776 014976 734976 734976 734976 734976 734976 734976 25^^ 000025 265625 265625 265625 265625 265625 265625 265625 265625 26^^ 000026 203776 203776 203776 203776 203776 203776 203776 203776 27^^ 000027 892803 403683 450083 242083 002083 802083 802083 802083

For example, to find the last 6 digits of 9↑↑4 = 9^{9^{9^{9))), look in the 9^th row and the 4^th column, and find the digits 865289.

Interactive Exploration

My LWFI game (based on LNGI) provides an interface for exploring values of hyper4 (and hyper5). Select the button in the upper-right that is labeled "* ^ ↑↑", then adjust the sliders A, B, C, and D to control the value of the expression D↑↑(C^{A×B)).

A Lifetime Interest in hyper4

A childhood obsession with the family of dyadic operators (increment, add, multiply, etc...) began in 1973 or 1974 when I was 9 or 10 years old. At age 12 or 13 I began looking at the "lower hyper4 function" (which I called "powerlog"²) defined by the left-associative repetition of exponents: x_④y = (((x↑x)↑x)↑...)↑x — the choice of left-associative came from a high school maths textbook that used left-associative parentheses to define exponentiation by repeated multiplication. I wanted to make a slide rule to calculate this function, and did not succeed for the first few attempts. I worked out the formula x_④y=x↑(x↑(y-1)) at age 14 and had a working slide rule a couple months later. In that part of my life (which I call "my classical period") I never could crack the right-associative "higher hyper4 function", and the obsession eventually faded. In 1985 the Mandelbrot set took its place as my primary mathematical obsession.

A real extension for the "higher" hyper4 function was still in the back of my mind, and by my late 30's I had seen common threads between some of the other generalized functions Gamma (for the factorials), Barnes' G-function (for the lower superfactorial), and the K-function (for the hyperfactorials).

Eventually I decided to just put the assumptions down on paper and manually construct a function that would meet all of them. What I describe above is not wholly satisfactory because it requires a different bias K_x for each base x.

Hyper4 Iterated Exponential Function

Contents

Lower Hyper4 Function a_④b

An Exact Solution of the Inverses of a_④b

The Higher Hyper4 Function ("tetration") a↑↑b = a^④b

My Extension of the hyper4 Function to Real-Valued Arguments

Results

The Power-Tower Paradox

Finding Final Digits Using Modular Arithmetic

Interactive Exploration

A Lifetime Interest in hyper4

See Also

Footnotes

Hyper4 Iterated Exponential Function

Contents

Lower Hyper4 Function a④b

An Exact Solution of the Inverses of a④b

The Higher Hyper4 Function ("tetration") a↑↑b = a④b

My Extension of the hyper4 Function to Real-Valued Arguments

Results

The Power-Tower Paradox

Finding Final Digits Using Modular Arithmetic

Interactive Exploration

A Lifetime Interest in hyper4

See Also

Footnotes

Lower Hyper4 Function a_④b

An Exact Solution of the Inverses of a_④b

The Higher Hyper4 Function ("tetration") a↑↑b = a^④b