1 / 38

Pushdown Automata Part I: PDAs

Pushdown Automata Part I: PDAs. Chapter 12. 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. Just Recognizing.

hartzler
Download Presentation

Pushdown Automata Part I: PDAs

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. Pushdown Automata Part I: PDAs Chapter 12

  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

  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) • (((()))

  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 state string of • symbols symbols • to pop to push • from top on top • of stack of stack

  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

  6. Manipulating the Stack • c will be written as cab • a • b • If c1c2…cn is pushed onto the stack: • c1 • c2 • cn • c • a • b c1c2…cncab

  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 (q1, cw, 1) |-M (q2, w, 2) iff ((q1, c, 1), (q2, 2)) . Let |-M* be the reflexive, transitive closure of |-M. C1yields configuration C2 iff C1 |-M*C2 c/1/2 q2 If ((q1, c, 1), (q2, 2)) , q1

  8. Computations A computation by M is a finite sequence of configurations C0, C1, …, Cn for some n 0 such that: ● C0 is an initial configuration, ● Cn is of the form (q, , ), for some state qKM and some string  in *, and ● C0 |-MC1 |-MC2 |-M … |-MCn.

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

  10. Accepting A computation C of M is an accepting computation iff: ● C = (s, w, ) |-M* (q, , ), and ● qA. Maccepts 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 byM, denoted L(M), is the set of all strings accepted by M.

  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, ). Mrejects a string w iff all of its computations reject. So note that it is possible that, on input w, M neither accepts nor rejects.

  12. A PDA for Balanced Parentheses

  13. A PDA for Balanced Parentheses If input is ) and ( is on stack top, then ( is popped and nothing is pushed to stack. If input is (, what’s on stack top doesn’t matter and a ( is pushed to stack. 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

  14. A PDA for AnBn = {anbn: n 0}

  15. A PDA for AnBn = {anbn: 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, ))

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

  17. A PDA for {wcwR: w {a, b}*} 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, ))

  18. A PDA for {anb2n: n 0}

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

  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.

  21. A PDA for PalEven ={wwR: w {a, b}*} S SaSa SbSb A PDA:

  22. A PDA for PalEven ={wwR: w {a, b}*} S SaSa SbSb A PDA:

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

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

  25. More on NondeterminismAccepting Mismatches L = {ambn: mn; m, n > 0} Start with the case where n = m: b/a/ a//a b/a/ 1 2

  26. More on NondeterminismAccepting Mismatches L = {ambn: mn; m, n > 0} Start with the case where n = m: b/a/ a//a b/a/ 1 2 ● 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):

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

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

  29. Putting It Together L = {ambn: 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.

  30. The Power of Nondeterminism Consider AnBnCn = {anbncn: n 0}. PDA for it?

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

  32. A PDA for L = AnBnCn What is it?

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

  34. L = {anbmcp: 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aA AaAb Bb BBb BaBb C | cC /* 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'bB' B'bB'c C'c | C'c C'C'c C'bC'c Q | aQ /* prefix with any number of a's

  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., $)

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

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

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

More Related