Computable functions

=computable function= A computable function, is a function that can be calculated by a Turing machine, and therefore can be calculated by turing complete computational system. Computable functions can be used in googology to make very big and well defined numbers.

Ackermann function
The Ackermann function is a function that is one of the simplest non primitively recursive functions. This functions rule sets are simple.

A(0, n)        = n + 1

A(m + 1, 0)    = A(m, 1)

A(m + 1, n + 1) = A(m, A(m + 1, n))

The Ackermann function usually only has 2 arguments, but can have one argument by doing A(n, n) = A(n).

code for obfuscated Ackermann function (in python)
def A(m,n): if m==0:return n+1 elif n==0:return A(m-1,1) else:return A(m-1,A(m,n-1)) i=int(input) print(A(i,i))

g sequence
The g sequence was constructed to be able to create Graham`s number, which is used for a problem in ramsey theory. Here are the rules:

g(0)   = 4

g(n + 1) = 3↑g(n)3

Grahams number is g(64).

conway chained arrow notation
Conway chained arrow notation is a simple notation, that uses a set of rules to reduce chains of numbers into very large numbers. Here are the rules:

Rule 1 (only two numbers): a→b = a^b

Rule 2 (last number is 1): #→1 = # where # denotes the rest of the chain (chop off the ending 1)

Rule 3 (second last number is 1): #→1→a = # where # denotes the rest of the chain (chop off the last two numbers)

Rule 4 (otherwise): #→a→b = #→(#→(a-1)→b)→(b-1) (decrease last number by 1, feed chain with second last number decreased by 1 into the second last number)

These rules make it so that x→y→z = x↑zy and 3→3→65→2 is bigger than graham`s number.

beklemishev`s worms
Beklemishev`s worms are similar to the mythological hydra, but instead of regrowing heads, it regrows segments of it's body. Although it might feel like these worms are impossible to kill without doing something else (like how Hercules cauterized their heads). It is in fact possible to kill these worms without doing anything but the rules to slowly kill these worms. How long will it take... the function that describes the amount of steps necessary to kill a one part worm of n number, is as fast growing as ƒε 0 (n). That means that a one part worm of only 3 number, could possibly take longer than Graham`s number of steps to kill. B(n) is faster growing than any function provable in peano arithmetic (first order arithmetic).

code for simplified Beklemishev`s worms function (in python)
cl = [int(input('input: '))] def kfinder: RI = 0 cp = len(cl) for i in range(0, len(cl)): cp -= 1 if cl[cp] < cl[-1]: RI = 1 return cp         break if RI == 0: return 'n' def next(m): global cl global g  if cl[-1]: if kfinder == 'n': g = [] b = cl[:(len(cl) - 1)] b.append(cl[-1] - 1) else: g = cl[:(kfinder)] b = cl[(kfinder + 1):(len(cl) - 1)] b.append(cl[-1] - 1) g += b     for i in range(0, m): g += b     cl = g  else: cl.pop s = 1 step = 0 s += 1 while cl: step += 1 next(s) s += 1 print('output is ' + str(step))

TREE sequence
The TREE sequence is a big number that arises in graph theory. The sequence arises from this, suppose we need to make a sequence of graphs where the number of nodes in each graph is equal or less than the number in the sequence this graph is in. The graphs are only allowed to have n-labeled graphs, and must allow any graphs before in the sequence to be inf-embeddable. TREE(n) outputs the longest a sequence like this can go with n-labeled graphs.

TREE(n) is faster than any function provable in ACA0 +Π12-BI which is a sub-system of second order arithmetic and is more powerful than first order arithmetic.

buchholz hydra
Buchholz Hydra is like an extension of the kirby paris hydra (which is as powerful as beklemishev`s worms). This hydra uses the same rules as the kirby paris hydra when the leaf node is 0, but when the leaf node is not 0, it uses another set of rules. The set of rules that Buchholz hydra uses when the leaf node that is being remove is not 0, are the following:

1. If the leaf node has a label u + 1, we search for an ancestor that has a label less than u, the sub tree rooted at this ancestor, call it s, make a copy of s, call it ʂ, in ʂ change the ancestor to u, and the leaf node to 0. Now replace the leaf node with ʂ.

2. If the leaf node has a label ω, change it to the number of steps taken already, plus 1.

The function BH(n) gives the number of steps it takes to reduce a hydra with a head of 0, with a tower of ω above it, that is n high. This function is faster than all functions proveable in Π11−CA+BI, which is more powerful than Π11−CA, which is more powerful than ACA0+Π12-BI.

D5(n)
D5(n) is a function used in a program call loader.c (made by ralph loader), this program applied the function to the number 99, which made a number big enough to win the bignum bakeoff contest held by David Moews. D(n) outputs an accumulation of all numbers possiblely provable in the calculus of constructions with log(n) infrence steps, (encoded as binary numbers and expressions as power towers). David Moews showed that D(99) is larger than 2↑↑30419, and D(D(99)) is bigger than ƒε 0 + ω^3 (1000000). loaders number is D(D(D(D(D(99))))), which is far bigger than BH(100), and is said to be bigger than TarTar(10)(10).