Basically, I was assuming that replacing G with X would allow adding an oracle to make everything work. But as (I think) you are suggesting, there’s no guarantee that X will continue to work in the presence of an oracle. That was just my hasty assumption.

Again, thanks for helping me work this out. Back to the drawing board!

]]>I’m still questioning whether X works properly in the relativized case. It seems like you’re defining X as follows. We are assuming diagNP is in EXP and so there is an EXPTIME algorithm that decides diagNP. X takes as input a tuple M=(T,G,C) of oracle machines (as explained above). X runs the EXPTIME procedure for diagNP and outputs a single guess: a correct witness that will cause C (with trivial oracle “plugged in”) to accept input M. (If no such witness exists because M is in diagNP then X can output a single garbage guess.)

My first question: Is it obvious that such an X even exists? Sure, X can decide whether or not M accepts itself in EXPTIME but can it actually find a witness? I don’t see any self-reducibility.

But the problem that worries me most is this one: the idea for relativizing this is to “plug in” the oracle O to all machines and use the same argument. But now in order for X to work correctly it needs to find a witness that will cause C with oracle O “plugged in” to accept input M. But all we know is that X can find a witness that will cause C with trivial oracle “plugged in” to accept input M. I see no reason why these witnesses should be the same.

Let me know what you think.

]]>To visualize this, imagine a diagram like the following:

M1 M2 M3 M4 M5 …

M1

M2

M3

M4

M5

…

(I had to omit the 1’s and 0’s due to WordPress being dumb…sorry). The diagonal of the diagram above represents what you get when you have M1 = (T,G,C)_1, M2 = (T,G,C)_2, … etc. running on themselves. The rows represent the NP machines that I am simulating, while the columns represent the NP machines I’m simulating on (but only at the places where I’ve filled in 1’s or 0’s). The filled in diagonal is the language diagNP.

When I replace G with X, I do it only in the rows. This will yield the exact same diagonal.

Now, when I relativize by adding an oracle O to every machine T, G, X, and C that appears in any computation or index, I’ll get the same structure. The key is that although I’ve technically added an oracle to X, it hasn’t changed a bit because it has no oracle access (just as G had no oracle access). So it can function the same way as before, and I just have a checker that runs in P^O and the same EXPTIME machine X to multitask over in EXP^O.

T^O,X,C^O is guaranteed to work when simulated because T,G,C works on the diagonal (which is all we care about) in the non-relativized world, T,X,C works on the diagonal in the non-relativized world, and so since adding an oracle to T,G,C works on the diagonal, so does adding an oracle to T,X,C.

Is that any clearer? I definitely understood your point, although I’m not sure if I’ve responded to it clearly yet.

]]>One more conventional system for enumerating NP machines is to list all nondeterministic machines with a polynomial time clocking (that forces the algorithm to halt and reject if its branches haven’t finished computing in time). This system also works, even though there are other machines that decide NP languages other than these.

]]>“Yes, that is my claim. This indexes (or members of the enumeration) don’t run in polynomial time, but this enumeration captures what NP is by allowing every NP language to be captured by the indexing.

The idea is that the machine brute force guesses every possible certificate, and then passes each certificate to the polynomial time checker. If the checker ever accepts, then the machine accepts. This is how NP usually works–except that it is assumed to guess the right certificate “nondeterministically” or automatically, not via brute force.”

]]>