Polynomial creativity

Last updated

In computational complexity theory, polynomial creativity is a theory analogous to the theory of creative sets in recursion theory and mathematical logic. The -creative sets are a family of formal languages in the complexity class NP whose complements certifiably do not have -time nondeterministic recognition algorithms. It is generally believed that NP is unequal to co-NP (the class of complements of languages in NP), which would imply more strongly that the complements of all NP-complete languages do not have polynomial-time nondeterministic recognition algorithms. [1] However, for the -creative sets, the lack of a (more restricted) recognition algorithm can be proven, whereas a proof that NP ≠ co-NP remains elusive.

Contents

The -creative sets are conjectured to form counterexamples to the Berman–Hartmanis conjecture on isomorphism of NP-complete sets. It is NP-complete to test whether an input string belongs to any one of these languages, but no polynomial time isomorphisms between all such languages and other NP-complete languages are known. Polynomial creativity and the -creative sets were introduced in 1985 by Deborah Joseph and Paul Young, following earlier attempts to define polynomial analogues for creative sets by Ko and Moore. [2] [3]

Definition

Intuitively, a set is creative when there is a polynomial-time algorithm that creates a counterexample for any candidate fast nondeterministic recognition algorithm for its complement.

The classes of fast nondeterministic recognition algorithms are formalized by Joseph and Young as the sets of nondeterministic Turing machine programs that, for inputs that they accept, have an accepting path with a number of steps that is at most . This notation should be distinguished with that for the complexity class NP. The complexity class NP is a set of formal languages, while is instead a set of programs that accept some of these languages. Every language in NP is recognized by a program in one of the sets , with a parameter that is (up to the factor in the bound on the number of steps) the exponent in the polynomial running time of the program. [2]

According to Joseph and Young's theory, a language in NP is -creative if it is possible to find a witness showing that the complement of is not recognized by any program in . More formally, there should exist a polynomially computable function that maps programs in this class to inputs on which they fail. When given a nondeterministic program in , the function should produce an input string that either belongs to and causes the program to accept , or does not belong to and causes the program to reject . The function is called a productive functionfor . If this productive function exists, the given program does not produce the behavior on input that would be expected of a program for recognizing the complement of . [2]

Existence

Joseph and Young construct creative languages by reversing the definitions of these languages: rather than starting with a language and trying to find a productive function for it, they start with a function and construct a language for which it is the productive function. They define a polynomial-time function to be polynomially honest if its running time is at most a polynomial function of its output length. This disallows, for instance, functions that take polynomial time but produce outputs of less than polynomial length. As they show, every one-to-one polynomially-honest function is the productive function for a -creativelanguage . [2]

Given , Joseph and Young define to be the set of values for nondeterministic programs that have an accepting path for using at most steps. This number of steps (on that input) would be consistent with belonging to . Then belongs to NP: given an input one can nondeterministically guess both and its accepting path, and then verify that the input equals and that the path is valid for . [2]

Language is -creative, with as its productive function, because every program in is mapped by to a value that is either accepted by (and therefore also belongs to ) or rejected by (and therefore also does not belong to ). [2]

Completeness

Every -creative set with a polynomially honest productive function is NP-complete. For any other language in NP, by the definition of NP, one can translate any input for into a nondeterministic program that ignores its own input and instead searches for a witness for , accepting its input if it finds one and rejecting otherwise. The length of is polynomial in the size of and a padding argument can be used to make long enough (but still polynomial) for its running time to qualify for membership in . [2]

Let be the productive function used to define a given -creativeset , and let be the translation from to . Then the composition of with maps an input for problem into a string that causes program to return the incorrect answer to the question of whether belongs to the complement of . When , program will return true (regardless of the value of ), so for this true answer to be incorrect it must be the case that . By the same reasoning, when , . Thus, the composition of with is a polynomial-time many-one reduction from to . Since is (by definition) in NP, and every other language in NP has a reduction to it, it must be NP-complete. [2]

Application to the Berman–Hartmanis conjecture

The Berman–Hartmanis conjecture states that there exists a polynomial-time isomorphism between any two NP-complete sets: a function that maps yes-instances of one such set one-to-one into yes-instances of the other, takes polynomial time, and whose inverse function can also be computed in polynomial time. It was formulated by Leonard C. Berman and Juris Hartmanis in 1977, based on the observation that all NP-complete sets known at that time were isomorphic. An equivalent formulation of the conjecture is that every NP-complete set is paddable. This means that there exists a polynomial-time and polynomial-time-invertible one-to-one transformation from instances to larger equivalent instances that encode the "irrelevant" information . [4]

However, it is unknown how to find such a padding transformation for a -creative language whose productive function is not polynomial-time-invertible. Therefore, if one-way permutations exist, the -creative languages having these permutations as their productive functions provide candidate counterexamples to the Berman–Hartmanis conjecture. [2]

The (unproven) Joseph–Young conjecture formalizes this reasoning. The conjecture states that there exists a one-way length-increasing function such that is not paddable. [2] Alan Selman observed that this would imply a simpler conjecture, the encrypted complete set conjecture: there exists a one-way function such that (the set of yes-instances for the satisfiability problem) and are non-isomorphic. [5] There exists an oracle relative to which one-way functions exist, both of these conjectures are false, and the Berman–Hartmanis conjecture is true. [6]

Related Research Articles

The P versus NP problem is a major unsolved problem in theoretical computer science. Informally, it asks whether every problem whose solution can be quickly verified can also be quickly solved.

In theoretical computer science and mathematics, computational complexity theory focuses on classifying computational problems according to their resource usage, and explores the relationships between these classifications. A computational problem is a task solved by a computer. A computation problem is solvable by mechanical application of mathematical steps, such as an algorithm.

<span class="mw-page-title-main">NP (complexity)</span> Complexity class used to classify decision problems

In computational complexity theory, NP is a complexity class used to classify decision problems. NP is the set of decision problems for which the problem instances, where the answer is "yes", have proofs verifiable in polynomial time by a deterministic Turing machine, or alternatively the set of problems that can be solved in polynomial time by a nondeterministic Turing machine.

In computational complexity theory, the complexity class #P (pronounced "sharp P" or, sometimes "number P" or "hash P") is the set of the counting problems associated with the decision problems in the set NP. More formally, #P is the class of function problems of the form "compute f(x)", where f is the number of accepting paths of a nondeterministic Turing machine running in polynomial time. Unlike most well-known complexity classes, it is not a class of decision problems but a class of function problems. The most difficult, representative problems of this class are #P-complete.

In computational complexity theory, a decision problem is PSPACE-complete if it can be solved using an amount of memory that is polynomial in the input length and if every other problem that can be solved in polynomial space can be transformed to it in polynomial time. The problems that are PSPACE-complete can be thought of as the hardest problems in PSPACE, the class of decision problems solvable in polynomial space, because a solution to any one such problem could easily be used to solve any other problem in PSPACE.

In computational complexity theory, randomized polynomial time (RP) is the complexity class of problems for which a probabilistic Turing machine exists with these properties:

In computability theory and computational complexity theory, a many-one reduction is a reduction that converts instances of one decision problem to another decision problem using a computable function. The reduced instance is in the language if and only if the initial instance is in its language . Thus if we can decide whether instances are in the language , we can decide whether instances are in its language by applying the reduction and solving for . Thus, reductions can be used to measure the relative computational difficulty of two problems. It is said that reduces to if, in layman's terms is at least as hard to solve as . This means that any algorithm that solves can also be used as part of a program that solves .

<span class="mw-page-title-main">Complexity class</span> Set of problems in computational complexity theory

In computational complexity theory, a complexity class is a set of computational problems "of related resource-based complexity". The two most commonly analyzed resources are time and memory.

In computer science and operations research, approximation algorithms are efficient algorithms that find approximate solutions to optimization problems with provable guarantees on the distance of the returned solution to the optimal one. Approximation algorithms naturally arise in the field of theoretical computer science as a consequence of the widely believed P ≠ NP conjecture. Under this conjecture, a wide class of optimization problems cannot be solved exactly in polynomial time. The field of approximation algorithms, therefore, tries to understand how closely it is possible to approximate optimal solutions to such problems in polynomial time. In an overwhelming majority of the cases, the guarantee of such algorithms is a multiplicative one expressed as an approximation ratio or approximation factor i.e., the optimal solution is always guaranteed to be within a (predetermined) multiplicative factor of the returned solution. However, there are also many approximation algorithms that provide an additive guarantee on the quality of the returned solution. A notable example of an approximation algorithm that provides both is the classic approximation algorithm of Lenstra, Shmoys and Tardos for scheduling on unrelated parallel machines.

In computer science, parameterized complexity is a branch of computational complexity theory that focuses on classifying computational problems according to their inherent difficulty with respect to multiple parameters of the input or output. The complexity of a problem is then measured as a function of those parameters. This allows the classification of NP-hard problems on a finer scale than in the classical setting, where the complexity of a problem is only measured as a function of the number of bits in the input. This appears to have been first demonstrated in Gurevich, Stockmeyer & Vishkin (1984). The first systematic work on parameterized complexity was done by Downey & Fellows (1999).

In computational complexity theory, Savitch's theorem, proved by Walter Savitch in 1970, gives a relationship between deterministic and non-deterministic space complexity. It states that for any function ,

In computational complexity theory, a function problem is a computational problem where a single output is expected for every input, but the output is more complex than that of a decision problem. For function problems, the output is not simply 'yes' or 'no'.

In computational complexity theory, the complexity class NEXPTIME is the set of decision problems that can be solved by a non-deterministic Turing machine using time .

<span class="mw-page-title-main">IP (complexity)</span>

In computational complexity theory, the class IP is the class of problems solvable by an interactive proof system. It is equal to the class PSPACE. The result was established in a series of papers: the first by Lund, Karloff, Fortnow, and Nisan showed that co-NP had multiple prover interactive proofs; and the second, by Shamir, employed their technique to establish that IP=PSPACE. The result is a famous example where the proof does not relativize.

In computability theory, productive sets and creative sets are types of sets of natural numbers that have important applications in mathematical logic. They are a standard topic in mathematical logic textbooks such as Soare (1987) and Rogers (1987).

In computational complexity theory, the complexity class TFNP is the class of total function problems which can be solved in nondeterministic polynomial time. That is, it is the class of function problems that are guaranteed to have an answer, and this answer can be checked in polynomial time, or equivalently it is the subset of FNP where a solution is guaranteed to exist. The abbreviation TFNP stands for "Total Function Nondeterministic Polynomial".

In computational complexity theory, a unary language or tally language is a formal language where all strings have the form 1k, where "1" can be any fixed symbol. For example, the language {1, 111, 1111} is unary, as is the language {1k | k is prime}. The complexity class of all such languages is sometimes called TALLY.

In computational complexity theory, a sparse language is a formal language such that the complexity function, counting the number of strings of length n in the language, is bounded by a polynomial function of n. They are used primarily in the study of the relationship of the complexity class NP with other classes. The complexity class of all sparse languages is called SPARSE.

<span class="mw-page-title-main">NP-completeness</span> Complexity class

In computational complexity theory, a problem is NP-complete when:

  1. It is a decision problem, meaning that for any input to the problem, the output is either "yes" or "no".
  2. When the answer is "yes", this can be demonstrated through the existence of a short solution.
  3. The correctness of each solution can be verified quickly and a brute-force search algorithm can find a solution by trying all possible solutions.
  4. The problem can be used to simulate every other problem for which we can verify quickly that a solution is correct. In this sense, NP-complete problems are the hardest of the problems to which solutions can be verified quickly. If we could find solutions of some NP-complete problem quickly, we could quickly find the solutions of every other problem to which a given solution can be easily verified.

In structural complexity theory, the Berman–Hartmanis conjecture is an unsolved conjecture named after Leonard C. Berman and Juris Hartmanis. Informally, it states that all NP-complete languages look alike, in the sense that they can be related to each other by polynomial time isomorphisms.

References

  1. Goldreich, Oded (2010), P, NP, and NP-Completeness: The Basics of Computational Complexity, Cambridge University Press, pp.  154–155, ISBN   9781139490092
  2. 1 2 3 4 5 6 7 8 9 10 Joseph, Deborah; Young, Paul (1985), "Some remarks on witness functions for nonpolynomial and noncomplete sets in NP", Theoretical Computer Science , 39 (2–3): 225–237, doi: 10.1016/0304-3975(85)90140-9 , MR   0821203
  3. Ko, Ker-I; Moore, Daniel (1981), "Completeness, approximation and density", SIAM Journal on Computing , 10 (4): 787–796, doi:10.1137/0210061, MR   0635436
  4. Berman, L.; Hartmanis, J. (1977), "On isomorphisms and density of NP and other complete sets" (PDF), SIAM Journal on Computing , 6 (2): 305–322, doi:10.1137/0206023, hdl: 1813/7101 , MR   0455536
  5. Selman, Alan L. (1992), "A survey of one-way functions in complexity theory", Mathematical Systems Theory, 25 (3): 203–221, doi:10.1007/BF01374525, MR   1151339, S2CID   33642595
  6. Rogers, John (1997), "The isomorphism conjecture holds and one-way functions exist relative to an oracle", Journal of Computer and System Sciences , 54 (3): 412–423, doi: 10.1006/jcss.1997.1486 , MR   1463764