I've been looking into and learning variants of the halting/acceptance problem of Turing Machine, and was wondering if there is a problem defined as:
{< M,x >|M halts on input x in at most f(|x|) steps, where |x| is the length of x and f(|x|) is a deterministic function of |x|}
Related
L = {<M> : M(x) is a Turing machine with running time bounded by 100|x|^2 + 200}
I think L is undecidable but I can't solve that. Please help me prove it. Thanks!
The language L is decidable because it's property is related to the structure of the turing machine. In other words, it doesn't satisfy the third condition of the Rice's theorem which states that an undecidable property must be related to the language of the turing machine and not the structure of the machine.
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.
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.
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