zlacker

>>jeremy+(OP)
It seems notable that so many different variations of "naming large numbers" all end up mapping iterated applications of a function into a new function that takes a number of iterations as a parameter. Knuth's up-arrow notation defines iterated exponentiation, iterated iterated exponentiation, and so on. Ackermann's function makes the number of up-arrows just a numeric parameter to the function.

But you could go further than that: A(A(10)) is much bigger than A(1000), so you can get larger numbers faster by iterated applications of the Ackermann function. Turn the iteration into a function, and let B(n) be n applications of A to n. Iterated application of B would be even faster, so turn that iteration into a function: let C(n) be n applications of B to n.

But this process itself is iterative. So, define a new function: let iterA(n) be the nth level of iterated Ackermann functions applied to n, where iterA(1) is A(1), iterA(2) is B(2), iterA(3) is C(3), and so on.

Now, iterA can be applied iteratively. So, repeat again. The resulting function can be applied iteratively, so repeat again.

And this whole process of turning iteration into a function and then iterating that function is itself an iterative process, so it can be turned into a function...

>>JoshTr+Og
In your notation B(n)=A[n](n), where [] denotes the number of iterations. So C(n)=B[n](n)=(A[n])[n](n)=A[nn](n), so really iterA(n)=A[n^n](n). I you repeat this procedure with iterA, then you get iterA2(n)=A[n^(n^n)](n) . While n^n, n^n^n and so on are definitely fast growing you are better of putting A into []. So you can write an extremely fast growing function as f(n)=A[A(n)](n). So one can improve your strategy by using the [] notation, resolving the recursion and putting large functions inside.

And of course my method can improved with iterations that also can be resolved by creating a new notation. It's really never ending.

A[A[A(n)](n)](n)

And it's all computable, so the Busy Beaver grows faster than any* of these.