1 / 42

Lecture#16-17

Lecture#16-17. Properties of regular languages. What happens when we perform operations on regular languages? E.g., if we concatenate two regular languages, is the resulting language also regular? Can we decide whether a given language has a certain property or not?

kolina
Download Presentation

Lecture#16-17

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. Lecture#16-17 Unit-2

  2. Properties of regular languages • What happens when we perform operations on regular languages? • E.g., if we concatenate two regular languages, is the resulting language also regular? • Can we decide whether a given language has a certain property or not? • E.g., Can we tell if a certain language is finite or not? • Can we tell whether a given language is regular or not? Unit-2

  3. Closure properties of regular languages • Definition: A regular language is any language that is accepted by a finite automaton • Theorem 4.1 : The class of regular languages is closed under the following operations (that is, performing these operations on regular languages creates other regular languages) • Union • Concatenation • Kleene star • Complement • Intersection Unit-2

  4. Closure for union, concatenation, and Kleene star • If L1 and L2 are regular languages, then there exist regular expressions r1 and r2 such that L1 = L(r1) and L2 = L(r2). By definition 3.1.2 in our text: r1+r2 , r1r2, and r* are regular expressions, and: L1 L2 = L(r1+r2) L1L2 = L(r1r2) L1* = L(r*) Unit-2

  5. Closure for union, concatenation, and Kleene star Since languages represented by regular expressions are by definition regular, performing the operations of union, concatenation, and star-closure on regular languages produces regular languages. We say that the class of regular languages is closed under union, concatenation, and Kleene star (star-closure). Unit-2

  6. So: • The null language  is regular • The language consisting of the empty string, {λ}, is regular • For each a in , {a} is regular • If L1 and L2 are regular: L1  L2 is regular L1L2 is regular L1* is regular Unit-2

  7. Unions, Intersections, and Complements: Theorem 4.1, p. 100 Suppose that M1 = (Q1, , 1, q1, F1) accepts language L1, and M2 = (Q2, , 2, q2, F2)accepts language L2 Let M be an FA defined byM = (Q, , , q0, F) where Q = Q1 Q2 q0 = (q1, q2) and the transition function  is defined by: ((p, q), a) = (1(p, a), 2(q, a)), for any p  Q1, q  Q2, and a  Unit-2

  8. Unions, Intersections, and Difference: Theorem 4.1, p. 100 Then: • If F = {(p, q)  p  F1orq  F2}, M accepts the language L1  L2 • If F = {(p, q)  p  F1andq  F2}, M accepts the language L1 L2 • If F = {(p, q)  p  F1andq  F2}, M accepts the language L1  L2 Unit-2

  9. Theorem 4.1, p. 100 Proof: For any x  and any (p, q)  Q: *((p, q), x) = (1*(p, x), 2*(q, x)) A string x is accepted by M iff *((q1, q2), x)  F By our formula, this is true only if (1*(q1, x), 2*(q2, x))  F Unit-2

  10. Theorem 4.1, p. 100 Proof (continued): For Case 1, this is equivalent to saying that: 1*(q1, x)  A1 or2*(q2, x)  A2 Which is equivalent to x L1  L2 Cases 2 and 3 are similar Unit-2

  11. Complement Consider the special case in which L1 is all of *. Here, L1 – L2 is actually L2’ (the complement of L2) Unit-2

  12. Reversal Theorem 4.2: The family of regular languages is closed under reversal. Proof: If L is a regular language, construct an NFA with a single final state that accepts it. Now change the initial vertex into a final vertex, the final vertex into the initial vertex, and reverse the direction on all the edges. For every string w accepted by the original NFA, the modified version of the NFA accepts wR. Unit-2

  13. Homomorphism Definition 4.1: A homomorphism is a substitution in which a single letter is replaced with a string. Formally, if  and  are alphabets, then a function h : * is a homomorphism. If L is a language on S, then its homomorphic image is: h(L) = {h(w) : w  L} Unit-2

  14. Homomorphism Theorem 4.3: If L is a regular langugae, then its homomorphic image h(L) is also regular. Thus the family of regular languages is closed under homomorphism. Unit-2

  15. Right quotient To form the right quotient of L1 with L2, L1/L2, take all strings in L1 that have a suffix belonging to L2 and remove the suffix. Example: L1 = {ab, aab, aaab, aaaab} L2 = {b} L1/L2 = {a, aa, aaa, aaaa} Unit-2

  16. Right quotient Theorem 4.4: If L1 and L2 are regular languages, then L1/L2 is also regular. Thus the family of regular languages is closed under right quotient with another regular language. Proof: By construction – see textbook, pp. 106-107. Unit-2

  17. The pigeonhole principle • The “pigeonhole principle” states that if n + 1 items are placed into n pigeonholes, then at least 1 pigeonhole must end up with more than 1 item in it. • In set notation: if f : A  B |A| = n + 1 |B| = n then f cannot be one-to-one Unit-2

  18. Not all formal languages are regular An automaton that accepts the language L = {akbk | k 0} must count the number of a’s in each string to make sure there is an identical number of b’s. There is no limit on how high the automaton might need to count to accept a string in this language. But an automaton with finite memory can only count as high as the size of its memory. This is an intuitive argument why this language is not regular. It is not a proof, however. To prove that a language is not regular, we use a mathematical result called the “pumping lemma for regular languages.” Unit-2

  19. 4.3: The Pumping Lemma • The Pumping Lemma is used to prove that a language is not regular • How do we prove that a language L is regular? • Write a regular expression for it • Draw a Finite Automaton for it • Construct a regular grammar for it Unit-2

  20. Pumping Lemma Theorem 4.8: Let L be a regular language. There exists a positive integer m such that for any string w  L with |w|  m, w may be written as w = xyz, for some x, y, and z satisfying the following: |xy|  m, |y|  1, and xyiz  L for every i  0 Unit-2

  21. Pumping Lemma In other words, every sufficiently long string in L can be broken down into three parts in such a way that an arbitrary number of repetitions of the middle part yields another string in L. We say that the middle string is “pumped,” hence the term pumping lemma. Unit-2

  22. Based on the idea of loops Given: M = (Q, S , d ,q0,A), where |Q| = n, and any string x where |x|  n , then x must pass through a sequence of n + 1 states. Suppose x = a1 a2 a3 ...an y. Then the sequence of n+1 states q0= d*(q0, l) q1= d*(q0, a1) q2= d*(q0, a1 a2) qn= d*(q0, a1 ...an) must contain some state at least twice, by the pigeonhole principle. Unit-2

  23. Example b a q0 q1 x = a |x| = 1 Sequence of states = q0 q1 n = Number of different states passed through = 2 Unit-2

  24. Example b a q0 q1 x = bba so |x| = 3 Sequence of states = q0 q0 q1 n = 2 Any string where |x|  n must have repeated a state Unit-2

  25. Pumping • If a state is repeated one or more times, it means that there must be a loop in the transition diagram. • If there is a loop, then it can be “pumped” to produce additional strings that belong to the language Unit-2

  26. Example • If ba is in the language, and there are only 2 states in the automaton, then a, bba, bbba, bbbba, etc. are also in the language. b a q0 q1 Unit-2

  27. Example of a nonregular language L = 0i1i | i  0 Is this regular? No. Why not? Intuitively: We can’t build a finite automaton to recognize it. Why not? Unit-2

  28. Example of a nonregular language L = 0i1i | i  0 Because the FA has no memory for past events except its states. Each state can tell you how you got to that state from the immediately previous state (i.e., the last character you processed), but, if there is a loop, it can’t remember the number of characters you processed up to that point. Unit-2

  29. Limits of a FA Being in state q1 and having just read a 1 doesn’t tell you anything about how many 1’s have already been processed. The FA simply doesn’t have the memory needed to retain this information. 0 1 l q0 q1 Unit-2

  30. Limits of a FA Moreover, if you have a loop like this in an FA, the FA must accept any number of 1’s in the loop. There is no way to specify “exactly as many 1’s as 0’s” – this FA can accept 000111, but must also accept 0111, 00001, etc. 0 1 l q0 q1 Unit-2

  31. Limits of an FA Consequently, we can’t build an FA that can tell whether the number of 0’s that it saw at the beginning of the string exactly matches the number of 1’s at the end of the string. But this is not a formal proof. Unit-2

  32. Proof idea If a DFA has n states, then any path of length n must visit n+1 states, and contains a cycle. (This is an application of the “pigeonhole principle.”) y z x This part of the string can be “pumped” to produce other strings in the language. Unit-2

  33. Proof idea again • If an infinite language is regular, it is accepted by a DFA. • The DFA has some finite number of states, say, m. • Because the language is infinite, some strings must have length > m. • For a string of length > m accepted by the DFA, a “walk” through the DFA must contain a cycle. • Repeating the cycle an arbitrary number of times must yield another string accepted by the DFA. Unit-2

  34. Proof Suppose that qi = qi+p , where 0  i < i + p  n x = uvw u = a1a2…ai v = ai+1a2…ai+p w = ai+p+1ai+p+2…any y = part of string longer than n + 1 Remember that qi = qi+p Unit-2

  35. Proof Assume a dfa with states labeled q0,q1,…qn Now take as string in L |w|  m = n +1 To process w the machine could go through a set of states say, q0, qi, qj, … qf. Since this sequence has exactly |w| +1 entries, at least one state must be repeated, and this repetition starts no later than the nth move. So the sequence of states must look like q0, qi, qj, …, qr, …qr, …, qf indicating there must be substrings x, y, z of w such that d*(q0, x) = qr d*(qr, y) = qr d*(qr, z) = qf with |xy|  n +1 = m and |y|  1 Unit-2

  36. Proof (cont.) From this it immediately follows that d*(q0, xz) = qf as well as d*(q0, xy2z) = qf, d*(q0, xy3z) = qf, and so on, completing the proof of the theorem Unit-2

  37. How to use the pumping lemma The Pumping Lemma describes a property that is possessed by every regular language. If we show that a language does not possess this property, we know that it is not regular. The strategy is proof by contradiction. We assume a language has the property described by the pumping lemma, and then we show that this leads to a contradiction. It follows that the language is not regular. Unit-2

  38. Example • Example 4.7: The language L = {anbn | n  0} is not regular. • The proof is by contradiction: • If L is regular, it must be accepted by some DFA. • Let m be the number of states of the DFA and consider some w  L such that |w|  m. • By the pumping lemma, we can split w into three pieces, w = xyz, such that for any n  0, the string xynz is in L. • So let w = ambm. • Because |xy|  m, y must consist of all a’s. • But then xy2z will contain more a’s than b’s. • This is a contradiction. Unit-2

  39. Homework Use the pumping lemma to show that the language of palindromes L = {w | w = wR, w  {a,b}*} is not regular. Unit-2

  40. Homework Use the pumping lemma (plus some closure properties of regular languages) to show that the language L = {w  {a,b}* | w contains equal number of a’s and b’s} is not regular. Unit-2

  41. Homework Use the pumping lemma to show that the language L = {ww | w  {a,b}*} is not regular. Unit-2

  42. THANK YOU Unit-2

More Related