[proofplan] Assume that such a total $A$-computable decision function exists. Using it, define a partial $A$-computable function that deliberately disagrees with the predicted diagonal behaviour: it halts exactly on inputs that the decision function declares non-halting. Since the oracle programs are effectively enumerated, this partial function has some index $d$. Evaluating the construction at its own index $d$ gives that the computation halts if and only if it does not halt, which is impossible. [/proofplan] [step:Assume an $A$-computable diagonal halting decider exists] Suppose, toward a contradiction, that there is a total $A$-computable function \begin{align*} f: \mathbb N &\to \{0,1\} \end{align*} such that, for every $e \in \mathbb N$, \begin{align*} f(e)=1 \iff \varphi_e^A(e) \text{ halts}. \end{align*} Equivalently, since the codomain of $f$ is $\{0,1\}$, for every $e \in \mathbb N$, \begin{align*} f(e)=0 \iff \varphi_e^A(e) \text{ does not halt}. \end{align*} [/step] [step:Construct an $A$-oracle partial function that reverses the predicted diagonal behaviour] Define a partial function \begin{align*} g: \mathbb N &\rightharpoonup \mathbb N \end{align*} by the following $A$-oracle procedure on input $n \in \mathbb N$: first compute $f(n)$ using the oracle $A$; if $f(n)=0$, halt and output $0$; if $f(n)=1$, enter an infinite loop. Because $f$ is total and $A$-computable, this procedure is a well-defined partial $A$-computable function. Thus, for every $n \in \mathbb N$, \begin{align*} g(n) \text{ halts} \iff f(n)=0. \end{align*} [guided] We use the alleged decider $f$ to build a new oracle computation whose purpose is to contradict $f$ on the diagonal. Define a partial function \begin{align*} g: \mathbb N &\rightharpoonup \mathbb N \end{align*} as follows. On input $n \in \mathbb N$, run the $A$-oracle computation for the total function $f$ at input $n$. Since $f$ is total, this first computation always halts and returns either $0$ or $1$. If the returned value is $0$, then the procedure for $g$ halts and outputs $0$. If the returned value is $1$, then the procedure for $g$ enters a fixed infinite loop. This is an $A$-oracle computation because the only nontrivial subroutine used is the $A$-computable computation of $f$, and the remaining instructions are ordinary computable control instructions. Therefore $g$ is a partial $A$-computable function. Its halting behaviour is exactly \begin{align*} g(n) \text{ halts} \iff f(n)=0 \end{align*} for every $n \in \mathbb N$: if $f(n)=0$, the construction explicitly halts, while if $f(n)=1$, the construction explicitly loops forever. This is the diagonal reversal: $g$ halts precisely when $f$ predicts that the corresponding diagonal computation does not halt. [/guided] [/step] [step:Choose an oracle program index for the constructed partial function] Since $(\varphi_e^A)_{e \in \mathbb N}$ enumerates all partial $A$-computable functions $\mathbb N \rightharpoonup \mathbb N$, and since $g$ is partial $A$-computable, there exists an index $d \in \mathbb N$ such that \begin{align*} \varphi_d^A = g. \end{align*} In particular, evaluating both partial functions at $d$ gives \begin{align*} \varphi_d^A(d) \text{ halts} \iff g(d) \text{ halts}. \end{align*} [/step] [step:Evaluate the reversal at its own index to obtain a contradiction] From the construction of $g$ applied to $n=d$, we have \begin{align*} g(d) \text{ halts} \iff f(d)=0. \end{align*} From the choice of $d$, this is equivalent to \begin{align*} \varphi_d^A(d) \text{ halts} \iff f(d)=0. \end{align*} But the assumed correctness of $f$ at the same index $d$ gives \begin{align*} f(d)=0 \iff \varphi_d^A(d) \text{ does not halt}. \end{align*} Combining the last two equivalences yields \begin{align*} \varphi_d^A(d) \text{ halts} \iff \varphi_d^A(d) \text{ does not halt}, \end{align*} which is impossible. Therefore no such total $A$-computable function $f$ exists. [/step]