Outline

• Polynomial Time
• In-class Exercise
• `O(T log T)` Universal Simulation

Polynomial Time

• A complexity class is a set of functions that can be computed within given resource bounds.
• We will often be interested in Boolean functions. These functions define decision problems also known as languages.
• We say a machine decides a language `L subseteq {0, 1}^star` if it computes `f_L:{0, 1}^star -> {0,1}`, where `f_L(x) = 1 iff x in L`.
• We next look at the case where the resource bound is time.

Definition. Let `T: NN -> NN` be some function. A language `L` is in `mbox(DTIME)(T(n))` iff there is a TM that runs in time `c cdot T(n)` for some constant `c > 0` and decides `L`.

• D in the above refers to deterministic. We will later define the notions of nondeterministic as well as probabilitic TM's.
• Using our definition above we can try to come up with a notion of "efficient computation". For this class, this will equate this with having a polynomial running time.

Definition. `P = cup_(c ge 1) mbox(DTIME)(n^c)`.

More on Polynomial Time

• Consider the problem: Given a graph `G` and two nodes `s` and `t` determine if they are connected and output `1` else `0`. You could use depth first search starting at `s` and see if one ever reaches `t`. This algorithm would visit all the nodes in at most `((n),(2))` steps. So s-t connectivity is in `P`.
• The class `P` only contains decision problems. However, if one can compute a function in polynomial time one can often find a member of `P` which corresponds to this.
• For instance, consider the problem of multiplying two `n` bit numbers. This is associated with the decision problem for the language: `{langle x, y, i rangle : mbox(The ith bit of ) xy mbox( is equal to) 1}`.
• For some problems it is unknown whether or not they are in `P`. For example, the CLIQUE problem we introduced a couple of days back may or may not be in `P`.

In-Class Exercise

• Show that the following three functions are primitive recursive: (a) pd(x) := max(x-1, 0), (b) ls(x, y) := max(x-y, 0), (c) eq(x,y) := 1 if x=y, 0 otherwise.
• Once you are done, upload your code to the Feb 15, Class Thread, and I'll try to look at it and give some feedback in class.

`O(T log T)` Universal Simulation

• Recall last week, we showed that there existed a TM `U` capable of taking the input `langle alpha, x 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 we will see, the tightness of the simulation has a direct impact on our ability to show there are problems in one time complexity class that are not solvable in a slightly smaller time complexity class.
• 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. For example,
  
• 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. For example,
  
• 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:
  1. Each of the zones we care about during the simulation is either empty, full, or half full, with non-`bar square` symbols.
  2. 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.
  3. 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):
  1. `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.
  2. `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)`, filling exactly half the symbols of each zone.
  3. `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`.
  4. 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.
  5. 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)`.