[proofplan] Each implication follows by viewing the stronger reduction as a special case of the weaker one. A one-one reduction is a many-one reduction with the extra injectivity condition forgotten. A many-one reduction is a truth-table reduction with one query and the identity Boolean function. A truth-table reduction is simulated by an oracle Turing machine that computes the finite nonadaptive query list, asks those oracle questions, and evaluates the corresponding Boolean function. [/proofplan]

[step:Forget injectivity to pass from one-one reducibility to many-one reducibility] Assume $A \le_1 B$. By definition, there exists a total computable injective map \begin{align*} f: \mathbb{N} &\to \mathbb{N} \end{align*} such that, for every $x \in \mathbb{N}$, \begin{align*} x \in A \iff f(x) \in B. \end{align*} The definition of many-one reducibility requires only a total computable map with this equivalence; it does not require injectivity. Therefore the same map $f$ witnesses $A \le_m B$. [/step]

[step:Turn a many-one reduction into a one-query truth-table reduction]Assume $A \le_m B$. Then there exists a total computable map \begin{align*} f: \mathbb{N} &\to \mathbb{N} \end{align*} such that, for every $x \in \mathbb{N}$, \begin{align*} x \in A \iff f(x) \in B. \end{align*} Define the query map \begin{align*} q: \mathbb{N} &\to \mathbb{N} \\ x &\mapsto f(x), \end{align*} and define the Boolean evaluation map \begin{align*} \beta: \{0,1\} &\to \{0,1\} \\ b &\mapsto b. \end{align*} The map $q$ is total computable because $f$ is total computable, and $\beta$ is computable because it is a finite Boolean function. For every $x \in \mathbb{N}$, \begin{align*} \mathbb{1}_A(x) = \beta(\mathbb{1}_B(q(x))). \end{align*} Thus the membership of $x$ in $A$ is determined by the single nonadaptive query $q(x)$ to $B$ and the Boolean function $\beta$. Hence $A \le_{tt} B$.[/step]

[guided]A many-one reduction already gives exactly the information needed for a truth-table reduction, but in the most economical possible form: it asks only one question. Since $A \le_m B$, we have a total computable map \begin{align*} f: \mathbb{N} &\to \mathbb{N} \end{align*} such that, for every $x \in \mathbb{N}$, \begin{align*} x \in A \iff f(x) \in B. \end{align*} To repackage this as a truth-table reduction, define the single query \begin{align*} q: \mathbb{N} &\to \mathbb{N} \\ x &\mapsto f(x). \end{align*} This query is computable because it is exactly the many-one reduction function. The truth-table reduction also needs a Boolean rule telling us how to use the oracle answer. Since the oracle answer to the query $q(x)$ is already the correct answer to whether $x \in A$, the Boolean rule is the identity function \begin{align*} \beta: \{0,1\} &\to \{0,1\} \\ b &\mapsto b. \end{align*} Therefore, for every $x \in \mathbb{N}$, \begin{align*} \mathbb{1}_A(x) = \beta(\mathbb{1}_B(q(x))). \end{align*} This is precisely a truth-table reduction: the finite query list has length one, the query is computed before any oracle answer is known, and the final answer is obtained by applying a computable Boolean function to the returned bit. Hence $A \le_{tt} B$.[/guided]

[step:Simulate a truth-table reduction with an oracle Turing machine] Assume $A \le_{tt} B$. By definition, there is a total computable truth-table procedure which, on input $x \in \mathbb{N}$, computes a finite list of queries \begin{align*} q_1(x), q_2(x), \dots, q_{k(x)}(x) \in \mathbb{N}, \end{align*} where $k(x) \in \mathbb{N}$ is computable from $x$, and computes a Boolean function \begin{align*} \beta_x: \{0,1\}^{k(x)} &\to \{0,1\}, \end{align*} such that \begin{align*} \mathbb{1}_A(x) = \beta_x\bigl(\mathbb{1}_B(q_1(x)),\mathbb{1}_B(q_2(x)),\dots,\mathbb{1}_B(q_{k(x)}(x))\bigr). \end{align*} Construct an oracle Turing machine $M^B$ as follows. On input $x \in \mathbb{N}$, the machine first runs the computable truth-table procedure to obtain $k(x)$, the query list $q_1(x),\dots,q_{k(x)}(x)$, and a code for $\beta_x$. It then asks the oracle $B$ each query $q_i(x)$, records the answer bit \begin{align*} b_i := \mathbb{1}_B(q_i(x)) \in \{0,1\} \end{align*} for each $i \in \{1,\dots,k(x)\}$, and finally computes \begin{align*} \beta_x(b_1,\dots,b_{k(x)}). \end{align*} All non-oracle computation performed by $M^B$ is computable, the number of oracle queries is finite for each input, and the oracle answers are exactly the bits required by the truth-table procedure. Therefore $M^B$ halts on every input $x$ and outputs $\mathbb{1}_A(x)$. Hence $A \le_T B$. [/step]

[step:Combine the implications] The first step proves $A \le_1 B \implies A \le_m B$. The second step proves $A \le_m B \implies A \le_{tt} B$. The third step proves $A \le_{tt} B \implies A \le_T B$. Since $A,B \subseteq \mathbb{N}$ were arbitrary, the full chain \begin{align*} A \le_1 B \implies A \le_m B \implies A \le_{tt} B \implies A \le_T B \end{align*} holds for all $A,B \subseteq \mathbb{N}$. [/step]