Pushdown Automata - automata with a stack memory - read and write access only to the top symbol

Transcription

1 Pushdown Automata (Chapter 3, Sections 3.3, 3.4) CmSc 365 Theory of Computation Pushdown Automata - automata with a stack memory - read and write access only to the top symbol Definition: M = (K,, Γ, Δ, s, F) is a push-down automaton, where K = finite set of states = alphabet (the input symbols) Γ = alphabet (the stack symbols) s є K, initial state F K, the set of final states Δ, the transition relation a finite subset of: (K x ( {e}) x Γ*) x (K x Γ*) The elements of Δ have the form: ((p, a, β),(q, γ)) The meaning is: Whenever M is in state p with β at the top of the stack, it can read a from the input tape, replace β with γ at the top of the stack, and enter state q i.e.: Given: M in state p with β at the top of the stack Action: read a replace β with γ at the top of the stack enter state q Configuration of M If a = e (the empty symbol) i.e. ((p, e, β),(q, γ)) we do not read from the tape. If β = e, i.e. ((p, a, e),(q, γ)), do not pop from the stack. If γ = e, i.e. ((p, a, β),(q, e)), do not push a symbol onto the stack A configuration is a member of ( K x * x Γ*), where: elements of K: current state, elements of * : portion of the input yet to be read elements of Γ* : contents of the stack read top-down 1

2 Computation of M Example: (p, w, abc) p: current sate w: unread input string abc - contents of stack, a at the top, c at the bottom A configuration C1 yields in one step the configuration C2 if: C1 = (p, x, α) C2 = (q, y, β) and there is a transition ((p, a, μ),(q, ν)) such that: x = ay, α = μ λ, β = ν λ, for some λ є Γ* we write C1 - C2 -* is the reflexive transitive closure of - A computation of M is a sequence of configurations such that C i - C (i+1) M accepts a string w є *, if and only if (s, w, e) -* (p, e, e) and p є F. i.e. there is a sequence of configurations starting with (s, w, e) and ending with (p, e, e), p є F, each yielding the next one. Example: Consider a pushdown automaton M that accepts the language L = { wcw R : w є {a,b}*}, e.g. aabbcbbaa is in L, while aabbcaabb is not. M = (K,, Γ, Δ, s, F) K = {s,f} = {a,b,c} Γ = {a,b} F = {f} Δ, the transition relation is : (1). ((s, a, e), (s, a)) (2). ((s, b, e), (s, b)) (3). ((s, c, e), (f, e)) (4). ((f, a, a), (f, e)) (5). ((f, b, b), (f, e)) Write down the sequence of configurations, accepting the string abcba Solution: We need to find a sequence of configurations, each of them yielding in one step the next one, starting with the initial configuration (s,abcba,e) and ending with a final configuration (f,e,e) 2

3 1. The initial configuration is: <1> (s, abcba,e) the machine is in state s, the input on the tape to be read is: abcba, and the stack is empty. 2. To find the next configuration, we are looking for a transition that has s as the first symbol in the left side, and a (this is the first input symbol to be read: abcba) as a second element in the left side. (1). ((s, a, e), (s, a)) if M is in state s, ((s, a, e), (s, a)) if the current symbol to read is a, ((s, a, e), (s, a)) pop nothing from the stack, ((s, a, e), (s, a)) push a onto the stack ((s, a, e), (s, a)) enter state s ((s, a, e), (s, a)) <2> (s, bcba,a) Here M is in state s, the remaining input is bcba, and the contents of the stack is a 3. To find the next configuration, we are looking for a transition that has s as the first symbol in the left side, and b (this is the first input symbol to be read: bcba) as a second element in the left side. (2). ((s, b, e), (s, b)) if M is in state s, ((s, b, e), (s, b)) if the current symbol to read is b, ((s, b, e), (s, b)) pop nothing from the stack, ((s, b, e), (s, b)) push b onto the stack ((s, b, e), (s, b)) enter state s ((s, b, e), (s, b)) <3> (s, cba,ba) Here M is in state s, the remaining input is cba, and the contents of the stack is ba (the top of the stack is the left of the string) 3

4 4. To find the next configuration, we are looking for a transition that has s as the first symbol in the left side, and c (this is the first input symbol to be read: cba) as a second element in the left side. (3). ((s, c, e), (f, e)) if M is in state s, ((s, c, e), (f, e)) if the current symbol to read is c, ((s, c, e), (f, e)) pop nothing from the stack, ((s, c, e), (f, e)) push nothing onto the stack ((s, c, e), (f, e)) enter state f ((s, c, e), (f, e)) <4> (f, ba,ba) Here M is in state f, the remaining input is ba, and the contents of the stack is ba (the top of the stack is the left of the string) 5. To find the next configuration, we are looking for a transition that has f as the first symbol in the left side, and b (this is the first input symbol to be read: ba) as a second element in the left side. (5). ((f, b, b), (f, e)) if M is in state f, ((f, b, b), (f, e)) if the current symbol to read is b, ((f, b, b), (f, e)) pop b from the stack, ((f, b, b), (f, e)) push nothing onto the stack ((f, b, b), (f, e)) enter state f ((f, b, b), (f, e)) <5> (f, a, a) Here M is in state f, the remaining input is a, and the contents of the stack is a 4

5 6. To find the next configuration, we are looking for a transition that has f as the first symbol in the left side, and a (this is the first input symbol to be read: a) as a second element in the left side. (4). ((f, a, a), (f, e) if M is in state f, ((f, a, a), (f, e)) if the current symbol to read is a, ((f, a, a), (f, e)) pop a from the stack, ((f, a, a), (f, e)) push nothing onto the stack ((f, a, a), (f, e)) enter state f ((f, a, a), (f, e)) <6> (f, e, e) Here M is in state f, the remaining input is empty, and the stack is empty. As this is the final configuration we have been aiming at, the sequence of configurations to accept abcba is found: <1> (s, abcba,e) - (upon transition (1). ((s, a, e), (s, a))) <2> (s, bcba,a) - (upon transition (2). ((s, b, e), (s, b))) <3> (s, cba,ba) - (upon transition (3). ((s, c, e), (f, e))) <4> (f, ba,ba) - (upon transition (5). ((f, b, b), (f, e))) <5> (f, a, a) - (upon transition (4). ((f, a, a), (f, e))) <6> (f, e, e) 5

6 Push-down Automata and Context-free Languages Lemma each context-free language is accepted by some pushdown automaton. Let G = (V,,R,S) be a CFG. We shall construct a pushdown automaton M such that L(M) = L(G). Consider M = ({p,q},, V, Δ, p, {q}) M has two states p and q, p is the starting state and after the first move M remains permanently in q. The stack alphabet is V - terminal and nonterminal symbols in G. The transition relation is defined as follows: 1. ((p,e,e),(q,s) 2. ((q,e,a),(q,x)) for each rule A x 3. ((q,a,a),(q,e)) for each symbol in Action of M: First, the starting symbol of the grammar is pushed onto the stack. Then, if the stack top symbol is a non-terminal symbol, it is replaced with its expansion, according to some grammar rule. If the stack top symbol is a terminal symbol, matching the current input symbol, both symbols are "consumed". The meaning: at each step the contents of the stack corresponds to a derivation string - it contains the remainder of the derivation string that has to be transformed to the remainder of the input string. Applying a transition rule corresponds to applying a grammar rule. Theorem: The class of languages, accepted by pushdown automata is exactly the class of context-free languages 6