UNIT-4

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.
PDA Components:
Input tape: The input tape is divided in many cells or symbols. The input head is read-only and
may only move from left to right, one symbol at a time.

Finite control: The finite control has some pointer which points the current symbol which is to
be read.

Stack: The stack is a structure in which we can push and remove the items from one end only. It
has an infinite size. In PDA, the stack is used to store the items temporarily.

Formal definition of PDA:

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

δ: mapping function which is used for moving from current state to next state.

Instantaneous Description (ID)

ID is an informal notation of how a PDA computes an input string and make a decision that
string is accepted or rejected.

An instantaneous description is a triple (q, w, α) where:

q describes the current state.

w describes the remaining input.

α describes the stack contents, top at the left.

Turnstile Notation:
 ⊢sign describes the turnstile notation and represents one move.

⊢* sign describes a sequence of moves.

For example,

(p, b, T) ⊢ (q, w, α)

In the above example, while taking a transition from state p to q, the input symbol 'b' is
consumed, and the top of the stack 'T' is represented by a new string α.

Example 1:
Design a PDA for accepting a language {anb2n | n>=1}.

Solution: In this language, n number of a's should be followed by 2n number of b's. Hence, we
will apply a very simple logic, and that is if we read single 'a', we will push two a's onto the stack.
As soon as we read 'b' then for every single 'b' only one 'a' should get popped from the stack.

The ID can be constructed as follows:

1. δ(q0, a, Z) = (q0, aaZ)  
2. δ(q0, a, a) = (q0, aaa)  

Now when we read b, we will change the state from q0 to q1 and start popping corresponding
'a'. Hence,

1. δ(q0, b, a) = (q1, ε)  

Thus this process of popping 'b' will be repeated unless all the symbols are read. Note that
popping action occurs in state q1 only.

1. δ(q1, b, a) = (q1, ε)  

After reading all b's, all the corresponding a's should get popped. Hence when we read ε as
input symbol then there should be nothing in the stack. Hence the move will be:

1. δ(q1, ε, Z) = (q2, ε)  

Where

PDA = ({q0, q1, q2}, {a, b}, {a, Z}, δ, q0, Z, {q2})

We can summarize the ID as:

1. δ(q0, a, Z) = (q0, aaZ)  
2. δ(q0, a, a) = (q0, aaa)  
3. δ(q0, b, a) = (q1, ε)  
4. δ(q1, b, a) = (q1, ε)  
5. δ(q1, ε, Z) = (q2, ε)  

Now we will simulate this PDA for the input string "aaabbbbbb".

1. δ(q0, aaabbbbbb, Z) ⊢ δ(q0, aabbbbbb, aaZ)  
2.                     ⊢ δ(q0, abbbbbb, aaaaZ)  
3.                     ⊢ δ(q0, bbbbbb, aaaaaaZ)  
4.                     ⊢ δ(q1, bbbbb, aaaaaZ)  
5.                     ⊢ δ(q1, bbbb, aaaaZ)  
6.                     ⊢ δ(q1, bbb, aaaZ)  
7.                     ⊢ δ(q1, bb, aaZ)  
8.                     ⊢ δ(q1, b, aZ)  
9.                     ⊢ δ(q1, ε, Z)  
10.                     ⊢ δ(q2, ε)        
11.                       ACCEPT  

Example 2:
Design a PDA for accepting a language {0n1m0n | m, n>=1}.

Solution: In this PDA, n number of 0's are followed by any number of 1's followed n number of
0's. Hence the logic for design of such PDA will be as follows:

Push all 0's onto the stack on encountering first 1's. Then if we read 1, just do nothing. Then
read 0, and on each read of 0, pop one 0 from the stack.

For instance:
 This scenario can be written in the ID form as:

1. δ(q0, 0, Z) = δ(q0, 0Z)  
2. δ(q0, 0, 0) = δ(q0, 00)  
3. δ(q0, 1, 0) = δ(q1, 0)  
4. δ(q0, 1, 0) = δ(q1, 0)  
5. δ(q1, 0, 0) = δ(q1, ε)  
6. δ(q1, ε, Z) = δ(q2, Z)      (ACCEPT state)  

Now we will simulate this PDA for the input string "0011100".

1. δ(q0, 0011100, Z) ⊢ δ(q0, 011100, 0Z)  
2.                   ⊢ δ(q0, 11100, 00Z)  
3.                   ⊢ δ(q0, 1100, 00Z)  
4.                   ⊢ δ(q1, 100, 00Z)  
5.                   ⊢ δ(q1, 00, 00Z)  
6.                   ⊢ δ(q1, 0, 0Z)  
7.                   ⊢ δ(q1, ε, Z)  
8.                   ⊢ δ(q2, Z)  
9.                     ACCEPT  
here are two different ways to define PDA acceptability.

Final State Acceptability

In final state acceptability, a PDA accepts a string when, after reading the entire string, the
PDA is in a final state. From the starting state, we can make moves that end up in a final state
with any stack values. The stack values are irrelevant as long as we end up in a final state.
For a PDA (Q, ∑, S, δ, q0, I, F), the language accepted by the set of final states F is −
L(PDA) = {w | (q0, w, I) ⊢* (q, ε, x), q ∈ F}
for any input stack string x.

Empty Stack Acceptability

Here a PDA accepts a string when, after reading the entire string, the PDA has emptied its
stack.
For a PDA (Q, ∑, S, δ, q0, I, F), the language accepted by the empty stack is −
L(PDA) = {w | (q0, w, I) ⊢* (q, ε, ε), q ∈ Q}