1 / 57

Pushdown Automata

CS 3240 – Chapter 7. Pushdown Automata. Where Are We?. A Pushdown Automaton Machine 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). PDA Operations.

admon
Télécharger la présentation

Pushdown Automata

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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

More Related