326 views

Uploaded by kims3515354178

- AUTOMATON-AN ABSTRACT COMPUTING DEVISE & ITS RECENT TRENDS
- Formal Language and Automata Theory
- Derivatives of Regular Expressions Re-Examined
- nlecture1428551440.pdf
- 214 Midterm a Solution
- Chapter5 Lexical Analysis
- ECEN 248 Lab11_report
- Automata Definitions
- L10 - Finite State Recognizers
- Concrete Basic Built in Expertise Exploitation
- A Study of Finite State Machine Coding Styles for Implementation
- Logic and Discrete Mathematics for Computer Scientists
- CompRobo Warmup Writeup
- Science Tripos
- A Critical Analysis of Performance and Efficiency of Minimization Algorithms for Deterministic Finite Automata
- Fsm Examples
- vlsi 10
- Regular Languages
- Oultine CS 729 TheoryOfAutomataAndFormalLanguages Spring 2012(MCS 2 Morning)
- Over 5

You are on page 1of 46

Automata

1

4. Automata

In the preceding two chapters we learned several models for language representation; formal grammars, L-systems, syntax flow

graphs and regular expressions. The natural languages are communication media, and so are the formal languages. The person who

hears a spoken sentence should be able to understand the meaning (i.e., the semantics) of the sentence. In this chapter we will learn

how to design machine models (i.e., automata) that recognize formal languages. We are not going to build a model which

understands a formal language, but one that recognizes it. Here we use the word “recognize” in a much narrower sense than the

word “understand” as follows.

For a given language L, we say a machine M recognizes L, if M, given a string x, can output “yes” or give

a positive indication if and only if x ∈ L.

What does it take for a machine M to recognize a language L? To answer this question it is better to think about a conceptual

model, instead of complex computer systems currently available. From 1930’s computer scientists have investigated many

machine models, called automata, for language recognition. We will study four popular models – Turing machines, linear-

bounded automata, pushdown automata and finite automata, respectively, recognizing the languages of types 0, 1, 2, and 3, that

we have introduced in Chapter 2. In Chapters 7, 12, and 14 we will study the so-called Chomsky hierarchy (after Noam

Chomsky), which shows the hierarchical relationship among the languages and automata.

Automata can be classified into two types of models, deterministic and nondeterministic. In this chapter we will first study the

deterministic models, which naturally follow our intuition, and then the nondeterministic models in the following chapter.

2

Automata

Design example

State transition graph, State transition table, State transition function

Formal definition

4.2 DLBA (Deterministic Linear Bounded Automata) 98

Definition and Design example

4.3 DPDA (Deterministic Pushdown Automata) 100

Definition

Design example

4.4 DFA (Deterministic Finite Automata) 111

Definition

Design example

Rumination 114

Exercises 120

Love is when you take away the feeling, the passion, the romance and you find out you still love the person.

Love comes to those who still hope even though they’ve been disappointed, to those who still believe, even though

they’ve been betrayed, to those who still love even though they’ve been deeply wounded before.

- Anonymous -

3

Automata

4.1 Deterministic Turing Machines

The Turing machine (TM), introduced by Alan M. Turing in 1936, is a model that

can recognize type 0 (phrase structured) languages. In this section we will study the

deterministic version of the Turing machine.

As illustrated below, a TM has a finite state control with a two-way read/write

tape head and one-dimensional tape of infinite length. The finite state control

corresponds to the CPU of a modern computer, where the “state” represents the

whole information stored in the main memory and registers.

The tape is divided into cells, each capable of holding one symbol. It is assumed

that initially, an input string over a given alphabet is written on the tape, and the tape

head is reading the leftmost symbol. We assume that all the blank cells are written

with the blank symbol B.

a b a b b read/write tape

finite state

control

4

DTM Automata

In one move (or step) a deterministic Turing machine (DTM) does the following:

(1) Read the content of the cell on which the tape head is located.

(2) Depending on the symbol read and the current state of the finite state control,

write a symbol on the cell, erasing the original symbol.

(3) Changing the state (or possibly without changing it) move the tape head left or

right, or let it stay on the same cell.

a b a .. c b a .. c b a ..

A

p q p

N

I

We say the DTM accepts the input string if it enters a designated state (called

accepting state) after some finite number of moves.

5

DTM Automata

It is unwieldy to draw the configuration (i.e., the tape and the finite state control)

for every step of a DTM to illustrate how it works. Instead we will mainly use a

directed graph, called the state transition graph, or occasionally the transition

function δ to represent each step as shown in figures (a) and (b), respectively.

next

state

( symbol read, symbol written, head direction )

current

δ (current state, symbol read) =

state

(next state, symbol written, head direction)

(a)

(b)

6

DTM Automata

Figures (a) and (b) below, respectively, show a graph and its functional

representation of two steps of a DTM. In the figures, R and L, respectively, denote the

tape head moving right and left. We shall use N to denote the head staying on the

same cell.

a b a .. c b a .. c b a ..

p q p

q

(a, c, R)

δ (p, a) = (q, c,

(b, b, L) R)

p δ (q, b) = (p, b,

L)

(a) (b)

7

DTM Automata

“father,” and vice versa. After completing the conversion, the DTM must halt in

an accepting state.

Figure (a) below shows the initial and final configurations of a DTM which does

the conversion. (Intermediate configurations are omitted.) Figure (b) shows the

state transition graph. In the state transition graph of a DTM, state labels are just

for reference and hence, can be omitted, if not needed, as shown in figure (b).

m o t h e r f a t h e r

s f

(a)

(a, o, R) (B, B, N)

(f, m, R) f

(r, r, R)

(m, f, R) (o, a, R) (t, t, R) (h, h, R) (e, e, R)

s

start

(b)

8

DTM Automata

Notice that depending on the first character (either ‘m’ or ‘f’) read, the machine

takes a transition to a different state. After converting the first two characters, it

does the same work (i.e., rewriting the “ther” part) by taking the four transitions,

and finally, reading the blank symbol B, enters the accepting state (the heavy circle

labeled with f).

Also notice that the machine cannot enter an accepting state after changing the

first two characters. It should make sure that the remaining part of the input is

correct.

(B, B, N)

f

(f, m, R) (a, o, R)

(r, r, R)

s

start

9

DTM Automata

Suppose that string 000111 is initially written on the tape as shown below. How can

a DTM M recognize that this string belongs to L? We know that if a string x is in L,

there should be the same number of 0’s and 1’s in x, and all the 0’s should come first.

We will let M use this property.

One idea is to let M move back and forth checking if, for each symbol 0 erased (i.e.,

rewritten) by a symbol, say X, there is 1 that can be erased by Y. We let M enter an

accepting state, if it sees that every pair of 0 and 1 is erased. Before we give a formal

definition of M, let’s figure out how the machine should move along the tape to

implement this idea.

0 0 0 1 1 1

10

DTM Automata

Let q0 denote the start state of M. We will use the following state names in which

the machine does the following;

q1: The state in which the machine, after erasing the leftmost 0

with X, moves right in search of the leftmost 1.

q2 : The state in which the machine, after erasing the leftmost 1

with Y, moves left in search of X.

q3 : The state in which, after reading X, the machine backs up right

to read the leftmost 0, if any.

work further in detail.

0 0 0 1 1 1

q0

11

DTM Automata

X 0 0 1 1 1

erasing it by X, moves right in q1 in

q0 q1 search of the leftmost 1.

(b) After erasing 1 with Y, M moves

(b) X 0 0 Y 1 1 left in state q2 in search of X.

q2 A

N

(c) X 0 0 Y 1 1 (c) Reading X in state q2, M backs up I

in state q3.

q2 q3 (d) Reads the next leftmost 0, if any,

(d) X X 0 Y 1 1 and erase it with X and moves right in

state q1 in search of the next 1 to be

q1 erased.

M repeats the procedure (b), (c) and

(d).

12

DTM Automata

A

(b) X X 0 Y Y 1 N

q2 I

(c) X X 0 Y Y 1

q2 q3 (f) This is the final phase. In state q3 if

M reads Y, not 0, it implies that all 0’s

are erased by X. M should make sure

(d) X X X Y Y 1

that no 1’s remain on the tape. For this,

q1 M needs additional states q4 and an

accepting state q5.

(e) X X X Y Y Y Reading Y in state q3, M enters state

q2 q4 and moves right until it reads the

blank symbol and then enters an

(f) X X X Y Y Y accepting state q5 .

q2

q3 q4 q5

13

DTM Automata

The following state transition graph is a formal representation of how the DTM

recognizes the language L = {0n1n | n ≥ 1}.

In q1, after erasing the (Y,Y,L)

(0,0,R) leftmost 1 with Y, keep

leftmost 0 with X, keep (Y,Y,R) moving left in search of

moving right in search of X.

the leftmost 1. (1,Y,L) q2

q1 Reading X, back up

right in state q3.

(0,X,R) (X,X,R)

(0,X,R)

q0 q3 A

start N

(Y,Y,R) (Y,Y,R) I

q4 q5

In q4, check if all 1’s have (B,B,N)

been erased with Y.

14

DTM Automata

Only the transitions along a path defined on the graph are legal. Reading a symbol

undefined (e.g., reading 1 in state q0 ), implies that M rejects the input.

Notice that the sequence of moves along the cyclic transitions through q1, q2, and q3

erases any number (≥ 1) of matching pairs of 0 and 1. We can prove by induction that

DTM M enters the accepting state q5 if and only if the input string is in the language

L = {0n1n | n ≥ 1}.

(0,0,R) (0,0,L)

(Y,Y,R) (1,Y,L) (Y,Y,L)

q2

q1

(X,X,R)

(0,X,R) (0,X,R)

q0 q3

start

(Y,Y,R) (Y,Y,R)

q4 q5

(B,B,N)

15

DTM Automata

below. In this book we will mainly use the state transition graph to show a DTM

and other automata, because it is easier to understand how they work.

δ (q2, 0) = (q2, 0, L) δ (q2, X) = (q3, X, R) δ (q3, 0) = (q1, X, R)

δ (q1, Y) = (q1, Y, R) δ (q2, Y) = (q2, Y, L) δ (q3, Y) = (q4, Y, R)

δ (q4, Y) = (q4, Y, R) δ (q4, B) = (q5, B, N)

16

DTM Automata

A DTM can also be represented with a table, called the state transition table. The

table below defines the DTM that we have designed. The states are listed on the

first column and the tape symbols on the first row. Table entries contain the triple

(next state, symbol written, direction). Blank entries are for the cases of rejecting

the input.

0 1 X Y B

q0 (q1, X, R)

q1 (q1, 0, R) (q2, Y, L) (q1, Y, R)

q2 (q2, 0, L) (q3, X, R) (q , Y, L)

2

q3 (q1, X, R) (q4, Y, R)

q4 (q4, Y, R) (q5, B, N)

q5

17

DTM Automata

where

Q: The finite set of states. q0 : The start state (q0 ∈ Q).

Σ : The finite input alphabet.

Γ : The finite tape alphabet, i.e., the set of symbols that are allowed to be

written on the tape, including the blank symbol B. Notice that Σ ⊆ Γ .

F: The set of accepting states (F ⊆ Q).

δ : The state transition function (δ : Q × Γ → Q × Γ × {L, N, R}), where

R, L and N, respectively, denote the direction in which the head moves

right, left or stay.

we say M accepts x. The language recognized by M, denoted by L(M), is the set of all

strings x in Σ * that are accepted by M, i.e.,

L(M) = { x | x ∈ Σ *, M accepts x}.

18

DTM Automata

defined as follows.

M = ( Q, Σ , Γ , δ , q0 , F ),

where Q = {q0, q1, q2, q3, q4, q5}, Σ = {0, 1}, Γ = {0, 1, X, Y, B}, F = {q5}, and the

transition function δ is given by the following state transition graph.

(0,0,R) (0,0,L)

(Y,Y,R) (Y,Y,L)

(1,Y,L)

q2

q1

(0,X,R)

(X,X,R)

(0,X,R)

q0 q3

start

(Y,Y,R) (Y,Y,R)

q4 q5

(B,B,N)

19

DTM Automata

The state transition of M shows only the transitions that lead to an accepting state.

For example, the graph (repeated below) defines only one transition from the start

state q0 for the case when the input symbol is 0. What will happen when the DTM

reads 1 in state q0? We assume that in such undefined cases, the machine enters a

“dead state” and rejects the input. For simplicity, we do not show such rejecting

transitions.

(0,0,R) (0,0,L)

(Y,Y,R) (Y,Y,L)

(1,Y,L)

q2

q1

(0,X,R)

(X,X,R)

(0,X,R)

q0 q3

start

(Y,Y,R) (Y,Y,R)

q4 q5

(B,B,N)

20

DTM Automata

• Only lower case letters are used for the input alphabet Σ .

• Initially, the input tape is written with a string x over the input alphabet, i.e.,

x ∈ Σ *, and the tape head is reading the leftmost symbol, if the input is not

εNotice

. that these assumptions do not affect the computational capability of the

machines. We could assume that the machine’s read/write head is initially

positioned at an arbitrary location on the input string. Then we can simply modify

the machine, as the following figure illustrates, so that it moves onto the leftmost

symbol of the input string and then starts the computation.

(X, X, L)

(B, B, R) . . . .

q0

start

X: any input symbol

21

Automata

A DLBA is a DTM whose read/write tape range is bounded by the length of the

input string. To indicate this range, the input string is delimited by a pair of boundary

markers (the matching brackets) as shown below. During the computation, if the

DLBA read one of the markers, it should either halt or move back toward the direction

it came from. Note that the boundary markers ‘[‘ and ‘]’ are in Γ .

Formally a DLBA is defined with an octuple including the boundary markers as

shown below. Except for the boundary markers, other elements of the octuple and the

language recognized by the automaton are specified as in the formal definition of a

DTM.

M = (Q, Σ , Γ , δ , q0, [, ], [ a b a a b ]

F)

q0

22

DLBA Automata

below, we can make the state transition graph of a DLBA which recognizes the

same language. Notice that in state q4, reading the closing boundary mark ‘]’

(instead of the blank symbol B), the machine enters the accepting state. All the

other moves are identical to the ones of the DTM.

(0,0,L)

(0,0,R)

(Y,Y,L)

(Y,Y,R) (1,Y,L) q2

q1

(0,X,R)

(X,X,R)

(0,X,R)

q0 q3

start

(Y,Y,R) (Y,Y,R)

q4 q5

( ], ], N )

23

Automata

A deterministic pushdown automaton (DPDA) is a restrictive version of the DTM.

The capacity of the two-way read/write tape head is restricted to one-way read-only

and instead, the machine is equipped with a pushdown stack as shown below. In each

move the machine does the following:

(1) Read the stack-top symbol.

(2) Depending on the stack-top symbol and the current state, either read the input

or do not read it.

(3) Depending on the input symbol read (if it was allowed to read) and the stack-top,

pop the stack-top symbol or push some symbols, possibly changing the stack-top.

a b b a a b

one-way read only

finite state

control

push down stack

Z0

24

Automata

DPDA

Notice that depending on the state and the stack top symbol, the input head is either

allowed to read or not. Reading the input tape, the head should move right onto the

next cell. Otherwise, it does not move. The stack head is always positioned at the

stack top. We assume that at the bottom of the stack, a designated bottom of the stack

symbol (Z0) is initially written.

a b b a a b

one-way read only

finite state

control

push down stack

Z0

25

Automata

DPDA

As we did for DTM and DLBA, we shall mainly describe a DPDA with the state

transition graph or the transition function δ as shown below. To denote a move of

not reading the input tape, we shall use the null character ε for the parameter “input

symbol read.” We call it an ε -move. If the parameter “stack-top content changed” is

ε , it is a popping move, i.e., the stack-top symbol is erased.

next

state

( input symbol read, stack-top symbol /stack-top content changed)

current (a)

state

(next state, stack-top content changed)

(b)

26

DPDA Automata

representations in terms of the transition function δ and the state transition graph.

Notice that the second move is an ε -move.

a b c a b c a b c a b c

p q r q

… Z … X Y … X V … X

δ ( p , a, Z ) = δ ( q, ε , Y ) = ( r, δ ( r, b, V ) = ( q, ε

( q,YX ) V) )

A

(a, Z /YX) (ε , Y/V) N

p q r I

(b, V/ε )

27

DPDA Automata

M = ( Q, Σ , Γ , δ , q0 , Z0, F ),

where Q is the set of states, Σ is the input alphabet, Γ is the stack alphabet, δ is

the transition function, q0 is the start state, Z0 is the bottom of the stack symbol, and F

is the set of accepting states.

The function δ , given the current state, the stack-top symbol and the input symbol

read or ε (for ε -move), outputs the next state and a string of stack symbols with

which the stack-top symbol is replaced, i.e.,

δ : Q × ( Σ ∪ {ε } ) × Γ → Q × Γ *

According to the above definition, M can rewrite the stack-top symbol with a string

(of stack symbols) of finite length (including the null string). For convenience we can

simplify the stack operation such that the machine either pops the stack-top or pushes

one symbol on top of the stack without affecting the language recognized by the

machine. At the end of this chapter we will show how.

28

DPDA Automata

Starting with the initial configuration with the input head on the leftmost symbol

and the stack head at the bottom of the stack, a DPDA M accepts the input if and

only if it enters a configuration satisfying the following two conditions. (Notice that

the conditions are irrelevant to the stack contents.)

(1) The input head has read the input string up to the last symbol.

(2) The machine is in an accepting state (qf in figure (b)).

a b b a a a b b a a

q0 qf

Z0 Z0 X

(a) (b)

The language L(M) is the set of input strings accepted by M, i.e.,

L(M) = { x | x ∈ Σ *

, M accepts x }

29

Designing a DPDA Automata

Here is a simple idea. Reading a’s, M pushes them in the stack, and then, for each b

read from the input tape, the machine erases one a by popping it from the stack top till

it sees Z0 (i.e., the stack is empty). Seeing the stack is empty, M enters an accepting

state without reading the input. The state transition graph of M is shown below.

The best way to understand how this DPDA works is to trace its moves along the

transition graph. See how M accepts the input string aaabbb and fails to accept aaabb.

a a a b b b

(a, a/aa)

(b, a/ε ) (ε ,

q0 Z0/Z0)

start

30

Designing a DPDA Automata

Example 2. Design a DPDA which recognizes {aibj | j > i > 0 }.

We will use the same idea of pushing a’s and then, for each b read, popping one

a from the stack top. Notice that by the time the stack is empty (i.e., Z0 appears at

the stack top), the machine has read the same number of a’s and b’s. It should

make sure that there are more b’s in the tape by reading them up to the last one.

To do this the machine reads one more symbol and if it is a, enters an accepting

state. In the accepting state the machine reads off all the remaining b’s, if any.

(b, a/ε )

(b, Z0/Z0)

(b, a/ε )

(a, Z0/aZ0)

start

31

Designing a DPDA Automata

Notice that this language has more a’s than b’s. The figure shown below is a DPDA

that recognizes this language. Notice that this machine reads the first a and discards it.

Then the machine pushes all the remaining a’s onto the stack and reading the first b,

enters an accepting state. And in the accepting state, read off all the remaining b’s,

popping one a from the stack top for each b read.

Because all the a’s in the input except the first one have been pushed into the stack,

during the popping phase it is guaranteed that the total number of a’s read from the

input tape is strictly greater than the number of b’s.

See how this DPDA works by tracing its moves for the input strings aaabb and

aabbb.

(a, Z0/aZ0)

(a, a/aa) (b, a/ε )

(b, a/ε )

(a, Z0/Z0)

start

32

Designing a DPDA Automata

For comparison, here are the three state transition graphs that we have designed

in the previous examples.

(a, Z0/aZ0)

(a, a/aa) (b, a/ε )

(a, a/aa)

(b, a/ε ) (ε ,

Z0/Z0)

(b, a/ε )

(a, Z0/Z0)

(a, Z0/aZ0) (b, a/ε ) start

start

(b, a/ε )

(b, Z0/Z0)

(a, Z0/aZ0)

start

33

DPDA 설계 Automata

{aibkci | k, i > 0 } ∪ {aibkdk | k, i > 0 }

Notice that to recognize the first half of the language, the machine needs to push a’s

into the stack to match with c’s. However, we cannot let the machine read off b’s and

discard them, because the input string may belong to the second half of the language.

The machine needs all a’s and b’s (in this order) pushed into the stack till it reads c or

d from the input tape. Reading c, we let it pop out all the b’s in the stack before it

begins matching a’s and c’s.

(ε , b/ε )

(ε , a/ε ) (c, a/ε )

(c, b/ε )

(a, a/aa) (ε , Z0/ Z0)

(b, a/ba)

(d, b/ε )

(ε , a/a)

start

(d, b/ε )

34

Automata

4.4 Deterministic finite automata (DFA)

Deterministic finite automata (DFA) are the simplest computational model, which

can recognize only regular languages. A DFA is a DPDA with the pushdown stack

removed. Thus a DFA M is defined with the quintuple M = ( Q, Σ , δ ,q0 , F ),

where Q, Σ , q0, and F are the same as they are defined for a DPDA. The transition

function δ is the mapping

δ : Q × Σ → Q.

In a move the machine reads the input tape, and depending on the current state and

the input symbol read, it enters a state in Q and moves right. For example, δ (p, a) =

q implies a move shown in figure (a) below, which can be represented with the state

transition graph shown in figure (b).

a a b a a b a q

One-way

read only p

p q

(a) (b)

35

DFA

Automata

A DFA accepts the input string if and only if it satisfies the following two

conditions, which are the same for DPDA’s.

(1) The input head has read the input string up to the last symbol.

(2) The machine is in an accepting state.

L(M) = { x | x ∈ Σ *

, M accepts x }

L = {x | x ∈ {0, 1}+, the number of 1’s in x is odd}

Here is the transition graph of a DFA which recognizes the language L.

0 0

1

start

1

36

Designing a DFA Automata

L = {x | x is a binary number, i.e., x ∈ {0, 1}+, and x mod 3 = 0 }

Let M be a DFA which recognizes L. In addition to the start state, M has 3 states,

each labeled with one of the three possible remainders, 0, 1, and 2 (see the graph

below). Reading the input binary string, M computes the current remainder on the fly

and enters the state labeled with that remainder as follows.

0 1

1 0

0

0 1 2

start 1 0

1

For a binary string w, let dec(w) be the decimal value of w. If the first symbol

read is 0, the current remainder is 0, if 1 it is 1. So, depending on the first input symbol

read, M enters either state 0 or 1. Suppose that reading up to a prefix v of the input

string, M entered a state i ∈ {0, 1, 2}, implying that i = dec(v) mod 3. Reading the next

bit j ∈ {0, 1}, M enters a state labeled by dec(vj) mod 3. Since dec(vj) mod 3 =

(2dec(v) + j) mod 3 = (2i + j) mod 3, M can easily identify the next state to enter as the

transition graph shows.

37

Automata

Rumination (1): States

Every automaton has some states. We have introduced the word “state” without elaborating the deep conceptual issues

involved. Actually, by a state we represent the whole information stored in the finite state control that the machine needs for

the work. The DTM that we have designed in Example 2 of Section 4.1 has 6 states. In each state qi the machine does a unique

work. Erasing the leftmost 0 with X, the machine keeps moving right in state q1 till it reads the leftmost 1. Rewriting this 1

with Y, the machine keeps moving left in state q2 until it reads X (see the top figures (a) through (d) below). Would it be

possible to do this part of the work in one state? The answer is no. The figures at the bottom show why.

Suppose that the machine, erasing the leftmost 1 by Y, moved left in the same state q1. Then the machine will encounter the

same symbol 0 that it came across moving right. Reading this 0 the machine should move right, because the DTM must take

the same move (as in figure (a)) with the same input 0 in the same state q1, i.e., δ (q1, 0) = (q1, 0, R). Reading the same 0

second time in state q1, the machine has no information in its finite control that indicates it should move left this time. In its

finite control the machine should have some information available that is different from the one when it is in state q1. Being in

state q2, different from q1, implies this.

X 0 1 1 .. X 0 1 1 .. X 0 Y 1 .. X 0 Y 1 ..

q1 q1 q2 q2

(a) (b) (c) (d)

X 0 1 1 .. X 0 1 1 .. X 0 Y 1 .. X 0 Y 1 ..

q1 q1 q1 ? q1

38

Rumination (1): States Automata

The six states of the DTM in Example 2 (repeated below) can be implemented with a three-bits register, for example, letting its

values 000, 001, 010, 011, 100, and 101 represent the states q0, q1, q2, q3, q4, and q5, respectively. The number of states is directly

related to the hardware complexity of the machine. Unfortunately, given an arbitrary automaton, it is an unsolvable problem to

minimize the number of states of the machine. However, for DFA it is possible to minimize them. We will learn how in Chapter 8.

(0, 0, R) (0, 0, L)

(Y,Y, R) (Y,Y, L)

(1,Y, L)

q2

q1

(0, X, R)

(X, X, R) X 0 Y 1 ..

(0, X, R)

q0 q3

start 010

(Y,Y, R) (Y,Y, R)

q4 q5

(B, B, N)

39

Automata

Rumination (2): Accepting conditions

Recall that by the definition, both DTM and DLBA accept the input string by entering an accepting state. Hence, no transition is

needed out of an accepting state. We may think that both DTM and DLBA halt in an accepting state. Also recall that both DTM and

DLBA can have more than one accepting state (i.e., F ⊆ Q). However, we can show that one accepting state is enough. If it has more

than one accepting state, we simply merge them into one as the figure below illustrates. Thus, we can design a user-friendly DTM or

DLBA which entering the accepting state, can kindly announce that the input has been accepted.

What will happen when the input string is not accepted? Would it be possible to design a DTM which can inform us of not

accepting the input? What about the other machine models? We will deal with these intriguing questions and related ones in

Chapters 7, 12 and 15, under the title of Hierarchy of Languages and Automata.

In contrast, for both DPDA and DFA the following two conditions should be satisfied simultaneously to accept the input

string.

(1) The input head has read the string up to the last symbol.

(2) The finite state control is in an accepting state.

Notice that with no unique marker appended to every input string, it is impossible for both DPDA and DFA to identify whether

the symbol read is the last one or not. Figures (a) and (b) below, respectively, show a DPDA and a DFA recognizing the language

L = {ai | i > 0 }. Suppose that the string aaaa is given as an input. Reading the first a, the machines enter the accepting state.

However, it is too early to say that the input string is accepted because it has not read the last a yet (i.e., the second condition is

not yet satisfied). Since the machines keep reading a’s in the accepting state, it will eventually satisfy the two conditions.

(a, Z0/Z0) a

(a, Z0/Z0) a

start start

(a) (b)

40

Automata

Rumination (2): Accepting conditions

If the input string had a symbol different from a, the machine would fail to accept it because the transitions are defined only for

the symbols in the input alphabet. Since the blank symbols does not belong to the input alphabet, the machine cannot read the

blank symbol next to the last input symbol to ensure that the symbol read in the previous move is the last input symbol or not.

(Such an illegal move is quite tempting for a student designing a DPDA.)

From the above analysis we find that both DPDA and DFA are not autonomous computational models that can kindly tell us

whether the input is accepted or not. In other words, we cannot make them say “Yes, I accept it!” or “Sorry, I cannot.” Rather

we, the user, must decide, for a given input string, whether or not the machine satisfies the two conditions after some finite

number of moves.

Concerning these accepting conditions, we may raise the following question: Why should we put the burden on the user for

the decision? How about appending an end-of-string marker to every input string? Consider the language L’ = {ai ; | i > 0}

with a marker ‘;’ appended to every string in L. For such language we don’t need condition (1) above. The input strings will

accepted if and only if the machine enters an accepting state (see the figures below).

(a, Z0/Z0) a

(a, Z0/Z0) a

Appending an end-of-string marker to every string appears to alleviate the burden for the user to see if a DPDA or a DFA

accepts it. However, this approach introduces a new burden for the user in the real application. For example, programming

language C uses such approach (each statement must end by a semicolon) and we know why it is a burden, while FORTRAN does

not. In this book we mainly study the automata whose languages have no end-of–string markers.

Recall that for both DTM and DLBA, the only accepting condition is to enter an accepting state. The user does not have to check

if the last input symbol has been read. They can identify the last symbol by reading the next neighboring symbol, i.e., the blank

symbol for DTM and the right boundary marker ‘]’ for DLBA. (Notice that blank symbol belongs to the tape alphabet that the

DTM can read.) Since the tape head of these models is bidirectional, they can accept the input string with the head located at any

position.

41

Automata

Rumination (3): Stack operation of DPDA

By definition, in every move, a DPDA rewrites the stack-top symbol with a string of finite length (including the null string).

(Notice that rewriting the stack-top with the null string implies a popping operation.) This stack operation can be simplified

such that the stack-top symbol is either popped out or exactly 1 symbol is pushed on top of the stack without affecting the

language recognized by the machine. (Notice that in this simplified version, there is no stack operation rewriting the stack-top

symbol with another.)

Suppose that as illustrated in figure (a) below, there is a DPDA which has a stack operation rewriting the stack-top with a

string of length either 1 (i.e., simply replaces the stack-top with another) or greater than 2 (i.e., pushes more than 1 symbol on

top of the stack). Figure (b) shows a simplified version of figure (a). Notice that the stack operation involved in the transition

with (b, A/B) is replaced by two transitions with a pushing operation (b, A/XB) followed by a popping operation (ε , X/ε ),

where X is a new stack symbol introduced. It is clear from the transformation that such simplification does not affect the

language recognized by the DPDA.

(ε , X/ε )

(b, A/XB)

(b, A/B)

(a, Z0/AaBZ0)

(ε , B/aB)

(a) (b)

42

Automata

Rumination (4): Reading operation of a DPDA

Finally we would like to ruminate on the reading operation of a DPDA and clarify some tricky concepts involved. Recall that

a DPDA does the following in a move.

(1) In the current state, read the stack-top symbol.

(2) Depending on the stack-top symbol and the current state, either read the input or do not read.

(3) Depending on the input symbol read (if it was allowed to read in (2) above) and the stack-top symbol, pop the stack-top

symbol or push some symbols, possibly changing the stack-top.

For a state p, stack symbol A and an input symbol a, if transition δ (p, a, A) is defined, then the above definition implies that

transition δ (p, ε , A) should not be defined, and vice versa. To the contrary, suppose that both transitions δ (p, a, A) = (q,

BA) and δ ( p, ε , A) = (r, CA) are defined (see the figure below). Transition δ (p, a, A) = (q, BA) implies the following

move.

(1) In state p, the DPDA reads the stack-top symbol. (This part is always done in any state.)

(2) If the stack-top symbol is A, the machine reads the input, and

(3) if the input symbol read is a, pushes B on top of the stack and enters state q.

r

In contrast, transition δ (p, ε , A) = (r, CA) implies the follow move: (ε , A/ CA)

p q

(2) If the stack-top is A, the machine does not read the input, and (a, A/ BA)

(3) pushes C on top of the stack and enters state r.

Notice that in the two moves δ (p, a, A) = (q, BA) and δ ( p, ε , A) = (r, CA), the machine does two contradictory actions

(boldfaced phrases) in the same state p with the same stack-top symbol A; in the former move, the machine reads the input

symbol, while in the later it does not read the input. This violates the determinism of DPDA that for the same course (i.e., the

same state p and stack-top symbol A) there must be a unique response. Deterministic automata do not allow such moves. In the

following chapter we will study nondeterministic automata, where such contradictory moves are allowed.

43

Automata

Exercises

4.1 Design a DTM which, given a binary number x ∈ {0, 1}+ on the input tape, increments x by one and halts in an

accepting state.

4.2 What does the following DTM do? The input is a binary string. Describe the work in detail referring each state.

For your answer, it is a good strategy to trace the moves of the machine with a couple of short input strings.

(0,0,L)

(1,1,R)

(0,0,R)

(0,B,L) 4 (B,0,N)

(1,1,R)

(1,0,L) (0,0,R)

start 0

(B,B,L)

2 3

(0, 1, R)

(B,1,R)

(1,B,L) 5 (B,1,N)

(1,1,L)

44

Exercises Automata

4.3 Design a DTM which, given a string x ∈{a, b}*, does each of the following works and then halts in an accepting state.

(a) Shift the string x one cell to the right. (b) Shift the string x two cells to the right.

4.4 Design a DTM which, given a string x ∈{a, b}*, collects all a’s in x to the left and all b’s to the right. For example, given

the string baabbab as an input, your machine should rearrange the symbols in it such that aaabbbb is the only string in the tape.

4.5 Design a DTM which, given a string x ∈ {a, b, c}+, moves all c’s toward the left end of the string and halts. For example,

given the string baacbbccabc, the machine should leave only the string ccccbaabbab on the tape and halt. With the transition

graph of your machine and an input string, briefly explain how it works.

4.6 Design a DPDA to recognize each of the following languages. (Notice that L1, L2, and L3 have an end-of-string marker ‘;’)

(a) L1 = {aibj; | i > j > 0 } (b) L2 = {aibj; | i ≥ j > 0 } (c) L3 = {aibj; | i ≥ j ≥ 0 }

(d) L4 = {aibj | i > j > 0 } (e) L5 = {aibj | i ≥ j > 0 } (f) L6 = {aibj | i ≥ j ≥ 0 }

(g) L7 = { aibkci | i, k > 0 } (h) L8 = { aibkci | i, k ≥ 0 }

4.7 Design a DPDA to recognize the language generated by each of the following context-free grammars.

(a) G1: S → aSbb | abb (b) G2: S → aSbb | ε (c ) G3: S → aSbb | ccc

L1 = { x | x ∈ {a, b, c}+, in x the number of a’s and the number of b’s are same. }

L2 = { x | x ∈ {a, b, c}+, in x the number of a’s is strictly greater than the number of c’s. }

(a) L1 = { babo } (b) L2 = { xbaboyobba | x, y ∈ {a, b, o}*}

(c) L3 = {x | x ∈ {a, b, c}+ , string x begins and ends with the same letter.}

45

Exercises Automata

The following problem is for modeling a system by a DFA. The original problem is given as an exercise in the book “Introduction

to Automata Theory, Languages, and Computation (page 53) (by Hopcropt, Motwani and Ullman, Edison Wesley, 2001).” Here we

present it slightly modified.

4.10 Consider a network of ducts shown below. The network has two entries labeled A and B, and two exits C and D. There are two

levers; x1 at the branching section and x2 at the cross-section. If we drop a marble in at A or B, the marble rolls down along the

ducks and hits one of the levers, which causes it to fall either to the left or to the right. Whenever a lever is hit by a marble, it causes

the lever change its orientation 90o such that the next marble to encounter the lever will be directed to the opposite direction. The

initial lever positions are set as shown in the figure, indicating that both levers direct the marble to the right.

Model this network by a DFA whose input is a binary string, where 0 denotes a marble dropped in at A, and 1 denotes a marble

dropped in at B. The automaton accepts the input if the last marble comes out of exit D.

A B

x1

x2

C D

46

- AUTOMATON-AN ABSTRACT COMPUTING DEVISE & ITS RECENT TRENDSUploaded byAnonymous vQrJlEN
- Formal Language and Automata TheoryUploaded byAhmed Mateen
- Derivatives of Regular Expressions Re-ExaminedUploaded byJoe Dane
- nlecture1428551440.pdfUploaded byasif usman
- 214 Midterm a SolutionUploaded byabdal113
- Chapter5 Lexical AnalysisUploaded byWassim Akel
- ECEN 248 Lab11_reportUploaded byRebecca Sontheimer
- Automata DefinitionsUploaded byal_badwi
- L10 - Finite State RecognizersUploaded bynho_Osaka
- Concrete Basic Built in Expertise ExploitationUploaded bysfofoby
- A Study of Finite State Machine Coding Styles for ImplementationUploaded bypriyankaanthem
- Logic and Discrete Mathematics for Computer ScientistsUploaded byjson smith
- CompRobo Warmup WriteupUploaded byBoon David
- Science TriposUploaded bySergio Herzel
- A Critical Analysis of Performance and Efficiency of Minimization Algorithms for Deterministic Finite AutomataUploaded byInternational Journal of Innovative Science and Research Technology
- Fsm ExamplesUploaded byRanjith M Kumar
- vlsi 10Uploaded byVimala Priya
- Regular LanguagesUploaded byRajendranbehappy
- Oultine CS 729 TheoryOfAutomataAndFormalLanguages Spring 2012(MCS 2 Morning)Uploaded byUmar Tahir
- Over 5Uploaded byDinesh Khandelwal
- ECE2072unitguide2010Uploaded byGaya Muthukumar
- Lexical Analyzer (Compiler contruction)Uploaded bytouseefaq
- 355mt1f16sol.pdfUploaded byCameron Harman
- qbUploaded byMadhan K Nithyanandham
- CS2006_2_SemUploaded byAditya Biswas
- 1-s2.0-037650758290112X-mainUploaded byAbdelkrim Lamraoui
- Com Put Able Function Atomta Trm PrUploaded byKhushi Gupta
- Algorithmic Information Theory Ibm JournalUploaded byshchasen

- Chapter 02. LanguagesUploaded bykims3515354178
- Models for Computation: Part 0Uploaded bySam Myo Kim
- Chapter 01. PreliminaryUploaded bykims3515354178
- Appendix F. CYK AlgorithmUploaded bykims3515354178
- Chapter 11. Ambiguity of Context-free GrammarsUploaded bykims3515354178
- Chapter 09. Language PropertiesUploaded bykims3515354178
- Appendix E. Pumpable CFLUploaded bykims3515354178
- Appendix D. Property of DCFLUploaded bykims3515354178
- Chapter 13.2. LR ParsingUploaded bykims3515354178
- Chapter 15. Hierarchy of Models (III)Uploaded bykims3515354178
- Appendix C. Computing Regular ExpressionUploaded bykims3515354178
- Appendix B. 2-Way Finite AutomataUploaded bykims3515354178
- Chapter 07. Hierarchy of ModelsUploaded bykims3515354178
- Chapter 12. Hierarchy of Models (II)Uploaded bykims3515354178
- Appendix A. Pascal Syntax FlowUploaded bykims3515354178
- Chapter 14. Language ApplicationUploaded bykims3515354178
- Chapter 05. Nondeterministic AutomataUploaded bykims3515354178
- Chapter 13.1. LL ParsingUploaded bykims3515354178
- Chapter 10. Manipulating Context-free GrammarsUploaded bykims3515354178
- Chapter 08. Manipulating Finite State AutomataUploaded bykims3515354178
- Chapter 06. Other Automata ModelsUploaded bykims3515354178
- References and IndexUploaded bykims3515354178
- Chapter 03. Other LanguagesUploaded bykims3515354178

- Final HRM ProjectUploaded byPunit Bhanushali
- MSUploaded byVidhi Joshi
- strain.pdfUploaded byChandra Clark
- percentstofractionslessonplan-2Uploaded byapi-351273594
- Are ResortUploaded byTracy Simon
- Respectability ZimbabweUploaded byKiwumulo Nakandi
- lesson planUploaded byapi-316608836
- Dave Bolton InterviewUploaded byZsákaiAntal
- Supervise RadiusdUploaded bymaverick4ml
- Wc 1 SolutionsUploaded byRodrigoCastellano
- SOUNDING,HIGH RESOLUTION SHALLOW SEISMIC REFLECTION AND UNDERWATER SONOGRAPHICUploaded byAlvaro Javier
- JN Transport Company ProfileUploaded byJN Transport
- 97615_03Uploaded byphanisai
- FingerprintUploaded byCristina Filip
- Infor CRM 8.3 Compatibility Matrix - Apr2016 (4)Uploaded byMalay Mukherjee
- Levels of TranceUploaded byJitesh Manwani
- Cross AppsUploaded byswadhincyber
- Totality and Infinity Whole Book Word PDF 2012-03-14Uploaded byAmy Dunville
- Hebbian Theory - WikiUploaded byJon Arnold Grey
- Project-on-TATA-MotorsUploaded byYashwanth Raj
- 7.Eke O. UdumaUploaded byiiste
- Luminol Post LabUploaded byjoshkty27
- Vocabulary of Mechanic -english to persianUploaded byneda
- Exchange Active Sync ExplainedUploaded byKaveri Uppar
- Interview Questions and AnswersUploaded byHardik Jadav
- Gassman TutorialUploaded byKristian Torres
- bgggUploaded byDaryl Badajos
- 02 Fiske, cap 1Uploaded byNelson Diaz
- Ian Ward-An Introduction to Critical Legal Theory-Gaunt (1998).pdfUploaded byHiram Camarillo
- e Familiar Ization for Open Lab Cds a 0202Uploaded byanon_665748378