1. Transparency No. P2C3-1 Formal Language and Automata Theory Chapter 3 Pushdown Automata and Context-Free Languages

2. PDAs and CFLs Transparency No. P2C3-2 NPDAs A NPDA (Nondeterministic PushDown Automata) is a 7-tuple M = (Q, , , ,s, , F) where Q is a finite set (the states)  is a finite set (the input alphabet)  is a finite set (the stack alphabet)   (Q x (  U {  })x  ) x (Q x  *) is the transition relation s  Q is the start state    is the initial stack symbol F  Q is the final or accept states ((p,a,A),(q,B 1 B 2 …B k ))   means that whenever the machine is in state p reading input symbol a on the input tape and A on the top of the stack, it pops A off the stack, push B 1 B 2 …B k onto the stack (B k first and B 1 last), move its read head right one cell past the a and enter state q. ((p, ,A),(q,B 1 B 2 …B k ))   means similar to ((p,a,A),(q,B 1 B 2 …B k ))   except that it need not scan and consume any input symbol.

3. PDAs and CFLs Transparency No. P2C3-3 Configurations Collection of information used to record the snapshot of an executing NPDA an element of Q x  * x  *. Configuration C = (q, x, w) means the machine is at state q, the rest unread input string is x, the stack content is w. Example: the configuration (p, baaabba, ABAC  ) might describe the situation: A B A C  a b a b b a a a b b a p

4. PDAs and CFLs Transparency No. P2C3-4 Start configuration and the next configuration relations Given a NPDA M and an input string x, the configuration (s, x,  ) is called the start configuration of NPDA on x. CF M = def Q x  * x  * is the set of all possible configurations for a NPDA M. One-step computation of a NPDA: (p, ay, A  ) --> (q, y,  ) if ((p,a,A), (q,  ))  . (1) (p, y, A  ) --> (q, y,  ) if ((p, ,A),(q,  ))  . (2) Let the next configuration relation --> M on CF M 2 be the set of pairs of configurations satisfying (1) and (2). --> M describes how the machine can move from one configuration to another in one step. (i.e., C --> M D iff D can be reached from C by executing one instruction) Note: NPDA is nondeterministic in the sense that for each C there may exist multiple D’s s.t. C --> M D.

5. PDAs and CFLs Transparency No. P2C3-5 Multi-step computations and acceptance Given a next configuration relation --> M : Define ---> n M and --->* M as usual, i.e., C --> 0 M D iff C = D. C --> n+1 M iff  E C--> n M E and E--> M D. C -->* M D iff  n  0 C --> n M D. i.e., --->* M is the ref. and trans. closure of --> M. Acceptance: When will we say that an input string x is accepted by an NPDA M? two possible answers: 1. by final states: M accepts x ( by final state) iff (s,x,  ) -->* M (p, ,  ) for some final state p  F. 2. by empty stack: M accepts x by empty stack iff (s,x,  ) -->* M (p, ,  ) for any state p. Remark: both kinds of acceptance have the same expressive power.

6. PDAs and CFLs Transparency No. P2C3-6 Language accepted by a NPDAs M = (Q, ,s,,F) : a NPDA. The languages accepted by M is defined as follows: 1. accepted by final state: L f (M) = {x | M accepts x by final state} 2. accepted by empty stack: L e (M) = {x | M accepts x by empty stack}. 3. Note: Depending on the context, we may sometimes use L f and sometimes use L e as the official definition of the language accepted by a NPDA. I.e., if there is no worry of confusion, we use L(M) instead of L e (M) or L f (M) to denote the language accepted by M. 4. In general L e (M)  L f (M).

7. PDAs and CFLs Transparency No. P2C3-7 Some example NPDAs Ex 23.1 : M 1 : A NPDA accepting the set of balanced strings of parentheses [ ] by empty stack. M 1 requires only one state q and behaves as follows: 1. while input is ‘[‘ : push ‘[‘ onto the stack ; 2. while input is ‘]’ and top is ‘[’ : pop 3. while input is ‘  ’ and top is  pop. Formal definition: Q = {q},  = {[,]},  = {[,  }, start state = q, initial stack symbol = .  = { ( (q,[,  ), (q, [  ) ), ( (q,[, [), (q, [[) ), // 1 ( (q,], [), (q,  ) ), // 2 ( (q, ,  ), (q,  ) ) } // 3 Transition Diagram representation of the program  : ==> ? This machine is not deterministic. Why ?

8. PDAs and CFLs Transparency No. P2C3-8 Example execution sequences of M1: let input x = [ [ [ ] ] [ ] ] [ ]. Then below is a successful computation of M 1 on x: (q, [ [ [ ] ] [ ] ] [ ],  ) : the start configuration --> M (q, [ [ ] ] [ ] ] [ ], [  ) instruction or transition (i) --> M (q, [ ] ] [ ] ] [ ], [ [  ) transition (ii) --> M (q, ] ] [ ] ] [ ], [ [ [  ) transition (ii) --> M (q, ] [ ] ] [ ], [ [  ) transition (iii) --> M (q, [ ] ] [ ], [  ) transition (iii) --> M (q, ] ] [ ], [ [  ) transition (ii) --> M (q, ] [ ], [  ) transition (iii) --> M (q, [ ],  ) transition (iii) --> M (q, ], [  ) transition (i) --> M (q,,  ) transition (iii) --> M (q,, ) transition (iv) accepts by empty stack

9. PDAs and CFLs Transparency No. P2C3-9 Failure computation of M1 on x Note besides the above successful computation, there are other computations that fail. Ex: (q, [ [ [ ] ] [ ] ] [ ],  ) : the start configuration -->* M (q, [ ],  ) --> M (q, [ ], ) transition (iv) a dead state at which the input is not empty and we cannot move further ==> failure!! Note: For a NPDA to accept a string x, we need only one successful computation (i.e.,  D with empty input and stack s.t. (s,x,  ) -->* M D. ) Theorem: String x  {[,]}* is balanced iff it is accepted by M 1 by empty stack. Pf: direct result of the key lemma: For any string y, if L(z)  R(z) for all prefixes z of y=zx, then (q, zx,  ) -->*(q,x, [ L(z)-R(z)  )

10. PDAs and CFLs Transparency No. P2C3-10 Another example The set {ww | w  {a,b}*} is known to be not Context-free but its complement L 1 = {a,b}* - {ww | w  {a,b}*} is. Exercise: As specified at p 147, design a NPDA to accept L 1 by empty stack. Hint: x  L 1 iff (1) |x| is odd or (2) x = yazubv or ybzuay for some y,z,u,v  {a,b}* with |y|=|z| and |u|=|v|.

11. PDAs and CFLs Transparency No. P2C3-11 Equivalent expressive power of both types of acceptance M = (Q, , , ,s,,F) : a PDA Let u, t : two new states  Q and  : a new stack symbol  . Define a new PDA M’ = (Q’, ,  ’,  ’,s’, , F’) where Q’ = Q U {u, t},  ’ =  U {  }, s’ = u, F’ = {t} and  ’ =  U { (u, ,  ) --> (s,  ) } // push  and call M U { (f, , A) -> (t,A) | f  F and A   ’ } /* return to M’ if entering into final states */ U {(t, ,A) --> (t,  ) | A   ’ } // pop until EmptyStack Diagram form relating M and M’: Theorem: L f (M) = L e (M’) pf: M accepts x => (s, x,  ) --> n M (q, ,  ) for some q  F => (u, x,  ) --> M’ (s, x,  ) --> n M’ (q, ,  ) --> M’ (t, ,   ) -->* M’ (t, ,  ) => M’ accepts x by empty stack.

12. PDAs and CFLs Transparency No. P2C3-12 From final state to emptystack: M s f u t ( , ,  ) * ( ,A,A) + for all As ( ,A,  ) ++ for all As M’ *: push  and call M +: return to t of M’ if entering into final states ++: pop all stack symbols until emptystack

13. PDAs and CFLs Transparency No. P2C3-13 From FinalState to EmptyStack Conversely, M’ accepts x by empty stack => (u, x,  ) --> M’ (s, x,  ) -->* M’ (q, y,   ) --> (t, y,  ) -->* (t, ,  ) for some q  F => y =  since M’ cannot consume any input symbol once it enters into state t. => M accepts x by final state. Define next new PDA M’’ = (Q’, ,  ’,  ’’,s’, , F’) where Q’ = Q U { u, t},  ’ =  U {  }, s’ = u, F’ = {t} and  ’’ =  U { (u, ,  ) --> (s,  ) } // push  and call M U { (p, ,  ) -> (t,  ) | p  Q } /* return to M’’ and accept if EmptyStack */ Diagram form relating M and M’’:

14. PDAs and CFLs Transparency No. P2C3-14 From EmptyStack to FinalState Theorem: L e (M) = L f (M’’). pf: M accepts x => (s, x,  ) --> n M (q, ,  ) => (u, x,  ) --> M’’ (s, x,  ) --> n M’’ (q, ,   ) --> M’’ (t, ,  ) => M’’ accepts x by final state (and empty stack). Conversely, M’’ accepts x by final state (and empty stack) => (u, x,  ) --> M’’ (s, x,  ) -->* M’’ (q, y,  ) --> M’’ (t, ,  ) for some state q in Q => y =  [and STACK=  ] since M’’ does not consume any input symbol at the last transition ((q, ,  ), (t,  )) => M accepts x by empty stack. QED

15. PDAs and CFLs Transparency No. P2C3-15 From emptystack to final state (and emptystack) M s f u t ( , ,  ) * ( , ,  ) + M’’ ( , ,  ) + * : push  and call M +: if emptystack (i.e.see  on stack), then pop  and return to state t of M’’

16. PDAs and CFLs Transparency No. P2C3-16 Equivalence of PDAs and CFGs Every CFL can be accepted by a PDA. G = (N, ,P,S) : a CFG. wlog assume all productions of G are of the form: A -> c B  B 2 B 3 …B k ( k  0) and c   U {  }. note: 1. A ->  satisfies such constraint; 2. can require k  3. Define a PDA M = ({q}, , N, , q, S, {}) from G where q is the only state (hence also the start state), , the set of terminal symbols of G, is the input alphabet of M, N, the set of nonterminals of G, is the stack alphabet of M, S, the start nonterminal of G, is the initial stack symbol of M, {} is the set of final states. (hence M accepts by empty stack!!)  = { ((q,c,A), (q, B 1 B 2 …B k )) | A -> c B  B 2 B 3 …B k  P }

17. PDAs and CFLs Transparency No. P2C3-17 Example G : S -> [ B S(q, [, S) --> (q, B S) S -> [ B(q, [, S) --> (q, B ) S-> [ S B ==>  : (q, [, S) --> (q, S B) S -> [ S B S (q, [, S) --> (q, S B S) B -> ] (q, ], B) --> (q,  ) L(G) = the set of nonempty balanced parentheses. leftmost derivation v.s. computation sequence (see table at p 153) S L -->* G [ [ [ ] ] [ ] ] (q, [[[]][]], S) -->* M (q, ,  )

18. PDAs and CFLs Transparency No. P2C3-18 leftmost derivation v.s. computation sequence Lemma 24.1: For any z,y   *,   N* and A  N, A L --> n G z  iff (q, zy, A) --> n M (q, y,  ) Ex: S L --> 3 G [ [ [ BBSB (q, [[[ ]][]], S) --> 3 M (q, ]][]], BBSB) pf: By ind. on n. Basis: n = 0. A L --> 0 G z  iff z =  and  = A iff (q, zy, A) = (q, y,  ) iff (q, zy, A) --> 0 M (q,y,  ) Ind. case: 1. (only-if part) Suppose A L --> n+1 G z  and B -> c  was the last rule applied. I.e., A L --> n G uB  L --> G uc  = z  with z = uc and . Hence (q, u cy, A ) --> n M (q, cy, B  ) // by ind. hyp. --> M (q, y,  ) // since ((q,c,B),(q,  ))  

19. PDAs and CFLs Transparency No. P2C3-19 leftmost derivation v.s. computation sequence (cont’d) 2. (if-part) Suppose (q, zy, A) --> n+1 M (q, y,  ) and ((q,c,B),(q,  ))   is the last transition executed. I.e., (q, zy, A) --> n M ( q, cy,  ) --> M (q, y,  ) with  and z = uc for some u. But then A L --> n G uB  // by ind. hyp., L --> uc  = z  // since by def. B -> c   P Hence A L --> n+1 G z  QED Theorem 24.2: L(G) = L(M). pf: x  L(G) iff S L -->* G x iff (q, x, S) -->* M (q,  ) iff x  L(M). QED

20. PDAs and CFLs Transparency No. P2C3-20 Simulating PDAs by CFGs Claim: Every language accepted by a PDA can be generated by a CFG. Can be proved in two steps: 1. Every PDA with only one state has an equivalent CFG 2. Every PDA can be simulated by another PDA with only one state. Note: Unlike FAs, according to 2, minimization of the number of sates of a PDA is meaningless. M = ({s}, , , , s, , {}) : a PDA with only one state. Define a CFG G = ( , , P,  ) where P = { A -> c  | ((q, c, A), (q,  ))   } Note: M ==> G is just the inverse of the transformation : G ==> M defined at slide 15.

21. PDAs and CFLs Transparency No. P2C3-21 Simulating PDAs by single-state PDAs Theorem: L(G) = L(M). Pf: Lemma 24.1 and Theorem 24.2 and their proofs are all valid to the present G and M. QED How to simulate arbitrary PDA by a single-state PDA ? idea: store all state information on the stack !! Wlog, assume M = (Q, , , , s, , {t}) be a PDA with only one final state and M can empty its stack after it enters into its final state. Let  ’ = Q x  x Q. Elements of  ’ are written as. Define a new PDA M’ = ({$}, ,  ’,  ’, $,, {}) where  ’ = { (($, c, ), ($,... )) | ((p,c,A), (q, B 1 B 2 …B k ))   k  c   U  q 1,…,q k  Q } U { (($, c, ), ($,  )) | ((p,c,A), (q,  ))   }

22. PDAs and CFLs Transparency No. P2C3-22 (p, c, A) --> (q, B 1 B 2...B k ) A C  p C x 1 x 2... t t1 t2 t1 p B k-1 BkBk C  q C x 1 x 2... B1B1 B2B2 t t1 t2 q k= t 2 q k-1 q1q1 q1q1 q2q2 q2q2.... q We want to use  * w to simulate the computation: (p, wy, A)  * M (q, y,  ) So, if (p,c,A)  M (q,  ) we have rules :  c for all states r. case 1:  = B 1 B 2 B 3 …B n ( n > 0) =>  … for all states q 1,q 2,…,q n-1. case2:  = . => (q  r ) = (q  r ) => q = r.

23. PDAs and CFLs Transparency No. P2C3-23 Simulating PDAs by single-state PDAs (cont’d) Note: Besides storing sate information on the stack, M’ simulate M by guessing nondeterministically what states M will be in at certain future points in the computation, saving its guesses on the stack, and then verifying later that those guesses are correct. Lemma 25.1: (p,x,B 1 B 2 …B k ) --> n M (q,  ) iff  q 0,q 1,q 2,…q k with p = q 0, q = q k and ($,x, … ) --> n M’ ($,  ). In particular, (p,x,B) --> n M (q,  ) iff ($,x, ) --> n M’ ($,  ). Pf: by ind. on n. Basis: n = 0. Trivial (both sides don’t hold!). (=>:) Now suppose (p,x,B 1 B 2 …B k ) --> n+1 M (q,  ) with ((p,c,B 1 ),(r,C 1 C 2 …C m )) the first instr. applied. then (p,x,B 1 B 2 …B k ) --> M (r, y  C 1 C 2 …C m B 2 …B k )  --> n M (q,  ) where x = cy.

24. PDAs and CFLs Transparency No. P2C3-24 Simulating PDAs by single-state PDAs (cont’d) By ind. hyp.,  r   r m-1,r m = q 1, q 2,… q k with r = r 0, q = q k and ($,y,... … ) --> n M’ ($,  ). Also by construction of M’: ($,c, ), ($,,... )   ’. Combining these, we get: ($,x, … ) --> M’ ($, y,... … ) --> n M’ ($,  ). (<=:) Suppose ($,x, … ) --> n+1 M’ ($,  ). Let ($,c, ), ($,... )   ’ be the first transition taken. Then x = cy and q 1 = r m (by def of  ’)

25. PDAs and CFLs Transparency No. P2C3-25 Simulating PDAs by single-state PDAs (cont’d) ($,x, … ) --> M’ ($, y,... … ) --> n M’ ($,  ). But then (q 0,x,B 1 …B k ) --> M (r 0,y, C 1 C 2 …C m B 2 …B n ) --- By const of M’ --> n M (q k,  ). --,by ind. hyp. QED Theorem 25.2 L(M’) = L(M). Pf: x  L(M’) iff ($, x, ) -->* M’ ($,  ) iff (s,x,  ) -->* M (t,  ) ---- Lemma 25.1 iff x  L(M). QED