pushdown automata

CS 3240 – Chapter 7

Language Machine GrammarRegular Finite Automaton Regular

Expression,Regular Grammar

Context-Free Pushdown Automaton

Context-Free Grammar

Recursively Enumerable

Turing Machine Unrestricted Phrase-Structure Grammar

2CS 3240 - Introduction

Take an FA and add a stack A restricted form of unbounded memory

Operations: Pop Push Ignore (λ) (Pop always precedes push)

3CS 3240 - Pushdown Automata

Three items per transition edge <read>,<pop>,<push> 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


A deterministic PDA (no choices; λ is okay sometimes). The stack alphabet (Γ = {X}) can differ from the input alphabet (Σ = {a, b}) .

Trace aabb…5CS 3240 - Pushdown Automata

q0 aabb λq0 abb Xq0 bb XXq1 b Xq1 λ λ


Traditional notation (see book):

(q0,aabb, λ) ⊢ (q0,abb,X) ⊢ (q0,bb,XX) ⊢ (q1,b,X) ⊢ (q1,λ, λ)

Also: (q0,aabb,λ) ⊢* (q1,λ, λ) (⇒ aabb ∈ L)


How would you do a2nbn?

CS 3240 - Pushdown Automata 9

Each b must pop 2 X’s

Is this deterministic?

Trace the string abaacaaba.


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


Is this deterministic?Trace the string abaaaaaba.Trace the string abaabaaba.Trace the string abaaaaba.



Trace aaabbbb

The grammar:

S → aSb | aSbb | λ


Trace ababbaab


Try abababbbb.How would you do Twicea?

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 read2)1 b has been read and 1 remains3)Both b’s are yet to be read

Q: set of states∑: input alphabetΓ: stack alphabetδ: Q x (∑∪λ) x (Γ∪λ) → finite subsets

of Q x Γ*

q0: start stateF ⊆ 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


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 forthCS 3240 - Pushdown Automata 26

The leading character is readThe LHS variable is poppedThe RHS string is pushed Initial transition pushes S

See next slide


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



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,λ,λ)


S → aSbSbS | bSaSbS | bSbSaS | λ… And trace bbabaabbb


S => (S) | SS | λ

Derive ()(()) from the grammar.Then accept it by the machine.Then find a one-state DPDA for this language.

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


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 λ)



S → aXS | bYS | λX → aXX | bYX | bY → bYY | aXY | a

Derive abbbaaba


Go back and find grammars for slides 22,24-25.

Also, work backward from the (()) DPDA to a grammar.

We must also track state changesOur variables must therefore contain

state and stack informationVery tricky!


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, λ, λ) 40CS 3240 - Pushdown Automata

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


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)42CS 3240 - Pushdown Automata

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 strings43CS 3240 - Pushdown Automata

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!!!



• 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…


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>


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


S → <sλf><sλf> → a<sXf><sXf> → a<sXf><fXf> | b<fXf> → b


S → a<sXf><sXf> → a<sXf><fXf> | b<fXf> → b


S → a<sXf><sXf> → a<sXf>b | b


S → aXX → aXb | b

Done! (finally :-)

Find a CFG for nb = na + 1 using the generic conversion process


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 non-deterministic (no deterministic equivalent, e.g., wwR)


Revisit previous PDAs and check for determinacy


Languages accepted bynondeterministic PDA

Languages accepted bydeterministic PDA

Languages accepted by DFA


pushdown automata

Documents

pushdown automatacs

pushdown automatais

pushdown automatahow

pushdown automatainput

pushdown automatanot

pushdown automatathree

s asb asbb cs

trace aabb