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

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

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: 1.The start state has transition arrows going to every other state, but no arrows coming in from any other state 2.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 3.The start state is not the accept state

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

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

Converting a DFA to a GNFA Add two new states ε ε qsqs qtqt q1q1 q2q2 q3q3 q4q4 0,1

Converting a DFA to a GNFA ε ε qsqs qtqt q1q1 q2q2 q3q3 q4q4 0,1 All transition labels with multiple labels are relabeled with the union of the previous labels 0101 0101

Converting a DFA to a GNFA ε ε qsqs qtqt q1q1 q2q2 q3q3 q4q4 All pairs of states without transitions get a transition labeled  0101 0101

Converting a DFA to a GNFA ε ε qsqs qtqt q1q1 q2q2 q3q3 q4q4 The resulting state diagram is a GNFA –All GNFA properties are satisfied 0101 0101

Converting a DFA to a GNFA ε ε qsqs qtqt q1q1 q2q2 q3q3 q4q4 No step changed the strings accepted by the machine 0101 0101

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

Removing one state from a GNFA q1’q1’ q2’q2’ a 13 a 32 a 12 a 33 q2q2 q1q1 q3q3 a 12  a 13 a 33 * a 32

Accounting for loops a 11  a 13 a 33 * a 31 q1’q1’ q2’q2’ a 31 a 13 a 32 a 23 a 21 a 12 a 33 a 22 q2q2 q1q1 q3q3 a 11 a 22  a 23 a 33 * a 32 a 21  a 23 a 33 * a 31 a 12  a 13 a 33 * a 32

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).

w  L(M) iff w  L(G) Let w = w 1 w 2 …w n, where each w i  Σ. w  L(M) iff there is a sequence of states q 1, q 2, …, q n+1 such that q 1 = q 0 q n+1  F q i+1 =  (q i,w i ) for each i = 1, 2, …, n iff when w is read by G, the sequence of states q s, q 1, q 2, …, q n+1, q t would accept w iff w  L(G)

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.

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

w  L(R) if w  L(G) Assume w  L(G) and an accepting branch of the computation G enters on w is q s, q 1, q 2, …, q t. Let G’ be the GNFA that results from removing one of G’s states, q rip. There are two possibilities: Case 2: q rip is entered in the computation of w (bracketed byq i and q j ). Then the new transition between q i and q j in G’ describes the computation that could be done on the computation of w through the branch q i, q rip, q j. So G’ accepts w. By induction w  L(R).

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 q rip. Therefore, w  L(G).

Example 1 q1q1 q2q

1 q1q1 q2q qsqs qtqt Step 1: Add two new states ε ε

Example 1 q1q1 q2q qsqs qtqt Step 2: Remove q 1 ε 1*01*0 101*0101*0 ε

Example q2q2 qsqs qtqt Step 3: Remove q 2 1*01*0 101*0101*0 ε 1 * 0(1  01*0) *

Example 1 q1q1 q2q So this DFA Is equivalent to the regular expression 1 * 0(1  01 * 0) *

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 –{0 n 1 n | n  0} –{101,101001, ,…} –{w | w has the same number of 0s and 1s} How can we tell if a language is not regular?

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

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 1.for each i  0, xy i z is in A 2.|y| > 0, and 3.|xy|  p p is called the pumping length

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

Proof idea 1.for each i  0, xy i z is in A 2.|y| > 0, and 3.|xy|  p x y z