1. 1 Dr. torng CFG → PDA construction Shows that for any CFL L, there exists a PDA M such that L(M) = L The reverse is true, but we skip the proof Parsing

2. 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(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. 3 Visualization CFL LPDA CFG’s PDA’s L L G M 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

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

5. 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. 6 Illustration Input Grammar G V = {S}  = {a,b} S = S P: S → aSb | What is L(G)? 1. Derive all strings in L(G) on the stack 2. Match the derived string against input (q 0, aabb, Z) /* put S on stack */ (q 1, aabb, SZ) /* derive aabb on stack */ (q 1, aabb, aSbZ) (q 1, aabb, aaSbbZ) (q 1, aabb, aabbZ) /* match stack vs input */ (q 2, aabb, aabbZ) (q 2, abb, abbZ) (q 2, bb, bbZ) (q 2, b, bZ) (q 2,, Z) (q 3,, Z) Illustration of how the PDA might work, though not completely accurate.

7. 7 Difficulty 1. Derive all strings in L(G) on the stack 2. Match the derived string against input (q 0, aabb, Z) /* put S on stack */ (q 1, aabb, SZ) /* derive aabb on stack */ (q 1, aabb, aSbZ) (q 1, aabb, aaSbbZ) (q 1, aabb, aabbZ) /* match stack vs input */ (q 2, aabb, aabbZ) (q 2, abb, abbZ) (q 2, bb, bbZ) (q 2, b, bZ) (q 2,, Z) (q 3,, Z) What is illegal with the computation graph on the left?

8. 8 Construction Input Grammar G=(V, , S, P) Output PDA M=(Q, , , q 0, Z, F,  ) Q = {q 0, q 1, q 2 }  =   = V union  union {Z} Z = Z q 0 = q 0 F = {q 2 }  : Fixed Transitions –  (q 0,, Z) = (q 1, SZ) –  (q 1,, Z) = (q 2, Z) Production Transitions For all productions A → , add  q 1,, A) = (q 1,  ) Matching Transitions For all a in , add  q 1, a, a) = (q 1, )

9. 9 Examples

10. 10 Balanced Parentheses BALG: V = {S}  = {(,)} S = S P: S → SS | (S) | λ Output PDA M=(Q, ,q 0,Z,F, δ) Q = {q 0, q 1, q 2 }  = {(,),S,Z} q 0 = q 0 Z = Z F = {q 2 } δ: Fixed Transitions δ(q 0, λ, Z) = (q 1, SZ) δ(q 1, λ, Z) = (q 2, Z) Production Transitions δ(q 1, λ, S) = (q1, SS) δ  q 1, λ, S) = (q 1, (S)) δ  q 1, λ, S) = (q 1, λ) Matching transitions δ  q 1, (, ( = (q 1, λ) δ  q 1, ), ) = (q 1, λ)

11. 11 BALG Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q 0 Z q 1 SZ 2 q 1 Z q 2 Z 3 q 1 S q 1 SS 4 q 1 S q 1 (S) 5 q 1 S q 1 λ 6 q 1 ( ( q 1 7 q 1 ) ) q 1

12. 12 Partial Computation Graph (q 0, ()(), Z) (q 1, ()(), SZ) (q 1, ()(), SSZ) (other branches not shown) (q 1, ()(), (S)SZ) (other branches not shown) (q 1, )(), S)SZ) (q 1, )(),)SZ) (other branches not shown) (q 1, (), SZ) (q 1, (), (S)Z) (other branches not shown) (q 1, ), S)Z) (q 1, ), )Z) (other branches not shown) (q 1,, Z) (q 2,, Z)

13. 13 Palindromes PALG: V = {S}  = {a,b} S = S P: S → aSa | bSb | a | b | Output PDA M=(Q, ,q 0,Z,F,  ) Q = {q 0, q 1, q 2 }  = {a,b,S,Z} q 0 = q 0 Z = Z F = {q 2 } δ: Fixed Transitions  (q 0,, Z) = (q 1, SZ)  (q 1,, Z) = (q 2, Z) Production Transitions  q 1,, S) = (q 1, aSa)  q 1,, S) = (q 1, bSb)  q 1,, S) = (q 1, a)  q 1,, S) = (q 1, b)  q 1,, S) = (q 1, ) Matching transitions  q 1, a, a) = (q 1, )  q 1, b, b) = (q 1, )

14. 14 Palindrome Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q 0 Z q 1 SZ 2 q 1 Z q 2 Z 3 q 1 S q 1 aSa 4 q 1 S q 1 bSb 5 q 1 S q 1 a 6 q 1 S q 1 b 7 q 1 S q 1 8 q 1 a a q 1 9 q 1 b b q 1

15. 15 Partial Computation Graph (q 0, aba, Z) (q 1, aba, SZ) (q 1, aba, aSaZ) (other branches not shown) (q 1, ba, SaZ) (q 1, ba, baZ) (other branches not shown) (q 1, a, aZ) (q 1,, Z) (q 2,, Z) On your own, draw computation trees for other strings not in the language and see that they are not accepted.

16. 16 {a n b n | n ≥ 0} Grammar G: V = {S}  = {a,b} S = S P: S → aSb | Output PDA M=(Q, ,q 0,Z,F,  ) Q = {q 0, q 1, q 2 }  = {a,b,S,Z} q 0 = q 0 Z = Z F = {q 2 }  : Fixed Transitions  (q 0,, Z) = (q 1, SZ)  (q 1,, Z) = (q 2, Z) Production Transitions Matching transitions

17. 17 {a n b n | n ≥ 0} Transition Table Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q 0 Z 2 q 1 Z 3 q 1 S 4 q 1 S 5 q 1 a a 6 q 1 b b

18. 18 Partial Computation Graph (q 0, aabb, Z) (q 1, aabb, SZ) (q 1, aabb, aSbZ) (other branch not shown) (q 1, abb, SbZ) (q 1, abb, aSbbZ) (other branch not shown) (q 1, bb, SbbZ) (q 1, bb, bbZ) (other branch not shown) (q 1, b, bZ) (q 1,, Z) (q 2,, Z)

19. 19 {a i b j | i = j or i = 2j} Grammar G: V = {S,T,U}  = {a,b} S = S P: S → T | U T → aTb | U → aaUb | Output PDA M=(Q, ,q 0,Z,F,  ) Q = {q 0, q 1, q 2 }  = {a,b,S,T,U,Z} q 0 = q 0 Z = Z F = {q 2 }  Fixed Transitions   (q 0,, Z) = (q 1, SZ)   (q 1,, Z) = (q 2, Z) Production Transitions Matching transitions

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

21. 21 Partial Computation Graph (q 0, aab, Z) (q 1, aab, SZ) (q 1, aab, UZ) (other branch not shown) (q 1, aab, aaUbZ) (other branch not shown) (q 1, ab, aUbZ) (q 1, b, UbZ) (q 1, b, bZ) (other branch not shown) (q 1,, Z) (q 2,, Z)

22. 22 Parsing

23. Eliminating Nondeterminism Lets revisit the BALG grammar S → SS | (S) | λ Whenever S is on top of the stack, we do not look at the input and nondeterministically select one of the 3 productions Think about the PDA parsing ( ) How might we try to eliminate the nondeterminism to choose between the productions? Will that work for this grammar? 23

24. Another Grammar BALG2 grammar S → (S)S | λ Now try parsing ( ) Any issues? Need an end marker, say $ T → S$, S → (S)S | λ 24

25. Resulting Transition Table * Transition Current Input Top of Next Stack Number State Symbol Stack State Update --------------------------------------------------------------------------------- 1 q 0 Z q 1 TZ 2 q 1 Z q 2 Z 3 q 1 T q 1 S$ 4 q 1 S q 1 (S)S 5 q 1 S q 1 λ 6 q 1 ( ( q 1 7 q 1 ) ) q 1 8 q 1 $ $ q 1 4’ q 1 ( S q 1 S)S 5’ q 1 ) S q ) λ 5’’ q ) λ ) q 1 λ 5’’’ q 1 $ S q $ λ 5’’’’ q $ λ $ q 1 λ 25

26. Deterministic Parsers BALG2 grammar {S → (S)S | λ} is called an LL(1) grammar The nondeterministic top-down PDA can be converted into a deterministic top-down parser by “looking ahead” 1 character Generalize to LL(k) grammar with k characters of lookahead LR(k) grammars correspond to bottom-up parsers using “shift” and “reduce” operations Shift: read and push input symbol onto stack Reduce: replace string on stack with variable that derives it 26

27. 27 Comments You should be able to execute the 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 answer- preserving input transformations between decision problems about CFL’s. You should have a basic intuition about parsing