User blog comment:Mh314159/Alpha numbers (and beyond)/@comment-35470197-20191007022858/@comment-39585023-20191014140507

Last few days of life have been very busy, and I don't want you to think I was ignoring your excellent efforts. I appreciate it.

I have other rules to take alpha(n) to new levels, but i'd like to start with something as strong as possible, so I'd like to post a couple of things:  1) the next extension of the alpha numbers and 2) the first rule set of a new system that I hope diagonalizes more strongly. If you have time, I would love to year what your thoughts are:

1)  Next rule set of the alpha numbers

Rule Set 2:

More than two arguments generates a recursive single argument α expression.

α[a,b,...,c] = αm[m]

m = α[α[a-1,b,c],b-1,...,c]

Drop trailing zeroes.

Replace a non-trailing zero with the entire α expression with the entry after zero copied into the zero's place, then decrease the next entry by one in both the replacement expression and the whole expression.

Examples of zero replacements:

α[0,b,c,...] = α[α[b,b-1,c,...],b-1,c,...]

α[a,0,c,...] = α[a,α[a,c,c-1,...],c-1,...]

All instances of α[a,b] or α[a] evaluate to natural numbers using existing rules for single or double argument alpha function

example:

α[1,1,1] = αm[m]

m = α[α[0,1,1],0,1]

α[α[0,1,1],0,1] = α[α[α[1,0,1],0,1],0,1]

α[α[α[1,0,1],0,1],0,1] = α[α[α[1,α[1,1,0],0],0,1],0,1] =

α[α[α[1,α[1,1]],0,1],0,1] =

α[α[α[1,α[1,1]],α[α[1,α[1,1]],1,0],1],0,1] =

α[α[α[1,α[1,1]],α[α[1,α[1,1]],1],1],0,1] =

α[α[α[1,α[1,1]],α[α[1,α[1,1]],1],1],α[α[α[1,α[1,1]],α[α[1,α[1,1]],1],1],1]] and this is made up of nested two-term expression so while it generates an enormous m it does not further recurse it.

α[1,1,2] = αm[m]

m = α[α[0,1,2],0,2] = α[α[α[1,0,2],0,2],0,2] = α[α[α[1,α[1,2,1],1],0,2],0,2] etc. and since this still contains a three term expression; in fact, a nested three-term expression, it will recursively iterate the m in the αm[m] structure a huge number of times.

2) a new rule set

1. Function with index indicated by angled brackets and argument in parentheses:

f<0>(x) = x + 1

f(x) = ff[n](x-1)(f(x-1))

f(0) = f(n) Ex:

f<1>(1) = f<0>f<1>(0)(f<0>(1)) = f<0>2(2) = 4

f<1>(2) = f<0>4(4) = 8

f<1>(x) = 2^(x+1)

f<2>(1) = f<1>8(8) > 2^^10

f<2>(2) = f<1>2^^10(2^^10) > 2^^2^^10

f<2>(3) = f<1>2^^2^^10(2^^2^^10) > 2^^2^^2^^10 > 2^^2^^2^^2^^2 or 2^^^5

f<3>(1) = f<2>f[2>(3)(1) > f<2>2^^2^^2^^10(1)

f<4>(1) = f<3>f<3>(4)(1)

f(x) is greater than 2^n+1x in Knuth up-arrow notation.

2. Function with index string and argument

f(x) = fm(m) where m = f(x-1) and f(0) = f(j)

S is any comma-delimited string of nonzero natural numbers

S' is S with the final term decreased by one and all other terms replaced by m

S is S with the initial term decreased by one

j is the final term in S

Drop trailing zeroes inside brackets.

Replacement rules for non-trailing zeroes inside brackets:

Replace the zero with the entire expression, copy the number after the zero into the zero's place, decrease the number that was after the zero by one, and decrease the number after the replacement expression by one.

Initial zero:

f<0,b,...c>(x) = f(x)

Noninitial, nontrailing zero:

f(x) = f(x),b-1,...c>(x)

Ex:

f<1,1>(1) = fm(m) = fm(m) where m = f<0,1>(1) = f(1),0>(1) f<f<1>(1)>(1) = f<4>(1) so f<1,1>(1) recurses the f<f<4>(1)> function f<4>(1) times.

f<2,1>(1) = f<m>m(m) where m = f<1,1>(1) (see above)

f<1,2>(1) = f<m,1>m(m) where m = f<0,2>(1) = f<f<2,1>(1),1>(1)

Expressions with three or more terms in the brackets recurse much more deeply.

f<1,1,1>(1) = f<m,m>m(m) where m = f<0,1,1>(1), which by repeated application of the zero replacement rules, = f<f<1,f<1,1>(1)>(1),f<f<1,f<1,1>(1)>(1),1>(1)>(1) and to make this easier to read we have f<q,f<q,1>(1)>(1) with q = f<1,p>(1) and p = f<1,1>(1).

f<1,1,2>(1) = f<m,m,1>m(m) where m = f<0,1,2>(1), which by zero replacement = f<q,f<q,1,1>(1),1>(1) with q = f<1,p,1>(1) and p = f<1,1,1>(1), so m is still a recursed three-term bracket string.