LEC2

Computational Models - Lecture 2
Non-Deterministic Finite Automata (NFA)

Slides modied by Benny Chor, based on original slides by Maurice Herlihy, Brown University. p.1
Closure of Regular Languages Under
, ,

, ,

Regular expressions
, ,

Regular expressions
Equivalence with nite automata
, ,

Regular expressions
, ,

Regular expressions
Sipsers book, 1.1-1.3
DFA Formal Denition (reminder)
A deterministic nite automaton (DFA) is a 5-tuple
(Q, , , q
0
, F), where
Q is a nite set called the states,
is a nite set called the alphabet,
: Q Q is the transition function,
q
0
Q is the start state, and
F Q is the set of accept states.
Languages and DFA (reminder)
Denition: Let L ( L
) be the set of strings that

M accepts. L(M), the language of a DFA M, is
dened as L(M) = L.
Denition: Let L ( L

dened as L(M) = L.
Note that
M may accept many strings, but
M accepts only one language.
Denition: Let L ( L

dened as L(M) = L.
Note that
M may accept many strings, but
M accepts only one language.
Alanguage is called regular if some deterministic nite
automaton accepts it.
The Regular Operations (reminder)
Let A and B be languages.
The union operation:
AB = {x|x A or x B}
The concatenation operation:
AB = {xy|x A and y B}
The star operation:
A
= {x
1
x
2
. . . x
k
|k 0 and each x
i
A}
Claim: Closure Under Union (reminder)
If A
1
and A
2
are regular languages, so is A
1
A
2
.
Claim: Closure Under Union (reminder)
If A
1
and A
2
are regular languages, so is A
1
A
2
.
Approach to Proof:
some M
1
accepts A
1
some M
2
accepts A
2
construct M that accepts A
1
A
2
.
What About Concatenation?
Thm: If L
1
, L
2
are regular languages, so is L
1
L
2
.
Example: L
1
= {good, bad} and L
2
= {boy, girl}.
L
1
L
2
= {goodboy, goodgirl, badboy, badgirl}
Thm: If L
1
, L
2
1
L
2
.
Example: L
1
= {good, bad} and L
2
= {boy, girl}.
L
1
L
2
This is much harder to prove.
Idea: Simulate M
1
for a while, then switch to M
2
.
Thm: If L
1
, L
2
1
L
2
.
Example: L
1
= {good, bad} and L
2
= {boy, girl}.
L
1
L
2
This is much harder to prove.
Idea: Simulate M
1
for a while, then switch to M
2
.
Problem: But when do you switch?
This leads us into non-determinism.
Non-Deterministic Finite Automata
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
an NFA may have more than one transition
labeled with the same symbol,
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
an NFA may have no transitions labeled with a
certain symbol, and
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
certain symbol, and
an NFA may have transitions labeled with , the
empty string.
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
certain symbol, and
an NFA may have transitions labeled with , the
empty string.
Comment: Every DFA is also a non-deterministic
nite automata (NFA).
Non-Deterministic Computation
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
What happens when more than one transition is
possible?
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
possible?
the machine splits into multiple copies
each branch follows one possibility
together, branches follow all possibilities.
If the input doesnt appear, that branch dies.
Automaton accepts if some branch accepts.
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
possible?
the machine splits into multiple copies
each branch follows one possibility
together, branches follow all possibilities.
If the input doesnt appear, that branch dies.
Automaton accepts if some branch accepts.
What does an transition do?
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
What happens on string 1001?
The String 1001
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
The String 1001
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
q
4
q
1
q
3
q
1
q
2
q
1
q
2
q
3
q
1
q
3
q
1
q
4
1
0
0
1
symbol
Why Non-Determinism?
Theorem (to be proved soon): Deterministic and
non-deterministic nite automata accept exactly the
same set of languages.
Q.: So why do we need them?
A.: NFAs are usually easier to design than equivalent
DFAs.
A.: NFAs are usually easier to design than equivalent
DFAs.
Example: Design a nite automaton that accepts all
strings with a 1 in their third-to-the-last position?
Solving with DFA
1
q
000
q
111
q
001
q
010
q
011
q
100
q
101
q
110
0
0 0
0
0 0 0
1 1
1
1 1 1
Solving with DFA
1
q
000
q
111
q
001
q
010
q
011
q
100
q
101
q
110
0
0 0
0
0 0 0
1 1
1
1 1 1
(oops, there are two errors:
Solving with DFA
1
q
000
q
111
q
001
q
010
q
011
q
100
q
101
q
110
0
0 0
0
0 0 0
1 1
1
1 1 1
(oops, there are two errors: q
101
should be an accept
state, and there should be a 0" labeled arrow from
q
011
to q
110
, but overall it is OK.)
Solving with NFA
q
4
q
1
q
2
q
3
1
0,1
0,1 0,1
Guesses which symbol is third from the last,
and
checks that indeed it is a 1.
NFA Formal Denition
Transition function is going to be different.
P(Q) is the powerset of Q.
= {}.
NFA Formal Denition
Transition function is going to be different.
P(Q) is the powerset of Q.
= {}.
A non-deterministic nite automaton is a 5-tuple
(Q, , , q
0
, F), where
Q is a nite set called the states,
is a nite set called the alphabet,
: Q
P(Q) is the transition function,

q
0
F Q is the set of accept states.
Example
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
N
1
= (Q, , , q
1
, F) where
Q = {q
1
, q
2
, q
3
, q
4
}, = {0, 1},
Example
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
N
1
= (Q, , , q
1
, F) where
Q = {q
1
, q
2
, q
3
, q
4
}, = {0, 1},
is
0 1
q
1
{q
1
, q
2
} {q
1
}
q
2
{q
3
} {q
3
}
q
3
{q
4
}
q
4
{q
4
} {q
4
}
Example
q
4
q
1
q
2
q
3
0
0,1 0,1
1 0,
N
1
= (Q, , , q
1
, F) where
Q = {q
1
, q
2
, q
3
, q
4
}, = {0, 1},
is
0 1
q
1
{q
1
, q
2
} {q
1
}
q
2
{q
3
} {q
3
}
q
3
{q
4
}
q
4
{q
4
} {q
4
}
q
1
is the start state, and F = {q
4
}.
Formal Model of Computation
Let M = (Q, , , q
0
, F) be an NFA, and
w be a string over
that has the form

y
1
y
2
y
m
where y
i

.
u be the string over obtained from w by
omitting all occurances of .
Let M = (Q, , , q
0
, F) be an NFA, and
w be a string over
that has the form

y
1
y
2
y
m
where y
i

.
Suppose there is a sequence of states (in Q),
r
0
, . . . , r
n
, such that
r
0
= q
0
r
i+1
(r
i
, y
i+1
), 0 i < n
r
n
F
Let M = (Q, , , q
0
, F) be an NFA, and
w be a string over
that has the form

y
1
y
2
y
m
where y
i

.
Suppose there is a sequence of states (in Q),
r
0
, . . . , r
n
, such that
r
0
= q
0
r
i+1
(r
i
, y
i+1
), 0 i < n
r
n
F
Then we say that M accepts u.
Equivalence of NFAs and DFAs
Given an an NFA, N, we construct a DFA, M,
that accepts the same language.
To begin with, we make things easier by ignoring
transitions.
transitions.
Make DFA simulate all possible NFA states.
transitions.
Make DFA simulate all possible NFA states.
As consequence of the construction, if the NFA
has k states, the DFA has 2
k
states.
Let N = (Q, , , q
0
, F) be the NFA accepting A.
Construct a DFA M = (Q
, ,
, q
0
, F
).
Q
= P(Q).
Let N = (Q, , , q
0
, ,
, q
0
, F
).
Q
= P(Q).
For R Q
and a , let
(R, a) = {q Q|q (r, a) for some r R}

Let N = (Q, , , q
0
, ,
, q
0
, F
).
Q
= P(Q).
For R Q
and a , let

q
0
= {q
0
}
Let N = (Q, , , q
0
, ,
, q
0
, F
).
Q
= P(Q).
For R Q
and a , let

q
0
= {q
0
}
F
= {R Q
|R contains an accept state of N}
Dealing with -Transitions
For any state R of M, dene E(R) to be the collection
of states reachable from R by transitions only.
E(R) = {q Q|q can be reached from some r R
by 0 or more transitions}
Dene transition function:
(R, a) = {q Q| there is some r R

such that q E((r, a))}
Dene transition function:
(R, a) = {q Q| there is some r R

such that q E((r, a))}
Change start state to
q
0
= E({q
0
})
Regular Languages, Revisited
By denition, a language is regular if it is accepted by
some DFA.
some DFA.
Corollary: A language is regular if and only if it is
accepted by some NFA.
some DFA.
This is an alternative way of characterizing regular
languages.
some DFA.
This is an alternative way of characterizing regular
languages.
We will now use the equivalence to show that regu-
lar languages are closed under the regular operations
(union, concatenation, star).
Closure Under Union (alternative proof)
N
1
N
2
Regular Languages Closed Under Union
N
1
N
2
Regular Languages Closed Under Union
Suppose
N
1
= (Q
1
, ,
1
, q
1
, F
1
) accept L
1
, and
N
2
= (Q
2
, ,
2
, q
2
, F
2
) accept L
2
.
Dene N = (Q, , , q
0
, F):
Q = q
0
Q
1
Q
2
is the same, q
0
is the start state
F = F
1
F
2
(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 =
Regular Languages Closed Under
Concatenation
N
2
N
1
Regular Languages
Closed Under Concatenation
N
2
N
1

Regular Languages
Suppose
N
1
= (Q
1
, ,
1
, q
1
, F
1
) accept L
1
, and
N
2
= (Q
2
, ,
2
, q
2
, F
2
) accept L
2
.
Dene N = (Q, , , q
1
, F
2
):
Q = Q
1
Q
2
Regular Languages
Suppose
N
1
= (Q
1
, ,
1
, q
1
, F
1
) accept L
1
, and
N
2
= (Q
2
, ,
2
, q
2
, F
2
) accept L
2
.
Dene N = (Q, , , q
1
, F
2
):
Q = Q
1
Q
2
q
1
is the start state of N
Regular Languages
Suppose
N
1
= (Q
1
, ,
1
, q
1
, F
1
) accept L
1
, and
N
2
= (Q
2
, ,
2
, q
2
, F
2
) accept L
2
.
Dene N = (Q, , , q
1
, F
2
):
Q = Q
1
Q
2
q
1
is the start state of N
F
2
is the set of accept states of N
(q, a) =
1
(q, a) q Q
1
and q / F
1
1
(q, a) q Q
1
and a =
1
(q, a) {q
2
} q F
1
and a =
2
(q, a) q Q
2
Regular Languages Closed Under Star
N
1
N
1
N
1
N
1
N
1
Oops - bad construction. How do we x it?

N
1
accepts R
1
. Wanna build NFA for R = (R
1
)
N
1
accepts R
1
1
)
GG
gg
GG
`
GG _
_

?
?
?
N
1
accepts R
1
1
)
GG
gg
GG
`
GG _
_

?
?
?
GG ` _ \
q
0
GG
gg
GG
`
GG _
_

?
?
?
`

N
1
accepts R
1
1
)
GG
gg
GG
`
GG _
_

?
?
?
GG ` _ \
q
0
GG
gg
GG
`
GG _
_

?
?
?
`

Ahaa - a better construction!

Suppose N
1
= (Q
1
, ,
1
, q
1
, F
1
) accepts L
1
.
Dene N = (Q, , , q
0
, F):
Q = {q
0
} Q
1
Suppose N
1
= (Q
1
, ,
1
, q
1
, F
1
) accepts L
1
.
Dene N = (Q, , , q
0
, F):
Q = {q
0
} Q
1
q
0
is the new start state.
Suppose N
1
= (Q
1
, ,
1
, q
1
, F
1
) accepts L
1
.
Dene N = (Q, , , q
0
, F):
Q = {q
0
} Q
1
q
0
is the new start state.
F = {q
0
F
1
}
(q, a) =
1
(q, a) q Q
1
and q / F
1
1
(q, a) q F
1
and a =
1
(q, ) {q
1
} q F
1
and a =
{q
1
} q = q
0
and a =
q = q
0
and a =
Summary
Regular languages are closed under
Summary
union
Summary
union
concatenation
Summary
union
concatenation
star
Summary
union
concatenation
star
Non-deterministic nite automata
Summary
union
concatenation
star
are equivalent to deterministic nite automata
Summary
union
concatenation
star
are equivalent to deterministic nite automata
but much easier to use in some proofs and
constructions.
Regular Expressions
A notation for building up languages by describing
them as expressions, e.g. (0 1)0
.
0 and 1 are shorthand for {0} and {1}
Regular Expressions
.
so (0 1) = {0, 1}.
Regular Expressions
.
so (0 1) = {0, 1}.
0
is shorthand for {0}
.
Regular Expressions
.
so (0 1) = {0, 1}.
0
.
concatenation, like multiplication, is implicit, so
0
10
is shorthand for the set of all strings over

= {0, 1} having exactly a single 1.
Regular Expressions
.
so (0 1) = {0, 1}.
0
.
0
10

Q.: What does (0 1)0
stand for?
Regular Expressions
.
so (0 1) = {0, 1}.
0
.
0
10

Q.: What does (0 1)0
stand for?
Remark: Regular expressions are often used in text
editors or shell scripts.
More Examples
Let be an alphabet.
The regular expression is the language of
one-symbol strings.
is all strings.
1 all strings ending in 1.

0
1 strings starting with 0 or ending in 1.

More Examples
Let be an alphabet.
The regular expression is the language of
one-symbol strings.
is all strings.
1 all strings ending in 1.

0
1 strings starting with 0 or ending in 1.

Just like in arithmetic, operations have precedence:
star rst
concatenation next
union last
parentheses used to change usual order
Regular Expressions Formal Denition
Syntax: R is a regular expression if R is of form
a for some a
a for some a
a for some a
a for some a
(R
1
R
2
) for regular expressions R
1
and R
2
a for some a
(R
1
R
2
1
and R
2
(R
1
R
2
1
and R
2
a for some a
(R
1
R
2
1
and R
2
(R
1
R
2
1
and R
2
(R
1
) for regular expression R
1
Let L(R) be the language denoted by regular
expression R.
R L(R)
a {a}
{}
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
)
L(R
1
)
expression R.
R L(R)
a {a}
{}
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
)
L(R
1
)
Q.: Whats the difference between and ?

expression R.
R L(R)
a {a}
{}
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
R
2
) L(R
1
) L(R
2
)
(R
1
)
L(R
1
)
Q.: Whats the difference between and ?

Q.: Isnt this denition circular?
Remarkable Fact
Thm.: A language, L, is described by a regular
expression, R, if and only if L is regular.
Remarkable Fact
=construct an NFA accepting R.
Remarkable Fact
=construct an NFA accepting R.
= Given a regular language, L, construct an
equivalent regular expression.
Given R, Build NFA Accepting It (=)
1. R = a , for some a
a
a
2. R =
a
2. R =
3. R =
N
1
N
2
N
2
N
1

R = (R
1
R
2
) R = (R
1
R
2
)
R = (R
1
)
GG ` _ \
q
0
GG
gg
GG
`
GG _
_

?
?
?
`

Approximately (?) Correct Example
a
a
b
b
a b
ab
a b
a
ab
U
a
Regular Expression from an NFA (=)
We now dene generalized non-deterministic nite
automata (GNFA).
automata (GNFA).
An NFA:
Each transition labeled with a symbol or ,
reads zero or one symbols,
takes matching transition, if any.
automata (GNFA).
An NFA:
A GNFA:
Each transition labeled with a regular expression,
reads zero or more symbols,
takes transition whose regular expression matches
string, if any.
automata (GNFA).
An NFA:
A GNFA:
Each transition labeled with a regular expression,
reads zero or more symbols,
takes transition whose regular expression matches
string, if any.
GNFAs are natural generalization of NFAs.
GNFA Special Form
Start state has outgoing arrows to every other
state, but no incoming arrows.
GNFA Special Form
Unique accept state has incoming arrows from
every other state, but no outgoing arrows
GNFA Special Form
Except for start and accept states, arrows goes
from every state to every other state, including
itself.
GNFA Special Form
itself.
Easy to transform any GNFA into special form.
GNFA Special Form
itself.
Easy to transform any GNFA into special form.
Really? How? . . .
Converting DFA to Regular Expression
(=)
Strategy sequence of equivalent transformations
given a k-state DFA
(=)
given a k-state DFA
transform into (k + 2)-state GNFA
(=)
given a k-state DFA
while GNFA has more than 2 states, transform it
into equivalent GNFA with one fewer state
(=)
given a k-state DFA
eventually reach 2-state GNFA (states are just
start and accept).
(=)
given a k-state DFA
eventually reach 2-state GNFA (states are just
start and accept).
label on single transition is the desired regular
expression.
Converting Strategy (=)
3-state
DFA
5-state
GNFA
4-state
GNFA
3-state
GNFA
2-state
GNFA
regular
expression
Removing One State
We remove one state q
r
, and then repair the machine
by altering regular expression of other transitions.
q
i j
q
q
r
R
1
3
R
4
R
q
i
j
q
2
R
2
R* R
1 3
R U
4
R
Formal Treatment GNDA Denition
q
s
is start state.
q
a
is accept state.
Ris collection of regular expressions over .
q
s
is start state.
q
a
is accept state.
The transition function is
: (Q{q
a
}) (Q{q
s
}) R
q
s
is start state.
q
a
is accept state.
: (Q{q
a
}) (Q{q
s
}) R
If (q
i
, q
j
) = R, then arrow from q
i
to q
j
has label R.
q
s
is start state.
q
a
is accept state.
: (Q{q
a
}) (Q{q
s
}) R
If (q
i
, q
j
) = R, then arrow from q
i
to q
j
has label R.
Arrows connect every state to every other state except:
no arrow from q
a
no arrow to q
s
Formal Denition
A generalized deterministic nite automaton (GDFA)
is (Q, , , q
s
, q
a
), where
Q is a nite set of states,
is the alphabet,
: (Q{q
a
}) (Q{q
s
}) Ris the
transition function.
q
s
q
a
Q is the unique accept state.
A Formal Model of GNFA Computation
A GNFA accepts a string w
if there exists a
parsing of w, w = w
1
w
2
w
k
, where each w
i

,
and there exists a sequence of states q
0
, . . . , q
k
such
that
q
0
= q
s
, the start state,
q
k
= q
a
, the accept state, and
for each i, w
i
L(R
i
), where R
i
= (q
i1
, q
i
).
(namely w
i
is an element of the language
described by the regular expression R
i
.)
The CONVERT Algorithm
Given GDFA G, convert it to equivalent GNFA G
.
let k be the number of states of G.
.
If k = 2, return the regular expression labeling
the only arrow.
.
the only arrow.
If k > 2, select any q
r
distinct from q
s
and q
a
.
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
For any q
i
Q
{q
a
} and q
j
Q
{q
s
}, let
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
For any q
i
Q
{q
a
} and q
j
Q
{q
s
}, let
R
1
= (q
i
, q
r
), R
2
= (q
r
, q
r
),
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
For any q
i
Q
{q
a
} and q
j
Q
{q
s
}, let
R
1
= (q
i
, q
r
), R
2
= (q
r
, q
r
),
R
3
= (q
r
, q
j
), and R
4
= (q
i
, q
j
).
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
For any q
i
Q
{q
a
} and q
j
Q
{q
s
}, let
R
1
= (q
i
, q
r
), R
2
= (q
r
, q
r
),
R
3
= (q
r
, q
j
), and R
4
= (q
i
, q
j
).
Dene
(q
i
, q
j
) = (R
1
)(R
2
)
(R
3
) (R
4
).
.
the only arrow.
r
distinct from q
s
and q
a
.
Let Q
= Q{q
r
} .
For any q
i
Q
{q
a
} and q
j
Q
{q
s
}, let
R
1
= (q
i
, q
r
), R
2
= (q
r
, q
r
),
R
3
= (q
r
, q
j
), and R
4
= (q
i
, q
j
).
Dene
(q
i
, q
j
) = (R
1
)(R
2
)
(R
3
) (R
4
).
Denote the resulting k 1 states GNFA by G
.
The CONVERT Procedure
We dene the recursive procedure CONVERT():
Given GDFA G.
Let k be the number of states of G.
Given GDFA G.
the only arrow of G.
Given GDFA G.
If k > 2, let G
be the k 1 states GNFA

produced by the algorithm.
Given GDFA G.
If k > 2, let G
be the k 1 states GNFA

produced by the algorithm.
Return CONVERT(G
).
Correctness Proof of Construction
Theorem: G and CONVERT(G) accept the same
language.
Proof: By induction on number of states of G
language.
Basis: When there are only 2 states, there is a single
label, which characterizes the strings accepted by G.
language.
Induction Step: Assume claim for k 1 states, prove
for k.
language.
Induction Step: Assume claim for k 1 states, prove
for k.
Let G
be the k 1 states GNFA produced from G by

the algorithm.
G and G
accept the same language

By the induction hypothesis, G
and CONVERT(G
)
accept the same language.
G and G

and CONVERT(G
)
On input G, the procedure returns CONVERT(G
).
G and G

and CONVERT(G
)
).
So to complete the proof, it sufces to show that G
and G

G and G

and CONVERT(G
)
).
So to complete the proof, it sufces to show that G
and G

Three steps:
1. If G accepts w, then so does G
.
2. If G
accepts w, then so does G.

3. Therefore G and G
are equivalent.
Step One
Claim: If G accepts w, then so does G
:
If G accepts w, then there exists a path of states
q
s
, q
1
, q
2
, . . . , q
a
traversed by G on w, leading to
the accept state q
a
.
Step One
:
q
s
, q
1
, q
2
, . . . , q
a
the accept state q
a
.
If q
r
does not appear on path, then G
accepts w
because the the new regular expression on each
edge of G
contains the old regular expression in

the union part.
Step One
:
q
s
, q
1
, q
2
, . . . , q
a
the accept state q
a
.
If q
r
accepts w
edge of G

the union part.
If q
r
does appear, consider the regular expression
corresponding to . . . q
i
, q
r
, . . . , q
r
, q
j
. . . .
The new regular expression (R
i,r
)(R
r,r
)
(R
r,j
)
linking q
i
and q
j
encompasses any such string.
Step One
:
q
s
, q
1
, q
2
, . . . , q
a
the accept state q
a
.
If q
r
accepts w
edge of G

the union part.
If q
r
does appear, consider the regular expression
corresponding to . . . q
i
, q
r
, . . . , q
r
, q
j
. . . .
The new regular expression (R
i,r
)(R
r,r
)
(R
r,j
)
linking q
i
and q
j
encompasses any such string.
Either way, the claim holds.
Steps Two and Three
Claim: If G

Proof: Each transition from q
i
to q
j
in G
corresponds
to a transition in G, either directly or through q
r
. Thus
if G

This completes the proof of the claim that
L(G) = L(G
).
Steps Two and Three
Claim: If G

i
to q
j
in G
corresponds
r
. Thus
if G

L(G) = L(G
).
Combined with the induction hypothesis, this
shows that G and the regular expression
CONVERT(G) accept the same language.
Steps Two and Three
Claim: If G

i
to q
j
in G
corresponds
r
. Thus
if G

L(G) = L(G
).
Combined with the induction hypothesis, this
shows that G and the regular expression
CONVERT(G) accept the same language.
This, in turn, proves our remarkable claim:
A language, L, is described by a regular
Conversion Example
We now construct a simple, 2 state DFA that
accepts the language over {0, 1} of all strings
with an even number of 1s.
Conversion Example
We now construct a simple, 2 state DFA that
accepts the language over {0, 1} of all strings
with an even number of 1s.
We followed the conversion through GNFAs to
translate this DFA (on the blackboard) into the
regular expression (0 10
1)
.

LEC2

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LEC2

Uploaded by

Copyright:

Available Formats

Computational Models - Lecture 2

Non-Deterministic Finite Automata (NFA)

) be the set of strings that

) be the set of strings that

) be the set of strings that

P(Q) is the transition function,

that has the form

that has the form

that has the form

(R, a) = {q Q|q (r, a) for some r R}

(R, a) = {q Q|q (r, a) for some r R}

(R, a) = {q Q|q (r, a) for some r R}

|R contains an accept state of N}

(R, a) = {q Q| there is some r R

(R, a) = {q Q| there is some r R

Oops - bad construction. How do we x it?

Ahaa - a better construction!

is shorthand for {0}

is shorthand for {0}

is shorthand for the set of all strings over

is shorthand for {0}

is shorthand for the set of all strings over

is shorthand for {0}

is shorthand for the set of all strings over

1 all strings ending in 1.

1 strings starting with 0 or ending in 1.

1 all strings ending in 1.

1 strings starting with 0 or ending in 1.

Q.: Whats the difference between and ?

Q.: Whats the difference between and ?

be the k 1 states GNFA

be the k 1 states GNFA

be the k 1 states GNFA produced from G by

accept the same language

accept the same language

accept the same language

accept the same language.

accept the same language

accept the same language.

accepts w, then so does G.

contains the old regular expression in

contains the old regular expression in

contains the old regular expression in

accepts w, then so does G.

accepts w, then so does G.

accepts w, then so does G.

accepts w, then so does G.

accepts w, then so does G.

accepts w, then so does G.

You might also like