On the Structure of Turing Universe: The Non-Linear Ordering of Turing Degrees

(1)

On the Structure of Turing Universe:

The Non-Linear Ordering of Turing Degrees

Yazan Boshmaf

^∗

November 22, 2010

Abstract

“Turing Universe: the final frontier. These are the voyages of five mathematicians. Their ongoing mission: to explore strange new computability problems, to seek out new degrees of unsolvability and new structures, to boldly go where no man has gone before.”

- Adapted from Star Trek This paper is a study of the Turing Universe, which is a collection of all Turing Degrees. In respect, Turing Degrees are levels of computability naturally arising from the set of natural numbers. We show that there exist incomparable pairs of Turing Degrees as to prove the non-linearity of the Turing Universe. This study focuses on the works of five great mathematicians who had the greatest impact on Computability Theory: G¨odel, Church, Turing, Kleene, and Post.

∗Department of Electrical and Computer Engineering, University of British Columbia, Vancouver, Canada. (e-mail: [email protected])

(2)

1 Introduction

The goal of this paper is to prove the non-linearity of the Turing universe.

The proofs we present are intuitive and simplistic compared to the original ones, and use basic results in computability theory.

Let us give some background on Turing universe and its structure. For any two sets A, B ⊆ N, we say A is Turing reducible to B (written A ≤T B) if the characteristic function of A, χA, is computable by an oracle Turing machine, ˆT , using an oracle B. An oracle Turing machine is a normal Turing machine with an extended power to query an external information source (called an oracle) concerning set memberships. We call A and B Turing equivalent (written A ≡_T B) if they are reducible to each other. The “≡_T” operator defines an equivalence relation whose class is called a Turing degree or a degree of unsovability. That is, for any set A ⊆ N

a = degree(A) := {X ⊆ N | X ≡T A}

is the degree of all sets that are Turing equivalent to A. The Turing universe D is a collection of all Turing degrees. The Turing universe is defined as a partial order that is induced by the operator “≤_T” over all sets of natural numbers. That is, for any two sets A, B ⊆ N

a ≤ b ⇐⇒ A ≤_T B

where a and b are the Turing degrees of the sets A and B, respectively.

There is an interesting substructure of D that contains the degrees of all sets whose elements can be effectively listed. These sets are called computably enumerable (c.e.) sets and can be viewed as unbounded search problems. For a set A ⊆ N, we say A is c.e. in B if we can computably enumerate the elements of A using an oracle B. We say the degree a is c.e. in b if some A ∈ a is c.e. in B ∈ b. Finally, we write E for the collection of all c.e. Turing degrees.

The goal of this paper is to prove that D and E are not linearly ordered (the latter case is known as Post’s Problem), that is, there exists a pair of Turing degrees that are incomparable. The goal is to prove the following theorem:

(4)

Theorem (Kleene-Post, Friedberg-Muchnik): There exist (c.e.) Tur- ing degrees a and b such that a 6≤_T b and b 6≤_T a.

We will now summarize the proofs and the rest of the paper. We construct two sets A and B such that A 6≤_T B and B 6≤_T A, where a = degree(A) and b = degree(B). The construction involves satisfying two relations which we call requirements. The requirements for constructing the sets A and B are:

R_2i: χ_A6= Φ^B_i R_2i+1: χ_B 6= Φ^A_i

where i ∈ N is the construction stage, and Φ^Si is the {0,1}-valued output of the i^th oracle Turing machine, ˆT_i, using the oracle S. In the case of D, we construct A and B as a sequence of binary strings representing their characteristic functions according to some strategy, as shown by Kleene and Post.

Satisfying the requirements for E , on the other hand, is more difficult as we cannot use oracles. We use set approximating sequences and define strategies that utilize priorities as a rule for selecting a candidate element for inclusion in either A or B. This method is known as the priority method and was proposed independently by Friedberg and Muchnik. We review all major results in computability theory that are needed to develop the aforementioned methods.

“So what?”, we hear you say. First, we argue that defining a hierarchical structure for complex problems is very important to reveal the dynamic relationships between different levels of abstraction¹. Moreover, putting such a hierarchical structure in a descriptive framework allows us to investigate each level with its local constraint. In respect, this is the underlying power of Turing universe. We can now get a deeper understanding of G¨odel’s Incom- pleteness Theorem and potentially leap over the unproved (and perhaps the unprovable) assumptions of incomputability, on which it is based. Second, if we look at computable and incomputable sets as having some computational information content (such as their mathematical description), then the existence of incomparable sets leads us to the fact that these sets hold different kinds of information content; a first result towards understanding the nature

1This is not surprisingly new. In science, the study of quantum mechanics, atoms, molecules, cells, organism, and so on, revealed many interesting properties between such different levels of abstraction.

(5)

of computability in complex environments, and its relationship to basic science and the empirical observation through algorithmic processes. What a rich and interesting topic!

We wish to thank the following people: Bader AlAhmad for his exquisite discussions and interest in the subject matter, Prof. Joel Friedman for intro- ducing us to the beautiful world of theoretical computer science, and for his unparalleled (and addictive) teaching style, the authors of the references for providing the means for this study to materialize, and last but not least, we thank the folks at ICICS Reading Room for the unlimited supply of chocolate bars and candy.

2 Computable Functions

What is a computable function? How can we formalize it in a rigorous mathematical model? In this section, we give an informal intuition on how a function can be computed. Then, we formalize the discussion and present two basic models of computation. Finally, we show that all of the accepted models define the same class of computable functions.

2.1 Informal Description

An algorithm for a function² f : N → N is a finite set of instructions which, given an input x ∈ N, yields an output y = f (x) in a finite number of steps.

Intuitively, such an algorithm must specify how to obtain each step of its calculations from previous steps and its input x. Informally, we say f is a computable function if there is an algorithm that calculates the output f (x) for each input x ∈ N. Note that this algorithm halts if f (x) is defined for all x ∈ N. Otherwise, it will “loop” forever, that is, it will not halt.

It should be noted that the algorithm of any computable function could be calculated by any modern computer, if one ignores the restrictions on the amount of computing time and storage capacity.

2In this study, we fix a domain for computable functions which is the set of natural numbers. This is the most basic set we can choose that is capable of expressing a full range of mathematical practice. This, however, can be extended to include rational number by proper enumeration or encoding.

(6)

2.2 Formal Definitions

We discuss two formal models of computation. There is, however, a consensus that these and other models give rise to exactly the same class of functions.

It is safe to say that all results presented in this study are independent of the chosen formal model of computation.

2.2.1 Recursive Functions

The natural way to devise an algorithm is by stating some logical assertions about how something could be done in a finite number of steps. Accordingly, the language of logic seems very suitable to express such algorithms, and in particular, the logical induction. Charged with this intuition, the great mathematician, G¨odel, defined what is called primitive recursive functions as follows.

Definition 1 (Primitive Recursive Functions): The class of primitive recursive functions includes all functions that are either initial functions or constructed from initial functions using substitution and primitive recursion rules, as follows:

(1) The following initial functions are primitive recursive:

(a) The zero function defined by:

0(n) = 0, ∀n ∈ N, (b) The successor function defined by:

n⁺ = n + 1, ∀n ∈ N, (c) The projection functions defined by:

U_i^k( ~m) = m_i, for each k ≥ 1, and i = 1, . . . , k, (where we write ~m = m₁, . . . , m_k).

(2) If g, h, h₀, . . . , h_l are primitive recursive then so is f obtained from these preceding functions, by one of the following rules:

(a) The substitution rule given by:

f ( ~m) = g(h₀( ~m), . . . , h_l( ~m)), (b) The primitive recursion rule given by:

f ( ~m, 0) = g( ~m),

f ( ~m, n + 1) = h( ~m, n, f ( ~m, n)).

(7)

Example 1: The function f (x, y) = x + y is primitive recursive.

This is clear once we apply the rules in Definition 1 as follows:

f (m, 0) = U₁¹(m) = m,

f (m, n + 1) = (f (m, n))⁺= (U₃³(m, n, f (m, n))⁺= (m + n) + 1.

So far, based on our definition of primitive recursive functions, we intuitively insist that there exist some algorithms that compute such functions.

This, however, is not enough as the class of primitive recursive functions does not include all computable functions. The general argument is that there exist some recursive functions that are not primitive but are computable. This can be shown by a simple diagonalization of all primitive recursive functions (which are total functions), and then one can define a recursive function that is not primitive. This function turns out to be partial. This demands that we extend the class to include all partial recursive functions. But first, let us define what we mean by total and partial functions.

Definition 2 (Total and Partial Functions): We say that a function f : A → B is total if f (x) is defined (written f (x) ↓) for every x ∈ A. Oth- erwise, if f (x) is undefined (written f (x) ↑) for some x ∈ A, we say that f is partial.

Now, let us extend the class of primitive recursive functions to include all partial recursive functions as follows.

Definition 3 (Partial Recursive Functions): A function f is partial recursive (written p.r.) if f can be defined using initial functions and a finite number of applications of the rules in Definition 1, in addition to one other rule called the minimalization rule, defined by:

If g(~n, m) is p.r., then so is f (~n) = µm[g(~n, m) = 0],

where µm[P (m)] means the minimal value of m such that P (m) is true.

Moreover, we call a p.r. function, f , recursive if it is total.

The µ-operator can be viewed as a search operation where the algorithm that computes f (~n) computes g(~n, 0), g(~n, 1), g(~n, 2) . . . and stops whenever g(~n, m₀) = 0 at which m = m₀. This computation can never halt as well.

Again, we still insist that all (partial) recursive functions are computable based on the intuitive idea of logical induction. Luckily, Church was working

(8)

on his, yet equivalent, λ-calculus and conjectured the following — which we accept as true as many experts in the field did.

Thesis 1 (Church): The following are equivalent for any function f : (1) f is recursive ⇐⇒ f is total and effectively computable.

(2) f is p.r. ⇐⇒ f is effectively computable.

What is meant by f being “effectively” computable is that there exists some description of an algorithm, in some language, which can be used to compute any value f (x) in a finite number of steps for which f (x) ↓.

Based on Thesis 1, we can extend our discussion of computability to include sets and relations. This is done by defining a characteristic function for each set or relation, and then call such a set or relation computable if their corresponding characteristic functions are computable, as follows.

Definition 4 (Recursive Relations and Sets): Let S be any set, and R be any relation. We define their computability as follows.

(1) First, define the characteristic function of S and R by:

χ_S(x) =

(1, if x ∈ S, 0, if x 6∈ S, χ_R(~x) =

(1, if R(~x) is true, 0, if R(~x) is false,

(2) We say S or R are recursive, if χ_S(x) or χ_R(~x) are recursive as well.

Example 2: The relation “<” is recursive (or efficiently computable).

We show this by showing that n < m is primitive recursive. Let γ(m) be the predecessor function defined by:

γ(m) =

(m − 1, if m > 0, 0, if m = 0,

(9)

This function is primitive recursive as γ(0) = 0(n) and γ(m + 1) = U₁²(m, γ(m)). Now, let diff(m, n) be the recursive difference function defined as follows:

diff(m, n) =

(m − n, if m ≥ n, 0, if m < n,

The function f is primitive recursive as diff(m, 0) = U₁¹(m) = m and diff(m, n+1) = γ(U₃³(m, n, diff(m, n))). Finally, let ztest(m) be the zero- test function defined as follows:

ztest(m) =

(0, if m = 0, 1, if m 6= 0,

It is clear that this function is also primitive recursive as ztest(0) = 0(n) and ztest(m + 1) = (U₂²(m, ztest(m)))⁺.

Now, we have χ_<(n, m) = ztest(diff(m, n)) = ztest ◦ diff(m, n), and hence, the relation n < m is primitive recursive.

Here is another useful result that simplifies our use of the µ-operator.

Proposition 1 (Minimalization and Recursive Relations): If R( ~m, n) is a recursive relation, then f defined by

f ( ~m) = µn[R( ~m, n)] := the least n such that R( ~m, n) holds, is partial recursive as well.

Proof: Notice that the χ¬R( ~m, n) = diff(1, χ_R( ~m)), which is primitive recursive. Now, by Definition 3, f ( ~m) = µn[χ_¬R( ~m, n)], and hence, f ( ~m) is primitive recursive.

Finally, we propose the following useful recursive function that we will use in the upcoming sections to effectively list pairs of natural numbers.

Proposition 2 (The Recursive Pairing Function): There exists a bi- jective recursive pairing function h., .i : N × N → N.

Proof: We use Thesis 1. First, we construct and array of all pairs of natural

(10)

numbers. After that, we list the pairs in the array algorithmically in a carefully selected order such that we do not go in a direction that is infinite before listing other previous pairs. This defines the required function.

Alternatively, we can define hx, yi = 2^x3^y, which is primitive recursive³, injective, and well-defined. Hence, h., .i is recursive.

2.2.2 Turing Machines

Turing machines, named after their inventor Alan Turing, are by far the strongest model of computation because they are a true measure of how difficult it is to carry out a particular type of computation. Hence, they became the standard model in the study of computational complexity. We will consider the classical Turing machine in this study, which has many equivalent variants (see Sipser’s book for a proper treatment).

The hardware of a Turing machine consists of a tape, divided into cells, which is infinitely extendable in both directions, and a read/write head.

When talking about a Turing machine, T , we actually mean its program.

Turing programs are the internal states of T (Turing refers to them as the human “states of mind”). We describe T as follows:

1. The tape symbols, called the tape alphabet, are the symbols that are allowed to be written on the tape, where each tape cell contains exactly one symbol. We refer to the tape symbols as the set Σ = {0, 1}, where 0 represents an empty (or blank) cell.

2. An infinite list of internal states, represented by the set Ω = {q₀, q₁, . . . }.

At the start of any given computation, T always starts in one state, q₀. 3. The action symbols, represented by the set Γ = {0, 1, L, R}, where 1 means “write 1”, 0 means “write 0 or erase current cell”, L means

“move head one cell to the left”, and R means “move head one cell to the right”.

4. The Turing program, P = {Q₁, . . . , Q_n}, is formed from a set of instructions, called quadruples. Any quadruple Q_k is in the form q_iSAq_j, which means “if T is currently at state qi ∈ Ω reading tape symbol S ∈ Σ, then perform action A ∈ Γ and go to the new state q_i ∈ Ω”.

3By showing that both exp(x) = c^x and mult(x, y) = xy are primitive recursive for some constant c, then it follows that hx, yi = 2^x3^y is primitive recursive as well.

(11)

Definition 5 (Turing Machines Input Convention): To input n ∈ N to a Turing machine, T , place n + 1 consecutive 1’s on the tape and then set the reading head in q0 reading the leftmost 1.

Definition 6 (Turing Machines Output Convention): If a Turing machine, T , halts its computation on input n ∈ N (i.e., there are applicable quadruple in T ), output the number ϕ_T(n) of 1’s left-printed on the tape.

Note that we input n + 1 consecutive 1’s for uniformity — all computations, even those with input 0, start with the head reading the leftmost 1.

Definition 7 (Turing Computable Functions): A function f (n) is Tur- ing computable if f (n) = ϕ_T(n) for all n ∈ N on some Turing machine T . Example 3: The successor function is Turing computable.

Let T have a Turing program P = ∅ (the empty program). Then ϕ_T(n) = n+1 for all n ∈ N.

Example 4: The zero function is Turing computable.

Let T have the following Turing program P :

q010q1 := quadruple for deleting 1’s, q₁0Rq₀ := quadruple for moving right, Hence, ϕ_T(n) = 0 = 0(n) for all n ∈ N.

Definition 8 (Extended Turing Machines Input/Output): We asso- ciate with a Turing machine, T , a partial function ϕ^(k)_T of k variables, by making ϕ^(k)_T (~n) the output when T is run on the input ~n = n₁, . . . , n_k. We input ~n as 1₀. . . 1_n₁₊₁ 0 1₀. . . 1_n₂₊₁0 . . . 0 1₀. . . 1_n_k₊₁, and setting the reading head is state q₀ reading the leftmost 1.

2.2.3 Equivalence of Models

We have finished outlining the two classical models of computation. As promised, we will combine all the definitions of computable functions into a single thesis. Fortunately, this is the work of Church and Turing.

(12)

Thesis 2 (Turing): Every function for which there is an intuitively effective process for computing its values can be shown to be Turing computable.

This thesis had immediate support by the research community, which supported Church’s thesis. In belated recognition of Turing’s contribution, people usually refer to Church’s famous thesis as Church-Turing thesis.

Thesis 3 (Church-Turing): The following are equivalent for a function f : (1) f is effectively computable.

(2) f is recursive or partial recursive (p.r.).

(3) f is Turing computable.

And finally, we use Thesis 3 to define a unified definition for computable functions as follows.

Definition 9 (Computable Functions): A function f is computable if it is either recursive, partial recursive, effectively computable, or Turing computable.

3 Coding and The Universal Turing Machine

Given a Turing machine T and a computable function f over N, how can T be converted into a number e ∈ N, such that all Turing programs could be effectively listed? What does it mean to feed e to T and compute f (e)?

In respect, we first discuss G¨odel numbering for Turing machines and then show the existence of a Turing machine that takes its own description (and others) as an input.

3.1 G¨ odel Numbering for Turing Machines

We use G¨odel-style coding to get an effective listing of all Turing machines.

Given a set of all Turing programs P, there is an encoding Enc : P → N such that with some little adjustment we can get a decoding Dec : N → P by a computable inverse the Enc⁻¹. This will enable us to enumerate any program in P with a non-negative integer, and hence, call up other Turing programs by their index — just as a modern computer system does.

(13)

Before we do so, let us consider the set S = {x | x ∈ N is a prime}. It can be shown that S is primitive recursive. Let p₀, p₁, . . . be a list of all prime numbers in an increasing order, then any x ∈ N can be uniquely represented by the following:

x = p^x₀⁰p^x₁¹p^x₁¹. . . p^x_nⁿ. . . ,

for finitely many x_i 6= 0. Now, it can be shown that the function (x)_i := the exponent x_i of the prime p_i,

is a primitive recursive function of x. This function is very useful because for any countable set of non-negative integers {a₀, a₁, . . . }, there is a code number, a = p^a₀⁰p^a₁¹. . . , such that a_i = (a)_i is computed primitively recursively from a. This is usually referred to as multiplicative encoding.

Now given such an encoding, we apply it to Turing machines and start by encoding the tape symbols, action symbols, and internal states. Let

Enc(L) = 2 (the 0^th prime number p₀) Enc(R) = 3 (the 1^st prime number p1)

Enc(qi) = p_2+(2i) (the (2 + 2i)^th prime number) Enc(Si) = p_2+(2i+1)

We can then encode any quadruple Q. For Q = q_iSAq_i, let Enc(Q) = 2Ênc(q¹⁾× 3Ênc(S)× 5Ênc(A) × 7Ênc(q^j⁾ And finally, for any Turing program P = {Q₀, . . . , Q_n}, let

Enc(P ) = 2Ênc(Q⁰⁾× 3Ênc(Q¹⁾× · · · × pÊnc(Qn ⁿ⁾

be a G¨odel number e ∈ N for P . We can now define the following.

Definition 10 (The Turing Machine Code): The e^th Turing machine Pe

is defined by P_e =

(P, if Dec(e) ↓ = some Turing program P,

∅, otherwise (the empty program), and we say P_e has an index e.

(14)

Now, we can simplify our notation ϕ^(k)_T in Definition 8 by using the index of T as follows.

Definition 11 (The Indexed Turing Machine): For a Turing machine T with index e ∈ N, let

ϕ^(k)_T := the k-place partial function computed by P_e. We call ϕ_T = ϕ⁽¹⁾_T the e^th partial computable (p.c.) function.

Now, it is clear that the list ϕ0, ϕ1, . . . is an enumeration or effective listing of all Turing machines (or programs). This gives us the following theorem.

Theorem 1 (The Enumeration Theorem): The ϕz(x) is a p.c. function of x, z ∈ N such that for each e ∈ N, ϕe is the e^th (unary) p.c. function.

Proof: We only need to describe how to compute ϕz(x): (1) Find Pz by computing Dec(z). (2) Run P_z on input x and wait until P_z halts. (3) At this point, set the output to ϕ_z(x). The rest of the theorem follows from Definitions 10 and 11.

3.2 The Universal Turing Machine

What was special about Turing’s 1936 paper is not the description of the Turing machine itself as a model of computation (as some equivalent models were proposed independently at the same time such as Post machines), but the existence and the description of a universal Turing machine — the basis of the stored program concept.

Theorem 2 (The Universal Turing Machine): There exists a Turing machine, U , which when given the input (e, x), simulates the e^th Turing machine on the input x ∈ N. That is, ϕ²U(e, x) = ϕ_e(x). We call U the universal Turing machine.

Proof: Using Theorem 1 and Thesis 2, choose U which computes ϕ_z(x). Finally, it is useful to consider whether ϕe(x) ↓ or ϕe(x) = y is a computable relation of e, x, y ∈ N.

(15)

Definition 12 (Computable Approximation): We write ϕ_e,s(x) = y to state that for x, y, e < s, the output y of ϕ_e(x) is computed in less than s computational steps of Pe.

The bound on the number of computational steps is the one which en- sures computability by truncating infinite searches.

Corollary 1: The following statements are true:

(1) ϕ_e,s(x) ↓ and ϕ_e,s(x) = y are computable relations⁴ of s, e, x, y ∈ N.

(2) ϕ_e(x) ↓ ⇐⇒ (∃s)[ϕ_e,s(x) ↓].

(3) ϕ_e(x) = y ⇐⇒ (∃s)[ϕ_e,s(x) = y].

4 Enumerability and Computability

What does it mean to effectively list or enumerate elements of a set? How does that affect its computability? We now present a new standpoint of computable sets by rigorously stating how one can list their elements, and show how computability and enumeration relate to each other. We start with the following definition of computably enumerable (c.e.) sets.

Definition 13 (Computably Enumerable Sets): A set A ⊆ N is computably enumerable (written c.e.) if there is an effective process for enumerating (listing) all the elements of A. In other words, A is c.e. if A = ∅, or there is a computable function f such that A = {f (0), f (1), . . . } = range(f ).

In Proposition 2, we showed that there is a recursive pairing function, h., .i : N × N → N, that maps any pair of natural numbers to a unique natural number. Now for a computable set A ⊆ N × N, it is easy to see that the function h., .i is computable and effectively enumerates A. This is quite interesting as it shows us the relationship between computable sets and computably enumerable sets.

Theorem 3 (Computable Sets and Enumeration): If A ⊆ N is computable, then A is computably enumerable.

4Pun is consciously intended.

(16)

Proof: Given A is computable, then we can effectively decide whether x ∈ A or not for any given x ∈ N. Hence, we can effectively enumerate A by asking, in turn, “is x ∈ A?”, and each time we get a “yes”, we enumerate (or list) x into A.

We know that if a Turing program Pe with an index e halts on input x with an output ϕ_e(x), this means that ϕ_e(x) ↓ and x ∈ domain(ϕ_e). What can be said about the set W_e of all x ∈ N such that Pe(x) halts?

Definition 14 (The Halting Problem): Let W_e = domain(ϕ_e) for each e ∈ N, then we say that Pe has the halting set W_e. We also say that the halting problem for the e^th Turing machine is said to be solvable is We is a computable set.

Using Definition 12, we can write a computable approximation to the halting set W_e, using those for the p.c. function ϕ_e as follows.

Definition 15 (Computable Approximation of The Halting Set): We write W_e,s = domain(ϕ_e,s) for each e, s ∈ N.

Corollary 2 (The Normal Form of C.E. Sets): The following are equivalent for a set A ⊆ N:

(1) A is c.e.

(2) A = domain(ϕ_e) for the e^th computable function ϕ_e. (3) A = {x | ϕ_e(x) ↓}

(4) A = W_e for some e ∈ N. (so that We= the e^th c.e. set)

Moreover, we can use computable approximation of sets to define approximation sequences that are useful in the coming sections.

Definition 16 (C.E. Approximating Sequences): For a c.e. set X = W_e, we write X^s = We,s and call the sequence {X^s}s≥0 a standard c.e. approximating sequence. Moreover, we say that the sequence

X⁰ ⊂ X¹ ⊂ . . . X^s ⊂ . . . is a c.e. approximating sequence of X where X = S

s≥0X^s.

(17)

Now, we are ready to construct a c.e. counterpart of the universal Turing machine as follows.

Theorem 4 (The Enumeration of C.E. Sets): There is a c.e. set K₀ such that for each e ∈ N, we have the e^th c.e. set W_e = {x | hx, ei ∈ K₀}.

Proof: Define K₀ = {hx, ei | x ∈ W_e}. Then,

hx, ei ∈ K₀ ⇐⇒ x ∈ W_e ⇐⇒ (∃s)[x ∈ W_e,s] ⇐⇒ (∃s)[ϕ_e,s(x) ↓], from which we conclude that K₀ is c.e. by Corollary 2.

Now, we show that there exists a c.e. set that is incomputable and prove that the halting problem is incomputable as a corollary.

Theorem 5 (Incomputable C.E. Sets): There exists a computably enumerable set which is incomputable.

Proof: We define a set K which is c.e. but not computable as follows. Let K = {x | x ∈ W_x}

It is clear that K is c.e. (see the proof of Theorem 4) since x ∈ K ⇐⇒ x ∈ Wx ⇐⇒ (∃s)[x ∈ Wx,s].

Now, we show that K is incomputable by contradiction. Assume K is computable. This means that its characteristic function χ_K(x) in computable.

Then we can construct the follwing function f (x) =

(ϕx(x) + 1, if x ∈ K,

↑, if x 6∈ K,

which is incomputable as f (x) 6= ϕ_x(x) for all x ∈ N (by diagonalization).

This is a contradiction. Hence, K is c.e. but incomputable.

Corollary 3 (Unsolvability of The Halting Problem): There exists a Turing machine with unsolvable halting problem. Moreover, The halting problem of the universal Turing machine, U , is unsolvable.

(18)

Proof: Since K is c.e. but incomputable, then there exists a halting set W_e = K for some e ∈ N. Hence, the halting problem for the corresponding Turing program, Pe, is unsolvable. Now, for a universal Turing machine U , let (x, e) be its input. This means that ϕ²_U(e, x) = ϕ_e(x). Hence, the halting problem for U is unsolvable.

5 Comparing Computability

How incomputable phenomena arise and interrelate? Are there different sorts of incomputable sets? How do we mathematically model situations involving interactions between incomputable phenomena? In respect, we explore the concept of computational reduction, called many-one reducibility, and present a glimpse of the structure of incomputable (and computable) sets along with their basic interaction.

5.1 Many-One Reducibility

We start by the natural way of comparing two computable (and incomputable) sets of numbers.

Definition 17 (Many-One Reducibility): For two sets A and B, we say A is many-one reducible or m-reducible to B (written A ≤_m B) if, and only if, there is a computable function f such that for all x ∈ N

x ∈ A ⇐⇒ f (x) ∈ B

It is easy to show that the ordering “≤_m” is both reflexive and transitive.

Moreover, this ordering has an intuition that says if A ≤_m B then A is “at least as computable” as B. This intuition is formalized as follows.

Theorem 6 (Computability and m-Reducibility): The following statements are true:

(1) If A ≤_m B and B is computable, then A is computable.

(2) If A ≤_m B and B is c.e., then A is c.e.

Proof: Say A ≤ B via a computable function f , then:

(19)

(1) B is computable, then χ_A = χ_B ◦ f , which is computable. Hence, it follows that A is computable.

(2) B is c.e., then for all x ∈ B ⇐⇒ (∃y)[R(x, y)] for some computable R(x, y). This means that for all x ∈ A ⇐⇒ (∃y)[R(f (x), y)]. Hence, A is computably enumerable.

5.2 The Non-Computable Universe and m-Degrees

It is natural to gather collections of sets which cannot be distinguished from each other using only m-reducibility. We will see, however, that m- reducibility is not general enough to model the algorithmic content of computationally complex environments.

Definition 18 (Many-One Equivalence): We say A is many-one equivalent to B (written A ≡m B) if A ≤m B and B ≤m A.

It is easy to show that the operator “≡_m” is an equivalence relation (that is, it is reflexive, symmetric, and transitive). This means that all interesting properties about the order of m-reducibility can be discovered by focusing on the structure it induces on the equivalence classes under ≡_m.

Definition 19 (m-Degrees): An equivalence class under ≡_m is called an m-degree or many-one degree. We write

(1) am = degree_m(A) = {X ⊆ N | A ≡^m X},

(2) D_m = {a_m | a_m is an m-degree} = the set of all m-degrees, and (3) a_m ≤ b_m if, and only if, A ≤_m B for some A ∈ a_m, B ∈ b_m.

It should be noted that we exclude ∅ and N as members of m-degrees. A deeper look at “≤” over D_mshows that the ordering “≤” is a partial ordering on D_m (that is, it is reflexive, transitive, and anti-symmetric).

Now, it is natural to ask: does D_m have a least or greatest element? We establish an answer in what follows. But before doing so, let us prove a useful lemma that will come in handy later on.

(20)

Lemma 1: Let A ⊆ N be computable. Then for each non-empty set B ⊂ N, we have A ≤_m B.

Proof: Given a computable set A, then χ_A is computable. To show that A ≤_m B, we want to define a computable function f such that χ_A= χ_B◦ f . To achieve this, choose any elements y ∈ B and z 6∈ B such that χB(y) = 1 and χ_B(z) = 0. Now define the reduction f by

f (x) =

(y, if χ_A(x) = 1, z, if χ_A(x) = 0,

It is clear that f is computable as χ_A is computable. Hence, A ≤_m B. Theorem 7 (The 0m Degree): Dm has a least element, 0m, that consists of all computable sets (other than ∅ and N).

Proof: We start by defining:

0_m = {A ⊂ N | A is computable and A 6= ∅, N}

Let A, B ∈ 0_m, then by Lemma 1, A ≤_m B and B ≤_m A. This means that 0m is certainly contained in some m-degree. Now, if A ≡m B and B ∈ 0m, then A ≤_m B, and hence by Theorem 6, A is computable. Since A 6∈ ∅, N, then A ∈ 0_m. This means that 0_m ⊆ degree_m(B). We conclude that 0_m by itself is an m-degree.

Now, we show that 0_m is the least element in D_m. Given any m-degree a_m = degree_m(A), then B ≤_m A for each B ∈ a_m by Lemma 1. But then, by the definition of “≤” on Dm, we have 0m ≤ am.

So far, we have seen that D_m has a least element 0_m. We claim that there is no greatest element of Dm, and delay the proof to a later section when we introduce Turing reducability.

Claim 1: Dm has no greatest element.

There are important substructures of D_m which do have a greatest element. Such substructures are the c.e. m-degrees, as defined below.

(21)

Definition 20 (Computably Enumerable m-Degrees): We say a_m is computably enumerable if there exists a c.e. set A ∈ a_m. We write E_m for the set of all c.e. m-degrees.

Theorem 8 (The 0⁰_m Degree): E_m has a greatest c.e. m-degree, 0⁰_m = degree_m(K0), such that 0⁰_m > 0m and am ≤ 0⁰_m for all c.e. am.

Proof: First, we show that for any A ⊆ N that is c.e. A ≤m K₀. We have already seen that K0 is c.e., so for each x ∈ N

x ∈ A ⇐⇒ x ∈ W_x ⇐⇒ hx, xi ∈ K₀

So, A ≤_m K₀ via x 7→ hx, xi, which is computable as hx, xi is computable.

We also know that K is incomputable, and hence by Theorem 6, K₀ is incomputable.

Now, the task is to translate this fact about reducibility into a degree- theoretic one. This is achieved as follows.

a_m is c.e. ⇐⇒ ∃A c.e. ∈ a_m ⇐⇒ ∃A ∈ a_m with A ≤_m K₀ And hence, a_m ≤ degree_m(K₀) = 0⁰_m.

Finally, it should be noted that all apparent variety of unsolvable problems found by Church, Turing, and others are to be found exclusively in 0⁰_m (they all are reducible from an incomputable set called the creative set, which is in 0⁰_m). Moreover, the m-reducibility seems inadequate to base our model of the incomputable universe. The m-reducibility is not general enough to model the algorithmic content of computationally complex environments.

For instance, a basic intuition is that if a set A can be computed, then so is its complement ¬A. However, it can be shown that in general, A 6≡_m ¬A (by letting A = K, then ¬K 6≤_m K since otherwise, K would be computable).

This demands that we extend this model with something that is more “natural” of the “real-world”. This is were the notion of oracle Turing machine comes in handy.

6 Computing with Oracles

What is a natural and more general model to explore the world of incomputability? How does this model structure the inherent difficultly of computation? How can we safely go beyond G¨odel’s Incompleteness Theorem and

(22)

make judgments on theories and algorithms? In answering these questions, we get a deeper meaning of G¨odel’s theorem and enhance our understanding of the computable and incomputable universe. We start the discussion with the more powerful reducibility of Turing. After that, we build the degree universe based on Turing’s model. Finally, we present essential results related to the structure of this universe.

6.1 Oracle Turing Machines

Oracle Turing machines contain a new sort of quadruples that enables them to use information form the real-world. Such usage is provided by an “oracle”, or by an information source that is external to the machine context.

The intuition behind oracle Turing machines is as follows: Let A, B ⊆ N be two sets of numbers. We want A to be computable from B (that is, A is computable relative to B). This can be achieved, in one way, by answering the question “is x ∈ A?” using an algorithm whose computation from input x uses finitely many pieces of information about the membership of numbers in B — it answers queries such as “is y₀ ∈ B?”, “is y₁ ∈ B?”,. . . , “is y_k ∈ B?”.

We introduce an oracle B to the usual Turing machine, T , by a new quadruple ˆQ = q_iS_kq_jq_l, which is called the query quadruple. This new Tur- ing machine is now called an oracle Turing machine, ˆT , and it works as follows: ˆT computes as usual on input n, except that when it applies ˆQ (that is, ˆT is in state q_i reading symbol S_k), it counts the number of 1’s on the tape (say n), asks the oracle B “is n ∈ B?”, and if the answer is “yes”, it goes into state qj. Otherwise, it goes into state ql.

Definition 20 (Relative Turing Computability): A function ψ (possibly partial) is B-Turing computable if ψ is computable by an oracle Turing machine ˆT with oracle B. Similarly, a set A is B-Turing computable (written A ≤_T B), or Turing reducible to B, if χ_A is B-Turing computable.

It should be noted that Turing reducibility is a generalization of m- reducibility. This means A ≤_m B =⇒ A ≤_T B. Moreover, the Turing reducibility “≤T” is reflexive, transitive, and can be extended to relations and functions.

(23)

6.2 Relativized Computable Functions

We now relativize the theory of computable functions and c.e. sets to any given oracle based on Turing reducibility.

Definition 21 (Relativized Church-Turing Thesis): All formalizations of “A computable from B” which are sufficiently reasonable and sufficiently general are equivalent to the intuitive one above, and so can be written as A ≤_T B.

We will call any ψ which is Turing computable from oracle B either B- computable (if it is total) or B-partial computable (B-p.c.) otherwise.

Definition 22 (The Oracle Turing Machine Code): The e^th oracle Tur- ing machine ˆP_e is defined by

Pˆ_e =

( ˆP , if Dec(e) ↓ = some oracle Turing program ˆP ,

∅, otherwise. (the empty program)

Note that we think of ˆPe as having arguments n (the input, which could be ~n) and B (the oracle). So, in a sense, ˆP_e computes a functional⁵ Φ instead of ψ. This is reflected in the following definition.

Definition 23 (Partial Computable Functionals): We write Φ for the functional corresponding to the e^th oracle Turing machine ˆP_e, were

Φ^B_e(n) = ztest(the output of ˆPe on input n and oracle B).

Note that Φ^B_e is 0-1 valued function (possibly partial) which equals 0 if the output of ˆP_e on input n and oracle B is 0, and equals 1 otherwise (see Example 2 for the definition of the primitive recursive function ztest).

6.3 The Turing Universe

Turing reducibility that is considered over all sets of numbers is called Turing universe. We formalize this idea below.

5Such a functional is a mapping whose arguments are functions or sets but not numbers.

Such a functional is also known as Lachlan functional.

(24)

Definition 24 (Turing Equivalence): For two sets of numbers A and B, we say A is Turing equivalent to B (written A ≡_T B) if A ≤_T B and B ≤_T A.

Definition 25 (Degrees of Unsolvability): For a set A ⊆ N, we define the degree of unsolvablity or the Turing degree of A as

degree(A) := {X ⊆ N | X ≡T A}.

Definition 26 (Turing Universe): The Turing universe D is the collection of all Turing degrees. The Turing universe is defined on the ordering “≤”

that is induced by “≤_T” on D by

degree(A) ≤ degree(B) ⇐⇒ A ≤T B.

A natural question is: what is the size of Turing universe? We prove the following theorem about basic cardinal properties of D.

Theorem 9 (Basic Cardinal Properties of D): For a set A ⊆ N, we write a = degree(A). The following statements are true:

(1) |a| = ℵ₀ for every Turing degree a.

(2) |{b | b ≤ a}| ≤ ℵ₀ for every Turing degrees a and b.

(3) |D| > ℵ₀.

Proof: We prove each property separately as follows.

(1) This property means that each Turing degree is countably infinite: Let a = degree(A) be some Turing degree. Then,

a = {X | X ≡_T A} ⊆ {X | X ≤_T A}

⊆ {Φ^A_i | Φ^A_i is total}

⊆ {Φ^A_i | i ≥ 0}

So a is a subset of countable set, and so is countable. To see that a is also infinite, we write

A_i =

(A ∪ {i}, if i 6∈ A, A − {i}, otherwise.

(25)

Then for each i 6= j, we have A_i(i) 6= A_j(i) = A(i). Hence, A_i 6= A_j. Now, it is easy to see that each A_i ≡_T A. So, a contains A₀, A₁, . . . , which is infinite and distinct.

(2) This property means that the set of degrees that is smaller than a given degree is countable: Write D(≤ a) = {b | b ≤ a}, and let A ∈ a. Then, D(≤ a) = {degree(X) | X ≤_T A} = {ΦÂ_i | ΦÂ_i is total} ⊆ {ΦÂ_i | i ≥ 0}.

So, D(≤ a) is countable.

(3) This property means that the Turing universe is uncountable: Given that any Turing degree a has a cardinality ℵ₀ = |N|, then |D| = |2^N| > ℵ₀. Hence, D is uncountable (note that |R| = |2^N|, and R is uncountable by Cantor’s Theorem).

This completes the proof.

Similar to many-one reducibility, D has a least element but no greatest element. We prove this in the following.

Corollary 4: D has no greatest element.

Proof: We prove this by contradiction. Assume that D has a greatest element. Then, there exists a ∈ D such that b ≤ a for all b ∈ D. Let A ∈ a.

The set of all A-computable sets is countable. Therefore, the set of Turing degrees less than A is also countable. However, the set of Turing degrees less than A is D. By Theorem 9 (property 3), we get a contradiction. Hence, there is no greatest element in D.

Note that the proof of Claim 1 in Section 5.2 follows from Corollary 4 as A ≤_m B =⇒ A ≤_T B.

Lemma 2: Let A ⊆ N be computable. Then for each non-empty set B ⊂ N, we have A ≤_T B.

Proof: In order to show that A ≤_T B, we need to show that there exists a computable function f which uses B as an oracle. Since A is computable, χA is a computable function. Then, we can let B be an oracle for f = χA, but compute χ_A the exact same way. Thus, A ≤_T B.

(26)

Theorem 10 (The 0 Degree): D has a least element, 0 = degree(∅), that consists of all computable sets (other than ∅ and N).

Proof: Let X be a computable set and A ⊂ N. Then by Lemma 2, X ≤T A.

Since X ∈ 0, then 0 ≤ degree(A) for all A ∈ N.

6.4 Enumerating with Oracles and Jump Operators

Relativizing what we have found out about computably enumerable sets is surprisingly revealing. This is a first indication on the deep intimate relationship between Turing degrees and their structural interrelationship.

Definition 27 (Turing Recducability and C.E. Sets): For a set A ⊆ N, we say that A is computably enumerable in B (written B-c.e.) if we can computably enumerate the elements of A using the oracle B. We also say that the degree a is computable enumerable in b if some A ∈ a is c.e. in B ∈ b. Finally, a degree a is computably enumerable if it contains a c.e. set.

We write E for the set of all c.e. Turing degree.

Proposition 3: For a set A ⊆ N, A is B-c.e. if, and only if, A is the domain of an B-p.c. function. That is, we can write W_e^B = domain(Φ^B_e) for each e ∈ N such that {We^B}_e∈N is a listing of all B-c.e. sets.

Proof: We start with the forward direction. Assume that A is B-c.e. Then, we can define the semi-characteristic function of A as follows:

S_A(n) =

(1, if n ∈ A,

↑, if n 6∈ A.

It is easy to see that S_A is B-partial computable. To compute S_A(n), just enumerate the elements of A using the help of B by setting SA(n) to 1 if we observe n enumerated into A. This means that domain(S_A) = B.

Now, for the reverse direction, let A be the domain of B-p.c. function ψ.

Then, we can enumerate the elements of A with the help of B by successively going through the computations ψ(0), ψ(1), . . . , and enumerating into A any n for which we observe the computation of ψ(n) terminates.

(27)

It is now the time to use the concealed power of these relativizations. We now define a jump operator by relativizing the definition of K₀ (see the proof of Theorem 4 for the definition of K0). The jump operator has many useful applications; it can be used to draw a link between first-order arithmetic and degrees of unsolvability. We use it here, however, to answer the natural question of: does D = E for all c.e. degrees?^?

Definition 28 (The Jump Operator): Let the jump B⁰ of a set B be B⁰ := {hx, yi | x ∈ W_y^B} = K₀^B.

Moreover, let the (n + 1)^th jump of B be B⁽ⁿ⁺¹⁾ := (B⁽ⁿ⁾)⁰.

The jump operator on sets have many interesting properties. We list some of them here as a definition.

Definition 29 (Jump Properties on Sets): For any two sets of numbers A and B, the following are true:

(1) B⁰ is B-c.e.

(2) A is B-c.e. ⇐⇒ A ≤_T B⁰ and B ≤_T B⁰. (3) B⁰ 6≤_T B.

(4) If A ≡T B, then A⁰ ≡T B⁰.

Property (4) above gives us a special kind of jumps. It allow us to perform jumps on Turing degrees, which is sometimes referred to as Turing jumps.

Definition 30 (Turing Jumps): For a set B, the Turing jump b⁰ of b = degree(B) is given by:

b⁰ := degree(B⁰).

Moreover, the (n + 1)^th jump b⁽ⁿ⁺¹⁾ of Turing degree b is given by:

b⁽ⁿ⁺¹⁾:= (b⁽ⁿ⁾)⁰ = degree(B⁽ⁿ⁺¹⁾).

Now, based on Definitions 29 and 30, we get the following property of the Turing jump.

Definition 31 (Turing Jumps Properties): The following order is valid:

(28)

b < b⁰ < b⁰⁰ < · · · < b⁽ⁿ⁾< . . . where b⁽ⁿ⁺¹⁾ is c.e. in b⁽ⁿ⁾ for each n ≥ 0.

Finally, by letting b = 0 = degree(∅), we get the ascending sequence 0 < 0⁰ < 0⁰⁰ < . . . , which shows that D 6= E for all c.e. degrees.

7 The Structure of Turing Universe

The hierarchical structure reveals the dynamic relationships between different levels of abstraction. In science, for instance, the study of quantum mechanics, atoms, molecules, cells, organisms, and so on, revealed many interesting properties between these different levels. Putting such a structured hierarchy in a descriptive framework allows the investigation of each level with its local constraint, and possibly, discover a unified theory that covers all such levels.

In this section, we start with the early work of Kleene and Post and show some basic results about the structure of D. After that, we extend out discussion and consider the structure of E and introduce the priority method;

the highly celebrated technique in degree theory.

7.1 Oracles as Strings

One way to represent characteristic functions is through strings of 0’s and 1’s. This allows us to look at the string as an oracle with finite information about memberships that is enough to answer queries.

Definition 32 (Strings): A string σ is a finite sequence of 0’s and 1’s. The string σ is 0-indexed, that is, the 1^st element of σ has an index 0, the 2^nd element has an index 1, and so on. We write σ(x) = 0 or 1 if the (x + 1)^th element is 0 or 1, respectively. Finally, the length of the string σ (written

|σ|) is the number of elements in σ, that is, the least x such that σ(x) ↑.

Example 5: Let σ = 101100. Then, σ has a length |σ| = 6, where it starts with σ(0) = 1 and ends with σ(5) = 0.

Definition 33 (Properties and Operations of Strings): We define the

(29)

(1) Concatenation: The concatenation of σ and τ (written σ^_τ ) consists of σ’s elements followed by τ ’s elements.

(2) Extension: τ is an extension of σ (written σ ⊆ τ ) if for all x < |σ|, we have σ(x) ↓ ⇒ τ (x) ↓ ⇒ σ(x). In other words, σ is a substring of τ . (3) Beginning: σ is the beginning of a set A (written σ ⊂ A) if σ is an initial

segment of χ_A.

(4) Compatibility: σ is compatible with τ if they are extensions of each other, that is, σ ⊆ τ and τ ⊆ σ. Otherwise, we say σ and τ are incompatible (written σ | τ ). If σ | τ , we write y(σ, τ ) = µy[σ(y) 6= τ (y)].

(5) Special strings/sets: The string ∅ is the empty string and the set S is the set of all string.

(6) Lexicographical ordering: The lexicographical ordering of S is given by σ ≤ τ ⇐⇒ σ | τ and σ(y(σ, τ )) < τ (y(σ, τ )), or σ ⊆ τ

Example 6: Let σ = 0101 and τ = 0101011. Then, σ^_τ = 01010101011, σ ⊆ τ , and σ is a beginning of A = {x | x ∈ N, x is odd}, where χ^A = 01010101 . . . is the first 8-element segment of A’s characteristic function.

Moreover, σ | τ where σ(4) = ∅ and τ (4) = 0.

Proposition 4: For an oracle Turing machine ˆT_e, we write Φ^σ_e(x) = y for the computation of the program ˆP_e on input x with output y, during which all oracle queries are answered by σ concerning any number n < |σ|.

Proof: This proposition directly follows from Definitions 32 and 33. It should be noted that strings can be extended from binary numbers to other more general strings such as sequence of numbers in N. This suggest that we extend our definition of beginnings as follows: a string σ is a beginning of a set A if σ is an initial segment of any function f : N → N (that is, not just of χ_A). We write 2^<w for binary strings and w^<w for the more general kind.

7.2 Non-Linearity of Turing Universe

Degree theory is vast and beautiful! We have already seen the limitations of m-reducibility as a model of the computable and incomputable universe.

(30)

Our objective here is to show the details of two main theories that show the richness of Turing universe. In specific, we will show that D and E are not linearly ordered, that is, there are incomparable pairs of Turing degrees. But first, please try to contain your own excitement for a moment, and let use define some useful notations.

Definition 34 (Notations in Approximations): We use the following notations for an expression A involving computable approximations:

(1) We write A[s] for A evaluated at stage s. Then, for Φ^B_i (x), we write Φ^B_i (x)[s] = Φ^B_i,s^s(x) where B^s is a c.e. approximating sequence.

(2) Let A^B be an expression whose computation involves k queries of the form “is n_i ∈ B?”, to an oracle B. Then let the use of the computation of A^B be max{n_i | 0 ≤ i ≤ k}.

(3) For a set A, we write A n if χ^A(x) is restricted to x < n.

(4) We write δ_i^B(x) for the use of Φ^B_i (x). Accordingly, let z = δ_i^B(x), then z = µz[Φ^Bz_i (x) ↓]. We assume that δ_i,s^B(x) < s.

We hope the above notations will be excused once we start proving the following two theorems!

Theorem 10 (Kleene-Post, 1954): D is not linearly ordered ⇐⇒ There exist Turing degrees a and b such that a 6≤ b and b 6≤ a.

Proof: We need to construct two sets A and B such that A 6≤_T B and B 6≤_T A, where a = degree(A) and b = degree(B). To achieve this, we define the following relations that must be satisfied for A and B to exist (call them requirements):

R2i: χA6= Φ^B_i R_2i+1 : χ_B 6= Φ^A_i

To do so, we start by defining the following sequences of strings:

σ₀ ⊂ σ₁ ⊂ σ₂ ⊂ . . . τ₀ ⊂ τ₁ ⊂ τ₂ ⊂ . . .

(31)

χ_A=S

i∈Nσ_i χ_B=S

i∈Nτ_i

Now, we assert that in order to satisfy the requirements at stage i + 1, we need to define two string σ_i+1 and τ_i+1 such that the i^th requirement is satisfied. We divide the construction of A and B into stages as follows.

Stage 0: Define σ₀ = τ₀ = ∅.

Stage i+1: Let this stage be (2e + 1) for e ≥ 0. We specifically handle requirement R_2e and leave R_2e+1 to the reader as the process is exactly the same. Now, assume the following are already defined:

σ₀ ⊂ σ₁ ⊂ σ₂ ⊂ · · · ⊂ σ_i τ₀ ⊂ τ₁ ⊂ τ₂ ⊂ · · · ⊂ τ_i

and let x_i = |σ_i|. We are looking for a string τ ⊃ τ_i such that Φ^τ_e(x_i) ↓.

There are two cases:

— Case I (τ exists): Then, computably choose a τ and let k = Φ^τ_e(x_i). Next, define the following strings:

σ_i+1 = σ_i^_(1 − k) τ_i+1 = τ

We now show that Φ^B_e(x_i) = Φ^τ_e(x_i) by contradiction: Assume Φ^B_e(x_i) 6=

Φ^τ_e(x_i). Then, since τ is the beginning of the characteristic function of B, τ and B match up to |τ |. Therefore, there must exist k ∈ N such that k > |τ |, and the k^th element of B changes the output Φ^B_e(xi) so that it is not equal to Φ^τ_e(x_i). Then, Φ^τ_e(x_i) must query the k^th element of τ as well. However, as τ is not defined at this index, Φ^τ_e(x_i) ↑. This is a contradiction. Therefore, Φ^B_e(xi) = Φ^τ_e(xi), and so

Φ^B_e(xi) = Φ^τ_e(xi) = k 6= (1 − k) = σi+1(xi) = χA(xi).

— Case II (τ does not exist): Then define the following string:

σ_i+1= σ_i^_0 τ_i+1 = τ_i^_0

(32)

Now, regardless of how τ_nare picked (n > i), Φ^B_e(x_i) ↑. Given that Φ^B_e(x_i) is not defined, the requirement is satisfied as Φ_A(x_i) = 0 6= Φ^B_e(x_i). We prove this by contradiction: Assume that Φ^B_e(xi) ↓. Let w be greater than |τ_i| and δ_e^B(x_i). Then, for τ = B w, Φ^Be(x_i) = Φ^τ_e(x_i) because for every element of B used to compute Φ^B_e(x_i), τ has the exact same elements. Note also that τ ⊃ τi. We have found a τ such that Φ^τ_e(xi) ↓, and so, we cannot be in Case II, which is a contradiction.

Hence, R_i is satisfied for all i ≥ 0, and the theorem follows.

In the early 1950’s, Post asked whether there is any c.e. Turing degree strictly between 0 and 0⁰. The problem of constructing such a degree (or showing that none exist) became known as Post’s problem. This problem was solved independently by Friedberg and Muchnik, who showed that these intermediate c.e. Turing degrees do exist. Their proofs developed the same new method for constructing c.e Turing degrees which came to be known as the priority method. The priority method is now the main technique for establishing results about c.e. sets.

Theorem 11 (Friedberg-Muchnik Theorem): E is not linearly ordered

⇐⇒ There exist c.e. Turing degrees a and b such that a 6≤ b and b 6≤ a.

Proof: As before, we need to construct two c.e. sets A and B such that A 6≤_T B and B 6≤_T A, where a = degree(A) and b = degree(B). To achieve this, we define the following relations that must be satisfied for A and B to exist (call them requirements):

R_2i: χ_A6= Φ^B_i R_2i+1 : χ_B 6= Φ^A_i

Here, however, the construction of A and B produces c.e. approximating sequences {A^s}_s≥0 and {B^s}_s≥0 to A and B, respectively. Accordingly, we have to discard any oracles that might spoil the computability of these enu- merations.

The construction will take place at stages 0, 1, . . . , s, s + 1, . . . as before.

At stage s + 1, we will computably construct A^s+1 ⊇ A^s and B^s+1 ⊇ B^s to satisfy one requirement. However, this time we will not be able to decide ahead in time exactly which requirement as there are no oracles.

On the Structure of Turing Universe: The Non-Linear Ordering of Turing Degrees