Many-one Research Articles

Undecidability Results for Low Complexity Time Classes

We prove that the theory of Exptime degrees with respect to polynomial time Turing and many-one reducibility is undecidable. To do so we use a coding method based on ideal lattices of Boolean algebras which was introduced by Nies (1997, Bull. London Math. Soc.29, 683–692). The method can be applied, in fact, to all time classes given by a time constructible function which dominates all polynomials. By a similar method, we construct an oracle U such that Th(NPU, ⊆) is undecidable.

On the Computational Complexity of Some Classical Equivalence Relations on Boolean Functions

The paper analyzes in terms of polynomial time many-one reductions the computational complexity of several natural equivalence relations on Boolean functions which derive from replacing variables by expressions, one of them is the Boolean isomorphism relation. Most of these computational problems turn out to be between co-NP and $\Sigma$ p 2 .

A relation of primal-dual lattices and the complexity of shortest lattice vector problem

We give a simplified proof of a theorem of Lagarias, Lenstra and Schnorr [17] that the problem of approximating the length of the shortest lattice vector within a factor of Cn, for an appropriate constant C, cannot be NP-hard, unless NP = coNP. We also prove that the problem of finding a n 1 4 - unique shortest lattice vector is not NP-hard under polynomial time many-one reductions, unless the polynomial time hierarchy collapses. © 1998—Elsevier Science B.V. All rights reserved

Total domination and transformation

Using a linear time many-one reduction from the problem total dominating set to the problem dominating set we show how to obtain efficient algorithms to compute a minimum cardinality total dominating set on a variety of graph classes, among them permutation graphs, dually chordal graphs and k-polygon graphs.

A characterization of the leaf language classes

Bovet, Crescenzi, and Silvestri (1992, 1995), and independently Vereshchagin (1994), showed that many complexity classes in the polynomial time setting are leaf language classes, i.e. classes which are determined by two disjoint languages. They gave many examples but they did not characterize the set of leaf language classes. This will be done in this paper. It will be shown that the set of leaf language classes equals the set of countable complexity classes that are closed downward with respect to polynomial-time many-one reducibility ⩽ m p and closed under join. Moreover, the set of classes characterizable by two complementary leaf languages will be shown to be equal to the set of complexity classes which, with respect to ⩽ m p , have a complete set and are closed downward.

Structural Average Case Complexity

Levin introduced an average-case complexity measure, based on a notion of “polynomial on average,” and defined “average-case polynomial-time many-one reducibility” among randomized decision problems. We generalize his notions of average-case complexity classes, Random-NP and Average-P. Ben-Davidet al. use the notation of 〈C, F〉 to denote the set of randomized decision problems (L, μ) such thatLis a set in C andμis a probability density function in F. This paper introduces Aver〈C, F〉 as the class of randomized decision problems (L, μ) such thatLis computed by a type-C machine onμ-average andμis a density function in F. These notations capture all known average-case complexity classes as, for example, Random-NP= 〈NP, P-comp〉 and Average-P=Aver〈P, ∗〉, where P-comp denotes the set of density functions whose distributions are computable in polynomial time, and ∗ denotes the set of all density functions. Mainly studied are polynomial-time reductions between randomized decision problems: many–one, deterministic Turing and nondeterministic Turing reductions and the average-case versions of them. Based on these reducibilities, structural properties of average-case complexity classes are discussed. We give average-case analogues of concepts in worst-case complexity theory; in particular, the polynomial time hierarchy and Turing self-reducibility, and we show that all known complete sets for Random-NP are Turing self-reducible. A new notion of “real polynomial-time computations” is introduced based on average polynomial-time computations for arbitrary distributions from a fixed set, and it is used to characterize the worst-case complexity classesΔpkandΣpkof the polynomial-time hierarchy.

On the power of generalized Mod-classes

The computational power of the counting class ModP, which generalizes the classes Mod/sub p/P, p prime, is investigated. It is shown that ModP is truth-table equivalent in power to MP, and that ModP is contained in the class AmpMP. As a consequence, the lowness of AmpMP or of ModP for MP would imply the collapse of the counting hierarchy (CH) to MP. Further, every set in C=P is shown to be reducible to a ModP set via a random many-one reduction that uses only logarithmically many random bits. Therefore, ModP and AmpMP are not closed under such reductions unless CH collapses. Finally, ModP is generalized to the class Mod/sub */P, which turns out to be a superclass of C=P. >

Degree theoretic definitions of the low2 recursively enumerable sets

The primary relation studied in recursion theory is that of relative complexity: A set or function A (of natural numbers) is reducible to one B if, given access to information about B, we can compute A. The primary reducibility is that of Turing, A ≤TB, where arbitrary (Turing) machines, φe, can be used; access to information about (the oracle) B is unlimited and the lengths of computations are potentially unbounded. Many other interesting reducibilities result from restricitng one or more of these facets of the procedure. Thus, for example, the strongest notion considered is one-one reducibility on sets: A ≤1B iff there is a one-one recursive (= effective) function f such that x Є A ⇔ f(x) Є B. Many-one (≤m) reducibility simply allows f to be many-one. Other intermediate reducibilities include truth-table (≤tt) and weak truth-table (≤wtt). The latter imposes a recursive bound f(x) on the information about B that can be used to compute A(x). The former also bounds the length of computations by requiring that the computation of A(x) from B halt in at most f(x) many steps.Each such reducibility r defines a notion of degree, degr(A) = {B : A ≤rB ∧ B ≤rA}, and a corresponding structure of the r-degrees ordered by r-reducibility. (We typically denote the degree of A by a.) A major theme in recursion theory has been the investigation of the relation between a set's place in these orderings (the algebraic properties of its degree) and other algorithmic, set-theoretic or definability type notions of complexity. Important examples of such other notions include rates of growth of functions, the types of approximation procedures which converge to the given function or set and the (syntactic) complexity of defining the set (or function) in arithmetic or analysis.

The isomorphism conjecture fails relative to a random oracle

Berman and Hartmanis [1977] conjectured that there is a polynomial-time computable isomorphism between any two languages complete for NP with respect to polynomial-time computable many-one (Karp) reductions. Joseph and Young [1985] gave a structural definition of a class of NP-complete sets-the k-creative sets-and defined a class of sets (the K f k 's) that are necessarily k-creative. They went on to conjecture that certain of these K f t 's are not isomorphic to the standard NP-complete sets. Clearly, the Berman-Hartmanis and Joseph-Young conjectures cannot both be correct. We introduce a family of strong one-way functions, the scrambling functions. If f is a scrambling function, then K f k is not isomorphic to the standard NP-complete sets, as Joseph and Young conjectured, and the Berman-Hartmanis conjecture fails. Indeed, if scrambling functions exist, then the isomorphism also fails at higher complexity classes such as EXP and NEXP. As evidence for the existence of scrambling functions, we show that much more powerful one-way functions-the annihilating functions-exist relative to a random oracle. Random oracles are the first examples of oracles relative to which the isomorphism conjecture fails with respect to higher classes such as EXP and NEXP.

On the NP-Isomorphism Problem with Respect to Random Instances

This paper takes a new approach to studying the NP-isomorphism problem initiated by Berman and Hartmanis. We consider polynomial-time computable and invertible bijections among NP-complete sets that preserve the underlying natural distributions on random instances. We show that there are natural NP-complete problems which are not polynomially isomorphic when instances are chosen at random because no polynomial-time isomorphisms can preserve the underlying natural distributions on instances of these problems, On the other hand, we show that all the known average-case NP-complete problems under many-one reductions are polynomially isomorphic with respect to their distributions on random instances. Simple and accessible proofs to the known average-case NP-complete problems are presented when establishing the isomorphism result. New average-case NP-complete problems are also presented.

Symmetric Logspace is Closed Under Complement

We present a logspace, many-one reduction from the undirected st-connectivity problem to its complement. This shows that SL = co - SL.

Minimal pairs and complete problems

Two sets are said to form a minimal pair for polynomial many-one reductions if neither set is in P and the only sets which are polynomially reducible (via polynomial many–one reductions) to both sets are in P. We consider the question of which complete sets can be the top (that is the supremum) of a minimal pair. Our main result is that any elementary recursive set which is hard for deterministic exponential time cannot be the top of a minimal pair. Hence in particular any complete set for an elementary recursive class containing exponential time cannot be such a supremum. For NP-complete sets the problem remains open. We show here that it is oracle dependent. This is the first example of an oracle dependent property which is completely degree theoretic.

Generalized theorems on relationships among reducibility notions to certain complexity classes

In this paper we give several generalized theorems concerning reducibility notions to certain complexity classes. We study classes that are either (I) closed under NP many-one reductions and polynomial-time conjunctive reductions or (II) closed under coNP many-one reductions and polynomial-time disjunctive reductions. We prove that, for such a classK, (1) reducibility notions of sets toK under polynomial-time constant-round truth-table reducibility, polynomial-time log-Turing reducibility, logspace constant-round truth-table reducibility, logspace log-Turing reducibility, and logspace Turing reducibility are all equivalent and (2) every set that is polynomial-time positive Turing reducible to a set inK is already inK. From these results, we derive some observations on the reducibility notions to C=P and NP.

Padding, commitment and self-reducibility

A new property of NP sets called commitability is introduced in this paper. Roughly, a language L in NP is commitable if given any instance x and any string y, a string z can be found in polynomial time such that z is in L iff y is a prefix of a witness of x in the context of a PTIME relation that defines L. It is shown that all NP sets complete under polynomial-time many-one reductions are commitable. Commitability can be seen as a genralization of d-self-reducibility. Every d-self-reducible set is commited and yet, commitability retains an important aspect of d-self-reducibility: the tree search method of Berman is shown to be extendible to commitable sets. Therefore, certain known results about reductions to co-sparse sets and p-selective sets generalize from d-self-reductible sets to commitable sets. The connection with paddability is as follows: Every paddable and commitable set is shown to be d-self-reducible. It is also shown that paddability in NP implies kernel constructibility, which was introduced elsewhere to capture a notion of self-reducibility more general than d-self-reducibility.

#P-COMPLETENESS VIA MANY-ONE REDUCTIONS

Valiant defined #P-completeness using Turing reductions. We propose a more restrictive definition, a variant of many-one reductions, and prove that the (0, 1)-permanent remains #P-complete under this definition.

Parallel algebraic reductions among numerical problems

In this note we consider, for a number of linear algebra problems, an environment allowing approximate computations. Within this framework we show that the relative complexity of these problems should be studied according to a strict notion of reducibility, which corresponds to the well-known many-one reducibility of combinatorial complexity.

Undecidability and initial segments of the (r.e.) tt-degrees

A notion of reducibility ≤r between sets is specified by giving a set of procedures for computing one set from another. We say that a set A is r-reducible to a set B, A ≤rB, if one of the procedures applied to B gives A. Associated with any such reducibility notion is the structure of r-degrees, the equivalence classes of sets with respect to this reducibility, with the induced ordering. The most general notion of a computable reducibility is that of Turing, ≤T. Here we say that A ≤TB if there is a Turing machine φe which, when equipped with an oracle for B, computes A: φeB = A. Such Turing degree computations are characterized by the phenomenon that only during the computation itself do we discover which questions about B need to be answered to compute A(x). In contrast, for nearly all other computable reducibilities the set of questions needed is given in advance by a recursive procedure. Perhaps the most common example of such a procedure is many-one reducibility, ≤m: A ≤mB if there is a recursive function f such that x ∈ A ⇔ f(x) ∈ B.Reducibilities with the property that the output, A(x), is determined by the answers that B gives to a set of questions calculated recursively from x are said to be of tabular type. The most general tabular reducibility is called truth-table reducibility, ≤tt. The procedures [e] associated with this reducibility are specified by a recursive function f (= {e}) which, for each x, gives a set of n questions about the oracle and, for each of the possible 2n sets of answers, gives the corresponding output. As usual this defines A ≤ttB as “there is an e such that [e]B = A”. It is with this notion of reducibility and the associated tt-degrees that we shall be concerned in this paper. Basic information on several such strong reducibilities can be found in Rogers [28]. For more information we recommend the survey articles by Odifreddi [25] and Degtev [2] as well as Odifreddi's book [26].

Relativizing relativized computations

This paper introduces a technique of relativizing already relativized computations and gives two interesting applications. The techniques developed here are simpler than the usual methods for constructing oracles that satisfy several requirements simultaneously. The first application shows that a result of Karp and Lipton (if sets in NP are decidable with polynomial-size circuits, then Σ P 2 = Π P 2) cannot be strengthened in the presence of certain oracles. This means that relativizable proof techniques cannot strengthen the conclusion to, say, P= NP. Such a stronger conclusion would be desirable as it would establish the equivalence of polynomial-time programs and polynomial-size circuits for solving NP-complete problems and would extend the known equivalence of polynomial-time programs and programs that are allowed a single query to a polynomial-size table. The second application gives an oracle C for which P C ≠ (NP C ∩ coNP C ) ≠ NP C and NP C ∩ coNP C has complete sets under polynomial-time many-one reductions. This complements a result of Sipser in which an oracle B is constructed for which NP B ∩ coNP B has no complete sets. These results suggest that current proof methods will not settle whether NP ∩ coNP has complete sets.

A new complete language for DSPACE(log n)

An important open problem relating sequential and parallel computations is whether the space complexity on Turing machines is linearly related to the depth complexity on uniform circuits. Some graph problems have been successfully proved to be complete for DSPACE(log n) under (log n)-depth Turing reducibility [3]. In this paper, we discuss (log n)-depth many-one reducibility which is proved to be weaker than (log n)-depth Turing reducibility. A new complete language for DSPACE(log n) under our reducibility is presented.

Positive relativizations of the P = ? NP problem

Whether or not P is properly included in NP is currently one of the most important open problems in computer science. A deterministic polynomially time-bounded reducibility ⩽ r P and its nondeterministic analogue ⩽ r NP provide a positive relativization of this problem if P = NP is equivalent to P · r(B) = NP · r(B) for all oracle sets B. Initial attempts to relativize the P = ?NP problem considered reducibilities which are not known to yield positive relativizations. Baker, Gill, and Solovay [1] provided oracle sets B and B′ such that P · T( B) ≠ NP · T( B) and P · T( B′) = NP · T(B'); however, it remains open whether P ⩞ NP or, equivalently, whether the polynomially time-bounded Turing reducibility of Cook ( in “Proceedings, 3rd Annual ACM Symposium on Theory of Computing, 1971,” pp. 151–158) provides a positive relativization of the problem. Book, Long, and Selman ( SIAM J. Comput. 13 (1984), 461–487) found a restricted form of Cook's reducibility that does provide a positive relativization. Several reducibilities between polynomially time-bounded Turing reducibility and polynomially time-bounded many-one reducibility are investigated for their ability to positively relativize the P = ?NP problem.