```CS 3240 – Chapter 7
Language
Machine
Grammar
Regular
Finite Automaton
Regular Expression,
Regular Grammar
Context-Free
Pushdown Automaton
Context-Free
Grammar
Recursively
Enumerable
Turing Machine
Unrestricted PhraseStructure Grammar
CS 3240 - Introduction
2

Take an FA and add a stack
 A restricted form of unbounded memory

Operations:
 Pop
 Push
 Ignore (λ)
 (Pop always precedes push)
CS 3240 - Pushdown Automata
3

Three items per transition edge
 any or all could be λ

A PDA accepts when:
 An accepting state is reached, and
 The stack is empty
▪ Different from book!
▪
The machine crashes when no move is possible
▪ implicit jail
CS 3240 - Pushdown Automata
4
A deterministic PDA (no choices; λ is okay
sometimes). The stack alphabet (Γ = {X}) can
differ from the input alphabet (Σ = {a, b}) .
Trace aabb…
CS 3240 - Pushdown Automata
5
q0
q0
q0
q1
q1
aabb
abb
bb
b
λ
λ
X
XX
X
λ
(q0,aabb, λ) ⊢ (q0,abb,X) ⊢ (q0,bb,XX) ⊢ (q1,b,X) ⊢ (q1,λ, λ)
Also: (q0,aabb,λ) ⊢* (q1,λ, λ)
CS 3240 - Pushdown Automata
(⇒ aabb ∈ L)
6
CS 3240 - Pushdown Automata
7
How would you do a2nbn?
CS 3240 - Pushdown Automata
8
Each b must pop 2 X’s
CS 3240 - Pushdown Automata
9
Is this deterministic?
Trace the string abaacaaba.
CS 3240 - Pushdown Automata
10


Input: (state-1, input character, pop character)
Output: (state-2, push character(s))

Example: The edge (a,λ,a) on previous slide:
δ(q0,a,λ) = (q0,a)

Exercise:
 Rewrite wcwR in functional form
CS 3240 - Pushdown Automata
11
Is this deterministic?
Trace the string abaaaaaba.
Trace the string abaabaaba.
Trace the string abaaaaba.
CS 3240 - Pushdown Automata
12
The grammar:
S → aSb | aSbb | λ
Trace aaabbbb
CS 3240 - Pushdown Automata
13
Trace ababbaab
CS 3240 - Pushdown Automata
14
CS 3240 - Pushdown Automata
15
Reasoning: There must be 2
b’s for every a. When we read
an a, there are three
possibilities:
1)Its 2 b’s have already been
2)1 b has been read and 1
remains
3)Both b’s are yet to be read
Try abababbbb.
How would you do Twicea?
CS 3240 - Pushdown Automata
16
CS 3240 - Pushdown Automata
17
CS 3240 - Pushdown Automata
18
CS 3240 - Pushdown Automata
19

Q: set of states
∑: input alphabet
Γ: stack alphabet
δ: Q x (∑∪λ) x (Γ∪λ) → finite subsets of Q x Γ*
q0: start state
F ⊆ Q: final states

(z ⋲ Γ: optional stack start symbol)





CS 3240 - Pushdown Automata
20

Not strictly necessary
 Can serve as a “bottom marker” to allow
detection of an empty stack

A convenience
 Can make things easier to design/understand
 Sometimes handy when seeking an associated
CFG
 Can eliminate some lambda pops
▪ Handy later
CS 3240 - Pushdown Automata
21
CS 3240 - Pushdown Automata
22
CS 3240 - Pushdown Automata
23
CS 3240 - Pushdown Automata
24
CS 3240 - Pushdown Automata
25





How do we know that PDAs are the correct
machine model for CFLs?
1) Must show that for any CFG, there is a PDA
that accepts its language
2) Must show that for any PDA, there is a CFG
that generates its language
The first case is easier than the second!
It can be handy to go back and forth
CS 3240 - Pushdown Automata
26

The LHS variable is popped
The RHS string is pushed
Initial transition pushes S

See next slide



CS 3240 - Pushdown Automata
27
CS 3240 - Pushdown Automata
28
CS 3240 - Pushdown Automata
29


Very trivial (Yay!)
But the (2-state) PDA is non-deterministic
 State-2 is a final state


1) Push S on the stack; move to state-2
2) For every rule, have a transition that:
 pops the left-hand side and pushes the right-hand side

3) For every character, c, in Σ, have a rule that:
 consumes and pops c simultaneously
CS 3240 - Pushdown Automata
30
S → aSb | aSbb | λ
Trace aaabbbbb: (q0,aaabbbbb,λ) ⊢ (q1,aaabbbbb,S) ⊢
(q1,aaabbbbb,aSbb) ⊢ (q1,aabbbbb,Sbb) ⊢ (q1,aabbbbb,aSbbbb) ⊢
(q1,abbbbb,Sbbbb) ⊢ (q1,abbbbb,aSbbbbb) ⊢ (q1,bbbbb,Sbbbbb) ⊢
(q1,bbbbb,bbbbb) ⊢* (q1,λ,λ)
CS 3240 - Pushdown Automata
31
S → aSbSbS | bSaSbS | bSbSaS | λ
…
And trace bbabaabbb
CS 3240 - Pushdown Automata
32
S => (S) | SS | λ
Derive ()(()) from the grammar.
Then accept it by the machine.
Then find a one-state DPDA for this language.
CS 3240 - Pushdown Automata
33



We need to relate PDA movement to a CFG
production rule somehow
Key: consuming a character in the PDA
corresponds to generating a character in the
CFG
The stack contents must also be part of all
this
CS 3240 - Pushdown Automata
34

PDAs of the form below have a natural
translation to a CFG
 the reverse of CFG-to-PDA conversion
 (conveniently) call the stack start symbol S
 Translate each transition in state-2 into a rule:
▪ c,X,Y ⟺ X → cY
(i.e., <pop> → <char> <push>)
▪ (X cannot be λ)
CS 3240 - Pushdown Automata
35
S → aXS | bYS | λ
X → aXX | bYX | b
Y → bYY | aXY | a
Derive abbbaaba
CS 3240 - Pushdown Automata
36
Go back and find grammars for slides 22,24-25.
Also, work backward from the (()) DPDA to a grammar.
CS 3240 - Pushdown Automata
37



We must also track state changes
Our variables must therefore contain state
and stack information
Very tricky!
CS 3240 - Pushdown Automata
38
Suppose X is on the stack and ‘a’ is read
 What can happen to X?

 It will be popped (and possibly put back)
 It may be replaced by one or more other stack symbols
▪ Which symbols will also later be popped, replaced, etc…
▪ The stack grows and shrinks and grows and shrinks …
 Eventually, as more input is consumed, the effect of having
pushed X on the stack must be erased (or we’ll never reach
an empty stack!)
 And the state may change many times!
CS 3240 - Pushdown Automata
39
… (qi, x1x2…xk, Y1Y2…Yk) ⊢* (qj, x2…xk, Y2…Yk) ⊢* (qn, xk, Yk) ⊢* (qf, λ, λ)
CS 3240 - Pushdown Automata
40

Let the symbol <qAp> represent the sequence of
movements in a PDA that:
 starts in state q
 eventually ends in state p
 eventually removes A and its after-effects from the stack
The symbol <sλf> then represents accepting a valid
string (if s is the start state and f is a final state)
 These symbols will be our variables

 Because they track the machine configuration that accepts
strings
 Just as the grammar will generate those strings
CS 3240 - Pushdown Automata
41

Consider the transition δ(q,a,X) = (p,Y)
 This means that a is consumed, X is popped, we move
directly to state p, and subsequent processing must
eventually erase Y and its follow-on effects

A corresponding grammar rule is:
 <qX?> → a<pY?> (?’s represent the same state)
 We don’t know where we’ll eventually end up when the
stack is back to where it was before the X was first pushed
 All we know is we immediately go through p
 So we entertain all possibilities (see 3 and 4 on next slide)
CS 3240 - Pushdown Automata
42


1) S → <sλf> for all final states, f
2) <qλq> → λ for all states, q
 These will serve as terminators

3) For transitions δ(q,a,X) = (p,Y):
 <qXr> → a<pYr> for all states, r

4) For transitions δ(q,a,X) = (p,Y1Y2):
 <qXr> → a<pY1s><sY2r> for all states, r, s
 And so on, for longer pushed strings
CS 3240 - Pushdown Automata
43

The process requires:
 No multiple pops
▪ So spread them out over multiple states if needed

Also, for every lambda-pop c,λ,X:
 Add an equivalent rule for each letter of Γ (the stack
alphabet) as follows:
▪ (c,X,XX)
▪ (c,Y,XY)
▪ etc.
▪ And keep the original lambda pop!!!
CS 3240 - Pushdown Automata
44
• Call the start state, s, and the final state, f.
• Add the following transition on s: (a,X,XX)
• 1) S → <sλf>
• 2) <sλs> → λ; <fλf> → λ
• Now go through each transition…
CS 3240 - Pushdown Automata
45
δ(s,a,λ) = (s,X):
1.


<sλs> → a<sXs>
<sλf> → a<sXf>
δ(s,a,X) = (s,XX):
2.




<sXs> → a<sXs><sXs>
<sXf> → a<sXs><sXf>
<sXs> → a<sXf><fXs>
<sXf> → a<sXf><fXf>
CS 3240 - Pushdown Automata
46
δ(s,b,X) = (f,λ):
3.


<sXs> → b<fλs>
<sXf> → b<fλf>
δ(f,b,X) = (f,λ):
4.


<fXs> → b<fλs>
<fXf> → b<fλf>
CS 3240 - Pushdown Automata
47
S → <sλf>
<sλs> → a<sXs> | λ
<fλf> → λ
<sλf> → a<sXf>
<sXs> → a<sXs><sXs>
<sXf> → a<sXs><sXf> | a<sXf><fXf> | b<fλf>
<fXf> → b<fλf>
CS 3240 - Pushdown Automata
48
S → <sλf>
<sλs> → a<sXs> | λ
<sλf> → a<sXf>
<sXs> → a<sXs><sXs>
<sXf> → a<sXs><sXf> | a<sXf><fXf> | b
<fXf> → b
CS 3240 - Pushdown Automata
49
S → <sλf>
<sλf> → a<sXf>
<sXf> → a<sXf><fXf> | b
<fXf> → b
CS 3240 - Pushdown Automata
50
S → a<sXf>
<sXf> → a<sXf><fXf> | b
<fXf> → b
CS 3240 - Pushdown Automata
51
S → a<sXf>
<sXf> → a<sXf>b | b
CS 3240 - Pushdown Automata
52
S → aX
X → aXb | b
Done! (finally :-)
CS 3240 - Pushdown Automata
53

Find a CFG for nb = na + 1 using the generic
conversion process
CS 3240 - Pushdown Automata
54

A PDA is deterministic if there are no choices:
 Depends on a state’s <character, pop symbol> pair:
 1) δ(q,a,X) has only one choice (a could be λ), and
 2) If a is not λ, then there is no δ(q,λ,X) edge, and
 3) if X is not λ, then there is no δ(q,a,λ) edge.

NOTE: Some PDAs are inherently nondeterministic (no deterministic equivalent, e.g.,
wwR)
CS 3240 - Pushdown Automata
55

Revisit previous PDAs and check for
determinacy
CS 3240 - Pushdown Automata
56
Languages accepted by
nondeterministic PDA
Languages
accepted by DFA
Languages accepted by
deterministic PDA
CS 3240 - Pushdown Automata
57
```