3.3.1_towers

3.3.1

Pandemonium With Power Towers

Introduction

            We begin our exploration of large number arithmetic with a look at power towers and their paradoxical properties. Besides creating numbers of impressive size, they also have a great deal of counter-intuitive properties which we will explore.

Deceptiveness of Exponents

            Before we delve into the mysteries of power towers, it's well to remember that even exponents are rather counter-intuitive. For example, take a guess at the value of:

1.567x1078 + 3.456x1064

            You may be trying to recall exponential laws, in which case you might think that you add the exponents and the answer would be something like 10142. Of coarse, that would be roughly the result of multiplying them, but here we are adding them, so by necessity it must be much smaller than that! Perhaps it increases the larger exponent by a few orders, perhaps about 1080 is the result. WRONG AGAIN! In fact, without performing a single computation I can safely say:

1.567x1078 + 3.456x1064 < 1.568x1078

            Notice, that the larger exponent doesn't even change! And mind you the actual answer would be even smaller! If this seems counter-intuitive, then it would be good to think in more native terms than scientific notation. Let's consider these numbers decimal expansions:

1.567x1078 = 1567000000000000000000000000 ... ... ... ... 00000000000 w/75 0s

3.456x1064 = 34560000000000000000000000 ... ... ... ... 0000000 w/61 0s

            Even though the exponents seem to be roughly in the same ball park, 1078 is actually a hundred trillion times more than 1064. Let's call the "ones place" the "zeroth column", the "tens place", the "first column", the "hundreds place" the "second column", and so on. In that case we can say that the "7" in 1.567x1078 is in the 75th column, and the "3" in 3.456x1064 is in the 64th column. If you think of these two numbers being added, you'll realize that the leading digit in the smaller number, is in a much lower rank column than the lowest ranked non-zero digit in the larger number. Therefore, the effect of adding the smaller number, won't even "flip" the 7 to an 8. Therefore 1.568x1078 is already a generous upper bound on the sum. In fact, based on this we can reach a seemingly strange conclusion.

if n < m then

10n+10m < 10m+1

            Regardless of what n and m are (we can assume they are real numbers without any lose of generality!). In fact:

10m+10m < 10m+1

            Actually we can go further:

10m+10m+10m < 10m+10m+10m+10m < 10m+10m+10m+10m+10m < 10m+1

            There are some bizarre consequences of this, which is that we can easily bound sums of exponential class numbers now with almost no computation necessary. For example, even if we use fractional exponents we can say that:

1016.75+1021.06 < 1022.06

            None of this is difficult to prove. Just assume n and m are real numbers. Now further assume that n is the smaller of the two. It follows then that:

10n+10m < 10m+10m

            Now observe that:

10m+10m = 2x10m < 10x10m = 10m+1

            In fact we can go further, and say that for a set of any 9 exponential numbers, the sum must be less than the highest exponent +1. Call the exponents x1, x2, x3, ... , x9, and assume that x9 is the largest exponent:

10x1+10x2+10x3+10x410x5+10x610x7+10x810x9

is less than or equal to

10x9+10x9+10x9+10x910x9+10x910x9+10x910x9 = 9x10x9 < 10x10x9 = 10x9+1

            So it seems no matter what we do, the sum of exponential numbers doesn't grow significantly from the largest exponent. However, with large numbers, there is seemingly an exception to every rule, but the exception is often just as surprising, if not more so, than the rule. For example if we take the sum:

1010+1010+1010+1010+1010+1010+1010+1010+1010+1010

            Which is 10 1010s then we get exactly:

1011

            If we add up a 100 1010s we get ... 1012 , if we add up a 1000 1010s we get 1013 and so on. Put that way it seems like we need to put in a lot of energy just to increase the exponent a little. That is mainly a testament to the compact nature of exponential notation. Remember, every time the exponent increases by 1, the number is becoming 10 times larger! Even when the exponent itself seems large, this is still the case. 10101 is still 10 times larger than 10100 or a googol. 10102 is a hundred times a googol, and so on.

            Trivially we can also establish the lower bound for the sum of two exponential numbers by saying it must be larger than the larger exponent:

10n+10m > 10m : n<m

(here " : " means "provided")

            In any case we will now establish the following as a lemma:

Sum of Exponentials Lemma (SEL)

10m < 10n + 10m < 10m+1 : n,m are real & n≤m

            An interesting feature of this lemma is that if we add multiple exponents together, computing an upper bound is dependent on the order we carry out the operations. For example:

1012+109+106+103 < 1013+106+103 < 1014+103 < 1015

            While this is certainly true, it's not a very tight bound on the original sum. To get the best bound using the sum of exponentials lemma (SEL) add up the exponents from smallest to largest:

1012+109+106+103 < 1012+109+107 < 1012+1010 < 1013

            Another strange feature is that the smaller exponent can get arbitrarily close to the larger, and it's still less than the larger exponent +1:

1012 + 1011.999999999999 < 1013

            We can also generalize this to allow for the subtraction of exponential numbers. However we have to be a little more careful in this case. For the most part subtracting a smaller exponent from a larger one, will result in a number larger than the larger exponent -1. For example:

1011-106 > 1011-1010 = 9*1010 > 1010

            However if we allow the exponents to be reals instead of integers, then the smaller exponent can get arbitrarily close to the larger and the difference can get arbitrarily close to zero. For example:

1013-1012.9995 ~ 10*1012- 9.98*1012 = 0.02*1012 = 2*1010 ~ 1010.301

            In this case the exponent decreased from the larger by more than 2. In even more extreme cases the difference can be as small as 1000 , 100 , 10 or even 1. The smaller exponent just needs to be close enough. So how do we figure out when the smaller exponent will or will not have a significant effect on the larger exponent?

            The trick is to use the addition property we just defined and transform it to obtain a subtraction rule. We begin with:

10m < 10m+10n < 10m+1 : n≤m

            Next we subtract the 10^n term:

10m-10n < 10m < 10m+1-10n : n≤m

            From the left side of the inequality we obtain the trivial truth:

10m-10n < 10m : n≤m

            For the right side define k := m+1. This implies m = k-1. We then obtain:

10k-1 < 10k - 10n : n≤k-1

            By combining the two statements we get our subtraction lemma:

Difference of Exponentials Lemma (DEL)

10m-1 < 10m-10n < 10m : n≤m-1

            So we can now say, without calculation that:

1012.56 - 1011.56 > 1011.56

            Alright, so we've established that exponents are really powerful, that adding them doesn't effect them much, and that subtracting a smaller from a larger won't effect it significantly unless the difference is less than 1. Now what happens if we multiply them. Say instead of adding the numbers from our original example, we multiplied them. Then we have:

(1.567x1078)(3.456x1064) < 8x10142

            To figure this out, we simply multiply the numbers 1.567 and 3.456 normally. Since 1.567 < 2 and 3.456 < 4 their product must be less than 8. We then add the exponents to obtain a new exponent. The addition of the exponents is basically one of the exponential laws:

10n * 10m = 10n+m

            It is interesting to note that multiplication has been reduced to a simple act of adding exponents. This makes arithmetic with some very large numbers fairly routine. For example:

1016 * 1032 * 1043 = 1016+32+43 = 1048+43 = 1091

            Consider arithmetic using roman numerals. Multiplying small numbers proves to be a hassle in that system, but in this system we can easily tackle numbers larger than the number of particles in the observable universe!

            Division of exponential numbers is also very straight forward:

10n/10m = 10n-m

            Example:

1048/1016 = 1048-16 = 1032

            Note, that even though we're dividing by ten quadrillion we still get the result 1032. Here is another example:

1021/1030 = 1021-30 = 10-9

            Here the final result is 10-9 = 0.000000001. So the quotient of large numbers can either be a very large number, a very small number, or even and ordinary sized number. Assuming both numbers are positive however, we know their quotient must be greater than zero.

            So we can now add, subtract, multiply and divide exponential numbers with ease, at least approximately.

            So what happens if you raise an exponential class number to some power. Say you square a number like a googol. What do you get? Is the square of a googol anywhere close to a googolplex? Let's see:

(10100)2 = 10100 * 10100 = 10100+100 = 10200

            As you can see, squaring will only double the exponent! Furthermore, cubing will only triple it, raising to the 4th power will quadruple it, etc. So exponentiation has been reduced to ... multiplication! If we agree that "exponents add" then it's easy to prove that raising an exponent to another exponent is equivalent to multiplying them. Simply observe:

(10n)m =

10n * 10n * 10n * 10n * ... ... 10n * 10n * 10n * 10n  w/m 10ns =

10n+n+n+ ... ... +n+n+n w/m n's =

10nm

(Note that this law applies even if n and m are real numbers.)

            So what would happen if we raised a googol to the tenth power?

(10100)10 = 10100*10 = 101000

            Wow! So if we raise a googol to the 10th power we get 1 followed by a 1000 zeroes.

            Now what would happen if we raised an exponential number to an exponential number! We would get:

(10^n)(10^m) = 10(n*10^m)

            In order to multiply n and 10^m we need to convert n to exponential form. For that we use the following logarithmic rule:

n = 10logn

            So we have:

10(n*10^m) = 10(10^logn * 10^m) = 1010^(m+logn)

            The upshot of this is that when we raise an exponential number to an exponential number we get a number with an exponential number of digits!

            Here is a concrete example:

(10^13)^(10^5) = 10^10^(5+log13) ~ 10^10^(5+1.1139) = 10^10^6.1139           

            As you can see the bottom exponent has far less effect than the top exponent. As another example we could have:

(10^134)^(10^12) = 10^10^(12+log134) ~ 10^10^(12+2.127) = 10^10^14.127

            Despite the fact that we have 134 at the bottom, it only accounts for about an increase of 2 in the "leading exponent" of the result. The "leading exponent" refers to the highest exponent in a stack of exponents. In Hyper-E notation it is the top most exponent that may or may not be equal to the base.

            This rule however does have an important caveat. When the exponent on the bottom is zero, something strange happens:

(10^0)^(10^12) = 10^10^(12+log0) = 10^10^(12+ERROR) = ERROR

            The logarithm of 0 (in any base) is undefined. Most calculators will give you an error message and would compute 10^10^(12+log0) as undefined. As it turns out, my TI-89 actually gives the correct output: 1. Why is the answer 1? Well since 10^0=1, we really have 1^(10^12). However, since 1 to any power is 1, 1^(10^12) = 1. So how does this equal 10^10^(12+log0)? To answer that we have to go a little beyond standard arithmetic and make some observations. We can define log0 as -∞ based on the observation that:

lim(x-->0+)logx = -∞       

            We can also define 10^-∞ based on the observation that:           

lim(x-->-∞)10^x = 0

            So if we allow infinities into our computation we can say that:

(10^0)^(10^12) = 10^10^(12+log0) = 10^10(12-∞) = 10^10^(-∞) = 10^0 = 1

            In any case, we can side step infinities all together if we just compute 10^0 first. So let's say our formula only applies when n>0.

            So what happens if we raise an ordinary number to an exponential power? Maybe we get an exponential class number? NOPE! It turns out, that it won't significantly result. For example, in the last example, let's say we replace 10^134 with something tiny like 2. Then we have:

(2)^(10^12) = 10^(log2*10^12) = 10^(10^loglog2*10^12) =

10^10^(12+loglog2) ~ 10^10^(12-0.5214) = 10^10^11.4786

            Turns out even when we raise an ordinary number to an exponential, you still get a number with an exponential number of digits! Even if take a number extremely close, but larger than, 1, we still end up getting large results. For example:

(1.001)^(10^12) = 10^10^(12+loglog1.001) ~ 10^10^(12-3.3624) = 10^10^8.6376

            The result still has more than 400 million digits! Yet if the base=1, the answer must be 1 no matter how large the power is! Let's see what happens if we apply logarithms in this case:

(1)^(10^12) = 10^(log1*10^12) = 10^(0*10^12) = 10^0 = 1

            So basically we can come to this conclusion. If the base is greater than 1, then:

(n)^(10^m) = 10^10^(m+loglogn)

Here is a summary of our results:

Exponential Arithmetic: Bounds and Laws

10m < 10n + 10m < 10m+1 : n≤m

10m-1 < 10m - 10n < 10m : n≤m-1

10n*10m = 10n+m

10n/10m = 10n-m

(10n)m = 10nm

(10n)(10^m) = 10^10^(m+logn) : n>0

(n)(10^m) = 10^10^(m+loglogn) : n>1

            These exponential laws will come in very handy and give us some grounding when we start working with more general tetrational class numbers. If you thought the exponential laws your counter-intuitive, well it only gets worse from here on! And if you didn't think the exponents were counter-intuitive, just wait ...

The 2nd Exponent

            The last section was just a warm up. Now that we've got a handle on exponents, let's explore the 2nd exponent. What's the "2nd exponent"? Basically it's the exponent of an exponent. For example:

1010N

               "N" is the 2nd exponent. The 2nd exponent has properties that are even more staggering than the ordinary exponent. For example, what happens when we add 2nd exponential class numbers (which I call double-exponentials, or hyper-exponentials). Let's add a googolplex to itself and see what happens:

1010100 + 1010100

                We know from the previous section that 10^m+10^m < 10^m+1. Therefore:

1010100 + 1010100 < 10(1+10100)

                It follows that a googolplex plus a googolplex is far less than 10^10^101. Of coarse, that shouldn't be surprising since it was true of ordinary exponents, so its even "more true" of the 2nd exponent. What would the effect of adding 1 to a googol be to the second exponent? Well firstly let's consider the actual effect of adding 10^99 to 10^100 using logarithms:

1099+10100 = 1099+10*1099 = 11*1099 = 10log11 * 1099 ~ 101.04 * 1099 = 10100.04

                So even if we add 1099 it only amounts to a 0.04 increase in the exponent! And it get's worse. We are only adding 1! So let's try a smaller value, say 1095. Then we have:

1095+10100 = (105+1) * 1095 ~ 105.000004 * 1095 = 10100.000004

                Incredible! At this point, if I get much smaller, say 1090 , then my calculator can't even compute the logarithm for me! So at this point some analysis is necessary.

An analysis of the Common Logarithm

                Let's look at some logs to get an idea for what is happening:

log2 ~ 0.301029...

log3 ~ 0.477121...

log4 ~ 0.602059...

log5 ~ 0.698970...

log6 ~ 0.778151...

log7 ~ 0.845098...

log8 ~ 0.903089...

log9 ~ 0.954242...

log9.1 ~ 0.959041...

log9.5 ~ 0.977723...

log9.7 ~ 0.986771...

log9.8 ~ 0.991226...

log9.9 ~ 0.995635...

log9.99 ~ 0.999565...

log9.999 ~ 0.999956...

            Notice a pattern? In all cases, if you multiply the result by 10, you get a larger value than you originally put in. This isn't always the case. For example, 10*log1.1 ~ 0.4139, so in this case the value is actually reduced. At some point however, the output exceeds the input. When does this occur? To find out we consider the two functions:

f(x) = 10*logx

g(x) = x

            First we want to find where the functions cross. So we begin with:

f(x) = g(x)

10*logx = x

logx = x/10

10logx = 10x/10

x = (101/10)x

x1/x = 101/10

            Although this might seem like a dead end it leads to one obvious solution: x=10. We can see that:

10log10 = 10(1) = 10

            The other crossing point can't not be obtained using these elementary methods, but we can approximate it based on the fact that both f(x) and g(x) are continuous functions. Therefore if we know that f(a)-g(a) is the opposite sign of f(b)-g(b) then we know that the crossing point must occur between "a" and "b". Call the crossing point x1 . I have approximated it as:

1.3712 < x1 < 1.3713

            Graphing f and g on the same axes reveals that there are only two crossings, and that f(x) is above g(x) only between the two crossing points x1 and 10:

            The red line is the linear equation g(x)=x, and the black line is the logarithmic equation f(x) = 10logx. Graphically we can now see why the result of the log times 10 is larger. What does this have to do with our previous problem? A lot actually. The fact that 10logx > x when x<10, and 10logx < x when x>10, provides us with a way to bound any common log of a number close to a power of 10.

            To convert these results into a form that will be useful for our problem, begin by assuming x is larger but very close to 10:

10logx < x : x>10

            Divide both sides of the equation by 10:

logx < x/10 : x>10

            Define k :=x/10. This implies x = 10k. Substitute accordingly:

log(10k) < k : 10k>10

            Divide the condition by 10:

log(10k) < k : k>1

            Expand and simplify the logarithm:

log(10k) = log10+logk = 1+logk

            Therefore:

1+logk < k : K>1

logk < k-1 : k>1

            Now define a := k-1. Note that since k is slightly larger than 1, a must be slightly larger than 0. It also follows that k = 1+a. Substituting we obtain:

log(1+a) < a : 1+a>1

            We now subtract 1 from the condition, and replace a with a new x to obtain:

log(1+x) < x : x>0

            This last statement is of great importance to our investigation, so make note of it. It basically allows us to place an upper bound on certain logarithms. We will also want to place a lower bound on log(1+x), and also find bounds for log(1-x) as well.

            The following graph contains a lot of useful information on these questions:

            The red line is y=x, the blue line is y=x/10, and the black line is log(1+x). All three functions cross the origin. This can be verified simply by plugging in zero. Let v(x) = x, and u(x) = x/10.

u(0) = 0/10 = 0

v(0) =0

log(1+0) = log1 = 0

            The function v(x) (what will serve as our upper-bound), represented by the red line, can be seen to cross the logarithm in only two places. One is at the origin, and the other is for some negative value of x. This can be approximated again by gradually bounding the value. I found that x and log(1+x) cross at -0.86287. So within the interval (-0.86287,0) x < log(1+x). Everywhere else x is larger (assuming that when log(1+x) is undefined that it's actually -∞). How can we be absolutely sure? Since I can't solve for the 2nd zero directly, the best approach I've found is to analyze the slope. One of the many results that calculus opens up, is that we can find an equation for computing the slope of a function at any point, for many elementary functions. In the case of log(1+x) the equation of the slope (known as it's derivative) turns out to be 1/((1+x)ln10). We know the slope of v(x) is 1 at all points. The slope of log(1+x) at 0 would be 1/((1+0)ln10) = 1/ln10 ~ 0.43429448. What this means is that at the point of intersection (0,0), the function x has greater slope than log(1+x). Furthermore, as x increases the slope of log(1+x) actually decreases, since the bottom term becomes proportionally larger. For example, the slope of log(1+x) at x=1 would be 1/((1+1)ln10) = 1/(2ln10) ~ 0.217147. This means that once x overtakes log(1+x) at (0,0), the logarithm never can catch up. This confirms our result that log(1+x) < x : x>0. We can also see that in the interval (-0.86,0) x < log(1+x).

            By a similar token we can analyze u(x) vs. log(1+x). Since the slope of u(x) = 0.1, we know that the logarithm has greater slope at the origin. Therefore it overtakes u(x). However, because the slope of log(1+x) is approaching 0, u(x) must eventually catch up. This happens somewhere around 10.671128. So we know that x/10 < log(1+x) on the interval (0,10.67). When x is negative however, we see that x/10 is always larger than log(1+x). So log(1+x) < x/10 : x<0.

            Combining these observations we can create the following important bounds on log(1+x):

Logarithmic Bounding Lemma (LBL)

x/10 < log(1+x) < x : (0,10.67)

x < log(1+x) < x/10 : (-0.86,0)

            In a nutshell, when x is very close to zero (either a little less or a little more), we can bound the logarithm. The considerable upshot of this will become apparent as we progress through the rest of this article.

The Deceptiveness of the 2nd Exponent

            Recall that we found the sum of 1099 + 10100 we had to find log11. We can now redo the calculation, but this time we can set it up so that we instead have to "compute" (estimate), log1.1:

1099 + 10100 = 1099 + 10*1099 = 11*1099 = 1.1*10100 = 10log1.1 * 10100 = 10100+log1.1

            Normally this is the point at which log1.1 would be punched into a calculator, but we now have a way to estimate it without one! Simply observe that log1.1 = log(1+0.1). 0.1 becomes our x, from the Logarithmic Bounding Lemma (LBL). Since 0.1 is between 0 and 10.67 we can apply the first inequality. Therefore:

0.01 < log(1+0.1) < 0.1

            This means that:

10100.01 < 10100+log1.1 < 10100.1

            Punching 100+log1.1 into a calculator I obtain 100.04139..., so you can see that this number lies between 100.01000..., and 100.10000...! Let's now test our lemma on 1095+10100:

1095 + 10100 = 1095 + 105*1095 = (105+1)*1095

            Rather than try to compute log(105+1), we can convert the expression into a form that allows us to apply of logarithmic bounding lemma (LBL) again. Simply factor out 105:

(105+1)*1095 = 105(1+10-5)*1095 = (1.00001)*10100 = 10100+log(1.00001)

            Again, applying our lemma we have:

10100.000001 < 10100+log(1.00001) < 10100.00001

            Again, punching 100+log(1.00001) into a calculator I obtain 100.000004343 (this is in fact the most digits that my TI-89 can display). This value does in fact lie between 100.000001000 and 100.000010000. "So what" you might say. If I can punch it into a calculator, why do I need to go through all the trouble of developing a way to get an estimate?! The reason is because I will reach the limits of my calculators precision long before I get to compute 10100+1. Here are some results using my calculator to make the point clear:

10100+10100 = 10100.301029996

10100+1099 = 10100.041392685

10100+1098 = 10100.004321374

10100+1097 = 10100.000434077

10100+1096 = 10100.000043427

10100+1095 = 10100.000004343

10100+1094 = 10100.000000434

10100+1093 = 10100.000000043

10100+1092 = 10100.000000004

10100+1091 = 10100 (TI-89)

10100+1090 = 10100 (TI-89)

...

            As you can see the calculator estimates the sum as no larger than a googol when the other term is 1091 or smaller. We have to go all the way down to 10100+1 however! The great thing is that the logarithmic bounding lemma (LBL) applies no matter how small the number we are adding to 10100 and allows us to get an estimate. You may notice that in the above results that the little extra bit keeps getting roughly 10 times smaller. This pattern continues indefinitely, and the value is always sandwiched between our bounds.

            So now we can compute 10100+1:

10100+10^-101 < 10100+1 = 10100+log(1+10^-100) < 10100+10^-100

            So it turns out that:

1010100 + 1010100

is less than ...

1010100.000000000000000000000 ... ... ... ... ... ... ... ... 0000000000000000000000000001

w/99 zeroes after decimal point

            So adding a googolplex to itself barely changes the leading exponent at all! It's much worse than when we added a googol to itself and obtained 10^100.301. We can now generalize our results so that we can add any two double-exponential numbers. Firstly note that if x is a real number then:

1 < 1010x < +∞

            This is because x must be between negative and positive infinity so 10^x must be between 0 and positive infinity, and 10^10^x must be between 1 and positive infinity. Now assume n and m are real numbers and n is less than or equal to m. We want to bound the sum:

1010m + 1010n

            Trivially:

1010m < 1010m + 1010n

            To obtain an upper-bound is more work. We begin by using logarithms and LBL to compute a complex upperbound:

            In order to simplify this bound to something manageable, simply observe that the difference 10n-10m must be negative or zero since n is less than or equal to m. Therefore we can remove it and say:

            This provides us with an elegantly simple upper-bound for adding double-exponential numbers! There is actually a much easier way to prove this. Since n is less than or equal to m we can simply say that:

1010m + 1010n ≤ 1010m + 1010m < 10(1+10m) [SEL] =

10 10log(1+10m) = 1010log[(10m)(1+10-m)] = 1010(m+log(1+10-m)

 < 1010m+10-m [LBL]

            What this means is that as long as n is smaller than m their sum is guaranteed to change the leading exponent of the larger by less than 10-m. Example:

10109 + 10108.996 < 10109.000000001

            In fact the sum is even smaller than this, and we can use the tighter bound appearing in our first proof to show just how extreme this is:

108.996-109-9 < -9,168,064

            So in fact we can also say with certainty that:

10109 + 10108.996 < 10109+10-9,168,064 =

10 109.000000000000 ... ... ... ... ... ... ... ... 00001 w/9,168,063 zeros

            Mind you, this is still an upper-bound! We used LBL twice in the proof to obtain this bound, which means the actual value must be even closer to 9! It's mind boggling! And this is only the deceptive nature of the 2nd exponent. It's only going to get worse from here. What's impressive about this, is that we were able to obtain these bounds with very minimum computation, and yet they are quite accurate. For example:

10109.000000001 ~ 101,000,000,002.3 ~ 199*10109

            What this means is that if our lower bound is N, the upper bound is 199N and the actual value lies somewhere between the 2. That is extremely accurate considering we are dealing with a number with a billion and one digits. I can't even compute this number with the big number calculator which only goes up to 999,999 digits of accuracy!

            In any case, we can now establish a "Sum of Hyper-Exponential Numbers Lemma" (SHNL):

Sum of Hyper-Exponential Numbers Lemma (SHNL)

Assume n≤m , and n,m are real numbers:

Super-Weak Bounds

1010m < 1010m+1010n < 1010m+1

Weak Bounds

1010m < 1010m+1010n < 1010m+10-m

Strong Bounds

1010m < 1010m+1010n < 1010m+10-m+(10^n-10^m)

            We can also establish a difference bound, but again when you subtract you can get almost any result. However, assuming that n is no more than m-1 we can establish a bounding rule. Admittedly though, it is somewhat confusing since it involves negatives, negative exponents and bounds all at the same time o_0;

            None the less I am fairly confident that the following bounds are correct:

Difference of Hyper-Exponential Numbers Lemma (DHNL)

Assume that n≤m-1, and n,m are non-negative real numbers*:

Super-Weak Bounds

1010m-1 < 1010m-1010n < 1010m

Weak Bounds

1010m-10-m < 1010m-1010n < 1010m

Strong Bounds

1010m-10-m+(10^n-10^m) < 1010m-1010n < 1010m

*Interestingly the inequalities are not valid for all real numbers. However provided that m > -0.4756327... the first inequality is true. If m > -0.4985407... the second inequality is true, and if m > -0.4930836... the third inequality is true. Therefore as long as m >= 0, all the bounds must be true.

            Note that we can now add and subtract any real numbers, and develop bounds or estimates, as long as the numbers involved are hyper-exponential or lower. To add an exponential number to a hyper-exponential number just convert 10^n to 10^10^logn. To add an ordinary number, n, which is greater than 1, simply convert n to 10^10^loglogn. The Lemmas doesn't cover a number between -1 and 1, because it can't be expressed in double-exponential form, but we could certainly still use the LBL to develop an estimate if we wanted to.

            So what would happen if we multiplied hyper-exponential numbers. Sure the change in value is miniscule when we add and subtract them. That's to be expected! But what happens when we multiply them. Surely that must have a noticeable effect. Well let's see:

1010m * 1010n = 10(10m+10n) < 1010m+1 [SEL]

            When we multiplied exponential numbers we found that the exponents add. With 2nd Exponents we see that the effect on the larger 2nd exponent is much smaller, regardless of how close the smaller 2nd exponent is. In fact, this isn't even a particularly good bound on the product. We now have the sophistication that we can actually improve on this result. To do so we simply make use of LBL:

1010m * 1010n = 10(10m+10n) = 1010log(10m+10n) =

 1010m+log(1+10n-m) < 1010m+10n-m [LBL]

            Notice how many LBL is at allowing us to create this bounds. This is a better bound on account of the fact that m is greater than n, and therefore n-m must be negative and 10n-m must be less than 1. You'll notice this looks very similar to the weak bound in SHNL. This value however is slightly larger because "n" is offsetting -m. Let's compare the sum and difference using our best current bounds:

10109 + 10108.996 < 10109+10-9,168,064

10109 * 10108.996 < 10109+108.996-9 = 10109+10-0.004 ~

10109.99083

            There is a world of difference between the product and the sum. The effect of the product however is a little deceptive in this case however. The large effect is mainly due to the fact that the smaller power tower is so close to the larger (relatively speaking. In truth the larger number has about ten million more digits making it about 1010,000,000 times larger!). However the effect is significantly reduced is there is some distance between the second exponents. For example:

101016 * 10109 < 101016+109-16 = 101016+10-7 ~

101016.0000001

            and remember we are multiplying the numbers, yet the smaller power tower barely has an effect on the larger. Still, we know that the product must be much larger than the sum of these numbers. In fact it turns out to be fairly easily to prove that:

x+y < xy : x,y>2

            In other words, the sum of two real numbers, x and y, is less than their product if they are both greater than 2. To prove this we assume that:

x := 2+c

y := 2+d

            Because we are assuming x,y>2, it follows that c,d>0. Now we examine the sum:

x+y = (2+c)+(2+d) = 4+c+d

            Now simplify the product:

xy = (2+c)(2+d) = 4+2c+2d+cd

            Now we wish to establish:

4+c+d < 4+2c+2d+cd

            Simply carry out some algebraic simplification:

c+d < 2(c+d)+cd

            Now c+d must be less than 2(c+d) and cd>0 because c,d>0. Therefore the right must be greater than the left! Thus we know that as long as two numbers are both greater than 2, their product must be larger than their sum. (Please note however that just because one of the numbers is not greater than 2 does not imply that the product is not greater than the sum. For example take 1.8 and 2.4. Their sum is 4.2 yet their product is 4.32. Also, it's not always the case that the product is greater than the sum. For example the sum of 1 and 2 is 3, but their product is only 2. All we have proven is that if both are greater than 2, then their product is guaranteed to be larger.)

            Since 10^10^16 and 10^10^9 are both much much larger than two, it follows that their product must be greater than their sum, and the upper bound on their product, is also an upper bound on their sum. You might be thinking "so what" but this result will come in handy when we deal with taller power towers.

            In any case, let's proceed to find how to divide hyper exponential numbers. Firstly we have:

1010m/1010n = 10(10m-10n)

            Again, a result like this can really come out to be just about anything. It might be a large number when m is at least 1 greater than n, it might become a number of almost any size less than 10^10^m. The result however must be greater than 1 (this is true of all numbers of the form 10^10^x where x is real). As usual we will place the restriction that n<=m-1. In this case we can use DEL to obtain bounds:

1010m-1 < 10(10m-10n) < 1010m

            We can also get tighter bounds using LBL:

10(10m-10n) = 1010m+log(1-10n-m)

implies...

1010m-10n-m < 1010m/1010n < 1010m-10n-m-1 [LBL]

            It should be noted that according to LBL these bounds won't apply if 10^(n-m) > 0.86. Assuming that n is at most m-1, we can say 10^(n-m) = 10^(m-1-m) = 10^(-1) = 0.1. Therefore as long as n<=m-1 these bounds apply.

            So now let's look at what happens when we raise a hyper-exponential number to an ordinary power. For example let's try:

(101086)5 = 10(5*1086) = 101086+log5 ~ 101086.699

            This is a surprisingly modest value considering that we are multiplying 10^10^86 by it's 4 times. What happens when we use our weak-upper-bound for products. How does this compare to the calculated value:

(101086)5 = 101086*101086*101086*101086*101086 <

10 1087*101086*101086*101086 <

10 1088*101086*101086 <

10 1089*101086 <

10 1090

            So our weak bound is quite off. Let's try using the strong bound this time:

(101086)5 = 101086*101086*101086*101086*101086 <

10 10(86+1086-86)*101086*101086*101086 =

10 10(86+100)*101086*101086*101086 =

10 1087*101086*101086*101086 <

...

< 10 1090

            In this case our strong-bound fails us as well. Our bounds work, but it turns out that they aren't quite as good at measuring the product as it might have seemed. In fact:

101086*101086 = 10(1086+1086) = 101086+log(1+1) = 101086+log2 ~

101086.301

            The reason for the discrepancy is because LBL is not a very good bound when x is relatively large. Although it's still valid as long as x>0, it's accuracy as a bound becomes very questionable as x becomes very large (greater than 1). For example:

0.9 < log(1+9) < 9 [LBL]

            Yet log(1+9) = log10 = 1. So while the upper bound is correct, it's not very accurate. In any case, when the leading exponents in the product are closer than 1, we can actually compute the logarithm directly, so this will be the preferred method for very close values (unless a rough estimate suffices).

            We can generalize the power result as:

(1010m)n = 1010m+logn

            Now let's raise a hyper-exponential to an exponential number and see what happens. That's bound to have a significant effect:

(1010m)(10n) = 10(10m*10n) = 1010m+n

            So in this case we simply add the leading exponents. Now what about what happens when we raise a hyper-exponential number to a hyper-exponential power:

(1010m)(1010n) = 10(10m*1010n) = 101010n+m <

 101010n+m*10-n [LBL]

            To obtain a lower-bound simply observe that (10)^(10^10^n) < (10^10^m)^(10^10^n).

            To complete our ability to perform hyper-exponential arithmetic, we will also want to see what happens when the base is exponential, or an ordinary number, and it's raised to a hyper-exponential power:

(10m)(1010n) = 10(m*1010n) = 1010(logm+10n) <

101010n+logm*10-n [LBL]

(m)(1010n) = 10(logm*1010n) = 1010(10n+loglogm) <

101010n+loglogm*10-n-1 (assuming 1<m<10)

&

101010n+loglogm*10-n (assuming m>=10)

 [LBL]

            We can see that the positive effect to n becomes less and less significant. Assuming m is at least 1 in every case (so as to justify the numbers status as hyper-exponential, and exponential) we can say that having an exponential number in the base will either have no effect if m=1, and if m>1 then it will have a marginal positive effect. For example:

(10100)(10104) < 1010104+log100*10-4 = 1010104+2*10-4 =

1010104.0002

            When we have a base that is less than 10, the top exponent is actually effected negatively. This is because the double-log of a number less than 10 must be negative. For example:

(2)(10104) < 1010104+loglog2*10-4 ~ 1010104-0.52*10-4 =

10 10103.999948

            Despite how small the base is, as you can see it only has a very minor effect on the leading exponent.

            Let's now gather all of this information into a set of rules for working with hyper-exponential numbers:

Hyper-Exponential Arithmetic

1010m < 1010m+1010n < 1010m+10-m+(10n-10m) :n=<m

1010m-10-m+(10n-10m) < 1010m-1010n < 1010m  :0=<n=<m-1

1010m < 1010m*1010n < 1010m+10n-m :n=<m

10 10m-10n-m < 1010m/1010n < 1010m-10n-m-1 :n<=m-1

(1010m)n = 1010(m+logn)

(1010m)(10n) = 1010m+n

101010n < (1010m)(1010n) < 101010(n+m*10-n) :m < 10n

  101010n < (1010m)(1010n) < 101010(n+10n/m) :10n =< m

101010n < (10m)(1010n) < 101010(n+logm*10-n) :m>1,n>=1

(m)(1010n) < 101010(n+loglogm*10-n-1) :1<m<10

(m)(1010n) < 101010(n+loglogm*10-n) :m>=10

            Seem like a bit much?! Relax. We are now going to generalize these kinds of results to power towers of any height, and come up with a simple rule of thumb that will enable us to quickly estimate the effect on the leading exponent with confidence.

Generalizing to Power Towers of any height

            To generalize the results for standard operations performed on power towers of any heights, we first use LBL to create a much simpler rule that we can always apply. Observe that:

10m+n = 10log(10m+n)

            Assume for argument sake that n < 10m, so that we can apply LBL under the assumption that it will be a decent upper bound. It then follows that:

10log(10m+n) = 10log[10m*(1+n/10m)] = 10[log(10m)+log(1+n/10m)] =

 10[m+log(1+n*10-m)]

            We now apply LBL to obtain:

10[m+log(1+n/10m)] < 10(m+n*10-m)

            Note that this statement is valid even if m and n are themselves power towers. We can therefore skip all of these lengthy steps and establish the following rule:

RULE OF ASCENSION  [ROA]

10M + N < 10(M + N/10M)

            The upshot of this statement may not be immediately apparent, but the following example should make it abundantly clear.

            Say we wanted to bound (estimate) the leading exponent of:

10101034 + 1

            What would have seemed like an intractable problem at the outset (since we'd have to find the triple logarithm of this number) now becomes a cinch to estimate. Simply apply the Rule of Ascension [ROA] to "ascend" the positive factor up the power tower:

            Better yet, we can make this even simpler! We can discard 10^10^34 and 10^34 in the denominator, and still maintain an upper-bound. This is because by removing them we are actually making the fraction larger, and thereby the leading exponent larger. We can therefore say:

10101034 + 1 < 10101034+10-101034

            So we find that by adding 1 the leading exponent must increase by less than the reciprocal of the original number. In fact this result can be generalized to any power tower! As long as the number is at least 10 the statement proves to be a good bound:

10 + 1 < 101.1  (according to our bounding rule since 0.1 is the reciprocal of 10)

10 + 1 = 11 = 10log(11) = 101.04139...

            The statement remains true as long as the number we are adding 1 to is positive. However, the sum is approaching 1, while the bound actually ends up diverging to infinity. For example, take 0.1 as the positive number:

0.1 + 1 = 10-1 + 1 < 10-1+10 = 109 = 1,000,000,000 (according to our bounding rule)

However...

0.1 + 1 = 1.1 = 100.04139...

            The bound is therefore not useful when the number is less than 10. This isn't really much a concern however, because when the number is less than 10 we can easily compute the sum. The concern is when the number is very large, making the sum impossible to compute (or store). However we can now very quickly find bound for lots of similar problems. For example:

10100 + 1 < 10100+10-100

10 10100 + 1 < 1010100+10-10100

etc.

            We now have a rule that is incredibly logical and simple for estimating these kinds of sums. What if we want to add something other than 1? Not a problem. This just means the numerator in the original example would become whatever value we were adding. If we add 2 to a power tower, the leading exponent increases by 2 times it's reciprocal, if we add 3 then 3 times the reciprocal, etc. Thus we come to this general conclusion about the sum of any two power towers:

Let A = 10^10^ ... ^10^x

Let B = 10^10^ ... ^10^y

Assume that A =< B

B+A < 10^10^ ...^10^(y+A/B)

            Note that when A=B the upper-bound becomes:

B+B < 10^10^ ... ^10^(y+B/B) = 10^10^ ... ^10^(y+1)

            Actually this isn't a very accurate bound, especially when B is a large power tower. For example:

10101034 + 10101034 = 2*10101034 =

 10(101034+log2) ~

10 (101034+0.30102999) < 10101034+0.3012999*10-1034

            Our bound however would give us the value of 10^10^10^35. However the actual value will have at least 10^34 zeroes following 34.0000000000000000... before you see any non-zero digits! So be wary of bounds when the smaller power tower is extremely close to the larger one. However this will almost never be the case unless your adding the same number to itself. For even better results you can in most cases drop A out of the fraction entirely and replace it with 1. As long as A =< logB and B is a power tower with at least two 10s, you can simply add the reciprocal of B and ignore A entirely!

            To understand why, we need to look at the smallest possible example. Let B = 10^10^1 (the smallest power tower with at least two 10s). This means the maximum value for A can be log(10^10^1) = log(10^10) = 10.

            Now let's try adding them now:

10101 + 10 < 10101 +10/10101 [ROA]

< 10101+10/(1010*10) [ROA]

            We can now cancel out the 10 in the numerator and denominator and we are left with:

10101+10-10

            So as long as we're dealing with at least exponential numbers greater than 10^10, and the smaller number is at most the log of the larger, all we need to do is add the reciprocal of the larger power tower to it's own leading exponent!

            We can also use this same reasoning to come up with a general rule of thumb for what to do when the smaller power tower is greater than the log of the larger one. Again we will assume a height of at least two 10s. Let's also assume A=B:

10101 + 10101 < 10101 +10101/10101 [ROA]

< 10101+1010/(1010*10) [ROA]

            This time we cancel out the two 1010s instead. We would therefore be left with:

10101+10-1

            So if A > logB then we simply add the reciprocal of logB to Bs leading exponent. There. Adding power towers is now a breeze! The remarkable thing about this is that the difference in the leading exponent is tetrationally small, even when the number being added is tetrational! Another remarkable thing about this, is that we are able to prove these bounds even though we can never compute these numbers completely!

            We will now gather these elegantly simple results into a single Lemma:

Sum of Power Towers Lemma [SPT]

            Let A,B>=10. Assume that A = 10^10^ ... ^10^x , where there is at least one 10 and x>=1. Assume that B = 10^10^ ... ^10^y, where there is at least one 10 and y>=1. Furthermore assume that A=<B. We can then say:

B+A < 10^10^...^10^(y+A/B)

            Furthermore, if B has at least two 10s we can apply the following bounds:

B+A < 10^10^...^10^(y+1/B) : A=<logB

B+A < 10^10^...^10^(y+1/logB) : A>logB

           We can essentially achieve the same result for subtracting of power towers. However, instead of producing upper bounds, we produce lower bounds (Recall LBL to understand why). This is a good thing, because we can easily obtain an upper bound (if necessary) simply by assuming that the difference B-A < B (which is basically a given). It's therefore a lower-bound that is of interest to us when subtracting. So here is of difference of Power towers lemma:

Difference of Power Towers Lemma [DPT]

            Let A,B>=10. Assume that A = 10^10^ ... ^10^x , where there is at least one 10 and x>=1. Assume that B = 10^10^ ... ^10^y, where there is at least one 10 and y>=1. Furthermore assume that A=<B. We can then say:

B-A > 10^10^...^10^(y-A/B)

Furthermore, if B has at least two 10s we can apply the following bounds:

B-A > 10^10^...^10^(y-1/B) : A=<logB

B-A > 10^10^...^10^(y-1/logB) : A>logB

            We can easily solve A-B as well using DPT. The we simply take negative of the absolute difference:

A-B = -(B-A)

            The bounds must consequently be changed from lower-bounds to upper-bounds.

            These results are surprising at first, but upon reflection it can be seen that this result is actually quite natural and could be anticipated by the fact that the log(1+x) can be approximated by a linear equation when x is very close to zero. Therefore the change in the leading exponent reduces to something very very very close to linear!

            Perhaps it's not surprising that the leading exponent is barely effected by the act of adding power towers. What about multiplying them? That's bound to have a much greater effect right?

            To determine how to multiply power towers, we will again begin by assuming we have two power towers, A and B, such that A=<B. For convenience I will use a concrete example:

10101034 * 10101027 = 10(101034 + 101027)

            Right off the bat we see that multiplication reduces to a problem of adding power towers. But we now know how to add power towers, so we simply apply SPT:

10(101034+101027) < 10101034+(10^10^27)/(10^10^34)

             So this time we take the ratio of the logarithms of the power towers. This means a significantly smaller effect. However, from a certain point of view this really isn't much of an improvement. The change will still be tetrationally small when we multiply large tetrational numbers together, so multiplying doesn't create much of a boost in the leading exponent. We can also eliminate logA from the equation all together as long as the larger power tower has at least three 10s. So we can now multiply power towers as follows:

Product of Power Towers Lemma [PPT]

            Let A,B>=10. Assume that A = 10^10^ ... ^10^x , where there is at least one 10 and x>=1. Assume that B = 10^10^ ... ^10^y, where there is at least one 10 and y>=1. Furthermore assume that A=<B. We can then say:

B*A < 10^10^...^10^(y+logA/logB)

Furthermore, if B has at least three 10s we can apply the following bounds:

B*A < 10^10^...^10^(y+1/logB) : A=<logB

B*A < 10^10^...^10^(y+1/loglogB) : A>logB

            To find quotients of power towers we again will use a concrete example:

10101034 / 10101027 = 10(101034 - 101027)

            So we must apply DPT here. This means we will be obtaining lower-bounds. This leads us to:

Quotient of Power Towers Lemma [QPT]

            Let A,B>=10. Assume that A = 10^10^ ... ^10^x , where there is at least one 10 and x>=1. Assume that B = 10^10^ ... ^10^y, where there is at least one 10 and y>=1. Furthermore assume that A=<B. We can then say:

B/A > 10^10^...^10^(y-logA/logB)

Furthermore, if B has at least three 10s we can apply the following bounds:

B/A > 10^10^...^10^(y-1/logB) : A=<logB

B/A > 10^10^...^10^(y-1/loglogB) : A>logB

            Note that we can also use QPT even if the larger power tower is in the base: A/B. We simply need to compute the reciprocal of B/A:

A/B = (B/A)-1

            Because we are taking the reciprocal we must again reverse the bounds from lower-bounds to upper-bounds.

            Lastly we want to use everything we've learned to solve the problem of raising one power tower to the power of another. Because exponentiation is not commutative we have to pay attention to whether the larger power tower is in the base or the exponent. It doesn't actually matter which one we try first because the results of one order can be used to apply to the other, but let's try placing the larger number in the base for starters. The reason I'm making this choice is because it will reveal a very nice progression.

            Again, it's best to work with a concrete example to help understand what's going on. We'll use an example where A < logB:

(10101034)(1034) = 10(101034*1034) = 1010(1034+34)

            This simply follows from the exponential laws. To estimate the leading exponent we apply ROA:

1010(1034+34) < 101010(34+34*10-34)

            So even though we are raising to the power of 10^34 the leading exponent is still 34.00000000000000......... followed by at least 32 zeroes! Note that 10^-34 is the reciprocal of loglog(10^10^10^34). Does this pattern continue if we use higher power towers? Let's see:

(1010101034)(1034) = 10(10101034*1034) = 1010(101034+34)

< 10 1010(1034+34/(101034)) [ROA]

< 10101010(34+34/(10^10^34*10^34)) [ROA]

            Note that the ratio 34/10^34 < 1. Therefore if I remove both from the fraction, I will actually be increasing it's value Thus we conclude that

(1010101034)(1034) < 10101010(34+10-1034)

            As you can see, the leading exponent increases by less than 10^(-10^34). Note that this "anti-power tower" has two less 10s than the base of 10^10^10^10^34. This is because we end up adding the logarithm of the exponent (10^34), only at the third exponent. This effectively chops off the first two 10s. So we can basically observe that the leading exponent increases by the quotient of the logarithm of the exponent and the double logarithm of the base. We can see this will only become more the case as the power tower grows. However we have to be careful about generalizations. Let's see what happens if we try it for smaller power towers. Let's say the base is a power tower with only two 10s:

(101034)(1034)

            According to the rule we just established we should get the log of 10^34 times the double log of 10^10^34. However since:

log(1034) = 34

&

loglog(10 1034) = 34

            This means the bound we'd obtain would be:

1010(34+34/34) = 101035

            This bound turns out to be VERY wrong! The actual value is much larger:

(101034)(1034) = 10(1034*1034) = 101034+34 = 101068

            Note that in this case, this is the exact value, and it's much larger than predicted. The reason for this is because our rule assumes that the power tower in the base is high enough that once we get to the stage of adding, the leading exponent is still a ways off. However in this case the addition occurs at the leading exponent. This isn't really a problem however, since we already have ways of dealing with hyper-exponential numbers as covered in the previous section. So our rule only applies when the power tower in the base has at least three 10s. This ensures that there is at least an exponential number in the second exponent.

            So we've established that our rule works as long as the power tower in the base is tall enough. However we must also be wary of the power tower in the exponent. When it begins to approach the scale of the base it does end up having a drastic effect. Basically the effect is very minimal as long the exponent is less than or equal to the logarithm of the base. In this case the effect must be less than adding 1 to the leading exponent. When the base and the exponent are equal however, something interesting happens to the base. Take Skewes' Approxima again as an example:

(10101034)(10101034) = 10(101034*10101034) =

10 10(1034+101034)

< 10 1010(1034+(1034)/(10^10^34)) [ROA]

< 10 101010(34+(10^34)/(10^10^34*10^34)) [ROA]

= 10 101010(34+1/10^10^34)

            The effect on the base was not minor this time. The height of the power tower actually increased by 1! Interestingly the effect on the leading exponent is still minor (it just get's shifted up). This begs the question: when does the exponent end up having such a drastic effect?! When the exponent is less than or equal to the logarithm of the base then the effect on the leading exponent is increased by less than 1. When we raise the base to its own power however the leading exponent itself becomes exponential. Somewhere in the middle would be an moderate sized increase. So let's try something larger than the log of Skewes' Approxima, but not by much:

(10101034)(10101000) = 10(101034*10101000) =

10 10(1034+101000)

< 10 1010(1000+10-966) [ROA]

            Interestingly, the leading exponent in the result basically becomes the leading exponent in the exponent (1000). This means we can obtain any value desired in the leading exponent simply by changing the leading exponent in the exponential power tower. Note however that we don't really need to come up with a special case for this however because:

(10101034)(10101000) =

10(101034*10101000) = 10(10101000*101034)

= (1010101000)(101034)

            Set up this way we now have an exponential power tower which is less than the logarithm of the basal power tower. Therefore we can simply apply our rule and we would take the logarithm of 10^10^34 and divide it by the by the double-logarithm of 10^10^10^1000. Thus:

1034/101000 = 10-966

            The same increase as we saw above. We can even apply this switching technique when the base and exponent are the same:

(10101034)(10101034) = (1010101034)(101034)

            When this switch out occurs, the exponent will always end up being the double-logarithm of the base. We can there apply our rule.

            It turns out that we really only need to consider exponents which are equal to or less than the logarithm of the base. If the exponent is larger than the base, we can simply switch out the exponents so that the base becomes larger instead. Just like we were able to discard the numerator with the earlier operations we will also be able to do that here. The main requirement is simply that the basal power tower needs a minimum of four 10s. This may seem like a lot but remember that we're dealing with exponentiation this time, so we need some room to work with.

            Taking all these facts it is possible to establish the following lemma for exponentiating power towers:

Exponentiating of Power Towers Lemma (EPT)

            Assume that A = 10^10^ ... ^10^x , where x>=1. Assume that B = 10^10^ ... ^10^y, where y>=1 (Note: A may =x & B may =y). Furthermore assume that A=<B.

            When the basal power tower is larger the following bound applies provided that B contains at least three 10s:

B^A < 10^10^ ... ^10^(y+logA/loglogB) : A=<logB

            When the basal power tower is larger the following bound applies provided that B contains at least four 10s:

B^A < 10^10^ ... ^10^(y+1/loglogB) : A=<logB

            If the exponential power tower is larger the following bound applies provided A>=10 and B contains at least two 10s:

A^B < 10^(10^10^...^10^(y+loglogA/logB))

            If the exponential power tower is larger the following bound applies provided A>=10 and B contains at least three 10s:

A^B < 10^(10^10^...^10^(y+1/logB))

            By switching out exponents the above rules can be applied to any situation as needed.

            We can actually even figure out how to apply roots to power towers. Since the nth root of x is also the same as x^(1/n), it follows that if we wanted to find the (10^10^10)th root of 10^10^10^34 we could simply try and solve:

(10^10^10^34)^(1/(10^10^10)

            By applying the exponential laws however we can obtain:

(10^10^10^34)^(1/10^10^10) = 10^(10^10^34/10^10^10) = 10^10^(10^34-10^10)

            From there we simply apply LBL:

10^10^(10^34-10^10) > 10^10^10^(34-10^10/10^34) = 10^10^10^(34-10^-24)

            We can even figure out how to work with logarithms where the base is a power tower. Firstly observe that:

log10(10^10^10^34) = 10^10^34

            Taking the base-10 logarithm of a power tower reduces it's number of 10s by one. Now observe, that any power tower can be expressed as 10y where y>=1. Say we want to find the base-10y logarithm of a power tower, where 10y is itself a power tower we then have:

log10^y(10^10^10^34) := x

such that (10y)x = 10^10^10^34

            Taking the logarithm of both sides:

xy = 10^10^34

            We then solve for x:

x = (10^10^34)/y

            This implies that in general the logarithm will be the logarithm of the power tower we are taking the logarithm of divided by the logarithm of the base. As a concrete example say we want to find the (10^10^10) base logarithm of 10^10^10^34:

log10^10^10(10^10^10^34) = (10^10^34)/(10^10) = 10^(10^34-10)

            This can be approximated using LBL:

10^(10^34-10) > 10^10^(34-10*10^-34)

            For an upper-bound on the logarithm just observe that:

log10^10^10(10^10^10^34) < log10(10^10^10^34) = 10^10^34.

            So there you have it. We now have the means to estimate the sum, difference, product, quotient, power, root, and logarithm of any pair of power towers. One of the things that I find very appealing about these results is that they tie the very very large together with the very very small. In our attempt to understand large integer arithmetic we also ended up exploring rational and real numbers! In fact even complex numbers came up in my analysis at one point. It is for example possible to interpret the logarithm of negative numbers as complex numbers. It turns out that:

log(-x) = logx + iπ/ln10 : x>0

                This can be obtained from euler's identity:

eiπ = -1

            This implies that:

ln(-1) = iπ

                Furthermore by applying the base change rule we can obtain a value for log(-1):

log(-1) = ln(-1)/ln10 = iπ/ln10

                One can then apply the law of logarithms to factor out the negative to obtain:

log(-x) = log(x) + log(-1) = logx + iπ/ln10

            The upshot of this is that we can treat negative logs as well defined values instead of undefines. It then becomes meaningful to say that:

10log(-1) = -1

            In fact, even without euler's identity we could accept this as a definition, and it would allow us to interpret certain results that would otherwise be considered erroneous, similar to how we interpreted log(0) as negative infinity to make sense of it.

Closing Statements

            Robert Munafo brought to my attention the work of Clenshaw & Olver. They developed a special data format for large numbers which they refer to as the Level-Index system. It is similar to Robert Munafo's PT-notation for power towers. Apparently Clenshaw & Olver's idea was to create an alternative number format to floating point numbers, and also develop a Level-index arithmetic system. Given that the Level-index system is designed for computer systems I am pretty sure that the computations on the leading exponent are only carried out for a small number of decimal digits. The results that I have obtained would not show up in such computations simply because you'd have to compute up to a tetrational number of decimal digits to actually see the effect! That's really the most mind blowing thing about these results. That, and the fact that they were not terribly difficult to obtain. The lemmas SPT, DPT, PPT, QPT, and EPT can be used when subtle calculations are needed, and they can also serve as the foundations for theorems and proofs.

            You may wonder now: if we can add, multiply and exponentiate power towers, couldn't we also tetrate them? What would that result in?! That will be the topic of another article ... and we will go beyond that to establish an important and powerful lemma that can be used to prove that the Moser is much less than Graham's Number...

Home > 3.3 >