[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$.
[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]
[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]
