Deterministic Finite Automata

Denition: A deterministic nite automaton (DFA) consists of 1. a nite set of states (often denoted Q) 2. a nite set of symbols (alphabet) 3. a transition function that takes as argument a state and a symbol and returns a state (often denoted ) 4. a start state often denoted q0 5. a set of nal or accepting states (often denoted F ) We have q0 Q and F Q

Deterministic Finite Automata

So a DFA is mathematically represented as a 5-uple (Q, , , q0 , F ) The transition function is a function in QQ Q is the set of 2-tuples (q, a) with q Q and a

Deterministic Finite Automata

How to present a DFA? With a transition table 0 q0 q1 q2 q2 q1 q2 1 q0 q1 q1

The indicates the start state: here q0 The indicates the nal state(s) (here only one nal state q1 ) This denes the following transition diagram
1 0 0

q0

q2

q1

0,1

Deterministic Finite Automata

For this example Q = {q0 , q1 , q2 } start state q0 F = {q1 } = {0, 1} is a function from Q to Q :QQ (q0 , 1) = q0 (q0 , 0) = q2

Example: password
When does the automaton accepts a word?? It reads the word and accepts it if it stops in an accepting state q0
=t t

q1
=e

q2

q3

q4

=h

q5 Only the word then is accepted Here Q = {q0 , q1 , q2 , q3 , q4 } is the set of all characters F = {q4 }

=n

We have a stop or dead state q5 , not accepting

5

How a DFA Processes Strings

Let us build an automaton that accepts the words that contain 01 as a subword = {0, 1} L = {x01y | x, y } We use the following states A: start B: the most recent input was 1 (but not 01 yet) C: the most recent input was 0 (so if we get a 1 next we should go to the accepting state D) D: we have encountered 01 (accepting state)

We get the following automaton

1 0 1 0 1

A Transition table

B
0

0,1

0 A B C D C C C D

1 B B D D

Q = {A,B,C,D}, = {0,1}, start state A, nal state(s) {D}

Extending the Transition Function to Strings

In the previous example, what happens if we get 011? 100? 10101? We dene (q, x) by induction : Q Q BASIS (q, ) = q for |x| = 0 INDUCTION suppose x = ay (y is a string, a is a symbol) (q, ay) = ((q, a), y) Notice that if x = a we have (q, a) = (q, a) since a = a and ((q, a), ) = (q, a)

Extending the Transition Function to Strings

: Q Q We write q.x instead of (q, x) We can now dene mathematically the language accepted by a given automaton Q, , , q0 , F L = {x | q0 .x F } On the previous example 100 is not accepted and 10101 is accepted

Minimalisation
The same language may be represented by dierent DFA
1 0 1 0 1

A and

B
0

0,1

1 0 0 1

0,1

10

Minimalisation
Later in the course we shall show that there is only one machine with the minimum number of states (up to renaming of states) Furthermore, there is a (clever) algorithm which can nd this minimal automaton given an automaton for a language

11

Example
Mn the cyclic automaton with n states on = {1} such that L(Mn ) = {1l | n divides l}

12

Functional representation: Version 1

Q = A|B|C and E = 0|1 and W = [E] One function next : Q E Q next (A, 1) = A, next (A, 0) = B next (B, 1) = C, next (B, 0) = B next (C, b) = C One function run : Q W Q run (q, b : x) = run (next (q, b), x), accept x = f inal (run (A, x)) where f inal A = f inal B = F alse, f inal C = T rue run (q, []) = q

13

Functional representation: Version 2

E = 0|1, W = [E] Three functions FA , FB , FC : W Bool FA (1 : x) = FA x, FB (1 : x) = FC x, FC (1 : x) = FC x, FA (0 : x) = FB x, FB (0 : x) = FB x, FC (0 : x) = FC x, FA [] = F alse FB [] = F alse FC [] = T rue

We have a mutual recursive denition of 3 functions

14

Functional representation: Version 3

data Q = A | B | C data E = O | I next next next next next next :: Q -> E -> Q A I = A A O = B B I = C B O = B C _ = C

run :: Q -> [E] -> Q run q (b:x) = run (next q b) x run q [] = q

15

Functional representation: Version 3

accept :: [E] -> Bool accept x = final (run A x) final final final final :: Q -> Bool A = False B = False C = True

16

Functional representation: Version 4

We have Q -> E -> Q ~ ~ Q x E -> Q

E -> (Q -> Q)

17

Functional representation: Version 4

data Q = A | B | C data E = O | I next next next next next next :: E -> Q -> Q I A = A O A = B I B = C O B = B _ C = C

run :: Q -> [E] -> Q run q (b:x) = run (next b q) x run q [] = q

18

Functional representation: Version 4

-- run q [b1,...,bn] is -- next bn (next b(n-1) (... (next b1 q)...)) -- run = foldl next

19

A proof by induction
A very important result, quite intuitive, is the following. Theorem: for any state q and any word x and y we have q.(xy) = (q.x).y Proof by induction on x. We prove that: for all q we have q.(xy) = (q.x).y (notice that y is xed) Basis: x = then q.(xy) = q.y = (q.x).y

Induction step: we have x = az and we assume q .(zy) = (q .z).y for all q

20

 The other denition of

Recall that a(b(cd)) = ((ab)c)d; we have two descriptions of words We dene (q, ) = q and (q, xa) = ( (q, x), a) Theorem: We have q.x = (q, x) = (q, x) for all x

21

 The other denition of

Indeed we have proved q. = q and q.(xy) = (q.x).y As a special case we have q.(xa) = (q.x).a This means that we have two functions f (x) = q.x and g(x) = (q, x) which satisfy f ( ) = g( ) = q and f (xa) = f (x).a g(xa) = g(x).a Hence f (x) = g(x) for all x that is q.x = (q, x)

22

Automatic Theorem Proving

f (0) = h(0) = 0, g(0) = 1

f (n + 1) = g(n), g(n + 1) = f (n), h(n + 1) = 1 h(n) We have f (n) = h(n) We can prove this automatically using DFA

23

Automatic Theorem Proving

We have 8 states: Q = {0, 1} {0, 1} {0, 1} We have only one action = {1} and ((a, b, c), s) = (b, a, 1 c) The initial state is (0, 1, 0) = (f (0), g(0), h(0)) Then we have (0, 1, 0).1n = (f (n), g(n), h(n)) We check that all accessible states satisfy a = c (that is, the property a = c is an invariant for each transition of the automata)

24

Automatic Theorem Proving

A more complex example f (0) = 0 f (2) = 1 f (1) = 1 f (3) = 0 f (n + 2) = f (n) + f (n + 1) f (n)f (n + 1) f (4) = 1 f (5) = 1 ...

Show that f (n + 3) = f (n) by using Q = {0, 1} {0, 1} {0, 1} and the transition function (a, b, c) (b, c, b + c bc) with the initial state (0, 1, 1)

25

Product of automata
How do we represent interaction between machines? This is via the product operation There are dierent kind of products We may then have combinatorial explosion: the product of n automata with 2 states has 2n states!

26

Product of automata (example)

p0

The product of
p1 p0

p1

A
p0

p1

and

p0

C
p1

p0

is
p1

A, C
p1

p0

B, C
p1 p1

A, D

p0

B, D

p0

If we start from A, C and after the word w we are in the state A,D we know that w contains an even number of p0 s and odd number of p1 s

27

Product of automata (example)

Model of a system of users that have three states I(dle), R(equesting) and U(sing). We have two users for k = 1 or k = 2 Each user is represented by a simple automaton rk

ik

uk

28

Product of automata (example)

The complete system is represented by the product of these two automata; it has 3 3 = 9 states i1 , i2 r1 , i2 u1 , i2

i1 , r2

r1 , r2

u 1 , r2

i1 , u2

r1 , u 2

u1 , u2

29

The Product Construction

Given A1 = (Q1 , , 1 , q1 , F1 ) and A2 = (Q2 , , 2 , q2 , F2 ) two DFAs with the same alphabet we can dene the product A = A1 A2 set of state Q = Q1 Q2 transition function (r1 , r2 ).a = (r1 .a, r2 .a) intial state q0 = (q1 , q2 ) accepting states F = F1 F2

30

The Product Construction

Lemma: (r1 , r2 ).x = (r1 .x, r2 .x) We prove this by induction BASE: the statement holds for x = STEP: if the statement holds for y it holds for x = ya

31

The Product Construction

Theorem: L(A1 A2 ) = L(A1 ) L(A2 ) Proof: We have (q1 , q2 ).x = (q1 .x, q2 .x) in F i q1 .x F1 and q2 .x F2 , that is x L(A1 ) and x L(A2 ) Example: let Mk be the cyclic automaton that recognizes multiple of k, such that L(Mk ) = {an | k divides n}, then M6 M9 M18 Notice that 6 divides k and 9 divides k i 18 divides k

32

Product of automata
It can be quite dicult to build automata directly for the intersection of two regular languages Example: build a DFA for the language that contains the subword ab twice and an even number of as

33

Variation on the product

We dene A1 A2 as A1 A2 but we change the notion of accepting state (r1 , r2 ) accepting i r1 F1 or r2 F2 Theorem: If A1 and A2 are DFAs, then L(A1 A2 ) = L(A1 ) L(A2 ) Example: multiples of 3 or of 5 by taking M3 M5

34

Complement
If A = (Q, , , q0 , F ) we dene the complement A of A as the automaton A = (Q, , , q0 , Q F ) Theorem: If A is a DFA, then L(A) = L(A) Remark: We have A A = A A

35

Languages
Given an alphabet A language is simply a subset of Common languages, programming languages, can be seen as sets of words Denition: A language L is regular i there exists a DFA A, on the same alphabet such that L = L(A) Theorem: If L1 , L2 are regular then so are L1 L2 , L1 L2 , L1

36

Remark: Accessible Part of a DFA

Consider the following DFA
0 0 0 1

q0

q1

q2

0 0

q3

it is clear that it accepts the same language as the DFA

0

q0

0 1

q1

which is the accessible part of the DFA The remaining states are not accessible from the start state and can be removed

37

Remark: Accessible Part of a DFA

The set Acc = {q0 .x | x } is the set of accessible states of the DFA (states that are accessible from the state q0 )

38

Remark: Accessible Part of a DFA

Proposition: If A = (Q, , , q0 , F ) is a DFA then and A = (Q Acc, , , q0 , F Acc) is a DFA such that L(A) = L(A ). Proof: It is clear that A is well dened and that L(A ) L(A). If x L(A) then we have q0 .x F and also q0 .x Acc. Hence q0 .x F Acc and x L(A ).

39

Automatic Theorem Proving

Take = {a, b}. Dene L set of x such that any a in x is followed by a b Dene L set of x such that any b in x is followed by a a Then L L = { } Intuitively if x = in L we have

...a... ...a...b... if x in L we have ...b... ...b...a...

40

Automatic Theorem Proving

We should have L L = { } since a nonempty word in L L should be innite We can prove this automatically with automata! L is regular: write a DFA A for L L is regular: write a DFA A for L We can then compute A A and check that L L = L(A A ) = { }

41

Application: control system

We have several machines working concurrently We need to forbid some sequence of actions. For instance, if we have two machines MA and MB, we may want to say that MB cannot be on when MA is on. The alphabets will contain: onA, oA, onB, oB Between onA, on2 there should be at least one oA The automaton expressing this condition is
=onA,onB

oA

=onB,oA

p0 onB oB p3 onA onA

p1 onB p2

42

Application: control system

What is interesting is that we can use the product construction to combine several conditions For instance, another condition maybe that onA should appear before onB appear. One automaton representing this condition is
=onA,onB

q0 onB q2

onA

q1

We can take the product of the two automata to express the two conditions as one automaton, which may represent the control system

43