Theory of Computation (II) Yijia Chen Fudan University

Transcription

1 Theory of Computation (II) Yijia Chen Fudan University

2 Review

3 A language L is a subset of strings over an alphabet Σ. Our goal is to identify those languages that can be recognized by one of the simplest computation models finite automata. We will also show that those languages can be formed by some simple syntactic manipulations regular expressions.

4 Finite automata Definition A (deterministic) finite automaton (DFA) is a 5-tuple ( Q, Σ, δ, q 0, F ), where 1. Q is a finite set called the states, 2. Σ is a finite set called the alphabet, 3. δ : Q Σ Q is the transition function, 4. q 0 Q is the start state, and 5. F Q is the set of accept states.

5 Formal definition of computation Let M = ( Q, Σ, δ, q 0, F ) be a finite automaton and let w = w 1w 2 w n be a string with w i Σ for all i [n]. Then M accepts w if a sequence of states r 0, r 1,..., r n in Q exists with: 1. r 0 = q 0, 2. δ(r i, w i+1 ) = r i+1 for i = 0,..., n 1, and 3. r n F. We say that M recognizes A if A = { w M accepts w }.

6 Regular languages Definition A language is called regular if some finite automaton recognizes it.

7 The regular operators Definition Let A and B be languages. We define the regular operations union, concatenation, and star as follows: Union: A B = { x x A or x B }. Concatenation: A B = { xy x A and y B }. Star: A = { x 1x 2... x k k 0 and each xi A }.

8 Closure under union Theorem The class of regular languages is closed under the union operation. In other words, if A 1 and A 2 are regular languages, so is A 1 A 2.

9 Proof (1) For i [2] let M i = ( Q i, Σ i, δ i, q i, F i ) recognize Ai. We can assume without loss of generality Σ 1 = Σ 2: Let a Σ 2 Σ 1. We add δ 1(r, a) = r trap, where r trap is a new state with δ 1(r trap, w) = r trap for every w.

10 Proof (2) We construct M = ( Q, Σ, δ, q 0, F ) to recognize A 1 A 2: 1. Q = Q 1 Q 2 = { (r 1, r } 2) r 1 Q 1 and r 2 Q Σ = Σ 1 = Σ For each (r 1, r 2) Q and a Σ we let δ ( (r 1, r 2), a ) = ( δ 1(r 1, a), δ 2(r 2, a) ). 4. q 0 = (q 1, q 2). 5. F = (F 1 Q 2) (Q 1 F 2) = { (r 1, r } 2) r 1 F 1 or r 2 F 2.

11 Closure under concatenation Theorem The class of regular languages is closed under the concatenation operation. In other words, if A 1 and A 2 are regular languages, so is A 1 A 2. We prove the above theorem by nondeterministic finite automata which have the same power as deterministic finite automata, are much easier to manipulate.

12 Nondeterminism Definition A nondeterministic finite automaton (NFA) is a 5-tuple ( Q, Σ, δ, q 0, F ), where 1. Q is a finite set of states, 2. Σ is a finite alphabet, 3. δ : Q Σ ε P(Q) is the transition function, where Σ ε = Σ {ε}, 4. q 0 Q is the start state, and 5. F Q is the set of accept states.

13 Formal definition of computation Let N = ( Q, Σ, δ, q 0, F ) be an NFA and let w = y 1y 2 y m be a string with y i Σ ε for all i [m]. Then N accepts w if a sequence of states r 0, r 1,..., r m in Q exists with: 1. r 0 = q 0, 2. r i+1 δ(r i, y i+1 ) for i = 0,..., m 1, and 3. r m F.

14 Equivalence of NFAs and DFAs Theorem Every NFA has an equivalent DFA, i.e., they recognize the same language.

15 Corollary A language is regular if and on if some nondeterministic finite automaton recognizes it.

16 Second proof of the closure under union For i [2] let N i = ( Q i, Σ i, δ i, q i, F i ) recognize Ai. We construct an N = ( Q, Σ, δ, q 0, F ) to recognize A 1 A 2: 1. Q = {q 0} Q 1 Q q 0 is the start state. 3. F = F 1 F For any q Q and any a Σ ε δ 1(q, a) q Q 1 δ 2(q, a) q Q 2 δ(q, a) = {q 1, q 2} q = q 0 and a = ε q = q 0 and a ε.

17 Closure under concatenation Theorem The class of regular languages is closed under the concatenation operation.

18 Proof For i [2] let N i = ( Q i, Σ i, δ i, q i, F i ) recognize Ai. We construct an N = ( Q, Σ, δ, q 1, F 2 ) to recognize A1 A 2: 1. Q = Q 1 Q The start state q 1 is the same as the start state of N The accept states F 2 are the same as the accept states of N For any q Q and any a Σ ε δ 1(q, a) q Q 1 F 1 δ 1(q, a) q F 1 and a ε δ(q, a) = δ 1(q, a) {q 2} q F 1 and a = ε δ 2(q, a) q Q 2.

19 Closure under star Theorem The class of regular languages is closed under the star operation.

20 Proof Let N 1 = ( Q 1, Σ, δ 1, q 1, F 1 ) recognize Ai. We construct an N = ( Q, Σ, δ, q 0, F ) to recognize A 1 : 1. Q = {q 0} Q The start state q 0 is the new start state. 3. F = {q 0} F For any q Q and any a Σ ε δ 1(q, a) q Q 1 F 1 δ 1(q, a) q F 1 and a ε δ(q, a) = δ 1(q, a) {q 1} q F 1 and a = ε {q 1} q = q 0 and a = ε q = q 0 and a ε.

21 Regular expression and the associated languages regular expression R language L(R) a {a} ε {ε} (R 1 R 2) L(R 1) L(R 2) (R 1 R 2) L(R 1) L(R 2) (R1 ) L(R 1)

22 Equivalence with finite automata Theorem A language is regular if and only if some regular expression describes it.

23 The languages defined by regular expressions are regular 1. R = a: Let N = ( {q 1, q 2}, Σ, δ, q 1, {q 2} ), where δ(q 1, a) = {q 2} and δ(r, b) = for all r q 1 or b a. 2. R = ε: Let N = ( {q 1}, Σ, δ, q 1, {q 1} ), where δ(r, b) = for all r and b. 3. R = : Let N = ( {q 1}, Σ, δ, q 1, ), where δ(r, b) = for all r and b. 4. R = R 1 R 2: L(R) = L(R 1) L(R 2). 5. R = R 1 R 2: L(R) = L(R 1) L(R 2). 6. R = R 1 : L(R) = L(R 1).

24 To prove the other direction we need to further generalize NFA to generalized nondeterministic finite automata, which might be viewed as a mixture of automata and regular expressions.

25 Generalized nondeterministic finite automata Definition A GNFA is a 5-tuple ( Q, Σ, δ, q start, q accept ), where 1. Q is a finite set of states, 2. Σ is a finite alphabet, 3. δ : ( Q {q accept} ) ( Q {q start} ) R is the transition function, where R is the set of regular expressions, 4. q start is the start state, and 5. q accept is the accept state.

26 Formal definition of computation A GNFA accepts a string w Σ if w = w 1w 2... w k, where each w i Σ and a sequence of states q 0, q 1,..., q k exists such that 1. q 0 = q start is the start state, 2. q k = q accept is the accept state, and 3. for each i [k], we have w i L(R i ), where R i = δ(q i 1, q i ).

27 Regular languages can be defined by regular expressions Let M be the DFA for language A. We convert M to a GNFA G by adding a new start state and a new accept state and additional transition arrows as necessary. 1. The start state has transition arrows going to every other state but no arrows coming in from any other state. 2. There is only a single accept state, and it has arrows coming in from every other state but no arrows going to any other state. Furthermore, the accept state is not the same as the start state. 3. Except for the start and accept states, one arrow goes from every state to every other state and also from each state to itself. Then we use a procedure convert on G to return an equivalent regular expression.

28 convert(g): 1. Let k be the number of states of G. 2. If k = 2, then return the regular expression R labelling the arrow from q start to q accept. 3. If k > 2, we select any state q rip Q {q start, q accept} and let G = ( Q, Σ, δ, q start, q accept ) be the GNFA, where Q = Q { q rip }, and for any q i Q { q accept } and qj Q { q start }, let δ (q i, q j ) = (R 1)(R 2) (R 3) (R 4), for R 1 = δ(q i, q rip), R 2 = δ(q rip, q rip), R 3 = δ(q rip, q j ), and R 4 = δ(q i, q j ). 4. Compute convert(g ) and return this value.

29 Languages need counting C = { w {0, 1} w has an equal number of 0s and 1s }. D = { w {0, 1} w has an equal number of occurrences of 01 and 10 as substrings }. Lemma D is regular.

30 The pumping lemma for regular languages Lemma If A is a regular language, then there is a number p (i.e., the pumping length) where if s is any string in A of length at least p, then s may be divided into three pieces, s = xyz, satisfying the following conditions: 1. for each i 0, we have xy i z A, 2. y > 0, and 3. xy p. Any string xyz in A can be pumped along y.

31 Proof Let M = ( Q, Σ, δ, q 1, F ) be a DFA recognizing A and p := Q. Let s = s 1s 2 s n be a string in A with n p. Let r 1,..., r n+1 be the sequence of states that M enters while processing s, i.e., for i [n]. r i+1 = δ(r i, s i ) Among the first p + 1 states in the sequence, two must be the same, say r j and r l with j < l p + 1. We define x = s 1 s j 1, y = s j s l 1, and z = s l s n.

32 Example (I) Example The language { 0 n 1 n n 0 } is not regular. Proof. Choose p be the pumping length and consider s = 0 p 1 p. By the Pumping Lemma, s = xyz with xy i z { 0 n 1 n n 0 } for all i y 00, then xyyz has more 0s than 1s, a contradiction. 2. y 11, then xyyz has more 1s than 0s, again a contradiction. 3. y consists of both 0s and 1s, then xyyz have 0 and 1 interleaved.

33 Example (II) Example The language { w w has an equal number of 0s and 1s } is not regular. Proof. Choose p be the pumping length and consider s = 0 p 1 p. By the Pumping Lemma, s = xyz with xy p and xy i z { w w has an equal number of 0s and 1s } for all i 0. Thus xy 00 and the contradiction follows easily.

34 Context-Free Languages

35 An example The grammar: A 0A1 A B B # A derivation: A 0A1 00A11 000A #111.

36 A second example (1) sentence noun-phrase verb-phrase noun-phrase cmplx-noun cmplx-noun prep-phrase verb-phrase cmplx-verb cmplx-verb prep-phrase prep-phrase prep cmplx-noun cmplx-noun article noun cmplx-verb verb verb noun-phrase article a the noun boy girl flower verb touches likes sees prep with

37 A second example (2) sentence noun-phrase verb-phrase cmplx-noun verb-phrase article noun verb-phrase a noun verb-phrase a boy verb-phrase a boy cmplx-verb a boy verb a boy sees.

38 Context-free grammars Definition A context-free grammar (CFL) is a 4-tuple (V, Σ, R, S), where 1. V is a finite set called the variables, 2. Σ is a finite set, disjoint from V, called the terminals. 3. R is a finite set of rules, with each rule being a variable and a string of variables and terminals, and 4. S V is the start variable.

39 Derivations Let u, v, w be strings of variables and terminals, and A w is a rule of the grammar. We say that uav yields uwv, written uav uwv. Say that u derives v, written u v, if u = v or if a sequence u 1, u 2,..., u k exists for k 0 and u u 1 u 2... u k v. The language of the grammar is { w Σ S w }, which is a context-free language (CFL).

40 Examples 1. The language { 0 n 1 n n 0 } has a grammar: S 1 0S 11 ε. 2. The language { 1 n 0 n n 0 } has a grammar: S 2 1S 20 ε. 3. The language { 0 n 1 n n 0 } { 1 n 0 n n 0 } has a grammar: S S 1 S 2 S 1 0S 11 ε S 2 1S 20 ε.

41 expr expr + expr expr expr ( expr ) a. The string a+a a have two different derivations: 1. expr expr expr expr + expr expr a+a a. 2. expr expr + expr expr + expr expr a+a a.

42 Leftmost derivations A derivation of a string w in a grammar G is a leftmost derivation if at every step the leftmost remaining variable is the one replaced.

43 Ambiguity Definition A string w is derived ambiguously is context free grammar G if it has two or more different leftmost derivations. Grammar G is ambiguous if it generates some string ambiguously. {a} has two different grammars S 1 S 2 a; S 2 a and S a. The first is ambiguous, while the second is not. { a i b j c k i = j or j = k } is inherently ambiguous, i.e., its every grammar is ambiguous.

44 Chomsky normal form Definition A context-free grammar is in Chomsky normal form if every rule is of the form A BC A a where a is any terminal and A, B, and C are any variables except that B and C may be not the start variable. In addition, we permit the rule S ε, where S is the star variable. Theorem Any context-free language is generated by a context-free grammar in Chomsky normal form.

45 Proof of the theorem 1. Add a new start variable S 0 with the rule S 0 S, where S is the original start variable. 2. Remove every A ε, where A S. Then for each occurrence of A on the right-hand side of a rule, we add a new rule with that occurrence deleted. For R A, we add R ε unless we had previously removed R ε. 3. Remove every A B. Then whenever a rule B u appears, where u is a string of variables and terminals, we add the rule A u unless this was previously removed. 4. Replace each rule A u 1u 2 u k with k 3 and each u i is a variable or terminal with the rules A u 1A 1, A 1 u 2A 2, A 2 u 2A 3,..., and A k 2 u k 1 u k. The A i s are new variables. We replace any terminal u i with the new variable U i and add U i u i.