2. 2 Pushdown Automata

1. 2.2 Pushdown Automata • Pushdown Automata • CFG = PDA • Deterministic PDA

2. Machine View of FA input tape 0 1 1 1 1 0 0 1 1 0 0 0 1 0 1 q0 finite control

3. Machine View of FA input tape 0 1 1 1 1 0 0 1 1 0 0 0 1 0 1 q3 finite control

4. Machine View of FA input tape 0 1 1 1 1 0 0 1 1 0 0 0 1 0 1 q1 finite control

5. Machine View of FA input tape 0 1 1 1 1 0 0 1 1 0 0 0 1 0 1 q2 finite control etc…

6. A More Powerful Machine • limitation of FA related to fact that they can only “remember” a bounded amount of information • What is the simplest alteration that adds unbounded “memory” to our machine? • Should be able to recognize, e.g., {0n1n: n ≥ 0}

7. Pushdown Automata input tape finite control 1 1 0 0 1 1 0 0 0 1 0 1 0 1 1 q0 • New capabilities: • can push symbol onto stack • can pop symbol off stack 0 (infinite) stack 1 1 0 :

8. Pushdown Automata input tape finite control 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 q0 Note: often start by pushing $ marker onto stack so that we can detect “empty stack” $ (infinite) stack :

9. Pushdown Automata input tape finite control 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 q1 0 (infinite) stack $ :

10. Pushdown Automata input tape finite control 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 q1 0 (infinite) stack 0 $ :

11. Pushdown Automata input tape finite control 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 q2 0 (infinite) stack $ :

12. Pushdown Automata input tape finite control 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 q2 $ (infinite) stack :

13. Pushdown Automata (PDA) • We will define nondeterministic PDA immediately • potentially several choices of “next step” • essentially an -NFA with a stack • Deterministic PDA defined later • weaker than NPDA • Two ways to describe NPDA • diagram • formal definition

14. NPDA Diagram transition: input symbol read, stack symbol popped → stack symbol pushed 0, ε→ 0 ε, ε→ $ 1, 0 →ε ε, $ →ε 1, 0 →ε

15. NPDA Operation • Taking a transition labeled: a, b → c • a (Σ {ε}) Σ: input alphabet • b,c ( {ε}) : stack alphabet • read a from input, or don’t read from input if a =ε • pop b from stack, or don’t pop from stack if b = ε • push c onto stack, or don’t push onto stack if c =ε

16. Example NPDA Σ = {0, 1}  = {0, 1, $} What language does this NPDA accept? 0, ε→ 0 ε, ε→ $ 1, 0 →ε ε, $ →ε 1, 0 →ε Input: 0011 001 0101

17. Formal Definition of NPDA • A NPDA is a 6-tuple (Q, Σ, , δ, q0, F) where: • Q is a finite set of states • Σ is a finite input alphabet •  is a finite stack alphabet • δ: Q x (Σ{ε}) x ({ε}) → (Q x ({ε})) is the transition function • q0 is an element of Q called the start state • F is a subset of Q called the accepting states

18. Example of Formal Definition 0, ε→ 0 ε, ε→ $ • Q = {q0, q1, q2, q3} • Σ = {0, 1} •  = {0, 1, $} • F = {q0, q3} q0 q1 1, 0 →ε ε, $ →ε q3 q2 1, 0 →ε δ(q0, ε, ε) = {(q1, $)} δ(q1, 0, ε) = {(q1, 0)} δ(q1, 1, 0) = {(q2, ε)} δ(q2, 1, 0) = {(q2, ε)} δ(q2, ε, $) = {(q3, ε)}

19. Exercises • {aibjck | i, j, k ≥ 0 and i = j or i = k} • {wwR | w{0, 1}*}

20. Instantaneous Descriptions • To reason about PDA computation, we use Instantaneous Descriptions (ID) of the PDA. An ID is a triple: (q, w, ) where q is the state, w the remaining input, and  the stack content. • If (p, Y)δ(q, a, X), then we denote (q, aw, X) |− (p, w, Y) • We define |−* to be the reflexive-transitive closure of |−.

21. NPDA Computation Example 2.11 (q1, 0110, ε) (q2, 0110, $) (q2, 110, 0$) (q2, 10, 10$) (q2, 0, 110$) (q2, ε, 0110$) (q3, 0110, $) (q3, 110, 0$) (q3, 10, 10$) (q3, 0, 110$) (q3, ε, 0110$) (q3, 0, 0$) (q3, ε, $) (q4, ε, ε)

22. Acceptance by Final State and by Empty Stack • Acceptance by final state (q0, w, $) |−* (p, ε, ) p in F • Acceptance by empty stack (q0, w, $) |−* (p, ε, ε) • They are equivalent

23. 2.2 Pushdown Automata • Pushdown Automata • CFG = PDA • Deterministic PDA

24. Equivalence of NPDA and CFG Theorem 2.12: a language is context free iff some pushdown automaton recognizes it. Must prove twodirections: • L is recognized by a NPDA  L is described by a CFG. • L is described by a CFG  L is recognized by a NPDA.

25. From CFG to NPDA Proof of ():L is described by a CFG implies L is recognized by a NPDA. an initial idea to design an NPDA from the CFG: • start from the start symbol; non-deterministically guess the derivation, and form it on the stack • compare the resulting terminal string with the input string; accept if they are identical

26. From CFG to NPDA • What is wrong with this approach? • only have access to the top of stack • Allow to match stack terminals with the input during the process of producing the derivation on the stack

27. From CFG to NPDA • informal description of construction: • place $ and start symbol S on the stack • repeat: • if the top of the stack is a non-terminal A, pick a production with A on the lhs and substitute the rhs for A on the stack • if the top of the stack is a terminal b, read b from the input, and pop b from the stack. • if the top of the stack is $, enter the accept state.

28. From CFG to NPDA one transition for each production A → w one transition for each terminal b ε, A → w b, b →ε ε, ε→S$ ε, $ →ε

29. ε, A → w = w1w2…wk r q ε, ε→ wk-1 … q2 qk ε, ε→ w1 ε, A → wk q1 q r From CFG to NPDA shorthand for:

30. Example: CFG  NPDA S → aTb | b T → Ta | 

31. From NPDA to CFG Proof of ():L is recognized by a NPDA implies L is described by a CFG. • harder direction • first step: convert NPDA into “normal form”: • single accept state • empties stack before accepting • each transition eitherpushesor popsa symbol, but not both

32. From NPDA to CFG • main idea: non-terminalAp,qgenerates exactly the strings that take the NPDA from state p (with empty stack) to state q (with empty stack) • then Astart, acceptgenerates all of the strings in the language recognized by the NPDA.

33. From NPDA to CFG • To get from state p to q, case 1: generated by Ap,r generated by Ar,q stack height p q r abcabbacacbacbacabacabbabbabaacabbbababaacaccaccccc input string taking NPDA from p to q

34. From NPDA to CFG • To get from state p to q, case 2: generated by Ar,s stack height r s p pop d q push d abcabbacacbacbacabacabbabbabaacabbbababaacaccaccccc input string taking NPDA from p to q

35. From NPDA to CFG • NPDA P = (Q, Σ, , δ, start, {accept}) • CFG G: • non-terminals V = {Ap,q | p, q  Q} • start variable Astart, accept • productions: for every p, r, q  Q, add the rule Ap,q → Ap,rAr,q; Case 1 Case 2 for every p, r, s, q  Q, d  , and a, b  (Σ  {ε}) if (r, d)  δ(p, a, ε) and (q, ε)  δ(s, b, d), add the rule Ap,q → aAr,sb; for every p  Q, add the rule Ap,p → ε

36. From NPDA to CFG • Two claims to verify correctness: • if Ap,q generates string x, then x can take NPDA P from state p (with empty stack) to q (with empty stack) • if x can take NPDA P from state p (with empty stack) to q (with empty stack), then Ap,q generates string x

37. From NPDA to CFG 1. if Ap,q generates string x, then x can take NPDA P from state p (with empty stack) to q (with empty stack) • induction on length of derivation of x. • Basis: one step derivation. must use rules that have only terminals on rhs. In G, must be productions of form Ap,p → ε. • Induction: Ap,q * x. • verify case: Ap,q  Ap,rAr,q k x = yz (Ap,r * y, Ar,q * z) • verify case: Ap,q  aAr,sb  k x = ayb (Ar,s * y)

38. From NPDA to CFG 2. if x can take NPDA P from state p (with empty stack) to q (with empty stack), then Ap,q generates string x • induction on # of steps in P’s computation • Basis: 0 steps. starts and ends at same state p. only has time to read empty string ε. G contains Ap,p → ε.

39. From NPDA to CFG 2. if x can take NPDA P from state p (with empty stack) to q (with empty stack), then Ap,q generates string x • Induction: • if stack becomes empty sometime in the middle of the computation (at state r) • y is read going from state p to r (Ap,r  * y) • z is read going from state r to q (Ar,q  * z) • conclude: Ap,q  Ap,rAr,q  * yz = x

40. From NPDA to CFG 2. if x can take NPDA P from state p (with empty stack) to q (with empty stack), then Ap,q generates string x • if stack becomes empty only at beginning and end of computation. • first step: state p to r, read a, push d • go from state r to s, read string y (Ar,s  * y) • last step: state s to q, read b, pop d • conclude: Ap,q  aAr,sb  * ayb = x

41. 2.2 Pushdown Automata • Pushdown Automata • CFG = PDA • Deterministic PDA

42. Deterministic PDA • Intuitively: never a choice of move. • δ(q, a, Z) is empty or a singleton for any q, a, Z (including a = ). • If δ(q,  , Z) is nonempty, then δ(q, a, Z) must be empty for all input symbols a. • Parsers, as in YACC, are really DPDA's. • Thus, the question of what languages a DPDA can accept is really the question of what programming language syntax can be parsed conveniently.

43. Some Language Relationships • If L is a regular language, then L is a DPDA language. • A DPDA can simulate a DFA, without using its stack (acceptance by final state). • If L is a DPDA language, then L is a CFL that is not inherently ambiguous. • A DPDA yields an unambiguous grammar in the standard construction.

44. Assignment 4 • 1、Consider the following language over the alphabet  = {0, 1}. L = {0i1j | i <= j <= 2i and i >= 0} This is the set of strings where all the 0’s come before all the 1’s, and the number of 1’s is at least the number of 0’s but no more than twice the number of 0’s. Provide a context-free grammar for L. • 2、Exercises 2.21

45. Assignment 4 • 3、(a) Design a PDA that accepts the set of strings of 0's and 1's that have an equal number of 0's and 1's (in any order, e.g., 1001, , or 011011100010). Your PDA should accept by empty stack, and we suggest that it is important for part (b) that it has only one state. (b) Convert your PDA from (a) to a CFG that defines the same language.