User blog:Fejfo/Super Fast Beaver Hierarchies and a weird OCF

This is in no way a new idea but I had never thought about higher order busy beavers as an ordinal hierachy before and it has some intersting implications.

Note I couldn't find a definition of \( \omega^{CK}_\alpha \) I could understand, In this post I assume it is the supremum of all ordinals computable on an order \( \alpha-1 \) machine.

Busy Beaver Hierachy
Order \( 0[n] \) turing machine= a 2-symbol, n-state turing machine.

Order \( \alpha[n] \) turing machine= a 2-symbol, n-state turing machine with oracles for order \( a \in \alpha\) turing machines.

\[ BB_\alpha(n)=\text{the largest output of a halting order $\alpha[n]$ turing machine} \\ \Rightarrow BB_0(n)=BB(n) \]

This grows much faster than the fast growing hierachy (\( BB_\alpha\approx f_{\omega^{CK}_{1+\alpha}}\))  but at the cost of uncomputability.

You may also notice \( BB_\alpha \) seems to be defined for uncountable ordinals but to explore this fully we need a more formal definition of those oracles. I'll be doing this using the bitf*ck programming language (since I like it more and it's turing complete anyway, this turned out to be a bad decision because it is so complex to explain )

Bitf*ck
Bitf*ck a variant of Brainf*ck consists of:
 * 1) A half infinite input tape (start in first cell)
 * 2) 6 instructions
 * 3) > move to the right on the tape
 * 4) < move to the left on the tape (in the first cell this does nothing)
 * 5) [  if the current cell is 0 goto the matching ] instruction
 * 6) ]  if the current cell is 1 goto the matching [ instruction
 * 7) ~ apply the NOT gate to the current cell (0 becomes 1 and vice versa)
 * 8) ' the oracle instruction, this will be explain later
 * 9) instructions are excecuted one by one (and counted) until you run out at that moment the program halts and the tape becomes the output.

Functions in bitf*ck
A program is a function \( f(x_1,x_2,...,x_n)=(y_1,y_2,...,y_m) \) if when the input consists of \( n \) 1 groups of length \( x_1 \) seperated by 0s (starting in the first cell), the output consists of of \( m \) 1 groups of length \( y_i \) seperated by 0s. \( f(x)=y is shorthand for f(x1)=(y1) \)

Lexographical ordering
Well-formed bitfuck programs are first indexed alphabetically. And then they are ordered in the following way:
 * \( O[n][m]=(n,\text{the $m^{th}$ alphabetical program} \)
 * the final ordering L is made by:
 * takeing the first element of O[1]
 * takeing the next element of O[1] and then O[2]
 * takeing the next element of O[1],O[2],O[3]
 * and so on

Ordinals in bitf*ck
Ordinals are encoded as functions representing their fundamental sequence. \( \alpha(x)=index(\alpha[x]) \) The input is the index of an ordinal indicating which element of a fundamental sequence to output (as it's index). When \( x\not\in cf(\alpha) \) the program can output any element of it's fundamental sequence.

This means we can define \( \alpha=\sup\{ \alpha(n) : n \in \omega \} \)

zero isn't a program but referenced by with index 0 1 is a program like [~>] which earses it's input and thus outputs the index 0 ω is a program which earaes programs not representing finite ordinals

The first element of the tuples in the ordering is the index of the ordinal indicating the order of the program.

The ' instruction
In a program of order \( \alpha \) ' does the following: This means ' lets the bit stay 1 if it is able to determine the program halts.
 * let i be the length of the current 1 group (arround the selected cell)
 * let \( (\beta,p)=L[i] \)
 * if \( \beta \not\in \alpha \) or p is a halting order \( \beta \) program the current bit is set to 0

Bit Beaver Hierachy
Now I can finally define:

(The lowercase b is mainly to distinguisch it from BB but it's also a reference to binary.)

\[ bB_\alpha(n)=\sum\{ \operatorname{steps}(F,0) : F \text{ is a halting (on empty input) order $\alpha$ program with $n$ instructions} \} \]

This is actually more like a maximum shifts function, the sum barely has an effect on later values.

Finally the OCF
It seems like \( bB_\Omega(n) \) is well defined because the length of the program limits it's growth. The same argument could be made for \( bB_{\Omega_\alpha} \) or \( bB_I \) this might break at a certain large cardinal but I'm not sure why that would happen.

This means you can define:

\[ \psi_{bB}(\alpha)=min\{ β : f_\beta >> bB_\alpha \} \]

And \( \psi_{BB}(\alpha)=min\{ β : f_\beta >> BB_\alpha \}  \)

It's interesting that this seems to collapse with out the use of closure functions so all you need is the definition of the large ordinal which needs to be brought in from above (\( \Omega \) is an order \( \Omega \) program

Analysis?
It's unclear to me how fast  \( bB_\Omega \) would grow, I think it's limited by which ordinals it can acces. Programs of order \( \alpha \) can define ordinals upto  \( \omega^{CK}_{1+\alpha} \) so \(  \psi_{bB}(\Omega) \) might be the supremum of a programs with an oracle for \( \alpha \mapsto \omega^{CK}_{\alpha} \) ? This is why I think the way the oracles are encoded is very important.

A more traditional version of this as a theta OCF might include a set closed under programs with an oracle for previous functions or something like that.

Because this OCF seems to me to be well-defined for all ordinals you would simply need to borrow a LCA and input it to create a huge ordinal which doesn't seem right.

Something else to investigate might be if there are catching points of the beaver hierachies and the fgh, I guess these would be the fixed points of "the alpha-th church-kleene ordinal"

So inconclusion I seem to be struggeling to even find notation to analyse this with.

Early values of \( bB_0 \)
\( bB_0(1)=4 \) these 4 well defined programs all run for exactly 1 step

\( bB_0(2)=16 \) loops still aren't usable

\( bB_0(3)=203 \) 3*4^3 for loopless programs, 1*4*3 for loops, -1 for ~[]

It seems like 1 instruction has quite a bit less power than 1 state in a turing machine, most of the growth is still coming from the amount of programs. In fact \( bB_0(n) \geq n*4^n  \) is an easy lowerbound based on loopless programs only.

\( bB_0(4)=1017 \) with ~[~], ~[>] and ~['] the first halting loops which aren't skipped