Recall last day we showed that there existed a TM `U` capable of taking the input `langle x, alpha rangle`
and simulating machine `M_alpha` on input `x` with at most a quadratic slowdown over the time `M_alpha` takes on the same input.
Today, we would like to improve this to a `O(T log T)` simulation.
As a first step to thinking about this simulation, we will assume our machines have a two-way infinite tape. This assumption only gives a linear slowdown over our starting model.
Next rather than view the actions right, left, and stay put as saying the tape head is moving, we view them as movements to the left, right, or stay put of the whole tape.
At the start of a simulation step, we assume the tape heads of our universal machine 'U' are always reading the current values of the corresponding tapes heads of the machine we are simulating, say 'M'.
`U` will use just one tape to represent the contents of the `k` tapes of `M`. You could imagine doing this by letting the squares `i mod k` as corresponding to the square `lfloor i/k rfloor` of tape `i mod k`.
`U` will use two additional tapes, one to keep track of `M`'s state, the other to store `M`'s transition function.
At a naive level, you could imagine simulating one step of `M` by reading the `k` squares to the right of where `U` starts to get the contents of the `k` tapes. Then we read the current state of `M` from the auxiliary tape, compute a new value for the state and square contents, then "shifting" each tape appropriately. Finally, putting the first tape head back to the currently being read block of squares
As shifting might take linear time this would give a `O(T^2)` simulation. Instead, we do shifting in an amortized way that will yield the `O(T log T)` runtime we want...
Amortized Shifting -- Zones
To make the shifting take logarithmic amortized time, we imagine each of `M`'s tapes being split into zones to the left and right of the tape center. Zone `R_0` contains two cells to the right of the center location of the tape head, similarly `L_0` contains two cells to the left of the tape head location. In general `R_i` and `L_i` represent `2^(i+1)` tape cells.
In time `T`, we'll never need to be concerned with more than zone `R_(log T)`, `L_(log T)` in what we propose.
In each zone we have a special kind of tape symbol besides blank, which we'll denote `bar square`. The intended semantics of this symbol is that we should ignore this square, it doesn't represent `square`, `0`, `1`.
In a simulation step, we will ensure the following invariants concerning our zones:
Each of the zones we care about during the simulation is either empty, full, or half full, with non-`bar square` symbols.
The total number of non-`bar square` symbols in `R_i cup L_i` is `2 cdot 2^i`. i.e., either one of these two zones is empty, or both are half full.
Location 0, always contains a symbol other than `bar square`.
Performing Shifts
To perform a left shift of a tape we do the following operations (a right shift would be similar):
`U` finds the smallest `i_0` such that `R_(i_0)` is not empty. Note that this is the smallest `i_0` such that `L_(i_0)` is not full. We call this the index of the shift.
`U` puts the leftmost non-`bar square` symbol of `R_(i_0)` in position `0` and shifts the `2^(i_0)-1` non-`bar square` symbol from `R_(i_0)` into `R_0, ... R_(i_0 -1)`, filing exactly half the symbols of each zone.
`U` performs the symmetric operation to the left of position `0`. That is for `j` starting from `i_0 - 1` down to `0`, `U` iteratively moves `2 cdot 2^j` symbols from `L_j` to fill half the cells of `L_(j+1)`. Finally `U` moves the symbol originally in position `0` to `L_0`.
At the end shift, all of the zones, `R_0, L_0, ... R_(i_0-1), L_(i_0-1)` are half-full, `R_(i_0)` has `2^(i_0)` fewer non-`bar square` symbols, and `L_i` has `2^i` additional non-`bar square` symbols, so the inavriants are maintained.
The total cost of performing the shift is proportional to the total size of the zones `R_0, L_0, ... R_(i_0-1), L_(i_0-1)`. That is, `O(sum_(j=0)^(i_0) 2 cdot 2^j)` = `O(2^(i_0))`.
Analysis
Notice using zones, when we perform shifts, we don't have to move the whole tape just the relevant zones.
After performing a shift with index `i` the zones `R_0, L_0, ... R_(i-1), L_(i-1)` are half-full, which means it will take at least `2^i - 1` lefts shifts before the zones `L_0, ... L_(i-1)` become empty or at least `2^i - 1` right shifts before the zones `R_0, ... R_(i-1)` become empty.
Once we perform a shift with index `i`, the next `2^i - 1` shifts of that tape will have index less than `i`.
This means that for every one of the tapes, at most `1/2^i` fraction of the total shifts have index i`.
Since to simulate `T` steps, we do `T` shifts and the highest possible index is `log T`. We have our runtime is bounded by:
`O(k cdot sum_(i=1)^(log T)frac(T)(2^(i-1))2^i) = O(T log T)`.
Quiz
Which of the following is true?
`C` language programs which compute boolean functions can be simulated by a TM, but Lisp programs cannot.
A `k`-tape TM can always be simulated by a `1`-tape machine with at most a linear slowdown.
Diagonalization can be used to show there exist uncomputable boolean functions.
