I just got done creating some really big numbers with my kids (see http://alistair.cockburn.us/crystal/articles/frbn/fugareallybignumbers.html). Had fun coming up with the brand-new function
''fuga(-)'' to get a faster growing function than any I knew of, so we could say "Fuga(googolplex)."
''Fuga''(N) is N to the Nth power N times, so
''fuga''(2) is 2^2, ''fuga'' (3) is 3^3^3, etc.
You can see how this grows. -- AlistairCockburn  

Since the ^ operation is not associative, i.e. (x^y)^z != x^(y^z), this begs the question whether Fuga(3) means (3^3)^3 = 19683 or 3^(3^3) = 7625597484987. Probably the latter, since the goal is to get big numbers. Otherwise the name could be <<Megafuga>> -- StephanHouben

Thanks, Stephan, I had in mind (3^3)^3, which is in line with building a big number from the bottom up. You deserve a neater name than Fuga for the computing in the other order (I'm curious as to how old my kids will have to be to understand it). My coffee buddy suggested Megafuga. I put in Megafuga in your text above... change it if you come up with something better. -- AlistairCockburn

(p.s. after reading the appends that showed up within hours of my posting, I am humbled, amazed and in awe of math again for the first time in decades. Thanks, folks.) 

(p.p.s. In an interesting turn of events, the American Physical Society found and published the article in their April 2001 (!) online news bulletin, http://www.aps.org/apsnews/0401/040111.cfm)
----
according to Perl 5.6
  fuga(1) = 1
  fuga(2) = 4
  fuga(3) = 19,683
  fuga(4) = 3.40282366920938 e+38 (340282366920938463463374607431768211456)
  fuga(5) = Infinity (Too long expand out... ~7.18 e+436)
-- AndyJewell
-----
''I have a faster function: start with 2, then do fuga(2) get your answer, in witch case is 4 , then do fuga((your answer)) (in this case fuga(4))witch, would give you 340282366... then do fuga of that huge number! And so on)''
----
Given that definition, I get the following numbers using Python's bignums:
  Megafuga(1) = 1
  Megafuga(2) = 4
  Megafuga(3) = 7,625,597,484,987
Megafuga(4) = 4 ^ 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096 = approx. 4 ^ 1.34e+153

''(I note that Megafuga(4) is somewhat larger than 4^googol.)''
The number 1.34e+153 is considerably larger than estimates about the number
of electrons, protons and neutrons in the visible part of the universe (the number of protons is only estimated to be 1e80 [NickKeighley]).
Since the number 4 ^ 1.34e+153 will require a number of digits in the order
of 1.34e+153, we can safely say that computing all digits of megafuga(4) will
never happen.

-- StephanHouben
-----

What would be the biggest number that could be represented in full using all the particles, photons and space in the known universe? I would have thought that each particle can represent a fir number of bits using its velocity, spin and locations dimensions. -- AndyMorris

----
''Never happen? Nonsense! Here they are: 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. (Some assembly required.)''

	 :	That's a very Platonic idea. However, all information must have some corresponding representation in reality. They aren't just "floating in the aether." If the number requires more bits than there are particles in the universe, there is no way to express it directly. However, that being said, the format we use to represent numbers is really just a vector function. It might be legitimate to say that the number is represented by such and such function with so and so parameters. If you can express the function and its parameters in far fewer bits of information, say in the few dozen bits used above, then the number itself is information light. That is, you can "compress" it by expressing it as the function with the parameters.

	 :	On the other hand, there is some amount of information that's being hidden by mathematical convention. This is where the ''Principia'' comes into play. But even then, how do you represent an axiom? -- SunirShah
-----
KenMulligan, my coffee buddy, said that he notices this big-number-competition between boys of all ages, but not girls. He says he thinks its an early gender related competition (already in place by age 5). -- Alistair
----
The AckermannFunction generates functions and applies the generated function to numbers. Officially:
 ack(i,j) =
	j + 1		 if i = 0,
	ack(i-1, 1)		if i > 0 and j = 0,
	ack(i-1, ack(i, j-1)) otherwise.

Just try to compute ack(4, 4). You are allowed to use a computer.
Not that it will help you much...

''Got it! Grokking the AckermannFunction. Just lousy variable naming conventions, that's all. The first argument describes the '' level ''of the function being described. Relabeling and Currying, we get a function generator operating on a function-level argument, and the resulting function applied to a specific number. This is great - I actually have been looking for such a thing for a looonnng time. -- AlistairCockburn''

 Ackermann(level,n) =  Ackermann[level](n)

 Ackermann[0] (n) is increment(n), actually  (n+1)
 Ackermann[1] (n) is add2to(n), actually  (n+2)
 Ackermann[2] (n) is double(n), actually  (2*n+3)
 Ackermann[3] (n) is 2exponentiatedBy(n), actually  2^(n+3)-3
 Ackermann[4] (n) is tetrate(n) or similar to Megafuga(n)
 Ackermann[5] (n) is quintate(n)
 etc., so
 Ackermann[100](n) is centate(n),
 whatever wicked function centate(_) turns out to be
''(Alistair -- you might want to see a JayLanguage exposition of the AckermannFunction at:''
	http://www.jsoftware.com/papers/ack.htm
''And if you want a complete copy of J, it is now available free for the downloading from the same site!)''

''(And after reading that exposition, I withdraw any claim I might have made about grokking Ackermann functions!! -- AlistairCockburn)

Redefining with these unconventional but more comprehensible labels:
 Ackermann[level] (n) =
	if level = 0	then n + 1
	elseif n=0	then Ackermann[level-1] (1)
	else		Ackermann[level-1] (Ackermann[level](n-1))

For level=4, Megafuga and Ackermann are still in the same league. But for larger
numbers, Ackermann grows much much faster than Megafuga. Megafuga is just
repeated exponentiation (called tetration by SunirShah). But for level = 5,
Ackermann starts doing "quintation" (repeated tetration). and for level = GoogolPlex, it does the googolplexation.

see my fast grower near the top of the page where it says (.pps. I would like to use mega fuga in sted of fuga to help in my function
KevinKostlan made this function.

From a theoretical computing science point of view, Ackermann is really in
a different league than Megafuga. Megafuga is still primitive recursive,
whereas Ackermann is computable but not primitive recursive anymore.

-- StephanHouben

If you have a lisp system and some memory to burn, you can play with this using something like (there are more efficient ways to do this)
     (defun ack (m n)
	(cond ((zerop m) (1+ n))
	      ((zerop n) (ack (1- m) 1))
	      ((ack (1- m) (ack m (1- n))))))
----
Consider tetration (verb ''to tetrate''), from the Greek for four (tetra) as it is fourth in order: addition, multiplication, exponentiation, tetration. It is traditionally rendered as

 y
   x
Just as in exponentiation, except you put the superscript to the left. It is associative top down, so 2 tetrated to the 4th is:

 4
  2 = 2^(2^(2^(2))) = 2^(2^(4)) = 2^(16) = 65536
-- SunirShah

With this notation, the closed form of Megafuga becomes simply:

		n
 Megafuga(n) =	n
Similarly, plain old fuga is just:

		(n-1)*n
 Fuga(n) = n
-----
'''Question:''' Isn't Fuga(n) actually

		n^(n-1)
 Fuga(n) = n

That's what I get. -- AlistairCockburn
-----
''Gadzooks! I feel totally outdone (although, how, of course, could I possibly compete with professional mathematicians who spent decades playing with really big functions)! That my '' Fuga(-) ''is so lowly as to not deserve a name, being a mere approximation to n^(n^2), is a shock, but actually a pretty happy one, since it points to the next embellishment.''

''That the '' Megafuga ''not only already has a name but even already a fixed notation is wonderful. And it doesn't reduce flat as Fuga suddenly did.''

''The AckermannFunction bothers me, because it is a function of two variables, and we'd be interested in functions of one variable. Surely there must be a name for Ackermann(n,n) for whatever n. Knackered_Man(n) = Ackermann(n,n)?? Or,'' Gag(n) ''for short? And that +, *, ^ progression... does it generate new functions as it goes? Is that what tetration and quintation mean? Thanks for all this'' -- AlistairCockburn
-----
Consider the progression addition, multiplication, exponentiation, tetration. First, consider addition:

 2 + 2 + 2 + 2
This can be written 2 * 4. Next, consider multiplication:

 2 * 2 * 2 * 2
This can be written 2^4. Next, consider exponentiation:

 2^(2^(2^(2))))
This can be written 2 tetrated to the 4th. Similarly,

 2
  2
	2
	2
can be written 2 quintated (*) to the 4th. Working top down, we have

 2	 2
  2	(2 )	4
	2	=	2  = ( 2)  = 65536  = a really huge number
	2	 2	2	2
2 quintated to the 3rd is 65536, by the way.

We can go further, working with the progression to sextation (**) and further. But who really wants to go further than sextation? -- SunirShah (*) 5 = quinque in Latin; (**) 6 = sex in Latin.

P.S. Notice how 2 [operation] 2 = 4 always. Cool!

''One nitpick. The prefix tetra- comes from Greek, not Latin. So we should stick to Greek. I learned the following table, not during Greek, but during Chemistry: mono = 1, di = 2, tri = 3, tetra = 4, penta = 5, hexa = 6, hepta = 7, octa = 8, ennea = 9, deca = 10.''

''See NumericalPrefixes''
----
How about something like this:

 F(n) =	1	  for n=1
	  n^(F(n-1)!)	for n>1
A witless program I wrote spits out:

 N	F(N)
 1	1
 2	2
 3	9
 4	Infinity (really a mere 4^362880)
Call it the expostfacto function. Not quite in the Megafuga league by N=4, but it does grow quickly. -- TomKreitzberg

''I love the name, "expostfacto", I almost think you thought up the function just to fit the name! -- AlistairCockburn''
-----
(I can't let this one go. Why bother with something puny as factorial(n) when we have Gag lying around (besides the cute name)? Playing the five-year-old game, what's Mag(n) = Gag(Gag(...(n))? As many Gags as N, to get it back to a function of one variable. Or as many Gags as Gag(n), or as many Gags as Mag(n)...)

''The game is more interesting if you can do it without referring to another non-elementary function, or at least not another function mentioned previously at ''any'' time previously during the game.''

OK. much tougher. I'll learn to withhold primitive recursive retorts.
----
A function that grows much faster than Gag is Rado's Sigma-function, also known
as the busy beaver function. See: http://www.drb.insel.de/~heiner/BB/ for an explanation.

Rado's Sigma is, however, uncomputable. It can be shown to grow faster than any computable function.

-- StephanHouben

"Grows faster" is an interesting turn of phrase. The initial numbers are way smaller than what Ackerman produces. Once the tape gets long enough to replicate Ackermann's function, then it grows as least as fast, rather by definition. So, yes, it grows faster.

(From the cited page: ''The function Sigma(n) denotes the maximal number of tape marks which a TuringMachine (TM) with n internal states and a two-way infinite tape can produce onto an initially empty tape and then halt.''
 Sigma(1) = 1
 Sigma(2) = 4 
 Sigma(3) = 6 
 Sigma(4) = 13 
 Sigma(5) >= 4098
 Sigma(6) >= 2,537,699,363,594,175,843,063
 Sigma(8) >= 8*10^44 

Unverified results claim that Sigma(6) > 6*10^462
----
Is that really an infinite tape? Or is it just an unbounded one?
----
Something else that might amuse aficionados of ReallyBigNumbers is what's
called "Graham's number". It's defined like this.

	1.	''a''^''b'' means "''a'' to the power ''b''".
	1.	''a''^^''b'' means "''a'' to the ''a'' to the ''a''..., ''b'' times" (grouped as for "Megafuga")
	1.	''a''^^^''b'' means "''a''^^''a''^^..., ''b'' times". And so on.
	1.	Now, write ''N''1 = 3^^^^3. (This is already frighteningly huge.)
	1.	Write ''N''2 = 3^^...^^3, with ''N''1 ^ signs.
	1.	Write ''N''3 = 3^^...^^3, with ''N''2 ^ signs. And so on.
	1.	Graham's number is ''N''64.

This staggeringly large number is an upper bound, found by R L Graham and B L Rothschild, for the answer to the following mathematical problem: What dimension does a hypercube graph need to have in order that, if you colour its edges in two colours, there will be four vertices connected by edges of a single colour?.

Oh, and it's generally believed that the actual answer (the one for which ''N''64 is the best known upper bound) is 6.

-- GarethMcCaughan

''I love it! I use this story as a party joke! (at the right kind of parties, of course)''

RamseyTheory is full of theorems like that. For instance, see VanDerWaerdensTheorem.

----
In BON (''Book of Numbers'' by Conway & Guy, ISBN 038797993X) Knuth's '''arrow notation''' is extended to their ''chained arrow'' notation.
 ''a'' --> ''b'' --> ''c'' stands for ''a'' ^^...^^ ''b'', ''c'' times a  ^

Furthermore
 ''a ... x'' --> ''y'' --> ''(z+1)''
is defined as
	''a ... x''							if ''y''= 1,
	''a ... x'' --> ''(a ... x'' --> ''(y - 1)'' --> ''z'') --> ''z''		if ''y''> 1.
Then they show that
 1, 2 --> 2, 3 --> 3 --> 3 
agree with the first 3 Ackermann numbers, but
 4 --> 4 --> 4 --> 4  = GC(4)
is very much larger then Ack(4) which is only
 4 --> 4 --> 4.
Their sequence CG(n) equals
 n --> ...--> n  ''n''times 
delivers extremely large numbers. Graham's number for example is less than
 3 --> 3 --> 3 --> 3, 
so definitely less than CG(4).

-- R.E. BOSS

----

Some definitions:
 
 exp(r,n) = r exponentiated n times, left-associative
 fuga(n+x) = exp(n+x,n) ^ ((n+x) ^ x) where n is integer and 0 <= x < 1
 fugarithm(a) = b iff fuga(b) = a
What is the fugarithm of 1000?

-- SteveHowell

I computed it to be ~2.824793.

----

How about this one: (a bit hard to render in ASCII though)
	* ''n'' written in a triangle = ''n'' ^ ''n''
	* ''n'' written in a square = ''n'' in ''n'' triangles
	* ''n'' written in a circle = ''n'' in ''n'' squares.

For example:

2 in a square = 2 in 2 triangles = 2^2 in a triangle = 4^4 = 256

2 in a circle = 2 in 2 squares = (2 in 2 triangles) in a square = ((2^2) in a triangle) in a square = (4^4) in a square = 256 in 256 triangles = an extremely big number.

-- TristanSeligmann

''One thing that delighted me when I was younger is that even though it's impossible to compute that exact value of 2-in-a-circle, and nobody will ever have a clear idea of how big it is, because it's just Too Big, it is quite trivial to show that it must end in the digit "6".'' -- MarkJasonDominus

----

Ahh the beauty of the Internet! I started out this rainy Sunday morning looking for a particular watch on the Internet, when 10 or so hyperlinks later I found myself smack in the middle of reading about extremely large numbers on this very page.
 
After intently reading down through it, I began to scribble numbers on a scrap of paper while looking through the various posts. As I neared the bottom of the webpage, I noticed the statement "Rado's Sigma is, however, uncomputable. It can be shown to grow faster than any computable function." Followed by the various levels and growth patterns:
 
     Sigma(1) = 1
     Sigma(2) = 4 
     Sigma(3) = 6 
     Sigma(4) = 13 
     Sigma(5) >= 4098
     Sigma(6) >= 2,537,699,363,594,175,843,063
     Sigma(8) >= 8*10^44
 
After scratching and scrawling numbers for a few minutes, I had come up with my own functions, one of which is virtually uncomputable by the second level. The two functions are "ban(n)" and "rban(n)" - (Big Ass Number and Really Big Ass Number... I know, not likely to make it into the annals of Mathematics history with a naming convention like that but it's just for fun anyway).
 
Ok, here goes...
 
ban(n) = n to the nth tetration OR: 
   n
    n
   n
ban(2) would look like the following:
   2      
    2
   2
Which equals 2^(2^(2^2)) = 2^(2^4) = 2^16 = 65,536

Similarly..... ban(3) = 3^(3^(3^(3^3))) = 3^(3^(3^9)) = 3^(3^19683) = 1.5054164145220926243143298033399e+9391
 
To take this to another level, we use "rban".
 
rban(n) = n to the nth tetration n times
  
rban(2) would look like the following:

 (2
   2)
     2
      2
     2
The closest I can get to computing rban(2) is....

 (16
    2)
     2
    2
The resulting number is larger than any app on my PC can compute, by just the second level!!!!!

rban(3) would look like the following:

 (3
   3)
   (3
     3)
      3
       3
      3
....and so on and so on.

Let me know what you think, and again thanks for making me think!!!

Matt Leach (mjleach@swbell.net)

----

Your definitions of ban(n) and rban(n) are not completely clear to me. Could you attempt to write it a bit more formally. As far as I understand,
"rban(n) = n to the nth tetration n times" means n^(n quintated with n).

With that definition, I find that rban(2) = 16, but this is clearly
not what you are getting. The expression

 (2
   2)
     2
      2
     2
is presumably to be parsed as 2 ** ( tetra(tetra(2,2), tetra(2,2) )), i.e.
2 ** (tetra(4,4)) = 2 ** (4** 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096).

Anyway, as far as I understand it, ban and rban are "simple" compositions of
tetration  and quintation, which means that they are still primitive recursive.
They cannot really compete with Ackermann, I'm afraid...

-- StephanHouben
----
So I was thinking about large number which actually could possibly somehow correspond to actual real physical world phenomena. Like this. So take the entire space of the universe, and imagine that it was filled *solid* with atoms or subatomic particles. The number of those particles would be huge, I wonder what it'd be. But, now, what about all possible permutations of those particles in space. I guess that'd be N! where N is the number of particles. Someone figure out the number! It's gotta approach or exceed Googol, or even Googolplex. Yathink?
----

So how's about factorials? If we define x!n (the nth level factorial of x) as x!n-1 * x-1!n-1 * ... * 2!n-1 * 1!n-1, and x!0 = x, then regular factorials are of the 1st level. Calculating factorials of 4 for the first couple of levels, we get:
  4!0 = 4
  4!1 = 4 * 3 * 2 * 1 = 24
  4!2 = 4! * 3! * 2! * 1! = 4 * 3 * 2 * 1 * 3 * 2 * 1 * 2 * 1 * 1 = 24 * 6 * 2 * 1 = 288
  4!3 = 4!2 * 3!2 * 2!2 * 1!2 = 4! * 3! * 2! * 1! * 3! * 2! * 1! * 2! * 1! * 1! = 288 * 12 * 2 * 1 = 6912
  4!4 = 4!3 * 3!3 * 2!3 * 1!3 = 6912 * 24 * 2 * 1 = 331776
Also note that x!n = x-1!n * x!n-1

Of course we could define a function called the Torian, where T(x) = x!x, which would give pretty big numbers as well, but my math is not good enough to prove that it's faster or slower than any of the other functions on this page. --AalbertTorsius
----
It appears that content of this page has been picked up elsewhere... at http://michaelhalm.tripod.com/mathematics_beyond_the_googol.htm on a page called Googology, and with the subtitle ''Andr� Joyce Fan Club (rated #1 googology website by Ask Jeeves/Teoma and Netscape and given 4 stars by ixquick.com)'' we find the section 

''"Young Kieran Cockburn named a googolplex googolplex or googolplex squared a "gargoogol" = 10^200. His father, Alistair Cockburn added the prefixes fuga-, gag- and mag-. and named Stephan Houban's prefix megafuga-." '' , and ''"Stephan Houban estimated megafugafour = 4^^^2 = 4(3^)2 = 4^^4 = 4^4^4^4 > 10^10^153 and claimed "We can safely say that computing all the digits of megafugafour will never happen.",  to which Sunir Shah responded with "Never happen? Nonsense! Here they are: 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. (Some assembly required.)" "''
----
See also http://www-users.cs.york.ac.uk/~susan/cyc/b/big.htm for representation of Ackeman's function using both Knuth's and Conway's funny arrow systems (and the triangle system).
---------------------------------------------------------------------------------------------------

in response to
"
So I was thinking about large number which actually could possibly somehow correspond to actual real physical world phenomena. Like this. So take the entires space of the universe, and imagine that it was filled *solid* with atoms or subatomic particles. The number of those particles would be huge, I wonder what it'd be. But, now, what about all possible permutations of those particles in space. I guess that'd be N! where N is the number of particles. Someone figure out the number! It's gotta approach or exceed Googol, or even Googolplex. Yathink? "

to who ever wrote this, I happily report that the permutation N! well exceeds a Googolplex, and furthermore, with probability and all the possible histories of a finite time, you can easily produces Googolplex's that describe real physical things(if you believe in parallel universes.). In any case, Googolplex is within the realm of things of practical scientific use, which means, it's not so big as we once thought.

This is how I solved his permutation problem. I packed the entire universe solid with strings, the smallest possible physical objects, they are only 10^-35 metres long. The plank length is the smallest unit of physical space, and is at the same order of magnitude, so by determining the volume of the universe in cubic plank lengths, I am determining the maximum number of strings that can fit.

the diameter of the universe is roughly 10^26 metres.so the difference in magnitudes is 
(10^26) / (10^-35) = 10^61. cube this and we get 10^183, which exceeds a googol. so all the possible arrangements of these strings in distinct spaces, (with no overlaps) would be 
(10^183)!

using a special factorial approximation [''Stirling's Approximation'' -- see http://mathworld.wolfram.com/StirlingsApproximation.html] I learned

N! ~ [sqrt:(2pi)] x  [ e^(-N) ] x [N^(N + 1/2)]

Note: N! < N^N upperbound. The first term in the equation is a constant: sqrt:(2pi)~ 2.506628
the second term is a very small number, which drags the function down, however the third term is a very very large number and easily cancels out the small number of the second term. This is because the third term contains 2 variables while the second only has one, thus the equation grows just under the function N^N.

The answer comes out roughly to

                                      185
                   1.82565705518 x 10
2.50662827463 x 10

which is basically 10^(10^185) which exceeds the googolplex 10^(10^100).
Now here's the fun part. Although the number on the left doesn't seem that much bigger than googolplex, there is a huge gulf between them and googolplex becomes point sized in comparison.

Imagine a humongous endless seemingly infinite universe which has a Googolplex particles in it, (you can think of it packed solid.) this would dwarf our own universe unimaginably. we call this The Googolplex universe.

Now imagine that this huge endless infinity is only a mere particle in another even more grand universe with a googolplex such particles! We call this the Googolplex universe of the second order. Now imagine the second order universe as a mere particle in a third order googolplex universe. Now imagine a 4th order a 5th, a 6th, a 7th , a 8th, 9,10,11,12,13,14,15,16,17,18,19,20, ... ... ,100,101, ... ... 999,1000,1001,1002, .... 2000, .... ... .... 10,000 ..... 99,999 , 100,000 , ... ... dizzy yet ... .. .    .....     .....         .....          .....

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000
order googolplex universe. The googolplex has been humbled by itself countless times, it's a point, or rather a point contained within a point. You have to remember that the first exponent has this same deceptive property. 10^267 might not seem that much more than 10^232 but the former is 10^35 times larger than the former. well the second exponent is ever more so deceptive. in general though it should be understood that 10^10^(x+1) is greater than 10^10^x. like this, the latter number raised to the tenth equals the former.

Actually, I went even further then the original writer went in terms of creating the ultimate "practical Number" I wanted to find all the possible universal histories from the Big Bang to the ultimate end of everything (Big Crunch or ever-expansion).

So the permutation N! is but a single possible moment, a single plank time, 10^-43 seconds. So 2 plank times would be another set of N! thus, (N!)^2. Now I let the universe run for 500 Quadrillion years (about a million times longer than the whole history so far.) the end result is

10^(10^245)

this number represents all imaginable histories you could ever create in the history of the whole universe, it is the ultimate reality upper bound, the ultimate practical number. I've even coined a useful name for this value, and I would like it to be known as it's originator. I termed this number as "Promaxima" which refers to "Probability Maximum". Promaxima is more a scientific number than mathematical, and therefore it's true exact value is yet to be known, my estimate of 10^(10^245) is an upper bound for Promaxima, since it makes many simplified assumptions (mainly for calculation reasons) which break the rules of physics. For example, let's say during some plank time a string is at one point in the universe then in the next it to a point one million light years away. That means that the string was traveling faster than the speed of light, which is impossible. Also there are much less than 10^183 strings in the universe(packed solid), when it's probably more like 10^80(less than a googol sadly). So Promaxima is most definitely less than my value. Still my value has the practical purpose of creating (a slightly blurly) dividing line between practical numbers, and boundless large numbers that are purely imaginary. 

The interesting thing though is, the Googolplex is not a Chimera, it actually exists. The googolplex's days are numbered.

-- Sbiis Saibian

-----------------------------------------------------------------------------------------------------
Today, I wrote that thing:

Let f<sup>n</sup>(a)=f(f(f(f(....a....)))) , f recursively repeated n times. <sup>something</sup> stands for superscript,like in html. (sorry, have no time, that's my last edit)

f[1](a)=a<sup>a</sup>

f[2](a)=f[1]<sup>f[1](a)</sup>(a)

f[3](a)=f[2]<sup>f[2](a)</sup>(a)

and so on.

f[1,1](a)=f[0,a]<sup>f[0,a]</sup>(a)

f[1,2](a)=f[1,1]<sup>f[1,1]</sup>(a)

and so on.

f[1,1,1](a)=f[a,a]<sup>f[a,a]</sup>(a)

g[1](a)=f[a,a,a,a,a... a times]<sup>f[a,a,a,a,a... a times](a)</sup>(a)

and so-on for h,i,j....z

(hope it was clear enough what I mean by "so-on".)

My number is z[1](1e6) or z[1](Googolplex), who cares. 
Shortly after writing it, I searched the web to find what big numbers others have defined, and have found that great page.

So, have I defined biggest number ever defined, and fastest-growing function? 
f[n,n,n](n) for n=Googolplex (or even n=2) looks __a lot__ bigger than anything I can see there. I can define even bigger numbers, unimaginably bigger. (say, instead of f,g,h...z I can use numbers (and then use some really big number instead of z). I can repeat method of making functions grow bigger on itself, then repeat repeating, and so-on (some big number times so-on). )

I originally wrote that thing in response on some other unrelated forum, where everyone started playing "name big number" game, and it reminded me some idea I had long ago (when I was a child), about defining fastgrowing function, repeating it on itself many times, repeating such repeating many times (using it to define "many"), and so-on (so-on really many times ,and so-on again :-) )

Excuse my English.

-- Dmytry Lavrov.
----

RubyLanguage handles unusually large integers - 

 def factorial (number)
     if number > 1 then
         number = number * factorial(number - 1)
     end
     return number
 end

 factorial 511
=> 67915816272121198501621990577062592031098645618037393952001461553742390860670948114711129889443403391490672521683866122127930019935560354
15315490493377694167162341094623363024629705069482370340382583639770604852051025007751078900881260986563780387150814624735226968735284198421
62562552418127764020680024482968790598268496243866679650323673581738094319089505549970142184801621850269613925335550243686896669960050310521
37252444342490533124025366601421787877162183318929120898905676153739676450022119554216006019111503245787889480514223303990661603585222902809
83056581139061975203268409517227097628503565293915173375016842772033992420027954613231165519595348486928597217331364955500576411208445051037
47698321968549791225387464757972194717258638273203703524026896110956010053969587186130935220793485519208765935248804175472350417314243815598
06483665425737450956215200571101573797878962406687241226979994202334868501452557598616171246609570457183183187330877615923910695499050822536
55735352487467721745688171632993384895972134402595566932459520000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000

(fact 512 blows the stack)
----
For numbers with a large but 'sensible' number of digits, the Unix mathematical language 'bc' - also known as GNU bc - is handy for calculations:

define factorial(x) {
 auto i,xx
 if(x<0)return(0)
 if(x<2)return(1)
 xx=1;for(i=x;i>=1;i--)xx*=i
 return(xx)
}
factorial(1000)
factorial(1000)
402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

You can do the same in DeeCee (I have written factorial in it), but it has no looping and a platform-dependent limit on recursion. -JesseMillikan

PuffyJon: A World Of Large Numbers:

So, Sbiis Saibian created Hyper-E, eh? (lol, get it?) Well, I made a better version, that extends beyond it, as well as changing the beginning!

Hyper-E Notation is defined as:

Ea#b = (10^a)^(10^a)^(10^a)...^(10^a) w/ b (10^a)s

Examples:

E1#1 = 10
E1#2 = 10^10 = 10,000,000,000 = diamom
E1#3 = 10^10^10 = 10^10,000,000,000 = diamomplex / triamom
E1#4 = 10^10^10^10 = 10^10^10,000,000,000 = diamomduplex / triamomplex / tetramom
E1#5 = 10^10^10^10^10 = 10^10^10^10,000,000,000 = diamomtriplex / triamomduplex / tetramomplex / pentamom
.....
E1#10 = 10^10^10^10^10^10^10^10^10^10 = diamomoctaplex / triamomsepttaplex / tetramomsexplex / pentamomquinplex / hexamomquadraplex / heptamomtriplex / octamomduplex / ennamomplex / decamom
To Be Continued...

----
TEST
----
See also: FloatingPointCurrency
-----
CategoryMath