Design and test Turing machines to solve the following
problems. For each, submit the following four things:

  1. Your state transition diagrams. No need for pretty
     formatting, a scan by your phone is enough, but be
     sure it is readable.

  2. A brief description of the way it works (*).

  3. The .tm file that implements it.

  4. Some test runs.

(*) For item 2 I just want to be told what your plan is.
As an example, you might describe the TM for adding two
"base one" numbers that we produced like this: "scan
right until either a 1 or an = is found. If it what's
found is 1, overwrite it, scan right to the > and replace
that with 1 > then go back left to repeat the process.
If the = was found before any 1 stop, the addition is
complete".

Apart from start and stop, use different state names
in each of your solutions, that will make it easy to
join two TMs together, which is something you will want
to do.

Remember that Unix shells interpret many characters in a
special way. An input-string of <101*1100> will not work,
it will have to be \<101\*1100\> or '<101*1100>' or something
like that.

The exact details of the TM running program can be found
here: https://rabbit.eng.miami.edu/class/een511/tmhowto.txt

In my samples, the initial and final states are shown,
with a ^ below at the position of the read/write head.

A. Subtract one from a binary number. The number will
   not be zero, so ignore that case.

   sample: initial <100111011001000>
                   ^

             final <100111011000111>
                   ^

B. Reverse a binary number.

   sample: initial <100111011001000>
                   ^

             final <000100110111001>
                   ^

C. Multiply together two "base one" numbers, making sure
   that the input "question" appears in the output.

   sample: initial <1111x111111=>     (4 x 6)
                   ^
                                      (24)
             final <1111x111111=111111111111111111111111>
                               ^

D. Add two binary numbers together the easy but slow
   way: repeatedly decrement one and increment the other
   until the one is zero.

   sample: initial <101+1011>       (5 + 13)
                   ^

             final xxxx:10010>      (18)
                       ^

   In the final state, "xxx" means that I don't care what
   is there, I don't even care how many symbols are there.
   You can mess up whatever is to the left of the read/write
   head as much as you want.

E. Add two binary numbers together the good efficient way,
   digit by digit as you would normally do a binary addition.

   sample: initial <101+1011>
                   ^

             final xxxx:10010>
                       ^

   "xxx" means the same as in part D.