1 / 18

Lecture 32

Lecture 32. CFG --> PDA construction Shows that for any CFL L, there exists a PDA M such that L(M) = L The reverse is true as well, but we do not prove that here. CFL subset LPDA. Let L be an arbitrary CFL Let G be the CFG such that L(G) = L G exists by definition of L is CF

carsyn
Download Presentation

Lecture 32

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. Lecture 32 • CFG --> PDA construction • Shows that for any CFL L, there exists a PDA M such that L(M) = L • The reverse is true as well, but we do not prove that here

  2. CFL subset LPDA • Let L be an arbitrary CFL • Let G be the CFG such that L(G) = L • G exists by definition of L is CF • Construct a PDA M such that L(M) = L • M is constructed from CFG G • Argue L(M) = L • There exists a PDA M such that L(M) = L • L is in LPDA • By definition of L in LPDA

  3. L L G M CFG’s PDA’s Visualization • Let L be an arbitrary CFL • Let G be the CFG such that L(G) = L • G exists by definition of L is CF • Construct a PDA M such that L(M) = L • M is constructed from CFG G • Argue L(M) = L • There exists a PDA M such that L(M) = L • L is in LPDA • By definition of L in LPDA CFL LPDA

  4. A Algorithm Specification • Input • CFG G • Output • PDA M such that L(M) = L(G) CFG G PDA M

  5. Construction Idea • The basic idea is to have a 2-phase PDA • Phase 1: • Derive all strings in L(G) on the stack nondeterministically • Do not process any input while we are deriving the string on the stack • Phase 2: • Match the input string against the derived string on the stack • This is a deterministic process • Move to an accepting state only when the stack is empty

  6. 1. Derive all strings in L(G) on the stack2. Match the derived string against input Illustration Illustration of how the PDA might work, though not completely accurate. • Input Grammar PALG • V = {S} • S = {a,b} • S = S • P: S --> aSa | bSb | a | b | l • What is L(PALG)? • The set of all palindromes over {a,b} (q0, aabaa, Z) /* put S on stack */ (q1, aabaa, SZ) /* derive aabaa on stack */ (q1, aabaa, aSaZ) (q1, aabaa, aaSaaZ) (q1, aabaa, aabaaZ) /* match stack vs input */ (q1, abaa, abaaZ) (q1, baa, baaZ) (q1, aa, aaZ) (q1, a, aZ) (q1,l, Z) (q2, l, Z)

  7. Construction • d: • d(q0, l, Z) = (q1, SZ) • d(q1, l, Z) = (q2, Z) • For all productions A --> a • d(q1, l, A) = (q1, a) • For all a in S • d(q1, a, a) = (q1, l) • Input Grammar • G=(V,S, S, P) • Output PDA • M=(Q, S, G, q0, Z, F, d) • Q = {q0, q1, q2} • S = S • G = V union S union {Z} • Z = Z • q0 = q0 • F = {q2}

  8. Examples

  9. Palindromes • d(q0, l, Z) = (q1, SZ) • d(q1, l, Z) = (q2, Z) • Production Transitions • d(q1, l, S) = (q1, aSa) • d(q1, l, S) = (q1, bSb) • d(q1, l, S) = (q1, a) • d(q1, l, S) = (q1, b) • d(q1, l, S) = (q1, l) • Matching transitions • d(q1, a, a) = (q1, l) • d(q1, b, b) = (q1, l) • PALG: • V = {S} • S = {a,b} • S = S • P: • S --> aSa | bSb | a | b | l • Output PDA M=(Q,S,G,q0,Z,F,d) • Q = {q0, q1, q2} • G = {a,b,S,Z} • q0 = q0 • Z = Z • F = {q2} • d:

  10. Palindrome Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q0l Z q1 SZ 2 q1l Z q2 Z 3 q1l S q1 aSa 4 q1l S q1 bSb 5 q1l S q1 a 6 q1l S q1 b 7 q1l S q1l 8 q1 a a q1l 9 q1 b b q1l

  11. Partial Computation Tree (q0, aba, Z) (q1, aba, SZ) (q1, aba, aSaZ) (other branches not shown) (q1, ba, SaZ) (q1, ba, baZ) (other branches not shown) (q1, a, aZ) (q1, l, Z) (q2, l, Z) On your own, draw computation trees for other strings not in the language and see that they are not accepted.

  12. {anbn | n >= 0} • d(q0, l, Z) = (q1, SZ) • d(q1, l, Z) = (q2, Z) • Production Transitions • d(q1, l, S) = (q1, aSb) • d(q1, l, S) = (q1, l) • Matching transitions • d(q1, a, a) = (q1, l) • d(q1, b, b) = (q1, l) • Grammar G: • V = {S} • S = {a,b} • S = S • P: • S --> aSb | l • Output PDA M=(Q,S,G,q0,Z,F,d) • Q = {q0, q1, q2} • G = {a,b,S,Z} • q0 = q0 • Z = Z • F = {q2} • d:

  13. {anbn | n >= 0} Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q0l Z q1 SZ 2 q1l Z q2 Z 3 q1l S q1 aSb 4 q1l S q1l 5 q1 a a q1l 6 q1 b b q1l

  14. Partial Computation Tree (q0, aabb, Z) (q1, aabb, SZ) (q1, aabb, aSbZ) (other branch not shown) (q1, abb, SbZ) (q1, abb, aSbbZ) (other branch not shown) (q1, bb, SbbZ) (q1, bb, bbZ) (other branch not shown) (q1, b, bZ) (q1, l, Z) (q2, l, Z)

  15. {aibj | i = j or i = 2j} • d • d(q0, l, Z) = (q1, SZ) • d(q1, l, Z) = (q2, Z) • Production Transitions • d(q1, l, S) = (q1, T) • d(q1, l, S) = (q1, U) • d(q1, l, T) = (q1, aTb) • d(q1, l, T) = (q1, l) • d(q1, l, U) = (q1, aaUb) • d(q1, l, U) = (q1, l) • Matching transitions • d(q1, a, a) = (q1, l) • d(q1, b, b) = (q1, l) • Grammar G: • V = {S,T,U} • S = {a,b} • S = S • P: • S --> T | U • T --> aTb | l • U --> aaUb | l • Output PDA M=(Q,S,G,q0,Z,F,d) • Q = {q0, q1, q2} • G = {a,b,S,T,U,Z} • q0 = q0 • Z = Z • F = {q2}

  16. {aibj | i = j or i = 2j} Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q0l Z q1 SZ 2 q1l Z q2 Z 3 q1l S q1 T 4 q1l S q1 U 5 q1l T q1 aTb 6 q1l T q1l 7 q1l U q1 aaUb 8 q1l U q1l 9 q1 a a q1l 10 q1 b b q1l

  17. Partial Computation Tree (q0, aab, Z) (q1, aab, SZ) (q1, aab, UZ) (other branch not shown) (q1, aab, aaUbZ) (other branch not shown) (q1, ab, aUbZ) (q1, b, UbZ) (q1, b, bZ) (other branch not shown) (q1, l, Z) (q2, l, Z)

  18. Things you should be able to do • You should be able to execute this algorithm • Given any CFG, construct an equivalent PDA • You should understand the idea behind this algorithm • Derive string on stack and then match it against input • You should understand how this construction can help you design PDA’s • You should understand that it can be used in many-one reductions between decision problems about CFL’s.

More Related