Is $n$ uniformly computable from an oracle for the $n^{\rm th}$ jump $0^{(n)}$?

Question

This is a little curiosity that came up in a project I am working on, and I thought someone might have a nice way to see the answer.

Question. Can we uniformly compute $n$ from an oracle for the $n^{\rm th}$ jump $0^{(n)}$?

Of course, if we hard-code $n$ into our representation of $0^{(n)}$, then the answer will be yes. Similarly, if we use a $\Sigma_n$-truth predicate instead of $0^{(n)}$, which is of course Turing equivalent, then we can compute $n$ by looking at the syntactic complexity of the assertions in the oracle. We could also get negative answers by making finite changes to each $0^{(n)}$, which would preserve Turing equivalence at each level but destroy the uniform algorithm.

My question, instead, is about using the usual representation of $0^{(n)}$ as sets of halting Turing machine programs. Specifically, using some standard Turing machine architecture and encoding of Turing machine programs, let $0'$ or $0^{(1)}$ be the collection of Turing machine programs (construed as a set of natural numbers) that halt on empty input. For $n\geq 1$, let $0^{(n+1)}$ be the collection of oracle Turing machine programs (construed as a set of natural numbers) that halt on empty input using oracle $0^{(n)}$.

The question is whether there is a program $e$ such that on empty input, program $e$ with oracle $0^{(n)}$ outputs $n$. In other words, is there a computer program such that if you give it some $0^{(n)}$ as an oracle, it can recover $n$?

I believe that the answer will be yes, by designing certain programs that halt or don't halt in a such a way that one can determine what $n$ must be.

If the answer is affirmative, then we can also answer affirmatively the following question:

Question. Is $0^{(k)}$ uniformly computable from $0^{(n)}$ for any $n\geq k$?

That is, using the specific representations of $0^{(n)}$ I defined above, is there an oracle Turing machine program $e$ such that on input $k$, given oracle $0^{(n)}$ for any $n\geq k$, will write out the contents of $0^{(k)}$?

I expect that the answer is yes.

Answer 1

Well, I am a little embarrassed, but after having written out my question and thinking about it for a time, I now see how to answer it. Somehow, it wasn't as clear to me before. (Should I instead simply delete? If so, please comment.)

We can compute any oracle $A$ uniformly in $A'$, by the following process: for any number $k$, there is a program $p_k$ that on any input checks if $k$ is in the oracle, halting if it is and not halting if it isn't. Thus, $k\in A\iff p_k\in A'$, and the map $k\mapsto p_k$ is computable.

For any program $e$ to be used with oracle $A$, we can uniformly create a program $q_e$ to be used with $A'$, but computing the same function. Namely, $q_e$ on any input uses the method of the previous paragraph to simulate $e$ with oracle $A$, by systematically generating larger and larger fragments of the oracle $A$ from $A'$ in order to simulate $e$ with oracle $A$.

Now we simply iterate this process, so that from $0^{(n)}$ we can uniformly compute the preceding jumps $0^{(n-k)}$ for any given $k< n$. That is, we compute the jumps from the top down.

Finally, notice that the way that I defined $0^{(1)}$, it consisted of non-oracle programs only, and so we can determine with oracle $0^{(n)}$ whether $n=1$ or $n>1$ by looking at one of the programs in the oracle, and checking if it is an oracle program or a non-oracle program.

So, we simply systematically undo the jumps until we see that we have $0^{(1)}$ or not, counting the number of times, and thereby compute $n$.