More specifically why is there a TM that accepts and halts for any complement language in P?
I understand, that there is a TM that rejects a language L from P, but why must there be a TM that accepts the complement of L?
Simple solution: Let L be the original language with Turing Machine M that accepts the language L. To compute L-complement, create a new machine M' such that M' is the same as M, except we switch all transitions to the accept state of M to a "reject state", and all transitions to a reject state (or a "malformed transition") to the accept state.
The running time for M' is the same as the running time for M. It will accept/reject exactly when M rejects/accepts.
A commenter asked if I could provide intuition for why this does not work for NP vs co-NP. It helps here to start with the Cook-Levin definition of a language L being in NP, which allows a clear definition of a language L' being in co-NP. (Using the definition based on Non-deterministic Turing machines makes the definition of co-NP a bit harder)
In the Cook-Levin definition, a language L is in NP, if we have a "verifying" Turing Machine V such that for all strings S in L, there is a polynomially-length bounded certificate string C such that V accepts the pair (S, C) (think of V either as a two-tape input machine, or else think of it as accepting the encoding of the pair of inputs). In addition of course, we have the requirement that V complete the verification in polynomial time.
As an example, for the 3SAT language, the strings S would be 3SAT problem instance statements, and the certificate C would be the truth-assignments to the variables. The verifier V would look at the truth-assignments and check if each clause of the 3SAT problem instance is verified with that truth assignment.
So put succinctly for a language L in NP is described by its verifying Turing machine V, and we say that:
So to describe the complement language, L' we have:
If we wanted to 'try the same trick' for NP vs co-NP as we did for P vs co-P, the opportunity does not really present itself well. We either need to try this for a deterministic Turing machine that completely solves the language for every instance (and will probably not have a polynomial-time running bound), or we need to see if we can make it work by applying the trick to V. If we simply swap around the results for the verifying machine V, we still need to check every possible certificate C to see if a given string S is truly not accepted by V.
Related
I have been asked to prove if the following set is decidible, semi-decidible or not semi-decidible:
In other words, it is the set of inputs such that exists a Turing Machine encoded with the natural y with input p that returns its input.
Consider the set K as the set of naturals such that the Turing machine encoded with x and input x stops. This is demonstrated to be a non-decidible set.
I think that what I need is to find a reduction of K to L, but I don't know how to prove that L is decidible, semi-decidible or not semi-decidible.
L may not look decidable at first glance, because there is this nasty unbounded quantifier included, which seems to make necessary a possibly infinite search when you look for a y satisfying the condition for a specific p.
However, the answer is much simpler: There is a turing machine M which always returns its input, i.e. M(p) = p holds for all p in the considered language. Let y be a code of M. Then you can use this same y for all p, showing that L contains all words of the language. Hence L is of course decidable.
In fact, this is an example to demonstrate the principle of extensionality (if two sets have the same elements and one is decidable, then the other is decidable too, even if it doesn't look so).
I am trying to prove that the language L = {w ∈ {0, 1} ∗ | Mw(x) ↓ for an input x} is partially decidable but not decidable. Mw is an encoding of M, thus the language L is such that all encodings of machine M halt on some input x.
I have two ideas:
reduce this to the halting problem using some decider TM
use Post's Theorem and somehow prove that the complement of L is undecidable but L is partially decidable
However, I'm having trouble deciding which of these two would actually be correct and how to write it with correct notation. Can anyone offer some hints?
This answer assumes that L is the language of all representations of Turing machines which halt on some input.
First, this language must be semi-decidable, or recursively enumerable, because we can enumerate Turing-machine encodings that halt on some input. To accomplish this, begin enumerating all binary strings. At each stage, begin a new TM which begins simulating execution of the machine encoded by the string just generated on all possible inputs. Continue on so that all possible TM encodings are being simulated on all possible inputs. Dovetail the executions of these machines so that each one gets its next time quantum within finite time so that every possible input is simulated on every possible TM in finite time. If any of the simulations ever halt, then we print out the encoding that halted on the input and we can stop simulating that encoding. This must eventually print out any encoding in the language, so the language is enumerated. This means we can answer the question, "is this TM in the language?" for any provided TM given that the answer is yes (since we will eventually encounter it).
Second, the language cannot be decidable, or recursive, because this gives us a clear method of deciding the halting problem: ask whether the TM in question in in the language, and get a yes or no answer back as to whether it halts on some input. We can always modify the TM of interest so that it can only possibly halt on whatever input is of interest and then feed it into our decider if we have a specific input in mind.
Third, these facts imply that the language is not co-recursively enumerable, since its being both recursively enumerable and co-recursively enumerable would imply it is recursive, which is not the case.
How is Turing Machine which accepts nothing is not Recursively Enumerable.
We will use an indirect argument to show that the language of encodings of Turing Machines that accept nothing cannot be recursively enumerable.
Lemma 1: if L and its complement are recursively enumerable, then L is recursive.
Proof: let M be a TM that enumerates L and M' be a TM that enumerates the complement of L. Given any string s, we can decide whether s is in L as follows. Begin running M and M', interleaving their executions so that each one eventually gets an arbitrary amount of runtime. If s is in L, M will eventually list it, at which point we know s is in L and we halt-accept. If s is not in L, M' will eventually list it, at which point we know s is not in L and we halt-reject. Thus, for any s, we can halt-accept if s is in L or halt-reject otherwise. Therefore, L and its complement are recursive.
Lemma 2: The language of encodings of Turing Machines that accept something is recursively enumerable.
Proof: The set of all Turing Machine encodings is countable, and so is the set of all possible tape inputs. Thus, the set (M, s) of pairs of machines and inputs is countable. We may therefore assume some ordering of these pairs p1, p2, ..., pk, ... For each pair p = (M, s), begin executing machine M on input s, interleaving the executions of pairs p1, p2, ..., pk, ... so each eventually gets an arbitrary amount of runtime. If pk enters the halt-accept state, we may immediately list M as a TM that accepts something (namely, the corresponding s), and we can even terminate all other running instances checking the same M (and forego starting any new ones). Any machine M that accepts some input will eventually be started and will eventually halt-accept on an input, so all machines are eventually enumerated.
Lemma 3: The language of encodings of Turing Machines that accept nothing is not recursive.
Proof: This is a direct result of Rice's Theorem. The property "accepts nothing" is a semantic property of the language itself and is true for some, but not all, languages; therefore, no TM can decide whether another TM accepts a language with the property or not.
Theorem: The language of encodings of Turing Machines that accept nothing is not recursively enumerable.
Proof: Assume this language is recursively enumerable. We have already proven in Lemma 2 that its complement is recursively enumerable. By Lemma 1, then, both languages are recursive. However, Lemma 3 proves that the language is not recursive. This is a contradiction. The only assumption was that the language is recursively enumerable, so that assumption must have been false: so the language is not recursively enumerable.
It is easy to say that {} and {a,b}* are not P complete because other problems in P can't be reduced to these because {} can't accept anything and {a,b}* cannot reject anything. So, proper mapping can't be done with a reduction function.
But I'm stuck with proving that every other problem in P is P-complete.
You have to be careful when talking about P-completeness because this means different things to different people based on what type of reductions you're allowing. I'm going to assume that you're talking about using polynomial-time reductions. In that case, choose any language L ∈ P other than ∅ or {a, b}*. Now pick any language M in P that you like. Here's a silly reduction from M to L:
Given an input string w, decide whether w in M in polynomial time (this is possible because M ∈ P.)
If w ∈ M, output any string w ∈ L that you'd like (at least one exists because L is nonempty.)
Otherwise, w ∉ M, so output any string w ∉ L that you'd like (at least one exists, because L isn't {a, b}*.
This reduction takes polynomial time because each step takes polynomial time, so it's a polynomial-time reduction from an arbitrary P language to L. Therefore, L is P-complete with respect to polynomial-time reductions.
Generally speaking, when you talk about notions of completeness, you have to make sure that your reductions are given fewer computational resources than the class of solvers that you're using, or you can do weird things like what's described here that make reductions essentially useless.
What is an example of a language over the alphabet {1}* which is recognizable but not decidable?
I have troubles finding an example of this. After a long search, I am still curious for the answer though.
A hint would be very welcome.
Since the universe of strings over any finite alphabet is countable, every language can be mapped to a subset of the natural numbers. So you just have to take a Recursively enumerable language wich is not decidable and map it into a subset of {1}*.
For example, in the classic version of the halting problem we enumerate every turing machine into a binary string; you can now sort all the turing machines and define a map f : TM -> N from Turing machines to integers where f(TM) = n if TM is the nth turing machine in the ordered list of all TM.
Now, the halting problem for turing machines coded as unary numbers is r.e. but not decidable.
Imagine a machine that given two machines whose alphabets are {1}*, accepts if the first can generate all strings that the second can generate.
Our machine halts if it accepts. But for strings not in the language (the first given machine cannot generate all the strings the second one can), our machine may halt and reject, or may never halt. This means that our Turing Machine is Recognizable, but it is not decidable.
See the Encyclopedia of Mathematics for more on recognizable and undecidable languages (specifically page 56).
The only subset that is not decidable in {1}* is the empty set.
We can define a Language over {1}* in terms of a TM:
L = { < M > | M is a TM and L(M) = empty }
So we can show that L is not decidable, because a TM U that receive L as a input need to test all elements over {1}* and then decide to accept in case of M rejected all of them, so it will never halt and it means that L is not decidable, implies that the empty Language is not decidable