Your SlideShare is downloading. ×
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

# 0227 regularlanguages

738
views

Published on

0 Comments
1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
Your message goes here
• Be the first to comment

No Downloads
Views
Total Views
738
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
50
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

### Transcript

• 1. Regular Languages
• Finite Automata
• eg. Supermarket automatic door:
exit or entrance
• 2. Finite Automata Door state Input signal State transition table State diagram OPEN OPEN OPEN CLOSED OPEN CLOSED CLOSED OPEN CLOSED CLOSED BOTH REAR FRONT NEITHER
• 3. Definition
• A finite automaton is a 5-tuple (Q,  ,  , q 0 , F)
• Q : a finite set called the states
•  : a finite set called the alphabet
•  : Qx   Q is the transition function
• q 0  Q is the start state
• F  Q is the set of accept states
final states
• 4.
• M 1 = (Q,  ,  , q 0 , F)
• Q = {q 1 , q 2 , q 3 }
•  = {0, 1}
•  : 0 1
• q 1 q 1 q 2
• q 2 q 3 q 2
• q 3 q 2 q 2
• q 1 : the start state
• F = {q 2 }
L(M) = A M recognizes A or M accepts A the set of all strings that M accepts L(M 1 ) = ?
• 5. q 2 q 3 q 2 q 3 q 2 q 3 100000 101011 M 2 =({q 1 ,q 2 }, {0,1},  , q 1 , {q 2 }) Eg:  : 0 1 q 1 q 1 q 2 q 2 q 1 q 2 L(M 2 ) =? M 2 : L(M 2 ) = {w | w ends in a 1}
• 6. M 3 : L(M 3 )=? L(M 3 )={  or ends in 0}
• 7. M 4 : Starts and ends with the same symbol
• 8. What is the language accepted by the above automata? 1 0 <RESET> 2 2 <RESET> 0 1 2 M 5 :  ={<RESET>, 0, 1, 2}
• 9. L(M 5 ) = {w | the sum of the symbols in w is 0 modulo 3 except the <RESET> resets to 0} M 5 :  ={<RESET>, 0, 1, 2}
• 10. Formal definition of computation
• M = (Q,  ,  , q 0 , F)
• w : a string over  , w i   , w = w 1 w 2 … w n
• M accepts w if a sequence of states r 0 , r 1 , …, r n exists in Q and satisfies the following 3 conditions:
• r 0 = q 0
•  ( r i , w i+1 ) = r i+1 , for i = 0, …, n-1
• r n  F
• 11.
• We say that M recognizes language A if A = { w | M accepts w }
• Def: A language is called a regular language if some finite automata recognizes it.
• 12. Designing finite automata
• Let A = { w | w is 0-1 string and w has odd number of 1}
• Is A a regular language ?
• What is the automata accepting A ?
• 13. Designing finite automata
• eg: Design a finite automaton to recognize all strings that contains 001 as a substring
• 14. Regular operations
• A, B : languages
• Regular operations : union, concatenation, star
• Union :
• A  B = { x | x  A or x  B}
• Concatenation :
• A 。 B = { x y | x  A and y  B}
• Star :
• A* = { x 1 x 2 … x k | k  0 and each x i  A }
• 15. Regular operations
• eg:  = { a, b, c, …, z} (26 letters) A = { good, bad} B = { boy, girl}
• A  B = { good, bad, boy, girl} A 。 B = {goodboy, goodgirl, badboy,badgirl} A* = {  , good, bad, goodbad, badgood, goodgood, badbad, goodgoodgood, goodgoodbad, ………}
• 16.
• eg. A 1 ={ w | w has odd number of 1}
• Q 1 = {q even , q odd }
•  = {0,1}
•  1 : 0 1 q even q even q odd q odd q odd q even
• q even : start state
• q odd : accept state
• 17.
• eg. A 2 ={ w | w has a 1}
• Q 2 = {q 1 , q 2 }
•  = {0,1}
•  2 : 0 1 q 1 q 1 q 2 q 2 q 2 q 2
• q 1 : start state
• q 2 : accept state
• 18.
• A 1  A 2 ={ w | w has odd number of 1 or w has a 1}
• Q= {(q even ,q 1 ), (q even ,q 2 ), (q odd ,q 1 ), (q odd ,q 2 )}
•  = {0, 1}
•  : 0 1 (q even , q 1 ) (q even , q 1 ) (q odd , q 2 ) (q even , q 2 ) (q even , q 2 ) (q odd , q 2 ) (q odd , q 1 ) (q odd , q 1 ) (q even , q 2 ) (q odd , q 2 ) (q odd , q 2 ) (q even , q 2 )
• (q even , q 1 ): start state
• (q odd , q 1 )(q odd , q 2 )(q even , q 2 ): accept state
• 19.
• 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 )
• 20.
• Pf : Let M 1 recognize A 1 , where M 1 = (Q 1 ,  ,  1 , q 1 , F 1 ) M 2 recognize A 2 , where M 2 = (Q 2 ,  ,  2 , q 2 , F 2 ) Goal: Construct M=(Q,  ,  , q 0 , F) to recognize A 1  A 2
• Q={(r 1 ,r 2 )|r 1  Q 1 and r 2  Q 2 }
•  is the same in M 1 , M 2
• For each (r 1 , r 2 )  Q and each a   , let  ((r 1 ,r 2 ), a)=(  1 (r 1 ,a),  2 (r 2 ,a))
• q 0 =(q 1 , q 2 ), (q 0 is a new state  Q 1  Q 2 )
• F={(r 1 , r 2 )|r 1  F 1 or r 2  F 2 }
• 21.
• Theorem: The class of regular languages is close under the concatenation (in other words, if A 1 and A 2 are regular languages, so is A 1 。 A 2 )
• 22. Nondeterminism:
• eg.
Deterministic Computation Non Deterministic Computation
• 23. Input : 0 1 0 1 1 0
• 24.
• eg:
• A : the language consisting of all strings over {0, 1} containing a 1 in the 3rd position from the end
• 25. 0 1 1 0 0 1
• 26.
• eg: What does the following automaton accept?
1. 2.   
• 27. Formal definition of a nondeterministic finite automaton
•   =  {  }, P (Q) : the collection of all subset of Q
• A nondeterministic finite automaton is a 5-tuple ( Q,  ,  , q 0 , F), where
• Q : a finite set of states
•  : a finite set of alphabet
•  : Qx    P (Q) transition function
• q 0  Q : start state
• F  Q : the set of accept states
• 28.
• eg.
• Q = {q 1 , q 2 , q 3 , q 4 }
•  = {0, 1}
•  : 0 1  q 1 {q 1 } {q 1 , q 2 }  q 2 {q 3 }  {q 3 } q 3  {q 4 }  q 4 {q 4 } {q 4 } 
• q 1 : start state
• q 4 : accept state
• 29.
• N=(Q,  ,  , q 0 , F ) ~NFA w : string over  , w= y 1 y 2 y 3 … y m , y i   r 0 ,r 1 ,r 2 ,…,r m  Q
• N accepts w if exists r 0 ,r 1 ,r 2 ,…,r m such that
• r 0 =q 0
• r i+1   (r i , y i+1 ), for i =0,…m-1
• r m  F
• 30. Equivalence of NFA and DFA
• Theorem : Every nondeterministic finite automaton has an equivalent deterministic finite automaton
• Pf: Let N=(Q,  ,  , q 0 , F) be the NFA recognizing A.
• Goal: Construct a DFA recognizing A
• 1. First we don’t consider  .
• Construct M= ( Q’,  ,  ’, q 0 ’, F’)
• 1. Q’= P (Q)
• 2. For R  Q’ and a  let
• 3. q 0 ’= {q 0 }
• 4. F’ = {R  Q’ | R contains an accept state of N}
• 31. Equivalence of NFA and DFA
• 2. Consider  :
• For any R  M, define E(R)={q | q can be reached from R by traveling along 0 or more  }
• Replace  (r,a) by E(  (r,a))
• Thus,  ’(R, a)={q  Q : q  E(  (r,a)) for some r  R}
• Change q 0 ’ to be E({q 0 })
• 32.
• Corollary: A language is regular if and only if some NFA recognizes it eq. D’s state :
• {  , {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}
• N 4 = ({1,2,3}, {a,b},  , 1, {1})
• 33.
• Construct a DFA D equivalent to N 4
• 34.
• eg. Convert the following NFA to an equivalent DFA
• E({q 0 }) = {q 0 }
• E(  ({q 0 },a)) = {q 1 ,q 2 }
• E(  ({q 0 },b)) = 
• E(  ({q 1 ,q 2 },a) = {q 1 ,q 2 }
• E(  ({q 1 ,q 2 },b) = {q 0 }
• 35. Closure under the regular operations
• Theorem : The class of regular language is closed under the union operation
• Pf: A 1 : N 1 : A 2 : N 2 :
• N 1 =(Q 1 ,  ,  1 , q 1 , F 1 ) for A 1
• N 2 =(Q 2 ,  ,  2 , q 2 , F 2 ) for A 2
A1  A2
• 36.
• Construct N=(Q,  ,  , q 0 , F) to recognize A1  A2
• Q : {q 0 }  Q 1  Q 2
• q 0 : start state
• F : F 1  F 2
• For q  Q and a    (q, a)=  1 (q, a), q  Q 1  2 (q, a), q  Q 2 {q 1 , q 2 }, q=q 0 and a=   , q=q 0 and a 
• 37.
• Theorem : The class of regular language is closed under the concatenation operation
• Pf: N 1 : N 2 :
• N 1 =(Q 1 ,  ,  1 , q 1 , F 1 ) recognize A 1
• N 2 =(Q 2 ,  ,  2 , q 2 , F 2 ) recognize A 2
A1 。 A2
• 38.
• Construct N=(Q,  ,  , q 1 , F 2 ) to recognize A1 。 A2
• Q : Q 1  Q 2
• q 1 : start state
• F 2 : accept state
•  (q, a) =  1 (q, a), q  Q 1 and q  F 1  1 (q, a), q  F 1 and a   1 (q, a)  {q 2 }, q  F 1 and a=   2 (q, a), q  Q 2
q  Q, a 
• 39.
• Theorem : The class of regular language is closed under the star operation
• Pf: A: A*:
• N 1 =(Q 1 ,  ,  1 , q 1 , F 1 ) recognize A
A = {a, b} A* = {  , a, b, …}  , A A 。 A = {aa, ab, ba, bb} A 。 A 。 A …
• 40.
• Construct N=(Q,  ,  , q 0 , F) to recognize A*
• Q : { q 0 }  Q
• q 0 : start state
• F : { q 0 }  F
•  (q, a) =  1 (q, a), q  Q 1 and q  F 1  1 (q, a), q  F 1 and a   1 (q, a)  {q 1 }, q  F 1 and a=  {q 1 }, q=q 0 and a=   q=q 0 and a 
• 41. Regular Expressions
• AWK, GREP in UNIX PERL, text editors.
• eg. (0  1)0* = ({0}  {1}) 。 {0}*
• eg. (0  1)* = {0, 1}*
• 42. Formal definition of a regular expression
• Definition: R is a regular expression if R is
• a  
• (R 1  R 2 ), R 1 and R 2 are regular
• (R 1 。 R 2 ), R 1 and R 2 are regular
• (R 1 * ), R 1 is regular expression
Inductive definition
• 43.
• eg.  = {0, 1}
• 0*10* = { w : w has exactly a single 1}
•  *1  *
•  *001  *
• (  )*
• 01  10
• 0  *0  1  *1  0  1
• (0  )1*=01*  1*
• (0  )(1  ) = {  , 0, 1, 01}
• 1*  = 
•  * = {  }
• 44.
• eg. R : regular expression R  = R R 。  = R
• R   ?=R R 。  ?= R R = {0} R 。  = 
• 45. Equivalence with finite automata
• Theorem: A language is regular if and only if some regular expression describes it
• Lemma: (  ) If a language is described by a regular expression then it is regular
• 46.
• Pf: Let R be a regular expression describing some language A Goal: Convert R into an NFA N.
• R=a   , L(R)={a}
• R=  , L(R)={  }
• R=  , L(R)= 
• R = R 1  R 2
• R = R 1 。 R 2
• R = R 1 *
• 47.
• eg. (ab  a)*
• a
• b
• ab
• ab  a
• (ab  a)*
• 48.
• eg. (a  b)*aba
• a
• b
• a  b
• (a  b)*
• aba
• 49.
• (a  b)*aba
• 50. Generalized nondeterministic finite automaton (GNFA)
• ( Q,  ,  , q start , q accept )  : (Q - {q accept }) x (Q - {q start })  R
Set of all regular expressions over   (q i , q j ) = R
• 51.
• Lemma: (  ) If a language is regular, then it is described by a regular expression
• Pf: a language A is regular  There is a DFA M accepting A
• Goal: Convert DFAs into equivalent regular expressions
• 52.
• A GNFA accepts a string w in  * if w = w 1 w 2 …w k , where each w i is in  * and a sequence of states q 0 q 1 q 2 …q k exists s.t.
• q 0 = q start is the start state
• q k = q accept is the accept state
• for each i , we have w i  L(R i ), where R i =  (q i-1 , q i )
• DFA M --------------------  GNFA G
• Convert (G) : takes a GNFA and return an equivalent regular expression
start state adding accept state transition arrows
• 53. Convert(G)
• Convert(G)
• Let k be the number of states of G
• If k=2, return R
• If k>2, select any q rip  Q (  q start ,q accept ), Let G’ = GNFA(Q’,  ,  ’, q start , q accept ), where Q’=Q-{q rip } , and for any q i  Q’-{q accept } and any q j  Q’-{q start }, let  ’(q i , q j ) = (R 1 )(R 2 )*(R 3 )  (R 4 )
• Compute CONVERT(G’) and return this value
• 54.
• Claim: For any GNFA G, CONVERT(G) is equivalent to G.
• Pf: By induction on k, the number of states of the GNFA
• Basis: It is clear for k=2
• 55. Induction step
• Assume that the claim is true for k-1 states
• Suppose G accepts an input w , Then in an accepting branch of the computation G enters a sequence of states: q start , q 1 , q 2 , …, q accept
• If none of them is q rip , G’ accepts w .
• If q rip does appear in the above states, removing each run of consecutive q rip states forms an accepting computation for G’
• Suppose G’ accepts an input w G’: G: or
• ⇒ G accepts w
• G ≅ G’, by induction hypothesis, the claim is true
• 56. example
• eg:
• 57. example
• 58. Pumping lemma for regular languages
• Is {0 n 1 n : n ≥ 0} regular? How can we prove a language non-regular?
• Theorem: (Pumping Lemma) If A is a regular language, then there is a number P (the pumping length) where, if s is any string in A of length ≥ P , then s may be divided into 3 pieces, s = x yz , satisfying the following conditions:
• for each i ≥ 0, x y i z ∈ A
• | y | > 0
• | x y | ≤ P
• 59.
• proof
• M=(Q, Σ , δ ,q 1 , F) : a DFA recognizing A
• P =|Q|: number of state of M
• s = s 1 s 2 … s n ∈ A, n ≥ P
• r 1 , r 2 , …, r n+1 : the seq. of states M enters while processing
• r i+1 = δ (r i , s i ) for 1 ≤ i ≤ n. By pigeonhole principle , there must be 2 identical states, say r j =r l , x = s 1 … s j-1 , y = s j …s l-1 , z = s l …s n
• x takes M from r 1 to r j , y takes M from r j to r j , and z takes M from r j to r n+1 M must accept x y i z for i ≥ 0 ∵ j ≠ l , | y |=| s j …s l-1 |>0, l ≤ P +1, so | x y | ≤ P
• 60.
• B={0 n 1 n : n ≥0 } is not regular
• proof:
• Suppose B is regular
• Let P be the pumping length
• Choose s = 0 P 1 P = 0…01…1 ∈ B
• Let s = x yz , By pumping lemma, for any i ≥0 x y i z ∈ B. But
• 0…001…1 : y has 0 only ⇒ ->←
• 0…01…1 : y has 1 only ⇒ ->←
• 0…01…1 : y has both 0 and 1 ⇒ x yyz ∉ B
• 61.
• C={ w | w has an equal number of 0s and 1s} is not regular
• proof: (By pumping lemma)
• Let P be the pumping length, Suppose C is regualr
• Let s = 0 P 1 P ∈ C, By pumping lemma, s can be split into 3 pieces, s = x yz , and x y i z ∈ C for any i ≥0
• By condition 3 in the lemma: | x y | ≤ P Thus y must have only 0s. Then x yyz ∉ C
• 62.
• proof: (Not by pumping lemma)
• Suppose C is regular
• It is clear that 0*1* is regualr
• Then C ∩ 0*1*={0 n 1 n : n ≥0 } is regular ->←
• 63.
• F={ ww | w ∈{0,1}* } is nonregular
• proof:
• Suppose F is regular
• Let P be the pumping length given by the pumping lemma
• Let s = 0 P 10 P 1 ∈ F
• Split s into 3 pieces, s = x yz
• By condition 3 in the lemma: | x y | ≤ P Thus y must have 0 only. ⇒ x yyz ∉ F 0…010…01 ->←
w y
• 64.
• E={0 i 1 j : i > j } is nonregular
• proof:
• Assume E is regular
• Let P be the pumping length
• Let s = 0 P+1 1 P ∈ E
• Split s into 3 pieces, s = x yz
• By pumping lemma: x y i z ∈ E for any i ≥ 0 | y |>0, y have 0 only. x z ∈ E. But x z has #(0) ≤ #(1)
• 65.
• D={1 n 2 : n ≥ 0 } is not regular
• proof:
• Assume D is regular
• Let P be the pumping length
• Let s = 1 P 2 ∈ D
• Split s into 3 pieces, s = x yz ⇒ x y i z ∈ D, i ≥ 0
• Consider x y i z ∈ D and x y i+1 z ∈ D ⇒ | x y i z | and | x y i+1 z | are perfect squre for any i ≥ 0
• If m=n 2 , (n+1) 2 - n 2 =2n+1 = 2 +1
• 66.
• Let m =| x y i z |
• | y | ≤ | s |= P 2
• Let i = P 4 | y |= | x y i+1 z |-| x y i z | ≤ P 2 = ( P 4 ) 1/2
• < 2( P 4 ) 1/2 +1
• ≤ 2(| x y i z |) 1/2 +1
• = 2 +1
• -> ←