# Finite Automata Regular Languages

Document Sample

```					Deterministic Finite Automata

CS 130: Theory of Computation
HMU textbook, Chapter 2 (Sec 2.2)
State-driven programs
   Many applications carry out actions only
when particular conditions apply at the given
moment
   conditions => state
   Examples:
after checkout
   Performing a simple arithmetic calculation using a
calculator: an operator character should be
pressed only after some sequence of digits have
been entered for the first operand
Model: finite automaton
   At any point in time, the “program” or
automaton will be in one state from a set of
states
   In the calculator example, the states are:
   first operand read (+ or - is pressed)
   result displayed/ready for next calculation
(= is pressed)
   A transition from one state to another state
occurs on a given input symbol
Accepting valid calculator input
   We want the automaton to allow (accept)
input strings like this
   123+456=
   3333-5=
   But “reject” string like this
   +-2=2
   567-=
   Symbols are read from left to right and cause
transitions from one state to another based
on the current state and current input symbol
Deterministic Finite Automata
   A DFA or deterministic finite automaton M is a
5-tuple, M = (Q, , , q0, F), where:
   Q is a finite set of states of M
    is the finite input alphabet of M
   : Q    Q is the state transition function
   q0 is the start state of M
   F  Q is the set of accepting states or final states
of M
DFA example 1
0         M
   State diagram                             0
1
q0                 q1

1
   Q = { q0, q1 }
     0        1    State
 = { 0, 1 }                         Table
q0    q0       q1
F = { q1 }
q1    q1       q0
State table &
state transition function
   State table       0     1
q0   q0    q1
q1   q1    q0

   State transition function
(q0, 0) = q0, (q0, 1) = q1
(q1, 0) = q1, (q1, 1) = q0
A DFA processing a string
   Given a string of input symbols
w = a1a2 … an
   A DFA M processes the string w as follows:
   For each input symbol ai :
qx = (qx, ai)
   If resulting qx  F, then w is accepted;
otherwise w is rejected
Extending  for strings
   Let w be a string over  and
let M = (Q, , , q0, F) be a DFA
   Define ^: Q X *  Q as follows
   If w = , then ^(q, w) = ^(q, ) = q
   If w ≠ , i.e., w = xa,
(where x is a string and a is a symbol) then
^(q, w) = ^(q, xa) = (^(q, x), a)
   A DFA M accepts a string w
when ^(q0, w)  F
Language recognized by a DFA
   The language L(M) that is recognized by a
DFA M = (Q, , , q0, F), is the set of all
strings accepted by M.
   That is, L(M) = { w  * | M accepts w }
= { w  * | ^(q0, w)  F }
   Example: For the previous DFA, L(M) is the
set of all strings of 0s and 1s with odd parity,
that is, odd number of 1s.
DFA Example 2
   Recognizer for 11*01*             1
B
* means zero or more                          0
occurrences of the         1                            1
preceding symbol

A                            C
0          0

D       0,1
Trap
DFA Example 2
   M = (Q, , , q0, F), L(M) = 11*01*
Q = { q0=A, B, C, D }
 = { 0, 1 }             0      1
F={C}
A       D       B
B       C       B
C       D       C
D       D       D
DFA Example 3
   Modulo 3 counter                     0

1       B
0
2
1
A               2
2

1               C       0
DFA Example 3
   M = (Q, , , q0, F)
Q = { q0=A, B, C }
 = { 0, 1, 2 }
F={A}              0   1   2
A    A    B   C
B    B    C   A
C    C    A   B
DFA Example 4
   Recognizing simple calculator expressions
   M = (Q, , , q0, F)
 = { 0…9, +, -, = }
   See course website for a sample Java
program that simulates this DFA (study how
the transition function  is implemented)
Regular Languages and DFAs
   A language L  * is called regular if
there exists a DFA M such that L(M)=L
   Examples of regular languages
   Binary strings with odd parity
   Language described by 11*01*
   Strings that form integers divisible by 3
   Simple calculator expressions
Next
   Variations on Finite Automata
(rest of Chapter 2)
   Nondeterministic Finite Automata (NFAs)
   Equivalences of these variations with DFAs
   Regular expressions as an alternative
model for regular languages
(Chapter 3)

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 399 posted: 2/4/2010 language: English pages: 17