# Turing Machine

A Turing Machine is an accepting device which accepts the languages (recursively enumerable set) generated by type 0 grammars. It was invented in 1936 by Alan Turing.

Contents

Contents

## Definition

A Turing Machine (TM) is a mathematical model which consists of an infinite length tape divided into cells on which input is given. It consists of a head which reads the input tape. A state register stores the state of the Turing machine. After reading an input symbol, it is replaced with another symbol, its internal state is changed, and it moves from one cell to the right or left. If the TM reaches the final state, the input string is accepted, otherwise rejected.

A TM can be formally described as a 7-tuple (Q, X, ∑, δ, q_{0}, B, F) where −

**Q**is a finite set of states**X**is the tape alphabet**∑**is the input alphabet**δ**is a transition function; δ : Q × X → Q × X × {Left_shift, Right_shift}.**q**is the initial state_{0}**B**is the blank symbol**F**is the set of final states

### Comparison with the previous automation

The following table shows a comparison of how a Turing machine differs from Finite Automaton and Pushdown Automaton.

Machine | Stack Data Structure | Deterministic? |
---|---|---|

Finite Automaton | N.A | Yes |

Pushdown Automaton | Last In First Out(LIFO) | No |

Turing Machine | Infinite tape | Yes |

### Example of Turing machine

Turing machine M = (Q, X, ∑, δ, q_{0}, B, F) with

- Q = {q
_{0}, q_{1}, q_{2}, q_{f}} - X = {a, b}
- ∑ = {1}
- q
_{0}= {q_{0}} - B = blank symbol
- F = {q
_{f}} - δ is given by −

Tape alphabet symbol | Present State ‘q_{0}’ |
Present State ‘q_{1}’ |
Present State ‘q_{2}’ |
---|---|---|---|

a | 1Rq_{1} |
1Lq_{0} |
1Lq_{f} |

b | 1Lq_{2} |
1Rq_{1} |
1Rq_{f} |

Here the transition 1Rq_{1} implies that the write symbol is 1, the tape moves right, and the next state is q_{1}. Similarly, the transition 1Lq_{2} implies that the write symbol is 1, the tape moves left, and the next state is q_{2}.

## Time and Space Complexity of a Turing Machine

For a Turing machine, the time complexity refers to the measure of the number of times the tape moves when the machine is initialized for some input symbols and the space complexity is the number of cells of the tape written.

Time complexity all reasonable functions −

**T(n) = O(n log n)**

TM’s space complexity −

**S(n) = O(n)**

A TM accepts a language if it enters into a final state for any input string w. A language is recursively enumerable (generated by Type-0 grammar) if it is accepted by a Turing machine.

A TM decides a language if it accepts it and enters into a rejecting state for any input not in the language. A language is recursive if it is decided by a Turing machine.

There may be some cases where a TM does not stop. Such TM accepts the language, but it does not decide it.

### Designing a Turing Machine

The basic guidelines of designing a Turing machine have been explained below with the help of a couple of examples.

**Example 1**live streaming film Life 2017

Design a TM to recognize all strings consisting of an odd number of **α’s**.

*Solution*

The Turing machine **M** can be constructed by the following moves −

- Let
**q**be the initial state._{1} - If
**M**is in**q**; on scanning_{1}**α**, it enters the state**q**and writes_{2}**B**(blank). - If
**M**is in**q**; on scanning_{2}**α**, it enters the state**q**and writes_{1}**B**(blank). - From the above moves, we can see that
**M**enters the state**q**if it scans an even number of_{1}**α’s**, and it enters the state**q**if it scans an odd number of_{2}**α’s**. Hence**q**is the only accepting state._{2}

Hence,

M = {{q_{1}, q_{2}}, {1}, {1, B}, δ, q_{1}, B, {q_{2}}}

where δ is given by −

Tape alphabet symbol | Present State ‘q_{1}’ |
Present State ‘q_{2}’ |
---|---|---|

a | BRq_{2} |
BRq_{1} |

**Example 2**

Design a Turing Machine that reads a string representing a binary number and erases all leading 0’s in the string. However, if the string comprises of only 0’s, it keeps one 0.

*Solution*

Let us assume that the input string is terminated by a blank symbol, B, at each end of the string.

The Turing Machine, M, can be constructed by the following moves −

- Let
**q**be the initial state._{0} - If
**M**is in**q**, on reading 0, it moves right, enters the state_{0}**q**and erases 0. On reading 1, it enters the state_{1}**q**and moves right._{2} - If
**M**is in**q**, on reading 0, it moves right and erases 0, i.e., it replaces 0’s by B’s. On reaching the leftmost 1, it enters_{1}**q**and moves right. If it reaches B, i.e., the string comprises of only 0’s, it moves left and enters the state_{2}**q**._{3} - If
**M**is in**q**, on reading either 0 or 1, it moves right. On reaching B, it moves left and enters the state_{2}**q**. This validates that the string comprises only of 0’s and 1’s._{4} - If
**M**is in**q**, it replaces B by 0, moves left and reaches the final state_{3}**q**._{f} - If
**M**is in**q**, on reading either 0 or 1, it moves left. On reaching the beginning of the string, i.e., when it reads B, it reaches the final state_{4}**q**._{f}

Hence,

M = {{q_{0}, q_{1}, q_{2}, q_{3}, q_{4}, q_{f}}, {0,1, B}, {1, B}, δ, q_{0}, B, {q_{f}}}

where δ is given by −

Tape alphabet symbol | Present State ‘q_{0}’ |
Present State ‘q_{1}’ |
Present State ‘q_{2}’ |
Present State ‘q_{3}’ |
Present State ‘q_{4}’ |
---|---|---|---|---|---|

0 | BRq_{1} |
BRq_{1} |
ORq_{2} |
– | OLq_{4} |

1 | 1Rq_{2} |
1Rq_{2} |
1Rq_{2} |
– | 1Lq_{4} |

B | BRq_{1} |
BLq_{3} |
BLq_{4} |
OLq_{f} |
BRq_{f} |