Pushdown Automata: Theory and Applications in Formal Languages

1. Fall 2008 The Chinese University of Hong Kong CSC 3130: Automata theory and formal languages Pushdown automata Andrej Bogdanov http://www.cse.cuhk.edu.hk/~andrejb/csc3130

2. Motivation • We had two ways to describe regular languages • How about context-free languages? regularexpression NFA DFA syntactic computational CFG pushdown automaton syntactic computational

3. Pushdown automata versus NFA • Since context-free is more powerful than regular, pushdown automata must generalize NFAs state control input 0 1 0 0 NFA

4. Pushdown automata • A pushdown automaton has access to a stack, which is a potentially infinite supply of memory state control input 0 1 0 0 … stack pushdown automaton (PDA)

5. Pushdown automata • As the PDA is reading the input, it can push / pop symbols in / out of the stack state control input 0 1 0 0 … Z0 0 1 1 stack pushdown automaton (PDA)

6. Rules for pushdown automata • The transitions are nondeterministic • Stack is always accessed from the top • Each transition can pop a symbol from the stack and / or push another symbol onto the stack • Transitions depend on input symbol and on last symbol popped from stack • Automaton accepts if after reading whole input, it can reach an accepting state

7. Example state control L = {0n#1n: n ≥ 0} read 0 input push a 0 0 0 # 1 1 1 read # read 1 … Z0 a a a pop a stack pop Z0

8. Shorthand notation 0, e / a read 0 push a #, e / e read # 1, a / e read 1 pop a e, Z0 / e pop Z0 read, pop / push

9. Formal definition A pushdown automaton is (Q, ,, , q0, Z0, F): • Q is a finite set of states; •  is the input alphabet; •  is the stack alphabet, including a special symbol Z0; • q0in Q is the initial state; • Z0in  is the start symbol; • F  Q is a set of final states; •  is the transition function d: Q  (  {})  (  {}) → subsets of Q  (G  {}) state input symbol pop symbol state push symbol

10. Notes on definition • We use slightly different definition than textbook • Example d(q0, 0, e) = {(q0, a)} 0, e / a 1, a / e d(q0, 1, e) = ∅ d(q0, #, e) = {(q1, e)} q0 q1 q2 d(q0, 0, a) = ∅ #, e / e e, Z0 / e ... d: Q  (  {})  (  {}) → subsets of Q  (G  {})

11. A convention • Sometimes we denote “transitions” by: • This will mean: • Intuitively, pop b, then push c1, c2, and c3 q0 q1 a, b/ c1c2c3 q0 q1 a, b/ c1 e, e/ c2 e, e/ c3 intermediatestates

12. Examples • Describe PDAs for the following languages: • L = {w#wR: w ∈ {0, 1}*}, S = {0, 1, #} • L = {wwR: w ∈ S*}, S = {0, 1} • L = {w: w has same number of 0s and 1s}, S = {0, 1} • L = {0i1j: i ≤ j ≤ 2i}, S = {0, 1}

13. Main theorem A language L is context-free if and only if it is accepted by some pushdown automaton. context-free grammar pushdown automaton

14. From CFGs to PDAs • Idea: Use PDA to simulate (rightmost) derivations CFG: A → 0A1A → BB → # A  0A1  00A11  00B11  00#11 input: PDA control: stack: 00#11 write start variable e, e / A Z0A 00#11 e, A / 1A0 Z01A0 replace production in reverse 0#11 pop terminals and match 0, 0 / e Z01A 0#11 e, A / 1A0 Z011A0 replace production in reverse #11 pop terminals and match 0, 0 / e Z011A #11 e, A / B Z011B replace production in reverse

15. From CFGs to PDAs • If, after reading whole input, PDA ends up with an empty stack, derivation must be valid • Conversely, if there is no valid derivation, PDA will get stuck somewhere • Either unable to match next input symbol, • Or match whole input but stack non empty

16. Description of PDA for CFGs • Repeat the following steps: • If the top of the stack is a variable A:Choose a rule A → a and substitute A with a • If the top of the stack is a terminal a:Read next input symbol and compare to aIf they don’t match, reject (die) • If top of stack is Z0, go to accept state

17. Description of PDA for CFGs a, a / e e, A / ak...a1 for every terminal a for every production A → a1...ak e, e / S e, Z0 / e q2 q1 q0

18. From PDAs to CFGs • First, we simplify the PDA: • It has a single accept stateqf • Z0 is always popped exactly before accepting • Each transition is either a push, or a pop, but not both ✓ context-free grammar pushdown automaton

19. From PDAs to CFGs • We look at the stack in an accepting computation: input 0 0 e 1 1 e 0 1 e e 0 q0 q1 q3 q1 q7 q0 q1 q2 q1 q3 q7 qf state a b a c c c a a a a a a a a a stack Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 portions that preserve the stack A03 = {x: x leads from q0 to q3 and preserves stack}

20. From PDAs to CFGs input 0 0 e 1 1 e 0 1 e e 0 q0 q1 q3 q1 q7 q0 q1 q2 q1 q3 q7 qf state a b a c c c a a a a a a a a a stack Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 A11 0 e A11 → 0A03e A03

21. From PDAs to CFGs input 0 0 e 1 1 e 0 1 e e 0 q0 q1 q3 q1 q7 q0 q1 q2 q1 q3 q7 qf state a b a c c c a a a a a a a a a stack Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 Z0 A10 A03 A13 A13 → A10A03

22. From PDAs to CFGs Aij variables: qi’ a, e / t A0f start variable: qi qj b, t /e Aij → aAi’j’b qj’ Aik → AijAjk qi qj qk Aii → e qi a, Z0 /e A0f → A0ia qf qi

23. Example 0, e / a 0, e / a 1, a / e 1, a / e q0 q1 q2 q0 q1 q2 q3 #, e / e e, Z0 / e #, e / $ e, Z0 / e e, $ /e start variable: A02 productions: A00 → e A01 → 0A011 A02 → A01 A00 → A00A00 A11 → e A01 → #A33 A00 → A01A10 A22 → e A00 → A03A30 A33 → e A01 → A01A11 A01 → A02A21 ...