Alright. I am PRAYING for the well definedness of Delta(n)
So.
Let's start.
CAF
I define CAF in the following recursive way:
C(a,b,c,d,n) = C^(C(a-1,b,c,d,n))(a-1,C(a-1,b,c,d,n),C(a-1,b,c,d,n),C(a-1,b,c,d,n),C(a-1,b,c,d,n))
C(a,b,c,d,n) = b^(b(b,c,d,n))(b,c,d,n) when a = 0
^ = recursion when used with a function. Otherwise, exponentiation.
I define b(b,c,d,n) in the following recursive way:
b(b,c,d,n) = b(b,b,c,d,n)
b(a,b,c,d,n) = b^(b(a-1,b,c,d,n))(a-1,b(a-1,b,c,d,n),b(a-1,b,c,d,n),b(a-1,b,c,d,n),b(a-1,b,c,d,n))
b(a,b,c,d,n) = Delta^(b^c)(d^n) when a = 0. (It won't cause infinite loop due to needing a at zero in order to run)
^ = recursion when used with a function. Otherwise, exponentiation.
a[b]c = C(b,a,a,c,c)
a[b]^(d)c = H(d,a,b,c)
If any of the terms is zero, return 1 trillion.
I define H(a,b,c,d) in the following recursive way.
H(a,b,c,d) = H^(H(a-1,b,c,d,n))(a-1,H(a-1,b,c,d,n),H(a-1,b,c,d,n),H(a-1,b,c,d,n),H(a-1,b,c,d,n))
H(a,b,c,d) = b[c]d when a = 0.
[a,b,c] = a[b]c
[a,b,c,d] = a[b]^(d)c
if array is of size 2 ([a,b]), return a^b.
If of size 1 ([n]) return n.
where ^ is recursion of the []s
Let μ be a large countable ordinal such to every limit ordinal α < μ there is assigned a fundamental sequence (a strictly increasing sequence of ordinals whose supremum is α). A Chick Hierarchy of functions Cα: N → N, for α < μ, is then defined as follows:
C_0(n) = [n,n,n,n]
C_{a+1}(n) = [{C_a}^n(n),{C_a}^n(n),{C_a}^n(n),{C_a}(n)]
C_a(n) = C_a[n](n) if a is a limit ordinal.
_ = subscript, the ^ means recursion of the C_a function as a whole.
Chick_1(n,m) {Chick_1}^m(n-1,{Chick_1}^m(n-1,m→m→m))
Chick_1(n,m) = C_g_g_g_g_g_g_g_g_g_g_g_g_g_g_g_g_g_(m^m)(m^m)
The _ = subscript, the ^ on the chickie_1 function is recursion of the Chickie_1 function, and ^ at the m means exponentiation. Also, g is the gamma naught's ordinal's gamma.
Finally.
Chickie_1(n) = Chick_1(n→n→n→n,n→n→n→n)
And the OELCN.
Chickie_1(10^100)
AYYYY!!!
Also, I'll include a more ambiguous multidimentional array thing. (I'm not making ANOTHER RECURSIVE FUNCTION FOR THAT, IT'S TOO BORING!!)
t_n = nth term, starts from 1
[x_1,x_2,x_3...x_{n-1},x_n] = [[x_1,x_2,x_3,...x_{n-1},x_n-1], t_1,t_1,... t_1,x_n-1]
This means take one from the last term of the array, call it t_1, and replace all terms in the larger array with it, except the last one, where we subtract one.
Of course, do not use this rule when we are at three or four size arrays.
[x_1,x_1,...x_{n-1},x_n] = [x_1*(n-1),x_2*(n-1),...x_{n-1}*(n-1)
_ is subscript, used to denote terms.
Again, don't apply these rules at size 3 or 4 arrays.
[n<m>] = n*m.
* = array of, meaning e.g. a*b = [a,a,a,a...a], with b copies of a.
We also evaluate the * operator from right to left. i.e. 3*3*3 = 3*(3*3) = 3*[3,3,3] = [3,3,3...(total there are [3,3,3] 3s)...,3]
[n<m,o>] = [[n<(m*m),o-1>]*x*x*x...(in total there are x xs)...*x]
^^^^^^^^^^^^^^^
call x. (that is [n<(m*m),o-1], if formatting is bad)
Note, DO NOT APPLY RULE WHEN o IS ONE, use the above rules for linear arrays.
& = dimention of, meaning e.g. a&b = [([a,<b,b>]*[a,<b,b>])<([a,<b,b>]*[a,<b,b>]),([a,<b,b>]*[a,<b,b>])>]
i.e. 3&3 = [[3,<3,3>]*[3,<3,3>]<[3,<3,3>]*[3,<3,3>],[3,<3,3>]*[3,<3,3>]>]
Eval right to left.
3&3&3 = 3&(3&3) and so on.
Stacked &*
Dimention array of.
Basically means
a&*b = a&a&a...&a, where there are b copies of a.
[n<m,o,p>] = [n<R(p,m,o),R(p,m,o)>]
I define R(n,m,o) in the following recursive way:
R(n,m,o) = R(n-1,R(n-1,m,o),R(n-1,m,o))
R(n,m,o) = (m&*m)&*(o&*o) when n = 0.
We also have &&, which is just &, except all <n,n>s are now <n,n,n> , then &&&, (<n,n,n,n>) and so on. (applies even to the larger ones. Sorry for ambiguity.) Again we have &&*, &&&*, &&&&*... I call &..& with n &s total &(n). We can easily say &&&&&&&&&&* as &(10)*.
[n<x_1,x_2,...x_{n-1},x_n>] = [n<P(x_1,x_2,...x_{n-1},x_n),P(x_1,x_2,...x_{n-1},x_n),...(in total there are n-1 P functions)...,P(x_1,x_2,...x_{n-1},x_n)>
P(n,m,o,...p) (size x) = P(n-1,P(n-1,m,o,...,p), (replace every term that isn't n with P(n-1,m,o,p)))
P(n,m,o,...,p) = (m&(x-2)*m)&(x-2)*(o&(x-2)*o)&(x-2)*... (ommited boing repitition, basically take the first term, &(x-2)* it, then &(x-2)* that by the next term &(x-2)*ed, and take the group of two and &(x-2)* it by the next term &(x-2)*ed and so on until we reach the end. Ambiguous? Yes. But it's late and i don't feel link making billions of recursive functions. So bear with me.
% Array of dimention of, meaning i.e. a%b = [a<a,a...(b copies of a in total),a>]
We can add a * (a%*b) to mean a%a%a..%a where there are b copies of a
# is rest of array.
[n(1)] = n%n
[n(m)] = n%m
[n(m,o,#,1)] = [n(m,o,#)]
[n(m,o,1,(n 1s),1,p,#)] = [n(m,o,[n(m%m,o%o,1,(n-1 1s),1,p%p,#%#)],p,#]
#%# means turn all terms into a%a form.
[n(m,o,p,#)] = [n,<[n,(m-1,o%*o,p%*p,#%*#)],[n,(m-1,o%*o,p%*p,#%*#)]>]%[n,<[n,(m-1,o%*o,p%*p,#%*#)],[n,(m-1,o%*o,p%*p,#%*#)]>]
#%*# means turn all terms in # to follow the form of n%*n
$ is Array of Array of dimention of, meaning e.g. a$b = [a,(a,a,a,...,a)] in which there are b as in the ()s.