1
$\begingroup$

To prove that $P \subseteq P_{\ poly}$ [see book by Arora and Barak, chapter 6, page no 105]

Proof : Let $M$ be an oblivious TM and running time is $T(n)$, let $x \in \{0,1\}^* $ be some input for $M$ and define the transcript of $M$'s execution on $x$ to be the sequence $z_1,z_2,..z_{T(n)}$ of snapshots (the machine's state and symbol read by all heads) of the execution at each step in time.

We can encode each such snapshot $z_i$ by a constant-sized binary string, and furthermore, we can compute the string $z_i$ based on input $x$, the previous snapshot $z_{i-1}$ and snapshot $z_{i_1},z_{i_2},\cdots ,z_{i_k}$, where $z_{i_j}$ denotes the last step that $M$ 's jth head was in the same position as it is in the ith step.

The composition of all these constant-sized circuits gives rise to circuit that computes from the input $x$ the snapshot $z_{T(n)}$. This requires polynomial space, but I want to do this whole computation in logarithmic space.

My question : How to compute snapshot $z_i$ of Turing machine $M$ from previous snapshots using logarithmic space?

$\endgroup$
1
$\begingroup$

What you seem to be asking is what is the complexity of computing each bit in the sequence of snapshots. The complexity depends on the way you encode the snapshots. Here are a few options:

  1. Encode the state of the machine, the position of the head, and the tape. Computing a bit of the tape requires knowing whether the head is currently at that position or at a neighboring position. Since in general a polytime machine has a polysize tape, this requires circuits accessing $\Theta(\log n)$ inputs.

  2. Encode the state of the machine and the tape, where the tape alphabet is enlarged to include another bit, signifying whether the head is at that position or not. Now each tape bit only depends on a constant number of bits. However, determining the next state is (still) very costly, since we need to know the value under the head.

  3. Encode the state of the machine and the tape, where the tape alphabet is enlarged to include the "head bit" as well as the symbol currently under the head. Now each bit indeed depends only on a constant number of bits.

Of course, given any formula, we can always convert it to a 3CNF using auxiliary variables without blowing it up by too much. What I outline above is a particular way of doing this transformation in the case at hand.

| cite | improve this answer | |
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.