Hubbry Logo
Turing reductionTuring reductionMain
Open search
Turing reduction
Community hub
Turing reduction
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Turing reduction
Turing reduction
from Wikipedia

In computability theory, a Turing reduction from a decision problem to a decision problem is an oracle machine that decides problem given an oracle for (Rogers 1967, Soare 1987) in finitely many steps. It can be understood as an algorithm that could be used to solve if it had access to a subroutine for solving . The concept can be analogously applied to function problems.

If a Turing reduction from to exists, then every algorithm for [a] can be used to produce an algorithm for , by inserting the algorithm for at each place where the oracle machine computing queries the oracle for . However, because the oracle machine may query the oracle a large number of times, the resulting algorithm may require more time asymptotically than either the algorithm for or the oracle machine computing . A Turing reduction in which the oracle machine runs in polynomial time is known as a Cook reduction.

The first formal definition of relative computability, then called relative reducibility, was given by Alan Turing in 1939 in terms of oracle machines. Later in 1943 and 1952 Stephen Kleene defined an equivalent concept in terms of recursive functions. In 1944 Emil Post used the term "Turing reducibility" to refer to the concept.

Definition

[edit]

Given two sets of natural numbers, we say is Turing reducible to and write

if and only if there is an oracle machine that computes the characteristic function of A when run with oracle B. In this case, we also say A is B-recursive and B-computable.

If there is an oracle machine that, when run with oracle B, computes a partial function with domain A, then A is said to be B-recursively enumerable and B-computably enumerable.

We say is Turing equivalent to and write if both and The equivalence classes of Turing equivalent sets are called Turing degrees. The Turing degree of a set is written .

Given a set , a set is called Turing hard for if for all . If additionally then is called Turing complete for .

Relation of Turing completeness to computational universality

[edit]

Turing completeness, as just defined above, corresponds only partially to Turing completeness in the sense of computational universality. Specifically, a Turing machine is a universal Turing machine if its halting problem (i.e., the set of inputs for which it eventually halts) is many-one complete for the set of recursively enumerable sets. Thus, a necessary but insufficient condition for a machine to be computationally universal, is that the machine's halting problem be Turing-complete for . Insufficient because it may still be the case that, the language accepted by the machine is not itself recursively enumerable.

Example

[edit]

Let denote the set of input values for which the Turing machine with index e halts. Then the sets and are Turing equivalent (here denotes an effective pairing function). A reduction showing can be constructed using the fact that . Given a pair , a new index can be constructed using the smn theorem such that the program coded by ignores its input and merely simulates the computation of the machine with index e on input n. In particular, the machine with index either halts on every input or halts on no input. Thus holds for all e and n. Because the function i is computable, this shows . The reductions presented here are not only Turing reductions but many-one reductions, discussed below.

Properties

[edit]
  • Every set is Turing equivalent to its complement.
  • Every computable set is Turing reducible to every other set. Because any computable set can be computed with no oracle, it can be computed by an oracle machine that ignores the given oracle.
  • The relation is transitive: if and then . Moreover, holds for every set A, and thus the relation is a preorder (it is not a partial order because and does not necessarily imply ).
  • There are pairs of sets such that A is not Turing reducible to B and B is not Turing reducible to A. Thus is not a total order.
  • There are infinite decreasing sequences of sets under . Thus this relation is not well-founded.
  • Every set is Turing reducible to its own Turing jump, but the Turing jump of a set is never Turing reducible to the original set.

The use of a reduction

[edit]

Since every reduction from a set to a set has to determine whether a single element is in in only finitely many steps, it can only make finitely many queries of membership in the set . When the amount of information about the set used to compute a single bit of is discussed, this is made precise by the use function. Formally, the use of a reduction is the function that sends each natural number to the largest natural number whose membership in the set was queried by the reduction while determining the membership of in .

Stronger reductions

[edit]

There are two common ways of producing reductions stronger than Turing reducibility. The first way is to limit the number and manner of oracle queries.

  • Set is many-one reducible to if there is a total computable function such that an element is in if and only if is in . Such a function can be used to generate a Turing reduction (by computing , querying the oracle, and then interpreting the result).
  • A truth table reduction or a weak truth table reduction must present all of its oracle queries at the same time. In a truth table reduction, the reduction also gives a boolean function (a truth table) that, when given the answers to the queries, will produce the final answer of the reduction. In a weak truth table reduction, the reduction uses the oracle answers as a basis for further computation depending on the given answers (but not using the oracle). Equivalently, a weak truth table reduction is one for which the use of the reduction is bounded by a computable function. For this reason, weak truth table reductions are sometimes called "bounded Turing" reductions.

The second way to produce a stronger reducibility notion is to limit the computational resources that the program implementing the Turing reduction may use. These limits on the computational complexity of the reduction are important when studying subrecursive classes such as P. A set A is polynomial-time reducible to a set if there is a Turing reduction of to that runs in polynomial time. The concept of log-space reduction is similar.

These reductions are stronger in the sense that they provide a finer distinction into equivalence classes, and satisfy more restrictive requirements than Turing reductions. Consequently, such reductions are harder to find. There may be no way to build a many-one reduction from one set to another even when a Turing reduction for the same sets exists.

Weaker reductions

[edit]

According to the Church–Turing thesis, a Turing reduction is the most general form of an effectively calculable reduction. Nevertheless, weaker reductions are also considered. Set is said to be arithmetical in if is definable by a formula of Peano arithmetic with as a parameter. The set is hyperarithmetical in if there is a recursive ordinal such that is computable from , the α-iterated Turing jump of . The notion of relative constructibility is an important reducibility notion in set theory.

See also

[edit]

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia
from Grokipedia
A Turing reduction, also known as Turing reducibility, is a preorder relation in computability theory that compares the relative computational complexity of decision problems or sets of natural numbers by allowing one problem to be solved using an oracle for the other. Formally, a set AA is Turing reducible to a set BB, denoted ATBA \leq_T B, if there exists a Turing machine equipped with an oracle for BB—a hypothetical device that instantly answers membership queries about BB—that can decide membership in AA for any input. This concept enables the classification of problems based on how much "computational power" is required to solve them relative to each other, distinguishing it from stricter reductions like many-one reducibility by permitting multiple, adaptive oracle queries during computation. Introduced by Alan Turing in his 1938 PhD thesis Systems of Logic Based on Ordinals, the notion arose from his exploration of oracle machines as a way to extend the limits of standard Turing machines beyond undecidable problems like the halting problem, aiming to analyze hierarchies of formal logical systems. Turing reducibility forms the basis for Turing degrees, equivalence classes of sets under the relation ATBA \equiv_T B (where ATBA \leq_T B and BTAB \leq_T A), which structure the "degrees of unsolvability" in a partial order; the minimal degree is that of the recursive (computable) sets, denoted 00. A key operation is the jump AA', the Turing degree of the halting problem relative to AA, satisfying A<TAA <_T A' and enabling the construction of increasingly complex degrees, as developed further by Emil Post and Stephen Kleene in the 1940s. The importance of Turing reductions lies in their role in proving undecidability: if ATBA \leq_T B and AA is undecidable, then so is BB, providing a systematic method to establish the unsolvability of problems like or the by reducing the to them. This framework has profoundly influenced recursion theory, with results like the Friedberg-Muchnik theorem (1956) showing the existence of incomparable recursively enumerable degrees, and continues to underpin modern areas such as descriptive set theory and . Properties of Turing reducibility include its reflexivity (ATAA \leq_T A) and transitivity, but it does not preserve recursively enumerable sets downward, highlighting its focus on total computability rather than partial functions.

Definition and Formalism

Formal Definition

A Turing reduction from a AA to a BB is a procedure computable by a that determines whether an input xAx \in A by making queries to an for BB, such that xAx \in A if and only if the oracle reports affirmatively on the relevant instances of BB. This procedure effectively transforms the problem of deciding AA into a series of decisions about BB, allowing the relative of AA to BB to be established. An formalizes this reduction: it is a standard augmented with an additional oracle tape and the ability to query it. Upon entering a designated query state qQq_Q, the machine writes a string ww on the oracle tape; the oracle then instantaneously replaces ww with 1 if wBw \in B or 0 if wBw \notin B, after which computation resumes from the next state. Formally, if MBM^B denotes the oracle MM equipped with BB, then AA is Turing reducible to BB, denoted ATBA \leq_T B, if there exists such an MM where MBM^B decides AA. Turing reducibility is transitive: if ATBA \leq_T B and BTCB \leq_T C, then ATCA \leq_T C. To see this, suppose M1BM_1^B decides AA and M2CM_2^C decides BB; construct M3CM_3^C that simulates M1M_1 on input xx but, whenever M1M_1 would query its for BB on some yy, M3M_3 instead runs M2CM_2^C on yy to obtain the answer from the CC-oracle and feeds it back to the simulation of M1M_1. Since simulations of Turing machines are computable, M3CM_3^C decides AA, establishing the reduction.

Relation to Oracle Machines

An Turing machine extends the standard model of a Turing machine by incorporating an additional oracle tape and a corresponding oracle head, along with designated query states that allow the machine to consult an external for decision problems. This augmentation enables the machine to solve problems beyond its native computational power by treating the oracle as a black-box subroutine that decides membership in a fixed . To make a query, the oracle Turing machine first writes the instance—typically a representing the input to the set—onto the tape, positioning the oracle head at the beginning of this . The machine then enters a query state, at which point the oracle instantaneously inspects the tape content and provides a yes/no answer by either overwriting a designated (such as replacing a query marker with '1' for yes or '0' for no) or transitioning the machine to one of two response states, allowing to continue based on the result. This process models the subroutine call in a Turing reduction, where the oracle acts as an idealized decider for the target problem without revealing its internal mechanism. The concept of Turing reducibility, denoted ATBA \leq_T B, is precisely captured by oracle Turing machines: a language AA is Turing reducible to BB if there exists an oracle Turing machine that, with BB as its oracle, decides membership in AA. This equivalence holds because any Turing reduction procedure, which involves a finite number of adaptive queries to BB followed by local computation, can be simulated by the oracle machine's tape operations and state transitions, ensuring the machine halts with the correct output for every input in AA. Relativization refers to the practice of interpreting and results relative to an arbitrary set, where classes like the recursively enumerable languages or recursive languages are defined with respect to the 's power. For instance, the class REA\text{RE}_A consists of languages accepted by nondeterministic Turing machines with AA, highlighting how models preserve structural properties of independently of the specific chosen.

Examples

Canonical Example with Halting Problem

The halting problem, denoted HH, is the set of all pairs P,x\langle P, x \rangle, where PP is the description of a Turing machine and xx is a finite input string, such that PP halts on input xx. A basic illustration of a Turing reduction involves reducing HH to itself, which is trivial: an oracle Turing machine MHM^H decides membership in HH by querying its oracle for HH directly on the input P,x\langle P, x \rangle and outputting the oracle's yes or no response. This single-query procedure demonstrates how access to an oracle for a problem enables its own solution via Turing reduction. Another canonical construction reduces the general halting problem HH to the blank-tape halting problem H={PPH_\emptyset = \{ \langle P \rangle \mid P halts on the empty tape }\}, showing HTHH \leq_T H_\emptyset. On input P,x\langle P, x \rangle, an oracle Turing machine MHM^{H_\emptyset} proceeds as follows:
  1. Compute the encoding Q\langle Q \rangle of a new Turing machine QQ, constructed such that QQ, when started on any input (including the blank tape), first erases the tape, then writes the fixed string xx onto it (hardcoding xx into QQ's finite description, which is possible since xx is given and finite), positions the tape head appropriately, and finally simulates PP starting from that configuration.
  2. Query the for HH_\emptyset on Q\langle Q \rangle.
  3. If the oracle returns yes (QQ halts on blank tape), accept (PP halts on xx); otherwise, reject.
This algorithm uses one oracle query and halts on all inputs, correctly deciding HH because QQ on blank tape replicates the computation of PP on xx and thus halts if and only if PP does. Such reductions underscore that HH cannot be Turing reducible to any decidable set DD. If HTDH \leq_T D for decidable DD, the oracle machine deciding HH relative to DD could be transformed into a standard Turing machine by replacing each oracle query to DD with a direct simulation using DD's decider (which always halts); this would yield a decider for HH, contradicting the undecidability of HH.

Example in Post's Correspondence Problem

Post's Correspondence Problem (PCP) is a introduced by Emil Post in 1946. Given two finite lists of strings U=(u1,,uk)U = (u_1, \dots, u_k) and V=(v1,,vk)V = (v_1, \dots, v_k) over an alphabet Σ\Sigma with Σ2|\Sigma| \ge 2, the question is whether there exists a sequence of indices i1,i2,,ini_1, i_2, \dots, i_n (with n1n \ge 1 and repetitions allowed) such that the concatenation ui1ui2uin=vi1vi2vinu_{i_1} u_{i_2} \dots u_{i_n} = v_{i_1} v_{i_2} \dots v_{i_n}. A from the to PCP provides a concrete example of how such reductions establish undecidability. The reduction constructs a RR that, on input M,w\langle M, w \rangle (where MM is a Turing machine and ww is a string), computes a PCP instance PP encoding the possible computations of MM on ww, and then queries an for PCP on PP. If the oracle indicates that PP has a solution, RR outputs that MM halts on ww; otherwise, it outputs no. Since the halting problem is undecidable, this reduction shows that PCP is undecidable. The detailed construction encodes the PCP instance PP so that a matching sequence of tiles corresponds exactly to a valid computation history of MM on ww that reaches the halting state. The tiles are designed as follows: The includes symbols for tape contents, states, and head position. There is an initial tile representing the starting configuration of MM on ww (top and bottom match the initial instantaneous description, or ID). For each possible transition rule of MM (read symbol aa, write bb, move direction DD, new state qq), there are corresponding tiles that "advance" the : the top string encodes the current ID, while the bottom encodes the subsequent ID after applying the transition. Additional tiles handle the head movement and symbol writing to ensure alignments only occur for valid steps. A special set of tiles allows matching only upon reaching a halting configuration, with no further extendable match possible otherwise. A solution to PP thus exists there is a finite computation path from the initial ID to a halting ID, i.e., MM halts on ww. This encoding was originally developed by .

Properties

Closure Properties

The Turing degrees are the equivalence classes of sets of natural numbers under Turing equivalence, denoted ATBA \equiv_T B, which holds if and only if ATBA \leq_T B and BTAB \leq_T A. This partitions the power set of the natural numbers into degrees that measure relative computational difficulty. The relation T\leq_T on sets induces a partial order on the Turing degrees that is reflexive, as every set is Turing reducible to itself via the identity functional, and antisymmetric, since mutual Turing reducibility implies equivalence and thus membership in the same degree. The poset of Turing degrees forms an upper semi-lattice under the join operation, where for degrees a=degT(A)\mathbf{a} = \deg_T(A) and b=degT(B)\mathbf{b} = \deg_T(B), the least upper bound ab=degT(AB)\mathbf{a} \vee \mathbf{b} = \deg_T(A \cup B). To see closure under union, note that if CTDC \leq_T D and ETDE \leq_T D, then CETDC \cup E \leq_T D, as one can compute CEC \cup E from DD by applying the respective Turing functionals for CC and EE and taking their union; coding CC and EE into disjoint effective ranges ensures recoverability from the union. Oracle machines facilitate this by simulating computations over the union to decide membership in either component. The Turing degrees do not form a full lattice, as not every pair admits a greatest lower bound (meet). This non-closure under intersection manifests particularly in the recursively enumerable (r.e.) degrees, where meets may exist but are often trivial (degree 0\mathbf{0}).

Degrees and Comparability

The Turing degrees, denoted D\mathcal{D}, form an upper semi-lattice under the partial order induced by Turing reducibility, where the degree of a set XX, written deg(X)\mathbf{deg}(X), represents the of all sets Turing equivalent to XX. This structure classifies the relative of unsolvable problems, with 0\mathbf{0} as the least degree containing all recursive sets. The arithmetic hierarchy organizes sets into levels Σn0\Sigma_n^0 and Πn0\Pi_n^0 based on the number of alternations of quantifiers in arithmetic formulas defining them, corresponding directly to Turing degrees via iterated jumps of the . Specifically, Post's theorem establishes that a set AA belongs to Σn0\Sigma_n^0 if and only if AT(n)A \leq_T \emptyset^{(n)}, the nnth Turing jump of the , and similarly AΠn0A \in \Pi_n^0 if and only if AT(n)A \leq_T \emptyset^{(n)}. These levels form increasing chains in the Turing degrees, with 0(n)=deg((n))\mathbf{0}^{(n)} = \mathbf{deg}(\emptyset^{(n)}) strictly above 0(n1)\mathbf{0}^{(n-1)}, capturing the progressive increase in unsolvability. The union of all finite levels yields the arithmetic sets, all of which are Turing reducible to some finite jump (k)\emptyset^{(k)}. Extending beyond the arithmetic hierarchy, the hyperarithmetic hierarchy classifies sets through transfinite iterations of the Turing jump up to the Church-Kleene ordinal ω1CK\omega_1^{CK}, the smallest ordinal not representable by a computable well-ordering. A set is hyperarithmetic if it is Turing reducible to (α)\emptyset^{(\alpha)} for some computable ordinal α<ω1CK\alpha < \omega_1^{CK}, with levels defined analogously to the arithmetic case but relativized to ordinal notations. Kleene introduced this hierarchy to capture the effective analogue of projective sets, showing that hyperarithmetic sets coincide with the Δ11\Delta_1^1 sets in descriptive set theory, all lying below the hyperjump 0(ω1CK)\mathbf{0}^{(\omega_1^{CK})}. This structure reveals a countable hierarchy of degrees denser than the arithmetic one but still properly contained in the full D\mathcal{D}. The Turing degrees exhibit incomparability, meaning the partial order is not a ; for any nonzero degree a\mathbf{a}, there exists b\mathbf{b} such that neither aTb\mathbf{a} \leq_T \mathbf{b} nor bTa\mathbf{b} \leq_T \mathbf{a}. The Friedberg-Muchnik theorem proves this by constructing two recursively enumerable sets AA and BB that partition the halting set KK (i.e., AB=KA \cup B = K, AB=A \cap B = \emptyset) such that deg(A)\mathbf{deg}(A) and deg(B)\mathbf{deg}(B) are incomparable, resolving Post's problem on the existence of non-trivial r.e. degrees. These minimal degrees, where no degree strictly between 0\mathbf{0} and the minimal one exists, further illustrate the branching structure. The poset D\mathcal{D} is dense: for any degrees a<b\mathbf{a} < \mathbf{b}, there exists c\mathbf{c} such that a<c<b\mathbf{a} < \mathbf{c} < \mathbf{b}. This property, established through priority constructions and forcing techniques, underscores the intricate, non-linear nature of the degrees, with infinitely many degrees between any comparable pair, contrasting with linear hierarchies like the arithmetic one.

Applications

Role in Undecidability Proofs

Turing reductions are instrumental in undecidability proofs within , enabling the transfer of undecidability from a known to another. The core strategy posits that if a problem AA Turing-reduces to the HH (denoted ATHA \leq_T H), and HH is undecidable, then AA must also be undecidable; for if AA were decidable, one could construct a decider for HH by composing the decider for AA with the reduction, yielding a contradiction. This leverages the constructive nature of Turing reductions, where queries to an for AA simulate computations relative to HH. The HH, defined as the set of pairs (M,w)(M, w) where MM halts on input ww, serves as the foundational undecidable set in this framework. A landmark application appears in Alan Turing's 1936 proof of the undecidability of the , Hilbert's question of whether there exists a general to determine the provability of statements in . Turing reduced this problem to the by encoding machine computations as logical formulas and showing that the provability of a formula UnU_n (asserting that machine nn eventually prints a specific symbol) corresponds exactly to whether the machine halts. Assuming a decision procedure for provability would then decide halting, which Turing had already shown impossible via diagonalization, thus establishing the result. Rice's theorem extends this reduction technique to a broad class of problems, stating that for any non-trivial property CC of the languages recognized by Turing machines (i.e., CC contains some but not all recursively enumerable sets), the {eL(ϕe)C}\{e \mid L(\phi_e) \in C\} is undecidable. The proof constructs a Turing reduction from the to this index set by modifying a to check membership in CC after simulating the relevant computation, implying that decidability of the index set would decide halting. Another significant application is the undecidability of , which asks whether there exists an to determine if a given (polynomial equation with integer coefficients) has integer solutions. In 1970, , building on work by Martin Davis, , and , proved this by showing that every recursively enumerable set is Diophantine, allowing a Turing reduction from the to the solvability of such equations. The —determining whether a given word in the generators of a finitely presented group represents the —was also shown undecidable using Turing reductions from the . Pyotr Novikov (1955) and William Boone (1959) independently constructed finitely presented groups whose word problems are undecidable, embedding computations of Turing machines into group relations. Diagonalization, as employed by Turing to prove the undecidable, synergizes with Turing reductions to construct universal undecidable sets, such as the diagonal halting set K={eϕe(e)}K = \{e \mid \phi_e(e) \downarrow\}, which captures all recursively enumerable sets via appropriate reductions and serves as a complete set in the Turing degrees. This combination allows for the systematic derivation of undecidability for myriad problems by reducing them to KK, highlighting the hierarchical structure of undecidable sets.

Use in Complexity Theory

In , polynomial-time , denoted as Tp\leq_T^p, extend the notion of many-one by permitting a polynomial-time to make multiple adaptive queries to an for the target problem. These are particularly useful for establishing completeness in resource-bounded classes like , where a language LL is if LL \in and for every AA \in , ATpLA \leq_T^p L. Unlike many-one , which map an instance to a single instance of the target problem, enable the solving machine to adapt its strategy based on responses, facilitating the handling of problems with inherent branching or alternating structures. A representative example of their application appears in the analysis of the true quantified Boolean formulas problem (TQBF), which is . Turing reductions are preferred over many-one reductions in certain contexts because adaptive queries capture dependencies that a single mapping cannot, such as iterative refinements in sparse set reductions or under assumptions separating deterministic and randomized completeness. For instance, under the assumption that contains dense hard sets, there exist languages that are complete under Tp\leq_T^p but not under polynomial-time many-one reductions (mp\leq_m^p). However, polynomial-time Turing reductions are not typically used to define , where Karp reductions (mp\leq_m^p) remain the standard. This is because Turing reductions are weaker (more permissive), potentially equating a language with its complement via answer flipping, which disrupts NP's asymmetry with ; many-one reductions provide finer granularity and align with Cook's original theorem for circuit satisfiability.

Stronger Reductions

A set AωA \subseteq \omega is many-one reducible to a set BωB \subseteq \omega, denoted AmBA \leq_m B, if there exists a total computable function f:ωωf: \omega \to \omega such that for all xωx \in \omega, xAx \in A if and only if f(x)Bf(x) \in B. This form of reduction is stricter than a Turing reduction because it relies solely on a computable pre-processing step to produce a single query to BB, with membership in AA determined directly by the oracle response without additional computation. Truth-table reducibility provides an intermediate level of restriction. A set AA is truth-table reducible to BB, denoted AttBA \leq_{tt} B, if there exists a Turing functional Φ\Phi such that ΦB(x)\Phi^B(x) \downarrow for all xx, and for each xx, Φ\Phi computes (without oracle access) a finite sequence of queries y1,,ykωy_1, \dots, y_k \in \omega and a computable Boolean function h:{0,1}k{0,1}h: \{0,1\}^k \to \{0,1\} (a truth table of size at most 2k2^k) such that xAx \in A if and only if h(χB(y1),,χB(yk))=1h(\chi_B(y_1), \dots, \chi_B(y_k)) = 1, where χB\chi_B is the characteristic function of BB. Unlike Turing reductions, which permit adaptive queries where each question may depend on prior answers, truth-table reductions require all queries to be fixed in advance and the decision to follow a pre-specified truth table on the responses. Every is a , as a single-query reduction corresponds to a truth table of size 2 where membership holds exactly when the oracle response is affirmative. Similarly, every truth-table reduction is a , since the fixed list of queries can be posed non-adaptively to the oracle for BB, followed by evaluation of the truth table. Thus, mttT\leq_m \subseteq \leq_{tt} \subseteq \leq_T as relations on sets. These inclusions are strict: for mtt\leq_m \subsetneq \leq_{tt}, consider the complement of the halting set K={eωφe(e)}\overline{K} = \{e \in \omega \mid \varphi_e(e) \uparrow \}, where K={eωφe(e)}K = \{e \in \omega \mid \varphi_e(e) \downarrow \}; KttK\overline{K} \leq_{tt} K via the single query to ee with truth table accepting on response 0, but K̸mK\overline{K} \not\leq_m K since the latter would imply K\overline{K} is recursively enumerable, contradicting that K\overline{K} is not r.e. while KK is. For ttT\leq_{tt} \subsetneq \leq_T, Post constructed pairs of sets A,BA, B such that ATBA \leq_T B but A̸ttBA \not\leq_{tt} B, establishing the existence of Turing degrees incomparable under truth-table reducibility. Many-one reducibility preserves recursively enumerability: if AmBA \leq_m B and BB is r.e., then AA is r.e., as the preimage under the computable ff of an of BB yields an enumeration of AA. Truth-table reducibility does not preserve r.e.-ness in general, as the example KttK\overline{K} \leq_{tt} K demonstrates, with KK r.e. but K\overline{K} not. These preservation properties highlight why many-one reductions are considered stronger, enabling finer distinctions in the structure of unsolvability degrees compared to the broader Turing reductions.

Weaker Reductions

Weaker impose additional constraints on the usage in a Turing reduction, limiting its expressive power compared to the full adaptive querying allowed in standard Turing reductions. These variants are useful for studying finer structures in the Turing degrees, such as separating sets based on query patterns or properties. Unlike full Turing reductions, weaker forms may fail to transfer undecidability in cases where the oracle provides no affirmative answers, highlighting their restricted applicability. Bounded Turing reductions, also known as weak truth-table (wtt) reductions, restrict the computation such that the set of queried strings (the "use") is computable from the input alone, effectively bounding the number of oracle queries by a computable function of the input size. This ensures that the oracle answers influence the computation in a controlled manner, without unbounded adaptive branching based on prior responses. For instance, disjunctive truth-table reductions compute the output as the disjunction of oracle answers to a computable list of queries, forming a subclass where the decision accepts if at least one query is affirmative. These reductions are instrumental in analyzing degrees where computational resources are limited, as explored in foundational work on recursive function theory. Positive reductions further restrict oracle queries to instances that are guaranteed to be positive (i.e., members of the oracle set), ensuring that the reduction never queries potential non-members. Formally, a set A is positive Turing reducible to B if there exists a Turing reduction from A to B such that for every input x, the queries generated depend only on affirmative oracle responses, preserving "positive " from B to A. This notion arises in studies of immunity and hyperimmunity in recursion theory, where it characterizes sets avoiding infinite computable subsets while maintaining directional information properties. Stronger variants, like strong positive reducibilities, extend this by requiring monotonicity in query generation, aiding proofs of non-trivial degrees below the . A key limitation of weaker reductions is their inability to fully capture undecidability transfers in trivial cases. For instance, there is no bounded Turing reduction from the H to the ∅, as any such reduction would generate only computably many queries answered negatively, yielding a computable procedure overall—contradicting the undecidability of H. This failure underscores how query bounds prevent simulating the full adaptive power needed for non-trivial uses, even though full Turing reductions also cannot reduce H to ∅ for similar reasons. Positive variants exhibit analogous shortcomings when the lacks sufficient affirmative information to resolve undecidable queries.

References

Add your contribution
Related Hubs
User Avatar
No comments yet.