(Editor)

Note that we don’t need transitions out of the accept state, because the TM halts as soon as we reach an accept state.

Try running this on

• 010
• 01010
• 011001

(Editor)

Notice the difference in how the accepting state is handled. In a FA, we halt if we reach the end of input and are in a final state. But TMs don’t have the idea of “end of input” – a TM can make any number of passes over its input. A TM halts when it enters a final state regardless of how many symbols it has processed.

In this case, therefore, when we spot a 101, we look to see if we are at the end of the string (input $\epsilon$) and, if so, halt.

Try running this on

• 101
• 1010
• 1010101

(Editor)

But there’s a simpler, arguably more “Turing-machine-style” way to do this. In this TM, state 0 simply moves the head to the end of the string, then states 1…4 move right-to-left to check if the end of the string is “101”.

Try running this on

• 101
• 1010
• 1010101

(Editor)

The TM does not use a stack, but we achieve much the same by “matching” symbols. We will remove pairs of ’0’s and ’1’s until we have no ’0’s left, then make sure that all of the ’1’s are also gone.

• Starting from state 0, we erase the leftmost ‘0’.
• In state 1, we then skip over any remaining ’0’s, expecting to hit a ‘1’.
• When we see a ‘1’, we replace it with an ‘x’.
• In state 2 we then run back to the left end of the string and return to state 0 so we can repeat the whole process.
• If, in state 0, we are looking at an ‘x’, we make one last pass over the string to make sure we have no ’1’s remaining.

Try running this on

• 0011
• 00011
• 00111

All strings over {0, 1} in which the number “01” pairs is odd.

This is actually a regular language. (The RE would be $1*00*11*(00*11*00*11*)*0*$.) You might have noticed that it processes the input on the tape in a strict left-to-right progression. The only use of the tape is to mark off 01 pairs with a ‘x’ for an odd occurrence and a ‘y’ for even occurrences. And that is purely decorative, because the TM never goes back to look at any of the changed markings.
In effect, all of the work is done in the TM’s controller, and that controller is a DFA.

If computes the “lower-case equivalent” of a string over {a, b, A, B}.

• Try running this on the input “aAbBa”.

It shifts all of the characters on the right of its starting position one step to the left, overwriting whatever character the head was originally positioned over.

The interesting thing here is the kind of two-step shuffle carried out in the transitions $q_0 \rightarrow q_1 \rightarrow q_4$, which sees and erases an ‘a’, steps to the left and writes an ‘a’, then steps back to the right into the newly erased position. The transitions $q_0 \rightarrow q_b \rightarrow q_4$, but for ‘b’ instead of ‘a’.

Now, of course, on an infinite tape of empty cells, shifting your entire input one one position to the left has no real effect. But we could use this as a building block or design pattern as part of a larger TM function.

We could design a TM that scans until it reaches the first ‘a’, then apply that “shift-left” pattern to move the remainder of the string one step to the left, overwriting and, in effect, deleting the ‘a’.

Try this TM on the input “bbaabab” to see this in action.

There are two changes here compared to our “shift-left” TM:

• The new starting state $q_5$, which scans right until we find an ‘a’, then moves into our “shift-left” TM pattern.
• The cells to the left of the starting position for the shift-left are not likely to be empty. So, in the transitions $q_1 \rightarrow q_4$ and $q_2 \rightarrow q_4$, instead of matching the input $\epsilon$, I’ve used a shortcut provided by Automat: ‘~’ denoting “any character”.

Here is the simplified TM. Try running it on the input “bbaabab” to see this in action.

• In the transition $q_0 \rightarrow q_1$, we save the input character into the variable w.
• In the transition $q_1 \rightarrow q_w$, we write the saved character onto the tape.

This is a palindrome generator. Given an input string over {a,b,c}, it copies the reverse of that string onto its own end.

For example, to process abc, it

1. Moves to the right end of the string.
2. Changes the final ‘c’ to ‘C’: abC
3. Moves to the right until it hits an empty cell and writes a ‘C’ there: abCC.
4. Moves to the left until it hits a lower-case letter (‘b’) and changes that to ‘B’: aBCC
5. Moves to the right until it hits an empty cell and writes a ‘B’ there: aBCCB.
6. Moves to the left until it hits a lower-case letter (‘a’) and changes that to ‘A’: ABCC
7. Moves to the right until it hits an empty cell and writes a ‘B’ there: ABCCBA.
8. Moves to the left looking for a lower-case letter, but hits the left end of the string instead.
9. Enters state 5, which scans down the string reducing each upper case character to its lower-case equivalent: abccba

 

This is a language that is not CF and cannot be accepted by a PDA. But we can recognize this language with a fairly minor change to our TM for $0^n1^n. That TM worked like this:

1. Starting from state 0, we erase the leftmost ‘0’.
2. In state 1, we then skip over any remaining ’0’s, expecting to hit a ‘1’.
3. When we see a ‘1’, we replace it with an ‘x’.
4. In state 2 we then run back to the left end of the string and return to state 0 so we can repeat the whole process.
5. If, in state 0, we are looking at an ‘x’, we make one last pass over the string to make sure we have no ’1’s remaining.

This TM inserts one additional state, $q_5$, that does for inputs of ‘2’ what state $q_2$ does for inputs of ‘1’. In essence, we implement a new algorithm:

1. Starting from state 0, we erase the leftmost ‘0’.
2. In state 1, we then skip over any remaining ’0’s, expecting to hit a ‘1’.
3. When we see a ‘1’, we replace it with an ‘x’.
4. In state 2 we continue moving to the right, skipping over any 1’s we encounter.
5. When we encounter a ‘2’, we replace it with an ‘x’, then run to the left end of the string and return to state 0 so we can repeat the whole process.
6. If, in state 0, we are looking at an ‘x’, we make one last pass over the string to make sure we have no ’1’s or ’2’s remaining.

Try executing this on inputs:

• 001122
• 00122
• 0011222
• 012012

(video)

We can actually simplify that algorithm slightly by merging the handling of the ‘a’ and ‘b’ inputs.

1. Look at the first character in the first string (the leftmost character).
   • If it is an ‘a’, erase it and move forward to the marker (‘c’).
   • If it is a ‘b’, erase it and move forward to the marker (‘c’).
   • If it is the marker character ‘c’, then there are no characters remaining in the 1st string.
     • Make a scan to be sure that there are no ’a’s or ’b’s remaining in the second string. If there are none, accept – the strings were identical.
2. Move past any “already processed” characters ‘x’.
3. Look at the character after the ‘c’ and any ’x’s.
   • If it is an ‘a’ and the character from step 1 was an ‘a’, replace this ‘a’ by ‘x’.
   • If it is a ‘b’ and the character from step 1 was a ‘b’, replace this ‘b’ by ‘x’.
   • If the current character does not match the character from step 1, the two inputs strings are different – fail.
4. Move back to the left of the string and repeat starting with step 1.

Then we can try to design a TM to carry out this approach.

Here is the TM.

Things of note:

• In the transition from $q_0$ to $q_1$, we recognize an ‘a’ or a ‘b’ and save it in the variable w.
• $q_1$ moves us forward to the inter-string marker ‘c’.
• $q_2$ moves us past any already-matched characters in the second string.
• In the transition from $q_2$ to $q_3$, we recognize a match in w to the character encountered in the transition from $q_0$ to $q_1$.
• $q_3$ moves us back to the start of the first string so that we can repeat the process.

This isn’t quite as simple as we might hope. Our convention is that all input needs to be supplied on the first tape, and so the input will still be presented in the form:

string1cstring2

The procedure in this case is:

1. Copy the first string onto the second tape.

   At the end of this procedure, the head of the first tape will be pointing at ‘c’, the head of the second tape just past the end of the copied first string.

2. Leave the 2nd tape head where it is, and move the first tape head to the right until we hit the end of the second string.

3. Now start moving to the left, comparing corresponding characters in the two strings. If they match we keep going. If they don’t match, we fail.

   If we reach the beginning of both strings with all matching, we accept.

 

Here is the TM for this new procedure.

Try executing this on:

• aabcaab
• abbcaab
• abbbcaab
• abbcabbb

Whether this is simpler or not than the single-tape approach may be, I suppose, open to debate. After all, trying to envision two tapes is unfamiliar and adds a bit of complication of its own. However, what cannot be denied is that the multi-tape version is faster. Because of the need to repeatedly traverse back and forthe across the entire input, the single-tape machine runs in $O(n^2)$ time (where $n$ is the length of the longer of the two strings). This multi-tape TM makes exactly two passes over the input, and so does the same thing in $O(n)$ time.

You may have expected to be more difficult than it really is.

 

To add 1 to a number written in unary format, we just add another ‘1’ to either end.

Try it out on:

• 1
• 11
• 111

 

All we need to do is to remove the ‘x’ separating the two numbers. Then shift the remaining characters left to fill in the gap.

Run this on

• 111x11
• 11x1
• x11
• 11x

This is the most complicated TM we have attempted so far, so let’s take it in stages.

First, let’s copy the 1st number onto the 2nd tape:

Let’s take this in stages:

 

Start by copying the 1st number to tape 2. Run this on 11c110 to confirm that it works.

Next, let’s shift the tape head on tape 1 to the end of the 2nd number, and then position both tape heads on the right-most digits.

Run this on 11c110, using single-stepping to watch the movement of the tape heads, to confirm that it works.

Now we are ready to start actually doing addition. If we see two zeros, we write a zero onto the answer in tape 1. If we see a one and a zero, we write a one onto the answer in tape 1. Either way, we then shift the tape heads left to the next higher pair of digits. Of course, that leaves the case of seeing a pair of ones. For that, we would write a ‘0’ and “carry the one”.

Run this on inputs

• 0c0
• 0c1
• 1c0
• 1c1

to see how the single digits are handled.

The idea of the “carry” reminds us that our prior rules (e.g., $1+0 \rightarrow 1$) only apply when there is no carry. So we will use state $q_2$ to add digits with no carry, and a different state, $q_3$, will enact the rules for addition when we have a carry.

Here we have added the “with carry” addition rules, including the case of adding $0+0$ with a carry, which gives us a sum of $1$ but returns us to the non-carry state $q_2$.

Run this on input 011c010.

Now it’s time to start thinking about how to end this.

• If we are in state 2 (no carry), and looking at two empty cells, then we have finished adding the numbers and can stop.
• If we are in state 3 (carry), and looking at two empty cells, then we would need to write the 1 from the carry onto the left of the answer.
• If we are in either of those states and see only one empty cell, that means that one of our two numbers has more digits than the other. We would treat those empty cells as if they contained a zero.

Run this on:

• 011c010
• 11c110
• 1111c1

and convince yourself that we really have implemented binary addition.