PDF (2023)

Q.1 (Answer any three from the following):

1. List different types of Finite State Machines of Regular Language. (4
marks)

There are three main types of finite state machines (FSM) that are used to describe regular
languages:

 Deterministic Finite Automaton (DFA): Every state has exactly one transition for
each possible input symbol.
 Non-deterministic Finite Automaton (NFA): A state can have zero, one, or more
transitions for a single input symbol, allowing multiple possible states after reading
the same symbol.
 ε-NFA (NFA with ε-moves): This type of NFA allows transitions that occur without
consuming any input symbol, called ε (epsilon) transitions.
 Moore and Mealy Machines: While not directly related to regular languages, they
are FSMs that produce outputs. Moore machines associate outputs with states, while
Mealy machines associate outputs with transitions.

2. Differentiate between DFA, NFA, and ε-NFA. (4 marks)

Feature DFA NFA ε-NFA

Determinism Fully deterministic Non-deterministic Non-deterministic,
(one transition per (multiple transitions with ε (epsilon)
input). possible). transitions.
Transitions Only one transition Can have multiple or Can include ε-
for each input symbol. no transitions for a transitions (consume
symbol. no input).
Empty String Not allowed. Not allowed. Allowed (can move
(ε) Transitions between states
without input).
State Space Larger, as every Typically smaller, Typically smaller due
possibility must be due to fewer explicit to ε-transitions.
explicitly defined. transitions.
Equivalence DFA and NFA are NFA and DFA Can be converted to
equivalent in power. recognize the same an equivalent DFA.
set of languages.
3. Create a DFA for L={x∈{0,1}∗∣0110 is a substring of x}. (4 marks)
4. Construct a NFA that accepts the set of all strings that end with 1. (4
marks)

5. Explain the steps in conversion from NFA to DFA with the help of an
example. (4 marks)

Steps in converting NFA to DFA:

1. Start from the NFA's start state and create a corresponding DFA start state, which
is a set containing the NFA's start state.
2. Explore transitions for each symbol from the set of states (subset) in the current
DFA state.
3. For each transition, compute the set of NFA states that can be reached for the
given input symbol. This becomes a new state in the DFA.
4. Repeat the process for each newly created state until all possible states and
transitions are exhausted.
5. Mark DFA states as accepting if any of their component NFA states are accepting.
Q.2 (Answer any three from the following):
1. List and explain any 4 identities of Regular Expressions. (4 marks)

The following are four identities of Regular Expressions:

∅+R=R\varnothing + R = R∅+R=R
1. Identity 1:

This means that adding the empty set to any regular expression RRR results in RRR.
The empty set does not contribute anything to the language.
2. Identity 2:
ϵR=Rϵ=R\epsilon R = R\epsilon = RϵR=Rϵ=R
This means that concatenating the regular expression RRR with the empty string ϵ\
epsilonϵ does not change the regular expression. The empty string is neutral in
concatenation.
3. Identity 3:
R+R=RR + R = RR+R=R
This means that the union of a regular expression RRR with itself results in the same
regular expression. Duplicate unions are redundant.
4. Identity 4:
(R∗)∗=R∗(R^*)^* = R^*(R∗)∗=R∗
This means that applying closure twice to a regular expression RRR is equivalent to
applying it once. Repeated closure operations are redundant.

2. Write a Regular Expression for a language accepting all strings starting

with ‘a’ but not having consecutive 'b'. (4 marks)

The regular expression for a language that accepts all strings starting with ‘a’ but not having
consecutive 'b' is:

R=a(a+ab)∗R = a(a + ab)^*R=a(a+ab)∗

Explanation:

 The string must start with ‘a’.

 After the first ‘a’, the string can be followed by any number of 'a's or 'ab' pairs.
 This ensures there are no consecutive 'b's.

3. What is the minimization of DFA? Explain different methods of

minimization. (4 marks)

Minimization of DFA refers to the process of reducing the number of states in a DFA
without changing the language it accepts. The minimized DFA is the simplest form of the
given DFA, and it helps to optimize performance and memory usage.
There are two main methods for DFA minimization:

1. Partition Method:
o Step 1: Group states into sets based on their acceptance (final and non-final
states).
o Step 2: Repeatedly refine these sets based on input transitions until no further
refinement is possible.
o Step 3: Merge equivalent states and create the minimized DFA.
2. Table Filling Method (Myhill-Nerode Method):
o Step 1: Create a table of all pairs of states.
o Step 2: Mark pairs that are distinguishable (e.g., one is final, the other is non-
final).
o Step 3: Continue marking pairs based on transitions and repeat until no new
pairs can be marked.
o Step 4: Merge unmarked pairs into a single state and construct the minimized
DFA.

4. Derive 4 strings from the given Grammar

Given Grammar: G1=({S,A},{a,b},S→aAb,aA→aaAb,A→ϵ)G_1 = (\{ S, A \}, \{ a, b \}, S \

to aAb, aA \to aaAb, A \to \epsilon)G1=({S,A},{a,b},S→aAb,aA→aaAb,A→ϵ)

The 4 derivable strings are:

1. S→aAb→abS \to aAb \to abS→aAb→ab

(By applying A→ϵA \to \epsilonA→ϵ)
2. S→aAb→aaAbb→aabbS \to aAb \to aaAbb \to aabbS→aAb→aaAbb→aabb
(By applying aA→aaAbaA \to aaAbaA→aaAb, followed by A→ϵA \to \epsilonA→ϵ)
3. S→aAb→aaAbb→aaaAbbb→aaabbbS \to aAb \to aaAbb \to aaaAbbb \to
aaabbbS→aAb→aaAbb→aaaAbbb→aaabbb
(By applying aA→aaAbaA \to aaAbaA→aaAb twice, followed by A→ϵA \to \
epsilonA→ϵ)
4. S→aAb→aaAbb→aaaAbbb→aaaaAbbbb→aaabbbbS \to aAb \to aaAbb \to
aaaAbbb \to aaaaAbbbb \to
aaabbbbS→aAb→aaAbb→aaaAbbb→aaaaAbbbb→aaabbbb
(By applying aA→aaAbaA \to aaAbaA→aaAb thrice, followed by A→ϵA \to \
epsilonA→ϵ)

5. Write a short note on Regular Grammar. (4 marks)

A Regular Grammar is a formal grammar that generates regular languages. Regular

grammars can be classified into two types:

1. Right Linear Grammar:

In this grammar, all production rules have the form:
 o A→xBA \to xBA→xB or A→xA \to xA→x, where A,BA, BA,B are non-
terminal symbols and xxx is a terminal symbol.
o Example: A→aBA \to aBA→aB, B→bB \to bB→b.
2. Left Linear Grammar:
In this grammar, all production rules have the form:
o A→BxA \to BxA→Bx or A→xA \to xA→x, where A,BA, BA,B are non-
terminal symbols and xxx is a terminal symbol.
o Example: A→BaA \to BaA→Ba, B→bB \to bB→b.

Regular grammars are equivalent to Finite State Automata (FSA), which means any
language generated by a regular grammar can also be accepted by an FSA.

Q.3 (Answer any three from the following):

1. Left Derivation Tree for the Given Production Rule

Grammar Rules:
css
Copy code
S → aAS | aS | SSS
A → SbA | ba

We need to construct a left derivation tree for a string generated by these rules.

Let's take the string aab. One possible derivation using the production rules is:

1. Start with S.
2. Apply S → aS to get aS.
3. Apply S → aAS to get aaAS.
4. Apply A → ba to get aabaS.
5. Apply S → ε (assuming implicit ε-rule) to get aab.

Derivation Tree:
css
Copy code
S
/ | \
a S S
| \
a A
/ \
S b
\
a

2. Notes on CFG Reduction and Removal of Null Production

Reduction of CFG:

CFG (Context-Free Grammar) reduction involves simplifying the grammar while keeping the
language generated unchanged. The steps include:

 Removing Useless Symbols: Non-terminal symbols that do not lead to terminal symbols
should be removed.
 Removing Unit Productions: Productions where a non-terminal produces only another non-
terminal should be removed (e.g., A → B).
 Eliminating Null Productions: Productions that produce an empty string (ε) should be
removed.

Example:
For a grammar S → aS | ε, we can remove ε by adjusting the productions as S → aS | a.

Removal of Null Production:

Null productions are rules of the form A → ε. To eliminate them, the grammar is modified to
ensure that no rule produces an empty string directly, except possibly the start symbol.

Steps:

1. Identify all nullable variables (variables that can eventually produce ε).
2. Modify the productions to include alternatives without nullable variables.

Example:
For S → AB | ε and A → ε | a, both S and A are nullable. The modified grammar would be
S → AB | B | A | ε and A → a.

3. Removing Unit Production from the Given Grammar

Given Grammar:
css
Copy code
S → XY
X → a
Y → Zb
Z → M
M → N
N → a
Step-by-Step Process:

1. Identifying Unit Productions:

The unit productions are Z → M, M → N, and N → a.
2. Substitute Non-terminals:
We replace the unit productions with direct terminal productions:
o Z → a (since M → N and N → a).

3. Modified Grammar:
 css
Copy code
S → XY
X → a
Y → Zb
Z → a

4. Steps to Convert CFG to Chomsky Normal Form (CNF)

Chomsky Normal Form requires each production to be in one of the following forms:

 A → BC (where both B and C are non-terminals).

 A → a (where a is a terminal).
 S → ε (only allowed for the start symbol if necessary).

Steps:

1. Eliminate Null Productions: Remove productions that generate the empty string (except
possibly for the start symbol).
2. Eliminate Unit Productions: Remove productions of the form A → B.
3. Eliminate Useless Symbols: Ensure every non-terminal contributes to generating a terminal
string.
4. Convert to Binary Productions: Ensure that every production has either two non-terminal
symbols on the right-hand side or one terminal.

Example: For the grammar S → aA | AB, convert it to:

css
Copy code
S → aA | AB
A → a
B → b

5. Construct a PDA for L = { a^n b^n | n > 0 }

A PDA (Pushdown Automaton) for the language { a^n b^n | n > 0 } can be designed as
follows:

 States: We need three states: q0 (initial), q1 (push phase), q2 (pop phase).

 Stack Operations: Push a onto the stack for each a in the input. For each b, pop a from the
stack. If the stack is empty when all input is consumed, accept the string.

PDA Description:

1. Start at state q0.

2. For each a, move to state q1 and push a onto the stack.
3. Once a b is encountered, switch to state q2 and start popping as from the stack.
4. Accept if all as are matched with bs and the stack is empty.
Transitions:

 (q0, a, ε) → (q1, A) (push A for each a).

 (q1, a, ε) → (q1, A) (stay in q1 and keep pushing A for each a).
 (q1, b, A) → (q2, ε) (pop A for each b).
 (q2, b, A) → (q2, ε) (stay in q2 and pop for each b).

Q.4 (Answer any three from the following):

1. Representation of a Turing Machine (4 marks):

A Turing Machine (TM) is represented as a formal mathematical model with a set of

components:

1. Q: The set of all states the machine can be in.

2. Σ: The input alphabet, which is the set of symbols the machine can read from the tape.
3. Γ: The tape alphabet, which includes all possible symbols the machine can write on the tape
(Σ is a subset of Γ).
4. δ: The transition function, which tells the machine what to do based on the current state
and the symbol it's reading (it tells what the next state will be, what symbol to write, and in
which direction to move the tape head).
5. q₀: The starting state, where the machine begins.
6. q_accept: The accepting state, which means the input is accepted when the machine
reaches this state.
7. q_reject: The rejecting state, which means the input is rejected when the machine reaches
this state.

The tape is an infinite sequence of cells where each cell contains one symbol from Γ. The
tape head moves left or right, and the machine reads and writes symbols based on the rules in
the transition function.

2. Design a Turing Machine for the language 01110^1 1^10111 (4 marks):

The language consists of the specific string "0111010111". To design a Turing Machine for
this string, the machine will:

1. Start in the initial state and begin reading the input.

2. The machine reads and moves through the tape, making sure it sees exactly "01110".
3. After confirming "01110", it checks that the next part of the input matches "10111".
4. If the machine matches the entire string, it moves to the accepting state.
5. If the input doesn't match, it moves to the rejecting state.

The transition function will be designed so the machine:

 Reads '0', moves right.

 Reads '1', moves right, and checks if the sequence follows as expected.
 Continues this until the entire string is checked.
3. Short Note on Linear Bounded Automata (LBA) (4 marks):

A Linear Bounded Automaton (LBA) is a special type of Turing Machine that has limited
space to work with. Unlike a regular Turing Machine, which has an infinite tape, an LBA's
tape is restricted to a length proportional to the size of the input. The key points are:

 An LBA has a tape that is only as long as the input, meaning it can only use a limited portion
of the tape.
 It is used to recognize context-sensitive languages, which are more complex than regular
and context-free languages.
 The LBA’s transition function behaves like a regular Turing Machine, but with the constraint
that the tape head can't move beyond the part of the tape used by the input.
 LBAs are useful for solving problems where memory is restricted to the size of the input.

4. Short Note on Universal Turing Machine (UTM) (4 marks):

A Universal Turing Machine (UTM) is a special kind of Turing Machine that can simulate
any other Turing Machine. It is a general-purpose machine that can perform any computation
that any other Turing Machine can do. Key features include:

 It takes as input the description of another Turing Machine along with the input for that
machine.
 The UTM then mimics the behavior of the described machine, running its program on the
given input.
 This idea is foundational to modern computers, which are essentially universal machines
that can run any program or algorithm.
 Alan Turing introduced the concept to show that a single machine can compute anything
that can be described algorithmically.

5. Halting Problem of Turing Machine (4 marks):

The Halting Problem is one of the most famous problems in computer science, introduced
by Alan Turing. It asks whether it's possible to write a program (or build a machine) that can
tell if any given Turing Machine will eventually stop (halt) or run forever for a particular
input. Here's what makes it important:

 Undecidability: Turing proved that there is no general algorithm that can solve the Halting
Problem for all possible Turing Machines and inputs. This means it’s undecidable.
 If a solution to the Halting Problem existed, we could determine for any algorithm whether it
will finish in a finite amount of time or keep running forever.
 This problem has deep implications, showing the limits of what machines (and computers)
can do.
 The proof uses a technique called diagonalization, where Turing showed that if a machine
that solves the Halting Problem existed, it would lead to a logical contradiction.

Q5) Answer the following

1. What is a Turing Machine? Explain it with its tuples. (3 marks)

A Turing Machine (TM) is a mathematical model of computation that describes an abstract
machine capable of performing computation by manipulating symbols on an infinite tape. It
consists of the following components, represented as a 7-tuple:

 Q: A finite set of states.

 X: The tape alphabet, which includes all symbols that can be written on the tape.
 Σ: The input alphabet, which is a subset of X that does not include the blank symbol.
 δ: The transition function, defined as δ:Q×X→Q×X×{Left_shift,Right_shift}δ: Q × X → Q × X
× \{ \text{Left\_shift}, \text{Right\_shift} \}δ:Q×X→Q×X×{Left_shift,Right_shift}, which
specifies how the machine moves from one state to another based on the current state and
the symbol being read from the tape.
 q0: The initial state, which is the state in which the machine starts.
 B: The blank symbol, which is used to represent empty cells on the tape.
 F: The set of final states, which determines when the machine halts and accepts or rejects
the input.

2. Write a short note on different types of languages. (3 marks)

In formal language theory, languages can be classified into different types based on their
complexity and the grammars that generate them:

 Regular Languages: These are the simplest type of languages, generated by regular
grammars and recognized by finite automata. They can be represented using regular
expressions.
 Context-Free Languages (CFLs): These languages are generated by context-free
grammars (CFGs) and can be recognized by pushdown automata. They include
languages that can be described using nested structures, such as balanced parentheses.
 Context-Sensitive Languages (CSLs): These languages are more complex than
CFLs and are generated by context-sensitive grammars. They can be recognized by
linear-bounded automata and allow for a more extensive set of rules than CFLs.
 Recursively Enumerable Languages: These are the most complex languages and
can be generated by Turing machines. They include all languages that can be accepted
by a Turing machine, which may not necessarily halt for some inputs.

3. Write a short note on the ambiguity of grammar. (3 marks)

A grammar is considered ambiguous if there exists at least one string that can be generated
by the grammar in more than one way, leading to multiple distinct derivation trees or parse
trees. This means that for some strings, there are two or more different sequences of
production rules that can derive the same string.

For example, consider the grammar defined by the productions S→S+S ∣S∗S ∣a ∣bS → S +
S \ | S * S \ | a \ | bS→S+S ∣S∗S ∣a ∣b. The string a+a∗ba + a * ba+a∗b can be derived in
multiple ways, resulting in different parse trees, hence demonstrating that the grammar is
ambiguous.

Ambiguity in grammars is undesirable because it can lead to confusion in parsing and

interpretation. Ambiguous grammars can be converted into unambiguous grammars, though
this may not always be possible for all languages.
4. Describe a Multitape Turing Machine in detail. (3 marks)

A Multitape Turing Machine is an extension of the standard Turing machine that features
multiple tapes, each with its own read/write head. Each tape operates independently and can
be used to store additional information or intermediate results during computation.

Components of a Multitape Turing Machine:

 Multiple Tapes: The machine has kkk tapes, each capable of holding an infinite number of
symbols.
 Multiple Heads: Each tape has its own read/write head, which can read from and write to
the tape independently.
 State Transitions: The transition function now takes into account the symbols currently
being read from each tape. The transition function can be defined as
δ:Q×Xk→Q×Xk×{Left_shift,Right_shift}kδ: Q × X^k → Q × X^k × \{ \text{Left\_shift}, \
text{Right\_shift} \}^kδ:Q×Xk→Q×Xk×{Left_shift,Right_shift}k.

The multitape Turing machine can perform more complex computations more efficiently than
a single-tape Turing machine because it can manipulate multiple pieces of information
simultaneously. For example, it can simulate a finite automaton while using one tape for the
input string and others for intermediate results or states.

5. Explain the Intersection operation on Regular language. (3 marks)

The Intersection operation on regular languages involves finding a language that consists of
all strings that are common to two regular languages L1L_1L1 and L2L_2L2. If L1L_1L1
and L2L_2L2 are both regular languages, then their intersection L1∩L2L_1 ∩ L_2L1∩L2 is
also a regular language.

To construct a finite automaton that recognizes the intersection L1∩L2L_1 ∩ L_2L1∩L2:

1. Let M1=(Q1,Σ,δ1,q01,F1)M_1 = (Q_1, Σ, δ_1, q_{0_1}, F_1)M1=(Q1,Σ,δ1,q01,F1) be the finite

automaton for L1L_1L1.
2. Let M2=(Q2,Σ,δ2,q02,F2)M_2 = (Q_2, Σ, δ_2, q_{0_2}, F_2)M2=(Q2,Σ,δ2,q02,F2) be the finite
automaton for L2L_2L2.
3. Construct a new automaton M=(Q1×Q2,Σ,δ,(q01,q02),F)M = (Q_1 × Q_2, Σ, δ, (q_{0_1},
q_{0_2}), F)M=(Q1×Q2,Σ,δ,(q01,q02),F), where:
o Q=Q1×Q2Q = Q_1 × Q_2Q=Q1×Q2: The states are pairs of states from M1M_1M1
and M2M_2M2.
o δδδ: The transition function is defined such that
δ((q1,q2),a)=(δ1(q1,a),δ2(q2,a))δ((q_1, q_2), a) = (δ_1(q_1, a), δ_2(q_2, a))δ((q1,q2
),a)=(δ1(q1,a),δ2(q2,a)) for each input symbol aaa.
o F=F1×F2F = F_1 × F_2F=F1×F2: The accepting states are pairs where both
components are accepting states in their respective automata.

The resulting automaton MMM accepts a string if it leads both M1M_1M1 and M2M_2M2
to accept states, thus recognizing the intersection of the two languages.

6. Derive 3 strings from the given Grammar

G1 = {(S, A, B), {a, b}, S → AB, A → aA | a, B → bB | b}.

To derive strings from the grammar G1:

1. Deriving the string "ab":

o S→ABS → ABS→AB
o A→aA → aA→a
o B→bB → bB→b
o Thus, S→aB→abS → aB → abS→aB→ab.

2. Deriving the string "aaabbb":

o S→ABS → ABS→AB
o A→aA→aaA→aaaA → aA → aaA → aaaA→aA→aaA→aaa
o B→bB→bbB→bbbB → bB → bbB → bbbB→bB→bbB→bbb
o Thus, S→aaAB→aaabB→aaabbbS → aaAB → aaabB →
aaabbbS→aaAB→aaabB→aaabbb.

3. Deriving the string "aabb":

o S→ABS → ABS→AB
o A→aA→aaA → aA → aaA→aA→aa
o B→bB → bB→b
o Thus, S→aAB→aabB→aabbS → aAB → aabB → aabbS→aAB→aabB→aabb.

These derivations show how strings can be constructed from the grammar G1 based on the
given production rules.

PDF (2024)

Q1. Answer any four from the following:

i) Differentiate between Mealy and Moore machine.

1. Output Generation:
o Mealy Machine: The output is generated based on both the current state and
the input symbol.
o Moore Machine: The output is generated based on only the current state.
2. Timing of Output:
o Mealy Machine: The output can change as soon as the input changes,
meaning the output is more immediate.
o Moore Machine: The output is stable until the state changes, as it depends
solely on the state.
3. State Complexity:
o Mealy Machine: Typically requires fewer states because the input influences
the output directly.
 o Moore Machine: May require more states since the output is fixed for each
state.
4. Transition Representation:
o Mealy Machine: Transitions are labeled with both input and output
(input/output).
o Moore Machine: Transitions are labeled only with input, while states are
labeled with outputs.

ii) Explain Deterministic Finite State Automata with the help of an example.

Deterministic Finite State Automaton (DFA) is a 5-tuple (Q, Σ, δ, q₀, F), where:

 Q: A finite set of states.

 Σ: A finite set of input symbols (alphabet).
 δ: A transition function δ: Q × Σ → Q.
 q₀: The initial state.
 F: A set of final or accepting states.

A DFA accepts or rejects a string based on whether it ends in an accepting state after reading
the entire string.

Example: Consider a DFA that accepts binary strings that end with "01".

 Q = {q₀, q₁, q₂} (states)

 Σ = {0, 1} (alphabet)
 q₀ = starting state
 F = {q₂} (final state)
 δ:
o δ(q₀, 0) = q₁
o δ(q₀, 1) = q₀
o δ(q₁, 0) = q₁
o δ(q₁, 1) = q₂
o δ(q₂, 0) = q₁
o δ(q₂, 1) = q₀

iii) Define the following:

a. Symbol: A symbol is a single entity from an alphabet used to form strings. For example, '0'
and '1' are symbols in the binary alphabet.

b. Alphabet: An alphabet is a finite, non-empty set of symbols used to construct strings. For
example, Σ = {0, 1} is a binary alphabet.

c. String: A string is a finite sequence of symbols from an alphabet. For example, "0110" is a
string over the alphabet {0, 1}.

d. Language: A language is a set of strings formed from a given alphabet that satisfy specific
rules or constraints. For example, the language L = {x | x contains an even number of 0’s and
1’s} is defined over the alphabet {0, 1}.
iv) Create a DFA for L = {x ∈ {0,1}* | x has an even number of 0's and even
number of 1's}

 States: Q = {q₀, q₁, q₂, q₃}

 Alphabet: Σ = {0, 1}
 Transition Function: δ is defined as:
o δ(q₀, 0) = q₁, δ(q₀, 1) = q₂
o δ(q₁, 0) = q₀, δ(q₁, 1) = q₃
o δ(q₂, 0) = q₃, δ(q₂, 1) = q₀
o δ(q₃, 0) = q₂, δ(q₃, 1) = q₁
 Initial State: q₀
 Final State: q₀ (both even 0’s and even 1’s)

This DFA ensures that for every string, if the number of 0's and 1's is even, it will end in state
q₀.

v) Construct a Mealy machine for L = {x ∈ {a, b}* | x contains either 'aa' or

'bb'}

A Mealy machine will have transitions that output '1' when it detects the substring 'aa' or 'bb',
and output '0' otherwise.

States: q₀, q₁, q₂

 Transitions:
o From q₀, on 'a' → q₁, output '0'
o From q₁, on 'a' → q₂, output '1'
o From q₀, on 'b' → q₃, output '0'
o From q₃, on 'b' → q₂, output '1'
o For any other transition, the output will be '0'.

vi) Compare DFA and NDFA

Aspect DFA (Deterministic Finite NDFA (Nondeterministic Finite

Automaton) Automaton)
Determinism Exactly one transition for each Can have multiple possible transitions
input from each state. for an input from a state.
Transition Only one path can be followed Multiple paths may be followed, or no
for a specific input. path, for a given input.
Empty No empty (ε) transitions are Can have ε-transitions (transitions
Transitions allowed. without any input).
Complexity Simpler to implement and May be simpler in theory but requires
 analyze. conversion to DFA for
implementation.
Acceptance A string is accepted if there is a A string is accepted if at least one path
single path to an accepting leads to an accepting state.
state.

Q2. Answer any four from the following:

i) What is a regular expression? Explain with the help of an example.

A regular expression is a sequence of characters that defines a search pattern, primarily used
for string matching within texts. Regular expressions are utilized in various programming
languages and tools for tasks like searching, replacing, and validating strings.

Example:
Consider the regular expression a(b|c)*d. This expression can be explained as follows:

 a indicates that the string must start with the character 'a'.
 (b|c)* means that any number (including zero) of 'b's or 'c's can appear in the
middle.
 d indicates that the string must end with the character 'd'.

Valid Strings:

 ad
 abd
 acd
 abbd
 aabbcd

ii) Explain the concept of regular expression with the help of an example.

A regular expression provides a concise and flexible way to match patterns in strings. It
consists of literals, operators, and special characters that together represent a search pattern.

Example:
Take the regular expression x?y*. This can be interpreted as follows:

 x? means that the character 'x' may appear either once or not at all (0 or 1 times).
 y* means that the character 'y' can appear zero or more times.

Valid Strings:

 y (no 'x', multiple 'y')

 xy (one 'x', one 'y')
 xyyy (one 'x', three 'y's)
 x (only 'x', zero 'y')
Invalid Strings:

 xxy (two 'x's)

 yyx (incorrect order)

This demonstrates how regular expressions can specify complex string patterns in a compact
form.

iii) Derive 5 strings from the given grammar

Grammar: G1=({S,A},{a,b},S,{S→aAAb,aA→aaAb,A→ϵ})G_1 = (\{ S, A \}, \{ a, b \},

S, \{ S \to aAAb, aA \to aaAb, A \to \epsilon \})G1=({S,A},{a,b},S,
{S→aAAb,aA→aaAb,A→ϵ})

Using the production rules, we can derive five strings:

1. Derivation 1:

S→aAAb→aϵAb→abS \to aAAb \to a \epsilon Ab \to abS→aAAb→aϵAb→ab

Result: ab

2. Derivation 2:

S→aAAb→aAAb→a(aaAb)b→aaAb→aaϵb→aabS \to aAAb \to aA Ab \to a (aaAb)b

\to aaAb \to aa \epsilon b \to aabS→aAAb→aAAb→a(aaAb)b→aaAb→aaϵb→aab

Result: aab

3. Derivation 3:

S→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaaAb→aaaϵb→aaabS \to aAAb \to aA

Ab \to a(aaAb)b \to aa(aaAb)b \to aaaAb \to aaa \epsilon b \to
aaabS→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaaAb→aaaϵb→aaab

Result: aaab

4. Derivation 4:

S→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaa(aaAb)b→aaaaAb→aaaaϵb→aaabS \
to aAAb \to aA Ab \to a(aaAb)b \to aa(aaAb)b \to aaa(aaAb)b \to aaaaAb \to aaaa \
epsilon b \to
aaabS→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaa(aaAb)b→aaaaAb→aaaaϵb→aa
ab

Result: aaaab

5. Derivation 5:
 S→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaa(aaAb)b→aaaa(aaAb)b→aaaaaAb→
aaaaaϵb→aaaaabS \to aAAb \to aA Ab \to a(aaAb)b \to aa(aaAb)b \to aaa(aaAb)b \to
aaaa(aaAb)b \to aaaaaAb \to aaaaa \epsilon b \to
aaaaabS→aAAb→aAAb→a(aaAb)b→aa(aaAb)b→aaa(aaAb)b→aaaa(aaAb)b→aaaa
aAb→aaaaaϵb→aaaaab

Result: aaaaab

The derived strings are ab, aab, aaab, aaaab, and aaaaab.

iv) Write a note on left and right linear grammar.

Linear Grammar is a type of context-free grammar in which every production rule has at
most one non-terminal symbol on the right side.

1. Right Linear Grammar:

o In this grammar, all production rules take the form:
 A→xBA \to xBA→xB or A→xA \to xA→x
o Here, AAA and BBB are non-terminal symbols, and xxx is a terminal symbol.
o Example:
 Rules: S→aAS \to aAS→aA and A→bA \to bA→b can generate
strings like ab.
2. Left Linear Grammar:
o In this grammar, all production rules take the form:
 A→BxA \to BxA→Bx or A→xA \to xA→x
o Again, AAA and BBB are non-terminal symbols, and xxx is a terminal
symbol.
o Example:
 Rules: S→AbS \to AbS→Ab and A→aA \to aA→a can generate
strings like ab.

Key Points:

 Both types of linear grammar generate regular languages.

 Right linear grammars correspond to deterministic finite automata (DFA) that process
input from left to right.
 Left linear grammars can be transformed into equivalent right linear grammars and
vice versa.

v) Write a note on homomorphism and inverse of homomorphism.

Homomorphism: In formal language theory, a homomorphism is a function that maps

symbols from one alphabet to strings over another alphabet. It preserves the structure of the
strings and allows the transformation of languages.
  Definition:
Let α\alphaα be an alphabet and β\betaβ be another alphabet. A homomorphism
h:α∗→β∗h: \alpha^* \to \beta^*h:α∗→β∗ is defined such that for each a∈αa \in \
alphaa∈α, h(a)h(a)h(a) is a string in β∗\beta^*β∗.
 Example:
Let h:{a,b}→{x,y,z}h: \{ a, b \} \to \{ x, y, z \}h:{a,b}→{x,y,z} be defined as:
o h(a)=xh(a) = xh(a)=x
o h(b)=yzh(b) = yzh(b)=yz

The homomorphism maps the string ab to xyz, as follows:

h(ab)=h(a)h(b)=x(yz)=xyzh(ab) = h(a)h(b) = x(yz) = xyzh(ab)=h(a)h(b)=x(yz)=xyz

Inverse of Homomorphism: The inverse homomorphism is a function that maps strings over
the target alphabet back to the source alphabet.

 Definition:
Given a homomorphism h:α∗→β∗h: \alpha^* \to \beta^*h:α∗→β∗, the inverse
homomorphism h−1:β∗→α∗h^{-1}: \beta^* \to \alpha^*h−1:β∗→α∗ maps each
string in β∗\beta^*β∗ back to strings in α∗\alpha^*α∗.
 Example:
Continuing from the previous example, if we define h−1h^{-1}h−1 such that:
o h−1(x)=ah^{-1}(x) = ah−1(x)=a
o h−1(y)=bh^{-1}(y) = bh−1(y)=b
o h−1(z)=bh^{-1}(z) = bh−1(z)=b

The inverse function would take the string xyz and map it back to ab:

h−1(xyz)=h−1(x)h−1(y)h−1(z)=a(b)(b)=abh^{-1}(xyz) = h^{-1}(x)h^{-1}(y)h^{-1}
(z) = a(b)(b) = abh−1(xyz)=h−1(x)h−1(y)h−1(z)=a(b)(b)=ab

Key Points:

 Homomorphisms are essential for transforming languages and understanding the

relationships between different formal systems.
 The inverse of a homomorphism allows for the retrieval of original strings from
transformed representations.

Q3. Answer any four from the following:

i) What is a Derivation Tree?

A derivation tree (or parse tree) is a graphical representation of how a string is derived from
a context-free grammar (CFG). It shows the sequence of production rule applications used to
generate a string from the start symbol of the grammar.

Components:

 Root Node: Represents the start symbol.

 Intermediate Nodes: Represent non-terminal symbols.
 Leaf Nodes: Represent terminal symbols or ε (empty string).

Example:

For the grammar:

S → aB
B → b

We derive the string ab.

Derivation:

1. S → aB
2. B → b

Derivation Tree:

S
/ \
a B
|
b

This tree shows that S produces a and B, and B further produces b, resulting in the string ab.

ii) Notes on CFG Reduction and Unit Production Removal

a. Reduction of CFG:

CFG reduction simplifies a grammar by removing unnecessary parts while preserving the
language it generates. It typically involves two steps:

1. Removing Useless Symbols: Non-terminals that do not contribute to generating a terminal

string.
2. Removing Unreachable Symbols: Non-terminals that are not reachable from the start
symbol.
Example:

S → AB
A → a
B → b
C → c

Here, C is useless because it doesn't contribute to the derivation of any string. After reduction:

S → AB
A → a
B → b
b. Removal of UNIT Production:

Unit productions are rules where a non-terminal produces another non-terminal (e.g., A → B).
These can be eliminated by directly substituting the productions of the right-hand non-
terminal.

Example: For the grammar:

S → A
A → B
B → a

After removing the unit productions, the grammar becomes:

S → a

iii) Note on CNF (Chomsky Normal Form)

Chomsky Normal Form (CNF) is a standard form of context-free grammar where each
production rule is either:

 A → BC (where both B and C are non-terminals),

 A → a (where a is a terminal),
 S → ε (if the start symbol can derive the empty string).

Steps to Convert CFG to CNF:

1. Eliminate Null Productions: Remove any production of the form A → ε.

2. Eliminate Unit Productions: Remove productions where a non-terminal produces another
non-terminal.
3. Binary Productions: Ensure all right-hand sides of the productions have two non-terminals,
or a single terminal.

Example: For the grammar:

S → AB | a
A → a
B → b
It is already in CNF because all the rules satisfy the CNF conditions.

iv) Construct a PDA for L = {(ab)^n | n ≥ 0}

The language {(ab)^n | n ≥ 0} consists of alternating a and b. The PDA will push a onto
the stack for every occurrence of a and pop for every occurrence of b.

PDA Construction:

 States: q0 (start), q1 (push state), q2 (pop state), qf (final state).

 Transitions:
1. Read a in q0 and push it onto the stack.
2. Read b in q1, pop a from the stack.
3. Move to qf when the stack is empty.

PDA Description:
1. (q0, a, ε) → (q1, A) (push A for every a)
2. (q1, b, A) → (q2, ε) (pop A for every b)
3. (q2, ε, ε) → (qf, ε) (accept when the stack is empty)

The PDA accepts the string when the stack is empty, ensuring the number of as matches the
number of bs.

v) Components of a PDA (Pushdown Automaton)

A Pushdown Automaton (PDA) is a computational model that includes a stack for memory.
It is used to recognize context-free languages.

Components:

1. Input Tape: A sequence of input symbols to be processed.

2. Finite Set of States (Q): The different states the automaton can be in.
3. Stack Alphabet (Γ): The set of symbols that can be pushed to or popped from the stack.
4. Transition Function (δ): Dictates state transitions based on the current state, input symbol,
and top of the stack.
5. Start State (q0): The initial state of the automaton.
6. Start Stack Symbol (z0): The initial symbol on the stack.
7. Final States (F): The accepting states.

vi) Derivation Tree for Given Production Rule

Grammar:
S → aAS | a
A → SbA | SS | ba
Let's derive the string aabbaa.

1. Start with S → aAS

2. Apply A → SS to get aSSS.
3. Apply S → a and S → aAS to get aaASS.
4. Apply A → ba and S → a to get aabbaa.

Derivation Tree:
S
/ | \
a A S
/ | \
S S S
/ \ / \
a A b a
/ \
b a

This tree represents the derivation of the string aabbaa from the given grammar.

Q4. Answer any four from the following:

i) Types of Turing Machines:

1. Deterministic Turing Machine (DTM): It follows one specific set of rules for each input.
There’s no choice in what it does next.
2. Non-deterministic Turing Machine (NDTM): It can have multiple options at each step and
can explore many possibilities at the same time.
3. Multi-tape Turing Machine: It has more than one tape, each with its own head, allowing it
to read and write faster.
4. Multi-track Turing Machine: It has one tape divided into multiple tracks, and the machine
reads from all tracks together.
5. Universal Turing Machine (UTM): It can imitate any other Turing machine. It’s like a general-
purpose computer.
6. Alternating Turing Machine (ATM): It splits states into two types—existential and universal
—helping it explore multiple paths more smartly.

ii) Undecidable Language:

An undecidable language is one for which no machine or algorithm can always give a correct
"yes" or "no" answer. Some problems cannot be solved with any Turing machine. One big
example is the Halting Problem, which asks whether a machine will stop running or go on
forever for a given input. There’s no general solution to this problem.

iii) Turing Machine for L = {a^n b^n | n ≥ 0}:

This machine needs to check if there are equal numbers of 'a's followed by 'b's. It works by:

1. Marking the first 'a' and finding the first 'b' to mark it too.
 2. Repeating this until all 'a's and 'b's are matched.
3. If it matches them all, it accepts the string; if not, it rejects.

iv) Tuples of Linear Bounded Automata (LBA):

An LBA is a Turing machine that can only use a part of the tape, limited by the input size.
The machine is described by a 7-part tuple:

 Q: Set of all states.

 Σ: Input alphabet (symbols the machine can read).
 Γ: Tape alphabet (symbols the machine can read and write on the tape).
 δ: Transition rules (instructions on what to do next).
 q0: Starting state.
 q_accept: Accept state (the state that means the input is accepted).
 q_reject: Reject state (the state that means the input is rejected).

v) Halting Problem:

The Halting Problem is about figuring out whether a Turing machine will ever stop or will
run forever for a given input. Turing proved that it’s impossible to create a machine that can
answer this for every possible machine and input. This means we can't always know whether
a machine will stop.

vi) Design of a Turing Machine:

A Turing machine has a tape (infinite paper strip), a tape head (to read and write on the
tape), and a state register (controls what the machine does next based on rules). It reads a
symbol from the tape, decides what to do (like change the symbol, move left or right, or go to
a new state), and keeps working until it either accepts or rejects the input.

The machine’s design includes:

1. The input alphabet (symbols it reads).

2. The tape alphabet (symbols it can write).
3. The transition rules that tell it what to do for each symbol in each state.

This machine helps decide whether a string belongs to a language or solve other problems
step-by-step.

Q5. Answer any four from the following:

i) Write a short note on ambiguity of grammar.

A grammar is said to be ambiguous if there exists at least one string that can be generated by
the grammar in more than one way, resulting in multiple distinct parse trees or leftmost
derivations for the same string. This can cause confusion during parsing, as the same string
may have different interpretations based on the different structures derived from the
grammar.

For example, consider a grammar defined by the productions:

1. S→S+SS \rightarrow S + SS→S+S

2. S→SSS \rightarrow S SS→SS
3. S→aS \rightarrow aS→a
4. S→bS \rightarrow bS→b

The string a+aba + aba+ab can be derived in multiple ways, leading to different parse trees:

1. S→S+S→a+S→a+abS \rightarrow S + S \rightarrow a + S \rightarrow a +

abS→S+S→a+S→a+ab
2. S→SS→aS→a+abS \rightarrow S S \rightarrow a S \rightarrow a + abS→SS→aS→a+ab

Due to this multiplicity in derivations, the grammar is ambiguous. Ambiguous grammars can
often be transformed into equivalent unambiguous grammars, although this transformation is
not always possible for all languages.

ii) What is a Turing Machine? Explain it with its tuples.

A Turing Machine (TM) is an abstract computational model that defines an algorithm for
solving problems and recognizing languages. It consists of a tape, a head that reads and
writes symbols on the tape, and a finite set of states that guide its operations. The formal
definition of a Turing Machine is given as a 7-tuple:

1. Q: A finite set of states.

2. Σ: The input alphabet, which does not include the blank symbol.
3. Γ: The tape alphabet, which includes all symbols that can be written on the tape (including
the blank symbol).
4. δ: The transition function, defined as δ:Q×Γ→Q×Γ×{Left,Right}δ: Q × Γ → Q × Γ × \{ \
text{Left}, \text{Right} \}δ:Q×Γ→Q×Γ×{Left,Right}, which specifies how the machine moves
from one state to another based on the current state and the symbol being read.
5. q₀: The initial state where the computation begins.
6. B: The blank symbol, which represents empty cells on the tape.
7. F: A set of accepting (final) states that determine when the machine halts and accepts or
rejects the input.

The operation of a Turing Machine involves reading the current symbol on the tape,
determining the next state based on the transition function, writing a new symbol, and
moving the head left or right.
iii) Verify if the given grammar is ambiguous or not:

Grammar: G=(S,a,b,+,S,P)G = ({S}, {a, b, +}, S, P)G=(S,a,b,+,S,P) where PPP consists of:

1. S→S+SS \rightarrow S + SS→S+S

2. S→SSS \rightarrow S SS→SS
3. S→aS \rightarrow aS→a
4. S→bS \rightarrow bS→b

To check for ambiguity, let's derive the string a+aba + aba+ab using the productions of the
grammar.

First Derivation:

1. S→S+SS \rightarrow S + SS→S+S

2. S→aS \rightarrow aS→a
3. S→SSS \rightarrow SSS→SS
4. S→aS \rightarrow aS→a and S→bS \rightarrow bS→b
5. Thus, a+aba + aba+ab can be derived as:
o S→S+S→a+SS→a+abS \rightarrow S + S \rightarrow a + S S \rightarrow a + a
bS→S+S→a+SS→a+ab

Second Derivation:

1. S→SSS \rightarrow S SS→SS

2. S→aS \rightarrow aS→a
3. S→S+SS \rightarrow S + SS→S+S
4. Thus, a+aba + aba+ab can be derived as:
o S→SS→aS→a+S→a+abS \rightarrow S S \rightarrow a S \rightarrow a + S \rightarrow
a + a bS→SS→aS→a+S→a+ab

Since there are multiple ways to derive the same string a+aba + aba+ab, the grammar is
ambiguous.

iv) Write a short note on the complement of Regular Language and the steps
to obtain the same.

The complement of a regular language LLL is the set of strings that are not in LLL,
typically denoted as L‾\overline{L}L. If LLL is recognized by a deterministic finite
automaton (DFA) M=(Q,Σ,δ,q0,F)M = (Q, Σ, δ, q₀, F)M=(Q,Σ,δ,q0,F), then the complement
L‾\overline{L}L can also be recognized by a DFA.

Steps to obtain the complement of a Regular Language:

1. Obtain the DFA for the language LLL: Start with a DFA that recognizes the regular language.
 create F′=Q∖FF' = Q \setminus FF′=Q∖F (where F′F'F′ is the new set of accepting states).
2. Switch the accepting and non-accepting states: Invert the accepting states FFF of the DFA to

3. The new DFA: The modified DFA, M′=(Q,Σ,δ,q0,F′)M' = (Q, Σ, δ, q₀, F')M′=(Q,Σ,δ,q0,F′),
recognizes the complement language L‾\overline{L}L.

This method works because the new DFA will accept all strings that were previously rejected
and reject all strings that were previously accepted.

v) Create a DFA for L={x∈{0,1}∗∣0110 is a substring of x}L = \{ x \in \{0,1\}^*

| 0110 \text{ is a substring of } x \}L={x∈{0,1}∗∣0110 is a substring of x}.

To construct a DFA for the language LLL where 011001100110 is a substring, we need to
create states that track the progress of matching the substring "0110":

1. States:
o q0q_0q0: Start state (no part matched).
o q1q_1q1: The first '0' matched.
o q2q_2q2: The first '0' and '1' matched (i.e., "01").
o q3q_3q3: The first '0', '1', and '1' matched (i.e., "011").
o q4q_4q4: The first '0', '1', '1', and '0' matched (i.e., "0110", accepting state).

2. Transitions:
o From q0q_0q0:
 on '0' → q1q_1q1
 on '1' → q0q_0q0
o From q1q_1q1:
 on '0' → q1q_1q1
 on '1' → q2q_2q2
o From q2q_2q2:
 on '0' → q1q_1q1
 on '1' → q3q_3q3
o From q3q_3q3:
 on '0' → q4q_4q4 (accepting state)
 on '1' → q0q_0q0
o From q4q_4q4:
 on '0' → q4q_4q4 (remain in accepting state)
 on '1' → q4q_4q4 (remain in accepting state)

3. Accepting State:
o The only accepting state is q4q_4q4.

This DFA correctly accepts any string containing "0110" as a substring.

vi) Explain the intersection operation on Regular Language.

The intersection operation on regular languages involves creating a new language that
contains all the strings that are common to two regular languages L1L_1L1 and L2L_2L2. If
both languages are regular, then their intersection L1∩L2L_1 \cap L_2L1∩L2 is also regular.

Constructing the DFA for Intersection:

1. Let M1=(Q1,Σ,δ1,q01,F1)M_1 = (Q_1, Σ, δ_1, q_{0_1}, F_1)M1=(Q1,Σ,δ1,q01,F1) be the DFA

for L1L_1L1.
2. Let M2=(Q2,Σ,δ2,q02,F2)M_2 = (Q_2, Σ, δ_2, q_{0_2}, F_2)M2=(Q2,Σ,δ2,q02,F2) be the DFA
for L2L_2L2.
3. Create a new DFA MMM that has the following:
o States: The states of MMM are pairs of states from M1M_1M1 and M2 M_2M2:
Q=Q1×Q2Q = Q_1 × Q_2Q=Q1×Q2.
o Initial State: (q01,q02)(q_{0_1}, q_{0_2})(q01,q02)
o Accepting States: F=F1×F2F = F_1 × F_2F=F1×F2 (both states must be accepting).
o Transition Function: For each pair of states (q1,q2)(q_1, q_2)(q1,q2), the transition
function is defined as: δ((q1,q2),a)=(δ1(q1,a),δ2(q2,a))δ((q_1, q_2), a) = (δ_1(q_1, a),
δ_2(q_2, a))δ((q1,q2),a)=(δ1(q1,a),δ2(q2,a))

This means that the transition for the new DFA takes inputs from both original DFAs.

This construction allows the new DFA to accept strings that are accepted by both M1M_1M1
and M2M_2M2, effectively computing the intersection of the two regular languages.