User blog:B1mb0w/Deeply Nested Ackermann

Deeply Nested Ackermann

The Deeply Nested Ackermann function is defined by generalizing the User blog:B1mb0w/Modified Ackermann Function MA with a input parameter array. For example with 4 input parameters the function (signified with a lowercase d) looks like this:

$$d(x1,x2,x3,x4)$$

Rules for the d function are similar to MA function rules but generalised as follows:

$$d = 0$$         This is a null function that always returns zero.

$$d(m) = m+1$$      This is equivalent to MA(0,m)

The next example is equivalent to the MA(x,y) function.

$$d(m,n) = MA(m,n)$$  And the same rules apply:

$$d(m,n)$$ defined as:

◾ $$n+1$$  if m=0 ,

◾ d(m−1,d(m-1,m))  if n=0, or

◾ d(m−1, d(m,m−1))  otherwise.

For 3 parameters, the rules are generalised and extended as follows:

$$d(m1,m2,m3)$$ defined as:

◾ $$d(m2,m3)$$ if m1=0 ,

◾ d(m1−1, d(m1,m2-1), d(m1,m2,m3-1)) if m1>0, m2>0 and m3>0

◾but d(m1,m2-1) is substituted by d(m1-1,m1) if m2=0

◾and d(m1,m2,m3-1) is substituted by d(m1,m2-1,m2) if m3=0

◾or d(m1,m2,m3-1) is substituted by d(m1-1,m1,m1) if m2=0 and m3=0

General Example

Instead of giving an example for d(x1,x2,x3,x4) next, it is actually easier to follow the general example for:

DNA(x1,x2,x3, ..., xn) defined as this deeply nested function:

DNA(x1-1,  DNA(x1,x2-1),   DNA(x1,x2,x3-1),   DNA(x1,x2,x3,x4-1),   ...   DNA(x1,x2,x3,x4, ... ,xn-1)  apologies for the clumsy subscripts (to be corrected soon).

The only substitution rules that need to be followed are:

Leading Zeros rule

DNA(0,0, ...,0,x,y,z) is substituted for DNA(x,y,z) in all cases

Trailing Zeros rule

DNA(x,y,z,0,0, ... ,-1) is substituted for DNA(x,y,z-1,z,z, ... ,z) in all cases

Calculated Examples

d = 0  This is a null function that always returns zero.

d(3) = 4    This is the successor function

d(1,2) = 5   This is the same as MA(1,2) which is equivalent to MA(1,b) = b+3

d(1,0,0)     Is the first non trivial calculation and expands as follows:

= d(0, d(0,1), d(0,1,1))  then apply the Leading Zeros rule

= d( d(1), d(1,1))

= d(2, 4) = 20 This is the same as MA(2,4) which is equivalent to MA(2,b) = 3*b+8

d(1,0,1)     expands as follows:

= d(0, d(0,1), d(1,0,0))  then apply the Leading Zeros rule

= d( d(1), d(1,0,0)))

= d(2, 20) = 68 This is the same as MA(2,20) which is equivalent to MA(2,b) = 3*b+8

It can be shown that d(1,0,c) is equivalent to but much greater than > 3^(c+2)

More Calculated Examples

d(1,1,0)     expands as follows:

= d(0, d(1,0), d(1,0,1))  from the above examples we know this is equal to

= d(3, 68)      This is the same as MA(3,68) which is equivalent to MA(3,b) >> 3^(b+3)

d(1,2,0)     expands as follows:

= d(0, d(1,1), d(1,1,2))  from the above examples we know this is equal to

= d(4, 3^(2+3))      This is equivalent to but much greater than >> 3^^(b+70)

My calculations show that d(1,b,0) is equivalent to but much greater than >> 3^^ ... b arrows ... ^^(b+70)

Some Comparisons

d(3, 0) = 59

d(3, 9) >> 1,000,000

d(3, 206) >> Googol

d(4, 0) = d(3, 5099) >> 3^(5099+3)

d(1,1,0) = d(3, 68) << Googol

d(1,1,1) = d(d(1,0), d(1,1,0)) = d(3, d(3, 68)) >> 3^3^(68+3) << Googolplex

d(1,1,2) = d(d(1,0), d(1,1,1) >> d(3, 3^3^(68+3)) >> Googolplex

d(1,3,0) >> d(6,0) >> g1 where g64 is Graham's number

d(1,4,0) >> d(6, 3^^^^3) >> 3^^^^3^^^^3 = 3^^^^^3

d(1,4,1) >> d(6, d(1,4,0))

and one more

d(2,0,0) = d(1,d(1,2),d(1,1,2)) >>  d(1, 5, 3^^72) >> d(1,4,63)

Another Comparison

The general rule for comparing d functions with 2 input parameters is:

d(x,y) = d^(y+2) (x-1,x) apologies for the clumsy notation (to be corrected soon).

Other general rules for comparing d functions with 3 and 2 input parameters are:

d(1,3,z) >> d(6,z-1)

d(1,y,z) >> d(y+3, z-1)

d(2,0,z) = d(1, d(1,2), d(2,0,z-1))

>> d( d(1,2)+3, d(2,0,z-1) -1)

>> d(8,z)

Graham's Number

The d function can reach g1 where g4 is Graham's number relatively quickly. As shown above d(1,3,0) >> g1. But from my analysis we need the power of the d function with many more input parameters to reach G (Graham's Number).

d(6,0) >> g1

d( d(6,0), 0) >> g2

d(6,0,0) = d(5, d(5,6), !!!)  where !!! is a big number that we can ignore for now

= d(4, d(4, d(5,6)-1), !!!)

...

= d(0, d(1, d(2, d(3, d(4, d(5,6)-1)-1)-1)-1)-1), !!!) and the leading parameter = 0 can be dropped.

The value of the second parameter is big but does not equal d(6,0) therefore d(6,0,0) << g2 but if we expand

d(6,1,0) we will get d(6,0) nested in the long expansion and therefore d(6,1,0) >> g2 by a very great amount.

We can reach g3 by moving to 4 input parameters

d(6,1,1,0) >> g3

We finally reach G (Graham's Number) with 64 input parameters

d(6,1,1,1, ..., 1,0) >> G

Growth Rate

The growth rate of the d function is much faster than the Fast-growing hierarchy. Here are some comparisons:

d(x,y) = d(x-1, d(x,y-1)) = d^(y+2) (x-1,x)

fx (y) = f(x-1)^y (y)      even if y>>x the d function will exceed f because y+2 > y and the extra function recursion will always generate the largest number. If y >> >> x by a ridiculous amount then this may not be true.

and also

f6 (6) >> g1

d(6,6) >> f6 (6) >> d(6,0) >> g1

Next

My next blog post will introduce a new Alpha function that I have been thinking about. You can find it here: User blog:B1mb0w/Alpha Function