Automata Suggestions Answer

---Soumyadip Karak

1.Define Alphabet, string & Regular Language.

Sol: 1. Alphabet (Σ):
An alphabet is a finite, non-empty set of symbols. Each symbol in the alphabet is
called a character or letter.
• Example:
Σ = {0, 1} → A binary alphabet
Σ = {a, b, c} → An alphabet with three letters
2. String (or Word):
A string is a finite sequence of symbols taken from an alphabet.
• Notation: If Σ = {a, b}, then "ab", "aab", and "" (empty string, denoted ε)
are strings over Σ.
• The length of a string is the number of symbols in it.
3. Regular Language:
A regular language is a set of strings that can be defined using regular expressions
or accepted by finite automata (DFA/NFA).
• Formally, regular languages are those that can be:
o Expressed using regular expressions
o Recognized by a Deterministic Finite Automaton (DFA)
o Recognized by a Non-deterministic Finite Automaton (NFA)
o Generated by a regular grammar
• Example:
The language L = { w ∈ {0,1}* | w contains an even number of 0s } is a
regular language.
2.What are the application of CFG.
1.Programming Language Syntax: CFGs are used to define the syntax (structure) of
programming languages in compilers and interpreters.
2.Natural Language Processing (NLP): CFGs help in parsing and analyzing the
grammatical structure of sentences in human languages.
3.XML/HTML Parsing: CFGs are used in designing parsers for markup languages
like XML and HTML to ensure proper nesting and structure.
3. Explain the Left Most Derivation & Right Most Derivation tree with Example
1. Left Most Derivation: In every step, the leftmost non-terminal is replaced
first. Helps in designing top-down parsers.
2. Right Most Derivation: In every step, the rightmost non-terminal is replaced
first. Used in bottom-up parsing.
Example:
Left Most Derivation Right Most Derivation:
Given CFG: S ⇒ aS (apply S → aS) S ⇒ Sb (apply S → Sb)
S → aS | Sb | ab ⇒ aaS (apply S → aS) ⇒ aSb (apply S → aS)
Derive the string: "aab" ⇒ aab (apply S → b) ⇒ aab (apply S → b)
4. The given CFG E E+ E | E* E | a. Find whether this CFG ambiguity or not?
Derivation 1 (interpreting as a + (a * a)): Derivation 2 (interpreting as (a + a) * a):
E⇒E+E E⇒E*E
⇒a+E ⇒E+E*E
⇒a+E*E ⇒a+a*a
⇒a+a*a
Since the string a + a * a can be derived in more than one way (two distinct parse trees),
→The given CFG is ambiguous.
 5.Language L= a2n , n>=1. Find it is regular or not?
Sol: No, the language is not regular.
Because the string lengths in L are powers of 2 (e.g., a², a⁴, a⁸, ...), and regular languages
cannot count or enforce exponential patterns like powers of 2. This can be proven using
the Pumping Lemma, which shows that the language violates the properties of regular
languages.
6. Define Moore Machine with example.
Sol: A Moore Machine is a type of finite state machine where the output depends only on
the current state, not on the input symbol.
Example:
• 1 when the number of 1's seen so far is even,
• 0 when it is odd.
State Input 1 Output • Start state: A
A B 1 • Transitions on input 1: A → B → A → B ...
• Output for input 1 1 1: 1 0 1 0
B A 0
7.Explain PDA utilizing a stack.
Sol: A Pushdown Automaton (PDA) is a type of automaton that uses a stack to store
additional information. This allows it to recognize context-free languages, which are more
complex than regular languages.
• A PDA reads input symbols and can push or pop symbols to/from the stack.
• The stack helps handle nested or recursive structures (like matching parentheses).
8.Rules to convert CFG to CNF with example.
Sol: Rules to Convert CFG to CNF (Chomsky Normal Form):
A CFG is in CNF if all productions are of the form:
1. A → BC (two non-terminals)
2. A → a (a single terminal)
3. S → ε (only if ε is in the language)
Steps to Convert CFG to CNF:
1. Add a new start symbol if needed: S₀ → S
2. Remove ε-productions (nullable rules)
3. Remove unit productions (like A → B)
4. Convert long/mixed rules into CNF by:
o Replacing terminals with variables: e.g., a → X, then use X in rules
o Breaking long rules into binary: e.g., A → BCD becomes A → BZ, Z → CD
9. Differentiate between Mealy & Moore machine?
Features Mealy Machine Moore machine
Output depends on Current state and input Only on the current state
Output changes Immediately with input Changes after state transition
Output function λ: Q × Σ → Δ λ: Q → Δ
Number of states Generally fewer May require more states
Example Output given during Output given on entering a
transition state
10. Estimate the CNF form for the given CFG: S→bA|aB, A→bAA|aS|a, B→aBB|bS|a.
Step 2: Convert rules to CNF (binary rules only)
Final S→YA|XB
X→a Break rules with more than 2 symbols: A → Y Z₁ | X S | X
CNF:
Y→b • A→YAA B → X Z₂ | Y S | X
S→YA|XB → introduce Z₁ → A A
A→YAA|XS|X → A → Y Z₁ Z₁ → A A
B→XBB|YS|X • B→XBB Z₂ → B B
X→a → introduce Z₂ → B B X→a
Y→b → B → X Z₂
Y→b
 11.L set of all even palindrome over Σ = {a, b} construct the PDA.
Sol: A Pushdown Automaton (PDA) can recognize even palindromes by using a stack to
compare the first half of the string with the second half.
PDA Description:
1. States:
o q₀: Start state
o q₁: State for reading and pushing symbols onto the stack
o q₂: State for popping symbols and comparing
o q₃: Accept state
2. Alphabet:
o Input: Σ = {a, b}
o Stack: Γ = {a, b, Z} (Z is the initial stack symbol)
3. Transition Function:
o q₀ → q₁: Push symbols ('a' or 'b') onto the stack while reading the first half
of the input.
o q₁ → q₂: Switch to comparing the second half when the string length is
half.
o q₂ → q₃: Accept when all symbols in the second half match the symbols
popped from the stack.
4. Final State: The PDA accepts when the input is completely read and the stack is
empty except for the initial symbol Z.
Example:
For input "abba":
• Push 'a' → Stack: [a]
• Push 'b' → Stack: [a, b]
• Pop 'b' → Stack: [a]
• Pop 'a' → Stack: []
The PDA transitions to the accept state and accepts the string.
This PDA can recognize even palindromes by storing the first half and matching it with the
second half.
12.Explain the Equivalence of CFL & PDA.
1.Context-Free Languages (CFL) can be recognized by Pushdown Automata (PDA).
This means that for every CFL, there exists a PDA that accepts it.
2.Conversely, every PDA can recognize a Context-Free Language. This means that
for every PDA, there exists a CFL that it recognizes.
13.Explain the ambiguity in CFG with example.
Sol: A Context-Free Grammar (CFG) is said to be ambiguous if there exists a string in the
language generated by the grammar that has more than one leftmost derivation or parse
tree.
Example: S → S + S | S * S | a
14.Define the closure properties of CFL with example.

1. Union: If L₁ and L₂ are CFLs, then L₁ ∪ L₂ is a CFL.

o Example: If L₁ = {a^n b^n} and L₂ = {a^n c^n}, then L₁ ∪ L₂ = {a^n b^n} ∪ {a^n c^n} is a CFL.
2. Concatenation: If L₁ and L₂ are CFLs, then L₁L₂ is a CFL.
o Example: If L₁ = {a^n b^n} and L₂ = {b^n c^n}, then L₁L₂ = {a^n b^n b^n c^n} is a CFL.
3. Kleene Star: If L is a CFL, then L* (zero or more repetitions of L) is a CFL.
o Example: If L = {a^n b^n}, then L* is also a CFL.
 15.What is CNF and GNF?
CNF (Chomsky Normal Form): A Context-Free Grammar (CFG) is in Chomsky Normal Form
(CNF) if all production rules are of the form:
1. A → BC (where A is a non-terminal and B, C are non-terminals).
2. A → a (where A is a non-terminal and a is a terminal).
Example:
S → AB | a
A → BC
B→b
C→c
GNF (Greibach Normal Form): A CFG is in Greibach Normal Form (GNF) if all production
rules are of the form:
1. A → aα (where A is a non-terminal, a is a terminal, and α is a string of non-
terminals).
Example:
S → AB | a
A → BC
B→b
C→c
16.Remove unique production from this CFG, Where S -> AB, A-> E, B->C, C-> D, D-> b, E-
>a.
Sol: Step: Remove Unit Productions
Unit productions are of the form: A → B (where both A and B are non-terminals).
Unit productions in this CFG:
• A→E
• B→C
• C→D
We'll replace them by directly linking A, B, and C to the terminal productions eventually
reached.
New CFG (after removing unit productions):
1. S → AB
2. A → a (from A → E → a)
3. B → b (from B → C → D → b)
4. C → b (from C → D → b)
5. D → b
6. E → a
17. Removal the ε production from the CFG. S -> ABaC, A-> BC, B->b| ε, C-> D| ε, D-> d
S → ABaC | AaC | ABa | Aa
A → BC | B | C
B→b
C→D
D→d
18. Explain Linear Grammar from converting PDA into an equivalent CFG.
Sol: When converting a Pushdown Automaton (PDA) to an equivalent Context-Free
Grammar (CFG), the resulting CFG often has a linear grammar structure — meaning that
each production rule contains at most one non-terminal on the right-hand side.
1. For each pair of states (p, q) in PDA, a variable A_pq is created in the CFG.
2. Productions are added such that A_pq → a A_rs b, simulating the PDA’s stack operations.
3. These rules maintain a structure where terminals and at most one non-terminal appear — forming a linear
grammar.
19.Explain Linear Grammar with example.
Sol: A Linear Grammar is a type of Context-Free Grammar (CFG) where at most one non-
terminal appears on the right-hand side of each production rule.
There are two types:
• Right-linear: productions like A → aB or A → a
• Left-linear: productions like A → Ba or A → a
20.Determine wheather the language L=w, where w is a palindrome on ε = a,b regular
or not?
Sol: The language L = { w | w is a palindrome over Σ = {a, b} } is not regular.
Reason: A palindrome reads the same forward and backward (e.g., abba, aba, babbab).
Regular languages cannot count or compare symbols in the middle of the string, which is
required for checking palindromes.
This can be proved using the Pumping Lemma for Regular Languages, which shows that
the language of palindromes fails the conditions of regularity.
21. Find the parse tree generate the string 11001010, the grammar given S->1B|OA, A->
1|1S|OAA, B-> 0|OS|1BB
Sol:
S → 1B S → 1B
→ 1 (1BB) B → 1BB
→ 1 1 (B B) B→0
→ 1 1 0 (B) B → 0S
→ 1 1 0 0S S → 0A
→ 1 1 0 0 0A A → 1S
→ 1 1 0 0 0 1S S → 0A
→ 1 1 0 0 0 1 0A A→1
→1100101
22.Explain whether PDA is more powerful than FA with example.
Sol: Yes, PDA (Pushdown Automaton) is more powerful than FA (Finite Automaton).
Reason:
• FA (Finite Automaton) can recognize only regular languages.
• PDA can recognize both regular and some non-regular languages like context-free
languages.
Example:
Language L = { aⁿbⁿ | n ≥ 0 }
• This language is not regular (cannot be accepted by FA) because FA cannot count
matching numbers of a's and b's.
• But it can be accepted by a PDA, using a stack to count and match a's and b's.
23.Write down Find PDA which accept all string containing eqal numbers of 0s and 1s.
Sol: The Pushdown Automaton (PDA) accepts strings where the number of 0s is equal to
the number of 1s by using its stack to track the difference.
PDA Components:
• States: {q₀, q_accept, q_reject}
• Alphabet: {0, 1}
• Stack Alphabet: {X, Z} (X is used to count 0s, Z is the initial stack symbol)
• Start State: q₀ 1. Push X for each 0:
• Accepting State: q_accept o (q₀, 0, Z) → (q₀, XZ)
o (q₀, 0, X) → (q₀, XX)
• Start Stack Symbol: Z (initial stack symbol)
2. Pop X for each 1:
• Transition Function: o (q₀, 1, X) → (q₀, ε)
3. Accept when stack is empty after reading all input:
o (q₀, ε, Z) → (q_accept, Z)
24.Find equivalent CFG for the expression (a+b)* aa(a+b)*
Sol: S → T AA T
AA → a a
T→aT|bT|ε
25.Explain the PDA for the CFG, Generates the set of all string over the alphabet Σ = {a,
b}, with exactly twice as many as and bs
Language: L = { w ∈ {a, b}* | number of a's = 2 × number of b's }
PDA Concept: We’ll build a non-deterministic PDA that uses its stack to count the
difference between the number of a's and b's. Specifically, for every b read, the
PDA ensures that there are two a's.
Strategy:
• Push one symbol (say A) for each a read.
• Pop two As for each b (since 2 a's per b).
• Accept if the stack is empty after input is processed.
Key Transitions (Simplified):
Let stack symbol be Z (initial) and A for a:
1. (q₀, a, Z) → (q₀, AZ)
2. (q₀, a, A) → (q₀, AA)
3. (q₀, b, A) → (q₀, ε) → do twice to pop 2 A's for 1 b
(This requires non-determinism or extra steps.)
4. (q₀, ε, Z) → (q_accept, Z)
(Accept if input ends and exactly 2 a's per b)
26.Even Grammar S-> Ab|bA, S-> As | bAA | a, B-> bS| aBB|b. W= aaabbabbba. Derive
the RMD tree.
S ⇒ bAA
⇒bAA
⇒ b aBB A
⇒ b a bS B A
⇒babaBBA
⇒bababBA
⇒ b a b a b aBB
⇒ b a b a b a bS B
⇒babababaB
⇒babababab