Presented by Joydeep Dey

DFA Definition

DFA Examples
NFA Definition
NFA Examples

NFA to DFA conversion

Regular Expressions

 In automata theory, a branch of theoretical computer

science, a deterministic finite automaton (DFA)

also known as deterministic finite state machine
is a finite state machine that accepts/rejects finite
strings of symbols and only produces a unique
computation (or run) of the automaton for each input
string.
'Deterministic' refers to the uniqueness of the
computation. In search of simplest models to capture
the finite state machines.

 For every string x, there is a unique path from initial

state and associated with x.

x

x is accepted if and only if this path ends at a accept

state.

 Construct a DFA that accepts a language L over = {0,

1} such that L is the set of all strings starting with 101.

0,1

start

q0

q1
1

q2

absorbing
state

q4
0,1

q3

dead
state

 Construct a DFA that accepts a language L over = {0,

1} such that L is the set of all strings ending with 101.

0
0

start

q0

1
1

q1

q10
1

0
1

q101

 In automata theory, a nondeterministic

finite automaton (NFA), or non

deterministic finite state machine, is a finite
state machine that does not require input
symbols for state transitions and is capable
of transitioning to zero or two or more states
for a given start state and input symbol.

 This distinguishes it from a

deterministic finite automaton (DFA),

in which all transitions are uniquely
determined and in which an input
symbol is required for all state
transitions.

 For any string x, there may exist one or more

than

one path from initial state and associated with x.

x is accepted if there is some path that ends at a

accept state.

 Construct NFAs for the following languages over the

alphabet {a, b, , z}:

All strings that contain eat or sea or easy
all

start

q1

q0

q2
s

q3
y

q4

s
e

q5

all

q6

 Construct NFA for the language over the alphabet {a,

b, , z} such that every string doesnt contain fool.

not f

dead
state

start

q0

q1
not f,o

not f,o

q2

q2
not f,l

q3

 We can have a simpler representation for common

suffix language using NFA:

1,0

start

q0

q1

q2

q3

Use subset construction to convert it to a DFA.

start

q0

1
1

q0q1

q0q2
1

0
1

q0q1q3

- Alphabet X = {a, b, c, d}
(a + b)*
all strings containing only a and b
2) c(a + b + c)*c2
all strings containing only a, b, and c that begin with c and end with cc
3) all strings containing only one b
(a+c+d)*b(a+c+d)*
1)

- Alphabet X = {0, 1}
1)
2)

3)

(0 + 1)*
the set of all binary strings
031*04
all strings consisting of three 0s, followed by any number of 1s,
followed by four 0s
0*1001*
all strings starting with any number of 0s, followed by 100,
followed by and number of 1s

Thank you!