1 / 41

Finite Automata

Finite Automata. Closure Properties of Regular Languages Theorem . The class of regular languages is closed under union, intersection, subtraction, complementation, concatenation, Kleene closure and reversal.

karif
Download Presentation

Finite Automata

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Finite Automata Closure Properties of Regular Languages Theorem. The class of regular languages is closed under union, intersection, subtraction, complementation, concatenation, Kleene closure and reversal. Note: closure under union, concatenation and Kleene closure comes from the fact that regular languages are represented by regular expressions; closure under intersection, subtraction and complementation comes from from the fact that regular languages are represented by DFAs. The only part still missing is the closure under reversal. FCS

  2. Finite Automata Closure Properties of Regular Languages Proof. We could prove it by structural induction (on the number of operators applied), since R=  , {}R= {} and {a}R = {a} for every a  , and the extension through union, concatenation and Kleene closure is not hard. We will prove it by construction, instead: • Assume M is an NFA (or DFA), with language L(M). • We construct and NFA M' such that L(M') = L(M)R. • The equivalence of DFAs and NFAs will do the rest. This is the only proof (of any of the statements of the theorem) where NFAs are really used FCS

  3. Finite Automata Closure Properties of Regular Languages Details: Let M = (Q, , , q0, F). We construct M' as follows: if |F| > 1, introduce a new state s and connect every element in F to it via an -transition. Otherwise, let s be the single state in F. Define: M' = (Q{s}, , ', {s}, {q0}), where q'  '(q, a)  q (q', a), a {} All we have done is to "reverse the arrows", after a small adjustment. We have an NFA (we cannot expect a DFA, even if M was a DFA with a singleton accepting state - why?) whose accepting paths are exactly the reversal of the accepting paths of the original. FCS

  4. Finite Automata Closure Properties of Regular Languages - Substitutions Substitution. Let f be a mapping: f (a) = La, where a and La is a language over an alphabet . Extend the function f to * by f() = {} and f(a1a2…ak) f(a1)f(a2)…f(ak) for a1, …, ak. For any language L  *, we apply f to L: f(L) = xLf(x). Ex.: L = {01, 10}; f(0) = 0(0+1)*; f(1) = (0+1)*1. f(L) = f(01) f(10) = f(0)f(1) f(1)f(0) = 0(0+1)*(0+1)*1 (0+1)*10(0+1)* = 0(0+1)*1  (0+1)*10(0+1)* A substitution is called a homomorphism if, for any a , f (a) is a language with a single string (= a singleton string). FCS

  5. Finite Automata Closure Properties of Regular Languages - Substitutions Proposition. Let f be a substitution over ; assume that L  * is a regular language and that f(a) is a regular language for each a . Then f(L) is a regular language. Proof. Let r be a RE for L, ra a RE for f(a) for each a . Replace each occurrence of a in r by f(a). We obtain a new regular expression r'. We observe: • For any two sets A, B *, f(AB) = f(A) f(B), f(AB) = f(A)f(B), and f(A*) = f(A)*. • For any two regular expressions r and s, (r + s)' = r' + s', (rs)' = r's', and (r*)' = (r')*. This could use detailed proof as set inclusions and RE equalities… FCS

  6. Finite Automata Closure Properties of Regular Languages - Substitutions We now start the induction: The base cases (0 operators): • f() = (extending the definition to the empty language). Regularity is preserved: the empty language is regular and its image (also the empty language) is also regular. • f({}) = {}. The image of the language consisting of the empty string is a regular language. • f({a}) is a regular language for each a , by definition of f. All three basis steps give rise to regular languages and their regular expressions starting from the regular language building blocks and their regular expressions. FCS

  7. Finite Automata Closure Properties of Regular Languages The structural induction step: Let r and s be regular expressions defining regular languages A and B * such that f(A) and f(B) are regular languages with regular expressions r' and s'. Assume the result holds for sets constructed with up to n operators; prove it holds if you apply any one of the operators to two such sets. We have: r+s AB : f(AB) = f(A)f(B)  r'+s' = (r+s)' and the image language is regular. Identical arguments will work for the remaining structural operations (concatenation and Kleene closure). FCS

  8. Finite Automata Closure Properties of Regular Languages - Quotients Definition. The quotient of two languages, denoted by L1/L2 is given by L1/L2= {x | (y  L2)[xy L1]}. Proposition. If L1 is a regular language, then L1/L2 is regular. Proof. Let M = (Q, , , q0, F) be a DFA accepting L1. By definition, for any x  L1/L2 y  L2 s.t. (q0, xy) = ((q0, x), y)  F. If we define F' = {q  Q | (y  L2)[(q, y)  F]}, M' = (Q, , , q0, F') is a DFA that accepts L1/L2. Note: The proof is not quite constructive, at the moment, since we would need to show that a finite number of strings in L2 suffices to construct F'. FCS

  9. Finite Automata Closure Properties of Regular Languages - Examples Ex. 2.37. Let L be regular over , k a pos. integer and : k. Then L1 = {(a1, a2, …, ak)…(a(n-1)k, a(n-1)k+1, …, ank) | a1a2…ankL} is regular. Note that a string of length nk in L becomes a string of length n in L1. Proof. Let L = L(M) for M = (Q, , , s, F). Let M' = (Q, , ', s, F), with  (q Q, a) '(q, a) = {(q, a1…ak) | (a1, …, ak) = a}. Note: there is no requirement for  to be 1-1. We can see that L1 = L(M'). Note that (q, a1…ak) is the state of M reached from q after consuming the string a1…ak. FCS

  10. Finite Automata Closure Properties of Regular Languages - Examples Def.: for any language L, MIN(L) = {xL | no proper prefix of x belongs to L}. Ex. 2.38. If L is regular, then MIN(L) is regular. Proof. Let L = L(M), where M = (Q, , , s, F) is a DFA. Let M' be the NFA obtained from M by deleting all the out-edges from the final states. It is clear that M' accepts MIN(L)… FCS

  11. Finite Automata Closure Properties of Regular Languages - Examples Def.: for a, b {0, 1}, let ab denote the disjunction of a and b; for any two binary strings x and y, with |x| = |y|, let xy denote the bitwise disjunction of x and y. Ex. 2.39. Let A and B be regular over {0, 1}. Then AB = {xy | xA, yB, |x| = |y|} is regular. Proof. Let MA = (QA, {0, 1}, A, sA, FA) and MB = (QB, {0, 1}, B, sB, FB) be the respective DFAs. We build a product NFA M' as follows: M' =(QA QB, {0, 1}, ', [sA, sB], FA FB) where '([p, q], 0) = {[A(p, 0), B(q, 0)]} '([p, q], 1) = {[A(p, 0), B(q, 1)], [A(p, 1), B(q, 0)], [A(p, 1), B(q, 1)]}. FCS

  12. Finite Automata Minimum Deterministic Finite Automata We have seen that regular languages give rise to at least three different, and equivalent, notational devices that represent them. For one of them, at least, the following question is meaningful: does a regular language have a corresponding (unique) minimal DFA, in the sense that no other DFA accepting the language has fewer states? if the answer is yes, can we construct it? The constructions we have, from REs to NFAs to DFAs tend to "blow up" the number of states, up to exponential cardinality in the number of states of the NFA - which already "bloats" the number of atomic terms in the regular expression (digraph construction). We could use a different characterization of regular languages. FCS

  13. Finite Automata Minimum Deterministic Finite Automata - the Index Definition. For any language L  *, we define a relation RL on *: x RL y  (w  *) [xw L  yw L]. Proposition. RL is an equivalence relation on *: • it is reflexive: (x  *) [xRLx] • it is symmetric: (x, y  *) [xRLy  yRLx] • it is transitive: (x, y, z  *) [xRLy, yRLz  xRLz] Proof. An easy exercise. Corollary. RL partitions * into disjoint equivalence classes, where the class containing x is denoted by [x]RL. Proof. Another easy exercise. Definition. The number of equivalence classes of R in * is called the index of R and denoted by Index(R). FCS

  14. Finite Automata Minimum Deterministic Finite Automata - the Index - Example Ex. 2.46: Let L be the set of binary strings starting and ending with the same symbol. Find all equivalence classes of RL (in *). Soln.: a) we first show that 8x, y2*, x RL y x and y start with the same symbol and end with the same symbol.  By contradiction. Assume x and y start with different symbols, with, say, x starting with a 0 and y starting with a 1. Then x0  L while y0  L, so that x RL y does not hold. This implies that x and y must start with the same symbol. Note further that x RL y  x L  y L (*), and therefore, since they start with the same symbol, they must end with the same symbol. FCS

  15. Finite Automata Minimum Deterministic Finite Automata - the Index - Example  Assume x and y start with the same symbol and end with the same symbol. Since they start with the same symbol: xw L  yw L for all w (0+1)+. Since x and y end with the same symbol, x L  y L. Thus xw L  yw L for any w (0+1)* = *. We can now characterize the (5) equivalence classes: []RL = , [0] RL = 0 + 0(0 + 1)*0, [1] RL = 1 + 1(0 + 1)*1, [01] RL = 0(0 + 1)*1, [10] RL = 1(0 + 1)*0 FCS

  16. Finite Automata Minimum Deterministic Finite Automata - the Index - Example How do we find the classes of * induced by the relation RL? If we cannot guess them - and we usually can't - the only strategy left is to be systematic. • Start from the string 2* and find the strings in * that belong to its class. • Move to the strings of length 1 • Move to the strings of length 2 … etc. • Either the classes will begin repeating after a finite number of constructions (in which case the index will be finite), or not, in which case the index will be infinite. FCS

  17. Finite Automata Minimum Deterministic Finite Automata - the Index - Example Details: recall x RL y  (w  *) [xw L  yw L], where L =  + 0 + 1 + 0(0+1)*0 + 1(0+1)*1 Show: []RL = {}, where []RL´ { y | y2* and (w  *) [w = w  L  yw L]} Since w2L,w2L, we are looking for those strings y s.t. yw2L,w2L. y =  is, obviously, OK. Let's now start with the shortest non-trivial candidates: y = 0, 1. For each w2L, 0w2L if w =  or w ends in 0, otherwise 0wL. So 0 []RL. The same argument gives that 1 []RL. If y is any other nontrivial string, it must be one of 0(0+1)*0, 0(0+1)*1, 1(0+1)*0 and 1(0+1)*1. Then 11 2L and 0(0+1)*011, 0(0+1)*111 L. Similarly for00 and 1(0+1)*000, 1(0+1)*100. So []RL contains just one string: . FCS

  18. Finite Automata Minimum Deterministic Finite Automata - the Index - Example We now look at the classes of longer strings. The strings of length 1 will give rise to the classes [0] RL and [1] RL. Claim: [0] RL = 0 + 0(0 + 1)*0, [1] RL = 1 + 1(0 + 1)*1. Let's construct [0] RL, the construction of [1] RL being similar. [0]RL´ { y | y2* and (w  *) [0w = w  L  yw L] Obviously, 0 2 [0] RL. The rest of the candidates must be of the form y = 1, 0(0 + 1)*0, 0(0 + 1)*1, 1(0 + 1)*0 and 1(0 + 1)*1. For y = 1, the choice w = 1 will invalidate the condition; for y = 0(0 + 1)*0, the condition will hold forw = (both 0 and 0(0+1)*0 begin and end in 0) and for all other choices of w it will depend only on the last character of w being 0 or not. For y having the form of one the three remaining string types, we find failures for w =  in the cases 0(0 + 1)*1 and 1(0 + 1)*0 and forw = 0 in the last one. FCS

  19. Finite Automata Minimum Deterministic Finite Automata - the Index - Example We still have to place two sets of strings: the ones denoted by 0(0 + 1)*1 and 1(0 + 1)*0. It should be clear that, after this placement, all strings in * will have been taken care of. An argument similar to those already encountered allows us to conclude that: [01] RL = 0(0 + 1)*1, [10] RL = 1(0 + 1)*0 FCS

  20. Finite Automata Minimum DFAs - the Index - Second Example Problem 2.7.1a: find all equivalence classes of RLfor the language L = (0 + 1)*01(0 + 1)*. Soln: first observe that = {0, 1}. RL is defined over * (= all strings over {0, 1} - we are partitioning the set of all strings over {0, 1}) and, specifically, xRLy,8(w2*){xw2L,yw2L} for any two strings x, y 2*. Start with the class of the empty string: []RL. Claim: []RL= [1]RL = [11]RL =…= [1n]RL =… Note that both  and 1n must be concatenated with a string containing 01 (thus in L) in order to give rise to a string in L. 8/6/2014 FCS 20

  21. Finite Automata Minimum DFAs - the Index - Second Example Problem 2.7.1a: find all equivalence classes of RLfor the language L = (0 + 1)*01(0 + 1)*. Claim: []RL=…= [0n]RL =…= [1m0n]RL for m ≥ 1, n ≥ 1, i.e., w must contain a 1 for the concatenation to be in L. Claim: [1]RL = []Rl from the previous slide. Claim: [01]RL = L. All other strings in * belong to one of the classes just constructed. Automaton for L: 1 0 0, 1 0 1 8/6/2014 FCS 21

  22. Finite Automata Minimum DFAs - the Index - Third Example Problem 2.7.2a: show that for L = {0m1n | 0 ≤ m ≤ n}, Index(L) = 1. Soln: first observe that = {0, 1}. RL is defined over * (= all strings over {0, 1} - we are partitioning the set of all strings over {0, 1}) and, specifically, xRLy,8(w2*){xw2L,yw2L} for any two strings x, y 2*. Start with the class of the empty string: []RL: for what y2* is it true that w2L,yw2L? It is clear that w2L,w2L, so that w = 0m1nfor some 0 ≤ m ≤ n. Question: what must y look like so that yw 2 L for all w of the form0m1n, 0 ≤ m ≤ n, and only for those ws? Assume y =0k for some k >0. Then 0k0m1n L 8 (0 ≤ m ≤ n < k + m). Similar arguments hold for any non-empty strings: []RL= {}. 8/6/2014 FCS 22

  23. Finite Automata Minimum DFAs - the Index - Third Example Let's now try x = 0k, k > 0. Let y = 0j, j ≠ k. We must satisfy the requirement 0kw 2 L , 0jw 2 L 8(w 2*). If we choose l = min{j, k}, then either 0k1lor0k1lL. Since we have just shown that 0k and 0j, j ≠ k, belong to different equivalence classes, we must conclude that RL has infinitely many equivalence classes. Notice that we do not need to identify all the distinct equivalence classes - there may be others, after all we have identified only []RL, [0]RL , [02]RL, …, [0n]RL ,… but this is enough to reach the desired conclusion. 8/6/2014 FCS 23

  24. Finite Automata Minimum Deterministic Finite Automata Lemma. Let L be accepted by the DFA M = (Q, , , q0, F), and letbe the extended transition function ofM. Then, for any strings x, y  *, (s, x) = (s, y)  x RL y. Proof. If (s, x) = (s, y), then, for any w  *, (s, xw) = ((s, x), w) = ((s, y), w) = (s, yw). Thus, for any w  *, xw L  yw L. Note. The lemma shows that, if L is accepted by a DFA M of n states, all strings with the same ending state are in the same equivalence class of RL. In particular Index(RL) ≤ n, and is thus finite. If we can find a DFA accepting L and with exactly Index(RL) states, we have found the desired minimum DFA. FCS

  25. Finite Automata Minimum Deterministic Finite Automata Theorem 2.48 (Myhill-Nerode). For any regular language L, its minimum DFA has exactly Index(RL) states. Proof. Let L have alphabet . Define M = (Q, , , s, F) by: • Q = {[x]RL| x *}, (and |Q| <  if L is regular); • [x]RLa) = [xa]Rl, for any a2; • s = []RL; • F = {[x]RL| x L}. The function  is well-defined since: [x]RL = [y]RL [xa]RL = [ya]RL [x]RLa) = [xa]RL = [ya]RL = [y]RLa). By induction on |y| we extend this to []RLx) = [x]RL x *proving that L(M) = L: x L [x]RL  F []RLx)  F  Macceptsx. Since M has Index(RL) states, it is, by the previous Lemma, a min. DFA for L. FCS

  26. Finite Automata Minimum Deterministic Finite Automata Corollary. A language L is regular  Index(RL)< . Proof. No use of regularity (other than for the finiteness of Q) was made in the Myhill-Nerode theorem. We can thus construct the minimum DFA for any language as along as Index(RL)< . Such languages L must be regular. Note: the finiteness of DFAs allows us to obtain a "simplification" - we don't need to look at all of * to characterize RL, but only to strings up to a certain length. FCS

  27. Finite Automata Minimum Deterministic Finite Automata Proposition. L is regular   k  N+s.t. [x RL y  [z  * with |z| ≤ k, xz L  yz L]]. This simply means that regular languages are really determined by finite sets of strings: you will have no surprises from "very long strings". This also means, in the language quotient case, that we don't need to look at all the strings in L2. FCS

  28. Finite Automata Minimum Deterministic Finite Automata Proposition. L is regular   k  N+s.t. [x RL y  [z  * with |z| ≤ k, xz L  yz L]]. Proof.  Let M = (Q, , , s, F) be a DFA accepting L; let k = |Q|2 - 1.  This is obvious, since x RL y  [z  *xz L  yz L], and therefore for all those z with |z| ≤ k.  Consider the product DFA M* = M M. Let w  * with |w| > k. Let x, y2*. The computation path of M* on w starting from q1* = [(s, x), (s, y)], to q2* = [(s, xw), (s, yw)], contains at least |Q|2 + 1 states, while M*has |Q|2 states,and therefore it contains some cycles in the transition diagram of M*. Eliminate the cycles and keep only a simple path from q1* to q2*, which corresponds to the computation path for a string z with |z| ≤ k, so that q2* = [(s, xz), (s, yz)]= [(s, xw), (s, yw)]. By assumption, xz L  yz L : the states (s, xz) and(s, yz) are both in F or not in F. So xw L  yw L and the result follows. 8/6/2014 FCS 28

  29. Finite Automata Minimum Deterministic Finite Automata  Assume  k  N+s.t. [x RL y  [z  * with |z| ≤ k, xz L  yz  L]]. Each z can divide * in at most two parts: {x | xz L} and {x | xz L}. The number of equivalence classes of RL is thus, at most, 21+||+...||k, and so finite. Which implies regularity for L. Note: we have developed some results and techniques which allow us to do two things • we have a way of constructing a minimum DFA for a regular language; • we have a way of determining (maybe) whether a language is regular or not (being unable to construct a DFA is quite different from proving that no DFA exists) by computing Index(RL). FCS

  30. Finite Automata Minimum Deterministic Finite Automata - Example Ex. 2.51.: find the minimum DFA for the language L = (0 + 1)*01. Soln.: we compute the equivalence classes of RL (some "bit analysis"), beginning from the shortest string in *: • []RL= {x {0, 1}* | (w  {0, 1}*)[xw  (0 + 1)*01  w  (0 + 1)*01]}. We need to characterize x[]RL. What are the possible relevant endings of x? : 0, 1, 00, 01, 10, 11.There is no point in looking at longer strings, since L fixes the last two characters. x may not end with 0 (or 01): if it did x1 (or x) would be in (0+1)*01, which would imply that w = 1 (or w = ) is in (0 + 1)*01. Conversely, if x does not end with 0 or 01, then x[]RL. Thus []RL=  + 1 + (0 + 1)*11. • [0]RL= {x {0, 1}* | (w  {0, 1}*)[0w  (0 + 1)*01  xw  (0 + 1)*01]}. What must x end with? Since, for w = 1, 0w (0 + 1)*01]}, x must end with 0. Conversely, if x ends with 0, x [0]RL. Thus [0]RL= (0 + 1)*0. FCS

  31. 0 1 0 1  0 01 0 1 Finite Automata Minimum Deterministic Finite Automata - Example • [1]RL. Using the definition of []RL we can see that 1 []RLand thus the two classes must coincide (by RL being an equivalence relation). • [00]RL. 00  [0]RL [00]RL= [0]RL. • [01]RL = {x {0, 1}* | (w  {0, 1}*)[01w  (0 + 1)*01  xw  (0 + 1)*01]}. Either x ends in 01, or it cannot satisfy the condition. We must conclude that [01]RL = (0+1)*01. • [10]RL: since 10 2 [0]RL, we have[10]RL= [0]RL. • [11]RL: since 11 2 []RL, we have[11]RL= []RL. The classes are []RL, [0]Rland [01]RL. The minimum DFA has only 3 states: FCS

  32. 0 0 1 0 1 1 2 3 0 1 0 1 1 4 5 0 0,1 Finite Automata Minimum Deterministic Finite Automata - Example Ex. 2.53. Find the minimum DFA equivalent to the DFA: FCS

  33. Finite Automata Minimum Deterministic Finite Automata - Example Soln. 1: M = (Q, , , q0, F), Q = {q0, q1, q2, q3, q4, q5}, L = L(M). Recall: for statespandq, pR*Lq, Sp = {x2* | (s, x) = p)} is in same equiv. class as Sq = {x2* | (s, x) = q)} . , (8w)[(p, w) 2 F ,(q, w) 2 F]. To find R*Lbetween any two states, construct a graph G: Each vertex is an unordered pair (qi, qj). Let U be the set of vertices (qi, qj) with one vertex qi2 F and the other vertex qj F. For each vertex (qi, qj)  U (either both vertices are in F or not in F), withi ≠ j, draw edges (qi, qj) !a ((qi, a), (qj, a))8a2. Claim: qiR*Lqj,there is no path in G from (qi, qj) to a vertex in U. FCS

  34. 0 0 1 0 1 1 2 3 0 1 0 0 1 1 (0, 1) (2, 3) (4, 4) 0 1 0 1 1 4 5 (5, 5) 0, 1 0 0,1 Finite Automata Minimum Deterministic Finite Automata - Example How do we use this construction? Construct G. U consists of the pairs (0, 2), (1, 3), (1, 2), (0, 3), (2, 4), (3, 4), (4, 5). The complement of U consists of (0, 0), (0, 1), (1, 1), (0, 4) (1, 4), (2, 2), (2, 3), (3, 3), (2, 5), (3, 5), (4, 4), (5, 5). Note:there is no point in starting from a (qi, qi) node - why? From (0, 1): FCS

  35. 0 0 1 1 0 0, 1 (0, 4) (2, 5) (5, 5) 0 1 1 1 1 0 0 1 (1, 4) (3, 5) (4, 5) 0 2 3 0 1 1 0 1 1 4 5 0 0,1 Finite Automata Minimum Deterministic Finite Automata - Example The next node in the list is (0, 4): Note that from the nodes (0, 4), (1, 4),(2, 5) and (3, 5) we can reach a node in U. When we put together the two partial graphs (constructed this way for convenience, we get: FCS

  36. 0 0 1 1 (0, 1) (2, 3) (4, 4) 0 1 1 0 (0, 4) (2, 5) (5, 5) (5, 5) 0, 1 1 1 0 0 1 (1, 4) (3, 5) (4, 5) 0 1 Finite Automata Minimum Deterministic Finite Automata - Example The minimal automaton is exactly the one corresponding to the graph with only black nodes: FCS

  37. 0 0 1 1 (0, 1) (2, 3) (4, 4) 0 1 (5, 5) (5, 5) 0, 1 Finite Automata Minimum Deterministic Finite Automata - Example We finish with just the minimal DFA, where we have highlighted it final nodes: FCS

  38. q1, q2, q3, q4, q5 0 0 0 0 q1, q2, q3, q4, q5 0 0 0 0 0 0 0 0 0 q0, q1, q2, q3, q4 0 0 0 0 1 1 0 q0, q1, q2, q3, q4 Finite Automata Minimum Deterministic Finite Automata - Example Soln. 2: The critical step of soln. 1 is to determine, for a pair (qi, qj) whether there is a path in G from it to a vertex of U. You need only study pairs where i ≠ j, since you know the (qi, qi) belong to the same class. Create a table of pairs, marking all pairs in U with a 0: Of the unmarked pairs, mark with a 1 those for which there is an a2 taking them to a pair marked with a 0. FCS

  39. Finite Automata Minimum Deterministic Finite Automata - Example Of the unmarked pairs, mark with a 2 those for which there is an a2 taking them to a pair marked with a 1. Keep on until no more markings. The pairs left unmarked must satisfy qiR*Lqj. Add the (qi, qi) needed to complete the graph q1, q2, q3, q4, q5 q1, q2, q3, q4, q5 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 1 1 0 0 0 1 1 0 q0, q1, q2, q3, q4 q0, q1, q2, q3, q4 FCS

  40. 0 0 1 0 1 1 2 3 0 1 0 1 1 4 5 0 0,1 Finite Automata Minimum Deterministic Finite Automata - Example Soln. 3: Split states into F and Q\F. Chase states from F: if any exit F, break F into an appropriate number of sub-blocks; same for Q\F. Keep on iterating until no new blocks appear. 0 0 1 0 1 1 2 3 0 1 0 1 1 4 5 0 0,1 FCS

  41. Finite Automata Minimum Deterministic Finite Automata - Example 0 0 0,1 0 1 0 1 0 0 1 1 1 1 1 2 3 2 3 0 0 1 1 2,3 0 0 0 1 1 1 1 1 4 4 1 4 5 5 5 0,1 0 0,1 0 0,1 0 FCS

More Related