Fine.
Code: Select all
\begin{eqnarray*}g(a,n,B)=\\
ah_{g(a-1,n,B)} \{B\}, a > 1;\\
n, a = 0\\
rule\ 1: ah^a_n\{\$_0\} = g(a,n,\$_0)\\
rule\ 2: ah_n\{\$_1,\beta\} = ah_n\{\$_1\}, \beta = 0\\
rule\ 3: ah_n\{\} = n+1\\
rule\ 4: ah_n\{\alpha+1,\$_2\} = ah^n_n\{\alpha,\$_2\}\\
rule\ 5: ah_n\{\alpha,\$_3\} = ah_n\{\alpha[n],\$_3\}, \alpha\ a\ lim\ ord\\
rule\ 6: ah_n ((0@b)\#\{\alpha+1,\$_4\}) = ah_{n+1} (((\alpha+1)@b)\#\{\alpha,\$_4\}),\ b > 0\\
rule\ 7: ah_n ((0@b)\#\{\alpha,\$_5\}) = ah_n ((\alpha@b)\#\{\alpha[n],\$_5\}), \alpha\ a\ lim\ ord, b > 0
\end{eqnarray*}
See here
Possible extension:
I'm considering using a sort of equivalent to legion bars from BEAF
EDIT:
{a,$_0//b} = {a@a@a@a@a w/b a's,$_0} doesn't quite work.
But
(Note: this is an old definition. A much definition is found further down this post)
ah_n{a,$_0//b} = ah_n(((a@(ah_n{a,$_0//(b-1)}))#{$_0})#{//(b-1)}), b>0
ah_n{a,$_0//b} = ah_n{a,$_0}, b=0
does.
That sounds really really really confusing, but it's just this:
ah_3{w,1,2//1} = ah_3{w,w,w,w,w,w,w,w,w,w,w,w,w...,1,2} with ah_3{w,1,2} w's
(btw, don't scream "LATEX!!! Where is the LaTeX?" Because
this is hardly any clearer.
Another demo:
ah_1{1//1} = ah_1{1@(ah_1{1})} = ah_1{1,1} = ah_2{1} = ah_ah_2{0}{0} = 4
ah_1{1//2} = ah_1{1@(ah_1{1//1})//1} = ah_1{1,1,1,1//1} = ah_1{1@(ah_1{1,1,1,1}),1,1,1}
ah_1{1,1,1,1} =
Code: Select all
ah_1{0,1,1,1}
ah_2{1,0,1,1}
ah_ah_2{0,0,1,1}{0,0,1,1}
ah_ah_3{1,1,0,1}{0,0,1,1}
... probably rather large
Therefore:
ah_1{1//2} is rather large
Really, an even better definition is this:
ah_n{$_0//(b+1)} = ah_n((($_0)(@^_n)ah_n{$_0//b})#{//b})
ah_n{$_0//0} = ah_n{$_0}
and of course, the dreaded limit ordinal case:
ah_n{$_0//b} = ah_n{$_0//(b[n]} for lim ord b
Where ($_1)(@^_n)a =
($_1)@(ah_n(($_1)(@^_n)(a-1))), a > 1,
ah_n{$_1}, a=1
Using this definition, which is closer to legion bars anyways, one gets functions like ah_n{2//w} or even ah_n{(gamma_0)//gamma_0}
(And of course, something like ah_n{(gamma_0)//gamma_0}, if I wrote all this as I wanted to and it's well defined, is
by far the most powerful function that I have coined.)
Even ah_n{1//w} is huge very fast:
n = 1:
ah_1{1//1} = ah_1(1(@^_1)(ah_1{1})) =
(ah_1{1} = 2)
ah_1(1(@^_1)2) =
ah_1(1@(ah_1{1})) =
ah_1{1,1} = 4
n = 2:
ah_2{1//2} = ah_2((1(@^_2)(ah_2{1//1}))//1)
Already, this must be > ah_2((1,1,1,1)//1)
Code: Select all
ah_2{1//1} =
ah_2(1(@^_2)4) =
ah_2(1@(ah_2(1@(ah_2(1@(ah_2(1@(ah_2{1})))) =
ah_2(1@(ah_2(1@(ah_2(1@(ah_2{1,1,1,1}))
...
ah_2{1//w} =
ah_2((1(@^_2)(ah_2(1@(ah_2(1@(ah_2(1@(ah_2{1,1,1,1}))))//1)
Yikes, this grows fast
Can anyone give reasonable bounds in terms of other functions?
(Also, it looks like ah_n{gamma_0//gamma_0} is defined, making it my fastest growing function, since of course it trumps f_gamma_0(n) = ~dco(gamma_0+n))
And now, the @@ operator, essentially the legion array of operator:
ah_n(a@@b) expands to
ah_n(a//(a@@(b-1))), b>0, b not a lim ord
ah_n(a), b = 0
ah_n(a@@(b[n])), b a lim ord
(Note: legion arrays can currently only associate rightwards, I.e. a//b//c is (a//b)//c which is, in an ah array, this mess:
ah_n{(a//b)//c} = ah_n(((a//b)(@^_n)ah_n{(a//b)//(c-1)})#{//(c-1)})
I think ah_n(n@@n) is very fast growing but I have a hunch that it's somewhat illdefined. So let's just stick to legions (//) for now.
Y'know, I'll add an extra rule for a@b so that it does the whole lim ord mess thing too:
ah_n({$_0}#a@b) = ah_n({$_0}#a@(b[n]))
EDIT:
Better @@:
ah_n($_0@@b) expands to
ah_n($_0//(ah_n($_0@@(b-1)))), b>0, b not a lim ord
ah_n($_0), b = 0
ah_n($_0@@(b[n])), b a lim ord
This time they associate more powefully:
ah_n(gamma_0@@gamma_0) is much more powerful than ah_n(gamma_0//gamma_0)
And now, two more:
ah_n{$_0/m+1/(b+1)} = ah_n((($_0)(@@^m_n)ah_n{$_0//b})#{//b})
ah_n{$_0/m+1/0} = ah_n{$_0}
ah_n{$_0/m/b} = ah_n{$_0/m/(b[n]} for lim ord b
ah_n{$_0@@b}, m = 0
Where ($_1)(@@^m_n)a =
($_1)@@(ah_n(($_1)(@@^m_n)(a-1)), a > 1, m=0
($_1)@@(ah_n(($_1)(@@^m_n)(a-1)#{/m/$_0)), a > 1, m>0
ah_n{$_1}, a=1
These new ones don't exactly match my original stuff and they may be illdefined, but they're pretty crazy.
Anyways, how powerful is ah_n(gamma_0@@gamma_0)