Scribd
Upload
295 views18 pages

3.3 Push-Down Automata

Push-down automata (PDAs) are finite state machines that use a stack to "remember" information while processing input. A PDA configuration consists of a state, remaining input, and stack contents. An input is accepted if the PDA reaches a final state with an empty stack after processing. PDAs can recognize context-free languages by pushing symbols onto the stack as needed and popping them off later to check for matching patterns in the input.

Uploaded by

tigistye
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
295 views18 pages

3.3 Push-Down Automata

Push-down automata (PDAs) are finite state machines that use a stack to "remember" information while processing input. A PDA configuration consists of a state, remaining input, and stack contents. An input is accepted if the PDA reaches a final state with an empty stack after processing. PDAs can recognize context-free languages by pushing symbols onto the stack as needed and popping them off later to check for matching patterns in the input.

Uploaded by

tigistye
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 18

Push-down Automata

Section 3.3
Fri, Oct 21, 2005
Push-Down Automata
 Recall that DFAs accept regular languages.
 We want to design machines similar to DFAs that
will accept context-free languages.
 These machines will need to be more powerful.
 To handle a language like {anbn | n  0}, the machine
needs to “remember” the number of as.
 To do this, we use a stack.
 A push-down automaton (PDA) is essentially an NFA
with a stack.
Definition of a Push-Down Automaton
 A push-down automaton (PDA) is a sextuple (K, Σ, Γ,
Δ, s, F) where
 K is a finite set of states.
 Σ is a finite alphabet of tape symbols.
 Γ is a finite alphabet of stack symbols.
 s  K is the start state.
 F  K is the set of final states.
 Δ is the transition relation, i.e., Δ is a finite subset of
(K  (Σ  {e})  Γ*)  (K  Γ*).
Transitions
 Let ((p, a, β), (q, γ))  Δ be a transition.
 It means that we
 Move from state p.
 Read a from the tape,
 Pop the string β from the stack,
 Move to state q,
 Push string γ onto the stack.
 The first three (p, a, β), are “input.”
 The last two (q, γ) are “output.”
Transitions
 We will draw it as

a, ; 
p q
Pushing and Popping
 When we push β, we push the symbols of β as we
read them right to left.
 When we push the string abc, we push c, then push b, then
push a.
 When we pop γ, we pop the symbols of γ as we read
them from left to right (reverse order).
 When we pop the string abc, we pop a, then pop b, then
pop c.
Pushing and Popping
 Thus, if we push the string abc and then pop it, we
will get back abc, not cba.
 If we wanted to reverse the order, we would use three
separate transitions:
 Push a
 Push b
 Push c
Configurations
 A configuration fully describes the current “state” of
the PDA.
 The current state p.
 The remaining input w.
 The current stack contents .
 Thus, a configuration is a triple
(p, w, )  (K, *, *).
Computations
 A configuration (p, w, ) yields a configuration
(p', w', ') in one step, denoted
(p, w, )  (p', w', '),
if there is a transition ((p, a, ), (p', ))  Δ such that
w = aw',  = , and ' =  for some   *.
 The reflexive, transitive closure of  is denoted *.
Accepting Strings
 After processing the string on the tape,
 The PDA is in either a final or a nonfinal state, and
 The stack is either empty or not empty.
 The input string is accepted if
 The ending state is a final state, and
 The stack is empty.
 That is, the string w  * is accepted if
(s, w, e) * (f, e, e)
for some f  F.
Accepting Strings
 One may define acceptance “by final state” only.
 The input is accepted if and only if the last state is a final
state, regardless of whether the stack is empty.
 One may define acceptance “by empty stack” only.
 The input is accepted if and only if the stack is empty once
the input is processed, regardless of which state the PDA is
in.
Example of a PDA
 Run the following PDA on the input string aaabbb.

a, e; a

a, e; a b, a; e
s p q

b, a; e
Example of a PDA
 The steps in the processing are
 (s, aaabbb, e)  (p, aabbb, a)
 (p, abbb, aa)
 (p, bbb, aaa)
 (p, bb, aa)
 (p, b, a)
 (q, e, e).
The Language of a PDA
 The language of a PDA A is
L(A) = {w  *A accepts w}.
 What is the language of the PDA in the previous
example?
Example of a PDA
 What is the language of the following PDA?

a, e; a b, a; e

e, e; e
s p
Examples of PDAs
 Let  = {a, b}.
 Design a PDA that accepts the language

{wcwR | w  *}.
 Design a PDA that accepts the language

{wwR | w  *}.
Examples of PDAs
 Design a PDA whose language is
{ambn  0  m < n}.
 Design a PDA whose language is

{ambn  0  n < m}.


Examples of PDAs
 Design a PDA whose language is
{ambncndm | m  0, n  0}.
 Design a PDA whose language is

{ambmcndn | m  0, n  0}.
 Design a PDA whose language is

{ambncpdq | m + n = p + q}.
 Design a PDA whose language is

{ambnck | m = n or m = k}.

You might also like