Theory of Computation II IA

1.What is a context free grammar? Explain a CFG with an example.

What are Context-Free Grammars (CFGs)

A context-free grammar (CFG) is a set of rules used to generate strings in a formal

language. They are called "context-free" because the rules can be applied regardless of the
surrounding symbols.

Formal Definition: A context-free grammar is a 4-tuple (V, Σ, R, S):

• V: A finite set of variables (nonterminals).

• Σ: A finite set of terminals (alphabet symbols).
• R: A finite set of rules (productions) of the form A → w, where A is a variable and w is
a string of variables and terminals.
• S: A special variable called the start variable.

A string is in the language of the grammar if it can be derived from the start variable by applying
the rules.

Example:

Consider the grammar G = ({S, A, B}, {a, b}, R, S), where R contains the following rules:

1. S → aSb
2. S → ε

This grammar generates the language {anbn | n ≥ 0}, which consists of strings with an equal
number of 'a's and 'b's. Here's how the string "aabb" is derived:

1. S (Start)
2. aSb (Apply rule 1)
3. aaSbb (Apply rule 1 again)
4. aabb (Apply rule 2)
2.Obtain the CFG to generate strings consisting any number of a’s and b’s where L = {
|w| mod 3 =0 }.

CFG for Strings with Length Divisible by 3

To generate strings consisting of any number of 'a's and 'b's where the length of the string is
divisible by 3, we can use the following CFG:

G = ({S, A, B}, {a, b}, R, S)

where R contains the following rules:

1. S→ε
2. S → AAA
3. A→a
4. A→b

Explanation:

• Rule 1 allows for the empty string (length 0, divisible by 3).

• Rule 2 ensures that any string derived from S will have a length that is a multiple of
3.
• Rules 3 and 4 allow for any combination of 'a's and 'b's within each group of three
symbols.

Examples:

• ε (from rule 1)
• aaa (from rules 2 and 3)
• bbb (from rules 2 and 4)
• aababb (from rules 2, 3, and 4)

This grammar ensures that all the generated strings will have a length divisible by 3.
3.Let G be the Grammer
S→aB| bA
A→aS| bAA| a
B→ bS| aBB| b.
For string aaabbabbba .Construct LMD,RMD and parse tree.

Leftmost Derivation (LMD), Rightmost Derivation (RMD), and Parse Tree

• Leftmost Derivation (LMD): In a leftmost derivation, the leftmost variable in each

sentential form is always chosen for replacement.
o For the string "aaabbabbba" and grammar G:
o S ⇒ aB
o ⇒ aaBB
o ⇒ aaaBBB
o ⇒ aaabSBB
o ⇒ aaabbaABBB
o ⇒ aaabbabABBB
o ⇒ aaabbabbABBB
o ⇒ aaabbabbbaBB
o ⇒ aaabbabbbbB
o ⇒ aaabbabbba
• Rightmost Derivation (RMD): In a rightmost derivation, the rightmost variable in each
sentential form is always chosen for replacement.
o For the string "aaabbabbba" and grammar G:
o S ⇒ aB
o ⇒ aABB
o ⇒ aabSBB
o ⇒ aabbaABBB
o ⇒ aabbaABBb
o ⇒ aabbabSBBb
o ⇒ aabbabbABBBb
o ⇒ aabbabbbaBBBb
o ⇒ aaabbabbbbBb
o ⇒ aaabbabbba
• Parse Tree: A parse tree visually represents the derivation of a string using a grammar.
o For the string "aaabbabbba" and grammar G:
o S
o / \
o a B
o / \
o a B
o / \
o B b
o / \
o b S
o / \
o a B
o / \
o a b
Explanation for an Engineering Student

Think of the grammar G as a set of rules for constructing strings.

• The variables (S, A, B) represent placeholders that can be replaced by other

variables or terminals (a, b).
• The productions (S→aB, A→aS, etc.) tell you how to make those replacements.

LMD and RMD are like step-by-step instructions for building the string "aaabbabbba" using
grammar G.

• LMD always works on the leftmost variable first.

• RMD always works on the rightmost variable first.

The parse tree shows you the hierarchical structure of the string, like a family tree.

• The root node (S) is the starting point.

• Each branch represents a production rule.
• The leaves (a, b) are the final symbols of the string.

Understanding LMD, RMD, and parse trees is important for:

• Compiler design: Compilers use parsing techniques to understand the structure of

programs written in programming languages.
• Natural language processing: Parsing techniques are also used to analyze the
grammatical structure of sentences in human languages.

4.Consider the grammar. E → +EE| *EE | -EE | x | y

Find leftmost and rightmost derivation for the string +* — xyxy and write parse tree.

Derivations and Parse Trees for Given Grammars

For the grammar E → +EE| *EE | -EE | x | y:

Leftmost Derivation (LMD) for the string +*—xyxy:

E → +EE
→ +*EEE
→ +*-EEEE
→ +*-xyEEE
→ +*-xyxyEE
→ +*-xyxyx
→ +*-xyxyxy
Rightmost Derivation (RMD) for the string +*—xyxy:

E → +EE
→ +E-EE
→ +E-Exy
→ +E-Exyx
→ +E-Exyxy
→ +*EE-Exyxy
→ +*-EE-Exyxy
→ +*-xyxy

Parse tree for the string +*—xyxy:

E
/|\
+ E E
| /|\
* - E E
| x y
x y

5.Consider the grammar ;E(E+E| E*E| (E) | id

Construct LMD, RMD and parse tree for the string (id+id*id)

For the grammar E → E+E| E*E| (E) | id:

Leftmost Derivation (LMD) for the string (id+id*id):

E → (E)
→ (E+E)
→ (id+E)
→ (id+E*E)
→ (id+id*E)
→ (id+id*id)

Rightmost Derivation (RMD) for the string (id+id*id):

E → (E)
→ (E+E)
→ (E+E*E)
→ (E+E*id)
→ (E+id*id)
→ (id+id*id)

Parse tree for the string (id+id*id):

E
|
(E)
|
 E+E
/ \
id E*E
/ \
id id

These derivations and parse trees demonstrate how strings can be generated and their structure
represented using the given grammars. Note that the sources provided do not contain examples
using these exact grammars. The provided answers draw on the general concepts of derivations
and parse trees discussed in the sources, and apply them to the specific grammars in the query.

6.Check whether the given grammar G is ambiguous or not.

S → aSb | SS
S→ε

Question 6 Solution: Grammar Ambiguity

The grammar G is ambiguous. Here's why:

Consider the string "aabb". This string can be derived in two different ways using the given
grammar:

Derivation 1:

• S → SS
• S → aSbS → aabbS → aabbε → aabb

Derivation 2:

• S → aSb
• S → aaSbb → aabb

The existence of two distinct leftmost derivations (and parse trees) for the same string proves the
grammar is ambiguous.

7.Consider the grammar G=(V,T,P,E) with V={E,I}, T={a,b,c,+,*,(,)}

For the Input string: a + b * c, prove that the grammar is ambiguous.
E→I,
E→E+E,
E→E*E,
E→(E),
I →|a|b|c
Question 7 Solution: Proving Grammar Ambiguity

The grammar is ambiguous. Let's prove this by demonstrating two different parse trees for the
input string "a + b * c":

Parse Tree 1 (Addition has higher precedence):

E
/ \
E *
/ \ \
E + E
| | |
I I I
| | |
a b c

This parse tree corresponds to the interpretation (a + b) * c

Parse Tree 2 (Multiplication has higher precedence):

E
/ \
E +
/ \ \
I * I
| / \ |
a E E c
| |
I I
| |
b c

This parse tree corresponds to the interpretation a + (b * c)

The existence of two distinct parse trees for the same input string "a + b * c" demonstrates
that the grammar is ambiguous.

Explanation for Engineering Students:

Ambiguity in grammars, particularly in programming languages, is undesirable because it leads

to multiple interpretations of the same expression. This can cause errors and unpredictable
behavior in programs.

• Question 6: The grammar allows for multiple ways to generate the same sequence
of 'a's and 'b's, making it unclear how to parse strings like "aabb".
• Question 7: The lack of explicit precedence rules for the operators '+' and '*' in the
grammar allows for two different ways to structure the expression "a + b * c", leading
to potential ambiguity in evaluating the expression.
8. What is ambiguous grammar? Show that the following grammar is ambiguous. For
w=ibtibtibtaea S → iCtS| iCtSeS| a C → b

An ambiguous grammar is a context-free grammar for which there exists a string that can have
more than one leftmost derivation or parse tree.

To show that the given grammar is ambiguous:

• Consider the string w=ibtibtibtaea.

• Two possible leftmost derivations can be constructed for this string:

1. Derivation 1: S ⇒ iCtS ⇒ ibtS ⇒ ibtiCtSeS ⇒ ibtibtSeS ⇒ ibtibtibtaeS ⇒ ibtibtibtaea

2. Derivation 2: S ⇒ iCtS ⇒ ibtS ⇒ ibtiCtSeS ⇒ ibtibtSeS ⇒ ibtibtibtaeS ⇒ ibtibtibtaea

• Both derivations lead to the same string, but they differ in the order of application of
the production rules.
• This demonstrates that the grammar is ambiguous as the string w=ibtibtibtaea can
be derived in multiple ways.

9. Explain ambiguous grammar. Show that the following grammar is ambiguous:

S->aSbS
S->bSaS
S->€

An ambiguous grammar is a context-free grammar where a single string can have more than one
leftmost derivation, leading to multiple parse trees.

This means that the grammar doesn't provide a unique interpretation for every string it generates,
making it difficult to understand the intended meaning.

Example: In the given grammar, the string "abab" can be derived in two ways:

1. S ⇒ aSbS ⇒ abS ⇒ abab

2. S ⇒ bSaS ⇒ abS ⇒ abab
10. Prove that the following grammar is ambiguous:
S-> aS | X
X -> aX | a

To demonstrate the ambiguity of the given grammar, consider the string 'aaa'. Two distinct
leftmost derivations are possible for this string, indicating the presence of ambiguity:

1. Derivation 1: S ⇒ aS ⇒ aaS ⇒ aaa

2. Derivation 2: S ⇒ X ⇒ aX ⇒ aaX ⇒ aaa

The existence of these two different derivations for the same string proves that the given
grammar is ambiguous.

Defining CFG and Constructing Grammars

11. Define CFG. Write CFG for the languages:
L = anb2n where n>=1.
L={an bm ck |n+2m=k for n>=0,m>=0}
L={wwR| w∈{a, b}*}

Context-Free Grammar (CFG): A CFG is a formal grammar in which every production rule is
of the form A → α, where A is a single non-terminal symbol, and α is a string of terminals and/or
non-terminals. CFGs are used to generate context-free languages.

CFGs for the given languages:

• L = anb2n where n>=1:

• S → aSbb | abb
o Explanation: The grammar starts with 'S' and generates an equal number of
'a's and 'bb's.
• L={an bm ck |n+2m=k for n>=0,m>=0}:
• S → aSc | X
• X → bXcc | ε
o Explanation: 'S' generates 'a's and 'c's according to the relation n + 2m = k. 'X'
handles the 'b's and corresponding 'cc's.
• L={wwR| w∈{a, b}*}:
• S → aSa | bSb | ε
o Explanation: 'S' generates palindromes by recursively adding 'a's or 'b's
symmetrically.
12. Define Left Recursion. Eliminate Left Recursion from the given grammar:
E -> E+T|T
T -> T f |F
F -> (E)|id*.

Left Recursion: Left recursion in a CFG occurs when a non-terminal symbol can derive a string
that starts with itself. It can cause issues in parsing and needs to be eliminated.

Example: In the given grammar, the production 'E -> E+T' demonstrates left recursion as 'E'
appears as the first symbol on the right-hand side.

Eliminating Left Recursion:

The given grammar can be rewritten to remove left recursion:

E -> TE'
E' -> +TE' | ε
T -> FT'
T' -> *FT' | ε
F -> (E) | id

Explanation:

• Introduce a new non-terminal, E', to handle the recursive part.

• The original 'E' production is split, ensuring E' handles the '+T' recursion.
• Apply the same pattern to 'T', introducing T' to handle '*F' recursion.

This modified grammar generates the same language but without left recursion.

13. Convert the following PDA to CFG.

M = ({q0,q1}, {0,1}, {X, Zo}, D, q0, Zo, {}) with e (epsilon ):
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) E

Explanation for a 12th Standard Student:

Imagine a PDA like a simple computer program. It has states (like points in the program), an
input tape (like data), and a stack (like temporary memory). The goal is to convert this program
into a set of rules (a CFG) that generates the same language.

Think of an engineering student who builds complex machines using simpler components.
Similarly, we'll break down the PDA into smaller parts and create rules based on its behavior:

Steps:

1. Variables: For every pair of states (p, q) in the PDA, create a variable [pXq], where X
is a stack symbol.
2. Start Variable: The start variable is [q0Z0q1] (starting state with initial stack symbol
leading to the final state).
3. Rules: For each transition in the PDA, create corresponding rules:
o If the PDA reads an input 'a' and pushes 'Y' onto the stack while moving from
state 'p' to 'q', add a rule: [pXq] -> a[pYq].
o If the PDA pops 'X' from the stack without reading input and moves from state
'p' to 'q', add a rule: [pXq] -> ε (epsilon, meaning empty string).
o Combine these rules for complex transitions.

Applying the Steps to the Given PDA:

• Variables: [q0Z0q0], [q0Xq0], [q0Z0q1], [q0Xq1], [q1Xq1], [q1Z0q1]

• Start Variable: [q0Z0q1]
• Rules:
o d(q0,0,Z0) = (q0,XZo): [q0Z0q0] -> 0[q0Xq0][q0Z0q0], [q0Z0q1] ->
0[q0Xq0][q0Z0q1]
o d(q0,0,X) = (q0,XX): [q0Xq0] -> 0[q0Xq0][q0Xq0], [q0Xq1] -> 0[q0Xq0][q0Xq1]
o d(q0,1,X) = (q1,e): [q0Xq1] -> 1
o d(q1,1,X) = (q1,e): [q1Xq1] -> 1
o d(q1,e,X) = (q1,e): [q1Xq1] -> ε
o d(q1,e,Zo) = (q1,e): [q1Z0q1] -> ε

This resulting CFG generates the same language as the given PDA.

14.Obtain CFG for the PDA shown below

Δ(q0,a,Z)=(qo,AZ)
Δ(q0,a,A)=(q0,A)
Δ(q0,b,A)=(q1,€)
Δ(q1,€,Z)=(q2,€)
CFG for PDA

The CFG for the given PDA is:

S -> aAS
A -> a | b

Explanation:

• The PDA starts in state q0 with Z on the stack.

• For each 'a' read, it pushes an 'A' onto the stack (rules 1 and 2). This corresponds to
the production S -> aAS.
• When a 'b' is encountered, it pops an 'A' from the stack (rule 3) and moves to state
q1, which leads to q2 where the stack is cleared and the input is accepted. This can
be represented by the production A -> b.

15.Obtain CFG for the PDA shown below

δ(q0,a,Z)=(qo,AZ)
δ(q0,b,A)=(q0,AA)
δ(q0,a,A)=(q1,€)

CFG for PDA

The CFG for the given PDA is:

S -> aAS
A -> bAA | a

Explanation:

• Similar to the previous example, for each 'a' read, the PDA pushes an 'A' onto the
stack.
• It stays in state q0 for any number of 'b' inputs, pushing two 'A's for each 'b' (rule 2).
This corresponds to the production A -> bAA.

16.Construct PDA for the given CFG, and test whether 010000 is acceptable by this
PDA.
S → 0BB
B → 0S | 1S | 0 .
Constructing a PDA and Testing a String

To construct a PDA for the given CFG and test if the string 010000 is acceptable:

1. Define the PDA:

o States: {q0, q1, q2}
o Input Alphabet: {0, 1}
o Stack Alphabet: {S, B, 0, 1, Z}
o Start State: q0
o Accepting State: q2
o Initial Stack Symbol: Z
2. Define the transitions:
o δ(q0, ε, Z) = {(q1, SZ)} (Push the start symbol onto the stack)
o δ(q1, 0, S) = {(q1, BB)} (Apply the production S → 0BB)
o δ(q1, 0, B) = {(q1, 0S)} (Apply the production B → 0S)
o δ(q1, 1, B) = {(q1, 1S)} (Apply the production B → 1S)
o δ(q1, 0, B) = {(q1, 0)} (Apply the production B → 0)
o δ(q1, ε, Z) = {(q2, ε)} (Accept if the stack is empty)
o For all other combinations, δ(q, a, X) = ∅
3. Test the string 010000:
o (q0, 010000, Z) → (q1, 010000, SZ)
o → (q1, 10000, BBZ)
o → (q1, 0000, 1SBZ)
o → (q1, 000, 01SSBZ)
o ... (Continue expanding productions)
o (Since the string can be derived from the CFG, it is accepted by the PDA)

Explanation:

The PDA uses the stack to store symbols that are currently being derived by the CFG. It starts by
pushing the start symbol onto the stack. Then, it repeatedly pops symbols from the stack and
replaces them with symbols from the right-hand side of a production. The PDA accepts the input
string if it is able to empty the stack.

17.Construct an equivalent PDA for the following CFG

S->aAB | bBA
A->bS | a
B-> aS | b
Equivalent PDA for CFG

To construct a PDA equivalent to the CFG:

1. Define the PDA:

o States: {q0, q1, q2}
o Input Alphabet: {a, b}
o Stack Alphabet: {S, A, B, Z}
o Start State: q0
o Accepting State: q2
o Initial Stack Symbol: Z
2. Define transitions:
o δ(q0, ε, Z) = {(q1, SZ)} (Push the start symbol onto the stack)
o δ(q1, a, S) = {(q1, AB)} (Apply S -> aAB)
o δ(q1, b, S) = {(q1, BA)} (Apply S -> bBA)
o δ(q1, b, A) = {(q1, S)} (Apply A -> bS)
o δ(q1, a, A) = {(q1, ε)} (Apply A -> a)
o δ(q1, a, B) = {(q1, S)} (Apply B -> aS)
o δ(q1, b, B) = {(q1, ε)} (Apply B -> b)
o δ(q1, ε, Z) = {(q2, ε)} (Move to accepting state when the stack is empty)

Explanation: The PDA simulates the leftmost derivation of the CFG. It pushes the start symbol
on the stack. For every input symbol, it pops a matching terminal symbol from the stack and
pushes the right-hand side of a production onto the stack.

18.Convert the grammar with following production to PDA accepted by empty stack:
S→ 0S1 | A
A→1A0 | S | ε

PDA for CFG Accepted by Empty Stack

To convert the grammar to a PDA that accepts by an empty stack:

1. Define the PDA:

o States: {q0, q1}
o Input Alphabet: {0, 1}
o Stack Alphabet: {S, A, 0, 1, Z}
o Start State: q0
o Accepting State: (None, accepts by empty stack)
o Initial Stack Symbol: Z
 2. Define transitions:
o δ(q0, ε, Z) = {(q1, SZ)} (Push S on the stack)
o δ(q1, 0, S) = {(q1, 0S1)} (Apply S → 0S1)
o δ(q1, ε, S) = {(q1, A)} (Apply S → A)
o δ(q1, 1, A) = {(q1, 1A0)} (Apply A → 1A0)
o δ(q1, ε, A) = {(q1, S)} (Apply A → S)
o δ(q1, ε, A) = {(q1, ε)} (Apply A → ε)
o δ(q1, 0, 0) = {(q1, ε)} (Match and pop 0)
o δ(q1, 1, 1) = {(q1, ε)} (Match and pop 1)

Explanation: The PDA pushes the start symbol on the stack. For every input, it pops a matching
terminal symbol from the stack. It accepts the string if it can empty the stack.

19.Construct a PDA to accept the language

L= { WCWR|W ∈ {a, b}* }. Draw the graphical representation of this PDA. Show the
moves made by this PDA for the string “aabbaa".
PDA for Palindromes with Center Marker

To construct a PDA to accept the language L = {WCWR | W ∈ {a, b}*}:

1. Define the PDA:

o States: {q0, q1, q2}
o Input Alphabet: {a, b, c}
o Stack Alphabet: {a, b, Z}
o Start State: q0
o Accepting State: q2
o Initial Stack Symbol: Z
2. Define transitions:
o δ(q0, a, Z) = {(q0, aZ)} (Push 'a' on the stack)
o δ(q0, b, Z) = {(q0, bZ)} (Push 'b' on the stack)
o δ(q0, a, a) = {(q0, aa)} (Push 'a' on the stack)
o δ(q0, b, a) = {(q0, ba)} (Push 'b' on the stack)
o δ(q0, a, b) = {(q0, ab)} (Push 'a' on the stack)
o δ(q0, b, b) = {(q0, bb)} (Push 'b' on the stack)
o δ(q0, c, Z) = {(q1, Z)} (Move to q1 on reading 'c')
o δ(q1, a, a) = {(q1, ε)} (Pop 'a' from the stack)
o δ(q1, b, b) = {(q1, ε)} (Pop 'b' from the stack)
o δ(q1, ε, Z) = {(q2, ε)} (Move to accepting state when 'c' is read and stack is
empty)
3. Graphical representation: (Please refer to a standard textbook for drawing a PDA
diagram. The transitions described above can be easily represented in a diagram.)
4. Moves for the string "aabbaa":
 o (q0, aabbaa, Z) → (q0, abbaa, aZ)
o → (q0, bbaa, aaZ)
o → (q0, baa, baaZ)
o → (q0, aa, bbaaZ)
o → (q0, a, abbaaZ)
o → (q0, ε, aabbaaZ)
o → (q1, aabbaa, aabbaaZ)
o → (q1, abbaa, abbaaZ)
o → (q1, bbaa, bbaaZ)
o → (q1, baa, baaZ)
o → (q1, aa, aaZ)
o → (q1, a, aZ)
o → (q1, ε, Z)
o → (q2, ε, ε) (String accepted)

Explanation: The PDA pushes the input symbols onto the stack until it encounters 'c'. Then, it
starts popping symbols from the stack, matching them with the remaining input symbols. If the
stack is empty after processing the entire input, the string is accepted.

20.Define PDA. Design a PDA to accept the following language. L={a^nb^n | n>=0} Draw
the transition diagram for the constructed PDA. Show the ID’s for the string aaabbb.

Defining a PDA and Designing one for {a^nb^n | n>=0}

Definition of a PDA:

A Pushdown Automaton (PDA) is a computational model that extends a Finite Automaton (FA)
by adding a stack. This stack allows the PDA to store and retrieve information, giving it more
computational power than an FA.

Formally, a PDA is defined as a 7-tuple (Q, Σ, Γ, δ, q0, Z, F):

• Q: A finite set of states

• Σ: A finite set of input symbols (input alphabet)
• Γ: A finite set of stack symbols (stack alphabet)
• δ: A transition function that maps Q × (Σ ∪ {ε}) × Γ to a finite subset of Q × Γ*
• q0: The start state (q0 ∈ Q)
• Z: The initial stack symbol (Z ∈ Γ)
• F: A set of accepting states (F ⊆ Q)

Designing a PDA for L = {a^nb^n | n>=0}:

1. Define the PDA:

 o States: {q0, q1, q2}
o Input Alphabet: {a, b}
o Stack Alphabet: {A, Z}
o Start State: q0
o Accepting State: q2
o Initial Stack Symbol: Z
2. Define transitions:
o δ(q0, a, Z) = {(q0, AZ)} (Push 'A' for each 'a' read)
o δ(q0, a, A) = {(q0, AA)} (Push 'A' for each 'a' read)
o δ(q0, b, A) = {(q1, ε)} (Pop an 'A' for each 'b' read)
o δ(q1, b, A) = {(q1, ε)} (Pop an 'A' for each 'b' read)
o δ(q1, ε, Z) = {(q2, ε)} (Move to accepting state when the stack is empty)
3. Transition diagram: (Please refer to a standard textbook for drawing a PDA diagram.
The transitions described above can be easily represented in a diagram.)
4. IDs for the string "aaabbb":
o (q0, aaabbb, Z)
o → (q0, aabbb, AZ)
o → (q0, abbb, AAZ)
o → (q0, bbb, AAAZ)
o → (q1, bb, AAZ)
o → (q1, b, AZ)
o → (q1, ε, Z)
o → (q2, ε, ε) (String accepted)

Explanation:

The PDA pushes an 'A' onto the stack for each 'a' it reads. Then, when it reads 'b's, it pops 'A's
from the stack. Finally, if the number of 'a's and 'b's is equal (indicated by an empty stack), it
moves to the accepting state.

Step-by-step explanation for an engineering student:

1. Understand the problem: The task is to design a PDA that accepts strings with an
equal number of 'a's followed by an equal number of 'b's.
2. Choose the states:
o q0: The initial state where the PDA starts.
o q1: The state for processing 'b's after reading 'a's.
o q2: The accepting state, signifying that the input is valid.
3. Choose the stack alphabet:
o A: Used to count the 'a's.
o Z: The initial stack symbol.
4. Define the transitions: These rules define how the PDA moves between states and
manipulates the stack based on the input:
o For each 'a' read, push an 'A' to count it.
 oFor each 'b' read, pop an 'A' if it's on top of the stack.
oIf all 'a's are matched with 'b's, move to the accepting state.
5. Draw the transition diagram: This visually represents the PDA's operation.
6. Test the PDA: Use a string like "aaabbb" and trace the IDs to see if the PDA accepts
it.
7. Explain the logic: The PDA uses the stack to remember the count of 'a's and
ensures that an equal number of 'b's follow them.

21.Explain the equivalence of PDA & CFG with a proper example.

Equivalence of PDA and CFG

Theorem: A language is context-free if and only if it is accepted by some PDA.

Proof:

• "Only if" part: If a language is context-free, then it is accepted by some PDA.

Theorem 12.1 proves this direction.
• "If" part: If a language is accepted by some PDA, then it is context-free. Theorem
12.2 proves this direction.

Example:

Consider the context-free language AnBn = {anbn : n ≥ 0}.

CFG for AnBn:

S -> aSb
S -> ε

PDA for AnBn:

This PDA can be described in English as follows:

1. Start in state q0 with the stack containing only the start symbol Z0.
2. For each 'a' read from the input:
o Push an 'A' onto the stack and remain in state q0.
3. When the first 'b' is read:
o Transition to state q1 and pop an 'A' from the stack.
 4. For each subsequent 'b' read:
o Pop an 'A' from the stack and remain in state q1.
5. If the input is empty and the stack contains only Z0:
o Transition to state q2 (the accept state).

Module 4

22.Explain Pumping lemma for context free language. Also explain application of CFG

Pumping Lemma for Context-Free Languages

The pumping lemma for context-free languages is a tool used to prove that certain languages are
not context-free. It states that any sufficiently long string in a context-free language can be
"pumped" - divided into specific parts that can be repeated to generate infinitely many other
strings that also belong to the language.

Formal Definition:

If A is a context-free language, then there is a number p (the pumping length) where if s is any
string in A of length at least p, then s may be divided into five pieces s = uvxyz satisfying these
conditions:

1. Pumping: For any i ≥ 0, the string uvixyiz is also in A.

2. Non-emptiness of vy: The substring vy is not empty (|vy| > 0). This ensures that
pumping actually changes the string.
3. Bounded length of vxy: The length of vxy is at most p (|vxy| ≤ p). This limits the
region of the string where pumping occurs.

Applications of CFGs

Context-free grammars have many applications in computer science and other fields:

• Programming Languages: Defining the syntax of programming languages, enabling

compilers to parse code.
 • Natural Language Processing: Modelling the structure of natural languages to help
computers understand and generate human language.
• Parsing: Creating parsers that analyze the structure of text based on grammatical
rules.

23.Find out whether the language L = {0ⁿ1ⁿ2ⁿ | n ≥ 1} is context free or not.

Is L = {0ⁿ1ⁿ2ⁿ | n ≥ 1} Context-Free?

The language L = {0ⁿ1ⁿ2ⁿ | n ≥ 1} is not context-free. This can be proven using the pumping
lemma.

Pumping Lemma for Non-Context-Free Languages

To prove a language L is not context-free using the pumping lemma:

1. Assume that L is context-free. This sets up a proof by contradiction.

2. Let p be the pumping length that is guaranteed to exist if L were context-free.
3. Choose a string s in L that is at least p symbols long and is structured to make
pumping it lead to a contradiction.
4. Demonstrate that s cannot be pumped without violating the pumping lemma's
conditions. This means considering all possible ways to divide s into uvxyz and
showing that, for each division, pumping the string results in a string that is not in L.
This contradiction disproves the initial assumption that L is context-free.

24.Explain Pumping Lemma for the non context free languages. Show that the given
language is non context free; L = {ww |w €{0, 1}*} is not CFL.

Example: Showing L = {ww | w ∈ {0, 1}*} is Not Context-Free

1. Assume L = {ww | w ∈ {0, 1}*} is a context-free language.

2. Let p be the pumping length given by the pumping lemma.
 3. Choose the string s = 0p1p0p1p. This string is clearly in L and its length is greater
than p.
4. Demonstrate that s cannot be pumped:
o No matter how you divide s into uvxyz, the pumped string uv2xy2z will
not be in L. This is because the repeated substring vy will disrupt the
balanced structure of two identical halves required by the language. The
pumping lemma states that uv2xy2z must be in L if L is context-free, so this
creates a contradiction.

Therefore, L = {ww | w ∈ {0, 1}*} cannot be context-free.

25.Use Pumping Lemma to show that aⁱbʲcᵏ for i<j<k for CFL.

Is aⁱbʲcᵏ for i < j < k Context-Free?

The language aⁱbʲcᵏ where i < j < k is not context-free. This can be proven using the pumping
lemma.

Proof:

1. Assume the language L = {aⁱbʲcᵏ | i < j < k} is context-free.

2. Let p be the pumping length provided by the pumping lemma.
3. Choose the string s = apbp+1cp+2. This string belongs to L and has length greater
than p.
4. Demonstrate that s cannot be pumped:
o Consider all possible divisions of s into uvxyz. Due to the length constraint |vxy|
≤ p, the substring vxy can span at most two of the three symbol groups ('a', 'b', 'c').
o Analyze each case and show that pumping leads to a contradiction:
▪ If vy contains only 'a's: Pumping up increases 'a's but not 'b's or 'c's,
violating i < j < k.
▪ If vy contains only 'b's: Pumping up increases 'b's but not 'c's enough
to maintain j < k.
▪ If vy contains only 'c's: Pumping up increases 'c's but not 'a's or 'b's
enough to maintain i < j < k.
▪ If vy spans 'a's and 'b's: Pumping may maintain i < j, but will violate j <
k.
▪ If vy spans 'b's and 'c's: Pumping may maintain j < k, but will violate i
< j.
o In all cases, pumping s results in a string that is not in L. This contradicts the
pumping lemma's requirement that uvixyiz be in L for all i ≥ 0.

Therefore, the language aⁱbʲcᵏ for i < j < k is not context-free.