1 / 30

CSCI 2670 Introduction to Theory of Computing

CSCI 2670 Introduction to Theory of Computing. September 13. Agenda. Last class Example DFA construction (on board) Equivalence of RE’s and regular languages GNFA’s Today More on equivalence of RE’s and regular languages Non-regular languages? Tomorrow Dr. Canfield returns.

nola
Download Presentation

CSCI 2670 Introduction to Theory of Computing

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. CSCI 2670Introduction to Theory of Computing September 13

  2. Agenda • Last class • Example DFA construction (on board) • Equivalence of RE’s and regular languages • GNFA’s • Today • More on equivalence of RE’s and regular languages • Non-regular languages? • Tomorrow • Dr. Canfield returns

  3. RE’s and regular languages Theorem: A language is regular if and only if some regular expression describes it. • i.e., every regular expression has a corresponding DFA and vice versa

  4. GNFA’s • To prove every DFA can be described using an RE, we introduce GNFA’s • A GNFA is an NFA with the following properties: • The start state has transition arrows going to every other state, but no arrows coming in from any other state • There is exactly one accept state and there is an arrow from every other state to this state, but no arrows to any other state from the accept state • The start state is not the accept state

  5. GNFA’s (continued) • Except for the start and accept states, one arrow goes from every state to every other state and also from each state to itself • Instead of being labeled with symbols from the alphabet, transitions are labeled with regular expressions

  6. Equivalence of DFA’s and RE’s • First show every DFA can be converted into a GNFA that accepts the same language • Then show that any GNFA has a corresponding RE that accepts the same language

  7. 0 q2 1 qs qt q1 1 ε ε 0 q3 q4 0,1 0,1 Converting a DFA to a GNFA Add two new states

  8. qs qt ε ε Converting a DFA to a GNFA • All transition labels with multiple labels are relabeled with the union of the previous labels 0 q2 1 q1 1 0 q3 q4 0,1 01 0,1 01

  9. qs qt ε ε Converting a DFA to a GNFA • All pairs of states without transitions get a transition labeled  0 q2 1 q1 1 0 q3 q4 01 01

  10. qs qt ε ε Converting a DFA to a GNFA • The resulting state diagram is a GNFA • All GNFA properties are satisfied 0 q2 1 q1 1 0 q3 q4 01 01

  11. qs qt ε ε Converting a DFA to a GNFA • No step changed the strings accepted by the machine 0 q2 1 q1 1 0 q3 q4 01 01

  12. Converting a GNFA to a RE • If the GNFA has two states, then the label connecting the states is the RE • Otherwise, remove one state at a time without changing the language accepted by the machine until the GNFA has two states

  13. a12 q2 q1 a32 a13 q3 a33 Removing one state from a GNFA a12a13a33*a32 q1’ q2’

  14. a12 a22 a11 q2 q1 a21 a13 a32 a23 a31 q3 a33 Accounting for loops a22a23a33*a32 a11a13a33*a31 a12a13a33*a32 q1’ q2’ a21a23a33*a31

  15. Every DFA has a corresponding RE Proof: Let M be any DFA and let w be any string in Σ*. Convert M to G, a GNFA, then convert G to R, a regular expression, using methods shown in class. • Want to show wL(M) iff wL(R). • First show wL(M) iff wL(G). • Then show wL(G) iff wL(R).

  16. wL(M) iff wL(G) • Let w = w1w2…wn, where each wi  Σ. • w  L(M) • iff there is a sequence of states q1, q2, …, qn+1 such that • q1 = q0 • qn+1F • qi+1 = (qi,wi) for each i = 1, 2, …, n • iff when w is read by G, the sequence of states qs, q1, q2, …, qn+1, qt would accept w • iff wL(G)

  17. wL(G) iff wL(R) • Prove by induction on number of states in G Base case: If G has 2 states then clearly wL(G) iff wL(R). Induction step: Assume wL(G) iff wL(R) for every G with k-1 states. Prove w  L(G) iff wL(R) for every G with k states.

  18. wL(R) if wL(G) Assume wL(G) and an accepting branch of the computation G enters on w is qs, q1, q2, …, qt. Let G’ be the GNFA that results from removing one of G’s states, qrip. There are two possibilities: Case 1: qrip is never entered in the computation of w. Then the same branch of computation exists in G’.

  19. wL(R) if wL(G) Assume wL(G) and an accepting branch of the computation G enters on w is qs, q1, q2, …, qt. Let G’ be the GNFA that results from removing one of G’s states, qrip. There are two possibilities: Case 2: qrip is entered in the computation of w (bracketed byqi and qj). Then the new transition between qi and qj in G’ describes the computation that could be done on the computation of w through the branch qi, qrip, qj. So G’ accepts w. By induction wL(R).

  20. wL(G) if wL(R) Assume wL(R). By induction hypothesis, wL(G’), the k-1 state GNFA resulting from removing one state from G. By construction, any computation in G’ can also be done in G – possibly going through an extra state qrip. Therefore, wL(G).

  21. 1 1 0 q1 q2 0 Example

  22. qs qt Example 1 1 0 q1 q2 0 ε ε Step 1: Add two new states

  23. qs qt Example 1 101*0 1 0 q1 q2 0 ε ε 1*0 Step 2: Remove q1

  24. qs qt Example 101*0 q2 ε 1*0 1*0(101*0)* Step 3: Remove q2

  25. 1 1 0 q1 q2 0 Example So this DFA Is equivalent to the regular expression 1*0(101*0)*

  26. Nonregular languages • So far, we have explored several ways to identify regular languages • DFA’s, NFA’s, GNFA’s, RE’s • There are many nonregular languages • {0n1n | n  0} • {101,101001,1010010001,…} • {w | w has the same number of 0s and 1s} • How can we tell if a language is not regular?

  27. Property of regular languages • All regular languages can be generated by finite automata • States must be reused if the length of a string is greater than the number of states • If states are reused, there will be repetition

  28. The pumping lemma Theorem: If A is a regular language, then there is a number p 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 • for each i  0, xyizis in A • |y| > 0, and • |xy|  p p is called the pumping length

  29. Proof idea • Pumping length is equal to the number of states in the DFA whose language is A • p = |Q| • If A accepts a word w with |w| > p, then some state must be entered twice while processing w • Pigeonhole principle

  30. y x z Proof idea • for each i  0, xyizis in A • |y| > 0, and • |xy|  p

More Related