Вы находитесь на странице: 1из 57

.

6
c
m
.
Introduction to Formal Languages,
Automata and Computability
Turing Machine
K. Krithivasan and R. Rama
Introduction to Formal Languages, Automata and Computability p.1/57
Introduction
The concept of Turing machine is particularly helpful in offering
a clear and realistic demarcation of what constitutes a single step
of execution. The problem of how to separate the steps from one
another in a step-by-step procedure is clearly specied when it is
put into the form of a Turing machine table.
To start with, we may specify an effective procedure as follows :
An effective procedure is a set of rules which tell us, frommoment
to moment, precisely how to behave. With this in mind, Turings
thesis may be stated as follows: Any process which could natu-
rally be called an effective procedure can be realised by a Turing
machine.
Introduction to Formal Languages, Automata and Computability p.2/57
contd.
One cannot expect to prove Turings thesis, since the
term naturally relates rather to human dispositions
than to any precisely dened quality of a process.
Support must come from intuitive arguments. Hence
it is called Turings hypothesis or Church-Turing
thesis and not as Turings theorem.
Till today Turing machine is taken as the model of
computation. Whenever a new model of computation
(like DNA computing, membrane computing) is
dened, it is the practice to show that this new model
is as capable as the Turing machine. This proves the
power of the new model of computation.
Introduction to Formal Languages, Automata and Computability p.3/57
Turing Machine as an Acceptor
The Turing machine can be considered as an accepting device
accepting sets of strings. Later we shall see that Turing machines
accept the family of languages generated by type 0 grammars. The set
accepted by a Turing machine is called a recursively enumerable set.
When we consider the Turing machine as an accepting device, we
usually consider a one way innite tape. The Turing machine consists
of a one way innite read-write tape and a nite control.
a
1
a
n
b b b

q
0
Figure 1: Initial conguration
Introduction to Formal Languages, Automata and Computability p.4/57
contd.
The input a
1
. . . a
n
is placed at the left end of the tape.
The rest of the cells contain the blank symbol b.
Initially the tape head points to the leftmost cell in the
initial state q
0
. At any time the tape head will point to
a cell and the machine will be in a particular state.
Suppose the machine is in state q and pointing to a cell
containing the symbol a, then depending upon the
mapping (transition function) of the TM it will change
state to p and write a symbol X replacing a and move
its tape head one cell to the left or to the right. The
Turing machine is not allowed to move off the left end
of the tape. When it reaches a nal state it accepts the
input. Now we consider the formal denition.
Introduction to Formal Languages, Automata and Computability p.5/57
Denition
A Turing machine (TM) M = (K, , , , q
0
, F) is a
6-tuple, where
K is a nite set of states
is a nite set of input symbols
is a nite set of tape symbols, , b is
the blank symbol
q
0
in K is the initial state
F K is the set of nal states
is a mapping from K into K {L, R}.
Introduction to Formal Languages, Automata and Computability p.6/57
contd.
Note
(a) Turing machine mapping is dened in such a way that it is
deterministic. One can dene nondeterministic TM.
Though they have the same power as far as accepting power
is concerned, the number of steps may exponentially
increase if a deterministic TM tries to simulate a
nondeterministic TM.
(b) In some formulations the head remaining stationary is
allowed. i.e., : K K{L, S, R}. But we shall
stick to {L, R} as remaining stationary can be achieved by
two moves, rst moving right and then moving back left.
Introduction to Formal Languages, Automata and Computability p.7/57
contd.
An Instantaneous Description (ID) of a Turing machine is a
string of the form
1
q
2
,
1
,
2

, q K.
This means that at that particular instance
1

2
is the content of
the tape of the Turing machine. q is the current state and the tape
head points to the rst symbol of
2
. See

1

2
b b b

q
The relationship between IDs can be described as follows:
If X
1
. . . X
i1
qX
i
X
i+1
. . . X
m
is an ID and
Introduction to Formal Languages, Automata and Computability p.8/57
contd.
(q, X
i
) = (p, Y, R) then the next ID will be
X
1
. . . X
i1
Y pX
i+1
. . . X
m
.
If (q, X
j
) = (p, Y, L) then the next ID will be
X
1
. . . X
i2
pX
i1
Y X
i+1
. . . X
m
. We denote this as
X
1
. . . X
i1
qX
i
X
i+1
. . . X
m
X
1
. . . X
i2
pX
i1
Y X
i+1
. . . X
m
.
q
0
X
1
. . . X
m
is the initial ID. Initially the tape head points to the
leftmost cell containing the input. If qX
1
. . . X
m
is an ID and
(q, X
1
) = (p, Y, L), machine halts. i.e., moving off the left end
of the tape is not allowed. If X
1
. . . X
m
q is an ID, q is reading
the leftmost blank symbol. If (q, b) = (p, Y, R) next ID will be
X
1
. . . X
m
Y p.
Introduction to Formal Languages, Automata and Computability p.9/57
contd.
If (q, b) = (p, Y, L) next ID will be
X
1
. . . X
m1
pX
m
Y .

is the reexive, transitive
closure of . i.e., ID
0
ID
1
ID
n
is denoted
as ID
0

ID
n
, n 0. An input will be accepted if the
TM reaches a nal state.
Denition A string w is accepted by the TM,
M = (K, , , , q
0
, F) if q
0
w


1
q
f

2
for some

1
,
2

, q
f
F. The language accepted by the
TM M is denoted as
T(M) = {w|w

, q
0
w


1
q
f

2
for some
1
,
2

, q
f
F}
Introduction to Formal Languages, Automata and Computability p.10/57
Note
(a) It should be noted that by denition, it is not necessary for
the TM to read the whole input. If w
1
w
2
is the input and the
TM reaches a nal state after reading w
1
, w
1
w
2
will be
accepted; for that matter any string w
1
w
j
will be accepted.
Usually while constructing a TM we make sure that the
whole of the input is read.
(b) Usually we assume that after going to a nal state, the TM
halts, i.e., it makes no more moves.
(c) A string w will not be accepted by the TM, if it reaches an
ID
1
r
2
from which it cannot make a next move;

, r K and r is not a nal state or while reading


w, the TM gets into a loop and is never able to halt.
Introduction to Formal Languages, Automata and Computability p.11/57
Example
Let us consider a TM for accepting {a
i
b
j
c
k
|i, j, k 1, i = j +k}.
The informal description of the TM is as follows. Consider the gure
which shows the initial ID.
aa a aab bc c b b b

q
0
The machine starts reading a a and changing it to a X; it moves right;
when it sees a b, it converts it into a Y and then starts moving left. It
matches as and bs. After that, it matches as with cs. The machine
accepts when the
Introduction to Formal Languages, Automata and Computability p.12/57
contd.
number of as is equal to the sum of the number of bs
and the number of cs.
Formally M = (K, , , , q
0
, F)
K = {q
0
, q
1
, q
2
, q
3
, q
4
, q
5
, q
6
, q
7
, q
8
} F = {q
8
}
= {a, b, c}
= {a, b, c, X, Y, Z, b}
is dened as follows:
(q
0
, a) = (q
1
, X, R)
In state q
0
, it reads a a and changes it to X and
moves right in q
1
.
(q
1
, a) = (q
1
, a, R)
In state q
1
it moves right through the as.
Introduction to Formal Languages, Automata and Computability p.13/57
contd.
(q
1
, b) = (q
2
, Y, L)
When it sees a b it changes it into a Y .
(q
2
, a) = (q
2
, a, L)
(q
2
, Y ) = (q
2
, Y, L)
In state q
2
it moves left through the as and Y s.
(q
2
, X) = (q
0
, X, R)
When it sees a X it moves right in q
0
and the process
repeats.
(q
1
, Y ) = (q
3
, Y, R)
(q
3
, Y ) = (q
3
, Y, R)
(q
3
, b) = (q
2
, Y, L)
After scanning the as it moves through the Y s still it
Introduction to Formal Languages, Automata and Computability p.14/57
contd.
sees a b, then it converts it into a Y and moves left.
(q
3
, c) = (q
4
, Z, L)
When no more bs remain it sees a c in state q
3
,
changes that it into Z and starts moving left in state
q
4
. The process repeats. After matching as and bs,
the TM tries to match as and cs.
(q
4
, Y ) = (q
4
, Y, L)
(q
4
, a) = (q
4
, a, L)
(q
4
, X) = (q
0
, X, R)
(q
3
, Z) = (q
5
, Z, R)
(q
5
, c) = (q
4
, Z, L)
(q
5
, Z) = (q
5
, Z, R)
(q
4
, Z) = (q
4
, Z, L)
Introduction to Formal Languages, Automata and Computability p.15/57
contd.
When no more as remain it sees a Y in state q
0
checks that all bs and cs have been matched and
reaches the nal state q
8
.
(q
0
, Y ) = (q
6
, Y, R)
(q
6
, Y ) = (q
6
, Y, R)
(q
6
, Z) = (q
7
, Z, R)
(q
7
, Z) = (q
7
, Z, R)
(q
7
, b) = (q
8
, b, halt)
Introduction to Formal Languages, Automata and Computability p.16/57
contd.
Let us see how a string aaabbcc will be rejected. Let
us trace the sequence of IDs on aaabbcc
q
0
aaabbcc Xq
1
aabbcc Xaq
1
abbcc Xaaq
1
bbcc Xaq
2
aY bcc
Xq
2
aaY bcc q
2
XaaY bcc Xq
0
aaY bcc XXq
1
aY bcc
XXaq
1
Y bcc XXaY q
3
bcc XXaY Y cc XXq
2
aY Y cc
Xq
2
XaY Y cc XXq
0
aY Y cc XXXq
1
Y Y cc XXXY q
3
Y cc
XXXY Y q
3
cc XXXY q
4
Y Zc XXXq
4
Y Y Zc XXq
4
XY Y Zc
XXXq
0
Y Y Zc XXXY q
6
Y Zc XXXY Y q
6
Zc XXXY Y Zq
7
c
Introduction to Formal Languages, Automata and Computability p.17/57
contd.
The machine halts without accepting as there is no
move for (q
7
, c).
Let us see the sequence of moves for aaaabc
q
0
aaabc Xq
1
aaabc Xaq
1
aabc Xaaq
1
abc Xaaaq
1
bc
Xaaq
2
aY c Xaq
2
aaY c Xq
2
aaaY c q
2
XaaaY c
Xq
0
aaaY c XXq
1
aaY c XXaq
1
aY c XXaaq
1
Y c
XXaaY q
3
c XXaaq
4
Y Z XXaq
4
aY Z XXq
4
aaY Z
Xq
4
XaaY Z XXq
0
aaY Z XXXq
1
aY Z XXXaq
1
Y Z
XXXaY q
3
Z XXXaY Zq
5
The machine halts without accepting as there is no
further move possible and q
5
is not an accepting state.
It can be seen that only strings of the form a
i+j
b
i
c
j
will be accepted.
Introduction to Formal Languages, Automata and Computability p.18/57
Example
Construct a Turing machine which will accept the set
of strings over = {a, b} beginning with a a and
ending with a b.
Though this set can be accepted by a FSA, we shall
give a TM accepting it.
M = (K, , , , q
0
, F) where
K = {q
0
, q
1
, q
2
, q
3
} F = {q
3
}
= {a, b} = {a, b, X, b}
is dened as follows:
(q
0
, a) = (q
1
, X, R)
(q
1
, a) = (q
1
, X, R)
(q
1
, b) = (q
2
, X, R)
(q
2
, a) = (q
1
, X, R)
Introduction to Formal Languages, Automata and Computability p.19/57
contd.
(q
2
, b) = (q
2
, X, R)
(q
2
, b) = (q
3
, halt)
Let us see how the machine accepts abab.
a b a b b

q
0
X b a b b

q
1
X X a b b

q
2
Introduction to Formal Languages, Automata and Computability p.20/57
contd.
X X X b b

q
1
X X X X b

q
2
X X X X b

q
3
It can be seen that after initially reading a, the ma-
chine goes to state q
1
.
Introduction to Formal Languages, Automata and Computability p.21/57
contd.
Afterwards if it sees a a it goes to state q
1
; if it sees a
b it goes to q
2
. Hence when it sees the leftmost blank
symbol, if it is in state q
2
it accepts as this means that
the last symbol read is a b.
Introduction to Formal Languages, Automata and Computability p.22/57
Turing Machine as a Computing De-
vice
We looked at the Turing machine as an acceptor. In
this section, we consider the Turing machine as a
computing device. It computes functions which are
known as partial recursive functions.
Example[Unary to binary converter] The input is a
string of as which is taken as the unary representation
of an integer; a
i
represents integer i. The output is of
the form b
i
X
i
where b
i
is a binary string which is the
binary representation of integer i. The mapping for
the Turing machine which does this is given below.
The tape symbols are {b, a, X, 0, 1}. The machine
has two states q
0
and q
1
. q
0
is the initial state and a
right moving state. q
1
is a left moving state.
Introduction to Formal Languages, Automata and Computability p.23/57
contd.
(q
0
, a) = (q
1
, X, L)
(q
1
, X) = (q
1
, X, L)
(q
1
, b) = (q
0
, 1, R)
(q
1
, 0) = (q
0
, 1, R)
(q
1
, 1) = (q
1
, 0, L)
(q
0
, X) = (q
0
, X, R)
(q
0
, b) = (q
2
, b, halt)
The machine works like a binary counter. When it has
converted j as into Xs, it prints binary number j to
the left of the position where it started. On input
aaaaa the TM should output 101XXXXX.
Introduction to Formal Languages, Automata and Computability p.24/57
Copy machine
Given an input #w#, where w is a string of as and bs, the machine
makes a copy of w and halts with #w#w#. The machine starts in
state q
0
, the initial state on the leftmost symbol of w.
It reads a a changes that into a X and moves right in state q
a
. When
it sees the rst blank symbol, it prints a a and moves left in state q
1
.
If it sees a b in q
0
, it changes that into a Y and moves right in state q
b
.
When it sees the rst blank symbol, it prints a b and moves left in state
q
1
. In state q
1
it moves left till it sees a X or a Y and the process
repeats. When no more a or b remains to be copied, the machine
goes to q
2
, prints a # after the copy
Introduction to Formal Languages, Automata and Computability p.25/57
contd.
it has made and moves left in q
3
. In q
3
it moves
left till the # symbol. Then moving left it converts the
Xs and Y s into as and bs respectively and halts
when it sees the leftmost # symbol. q
a
and q
b
are used
to remember the symbol the machine has read.
The state set is {q
0
, q
a
, q
b
, q
1
, q
2
, q
3
, q
4
, q
5
}.
Tape symbols are {#, a, b, X, Y, b}
mappings are given by :
(q
0
, a) = (q
a
, X, R)
(q
a
, a) = (q
a
, a, R)
(q
0
, b) = (q
b
, Y, R)
(q
b
, a) = (q
b
, a, R)
(q
a
, b) = (q
a
, b, R)
Introduction to Formal Languages, Automata and Computability p.26/57
contd.
(q
a
, #) = (q
a
, #, R)
(q
a
, b) = (q
1
, a, L)
(q
b
, b) = (q
b
, b, R)
(q
b
, #) = (q
b
, #, R)
(q
b
, b) = (q
1
, b, L)
(q
1
, a) = (q
1
, a, L)
(q
1
, b) = (q
1
, b, L)
(q
1
, #) = (q
1
, #, L)
(q
1
, X) = (q
0
, X, R)
(q
1
, Y ) = (q
0
, Y, R)
(q
0
, #) = (q
2
, #, R)
(q
2
, a) = (q
2
, a, R)
(q
2
, b) = (q
2
, b, R)
Introduction to Formal Languages, Automata and Computability p.27/57
contd.
(q
2
, b) = (q
3
, #, L)
(q
3
, a) = (q
3
, a, L)
(q
3
, b) = (q
3
, b, L)
(q
3
, #) = (q
4
, #, L)
(q
4
, X) = (q
4
, a, L)
(q
4
, Y ) = (q
4
, b, L)
(q
4
, #) = (q
5
, #, halt)
Introduction to Formal Languages, Automata and Computability p.28/57
contd.
The sequence of moves in input #abb# can be
described as follows :
#q
0
abb# #Xq
a
bb#

#Xbb#q
a
#Xbbq
1
#a

#q
1
Xbb#a
#Xq
0
bb#a #XY q
b
b#a

#XY b#aq
b
#XY b#q
1
ab

#XY q
0
b#ab #XY Y q
b
#ab

#XY Y #abq
b

#XY Y #aq
1
bb

#XY Y q
0
#abb #XY Y #q
2
abb

#XY Y #abbq
2
#XY Y #abq
3
b#

#XY Y q
3
#abb# #XY q
4
Y #abb#

q
4
#abb#abb# q
5
#abb#abb#
Introduction to Formal Languages, Automata and Computability p.29/57
Example
Given two integers i and j, i > j, to compute the quotient and
reminder when i is divided by j.
The input is
# a
i
# b
j
#

with the tape head positioned on the leftmost b in the initial


state q
0
.
The output is
# X
i
# b
j
# c
k
# d

#
where k is the quotient when i is divided by j and l is the
remainder. The TM which does this is described as follows :
The TM converts the bs into Y s and as into Xs one by one.
Introduction to Formal Languages, Automata and Computability p.30/57
contd.
When it sees no more bs it prints a c after the # meaning j has
been subtracted from i once
# X
j
a
ij
# b
j
# c
This repeats as many times as possible. Each time a c is printed.
Finally when the number of as which have to be converted to Xs
is less than j, the TM while trying to convert a a into a X, will
not nd a a. At this stage it would have converted (i mod j +1)
bs into Y s. The TM prints a # after cs and prints i mod j + 1
ds. It does this by changing a Y into a b and printing a d after
rightmost # and ds. When all the Y s have been converted into
Introduction to Formal Languages, Automata and Computability p.31/57
contd.
bs, we have i mod j + 1 ds after the rightmost #. The
TM erases the last d and prints a # and halts. The set
of states are {q
0
, . . . , q
21
}. The tape symbols are
{b, #, a, b, c, d, X, Y }
The mappings are given by
(q
0
, b) = (q
1
, Y, L)
changes b to Y and moves left.
(q
1
, Y ) = (q
1
, Y, L)
(q
1
, #) = (q
2
, #, L)
(q
2
, a) = (q
2
, a, L)
moves left.
(q
2
, #) = (q
3
, #, R)
(q
2
, X) = (q
3
, X, R)
Introduction to Formal Languages, Automata and Computability p.32/57
contd.
when the leftmost # or an X is seen the head starts
moving right
(q
3
, a) = (q
4
, X, R)
one a is changed into X
(q
4
, a) = (q
4
, a, R)
(q
4
, #) = (q
5
, #, R)
(q
5
, Y ) = (q
5
, Y, R)
moves right
(q
5
, b) = (q
1
, Y, L)
process starts repeating
(q
5
, #) = (q
6
, #, R)
all bs have been converted to Y s
(q
6
, c) = (q
6
, c, R)
(q
6
, b) = (q
7
, c, L)
Introduction to Formal Languages, Automata and Computability p.33/57
contd.
one c is printed
(q
7
, c) = (q
7
, c, L)
(q
7
, #) = (q
8
, #, L)
moves left
(q
8
, Y ) = (q
8
, b, L)
Y s are changed back to bs
(q
8
, #) = (q
0
, #, R)
process starts repeating
(q
3
, #) = (q
9
, #, R)
all as have been changed. Now the number of cs
represents the quotient. Y s represented the remainder
(q
9
, Y ) = (q
9
, Y, R)
(q
9
, b) = (q
9
, b, R)
Introduction to Formal Languages, Automata and Computability p.34/57
contd.
(q
9
, #) = (q
10
, #, R)
(q
10
, c) = (q
10
, c, R)
moves right
(q
10
, b) = (q
11
, #, L)
# is printed after the cs
(q
11
, c) = (q
11
, c, L)
(q
11
, #) = (q
12
, #, L)
(q
12
, b) = (q
12
, b, L)
(q
12
, Y ) = (q
13
, b, R)
(q
13
, b) = (q
13
, b, R)
(q
13
, #) = (q
14
, #, R)
(q
14
, c) = (q
14
, c, R)
(q
14
, #) = (q
15
, #, R)
Introduction to Formal Languages, Automata and Computability p.35/57
contd.
(q
15
, d) = (q
15
, d, R)
(q
15
, b) = (q
16
, d, L)
(q
16
, d) = (q
16
, d, L)
(q
16
, #) = (q
11
, #, L)
Y s are copied as ds
(q
12
, #) = (q
17
, #, R)
after all Y s have been copied as ds the process starts
nishing
(q
17
, b) = (q
17
, b, R)
(q
17
, #) = (q
18
, #, R)
(q
18
, c) = (q
18
, c, R)
(q
18
, #) = (q
19
, #, R)
(q
19
, d) = (q
19
, d, R)
Introduction to Formal Languages, Automata and Computability p.36/57
contd.
(q
19
, b) = (q
20
, b, L)
(q
20
, d) = (q
21
, #, halt)
The move of a TM can be represented as a state
diagram
X / Y, R
p q
means the TM when in state p and reading X, prints a
Y over X, goes to state q and moves right.
The state diagram for previous example can be repre-
sented as
Introduction to Formal Languages, Automata and Computability p.37/57
contd.
q
0
q
a
q
b
q
1
q
2
q
3
q
4
q
5
a/X,R
b/Y,R
a/a,R
b/b,R
#/#,R
b/a,L
a/a,L
b/b,L
#/#,L
b/b,R
a/a,R
#/#,R
a/a,R
b/b,R
#/#,R
b/b,L
a/a,L
b/b,L
#/#,L
X/a,L
Y/b,L
#,#
X/X,R
Y/Y,R
b/#
Introduction to Formal Languages, Automata and Computability p.38/57
Techniques for Turing Machine Con-
struction
Designing a Turing machine to solve a problem is an interesting
task. It is somewhat similar to programming. Given a problem,
different Turing machines can be constructed to solve it. But we
would like to have a Turing machine which does it in a simple
and efcient manner. Like we learn some techniques of program-
ming to deal with alternatives, loops etc, it is helpful to understand
some techniques in Turing machine construction, which will help
in designing simple and efcient Turing machines. It should be
noted that we are using the word efcient in an intuitive manner
here.
Introduction to Formal Languages, Automata and Computability p.39/57
contd.
1. Considering the state as a tuple.
In an earlier example we considered a Turing machine which
makes a copy of a given string over = {a, b}. After reading a
a, the machine remembers it by going to q
a
and after reading a
b, it goes to q
b
. In general we can represent the state as [q, x]
where x denoting that it has read a x.
2. Considering the tape symbol as a tuple.
Sometimes we may want to mark some symbols without destroy-
ing them or do some computation without destroying the input. In
such cases it is advisable to have multiple tracks on the tape. This
is equivalent to considering the tape symbol as a tuple.
Introduction to Formal Languages, Automata and Computability p.40/57
contd.
. . . A . . .
. . . B . . .
. . . C . . .

There is only one tape head. In the above gure there are three
tracks. The head is pointing to a cell which contains A on the
rst track, B on the second track and C on the third track. The
tape symbol is taken a 3-tuple [A, B, C]. Some computation can
be done in one track by manipulating the respective component of
the tape symbol. This is very useful in checking off symbols.
Introduction to Formal Languages, Automata and Computability p.41/57
contd.
3. Checking off symbols.
We use one track of the tape to mark that some symbols have
been read without changing them.
Example
Consider a Turing machine for accepting
w#w#w, w {a, b}

A tape having two tracks is considered.


. . . a b b # a b b # a b b . . .
. . . . . .
Introduction to Formal Languages, Automata and Computability p.42/57
contd.
The rst track contains the input. When the TM reads the rst a
in state q
0
, it stores it in its memory (by taking the state as a pair),
checks off a by printing a

in the second track below a, moves


right and after the # symbol checks whether the symbol is a a.
If so marks it by putting a

in the second track, moves right and
again checks the rst symbol after # is a a and if so it marks also.
It then moves left and repeats the process with each unmarked
leftmost symbols in each block. When all the symbols in the rst
block match with the second and third blocks, the machine halts
accepting the string.
Introduction to Formal Languages, Automata and Computability p.43/57
contd.
The mappings can be dened as follows:
(q
0
, [a, b]) = ([q, a], [a,

], R)
(q
0
, [b, b]) = ([q, b], [b,

], R)
The machine reads the leftmost symbol marks it and
remembers whether it is a a or b by storing it in the
state ([q, a], [a, b]) = ([q, a], [a, b], R)
([q, a], [b, b]) = ([q, a], [b, b], R)
([q, b], [a, b]) = ([q, b], [a, b], R)
([q, b], [b, b]) = ([q, b], [b, b], R)
The head passes through symbols in the rst block to
the right
([q, a], [#, b]) = ([p, a], [#, b], R)
([q, b], [#, b]) = ([p, b], [#, b], R)
Introduction to Formal Languages, Automata and Computability p.44/57
contd.
When the head encounters a # in the rst track, the
rst component of the state is changed to p.
([p, a], [a,

]) = ([p, a], [a,

], R)
([p, a], [b,

]) = ([p, a], [b,

], R)
([p, b], [a,

]) = ([p, b], [a,

], R)
([p, b], [b,

]) = ([p, b], [b,

], R)
([p, a], [a, b]) = ([r, a], [a,

], R)
([p, b], [b, b]) = ([r, b], [b,

], R)
Introduction to Formal Languages, Automata and Computability p.45/57
contd.
When it encounters a rst unchecked symbol it marks
it by putting a

in the second track and changes the


rst component of the state to r.
([r, a], [a, b]) = ([r, a], [a, b], R)
([r, b], [a, b]) = ([r, b], [a, b], R)
([r, a], [b, b]) = ([r, a], [b, b], R)
([r, b], [b, b]) = ([r, b], [b, b], R)
The head moves through the second block without
changing symbols, when the rst component of the
state is r
Introduction to Formal Languages, Automata and Computability p.46/57
contd.
([r, a], [#, b]) = ([s, a], [#, b], R)
([r, b], [#, b]) = ([s, b], [#, b], R)
When it encounters a # in the rst track it moves right
into the third block changing the rst component of
the state to s
([s, a], [a,

]) = ([s, a], [a,

], R)
([s, a], [b,

]) = ([s, a], [b,

], R)
([s, b], [a,

]) = ([s, b], [a,

], R)
([s, b], [b,

]) = ([s, b], [b,

], R)
It moves right looking for the unchecked symbol
([s, b], [b, b]) = (t, [b,

], L)
([s, a], [a, b]) = (t, [a,

], L)
When it encounters an unchecked symbol in the third
Introduction to Formal Languages, Automata and Computability p.47/57
contd.
it marks it by putting a

in the second track and


starts moving left.
(t, [a,

]) = (t, [a,

], L)
(t, [b,

]) = (t, [b,

], L)
(t, [#,

]) = (t

, [#,

], L)
It moves into the second block in state t

(t

, [a, b]) = (t

, [a, b], L)
(t

, [b, b]) = (t

, [b, b], L)
(t

, [a,

]) = (t

, [a,

], L)
(t

, [b,

]) = (t

, [b,

], L)
It moves left in the second block.
(t

, [#, b]) = (t

, [#, b], L)
It moves left into the rst block in state t

.
Introduction to Formal Languages, Automata and Computability p.48/57
contd.
(t

, [a, b]) = (t

, [a, b], L)
(t

, [b, b]) = (t

, [b, b], L)
It moves left in the rst block through unchecked
symbols.
When it encounters a checked symbol it moves right
in state q
0
and the whole process repeats
(t

, [a,

]) = (q
0
, [a,

], R)
(t

, [b,

]) = (q
0
, [b,

], R)
This way the machine checks for same symbols in the
rst, second and third blocks.
Finishing
When the machine encounters a # in the rst track in
state q
0
, it means it has checked all symbols in the rst
block. Now it has to check that there are no more
Introduction to Formal Languages, Automata and Computability p.49/57
contd.
symbols in the second and third block.
(q
0
, [#, b]) = (q
1
, [#, b], R)
(q
1
, [a,

]) = (q
1
, [a,

], R)
(q
1
, [b,

]) = (q
1
, [b,

], R)
If it encounters an unchecked symbol, it halts without accepting
(q
1
, [a, b]) = (q
n
, [a, b], R)
(q
1
, [b, b]) = (q
n
, [b, b], R)
If it nds all symbols are checked in the second block, it moves
to the third block in state q
2
(q
1
, [#, b]) = (q
2
, [#, b], R)
In the third block it checks whether all symbols have already been
checked. If so, it halts in accepting state q
y
.
Introduction to Formal Languages, Automata and Computability p.50/57
contd.
Otherwise halts in nonaccepting state q
n
(q
2
, [a,

]) = (q
2
, [a,

], R)
(q
2
, [b,

]) = (q
2
, [b,

], R)
(q
2
, [a, b]) = (q
n
, [a, b], R)
(q
2
, [b, b]) = (q
n
, [b, b], R)
(q
2
, [b, b]) = (q
y
, [b, b], R)
If the input has more symbols in the rst block (than
second block) it moves in the second block in state
[p, a] or [p, b] and encounters [#, b]. Then it halts
rejecting the input
([p, a], [#, b]) = (q
n
, [#, b], R)
([p, b], [#, b]) = (q
n
, [#, b], R)
If the input has equal symbols in the rst and second
Introduction to Formal Languages, Automata and Computability p.51/57
contd.
block but less symbols in the third block, the machine encounters
[b, b] an state [s, b] or [s, a] and halts without accepting
([s, a], [b, b]) = (q
n
, [b, b], R)
([s, b], [b, b]) = (q
n
, [b, b], R)
Thus we nd that having two tracks and using the second track to
check off symbols is a useful technique.
When we consider a single tape multitrack TM, we really take
the tape symbol as a tuple. This need not be considered as a
variation of Turing machine.
4. Shifting over.
Sometimes we may have to shift symbols on the tape to the right
or left to allow for some symbols to be written.
Introduction to Formal Languages, Automata and Computability p.52/57
contd.
Suppose the contents of the tape are a
1
. . . a
i1
Aa
i+1
. . . a
n
at
some instant. A has to be replaced by abcd say. Then a
i+1
. . . a
n
have to be shifted three cells to the right and then in the space
created abcd can be printed. We can use the state as a tuple to
store some information and shift symbols. Suppose the head is
reading a
i+1
in state q and the shifting process has to start.
Then the TM reads a
i+1
and goes to a state [q, , , a
i+1
] and
prints X over a
i
.
The ID
a
1
. . . a
i
1
A a
i+1
. . . a
n
b . . .

q
Introduction to Formal Languages, Automata and Computability p.53/57
contd.
changes to
a
1
. . . a
i
1
A X a
i+2
. . .

[q, , , a
i+1
]
Next, the TM reads a
i+2
, storing it in the fourth
component, and shifting a
i+1
from fourth component
to the third component
([q, , , a
i+1
], a
i+2
) = ([q, , a
i+1
, a
i+2
], X, R)
Similarly
([q, , a
i+1
, a
i+2
], a
i+3
) = ([q, a
i+1
, a
i+2
, a
i+3
], X, R)
When it reads a
i+4
, it deposits a
i+1
in that cell
Introduction to Formal Languages, Automata and Computability p.54/57
contd.
([q, a
i+1
, a
i+2
, a
i+3
], a
i+4
) =
([q, a
i+2
, a
i+3
, a
i+4
], a
i+4
, R)
In general
([q, a
j
, a
j+1
, a
j+2
], a
j+3
) =
([q, a
j+1
, a
j+2
, a
j+3
], a
j
, R) i + 1 j n
where a
n+1
, a
n+2
, a
n+3
are blank symbol b. Finally it
starts moving left
([q, a
n
, b, b], b) = (q

, a
n
, L)
In q

it moves left till it nds AXXX and replaces it


by abcd. A similar method can be used for shifting
symbols to the left. Thus storing some information in
some components of the state and cyclically moving
Introduction to Formal Languages, Automata and Computability p.55/57
contd.
the components helps in the technique of shifting off
symbols.
5. Subroutines.
Just as a computer program has a main procedure and
subroutines, the TM can also be programmed to have
a main TM and TMs which serve as subroutines.
Suppose we have to make n copies of a word w. Input
is #w# and the output is #w#www. . . w

n times
.
In this case we can write the mappings for a TM M
sub
which when started on #w#x ends up with #w#xw.
The main TM will call this M
sub
x times. Similarly for
multiplying two unary numbers m and n, n has to be
Introduction to Formal Languages, Automata and Computability p.56/57
contd.
copied on m times. We can write a sub TM for
copying and main TM will call this m times.
In order that a Turing machine M
1
uses another
Turing machine M
2
as a subroutine, the states of M
1
and M
2
have to be disjoint. Also when M
1
wants to
call M
2
, from a state of M
1
, the control goes to the
initial state of M
2
. When the subroutine nishes and
returns to M
1
, from the halting state of M
2
, the
machine goes to some state of M
1
. Note that a
subroutine TM call another TM as its subroutine. This
technique helps to construct a TM in a topdown
manner dividing the work into tasks and writing a TM
for each task and combining them.
Introduction to Formal Languages, Automata and Computability p.57/57

Вам также может понравиться