Pushdown Automata

1. CS 3240 – Chapter 7 Pushdown Automata

2. Where Are We? CS 3240 - Introduction

3. A Pushdown AutomatonMachine for Context-Free Languages • 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

4. PDA Operations • 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 CS 3240 - Pushdown Automata

5. A PDA for anbn (n > 0) 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

6. Tracing the PDA(<state> | <input> | <stack>) q0 aabb λ q0 abb X q0 bb XX q1 b X q1 λ λ Traditional notation (see book): (q0,aabb, λ) ⊢ (q0,abb,X) ⊢ (q0,bb,XX) ⊢ (q1,b,X) ⊢ (q1,λ, λ) Also: (q0,aabb,λ) ⊢*(q1,λ, λ) (⇒ aabb ∈ L) CS 3240 - Pushdown Automata

7. A PDA for anbn (n ≥ 0) CS 3240 - Pushdown Automata

8. A PDA for anb2n (n ≥ 0) How would you do a2nbn? CS 3240 - Pushdown Automata

9. a2nbn Each b must pop 2 X’s CS 3240 - Pushdown Automata

10. A PDA for wcwR Is this deterministic? Trace the string abaacaaba. CS 3240 - Pushdown Automata

11. Transition Functions for PDAs • 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

12. A PDA for All Palindromes Is this deterministic? Trace the string abaaaaaba. Trace the string abaabaaba. Trace the string abaaaaba. CS 3240 - Pushdown Automata

13. A PDA for ambn, m ≤ n ≤ 2mNon-deterministic The grammar: S → aSb | aSbb | λ Trace aaabbbb CS 3240 - Pushdown Automata

14. A PDA for Equal Trace ababbaab CS 3240 - Pushdown Automata

15. A PDA for nb = na + 1 CS 3240 - Pushdown Automata

16. A PDA for Twicebnb = 2na • Reasoning: There must be 2 b’s for every a. When we read an a, there are three possibilities: • Its 2 b’s have already been read • 1 b has been read and 1 remains • Both b’s are yet to be read Try abababbbb. How would you do Twicea? CS 3240 - Pushdown Automata

17. What Language Is This? CS 3240 - Pushdown Automata

18. aibjck, i,j,k ≥ 0, i = jor i = k CS 3240 - Pushdown Automata

19. anor anbn CS 3240 - Pushdown Automata

20. Formal Definition of PDAs • 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

21. Using Stack Start Symbols • 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

22. anbn with a Start Symbol CS 3240 - Pushdown Automata

23. A PDA for EqualUsing a Stack Start Symbol (“Almost” Deterministic) CS 3240 - Pushdown Automata

24. xxR (Even Palindrome) CS 3240 - Pushdown Automata

25. anbm, n ≤ m≤ 2n CS 3240 - Pushdown Automata

26. PDAs and Context-Free LanguagesSection 7.2 • 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

27. From Greibach Form to PDA • The leading character is read • The LHS variable is popped • The RHS string is pushed • Initial transition pushes S • See next slide CS 3240 - Pushdown Automata

28. CFG to PDA ExampleFrom Greibach Form CS 3240 - Pushdown Automata

29. CFG to PDA ExampleFrom Greibach Form II CS 3240 - Pushdown Automata

30. CFG => PDAGeneral Case • 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

31. Without Greibach FormFor Lazy People 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

32. Now You Do One S → aSbSbS | bSaSbS | bSbSaS | λ … And trace bbabaabbb CS 3240 - Pushdown Automata

33. One More 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

34. PDA => CFG • 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

35. Special Case • 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

36. PDA-to-CFG ExampleEQUAL S → aXS | bYS | λ X → aXX | bYX | b Y → bYY | aXY | a Derive abbbaaba CS 3240 - Pushdown Automata

37. Exercise Go back and find grammars for slides 22,24-25. Also, work backward from the (()) DPDA to a grammar. CS 3240 - Pushdown Automata

38. PDA => CFGGeneral Case • We must also track state changes • Our variables must therefore contain state and stack information • Very tricky! CS 3240 - Pushdown Automata

39. PDA => CFGContinued • 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

40. Observing a PDA(Source: Aho et al) … (qi, x1x2…xk, Y1Y2…Yk) ⊢*(qj, x2…xk, Y2…Yk) ⊢*(qn, xk, Yk) ⊢*(qf, λ, λ) CS 3240 - Pushdown Automata

41. Converting from PDA to CFG • 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

42. Converting from PDA to CFGcontinued • 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 throughp • So we entertain all possibilities (see 3 and 4 on next slide) CS 3240 - Pushdown Automata

43. From Transitions to Grammar Rules4 types of rules generated • 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

44. Preparing a Grammar for Conversion • 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

45. Convert PDA for anbn (n > 0) • 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

46. Converting Transitions to Rules • δ(s,a,λ) = (s,X): • <sλs> → a<sXs> • <sλf> → a<sXf> • δ(s,a,X) = (s,XX): • <sXs> → a<sXs><sXs> • <sXf> → a<sXs><sXf> • <sXs> → a<sXf><fXs> • <sXf> → a<sXf><fXf> CS 3240 - Pushdown Automata

47. Converting Transitions to RulesContinued • δ(s,b,X) = (f,λ): • <sXs> → b<fλs> • <sXf> → b<fλf> • δ(f,b,X) = (f,λ): • <fXs> → b<fλs> • <fXf> → b<fλf> CS 3240 - Pushdown Automata

48. What’s Left? • 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

49. SimplifySubstitute lambda for <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 CS 3240 - Pushdown Automata

50. Simplify<sλs> is unreachable; <sXs> doesn’t terminate • S → <sλf> • <sλf> → a<sXf> • <sXf> → a<sXf><fXf> | b • <fXf> → b CS 3240 - Pushdown Automata