Transcript Document

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
0
1
qs
ε
q1
q2
1
0
q3
ε
0,1
q4
0,1
Add two new states
qt
Converting a DFA to a GNFA
0
1
qs
ε
q1
q2
1
0
q3
ε
0,1
01
q4
qt
0,1
01
• All transition labels with multiple
labels are relabeled with the union of
the previous labels
Converting a DFA to a GNFA
0
1
qs
ε
q1
q2
1
0
q3
ε
01
q4
qt
01
• All pairs of states without transitions
get a transition labeled 
Converting a DFA to a GNFA
0
1
qs
ε
q1
q2
1
0
q3
ε
01
q4
01
• The resulting state diagram is a
GNFA
– All GNFA properties are satisfied
qt
Converting a DFA to a GNFA
0
1
qs
ε
q1
q2
1
0
q3
ε
01
q4
qt
01
• No step changed the strings accepted
by the machine
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
a12
a12a13a33*a32
q2
q1
q 1’
a32
a13
q3
a33
q2 ’
Accounting for loops
a11a13a33*a31
a12
a11
q1
a22
q2
a21
a13
a32
a31
q3
a33
a23
q 1’
a22a23a33*a32
a12a13a33*a32
a21a23a33*a31
q2 ’
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 = 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)
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 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’.
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).
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).
Example
1
1
0
q1
0
q2
Example
1
ε
1
0
q1
0
q2
ε
qs
qt
Step 1: Add two new states
Example
1
ε
qs
*0
1
101
0
q1
0
q2
1*0
Step 2: Remove q1
ε
qt
Example
101*0
q2
qs
1*0
1*0(101*0)*
Step 3: Remove q2
ε
qt
Example
So this DFA
1
1
0
q1
0
q2
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
– {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?
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, xyiz 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
y
x
1. for each i  0, xyiz is in A
2. |y| > 0, and
3. |xy|  p
z