You are on page 1of 29

# Theory of Computation (With Automata Theory)

Designing Deterministic
Finite Automata
Designing DFAs

## Case Study 1: Design a DFA that

accepts all strings over the alphabet
= {0, 1} with an odd number of 1s.

## The states of a DFA represent

something the machine must
string.

## Assume that several input

Upon the arrival of the next
symbol, the machine does not
have to remember the exact
number of 1s it has received.

## Designing Deterministic Finite Automata

* Property of STI
Page 1 of 29

## Theory of Computation (With Automata Theory)

remember two things:

to

## 1. Whether the number of 1s

in the input string at any
point in time is odd.
2. Whether the number of 1s
in the input string at any
point in time is even.

## This implies that only two

states are needed. One to
represent the fact that the
current number of 1s is odd,
and the other to represent
even.

## Designing Deterministic Finite Automata

* Property of STI
Page 2 of 29

## The state in which the number

of 1s is even will be
designated as the start state.
This is because while there is
no input symbol yet, the
number of 1s is zero (even).

## Obviously, the odd state will

be the final state.

## Let these two states be:

q0 = current number of 1s
is even.
q1 = current number of 1s
is odd.

## Designing Deterministic Finite Automata

* Property of STI
Page 3 of 29

## Assume that the DFA is in

state q0 (even):
If it receives a 0, it remains
in that state since the
number of 1s is still even.
If it receives a 1, it moves
to state q1 since the
number of 1s is now odd.

## Assume that the DFA is in

state q1 (odd):
If it receives a 0, it remains
in that state since the
number of 1s is still odd.
If it receives a 1, it moves
to state q0 since the
number of 1s is now even.

## Designing Deterministic Finite Automata

* Property of STI
Page 4 of 29

required DFA:
0

0
1

q0

q1

## Designing Deterministic Finite Automata

* Property of STI
Page 5 of 29

## Case Study 2: Design a DFA that

accepts all strings over the alphabet
= {0, 1} that contains the
substring 011.

## As in case study 1, the DFA to

be designed does not have to
remember each and every
input symbol that arrives.

## At any point in time, the DFA

only has to remember whether
the substring 011 has been
encountered.

## Designing Deterministic Finite Automata

* Property of STI
Page 6 of 29

## The DFA would have to

remember the following things
(states):

## 1. it has not encountered the

first symbol of the
substring so far.
2. it has encountered the first
symbol of the substring (0).
3. it has encountered the first
two symbols of the
substring (01).
4. it has encountered all three
symbols of the substring
(011).

## Designing Deterministic Finite Automata

* Property of STI
Page 7 of 29

## The state where the DFA had

not yet encountered any of the
symbols of the substring will
be designated as the start
state while the state where it
will be the final state.

## The DFA will have four states:

1. q0 = the first symbol of the
2. q1 = the first symbol had
arrived.
3. q2 = the first two symbols
4. q3 = all three symbols had
arrived.

## Designing Deterministic Finite Automata

* Property of STI
Page 8 of 29

## Assume that the DFA is in

first symbol in the substring):

If a 0 arrives, it moves to
encountered the first
symbol of the substring.

If a 1 arrives, it stays in
that state because the
0.

## Designing Deterministic Finite Automata

* Property of STI
Page 9 of 29

## Assume that the DFA is in

state q1 (only the first symbol,
If a 0 arrives, it remains in
that state. Remember that
encountered. The arrival
of another 0 does not
improve the search.
However, this newly
arrived 0 can now be the
new first symbol of the
substring (the previous 0
may be forgotten).
If it receives a 1, it moves
to state q2 since the two
symbols of the substring
encountered.

## Designing Deterministic Finite Automata

* Property of STI
Page 10 of 29

## Assume that the DFA is in

state q2 (the first two symbols,

If a 0 arrives, it goes to
state q1. The arrival of this
0 makes the substring 010.
The previous 01 would
have to be forgotten and
this newly arrived 0 can
now be the new first
symbol of the substring.

If it receives a 1, it moves
to state q3 since the three
symbols of the substring
encountered.

## Designing Deterministic Finite Automata

* Property of STI
Page 11 of 29

## Assume that the DFA is in

state q3 (the substring 011 had
been encountered):
The DFA will not change
state upon the arrival of
succeeding 0s and 1s
since the desired substring

required DFA:

q0

q1

0, 1

q2

q3

## Designing Deterministic Finite Automata

* Property of STI
Page 12 of 29

## Case Study 3: Design a DFA that

accepts all strings over the alphabet
= {0, 1} that starts and ends with
01.

## In this example, the DFA to be

designed must be able to
detect if the input string has a
prefix which is 01 and a suffix
which is also 01.

## The DFA to be designed

should remember the following
things:
1. The state where it had not
yet encountered the first
symbol (0) of the prefix 01.
2. The state where it had
encountered the first
symbol (0) of the prefix 01.

## Designing Deterministic Finite Automata

* Property of STI
Page 13 of 29

## 3. The state where it had

encountered the two
symbols (01) of the prefix
01.
4. The state where it had
encountered the first
symbol (0) of the suffix 01.
5. The state where it had
encountered the prefix 01
and the two symbols (01)
of the suffix 01.
6. The state where the input
prefix 01. If the string did
would be useless for the
DFA to determine if it
would end with a 01.

## Designing Deterministic Finite Automata

* Property of STI
Page 14 of 29

## The DFA will have 6 states:

1. q0 = the first symbol of the
2. q1 = the first symbol of the
3. q2 = the two symbols of the
4. q3 = the two symbols of the
prefix
01
been
symbol of the suffix 01 had
arrived.
5. q4 = the two symbols of the
prefix
01
been
symbols of the suffix 01
6. q5 = the input string did not

## Designing Deterministic Finite Automata

* Property of STI
Page 15 of 29

## Assume that the DFA is in

state q0 (the first symbol of the

If a 0 arrives, it moves to
encountered the first
symbol of the prefix.

If a 1 arrives, it goes to
state q5 since it is now
impossible for the input
prefix 01.

## Designing Deterministic Finite Automata

* Property of STI
Page 16 of 29

## Assume that the DFA is in

state q1 (the first symbol of the

If a 0 arrives, it moves to
state q5 since it is now
impossible for the input
prefix 01 since the first two

If a 1 arrives, it goes to
state q2 since the two
symbols of the prefix 01

## Designing Deterministic Finite Automata

* Property of STI
Page 17 of 29

## Assume that the DFA is in

state q2 (the two symbols of

If a 0 arrives, it moves to
state q3 since this newlyarrived zero can potentially
be the start of the suffix 01.

## If a 1 arrives, it stays in this

state since the suffix 01 is
still to be detected.

## Designing Deterministic Finite Automata

* Property of STI
Page 18 of 29

## Assume that the DFA is in

state q3 (the two symbols of
of the suffix 01 had arrived):

## If a 0 arrives, it stays in q3.

By this time, the last two
The newly-arrived 0 can
now be the first symbol of
the suffix 01 while the
previous zero may be
forgotten.

If a 1 arrives, it moves to
state q4 since the prefix 01

## Designing Deterministic Finite Automata

* Property of STI
Page 19 of 29

## Assume that the DFA is in

state q4 (the two symbols of
of the suffix 01 had arrived):
If a 0 arrives, the previous
two symbols (01) is not the
true suffix of the input
string. This newly arrived
0 can become the first
symbol of the potentially
true suffix. The DFA
therefore moves to state
q 3.
If a 1 arrives, the previous
two symbols (01) is not the
true suffix of the input
string. The DFA goes to
state q2.

## Designing Deterministic Finite Automata

* Property of STI
Page 20 of 29

## Assume that the DFA is in

state q5 (the input string did
The DFA will not change
state upon the arrival of
succeeding
0s and 1s
since the string did not start
with the prefix 01. It is now
useless for the DFA to track
the
arriving
symbols
because the string will not
be accepted anyway.

required DFA:
0, 1

q5
1

q0

q1

q2

q3

q4

0
1

## Designing Deterministic Finite Automata

* Property of STI
Page 21 of 29

## 1. Design a DFA that accepts all

strings over the alphabet =
{0, 1} with no more than three
1s.

## 2. Design a DFA that accepts all

strings over the alphabet =
{0, 1} with an even number of
0s and an odd number of 1s.

## 3. Design a DFA that accepts all

strings over the alphabet =
{0, 1} that starts or ends with a
01.

## Designing Deterministic Finite Automata

* Property of STI
Page 22 of 29

## Theory of Computation (With Automata Theory)

For Exercise 1
Design a DFA that accepts all
strings over the alphabet =
{0, 1} with no more than three
1s.
The DFA will have 5 states:
1. q0 = there are no 1s
2. q1 = there is one 1
3. q2 = there are two 1s
4. q3 = there are three 1s
5. q4 = there are four or more
The start state is q0 while the
final states are q0, q1, q2, and
q 3.

## Designing Deterministic Finite Automata

* Property of STI
Page 23 of 29

q0

q1

## Designing Deterministic Finite Automata

q2

0, 1

q3

q4

* Property of STI
Page 24 of 29

## Theory of Computation (With Automata Theory)

For Exercise 2
Design a DFA that accepts all
strings over the alphabet =
{0, 1} with an even number of
0s and an odd number of 1s.
The DFA will have 4 states:
1. q0 = the number of 0s is
even and the number of 1s
is even.
2. q1 = the number of 0s is
even and the number of 1s
is odd.
3. q2 = the number of 0s is
odd and the number of 1s
is even.
4. q3 = the number of 0s is
odd and the number of 1s
is odd.

## Designing Deterministic Finite Automata

* Property of STI
Page 25 of 29

## The start state is q0 while the

final state is q1.

q0

q1

q2

## Designing Deterministic Finite Automata

q3

* Property of STI
Page 26 of 29

## Theory of Computation (With Automata Theory)

For Exercise 3
Design a DFA that accepts all
strings over the alphabet =
{0, 1} that starts or ends with a
01.
This is similar to the design
a string starting and ending
with the substring 01, the DFA
should accept strings starting
OR ending with the substring
01.
One way of processing the
strings is to determine first if
the prefix 01 is present. If it is,
then the DFA stops at an
accept state, regardless if
there are still incoming input
strings.

## Designing Deterministic Finite Automata

* Property of STI
Page 27 of 29

## Theory of Computation (With Automata Theory)

the prefix 01, then the DFA
proceeds to determine if it will
end with the suffix 01.
The DFA will have 6 states:
1. q0 = the first symbol of the
2. q1 = the first symbol of the
3. q2 = the two symbols of the
4. q3 = the prefix 01 was not
encountered.
5. q4 = the prefix 01 was not
encountered and the first
symbol of the suffix 01 had
arrived.
6. q5 = the prefix 01 was not
encountered and the two
symbols of the suffix 01
Designing Deterministic Finite Automata

* Property of STI
Page 28 of 29

required DFA:
0, 1

q0

q1

q2

q3

q4

q5

0
1

## Designing Deterministic Finite Automata

* Property of STI
Page 29 of 29