Decision Problems

In a nutshell: In computability theory and computational complexity theory, a

decision problem is a question in some formal system with a yes-or-no answer.
For example, the problem "given two numbers x and y, does x evenly divide y?"
is a decision problem. The answer can be either 'yes' or 'no', and depends upon
the values of x and y.

The Entscheidungsproblem, German for "Decision-problem", is attributed to

David Hilbert: "At [the] 1928 conference Hilbert made his questions quite
precise. First, was mathematics complete... Second, was mathematics
consistent... And thirdly, was mathematics decidable? By this he meant, did there
exist a definite method which could, in principle be applied to any assertion, and
which was guaranteed to produce a correct decision on whether that assertion
was true" Hilbert believed that "in mathematics there is no ignorabimus'
meaning 'we will not know'.

A simple example: Decision Problems for Regular Languages

In a nutshell: A question that takes collection of automata and asks for a

terminating algorithm yielding a Boolean (true or false) answer is called a
decision problem. Note that a decision problem is a question about the (often
infinite) set of strings in the language; and answers that involve running the
machine on every string are not useful, since they will take forever. That is not
allowed: in every case, a decision algorithm must return a correct answer in
finite time.

Here is a list of decision problems for automata and regular expressions:

These three problems are easily solved: for the first, merely run the string x
through the DFA and check whether the machine is in an accept state at the end of
the run. For the second, first translate the NFA to an equivalent DFA by the subset
construction and then run the DFA on the string. For the third, one must translate
the regular expression to an NFA and then translate the NFA to a DFA before
running the DFA on x.
Decidability

In a nutshell: There are 3 possible outcomes for a Turing Machine:

1. Accept
2. Reject
3. Loop

If a TM always halts (accepts or rejects) when reading strings from a

language, we say that the language is decidable
If a TM can always tell when a string is in a language, but may loop forever if
it is not, we say that the language is Turing-recognizable

More formally:

Definition (Turing-recognizable, Recursively enumerable). A language L is Turing

recognizable, or recursively enumerable, if there is some Turing machine M
(called a recognizer) such that

L = L(M) = {w | M halts and accepts w} .

Notice that M only has to halt for strings in L to be a recognizer; on strings

outside of L it may either reject or loop.

Definition (Decidable, Recursive). A language L is decidable, or recursive, if there

exists a Turing machine M (called a decider) that recognizes L and always halts.

Thus a decider always says „yes‟ given a string in the specified language, and
always says „no‟ given a string outside the specified language. Obviously, it is
better to have a decider than a recognizer, since it is required to always give a
verdict. The reason that the recognizer/decider distinction is important is that
blind simulation is in many cases an easy-to-use technique in building
recognizers.

Definition (Decision Problem). A decision problem for a language L is just the

question: is there a decider for L?

All decidable languages are Turing-recognizable but the converse is not true.

Think about an “incomputable”

quality like intelligence

“I can’t decide what

intelligence is, but I recognize
it when I see it”
 Encodings

ADFA = {<A,w>| A is a DFA accepting w} is a decidable language

M= “On input <A,w>

1. Simulate A on input w
2. If simulation ends in accept state,
accept, otherwise, reject"

(encodings of all DFAs together with the strings that they accept)

In general, to show that a problem is decidable, it suffices to display an

algorithm and show that it solves the problem. But everything we‟ve seen so far
is Turing Machines recognizing languages that we know are decidable.

Are there any languages that are not decidable, even though
a Turing Machine can recognize them?

The answer to the question above is obviously yes, and one example of such
languages is the one described by the Halting Problem.

Universal Turing Machines

The Universal Turing Machine, U, is a TM that is capable of simulating any other

Turing Machine by encoding the latter

By convention we use

{q}{0,1}* to encode the states

{a}{0,1}* to encode the alphabet

What we want from U…

Given a representation of any Turing machine, followed by the representation of

a given string we want U to give us a description of M(w) as an output.
We simulate it with a 3-tape TM.
The Halting Problem/Undecidability

Given an arbitrary Turing Machine (M), and arbitrary input for

the TM (w), will the given TM halt on the given input?

In other words, we are wondering whether it would be possible to construct a

Turing Machine U that would take two inputs:

1. A Turing Machine M, and

2. Some input w for M

And would give as its output the answer to the question of whether U executing
M would ever halt on input w.

H= {<M,w>| Turing Machine M halts on input string w}

To see that this problem is Turing-recognizable (semi-decidable), we construct a

TM, MH, which recognizes H

MH = “On input <M,w>

1. Simulate M on input w
2. If M enters accept state, accept,
otherwise, reject.

To see that H is undecidable we must assume H is decidable and try to reach a

contradiction. The proof of this is in your book (pages 429-430)

Languages which are NOT semi-decidable

Lastly, let‟s see that there are languages that are not Turing-recognizable:

The set of all Turing Machines is countable since we can count the
descriptions <M>.
The set of all languages is uncountable

We cannot put into a correspondence the set of languages with the set of TMs
since there are more languages than TMs and therefore we conclude that there
are languages that cannot be recognized by any Turing Machine.
EXAMPLEs:
¬H= {<M,w>| Turing Machine M does not halt on input string w}
or
{<M>| L(M)=∑*}

(in either case, to prove it we would have to run the machine forever)

Theorem: A language is decidable if and only if both it and its complement are
Turing-recognizable.

Reductions

A reduction is a way of converting one problem into another such that a solution
to the second problem would lead to a solution to the first.

To prove that a language A is NOT decidable we show that if A

can be reduced to the Halting Problem and A was decidable, then
the Halting Problem would also be decidable.

Example:

ATM = {<M,w>|M is a TM accepting w} is undecidable.

To prove we have to assume that ATM is decidable and try to reach a

contradiction, i.e. assume there exists R, a TM that decides ATM. Then we
construct another oracle TM S performing operations on the encoding of M.

In the end if R decides ATM, then S decides H. Since we know that H is

undecidable, then ATM must also be undecidable.

There are many examples of this on chapter 21 of your book.