TOC ANSWERS CLASS TEST

1) Construct the CFG for the language having any number of a's over the
set ∑= {a}.

For the language containing any number of a's over the alphabet Σ={a}
the corresponding Context-Free Grammar (CFG) can be defined as
follows:
CFG:
 Non-terminal: S (Start symbol)
 Terminal: a
 Production rules:
1. S→aS
2. S→ϵS
 The first rule S→aS generates one a and then calls the production again, allowing for
any number of a's.
 The second rule S→ϵS is the base case, which allows the string to terminate with no
a's, representing the empty string.

This CFG generates strings like ϵ\epsilonϵ, a, aa, aaa, etc., which cover all possible strings of
a over the alphabet Σ={a}.

2) Difference between Ambiguous and Unambiguous Grammar

S.NO Ambiguous Grammar Unambiguous Grammar

In ambiguous grammar, the leftmost

In unambiguous grammar, the leftmost
1. and rightmost derivations are not
and rightmost derivations are same.
same.

Amount of non-terminals in Amount of non-terminals in

2. ambiguous grammar is less than in unambiguous grammar is more than in
unambiguous grammar. ambiguous grammar.
S.NO Ambiguous Grammar Unambiguous Grammar

Length of the parse tree in

Length of the parse tree in ambiguous
3. unambiguous grammar is
grammar is comparatively short.
comparatively large.

Speed of derivation of a tree in Speed of derivation of a tree in

4. ambiguous grammar is faster than that unambiguous grammar is slower than
of unambiguous grammar. that of ambiguous grammar.

Ambiguous grammar generates more Unambiguous grammar generates only

5.
than one parse tree. one parse tree.

Ambiguous grammar contains Unambiguous grammar does not

6.
ambiguity. contain any ambiguity.

3) Convert a left linear grammar to left linear grammar. S→ Sa|Abc A→ Sa|Ab|a

This grammar is already left-linear since all the non-terminal symbols appear at the
leftmost side of the right-hand side of the production rules. A left-linear grammar is a
type of regular grammar where all the rules have the form A→xB or A→xA where B
is a non-terminal and x is a string of terminals.

Thus, there is no need for conversion as this grammar is already left-linear. Let's
rewrite it just for clarity:

Left-Linear Grammar:

1. S→Sa ∣ Abc
2. A→Sa ∣ Ab ∣ a

4) Conversion of RLG to LLG: S → aS | bA S → aS | bB S → aB | bB | ε

To convert a Right-Linear Grammar (RLG) to a Left-Linear Grammar (LLG),

we need to change the position of non-terminals from the rightmost side of production
rules to the leftmost side, while still generating the same language.

 Reversing the language: For every string generated by an RLG, the

corresponding LLG must generate the reverse of that string. Therefore, we will first
reverse the production rules by shifting non-terminals to the leftmost position.

 Handling multiple rules for the same non-terminal: Combine similar rules into
a single set where necessary.
 Step 1: Reverse the production rules

We'll reverse each production and modify non-terminals as needed. For example:

 S→aS (generates strings of the form "a...") will reverse to S→Sa

 S→bA (generates strings of the form "...b") will reverse to A→Sb

To convert a Right-Linear Grammar (RLG) to a Left-Linear Grammar (LLG),

we need to change the position of non-terminals from the rightmost side of production
rules to the leftmost side, while still generating the same language.

Given Right-Linear Grammar (RLG):

1. S→aS ∣ bAS \to aS \ | \ bAS→aS ∣ bA

2. S→aS ∣ bBS \to aS \ | \ bBS→aS ∣ bB
3. S→aB ∣ bB ∣ ϵS \to aB \ | \ bB \ | \ \epsilonS→aB ∣ bB ∣ ϵ

Approach to Convert RLG to LLG:

1. Reversing the language: For every string generated by an RLG, the corresponding
LLG must generate the reverse of that string. Therefore, we will first reverse the
production rules by shifting non-terminals to the leftmost position.
2. Handling multiple rules for the same non-terminal: Combine similar rules into a
single set where necessary.

Let's proceed step by step.

Step 1: Reverse the production rules

We'll reverse each production and modify non-terminals as needed. For example:

 S→aS(generates strings of the form "a...") will reverse to S→Sa

 S→bA (generates strings of the form "...b") will reverse to A→Sb

Step 2: Applying the transformation

Here’s the conversion of each right-linear rule to left-linear:

1. From S→aS
o S→Sa(reverse of S→aS)
o A→Sb (reverse of S→bA)
2. From S→aS ∣ bB:
o S→Sa (already done in previous step)
o B→Sb (reverse of S→bB)
3. From S→aB ∣ bB ∣ϵ:
o B→Sa (reverse of S→aB)
o B→Sb (already done)
o S→ϵ (remains unchanged since it represents the empty string)

Final left linear Grammer-

1) S-> Sa | e
2) A -> Sb
3) B -> Sa| Sb

4) Differenciate between Chomsky normal form CNF and Greibach normal form
GNF alongwith their examples.

CNF (Chomsky Normal GNF (Greibach Normal

Feature
Form) Form)
Non-terminal → Two non- Non-terminal →
Rule
terminals OR Non-terminal Terminal followed by any
Structure
→ Terminal number of non-terminals
Parsing Suitable for bottom-up Ideal for top-down
Method parsing methods parsing methods
Grammar Can increase the number of Potentially increases the
Complexity production rules length of production rules
Allows both left and right
Recursion Eliminates left recursion
recursion
Used in many theoretical Used in practical parser
Use Case aspects of computer construction, especially
science for simple languages
Relatively straightforward
Conversion More complex
conversion from general
Complexity conversion process
CFG

5) Derive the string for leftmost derivation and rightmost derivation using a CFG
given by, w1=("aabbabba") and w2= "00101" 1) S → aB | bA 2)S → A1B S → a |
aS | bAA A → 0A | ε S → b | aS | aBB B → 0B | 1B | ε

Leftmost and Rightmost Derivations of Given Strings

Derivation of w1 = "aabbabba"

1. Leftmost Derivation

1. Start with S.

2. Apply the rule S → aS, resulting in "aS".

3. Apply S → aB, resulting in "aaB".

4. Apply B → bA, resulting in "aabA".

5. Apply A → bAA, resulting in "aabbAA".

6. Apply A → aB, resulting in "aabbaB".

7. Apply B → bB, resulting in "aabbabB".

8. Apply B → bB, resulting in "aabbabbB".

9. Apply B → ε, resulting in "aabbabba".

2. Rightmost Derivation

1. Start with S.

2. Apply the rule S → aS, resulting in "aS".

3. Apply S → aB, resulting in "aaB".

4. Apply B → bA, resulting in "aabA".

5. Apply A → bAA, resulting in "aabbAA".

6. Apply A → aB, resulting in "aabbaB".

7. Apply B → bB, resulting in "aabbabB".

8. Apply B → bB, resulting in "aabbabbB".

9. Apply B → ε, resulting in "aabbabba".

Derivation of w2 = "00101"

1. Leftmost Derivation

1. Start with S.

2. Apply the rule S → A1B, resulting in "A1B".

3. Apply A → 0A, resulting in "0A1B".

4. Apply A → 0A, resulting in "00A1B".

5. Apply A → ε, resulting in "001B".

6. Apply B → 1B, resulting in "0011B".

7. Apply B → 0B, resulting in "00110B".

8. Apply B → 1B, resulting in "001101B".

9. Apply B → ε, resulting in "001101".

2. Rightmost Derivation

1. Start with S.

2. Apply the rule S → A1B, resulting in "A1B".

3. Apply A → 0A, resulting in "0A1B".

4. Apply A → 0A, resulting in "00A1B".

5. Apply A → ε, resulting in "001B".

6. Apply B → 1B, resulting in "0011B".

7. Apply B → 0B, resulting in "00110B".

8. Apply B → 1B, resulting in "001101B".

9. Apply B → ε, resulting in "001101".

7)

Explain the relationship between grammar and language in TOC

A grammar is a set of production rules which are used to generate strings of a

language. In this article, we have discussed how to find the language generated by a
grammar and vice versa as well.

Language generated by a grammar –

Given a grammar G, its corresponding language L(G) represents the set of all strings
generated from G. Consider the following grammar,

G: S-> aSb|ε

In this grammar, using S-> ε, we can generate ε. Therefore, ε is part of L(G).

Similarly, using S=>aSb=>ab, ab is generated. Similarly, aabb can also be generated.
Therefore,

L(G) = {anbn, n>=0}

 In language L(G) discussed above, the condition n = 0 is taken to accept ε.
Key Points –

 For a given grammar G, its corresponding language L(G) is unique.

 The language L(G) corresponding to grammar G must contain all strings which can be
generated from G.
 The language L(G) corresponding to grammar G must not contain any string which
can not be generated from G.

8) Explain PDA

Pushdown Automata(PDA)

o Pushdown automata is a way to implement a CFG in the same way we design DFA
for a regular grammar. A DFA can remember a finite amount of information, but a
PDA can remember an infinite amount of information.
o Pushdown automata is simply an NFA augmented with an "external stack memory".
The addition of stack is used to provide a last-in-first-out memory management
capability to Pushdown automata. Pushdown automata can store an unbounded
amount of information on the stack. It can access a limited amount of information on
the stack. A PDA can push an element onto the top of the stack and pop off an
element from the top of the stack. To read an element into the stack, the top elements
must be popped off and are lost.
o A PDA is more powerful than FA. Any language which can be acceptable by FA can
also be acceptable by PDA. PDA also accepts a class of language which even cannot
be accepted by FA. Thus PDA is much more superior to FA.

The PDA can be defined as a collection of 7 components:

 Q: the finite set of states

∑: the input set

Γ: a stack symbol which can be pushed and popped from the stack

q0: the initial state

Z: a start symbol which is in Γ.

F: a set of final states

9)

Explain:Why NPDA is more powerful than DPDA

A Non-deterministic Pushdown Automaton (NPDA) is more powerful than a

Deterministic Pushdown Automaton (DPDA) because an NPDA can recognize a
broader class of languages, specifically:

1. Language Recognition Power:

o DPDA can recognize only deterministic context-free languages (DCFLs),
which are a subset of context-free languages (CFLs). These languages have a
strict requirement where the transitions between states must be deterministic,
meaning that the next action is always uniquely determined by the current
state, input symbol, and stack content.
o NPDA, on the other hand, can recognize all context-free languages (CFLs).
This includes non-deterministic languages where multiple possible transitions
can occur from a given state, input symbol, and stack content. Thus, an NPDA
can "guess" and explore multiple possible computation paths, making it more
powerful in recognizing certain CFLs that a DPDA cannot.
2. Handling Ambiguity and Non-determinism:
o In a DPDA, for every state, input symbol, and stack content, there must be
exactly one transition. This restriction means that DPDAs cannot handle
languages that require non-deterministic choices to process strings.
o An NPDA allows multiple transitions for the same input and stack
configuration. This non-determinism gives NPDAs the ability to make guesses
at critical points in computation (e.g., deciding which branch of a grammar to
follow), and if one computation path leads to acceptance, the entire input is
accepted.
3. Example:
o A classic example of a language that can be recognized by an NPDA but not
by a DPDA is the language L = { a^n b^n c^n | n ≥ 1 }. This language
requires balancing three different symbols (where the number of a’s, b’s, and
c’s must match). An NPDA can handle this by guessing the transition points,
 but a DPDA cannot, as it cannot deterministically decide the point to transition
between reading a's, b's, and c's.
4. Formal Language Implications:
o DPDA: A deterministic pushdown automaton is strictly less powerful than an
NPDA because it can only recognize a subset of CFLs (DCFLs). DPDAs are
used to recognize languages like balanced parentheses or palindromes
where deterministic parsing rules can be applied.
o NPDA: A non-deterministic pushdown automaton can recognize all context-
free languages, including ambiguous languages and those requiring non-
deterministic decision-making.

10)

Solve to obtain PDA from CFG S → 0S1 | A A → 1A0 | S | ε

Given CFG:
S → 0S1 | A
A → 1A0 | S | ε
For string: '11'

To construct a PDA from the given CFG, the approach is to simulate the derivations
of the CFG in the PDA by pushing and popping the symbols in correspondence to the
production rules.

For this CFG:

- For rule S → 0S1, the PDA pushes 0 onto the stack and then processes S
recursively, eventually expecting a 1 to pop the 0.
- For rule A → 1A0, the PDA similarly pushes 1 and expects 0 later.
- The PDA accepts by emptying the stack.

PDA Transitions:

1. d(q0, 0, Z0) = (q0, SZ0)

2. d(q0, 0, S) = (q0, 0S1)

3. d(q0, 1, S) = (q0, 1A0)

4. d(q0, 1, A) = (q1, ε)

5. d(q1, 1, A) = (q1, ε)

Thus, the string '11' is accepted.

11) Convert a PDA to a CFG : d(q0,0,Z0) = (q0, XZo) d(q0,0,X) = (q0,XX) d(q0,1,X)
= (q1,e) d(q1,1,X) = (q1,e) d(q1,e,X) = (q1,e) d(q1,e,Zo) = (q1,e
PDA Transitions

1. d(q0, 0, Z0) = (q0, XZ0)

2. d(q0, 0, X) = (q0, XX)
3. d(q0, 1, X) = (q1, ε)
4. d(q1, 1, X) = (q1, ε)
5. d(q1, ε, X) = (q1, ε)
6. d(q1, ε, Z0) = (q1, ε)

Steps to Convert PDA to CFG

1. **Create Non-terminals for Each Pair of States:**

Each pair of PDA states (q, p) is represented as a non-terminal A_qp. This non-
terminal indicates that the PDA moves from state q to state p while processing input
and managing the stack.

2. **Define Production Rules:**

Each PDA transition will be converted into a CFG production rule. Push transitions
(where the PDA adds symbols to the stack) introduce non-terminal symbols, while
pop transitions remove them.

Start Symbol

The start symbol of the CFG will be A_q0q1, which represents the PDA moving from
state q0 to state q1, starting with the initial stack symbol Z0.

Grammar for Transitions

1. **For transition d(q0, 0, Z0) = (q0, XZ0):**

When the PDA reads 0, the stack symbol Z0 is replaced by XZ0. This can be
represented in the CFG as:
A_q0q0 → 0A_q0q0

2. **For transition d(q0, 0, X) = (q0, XX):**

When the PDA reads 0 with X on the stack, it replaces X with XX. This translates to:
A_q0q0 → 0A_q0q0A_q0q0

3. **For transition d(q0, 1, X) = (q1, ε):**

When the PDA reads 1 and pops X from the stack, this can be written as:
A_q0q1 → 1A_q0q1

4. **For transition d(q1, 1, X) = (q1, ε):**

This transition can be written as:
A_q1q1 → 1A_q1q1

5. **For transition d(q1, ε, X) = (q1, ε):**

This corresponds to the stack symbol being popped without reading input:
A_q1q1 → ε
6. **For transition d(q1, ε, Z0) = (q1, ε):**
This is the acceptance transition, represented as:
A_q1q1 → ε

Final CFG Rules

The final CFG that corresponds to the given PDA transitions is:
1. A_q0q1 → 0A_q0q0 | 1A_q0q1
2. A_q0q0 → 0A_q0q0A_q0q0
3. A_q1q1 → 1A_q1q1 | ε

12) Illustrate with an example.Is NPDA (Nondeterministic PDA) and DPDA

(Deterministic PDA) equivalent?

Example: Consider the language L = { a^n b^n | n ≥ 1 }.

A DPDA can handle this by pushing 'a's onto the stack and then popping for each 'b'.
However, for a language like L = { a^n b^m | n ≠ m }, a DPDA fails while an NPDA
can process the non-deterministic case.
Thus, NPDAs are strictly more powerful than DPDAs as they can recognize all
context-free languages, while DPDAs can only recognize a subset.

13) Construct push down automata (PDA) for a^nb^n where n>=1.

A PDA for the language L = { a^n b^n | n ≥ 1 } works by pushing each 'a' onto the
stack and then popping for each 'b'. When the stack is empty and the input is fully
consumed, the string is accepted.

Transitions:

1. d(q0, a, Z0) = (q0, aZ0)

2. d(q0, a, a) = (q0, aa)

3. d(q0, b, a) = (q1, ε)

4. d(q1, b, a) = (q1, ε)

5. d(q1, ε, Z0) = (qf, ε)

14) Design a PDA for accepting a language {a^nb^2n | n>=1}.

For the language L = { a^n b^2n | n ≥ 1 }, the PDA pushes 'a' onto the stack and
expects two 'b's for each 'a'. The transitions handle two 'b's for each pop of 'a'.
Transitions:

1. d(q0, a, Z0) = (q0, aZ0)

2. d(q0, a, a) = (q0, aa)

3. d(q0, b, a) = (q1, ε)

4. d(q1, b, a) = (q1, ε)

5. d(q1, b, Z0) = (qf, ε)

15) How"Recursive Innumerable Language" is different from "Recursive Language"

A **Recursive Language** is a language where there exists a Turing machine that

halts for every input and correctly decides if the input belongs to the language.
A **Recursively Enumerable Language (REL)** is a language where a Turing
machine can enumerate the strings in the language. It may not halt on strings that are
not part of the language.
Key differences:
- **Recursive Languages** are decidable, meaning there is a guaranteed halting
decision process.
- **RELs** are semi-decidable, meaning the machine might run indefinitely on
inputs not in the language.

16) Explain the working of Turing machine with an appropriate diagram.

Turing Machine was invented by Alan Turing in 1936 and it is used to accept
Recursive Enumerable Languages (generated by Type-0 Grammar).

In the context of automata theory and the theory of computation, Turing machines are
used to study the properties of algorithms and to determine what problems can and
cannot be solved by computers. They provide a way to model the behavior of
algorithms and to analyze their computational complexity, which is the amount of
time and memory they require to solve a problem.

A Turing machine is a finite automaton that can read, write, and erase symbols on an
infinitely long tape. The tape is divided into squares, and each square contains a
symbol. The Turing machine can only read one symbol at a time, and it uses a set of
rules (the transition function) to determine its next action based on the current state
and the symbol it is reading.

The Turing machine’s behavior is determined by a finite state machine, which

consists of a finite set of states, a transition function that defines the actions to be
taken based on the current state and the symbol being read, and a set of start and
accept states. The Turing machine begins in the start state and performs the actions
specified by the transition function until it reaches an accept or reject state. If it
reaches an accept state, the computation is considered successful; if it reaches a reject
state, the computation is considered unsuccessful.
 Turing machines are an important tool for studying the limits of computation and for
understanding the foundations of computer science. They provide a simple yet
powerful model of computation that has been widely used in research and has had a
profound impact on our understanding of algorithms and computation.

A turing machine consists of a tape of infinite length on which read and writes
operation can be performed. The tape consists of infinite cells on which each cell
either contains input symbol or a special symbol called blank. It also consists of a
head pointer which points to cell currently being read and it can move in both
directions.

Figure: Turing Machine

A TM is expressed as a 7-tuple (Q, T, B, ∑, δ, q0, F) where:

 Q is a finite set of states

 T is the tape alphabet (symbols which can be written on Tape)

 B is blank symbol (every cell is filled with B except input alphabet initially)

 ∑ is the input alphabet (symbols which are part of input alphabet)

 δ is a transition function which maps Q × T → Q × T × {L,R}. Depending on its

present state and present tape alphabet (pointed by head pointer), it will move to new
state, change the tape symbol (may or may not) and move head pointer to either left or
right.

 q0 is the initial state

 F is the set of final states. If any state of F is reached, input string is accepted.

17) Show that if a language is accepted by a multitape turing machine ,it is accepted
by a single-tape TM.

Example: Prove take one language example on your own

1. Multitape Turing Machine to Single-tape Turing Machine

A multitape Turing machine can be simulated by a single-tape Turing machine. If a

language is accepted by a multitape Turing machine, it can also be accepted by a
 single-tape Turing machine. The basic idea is that a single-tape Turing machine can
simulate multiple tapes by combining the content of all tapes on one tape. We use
delimiters to separate the contents of different tapes and keep track of the positions of
each tape head. Although the simulation may take more time, the single-tape Turing
machine can still perform the same computation.

The proof involves constructing a single-tape Turing machine that simulates the
behavior of the multitape Turing machine. Here are the main steps:

Step 1: Representation of Tapes

 Let MMM be a multitape Turing machine with kkk tapes.

 Each tape of MMM contains symbols from a finite alphabet, and the contents of the
tapes can be represented as follows:

Tape 1: x1x2x3…Tape 2: y1y2y3……Tape k: z1z2z3…

 In the single-tape Turing machine, we can combine all the tapes into a single tape.
The single tape will use a special delimiter (e.g., a special symbol such as #) to
separate the contents of each tape. The configuration of the single tape will look like
this:

x1x2x3…#y1y2y3…#…#z1z2z3

Step 2: Simulating the Multitape TM

 The single-tape TM needs to simulate the transitions of the multitape TM. For this, we
will keep track of the head positions of all kkk tapes.
 When the multitape TM moves one of its heads, the single-tape TM must adjust the
position of the head accordingly. Here’s how we can do that:

1. Initialization: The single-tape TM starts with its head at the leftmost symbol of the
first tape.
2. Reading Symbols: To read the symbols from each tape:
o The single-tape TM can first move to the delimiter #, reading the symbols
from the first tape until it reaches the first delimiter.
o Then, it moves to the next delimiter to read symbols from the second tape, and
so on.
3. Simulating Head Movements:
o The single-tape TM simulates the movements of the multitape TM’s heads. If
the multitape TM moves one of its heads left or right, the single-tape TM must
navigate through the entire tape to reach the relevant symbol.
o For example, if the first head of the multitape TM moves right, the single-tape
TM will:
 Read the current configuration,
 Move to the right (to the next symbol),
 Write if necessary, and then
 Go back to the position to continue processing.
4. Transition Function:
o The transition function of the multitape TM is defined as
δ(q,a1,a2,…,ak)→(p,b1,b2,…,bk,d1,d2,…,dk)
o The single-tape TM will mimic this by simulating each head movement and
performing the required actions according to the transition function, while
keeping track of the delimiters.

Step 3: Acceptance Condition

 If the multitape TM enters an accepting state, the single-tape TM will also enter a
corresponding accepting state. The single-tape TM will halt and accept the input if the
multitape TM accepts.

18) Explain Halting Problem in Turing Machine

The Halting Problem is the problem of determining, given a description of a Turing

machine and an input, whether the Turing machine will eventually halt (terminate) or
continue running forever. Alan Turing proved that this problem is undecidable,
meaning that no Turing machine can solve the halting problem for all possible inputs.
The proof uses a diagonalization argument and shows that if such a machine existed,
it would lead to a logical contradiction.

19) Draw a Turing machine which subtract two numbers m and n, where m is greater
than n.

subtract two numbers. Example:

Steps:

 Step-1. If 0 found convert 0 into X and go right then convert all 0’s into 0’s and go
right.
 Step-2. Then convert C into C and go right then convert all X into X and go right.
 Step-3. Then convert 0 into X and go left then convert all X into X and go left.
 Step-4. Then convert C into C and go left then convert all 0’s into 0’s and go left then
convert all X into X and go right and repeat the whole process.
 Step-5. Otherwise if C found convert C into C and go right then convert all X into B
and go right then convert 0 into 0 and go left and then stop the machine.
 Here, q0 shows the initial state and q1, q2, q3, q4, q5are the transition states
and q6shows the final state. And X, 0, C are the variables used for subtraction and R,
L shows right and left. Problem-2: Draw a Turing machine which subtract two
numbers m and n, where m is greater than n.

Steps:

 Step-1. If 0 found convert all 0’s into 0’s and go right then convert C into C and go
right
 Step-2. If X found then convert all X into X and go right or if 0 found then convert 0
into X and go left and go to next step otherwise go to 5th step
 Step-3. Then convert all X into X and go left then convert C into C and go left
 Step-4. Then convert all 0’s into 0’s and go left then convert B into B and go right
then convert 0 into B and go right and repeat the whole process
 Step-5. Otherwise if B found convert B into B and go left then convert all X into B
and go left then convert C into B and go left and then stop the machine.
 Here, q0 shows the initial state and q1, q2, q3, q4, q5are the transition states
and q6shows the final state. And B, X, 0, C are the variables used for
subtraction(m>n) and R, L shows right and left and B variable is a input symbol.

20) Construct a Turing Machine for language L = {0^n1^n2^n | n≥1}

To construct a Turing machine for the language L={0n1n2n∣n≥1}L = \{0^n 1^n 2^n
L={0n1n2n∣n≥1}, we need a machine that processes inputs with equal numbers of
000's, 111's, and 222's in that order. The idea is to successively match one 0 with one
1 and one 2 until the entire string is processed.

Here is the process breakdown:

Steps:

1. Mark a 000:
o Move right and find the first 0, mark it by changing it to X to indicate that it
has been processed.
2. Find the corresponding 111:
o After marking the 0, move to the right until the first 1 is found and mark it by
changing it to Y
3. Find the corresponding 222:
o After marking the 1, continue moving right until the first 2 is found and mark
it by changing it to Z.
4. Return to the beginning:
o After marking a 0, 1, and 2, move left to the beginning of the string, and repeat
the process until all symbols are marked.
5. Check for completion:
 o When all 0's, 1's, and 2's are marked, check if the tape only contains X's, Y's,
and Z's. If so, accept the input; otherwise, reject it.

Formal Turing Machine Description:

The Turing machine operates in several states to handle marking, checking, and
returning to the start.

1. Initial state (q0):

o Read the first 0, replace it with X, and move right to find the first 1 (go to state
q1).
2. State q1:
o Scan for the first 1, replace it with Y, and move right to find the first 2 (go to
state q2).
3. State q2:
o Scan for the first 2, replace it with Z, and move left back to the start of the
string (go to state q3).
4. State q3:
o Move left until the first X is encountered, then move right to find the next 0
(go back to q0).
5. Final state (accepting state):
o If the tape contains only X, Y, and Z without any remaining 0's, 1's, or 2's, the
machine accepts the input.

22) Explain with diagram 1) the classes of P and NP 2) Reducability

P Class

The P in the P class stands for Polynomial Time. It is the collection of decision
problems(problems with a “yes” or “no” answer) that can be solved by a deterministic
machine in polynomial time.

Features:

 The solution to P problems is easy to find.

 P is often a class of computational problems that are solvable and tractable. Tractable
means that the problems can be solved in theory as well as in practice. But the
problems that can be solved in theory but not in practice are known as intractable.

NP Class

The NP in NP class stands for Non-deterministic Polynomial Time. It is the

collection of decision problems that can be solved by a non-deterministic machine in
polynomial time.

Features:

 The solutions of the NP class are hard to find since they are being solved by a non-
deterministic machine but the solutions are easy to verify.
 Problems of NP can be verified by a Turing machine in polynomial time.

Reducibility and Undecidability

Language A is reducible to language B (represented as A?B) if there exists a function
f which will convert strings in A to strings in B as:

w ? A <=> f(w) ? B

Theorem 1: If A?B and B is decidable then A is also decidable.

Theorem 2: If A?B and A is undecidable then B is also undecidable.

23) Explain NP hard and NP completeness problem with diagram.

An NP-hard problem is at least as hard as the hardest problem in NP and it is a class

of problems such that every problem in NP reduces to NP-hard.

Features:

 All NP-hard problems are not in NP.

 It takes a long time to check them. This means if a solution for an NP-hard problem is
given then it takes a long time to check whether it is right or not.

 A problem A is in NP-hard if, for every problem L in NP, there exists a polynomial-
time reduction from L to A.

A problem is NP-complete if it is both NP and NP-hard. NP-complete problems are

the hard problems in NP.

Features:

 NP-complete problems are special as any problem in NP class can be transformed or

reduced into NP-complete problems in polynomial time.
 If one could solve an NP-complete problem in polynomial time, then one could also
solve any NP problem in polynomial time.

24) Explain 'Node Cover Decision Problem' with an appropriate example.

Node Cover Decision Problem

The Node Cover Decision Problem is a decision problem associated with graph
theory. It asks whether a given undirected graph contains a set of nodes (vertices)
such that every edge in the graph is incident to at least one of the nodes in the set.
This set of nodes is called a node cover.

Formally, the problem can be defined as follows:

 Input: An undirected graph G=(V,E) and an integer k.

 Output: Is there a subset V′⊆V such that:
o ∣V′∣≤k (the size of the subset is at most kkk)
o Every edge (u,v)∈E has at least one of its endpoints in V′?

 Vertices (V): {1, 2, 3}

 Edges (E): {(1, 2), (1, 3), (2, 3)}

Problem Instance

Let's say we want to find a node cover of size k=2k = 2k=2.

Solution

To determine if there is a node cover of size 2, we can evaluate possible subsets of

vertices:

1. Subset {1, 2}:

o Covers edges (1, 2) and (1, 3) but does not cover edge (2, 3).
o Not a valid cover.
2. Subset {1, 3}:
o Covers edges (1, 2) and (1, 3) but does not cover edge (2, 3).
o Not a valid cover.
3. Subset {2, 3}:
o Covers edges (1, 2) and (2, 3) but does not cover edge (1, 3).
o Not a valid cover.
4. Subset {1, 2, 3}:
o Covers all edges: (1, 2), (1, 3), and (2, 3).
o However, this exceeds our limit of k=2 k = 2k=2.

Since we cannot find any subset of size 2 that covers all edges, we conclude that
there is no node cover of size 2 for this graph.

Complexity
The Node Cover Decision Problem is known to be NP-complete. This means that
while it is easy to verify a given solution (i.e., checking if a specific set of nodes
covers all edges), finding the optimal solution (the smallest node cover) is
computationally challenging.

26) Obtain the solution for the following system of posts correspondence problem, X
= {100, 0, 1}, Y = {1, 100, 00}.

Given the sets:

X = {100, 0, 1}
Y = {1, 100, 00},
we need to find a sequence of indices (i1, i2, …, in) such that:
concat(X[i1], X[i2], …, X[in]) = concat(Y[i1], Y[i2], …, Y[in]),
where concat(a1, a2, …, an) means concatenating the strings.

Approach to Find a Solution

To solve this, we can try to find combinations of the strings from X and Y to see if
any concatenation results in the same string.

Steps

1. Try Using Pair Indices: We'll generate all possible combinations of indices for the
pairs in X and Y.

2. Check the Concatenation: For each sequence of indices, concatenate the

corresponding elements from X and Y and check if they are equal.

Exploring Combinations

Using (0, 1):

From X: 0 and 1
From Y: 100 and 1
Concatenation: concat(0,1)=01 and concat(100,1)=1001
Not equal.

Using (100, 0):

From X: 100 and 0
From Y: 1 and 100
Concatenation: concat(100,0)=1000 and concat(1,100)=1100
Not equal.

Using (1, 100):

From X: 1 and 100
From Y: 100 and 1
Concatenation: concat(1,100)=1100 and concat(100,1)=1001
Not equal.

Using (0, 100, 1):

From X: 0, 100, 1
From Y: 1, 100, 00
Concatenation: concat(0,100,1)=0100 and concat(1,100,00)=11000
Not equal.

27) Find whether the lists 1)M = (abb, aa, aaa) and N = (bba, aaa, aa) 2) M = (ab, bab,
bbaaa) and N = (a, ba, bab) have a Post Correspondence Solution

. M = (abb, aa, aaa) and N = (bba, aaa, aa)

We need to find if there exists a sequence of indices i1, i2, ... such that the
corresponding concatenations from both lists are equal.

Try Different Indices:

- Try index 1 for both lists:

m1 = 'abb', n1 = 'bba'.
Concatenation: m1 = 'abb', n1 = 'bba'.
Since 'abb' ≠ 'bba', we continue trying.

- Try index 2 for both lists:

m2 = 'aa', n2 = 'aaa'.
Concatenation: m2 = 'aa', n2 = 'aaa'.
Since 'aa' ≠ 'aaa', this also fails.

- Try index 3 for both lists:

m3 = 'aaa', n3 = 'aa'.
Concatenation: m3 = 'aaa', n3 = 'aa'.
Since 'aaa' ≠ 'aa', this fails as well.

There is no Post Correspondence Solution for this pair.

2. M = (ab, bab, bbaaa) and N = (a, ba, bab)

We need to find if there is a sequence of indices such that the concatenations from M
and N are equal.

Try Different Indices:

- Try index 1 for both lists:

m1 = 'ab', n1 = 'a'.
Concatenation: m1 = 'ab', n1 = 'a'.
Since 'ab' ≠ 'a', continue trying.

- Try index 2 for both lists:

m2 = 'bab', n2 = 'ba'.
 Concatenation: m2 = 'bab', n2 = 'ba'.
Since 'bab' ≠ 'ba', continue trying.

- Try index 3 for both lists:

m3 = 'bbaaa', n3 = 'bab'.
Concatenation: m3 = 'bbaaa', n3 = 'bab'.
Since 'bbaaa' ≠ 'bab', this also fails.

There is no Post Correspondence Solution for this pair.