(00:01)

Hello, everyone.

(00:02)
Welcome to the next lecture.

(00:04)
In the course and Theory of Atom Meta.

(00:08)
In the previous lecture we studied
the formal definition of a Turing machine,

(00:14)
and in this lecture we will see two
examples of Turing machine,

(00:18)
and we will see how we design a Turing
machine for a given language.

(00:22)
All right.
So let's get started.

(00:26)
Here we have an example for designing

(00:28)
of a Turing machine which recognizes the
language L equal to zero, one star zero.

(00:35)
So what this language mean?

(00:37)
This language mean?

(00:39)
It should have one0 followed by any number
of ones followed by one0 at the end.

(00:46)
So if you look, it is a regular language,

(00:49)
and we can easily design a finite
state machine for this language.

(00:54)
But we design theorem machine for this

(00:56)
language so that we can understand the
machine from the very simplest example.

(01:02)
So here I have designed the Turing
machine for the language.

(01:06)
So here we have the starting
state, which is a.

(01:10)
Then we have two States B and C,

(01:13)
and then we have two final States, which
are the reject and the except state.

(01:18)
Let us see how it works.

(01:21)
So as we want to accept
zero, one star zero.

(01:25)
So at the initial state,

(01:27)
when we get a zero,
we go to the next state B,

(01:31)
and in our tape we write symbol X,
and we move to the right on our tape.

(01:38)
So we are now instead B.

(01:41)
So now we know that we have to accept any

(01:45)
number of ones after we have
accepted the zero at the start.

(01:49)
So instead B, if you get any number
of ones, you always stay instead B.

(01:55)
And then on the tape we write Y
and we move right on the tape.

(02:01)
And after getting any number of ones,
finally, we need to get a zero.

(02:06)
So if we get a zero, we move to the next
state C, and we write X on tap.
(02:13)
And then we move right on the tap.

(02:18)
And after reaching this state C, we see
that there is nothing more to take.

(02:23)
So what we do, we read the blank
symbol that is the spacious symbol.

(02:28)
So when we read the blank symbol,
we do not write other symbol other than

(02:33)
the blank symbol, and we
move to the accept state.

(02:38)
So this is how it works.

(02:41)
Now let us take an example string

(02:43)
from this language, which is 0110 and let
us see how it works using the tape.

(02:51)
So we come to the tape and our head
is at the leftmost cell of our tape.

(03:02)
So when we get a zero,

(03:04)
we write X on our tap, and we go to step
B, and we move to the right under tab.

(03:13)
Now our next input is one.

(03:18)
So if we get a one,

(03:19)
we are instead B and we write a y
onto our tape, and we remain in step

(03:41)
B.
But we move to the right on our tape,

(03:45)
and then the next input we have is a zero.
(03:48)
So when we get zero at state B,
we move to the state C and we write X onto

(03:54)
our tape, and we move one
step to the right on the tab.

(04:00)
Now we see that we have reached
to the end of the string.

(04:04)
So after the zero at the end,
we consider it to be the blank symbol.

(04:11)
So we are at state C,
and we encounter a blank symbol.

(04:15)
So we write blank symbol on the tab,

(04:18)
and we move one step to the right
and we go to the accept state.

(04:25)
So the string 0110 is accepted.

(04:29)
And now this is the condition of our tape.

(04:34)
Now you may ask why we write
these X and y onto the tape.

(04:41)
So as this was a very simple example
language, and we actually do not need

(04:46)
the full power of Turing machine
in order to implement this.

(04:50)
But we have to do this because we are

(04:53)
using the Turing machine,
and particularly for this language,

(04:57)
these tape symbols have no such specific
meaning, but we just do it in order
(05:02)
to show how Turing machine works and how
Turing machine tape actually works.

(05:08)
Also, in the first lecture on Turing

(05:10)
machine, I told you that Turing
machines are deterministic.

(05:14)
So here in this transition diagram, you
see, we have transition for every input.

(05:21)
Now let us discuss another example

(05:25)
in which we design a Turing machine for
the language zero power n one power N.

(05:31)
So it means we have to design a Turing
machine for a language where number

(05:35)
of zeros should exactly be equal to the
number of ones that follow these zeros.

(05:43)
In the previous lecture,
when we were discussing finite state

(05:47)
machines, we saw that we could not
implement this language using finite state

(05:54)
machine because we need to keep count
of how many zeros are there in order

(06:00)
to repeat the exact same number of ones
so that we can implement this language.

(06:05)
But we saw that finite state machine due
to their limited memory and due to their

(06:10)
limited capability,
it was not possible to design a finite

(06:14)
state machine, and therefore we declared
that this was not a regular language.
(06:21)
So we shall see using a Turing machine,
how can we design this language?

(06:25)
So first of all, I will explain to you
the algorithm of how this can be done.

(06:33)
We first will design an algorithm

(06:35)
which will accomplish this task
of accepting this kind of strings.

(06:40)
And then from that algorithm,

(06:42)
we will see how we design
the equivalent Turing machine for it.

(06:47)
All right.
So here you see, we have the tape sequence

(06:51)
in our Turing machine,
and then we have the algorithm.

(06:56)
So the first step in algorithm says
change zero to X.

(07:03)
So we replace the first zero in our tape

(07:05)
to X, and then we move right
until we find the first one.

(07:10)
So if you cannot find the one,

(07:12)
then you have to reject means
that the string will not be accepted.

(07:18)
And if you are able to find a one,
then you have to change it to Y.

(07:24)
And after you do that,
you have to move left until you find
(07:28)
the leftmost zero, and this process will
be repeated until no more zeros are there.

(07:34)
And also you have to make sure
that no more ones remain as well.

(07:40)
Now let us apply this algorithm
on our tap in the Turing machine.

(07:45)
You notice in the tape that we have four
number of zeros and four number of ones.

(07:50)
So the number of zeros are same
to the number of ones that follow.

(07:57)
So

(07:59)
this string should be accepted.

(08:03)
So first of all, our tape head is
about the leftmost zero in our tab.

(08:12)
So as in our algorithm,

(08:14)
the first step we perform is
to change this X this zero to X.

(08:20)
Then we move right on the tape

(08:24)
until we find the first one.

(08:27)
So here I have found the first one.

(08:31)
So according to the algorithm,
we change it to a Y,

(08:36)
and then what we have to do, we have
to move left to the leftmost zero.

(08:44)
So I move step by step to the leftmost
zero, and I find that my left most zero is
(08:51)
here, so we change it to X
according to the algorithm.

(08:57)
So after replacing the lift most zero

(08:59)
with X, I again move to the right
until I find my first one.

(09:06)
I change it to Y.

(09:09)
Then I start moving left until I find the
leftmost zero, and I change it to an X.

(09:17)
Then again, I repeat these steps

(09:22)
and I start moving to the right
and I find my first one.

(09:29)
So I changed it to Y,

(09:31)
then start moving left, and finally I see
my left most and also the final zero.

(09:38)
I change it to X, and then I move right
and I find the first and the last one.

(09:48)
So I change it to Y.

(09:53)
Now, if we look, there are no more
zeros and also there are no more ones.

(09:59)
So our tape.