====== Lab 02 - Introduction to Turing Machines =======

**Key concepts**
  - How is a Turing Machine (TM) defined?
  - What is a **configuration**?
  - How is the execution of a TM defined?

==== 1. Intro ====
A **Turing Machine** consists of:
    * an **alphabet** $math[\Sigma]
    * a set of **states** $math[K]
    * an **initial** state $math[q_0]
    * a **transition function** $math[\delta : K \times \Sigma \rightarrow K \times \Sigma \times \{L,H,R\}]
    * a set of **final** states $math[F \subseteq K]

Which of the following components of an **assembly language** would best correspond to the above? $math[K,\Sigma, \delta, q_0, F]
  * the processor
  * the memory
  * registers
  * assembly instructions

==== 1. A few basic Turing Machines ====

**1.1** What does the following TM do? 

$math[M=(K,\Sigma,q_0,\delta,F)] where $math[K=\{q_0,q_1,q_2\}], $math[F=\{q_2\}], $math[\Sigma=\{0,1,\#\}] and $math[\delta] is defined as below:

^              ^ 0                ^ 1                ^ #                 ^
| $math[q_0]   | $math[(q_0,1,R)] | $math[(q_0,0,R)] | $math[(q_1,0,L)]  |
| $math[q_1]   | $math[(q_1,0,L)] | $math[(q_1,1,L)] | $math[(q_2,\#,R)]  |


**1.2** Write a TM which **enters the final state** only if the **input** is a binary encoding of an **even** natural number.

**1.3** Write a TM which verifies if a given word over alphabet $math[{A,B}] contains the sequence ''ABA''.

**1.4** Write a TM which adds **5** to a number encoded in binary on the tape. 

**1.5** Write a TM which checks if a binary number ''x'' is strictly larger than ''y''. Hint: use a separator symbol between words.

==== 2. Algorithms and Turing Machines ====

How would the following algorithm be represented as a Turing Machine:
<code>
Algorithm(vector V, integer M) {
   integer s = 0
   for-each x in V
      s += x
   if (s > M)
   then  return 1
   else  return 0
}
</code>
Helpful questions:
  * how should the tape be organised?
  * when should the machine accept?
  * how would ''foreach x in V'' be implemented?
  * how would ''s += x'' be implemented?
  * how would ''if (s > M) then ... else ...'' be implemented ?

/*

**Answer:**
  * The input of the tape should contain each element of the vector ''v'', encoded in binary, separated by a special character (e.g. ''@''). The last number in the sequence will be separated by another character (e.g. ''!'') from the value ''M''.
  * The machine should accept if the algorithm returns 1, that is, if the sum of elements of the array is greater than ''M''
  * Before executing the foreach, the TM should //allocate// part of its tape for the sum ''s'' which is initially 0. The LHS of the tape could be used.
  * The foreach can be easily implemented by moving the cursor between ''@'' characters.
  * For a particular ''x'', we can implement binary adding between ''x'' and the current ''s'':
    * M should go back-and-forth between the location of ''s'' and that of the current ''x''.
    * As each bit of ''x'' is processed, it should be erased (writing ''#'') so that we can easily skip to the current ''x''.
  * After ''!'' is read on the tape, we know we have finished the ''foreach''. We can then implement a bit-wise comparison of the values ''s'' and ''M'', which would now be the current value of the tape. The machine accepts if ''s > M''.

*/
==== More practice exercises ====
  * Write a TM which verifies if a string has the **same number** of ones and zeroes. Give hints - live (what should the machine do?)
  * write a TM which **accepts** a given regular expression
  * write a TM which **reverses** a given binary string (always accepts)