Outline

• Multi-tape Turing Machines
• Quiz
• RAMs

`k`-tape Turing Machines

One way you might try to improve the power of a TM is to allow multiple tapes.

Definition. A `k`-tape TM, where `k ge 1` is an integer, is a six-tuple `M=(Q, Sigma, Gamma, delta, q_0, F)` where `Q, Sigma, Gamma, q_0` are as in the 1-tape case. Now, however, the transition functions is a map `delta:Q times Gamma^k -> Q times Gamma^k times {L,R}^k`

• The transition allows the heads on each tape to move independently of each other.
• At the start of the computation the first tape has the input written on it and all the other tapes are blank.
• With a two tape machine, an algorithm for palindrome testing is easy:
  • We set up the transition function so it first copies the first tape input to the second tape.
  • Then it rewinds the first tape and leaves the second tape at the end of the input.
  • Then the first tape moves right while the second tape moves left and we compare the two tape symbol by symbol. If they don't match we halt and reject. If the second tape gets back to the `\square` then we accept.

TIME and SPACE classes.

• We shall use the k-tape model of TM as our basic model to study time and space complexity.
• When we are interested in sub-linear space classes, we will often assume the first tape is offline (read-only) and consider the squares used on the remaining tapes.
• Let `f:NN -> NN`. We say that machine `M` operates within time `f(n)` if for any input string `x`, the time require by `M` on input `x` is at most `f(|x|)`. Here `|x|` is the length of `x` as a string. We can make a similar definition for space.

Definition. We say that a language `L` is in `\mbox{TIME}(f(n))` (resp. `\mbox{SPACE}(f(n))`) if it is decided by some `k`-tape TM in time `f(n)` (resp. space `f(n)`).

• For example, the algorithm for palindrome is in time `\mbox{TIME}(3(n+2))`.
• You can show using an information/Komolgorov-theoretic style argument that for a single tape machine you need at least time `Omega(n^2)` to test for palindromes.

Linear Speed-Up

• You might wonder why we didn't say a language is in time `\mbox{TIME}(f(n))` if it can be computed in `O(f(n))` steps rather than the more fragile seeming definition of `f(n)` steps.
• The reason is because of the following linear speed-up theorem from Hartmanis and Stearns. Trans AMS #117. May, 1965:
  Theorem. Let `L` be in `\mbox{TIME}(f(n))`. Then for any `epsilon > 0`, `L` is also in `\mbox(TIME(f '(n)))` where `f'(n) = epsilon f(n) + n + 2`.
  Proof. We give this proof for stay-put TMs started one square to the left of the input, as it is slightly easier in this context, but the proof idea also applies to usual TMs. Let `M=(K, Sigma, Gamma, delta, s, F)` be a `k`-tape machine that decides `L` in `\mbox{TIME}(f(n))`. Let `k'` be `2` if `k=1` and be `k` otherwise. We will get the speedup by making a simulating `k'` tape machine `M'=(K', Sigma', Gamma', delta', s', F')` that encodes several of moves of `M` by one move of `M'`. To be specific let `Gamma = Gamma cup Gamma^m` -- we'll fix `m` in a moment. To begin `M'` scans the input `x = x_1 ldots x_n` writing for each `m` adjacent symbols a single symbol in `Gamma'` . At the end of this `m cdot |~ |x|/m ~| + 2` step process the second tape has `n/m` squares with symbols. We then delete the first tape and use the second tape as the input from now on. The machine `M'` then simulates `m` steps of `M` using `6` or fewer steps. At the beginning of a simulating stage the state of `M'` consists of a `k+1` tuple `(q, j_1, ldots, j_k)` where `q` is `M's` state at the start of the stage, and the `j_i`'s represent where within the current `m`-block on each tape `M`'s head would be. For each tape `M'` then scans one square left, two right, one left. It remembers in its controls the symbols it saw to the left and right. Using this information `M'` can now completely predict where `M` would go in its next `m` moves. It then updates the at most two tape square it needs to update and starts simulating the next `m` steps. If `M` accepts or reject, so does `M'`. Simulating `f(n)` steps takes time `|x|+2 +6 \cdot |~ f(|x|)/m ~|` steps. So for `m = |~ 6/epsilon ~|` the theorem holds.
• We now turn to the question of how well a `1`-tape machine simulate a `k`-tape machine?

Simulating `k`-tapes with `1`-tape

Theorem. Given any `k`-tape machine `M` that operates within time `f(n)` deciding `L`, we can construct a `1`-tape machine `M'`operating within time `O((f(n))^2)` deciding `L`.

Proof. Let `M=(Q, Sigma, Gamma, delta, q_0, F)` be a `k`-tape machine.

• The idea is `M`'s tape alphabet, `Gamma`, is going to be expanded to include symbol `#` to denote the last used square of a tape. We are also going to add to the new tape alphabet, `Gamma'`, a symbol `\ul{b}` for each symbol `b` in `Gamma`.
• A configuration of `M` can now be written as: `(q, #w_1\ul{a_1}v_1#w_2\ul{a_2}v_2#ldots#w_k\ul{a_k}v_k#)`
  Here the underscored character indicates the position of the tape head for the given tape.
• So except for the state, which we can keep track of in `Q'`, the rest of the configuration is a string over `Gamma'`.
• We will use new states in `Q'` to keep track of the state of `M` during a simulation step.
• To simulate `M`, we first convert the input into the initial configuration of `M` viewed as a string.
• Then to simulate a step we scan left to right the current configuration string, noting what symbol is being read by each tape in our finite control.
• Next we rewind the tape and we then do passes again to update each tapes configuration.
• In the worst case we need to expand the number of tape squares of each tape by `1`. So we could need `(k(f(|x|)+1)+1` passes to simulate `1` step of the `k`-tape machine.
• So simulating `f(|x|)` steps take at most `f(|x|)((k(f(|x|)+1)+1)` times which is `O((f(n))^2)`.

Quiz

Which of the following is true?

1. Turing-recognizable and decidable are synonyms.
2. A stay-put Turing Machine cannot in general be simulated by a Turing Machine.
3. In an offline Turing Machine, at the start of a computation, the input is written on a read only tape.

Random Access Machines (RAMs)

• We next look at a computation model which is closer to a modern day computer.
• A Random Access Machine (RAM) consists of a program which acts on an arrays of registers. You can think of an array element as corresponding to a memory location in a computer.
• RAMs were first defined in Shepherdson and Sturgis, JACM. Vol. 10. Iss. 2. pp. 217--255. 1963.
• Unlike a usual computer, which might be able to store 32 or 64 bits in a memory word, each register is capable of storing an arbitrarily large integers (either positive or negative).
• Register 0 is called the accumulator. It is where any computations will be done.
• A RAM program consists of a finite sequence of instructions `P=(p_1, p_2, ldots, p_n)`.
• The machine has a program counter which says what instruction is to be executed next.
• This initially starts at the first instruction. An input `w=w_1, ldots ,w_n` is initially placed symbol-wise into registers `1` through `n`. (We assume some encoding of the alphabet into the integers). All other registers are `0`.
• A step of the machine consists of looking at the instruction pointed to by the program counter, executing that instruction, then adding 1 to the program counter if the instruction does not modify the program counter and is not the halt instruction.
• Upon halting, the output of the computation is the contents of the accumulator. For languages, we say w is in the language of the RAM, if the accumulator is positive, and is not in the language otherwise.

The RAM Instruction Set

The allowable RAM instructions are listed below:

1. Read j /* read into register j into accumulator */
2. Read (j) /* look up value v of register j then read register v into the accumulator*/
3. Store j /* store accumulator's value into register j */
4. Store (j) /* look up value v of register j then store acumulators values into register v*/
5. Load x /* set the accumulator's value to x */
6. Add j /* add the value of register j to the accumulator's value */
7. Sub j /* subtract the value of register j from the accumulator's value */
8. Half /* divide accumulator's value by 2 round down (aka shift left)*/
9. Jump j /* set the program counter to be the jth instruction */
10. JPos j /* if the accumulator is positive, then set the program counter to be j */
11. JZero j /* if the accumulator is zero, then set the program counter to be j */
12. JNeg j /* if the accumulator is negative, then set the program counter to be j */
13. HALT /* stop execution */

Example Program for Multiplication

Suppose we input into Register 1 and 2 two number `i_1` and `i_2` and we would like to multiply these two numbers. The following program could do this:

1. Read 1 //(Register 1 contains `i_1` ; during the `k`th iteration
2. Store 5 // Register 5 contains `i_1 cdot 2^k`. At the start `k=0`)
3. Read 2
4. Store 2 //(Register 2 contains `lfloor i_2/2^k rfloor` just before we increment `k` )
5. Half //(now accumulator is `lfloor i_2/2^{k+1} rfloor`, we've chopped off the low order bit of `i_2`. The `k`th iteration begins)
6. Store 3 // (Register 3 contains half Register 2, `lfloor i_2/2^{k+1} rfloor` )
7. Add 3 //(so now accumulator is twice Register 3, `2 cdot lfloor i_2/2^{k+1} rfloor`)
8. Sub 2 //(accumulator will be `0` if low order bit of what was stored in register 2 is `0`)
9. JZero 13
10. Read 4 //( so this and the next instruction add Register 5 to Register 4 only if the `k`th least significant bit of `i_2` is nonzero)
11. Add 5
12. Store 4 //(Register 4 contains `i_1 cdot (i_2 mod 2^k))`
13. Read 5
14. Add 5
15. Store 5 // Register 5 contains `i_1 cdot 2^{k+1}`, so can start next round
16. Read 3
17. JZero 19
18. Jump 4 //(if not, we repeat)
19. Read 4 //(the result)
20. Halt