Your SlideShare is downloading. ×
 0227 regularlanguages
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
  • 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

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
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
      • -> ←

×