1. Pushdown Automata Part I: PDAs Chapter 12 1

2. Recognizing Context-Free Languages Two notions of recognition: (1) Say yes or no, just like with FSMs (2) Say yes or no, AND if yes, describe the structure a + b * c 2

3. Just Recognizing We need a device similar to an FSM except that it needs more power. The insight: Precisely what it needs is a stack, which gives it an unlimited amount of memory with a restricted structure. Example: Bal (the balanced parentheses language) (((())) 3

4. Definition of a Pushdown Automaton M = (K, , , , s, A), where: K is a finite set of states  is the input alphabet  is the stack alphabet s  K is the initial state A  K is the set of accepting states, and  is the transition relation. It is a finite subset of (K  (   {  })   *)  (K   *) state input or  string of statestring of symbols to pop to push from top on top of stackof stack 4

5. Definition of a Pushdown Automaton A configuration of M is an element of K   *   *. The initial configuration of M is (s, w,  ). K : Current state  * : Input left to read  * : Stack content Compare to the configuration of FSM 5

6. Manipulating the Stack c will be written as cab a b If c 1 c 2 …c n is pushed onto the stack: c 1 c 2 c n c a b c 1 c 2 …c n cab 6

7. Yields Let c be any element of   {  }, Let  1,  2 and  be any elements of  *, and Let w be any element of  *. Then,yields-in-one-step |- M is defined as (q 1, cw,  1  ) |- M (q 2, w,  2  ) iff ((q 1, c,  1 ), (q 2,  2 ))  . Let |- M * be the reflexive, transitive closure of |- M. C 1 yields configuration C 2 iff C 1 |- M * C 2 7 q1q1 q2q2 c/1/2c/1/2 If ((q 1, c,  1 ), (q 2,  2 ))  ,

8. Computations A computation by M is a finite sequence of configurations C 0, C 1, …, C n for some n  0 such that: ● C 0 is an initial configuration, ● C n is of the form (q, ,  ), for some state q  K M and some string  in  *, and ● C 0 |- M C 1 |- M C 2 |- M … |- M C n. 8

9. Nondeterminism If M is in some configuration (q 1, s,  ) it is possible that: ●  contains exactly one transition that matches. ●  contains more than one transition that matches. ●  contains no transition that matches. 9

10. Accepting A computation C of M is an accepting computation iff: ● C = (s, w,  ) |- M * (q, ,  ), and ● q  A. M accepts a string w iff at least one of its computations accepts. Other paths may: ● Read all the input and halt in a nonaccepting state, ● Read all the input and halt in an accepting state with the stack not empty, ● Loop forever and never finish reading the input, or ● Reach a dead end where no more input can be read. The language accepted by M, denoted L(M), is the set of all strings accepted by M. 10

11. Rejecting A computation C of M is a rejecting computation iff: ● C = (s, w,  ) |- M * (q, w,  ), ● C is not an accepting computation, and ● M has no moves that it can make from (q, w,  ). M rejects a string w iff all of its computations reject. So note that it is possible that, on input w, M neither accepts nor rejects. 11

12. A PDA for Balanced Parentheses 12

13. A PDA for Balanced Parentheses M = (K, , , , s, A), where: K = {s}the states  = {(, )} the input alphabet  = {(}the stack alphabet A = {s}  contains: ((s, (,  **), (s, ( )) ((s, ), ( ), (s,  )) **Important: This does not mean that the stack is empty If input is (, what’s on stack top doesn’t matter and a ( is pushed to stack. If input is ) and ( is on stack top, then ( is popped and nothing is pushed to stack. 13

14. A PDA for A n B n = { a n b n : n  0} 14

15. A PDA for A n B n = { a n b n : n  0} M = (K, , , , s, A), where: K = {s, f}the states  = { a, b } the input alphabet  = { a }the stack alphabet A = {f}the accepting states  contains: ((s, a,  ), (s, a )) ((s, b, a ), (f,  )) ((f, b, a ), (f,  )) 15

16. A PDA for {w c w R : w  { a, b }*} 16

17. M = (K, , , , s, A), where: K = {s, f}the states  = { a, b, c } the input alphabet  = { a, b }the stack alphabet A = {f}the accepting states  contains: ((s, a,  ), (s, a )) ((s, b,  ), (s, b )) ((s, c,  ), (f,  )) ((f, a, a ), (f,  )) ((f, b, b ), (f,  )) A PDA for {w c w R : w  { a, b }*} 17

18. A PDA for { a n b 2n : n  0} 18

19. A PDA for { a n b 2n : n  0} M = (K, , , , s, A), where: K = the states  = the input alphabet  = the stack alphabet A = the accepting states  contains: 19

20. Exploiting Nondeterminism A PDA M is deterministic iff: ●  M contains no pairs of transitions that compete with each other, and ● Whenever M is in an accepting configuration it has no available moves. But many useful PDAs are not deterministic. 20

21. A PDA for PalEven ={ww R : w  { a, b }*} S   S  a S a S  b S b A PDA: 21

22. A PDA for PalEven ={ww R : w  { a, b }*} S   S  a S a S  b S b A PDA: 22

23. A PDA for {w  { a, b }* : # a (w) = # b (w)} 23

24. A PDA for {w  { a, b }* : # a (w) = # b (w)} 24

25. More on Nondeterminism Accepting Mismatches L = { a m b n : m  n; m, n > 0} Start with the case where n = m: a//a a//a b/a/b/a/ b/a/b/a/ 12 25

26. More on Nondeterminism Accepting Mismatches L = { a m b n : m  n; m, n > 0} Start with the case where n = m: a//a a//a b/a/b/a/ b/a/b/a/ ● If stack and input are empty, halt and reject. ● If input is empty but stack is not (m > n) (accept): ● If stack is empty but input is not (m < n) (accept): 12 26

27. More on Nondeterminism Accepting Mismatches L = { a m b n : m  n; m, n > 0} a//a a//a b/a/b/a/ b/a/b/a/ ● If input is empty but stack is not (m > n) (accept): a//a a//a b/a/b/a/ b/a/b/a/ /a//a/ /a//a/ 1 2 2 13 27

28. More on Nondeterminism Accepting Mismatches L = { a m b n : m  n; m, n > 0} a//a a//a b/a/b/a/ b/a/b/a/ ● If stack is empty but input is not (m < n) (accept): a//a a//a b/a/b/a/ b/a/b/a/ 1 2 2 1 4 b// b// b// b// 28

29. Putting It Together L = { a m b n : m  n; m, n > 0} ● Jumping to the input clearing state 4: Need to detect bottom of stack. ● Jumping to the stack clearing state 3: Need to detect end of input. 29

30. The Power of Nondeterminism Consider A n B n C n = { a n b n c n : n  0}. PDA for it? 30

31. The Power of Nondeterminism Consider A n B n C n = { a n b n c n : n  0}. Now consider L =  A n B n C n. L is the union of two languages: 1. {w  { a, b, c }* : the letters are out of order}, and 2. { a i b j c k : i, j, k  0 and (i  j or j  k)} (in other words, unequal numbers of a ’s, b ’s, and c ’s). 31

32. A PDA for L =  A n B n C n What is it? 32

33. Are the Context-Free Languages Closed Under Complement?  A n B n C n is context free. If the CF languages were closed under complement, then  A n B n C n = A n B n C n would also be context-free. But we will prove that it is not. 33

34. L = { a n b m c p : n, m, p  0 and n  m or m  p} S  NC/* n  m, then arbitrary c 's S  QP/* arbitrary a 's, then p  m N  A/* more a 's than b 's N  B/* more b 's than a 's A  a A  a A A  a A b B  b B  B b B  a B b C   | c C/* add any number of c 's P  B'/* more b 's than c 's P  C'/* more c 's than b 's B'  b B'  b B' B'  b B' c C'  c | C' c C'  C' c C'  b C' c Q   | a Q/* prefix with any number of a 's 34

35. Reducing Nondeterminism and show where the competitions are ● Jumping to the input clearing state 4: Need to detect bottom of stack, so push # onto the stack before we start. ● Jumping to the stack clearing state 3: Need to detect end of input. Add to L a termination character (e.g., $) 35

36. Reducing Nondeterminism ● Jumping to the input clearing state 4: 36

37. Reducing Nondeterminism ● Jumping to the stack clearing state 3: 37

38. More on PDAs A PDA for {ww R : w  {a, b}*}: What about a PDA to accept {ww : w  { a, b }*}? 38