Pinpointing computation with modular queries in the Boolean hierarchy

Abstract

A modular query consists of asking how many (modulo m) of k strings belong to a fixed NP language. Modular queries provide a form of restricted access to an NP oracle. For each k and m, we consider the class of languages accepted by NP machines that ask a single modular query. Han and Thierauf [HT95] showed that these classes coincide with levels of the Boolean hierarchy when m is even or k ≤ 2m, and they determined the exact levels. Until now, the remaining case -odd m and large k -looked quite difficult. We pinpoint the level in the Boolean hierarchy for the remaining case; thus, these classes coincide with levels of the Boolean hierarchy for every k and m.In addition we characterize the classes obtained by using an NP(l) acceptor in place of an NP acceptor (NP(l) is the lth level of the Boolean hierarchy). As before, these all coincide with levels in the Boolean hierarchy.

Self-Specifying Machines

“…Also equivalently, we note that SelfOutput = P #P[1]:NP[1] + , the class of languages accepted by P machines given at most one call to a #P oracle followed by at most one positive [33,39] . This is a so-called "downward separation" result (see, e.g., [21], for some background), and indeed what our proof actually establishes is that the following three conditions are equivalent: [10,38] that P #P [1] does equal P NP[1]:#P [1] (indeed, even P #P [1] = P NP[O(log n)]:#P [1] ), the comments of the previous paragraph give some weak evidence that order of access may be important in determining computational power, a theme that has been raised and studied in other settings (see the survey [17]). Unfortunately, in the present setting, giving firm evidence for this seems hard.…”

“…One might naturally wonder whether ≤ #NP m -reductions to the same classes yield even greater computational power. However, note that from Toda and Watanabe's [49] result #PH ⊆ FP #P [1] we can easily prove the following proposition, which says that for most natural classes ≤ #NP…”

“…For any a and b for which ≤ b a is defined and any class C, let R b a (C) = {L | (∃C ∈ C)[L ≤ b a C]}. Hemaspaandra, Hempel, and Wechsung [20] introduced the study of the power of ordered query access (other papers on or related to query order include [18,1,25,3,48,34,19] and the survey [17]). We adopt this notion, and extend it to the function class case and to the positive query case.…”

“…We adopt this notion, and extend it to the function class case and to the positive query case. For any function or language classes C 1 and C 2 , define P C 1 [1]:C 2 [1] to be the class of languages accepted by polynomial-time machines making at most one query to a C 1 oracle followed by at most one query to a C 2 oracle. If C 2 is a language class, then…”

“…witnessed by a polynomial-time oracle machine that accepts if and only if the C 2 set is queried and the answer to that query is "yes." 1 1 We mention that this requires that the querying machine is such that if (in light of of the C1 query's actual answer if any-note that we do not require that a query to either C1 or C2 necessarily be made) there is a C2 query then the truth-table the querying machine has with respect to the answer from the C2 query, given the true answer to the C1 query if there is any such query, is that the machine will accept if and only if the answer is "yes." However, for most natural classes, in particular C2 = NP, without loss of generality we can assume that the querying machine always makes exactly two queries and that its truth table with respect to the two answers (even given a "lying" answer to the first query) is: accept if and only if the second answer is "yes."…”