UNIT-5

Undecidability; the Church-Turing Thesis The Church-Turing thesis: A Turing machine that
halts on all inputs is the precise, formal notion corresponding to the intuitive notion of an
algorithm.
Note that algorithms existed before Turing machines were invented; for example, Euclids
algorithm to compute the greatest common divisor of two positive integers, and algorithms to
multiply two integers. The Church-Turing thesis cannot be proved because it relates a formal
concept (Turing machines) to a vaguely defined informal one.
An algorithm is defined as a sequence of instructions that can be unambiguously carried out by
a human to obtain some kind of a result. However, this thesis can be supported in various ways.
1. No one has yet found a natural example of an algorithm that could not be simulated by a
Turing machine. 2. Also, the fact that all reasonable extensions to Turing machines do not
increase their power, is a justification of the Church-Turing thesis.
Using the Church-Turing thesis, if one can show that a problem cannot be solved on a Turing
machine, then it is reasonable to conclude that it cannot be solved by any computer or by any
human. This brings up the question of the relative strengths of Turing machines and humans. Of
course people can do a lot of things that do not make sense for a Turing machine, such as
enjoying a musical composition, or playing a game for fun. Computers are very good at some
games, including chess. They have had a harder time with others

A Universal Turing Machine (UTM) is a foundational concept in theoretical computer science

that demonstrates the capability of Turing machines to simulate the behavior of any other Turing
machine. Here's an in-depth exploration:

Definition

Turing machine MMM on any input www. Given the encoding ⟨M,w⟩\langle M, w \
A Universal Turing Machine (UTM) is a Turing machine UUU that can simulate any other

rangle⟨M,w⟩ of MMM and www, the universal Turing machine UUU produces the same output
as M(w)M(w)M(w).

Key Components

o The UTM takes as input a string ⟨M,w⟩\langle M, w \rangle⟨M,w⟩, where:

1. Input Encoding:

 MMM: A description (encoding) of the Turing machine.

o The encoding ⟨M⟩\langle M \rangle⟨M⟩ typically represents the states, transition

 www: The input string for MMM.

functions, and symbols of MMM in a format understandable by UUU.

 2. Simulating MMM:
o The UTM reads the description of MMM and interprets it to simulate MMM step-
by-step as if it were MMM itself.

3. Output:
o The UTM halts with the same result (accept, reject, or loop forever) as
M(w)M(w)M(w).

Formal Definition

A Universal Turing Machine UUU is a 7-tuple:

U=(Q,Σ,Γ,δ,q0,qaccept,qreject),U = (Q, \Sigma, \Gamma, \delta, q_0, q_{accept},

q_{reject}),U=(Q,Σ,Γ,δ,q0,qaccept,qreject),

where:

 QQQ: Set of states.

 Σ\SigmaΣ: Input alphabet (does not include the blank symbol).
 Γ\GammaΓ: Tape alphabet (Σ⊆Γ\Sigma \subseteq \GammaΣ⊆Γ, includes the blank
symbol).
 δ\deltaδ: Transition function. Encodes the simulation of other Turing machines.
 q0q_0q0: Initial state.
 qacceptq_{accept}qaccept: Accept state.
 qrejectq_{reject}qreject: Reject state.

The UTM operates on three conceptual tapes:

1. Encoding Tape: Contains ⟨M⟩\langle M \rangle⟨M⟩, the description of the machine

MMM.
2. Input Tape: Contains www, the input for MMM.
3. Simulation Tape: Used for UUU's own computation as it simulates M(w)M(w)M(w).

Working of a Universal Turing Machine

o UUU starts by reading ⟨M⟩\langle M \rangle⟨M⟩ and www from the input tape.
1. Initialization:

o UUU decodes the transitions of MMM from ⟨M⟩\langle M \rangle⟨M⟩.

2. Interpreting MMM:

o These transitions specify how MMM would process www.

3. Simulating MMM:
 o UUU emulates MMM's state transitions:
 Reads a symbol from MMM's tape.
 Writes a symbol to MMM's tape.
 Moves MMM's head (left or right).
 Updates MMM's state.

4. Output:
o If M(w)M(w)M(w) accepts or rejects, UUU enters its qacceptq_{accept}qaccept
or qrejectq_{reject}qreject state.
o If M(w)M(w)M(w) loops indefinitely, UUU also loops indefinitely.

Diagonalization Language (LDL_DLD)

Definition

The Diagonalization Language, denoted as LDL_DLD, is constructed using a diagonalization

argument. It is designed to prove that there are languages that cannot be recognized by any
Turing machine. Formally:

LD={w∣the Turing machine encoded by w does not accept w}.L_D = \{ w \mid \text{the Turing
machine encoded by } w \text{ does not accept } w \}.LD
={w∣the Turing machine encoded by w does not accept w}.

Here:

 www is both the description of a Turing machine MwM_wMw and the input to
MwM_wMw.

Key Properties

1. Contradiction via Diagonalization:

o The construction of LDL_DLD ensures that w∈LDw \in L_Dw∈LD if and only
if w∉L(Mw)w \notin L(M_w)w∈/L(Mw), creating a self-referential paradox.
o If MMM claims to recognize LDL_DLD, it would lead to a contradiction:
 If M(w)M(w)M(w) accepts www, then w∉LDw \notin L_Dw∈/LD.
 If M(w)M(w)M(w) rejects www, then w∈LDw \in L_Dw∈LD.

2. Non-Recognizability:
o LDL_DLD is not semi-decidable because no Turing machine can consistently
decide whether w∈LDw \in L_Dw∈LD.

3. Proof of Undecidability:
 Diagonalization is a fundamental method to show that the set of all Turing
o
machines is countable, while the set of all possible languages over an alphabet is
uncountable, leaving many languages (like LDL_DLD) unrecognizable.
4. Comparison of LUL_ULU and LDL_DLD

Feature LUL_ULU LDL_DLD

{⟨M,w⟩∣M accepts w}\ {w∣the machine encoded by w does not accept w}\
{ \langle M, w \rangle \ { w \mid \text{the machine encoded by } w \
Definition
mid M \text{ accepts } w text{ does not accept } w \}
\}{⟨M,w⟩∣M accepts w} {w∣the machine encoded by w does not accept w}
Recognizability Semi-decidable Not semi-decidable
Models universal
Role Shows limits of computation
computation
Key Technique Simulation Diagonalization
Proof of unrecognizability, undecidability
Universal Turing
Applications
Machine, reductions

A reduction from a language L1L_1L1 to a language L2L_2L2 is a transformation that converts

any instance of L1L_1L1 into an instance of L2L_2L2 such that solving L2L_2L2 also solves
L1L_1L1.

Formally, we say:

L1≤mL2L_1 \leq_m L_2L1≤mL2

if there exists a computable function fff (called the reduction function) such that:

w∈L1 ⟺ f(w)∈L2.w \in L_1 \iff f(w) \in L_2.w∈L1⟺f(w)∈L2.

Key Idea

If L2L_2L2 is decidable (or semi-decidable), then L1L_1L1 must also be decidable (or semi-
decidable). Conversely, if L1L_1L1 is undecidable (or non-semi-decidable), then L2L_2L2 must
also be undecidable (or non-semi-decidable).

2. Types of Reductions

a. Many-One Reduction (≤m\leq_m≤m)

 The most common type of reduction.

 A computable function fff maps inputs from L1L_1L1 to L2L_2L2.
 Ensures w∈L1w \in L_1w∈L1 if and only if f(w)∈L2f(w) \in L_2f(w)∈L2.
b. Turing Reduction (≤T\leq_T≤T)

 Uses an oracle for L2L_2L2 to decide L1L_1L1.

 L1≤TL2L_1 \leq_T L_2L1≤TL2: L1L_1L1 can be decided by a Turing machine with
access to a decision procedure for L2L_2L2.
 More general than many-one reductions.

c. Polynomial-Time Reduction (≤p\leq_p≤p)

 Used in complexity theory.

 A reduction where fff can be computed in polynomial time.

d. Log-Space Reduction (≤L\leq_{L}≤L)

 The reduction function fff uses logarithmic space with respect to the input size.

3. Importance of Reduction

a. Proving Undecidability

 If L1L_1L1 is known to be undecidable and L1≤mL2L_1 \leq_m L_2L1≤mL2, then

L2L_2L2 is also undecidable.
 Example: Reduction from the Halting Problem to another problem demonstrates its
undecidability.

b. Proving NP-Completeness

 To prove a problem is NP-complete, we reduce a known NP-complete problem to the

given problem in polynomial time.

c. Comparing Complexity

 Reductions provide a way to classify problems into complexity classes (e.g.,

P,NP,PSPACEP, NP, PSPACEP,NP,PSPACE).

Statement of Rice's Theorem

Let PPP be a property of the languages recognized by Turing machines. Then:

1. If PPP is non-trivial:
o There exists at least one Turing machine M1M_1M1 such that the language
L(M1)L(M_1)L(M1) has property PPP.
o There exists at least one Turing machine M2M_2M2 such that the language
L(M2)L(M_2)L(M2) does not have property PPP.
 2. The decision problem:

"Does a given Turing machine M recognize a language with property P?"\text{"Does a

given Turing machine \( M \) recognize a language with property \
( P \)?"}"Does a given Turing machine M recognize a language with property P?"

is undecidable.

2. Key Terms

a. Property of a Language

A property PPP is a characteristic or attribute of the language recognized by a Turing machine.

Examples of properties include:

 Whether the language is empty.

 Whether the language is finite.
 Whether the language contains a specific string (e.g., w∈L(M)w \in L(M)w∈L(M)).

b. Non-Trivial Property

A property PPP is non-trivial if:

 There exists at least one Turing machine M1M_1M1 such that L(M1)L(M_1)L(M1)
satisfies PPP.
 There exists at least one Turing machine M2M_2M2 such that L(M2)L(M_2)L(M2) does
not satisfy PPP.

Trivial properties:

 PPP is true for all Turing machine languages.

 PPP is false for all Turing machine languages.

c. Language Recognized by a Turing Machine

The language L(M)L(M)L(M) of a Turing machine MMM is the set of strings w∈Σ∗w \in \
Sigma^*w∈Σ∗ that MMM accepts.

Implications of Rice's Theorem

1. Undecidability of Language Properties:

o Any property of Turing machine languages, beyond trivial ones, is undecidable.

2. Limits of Computability:
 o Rice's theorem underscores the limits of algorithmic solutions, even for seemingly
simple questions about languages.

3. Generalization:
o The theorem applies to all computational models equivalent to Turing machines,
such as λ-calculus, Post machines, etc.

Undecidable Problems About Languages

Undecidability in computer science refers to problems for which no algorithm exists to provide a
definitive "yes" or "no" answer for all possible inputs. Many undecidable problems arise in the
context of languages recognized by computational models like Turing machines.

Below is a detailed explanation of some of the most important undecidable problems related to
languages, their formal definitions, and the implications.

1. Halting Problem

The Halting Problem is one of the most famous undecidable problems, and it serves as the basis
for proving many other problems undecidable.

Problem Statement

Given a Turing machine MMM and an input www, does MMM halt when run on www?

Formal Language

HALT={⟨M,w⟩∣M halts on input w}.HALT = \{ \langle M, w \rangle \mid M \text{ halts on

input } w \}.HALT={⟨M,w⟩∣M halts on input w}.

Undecidability

The Halting Problem is undecidable, as proven by Alan Turing in 1936. There is no general
algorithm that can determine whether MMM halts for all possible MMM and www.

2. Emptiness Problem

The Emptiness Problem for Turing machines asks whether the language recognized by a given
Turing machine is empty.

Problem Statement
Given a Turing machine MMM, is L(M)=∅L(M) = \emptysetL(M)=∅?

Formal Language

EMPTY={⟨M⟩∣L(M)=∅}.EMPTY = \{ \langle M \rangle \mid L(M) = \

emptyset \}.EMPTY={⟨M⟩∣L(M)=∅}.

Undecidability

This problem is undecidable because we can reduce the Halting Problem to the Emptiness
Problem:

 Construct a machine M′M'M′ that simulates MMM on www and halts if MMM halts.
 L(M′)=∅L(M') = \emptysetL(M′)=∅ if and only if MMM does not halt on www.

3. Membership Problem

The Membership Problem asks whether a specific string www is in the language recognized by
a Turing machine MMM.

Problem Statement

Given a Turing machine MMM and a string www, is w∈L(M)w \in L(M)w∈L(M)?

Formal Language

MEMBER={⟨M,w⟩∣w∈L(M)}.MEMBER = \{ \langle M, w \rangle \mid w \in

L(M) \}.MEMBER={⟨M,w⟩∣w∈L(M)}.

Undecidability

This problem is undecidable in general because determining membership would require solving
the Halting Problem:

 To decide if w∈L(M)w \in L(M)w∈L(M), we would need to determine if MMM halts

and accepts www.

4. Finiteness Problem

The Finiteness Problem asks whether the language recognized by a Turing machine is finite.
Problem Statement

Given a Turing machine MMM, is L(M)L(M)L(M) finite?

Formal Language

FINITE={⟨M⟩∣L(M) is finite}.FINITE = \{ \langle M \rangle \mid L(M) \text{ is

finite} \}.FINITE={⟨M⟩∣L(M) is finite}.

Undecidability

This problem is undecidable because we can reduce the Halting Problem to the Finiteness
Problem:

 Construct a machine M′M'M′ that halts on a specific set of inputs if MMM halts.
 L(M′)L(M')L(M′) is finite if and only if MMM halts on a specific input www.

5. Universality Problem

The Universality Problem asks whether a Turing machine recognizes all possible strings over
its alphabet.

Problem Statement

Given a Turing machine MMM and an alphabet Σ\SigmaΣ, is L(M)=Σ∗L(M) = \

Sigma^*L(M)=Σ∗?

Formal Language

UNIV={⟨M⟩∣L(M)=Σ∗}.UNIV = \{ \langle M \rangle \mid L(M) = \

Sigma^* \}.UNIV={⟨M⟩∣L(M)=Σ∗}.

Undecidability

This problem is undecidable because we can reduce the Halting Problem to it:

 Construct a machine M′M'M′ that halts on all strings except when simulating MMM on a
specific input.
 L(M′)=Σ∗L(M') = \Sigma^*L(M′)=Σ∗ if and only if MMM does not halt on that input.

6. Equivalence Problem
The Equivalence Problem asks whether two Turing machines recognize the same language.

Problem Statement

Given two Turing machines M1M_1M1 and M2M_2M2, is L(M1)=L(M2)L(M_1) =

L(M_2)L(M1)=L(M2)?

Formal Language

EQUIV={⟨M1,M2⟩∣L(M1)=L(M2)}.EQUIV = \{ \langle M_1, M_2 \rangle \mid L(M_1) =

L(M_2) \}.EQUIV={⟨M1,M2⟩∣L(M1)=L(M2)}.

Undecidability

This problem is undecidable because we can reduce the Halting Problem to it:

 Construct M1M_1M1 and M2M_2M2 such that L(M1)L(M_1)L(M1) differs from

L(M2)L(M_2)L(M2) depending on whether MMM halts on a specific input.

Time complexity for Turing machines provides a way to measure how the runtime of an
algorithm grows as the size of the input increases. Here’s an introductory explanation focusing
on deterministic and nondeterministic Turing machines:

1. Deterministic Turing Machine (DTM):

 A deterministic Turing machine is a model of computation where every step is uniquely
determined by the machine's current state and the symbol under the tape head.
 For any input, the machine follows a single computational path—one step leads to the
next without ambiguity.
 Time complexity measures the number of steps the machine takes to halt for an input of
size nnn.
o Example: If a DTM solves a problem in T(n)=n2T(n) = n^2T(n)=n2, this means
the machine will execute at most n2n^2n2 steps for an input of size nnn.

2. Nondeterministic Turing Machine (NTM):

 A nondeterministic Turing machine can "guess" or "branch" into multiple possible
computational paths at each step.
o Think of it as exploring many possible solutions simultaneously.
 It accepts an input if any of its computational paths reach an accepting state.
  Time complexity for an NTM measures the length of the longest path needed to reach an
answer (assuming the machine "guesses" correctly).

3. Key Differences in Time Complexity:

 A DTM always takes a single, predictable path to solve a problem, while an NTM
explores many paths simultaneously.
 For a given problem:
o If an NTM solves the problem in T(n)T(n)T(n) steps, simulating it with a DTM
can take up to O(2T(n))O(2^{T(n)})O(2T(n)) steps, as the DTM must explore all
possible paths.

4. Simple Analogy:
 Imagine you’re trying to find a key in one of 100 boxes:
o On a DTM, you must open each box one by one. This could take up to 100 steps.
o On an NTM, you magically “try all boxes at once,” finding the key immediately
if it’s in any box. This might take only 1 step.

5. Importance of Time Complexity in Theory:

 P (Polynomial Time): Problems solvable in polynomial time by a DTM.
 NP (Nondeterministic Polynomial Time): Problems solvable in polynomial time by an
NTM.
 A major question in computer science is whether P=NP\text{P} = \text{NP}P=NP,
meaning: Can problems solved efficiently by guessing (NTM) also be solved efficiently
without guessing (DTM)?

Understanding time complexity for these machines sets the stage for studying computational
complexity theory and the nature of efficient problem-solving.

Class P (Polynomial-Time Problems)

Definition
The class PPP consists of all decision problems (yes/no problems) that can be solved by a
deterministic Turing machine in polynomial time. In simpler terms, PPP includes problems for
which we can find a solution efficiently.

Key Features

 Deterministic Algorithm: The algorithm follows a specific sequence of steps to find the
solution.
 Polynomial Time: The time to solve the problem is bounded by a polynomial function of
the input size (O(nk)O(n^k)O(nk), where kkk is a constant).

Examples

 Sorting a list (e.g., Merge Sort, Quick Sort).

 Finding the shortest path in a graph (e.g., Dijkstra’s algorithm).
 Testing primality (determining if a number is prime).

Significance

PPP represents the set of problems that are "efficiently solvable."

2. Class NP (Nondeterministic Polynomial-Time Problems)

Definition

The class NPNPNP consists of all decision problems for which a solution can be verified in
polynomial time by a deterministic Turing machine.

Key Features

 Verification vs. Solving: While the problem might not be efficiently solvable, any given
solution can be checked efficiently.
 Nondeterministic Machine: A nondeterministic Turing machine can explore all possible
solutions simultaneously and "guess" the correct one in polynomial time.

Examples

 Subset sum problem: Does a subset of numbers in a list add up to a given value?
 Graph coloring: Can a graph be colored with kkk colors without adjacent nodes sharing
the same color?
 Hamiltonian cycle: Does a cycle exist that visits every vertex exactly once?

Relationship to PPP
  Clearly, P⊆NPP \subseteq NPP⊆NP, since any problem solvable in polynomial time can
also be verified in polynomial time.

3. NP-Complete Problems

Definition

A problem is NP-complete if:

1. It belongs to NPNPNP, meaning solutions can be verified in polynomial time.

2. Every other problem in NPNPNP can be reduced to it in polynomial time.

Key Features

 Hardest Problems in NPNPNP: If any NPNPNP-complete problem is shown to be

solvable in polynomial time, then every problem in NPNPNP can also be solved in
polynomial time (P=NPP = NPP=NP).
 Reduction: To prove that a problem is NPNPNP-complete, we typically reduce a known
NPNPNP-complete problem to it.

Examples

1. SAT (Boolean Satisfiability Problem): Given a Boolean formula, is there an assignment

of truth values to variables that makes the formula true? (This was the first problem
proven to be NPNPNP-complete by Cook’s theorem.)
2. Traveling Salesperson Problem (TSP): Given a set of cities and distances, is there a
tour visiting each city exactly once with a total distance less than or equal to kkk?
3. Knapsack Problem: Given a set of items with weights and values, can we select items to
maximize value without exceeding a weight limit?

Significance

NPNPNP-complete problems are the benchmark for intractability. They are widely believed to
require non-polynomial time to solve.

4. P vs. NP Question

The Core Question

 Does P=NPP = NPP=NP?

 In other words, can every problem whose solution can be verified in polynomial time also
be solved in polynomial time?
Implications

 If P=NPP = NPP=NP, it would revolutionize fields like cryptography, optimization, and

artificial intelligence, as many currently intractable problems would become solvable
efficiently.
 If P≠NPP \neq NPP=NP, it confirms the inherent difficulty of certain computational
problems.

5. NP-Hard Problems

Definition

A problem is NPNPNP-hard if every problem in NPNPNP can be reduced to it in polynomial

time. Unlike NPNPNP-complete problems, NPNPNP-hard problems:

 May not belong to NPNPNP.

 Are not necessarily decision problems; they can include optimization problems.

Examples

 TSP Optimization Problem: Find the shortest possible route that visits each city exactly
once.
 Halting Problem: Undecidable and not in NPNPNP, but NPNPNP-hard.

Relationship to NP-Complete

Every NPNPNP-complete problem is NPNPNP-hard, but not all NPNPNP-hard problems are
NPNPNP-complete.

6. Cook’s Theorem

Statement

The Boolean Satisfiability Problem (SAT) is NPNPNP-complete.

Proof Outline

1. Show SAT is in NPNPNP: Any satisfying assignment for a Boolean formula can be
verified in polynomial time.
2. Show every problem in NPNPNP can be reduced to SAT in polynomial time:
o Simulate a nondeterministic Turing machine solving a problem in NPNPNP using
a Boolean formula.
 o Construct a formula such that the formula is satisfiable if and only if the machine
accepts the input.

Significance

Cook’s theorem provides the foundation for the concept of NPNPNP-completeness. By reducing
SAT to other problems, we can prove those problems are also NPNPNP-complete.

7. Summary of Relationships

Class Definition

PPP Problems solvable in polynomial time by a deterministic Turing machine.

NPNPNP Problems for which solutions can be verified in polynomial time.

NPNPNP- Problems in NPNPNP that are at least as hard as every other problem in
Complete NPNPNP.

Problems that are at least as hard as NPNPNP-complete problems but not

NPNPNP-Hard
necessarily in NPNPNP.

8. Implications in Real-World Problems

1. Cryptography: Many cryptographic systems rely on problems believed to be NPNPNP-

hard, such as factoring large numbers.
2. Optimization: Problems like TSP and Knapsack are critical in logistics, resource
allocation, and scheduling.
3. Machine Learning: Problems like feature selection and clustering often involve
NPNPNP-hard optimization tasks.