Q.

1 Elaborate the following terms with proper examples

i) Universal Turing Machine (UTM)

ii) Recursively Enumerable Languages

i) Universal Turing Machine (UTM):

 A Universal Turing Machine (UTM) is a Turing machine that can

imitate any other Turing machine. It works like a "general-purpose
computer."

 Instead of being designed for one specific task, the UTM takes the
description of another Turing machine and its input as its own input.

Example:
If you give a UTM the encoding of a Turing machine that adds two
numbers and an input string "2+3", the UTM will imitate that Turing
machine to produce the result "5."

ii) Recursively Enumerable Languages:

 A language is called recursively enumerable if there is a Turing

machine that accepts every string in the language but might not
stop for strings not in the language.

 These languages are also called "semi-decidable" because the

machine might not give a definitive "no" answer for invalid strings.

Example:
Consider the language L = {strings that represent prime numbers}. A
Turing machine can check whether a number is prime and accept it, but it
might run forever for non-prime inputs.

Q.2 What is undecidability? How do we prove universal language is

undecidable? What is the relation between undecidability and reducibility

theory.
Q.3 What is a Turing Machine? Give the formal definition of TM.

Design a TM that replaces every occurrence of abb by baa.

What is a Turing Machine?

A Turing Machine (TM) is a mathematical model of computation that

defines an abstract machine. It manipulates symbols on a tape according
to a set of rules. A Turing machine can simulate any computer algorithm
and is used to study the limits of what can be computed.

Formal Definition of a Turing Machine:

A Turing Machine is a 7-tuple:

M = (Q, Σ, Γ, δ, q₀, q_accept, q_reject)
Where:

1. Q: Finite set of states.

2. Σ: Input alphabet (does not include the blank symbol ␣).

3. Γ: Tape alphabet (includes Σ and the blank symbol ␣).

4. δ: Transition function, δ: Q × Γ → Q × Γ × {L, R}.

o Describes the machine's move based on the current state and

tape symbol.

5. q₀: Initial state (q₀ ∈ Q).

6. q_accept: Accept state (q_accept ∈ Q).

7. q_reject: Reject state (q_reject ∈ Q, q_accept ≠ q_reject).

TM to Replace Every Occurrence of abb with baa:

To design the TM:

 The machine scans the tape for "abb."

 When it finds "abb," it replaces it with "baa."

 The machine continues until the entire input is processed.

Steps:

1. Start from the leftmost position.

2. If the machine reads "abb":

o Replace a → b, b → a, b → a.
 3. Move right and repeat.

4. Halt when no more "abb" is found.

Transitions:

1. Read a, b, b in sequence:

o Replace a with b, move right.

o Replace first b with a, move right.

o Replace second b with a.

2. Continue scanning for the next occurrence.

This TM works iteratively to find and replace occurrences of abb with baa

Q.4 How turing machine can be use to compute the functions? Design
turing

machine for multiplication of two numbers.

How a Turing Machine Computes Functions:

A Turing Machine (TM) computes functions by transforming an input into

an output based on a predefined set of rules. The input is encoded on the
tape, and the TM processes it step-by-step according to its transition
functions until it reaches the desired result.

For functions like multiplication, the TM can encode numbers and perform
operations similar to how humans do, using repeated addition,
subtraction, or shifting techniques.

Design a Turing Machine for Multiplication of Two Numbers:

Objective:

Given two numbers mmm and nnn encoded in unary (e.g., 3 = "111"), the
TM should compute their product m×nm \times nm×n in unary.
Input Format on the Tape:

Input is written as m#nm \# nm#n, where mmm and nnn are in unary,
and # separates them. For example, multiplying 3×23 \times 23×2 is
encoded as 111#11.

Output Format on the Tape:

The result m×nm \times nm×n is written as a sequence of unary symbols,

e.g., 11111 for 3×2=63 \times 2 = 63×2=6.

High-Level Steps:

1. Copy mmm:

o Copy mmm as many times as there are symbols in nnn.

2. Use a marker:

o Mark each symbol in nnn after processing it to avoid re-

processing.

3. Iterate until nnn is completely processed.

4. Erase markers and format the output.

Transitions for the TM:

1. Start in the initial state and move right to locate the #.

2. Copy mmm after the # for each 1 in nnn:

o Use a marker (e.g., replace 1 in nnn with X) to track processed

symbols.

3. After copying, move back to the beginning of nnn and repeat until
all 1s in nnn are processed.

4. Clean up by erasing # and markers to leave only the output.

Example Walkthrough for Input 111#11:

1. Start with tape: 111#11 (3 × 2).

2. Copy 111 after the # for the first 1 in 11:

o Tape becomes 111#11#111.

3. Mark the first 1 in 11 as processed:

 o Tape becomes 111#X1#111.

4. Copy 111 again for the second 1 in 11:

o Tape becomes 111#X1#111111.

5. Mark the second 1 in 11:

o Tape becomes 111#XX#111111.

6. Clean up markers and #:

o Final tape: 111111 (result = 6).

This Turing Machine performs multiplication by leveraging repeated

addition, marking symbols, and iterating systematically over the input.

Q.5 Elaborate the following terms.

i) Universal Turing Machine (UTM)

ii) Recursively Enumerable Languages

iii) Halting problem of Turing Machine

i) Universal Turing Machine (UTM):

 A Universal Turing Machine (UTM) is a Turing machine that can

simulate the behavior of any other Turing machine.

 Instead of solving a specific problem, it takes two inputs:

1. The description of another Turing machine MMM (encoded as a

string).

2. The input www for that Turing machine MMM.

 The UTM processes this information and behaves exactly as MMM

would on www.

Example:
If MMM is a Turing machine designed to check whether a number is prime,
the UTM can simulate MMM to determine if the input number is prime.

ii) Recursively Enumerable Languages:

  A language is called recursively enumerable (RE) if there exists a
Turing machine that can recognize strings in the language.

 The machine will halt and accept if the string is in the language.
However, if the string is not in the language, the machine might:

o Run forever (without halting).

o Reject explicitly.

Key Points:

 These languages are also called semi-decidable.

 They are more general than decidable languages because they do

not guarantee halting for invalid inputs.

Consider the language L={w ∣ w encodes a valid prime number}L = \

Example:

{w \,|\, w \text{ encodes a valid prime

number}\}L={w∣w encodes a valid prime number}. A Turing machine can
recognize www if it is a prime but might run infinitely for non-prime
numbers.

iii) Halting Problem of Turing Machine:

 The halting problem is a decision problem that asks:

"Given a Turing machine MMM and an input www, will MMM halt on
www or run forever?"

 Key Result: Alan Turing proved that the halting problem is

undecidable. This means there is no general algorithm (or Turing
machine) that can solve the halting problem for all possible
machines and inputs.

Explanation:

 If we try to create a machine HHH that determines whether MMM

halts on www, contradictions arise when HHH is tested on specific
inputs.

Example of Contradiction:
Imagine a machine HHH that solves the halting problem. If HHH is fed a
description of itself as input, it leads to contradictory behavior, proving
that such a machine cannot exist.
Q.5 Write short notes on:

i) Reducibility

ii) Multi-tape Turing Machine

Q.6 What is pushdown automata? Define PDA pictorially and

mathematically

with respect to input tape, stack, finite control and Instanteous

description.

Definition of Pushdown Automaton (PDA)

A Pushdown Automaton (PDA) is a computational model that extends

the capabilities of a finite automaton by adding a stack as an auxiliary
storage device. This stack allows the PDA to recognize context-free
languages.

Components of a PDA

A PDA consists of:

1. Input Tape: A tape that holds the input string. The input is read
symbol by symbol.

2. Finite Control: A finite state machine that governs the PDA’s

transitions.

3. Stack: A data structure used for auxiliary memory, with operations

like push, pop, and peek.

Formal Definition of PDA

A PDA is defined as a 7-tuple:

P=(Q,Σ,Γ,δ,q0,Z0,F)P = (Q, \Sigma, \Gamma, \delta, q_0, Z_0,

F)P=(Q,Σ,Γ,δ,q0,Z0,F)

Where:

1. QQQ: A finite set of states.

2. Σ\SigmaΣ: Input alphabet (symbols from the input tape).

 3. Γ\GammaΓ: Stack alphabet (symbols that can be pushed onto or
popped from the stack).

4. δ\deltaδ: Transition function, defined as:

δ:Q×(Σ∪{ϵ})×Γ→Powerset(Q×Γ∗)\delta: Q \times (\Sigma \cup \{\
epsilon\}) \times \Gamma \to \text{Powerset}(Q \times \
Gamma^*)δ:Q×(Σ∪{ϵ})×Γ→Powerset(Q×Γ∗) The PDA moves based
on the current state, input symbol, and stack top, updating the state
and stack.

5. q0q_0q0: The start state (q0∈Qq_0 \in Qq0∈Q).

6. Z0Z_0Z0: Initial stack symbol (Z0∈ΓZ_0 \in \GammaZ0∈Γ).

7. FFF: A set of accepting states (F⊆QF \subseteq QF⊆Q).

Instantaneous Description (ID)

An Instantaneous Description (ID) of a PDA provides a snapshot of its

current configuration, consisting of:

1. The current state of the finite control.

2. The remaining input string on the tape.

3. The current stack contents.

An ID is written as:

(q,w,α)(q, w, \alpha)(q,w,α)

Where:

 qqq: Current state.

 www: Remaining input string.

 α\alphaα: Current stack contents (top of the stack on the left).

Transition in ID

If δ(q,a,X)=(q′,β)\delta(q, a, X) = (q', \beta)δ(q,a,X)=(q′,β):

 Current state: qqq.

 Input symbol: aaa (or ϵ\epsilonϵ).

 Stack top: XXX.

 Next state: q′q'q′.

  Stack update: Replace XXX with β\betaβ.

Transition is written as:

(q,aw,Xα)⊢(q′,w,βα)(q, aw, X\alpha) \vdash (q', w, \beta\alpha)

(q,aw,Xα)⊢(q′,w,βα)

Q.7 Compare FA and PDA.