## 5.3. Recursive languages

Definition 5.6.

```The language  is called recursive, if  Turing machine such
that it terminates on every input and .```

Definition 5.7.

```The language  is called recursively enumerable, if  Turing
machine such that .```

There is only a slight difference between the two definitions. In the second case we do not require from the Turing machine to terminate on every input word.

Is this difference crucial or is it a simple modification of the same concept? Anyway, it is clear that if a language is recursive then it is recursively enumerable, too.

Notation 5.8.

```

```

By the above notation we may write the observation and question in the form:

Remark 5.9.

```
```

Question 5.10.

`               ? (Más formában: , azaz valódi részhalmaza?)`

We prove some properties of the recursive languages.

Properties 5.11.

```Let . Then
1.
2.
3.  ( i.e.  )
4.
5.
```

Proof

By definition, there exist Turing machines which terminate on every input and and . For simplicity, assume that both of them contains the necessary number of tapes, but they use only the first for their computation.

The following simple Turing machines will be used for the proof.

- the Turing machines are copy the content of tape to the tape ( if contains some symbol then the copied word is concatenated to the original content)

- the Turing machines are deleting the content of the tape

- the Turing machines are copying the first symbol on tape to the end of tape , while the symbol is deleted from tape . If tape is empty (before copying), then the Turing machines terminate in "no", otherwise they terminate in "yes" state.

- the Turing machines check whether the tape is empty. If so, then they terminate in "yes", otherwise they terminate in "no" state.

1. Let be the following Turing machine:

accepts its input if it terminates in state and rejects its input if it terminates in state . and accept in direction and reject in direction their inputs. Since both Turing machines ( and ) get the original input of , thus terminates on the word in state if and terminate in state on . I.e. accepts if and only if both and accept it. In other words:

if and only if and ,i.e. . Since terminates on every input, thus .

2. Let be the following Turing machine:

Similarly to the proof of 1, accepts its input if it terminates in state and rejects it if it terminates in state . and accept in direction and reject in direction their inputs. Since both Turing machines ( and ) get the original input of , thus terminates on the word in state if or accept in direction on . I.e. accepts if and only if either or accept it. In other words:

if and only if or , i.e. . Since terminates on every input, thus .

3. Let be the following Turing machine:

accepts its input if and only if rejects it, i.e. . Since terminates on every input, thus .

4. Let be the following Turing machine:

The Turing machine operates by the following:

1. Copies the input word to tape .

2. It checks whether the word on tape is in and whether the word on tape is in . If the answer is "yes" in both cases, it accepts the input and terminates. If some of the answer is "no", then it continues the computation.

3. It checks whether tape is empty. If yes (), then it terminates with answer "no". If not empty, then it continues its computation.

4. It copies the firs symbol of tape to the end of the word on tape and continues its computation with step 2.

Actually, decomposes the input word in all possible way to the composition of two words and checks if the first part is in while the second part is in . Finding the firs successful decomposition it terminates in an accepting state. If there are no such decomposition, it terminates in a rejecting state.

Hence . Since terminates on every input, thus .

5. To prove the statement we need some more Turing machines.

- places a symbol at the end of the word on tape . If the tape was empty, then only the symbol remains on the tape.

- staring form the end of tape , it copies the symbols until the first sign to the beginning of tape . If was empty, only the copied word is on it. For instance, if the content of tape is and the content of tape is , then will contain the word .

- deletes all symbols on tape from the end until the first sign . (The symbol is deleted, too.) If, for instance, tape contains , then after operation contains .

Let be the following Turing machine:

The operation of the Turing machine:

1. If the input is , then it accepts and terminates, otherwise it copies to tape .

2. It places a symbol (separation sign) on tape .

3. It copies longer and longer prefixes of the word on tape to tape until it is in .

4. If a prefix is found to be in , then it continues with step 2, i.e. it checks the next part to be in . If no proper prefix can be found, then it continues with step 5.

5. It copies back form the end of tape to the beginning of tape the last selected part and continues with increasing the previous part instep 3. If there are nothing remains on tape 2 after removing the symbols from the tape, then no decomposition of the input word to word from . Then it terminates and reject its input.

By detailed observation of , one can see that it recognise exactly the language . Since the Turing machine terminates on every input, thus .

Similar properties can be stated for recursively enumerable languages.

Properties 5.12.

```Let . Then
1.
2.
3.
4.
```

Proof

Similarly as in the proof of the previous theorem, there exist Turing machines which are not necessarily terminate on every input and and . For simplicity, assume that both of them contains the necessary number of tapes, but they use only the first for their computation.

The following simple Turing machines will be used for the proof.

- the Turing machines are copy the content of tape to the tape ( if contains some symbol then the copied word is concatenated to the original content)

- the Turing machines are deleting the content of the tape

- the Turing machines are copying the first symbol on tape to the end of tape , while the symbol is deleted from tape . If tape is empty (before copying), then the Turing machines terminate in "no", otherwise they terminate in "yes" state.

- the Turing machines check whether the tape is empty. If so, then they terminate in "yes", otherwise they terminate in "no" state.

1. Let be the following Turing machine:

Similarly tho the recursive case, accepts its input if it terminates in state , i.e. both and accept it. Since both Turing machines ( and ) get the original input of , thus terminates on the word in state if and terminate in state on . I.e. accepts if and only if both and accept it. In other words:

if and only if and ,i.e. . Hence . Since we cannot prove termination, thus cannot be proven.

2. This case is not as simple as for recursive languages, since there the corresponding Turing machines are connected through the nonaccepting states. But the languages and are assumed to be recursively enumerable only, thus the corresponding Turing machines not necessarily terminate in nonaccepting states, if the input is not in the given language.

The problem can be solved by parallel composition of Turing machines. Its definition (given for single tape Turing machines, but similar to multi tape ones) is the following :

Let and be two Turing machines.

The Turing machine is called the parallel composition of and , if

,

,

,

, i.e. if and only if and and

, i.e. terminates if at least one component terminates.

The -tape Turing machine executes the same operation steps on its first tape as and the same operation steps on its second tape as would do.

The accepting states of depends on the task we want to solve. In our case:

, while .

It means that accepts its input if and only if one of the components accepts it.

The parallel composition is denoted by .

Since the Turing machine accepts its input if one of and accepts it, thus .

Since does not necessarily terminate on every input, thus only can be stated.

3. To prove the statement we use the construction of the Turing machine of the proof of Properties 5.11. (4) and some further Turing machines:

- is a Turing machine, which checks if the content of tape is from and the content of tape is from :

- is a Turing machine, which writes a symbol to the end of the word on tape,

- is a Turing machine, which moves it read-write head to the end of the word on tape and then returns to the beginning.

With these Turing machines let be the following:

Observing the Turing machine we find some difference from the Turing machine defined in the 4th statement of the previous theorem. Here we built in a counter, which does not let the Turing machine run for arbitrary length, but reduces the length of computation to the number of steps which needs to move the read-write head on tape to the end and back. If ti finds that the content of tape is from and the content of tape is from , then it terminates in an accepting state. If it does not find positive answer in the given time limit, then it finish computation on the actual decomposition and restart with another one. If all decomposition is checked and there are still no positive answer, it erases tapes and , increases length of the word on tape and restart the computation. With the help of this embedded time limit function we bound the length of computations in one direction, thus no infinite loop blocks the test of other decomposition cases. The failure of one test cycle does not mean that the input is not from the observed language, because the time limitation may cause earlier termination than needed. Therefore the cycle is restarted with longer time limit. We repeat it until the Turing machine terminates in an accepting state. If none of the decompositions are such that the first component is from , while the second is from , then obviously the Turing machine never terminates.

Thus the language recognized by the Turing machine is exactly the language , whence by definition .

4. Similarly to (3) the proof is based on the construction of a Turing machine, which is a modification of the one from the proof of Properties 5.11. (5).

Here again, we introduce the same limiting Turing machine. It is composed in parallel with and the result is the Turing machine . Terminating in "no" state means that the computation is cancelled by the limiting Turing machine and not by .

Clearly, we cannot say that if no solution has found (in limited time), then no solution at all. Thus instead of terminating in nonaccepting state, the Turing machine returns to the beginning, increases the time limit and restart computation. This Turing machine recognize the language , whence .

Remark 5.13.

```The concept of parallel composition and limited time
execution can be used in some general manner, too. ```

Corollary 5.14.

```Let . Then
1.
2.
```

Proof

1. By definition means that . By Properties 5.12. (2), , i.e. .

2 Similarly as above, means that and by Properties 5.12. (1) , i.e. . ✓

Theorem 5.14.

```Let .
Then  if and only if  and .
In other words: .```

Proof

The statement of the theorem stands of two parts:

1. If then and .

2. If and , then .

We prove first the simpler looking part:

1. By the Remark 5.9, if then . By Properties 5.11. (3), if , then , i.e. , which proves the statement.

The proof of the second part:

2. By definition, if and , then there exist Turing machines and such that and .

Let be Turing machines, which copy the content of tape to the tape and let be the Turing machine defined by the following parallel composition:

Since all input word either in or not in , thus the Turing machine terminates in all input words. If , then the part, if , then the part terminates. The language recognised by is , since it accepts exactly the same words as . By definition it means that . ✓

The statement of the theorem is not really surprising and the interpretation of it is reflected in the proof. Namely, it says that if we have two algorithms - one for deciding if a word is in a language and one for deciding if the word is not in the language - then there exists a unified algorithm to decide whether the word is in the language or not. It is natural to try to mix the two algorithm and create a new from them, as it is done in the proof.

Now, we see some relations between the classes of recursive and recursively enumerable languages, but still don't know, if we have to make difference between them. The next two theorems explains the remaining question about the difference of the two definitions.

Theorem 5.15.

`               .`

Proof

The proof is indirect.

Opposite to the statement of the theorem, assume that . By definition, there exists a Turing machine such that . Let be its program. Then one may ask whether or not. Try to prove one of them.

1. Assume first, that . Then

a. by the Turing machine accepts and

b. by the definition of , if , then it is a program of a Turing machine, which does not accept itself as an input. I.e. does not accept .

But a. and b. contradict, i.e. is wrong.

2. Assume now, that . Then

a. by the Turing machine does not accept and

b. by the definition of , if , then either is not a Turing machine program or it is a program of a Turing machine, which accepts itself as an input. Since is the program of , thus the second condition holds, i.e. accepts .

By then, again, a. and b. contradict, i.e. is wrong.

But exactly one of or should be true, thus it is a contradiction. This is because of our indirect assumption, i.e. is wrong. ✓

Theorem 5.16.

`               .`

Proof

The theorem stands of two statement:

1. and

2 .

We prove first the simpler one:

1. Since , by definition, this means that .

The proof of the second statement is made by indirect assumption:

2. Assume the opposite of the statement, i.e. . Then, by definition, there exists a Turing machine terminating on every input word such that .

We construct a new Turing machine using and the following:

- decides, whether the input word is a Turing machine program or not. Since a Turing machine program has a rather strict structure, thus it is not unbelievable that this Turing machine exists.

- copies the word contained on tape to tape twice, separating them by the symbol , i.e. it maps to .

- , copies the content of tape to tape .

- deletes the content of tape .

Let define by the following:

Clearly, terminates on every input and accepts the words , which are Turing machine programs () and the corresponding Turing machines does not accept them (). However, these are exactly the words of the diagonal language, which means that . By Theorem 5.15. we have . Since , this is a contradiction. This means, that is wrong.✓

Corollary 5.17.

```1.  and
2. .```

Proof

1. Using the Turing machines of the proof of Theorem 5.16., define the following Turing machine:

accepts the words, which are either not Turing machine programs or the corresponding Turing machine accepts themselves. In other words, . This means that , i.e. .

2. By Theorem 5.16., . If holds, then by Theorem 5.14. , too. But we have seen, that this is not true, thus .✔

We see now, that there exists a recursive enumerable, but not recursive language. However, it is still not proven, that there exists a language, which is not recursively enumerable but the complementer is not recursively enumerable, neither. The next theorem is about this language.

Theorem 5.18.

`There exists a language  such that .`

Proof

The cardinality of the set of recursively enumerable languages is less than the number of Turing machines. Since every Turing machine can be identified uniquely by its program, thus the number of Turing machines is not more than the number of finite words, i.e. countably infinite. Since the cardinality of the set of finite words over a fixed alphabet ( i.e. ) is countably infinite, thus the related power set has continuum cardinality. Since it is strictly greater than the countably infinite, thus there exists a language, such that neither it nor the complement of it is recursively enumerable. ✓

The following theorem explains the name "recursively enumerable". It says that the words of a recursively enumerable language can be enumerated by a Turing machine (recursively).

Theorem 5.19.

```Let . Then  if and only if  terminating on
every input, such that .```

Proof

If , then both condition of the theorem trivially fulfilled, thus without loss of generality, we may assume that is not empty.

Let be an alphabet. The members of can be enumerated in quasi-lexicographic order (i.e. the words are ordered first by length, then by lexicographically). If for instance , then the enumeration is . Every word appears in the enumeration and easy to determine the successor of any word. (Actually it is a modified incrementation by in binary form.)

The theorem stands of two statement:

1. If , then Turing machine, which terminates on all input and .

2. If Turing machine, which terminates on all input and , then .

1. The proof is constructive.

Since we have assumed that is not empty, thus it has at least one element. Denote by an arbitrary fixed word from . Since , thus by definition, there exists a Turing machine , such that .

We will use the following Turing machine for the construction of :

- copies the content of tape to tape (if tape is not empty, then it is concatenated to the end of the content).

- deletes the content of tape .

- moves trough the content of tape and returns to the beginning.

- writes the word to tape .

- starting from the rear end of tape , it copies the symbols until the first found sign to the beginning of tape . If tape is empty, then the copied word will be its only content.

- starting from the rear end of , it deletes all symbol until the first found sign . (The symbol is erased, too.)

- counts the number of symbols on tape . If there is only , then it terminates in state , otherwise it terminates in state .

As before, define the time limited version of by parallel composition:

Let be the following Turing machine:

Since every components of terminate on all input words, thus terminates, too.

Clearly, is not an accepting Turing machine. What is the output on a given input word? If the input is not in the form , then the output is the word . If the input is in the form , then it divides into two parts. It copies to tapes and the word and it copies to tape the word . Then it executes the steps of on , but the length of the computation is limited by . If it accepts the input in the limited time, then , otherwise is the output.

Clearly, the possible output is from , since either or another word accepted by is the content of the first tape, before termination.

Furthermore, if , then accepts . Let the length of the accepting computation and let (i.e. the sequence of 's of length). Since is long enough, thus terminates in an accepting state on the input word , whence . This means that every word from (and by the above observations, only the words from ) is an image of some input word, whence the statement is proven.

2. Similarly as above, it is again a constructive proof.

Let be a Turing machine, which terminates on every input and .

For the construction, we need some additional Turing machines:

- replaces the content of tape by its quasi-lexicographic successor.

- compares the contents of tapes and . If they are equal, then it terminates with answer , otherwise it terminates with answer .

Let define the following Turing machine:

The explanation of the behaviour of :

The content of the different tapes:

1. It is used for computation, the intermediate result is here.

2. Stores the actual input of . The content changes in quasi-lexicographic order.

3. The copy of the input word.

Let be the actual input word. During its operation computes for all in quasi-lexicographic order. If there is a , such that , then terminates with "yes" answer, otherwise it continues the incrementation and checking of .

Since for all word there exists such that , thus accept exactly the words , i.e. . By definition, it means that . ✓

Collecting the results of the chapter one may draw the following diagram:

Here is one of the languages, such that .

Problems:

Let and be two nonempty languages.

1. Prove that if and then .

Similarly, if and then .

2. Prove that if and , then .

Similarly, if and , then .

3. Prove that if and , then .