5

In implicit complexity theory we construct languages that characterize what can be computed in various complexity classes. One major result is Bellantoni and Cook where they show that $FP$ can be characterized by such a language (called system $B$).

I have the following beliefs about system $B$

  • System B can encode all functions which can be computed in polynomial time
  • All terms in System $B$ normalize in polynomial time
  • Because all System $B$ terms normalize (in any amount of time) System $B$ is total
  • Because all System $B$ terms normalize in polynomial time System $B$ can interpret System $B$

I have the following beliefs a computability as well

So I seem to believe contradictory things now; namely that System $B$ is total and that System $B$ is not total. Writing out like this makes me realize that the error is almost certainly in the last line of my beliefs about System $B$. So it must be the case that System $B$ can't interpret itself but I don't actually understand why this is the case. Is there a program input pair such that interpreting it takes greater than polynomial time? Further still System $B$ is just one such system among all characterizations of complexity classes on which I could apply this faulty reasoning so the answer should not be specific to System $B$ but to all such implicit characterizations of complexity classes.

Community
  • 1
Jake
  • 3,810
  • 21
  • 35

2 Answers2

2

As concluded via non-direct means in discussion interpreting a polytime program cannot be done in polynomial time in general. The following example shows this directly.

The trick is that for the interpreter to run in polynomial time there must be an polynomial that bounds the running time for every input. This pretty obviously isn't going to hold for System-$B$ because a small constant increase in program size can increase the order of the polynomial that bounds it by a constant amount. The trick you can fall into (and I indeed fell into) is to think that because for each program the running time is bounded a polynomial that the interpreter will run in polynomial time which is pretty embarrassingly obviously false when you write it out like this. It's running time on certain inputs will be bounded by some polynomial but that's the case for any program that always terminates.

So say there is a program, $I$ in System-$B$ that interprets System-$B$ and has running time in $O(n^k)$. Say I had another program, $P$, that ran in $O(n^K)$ with $K > k$. We could speed up P to $O(n^k)$ by simply running it though the interpreter first. So suddenly you have a huge speed up on $P$ that you shouldn't be able to get. In general $I$ could speed up any program slower than it.

I don't have a proof there is no $k$ such that every polytime function can be computed in $O(n^k)$ but it seems fairly obviously the case.

Jake
  • 3,810
  • 21
  • 35
1

If a language can interpret itself then it is not total

I take this to mean that if there is a universal machine for a class in the class itself, the class can not be total (i.e. there have to be non-total functions in the class). What you probably have in mind is that the class can not be the class of all total computable functions since we know that one to be not recursively enumerable.

However, that does not say anything about any other set of total functions.

For instance, all polynomial-time TMs can be simulated by a single polynomial-time TM. Assuming computable enumerations $M_i$ of all TMs and $p_j$ of the polynomials; both exist. Now consider the following machine UPM (universal polynomial machine):

UPM(<i,j>, n) :
  simulate M_i(n) for p_j(n) steps
  if the computation halts
    return M_i(n)
  else
    return 0
  end

This machine clearly exists (i.e. the described function is computable). Computing $p_j(n)$ and simulating $M_i(n)$ takes only polynomial time (some polynomial effort per simulated step) in $n$ and the size of the $M_i$ (effectively $|\langle i,j \rangle|$), so UPM is a polynomial-time machine itself.

Raphael
  • 73,212
  • 30
  • 182
  • 400