An Overview Of Some Semantic And Syntactic Complexity Classes

06/09/2018 ∙ by James L. Cox, et al. ∙ CUNY Law School 0

We review some semantic and syntactic complexity classes that were introduced to better understand the relationship between complexity classes P and NP. We also define several new complexity classes, some of which are associated with Mersenne numbers, and show their location in the complexity hierarchy.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The study of non-deterministic polynomial-time Turing machines (NPTM) was initiated in

[1] with the first NP-Complete problem. This problem asks if a Boolean expression in conjunctive normal form (CNF) has a satisfying truth assignment; and it is referred to as CNF-SAT. It was also shown that CNF-SAT is polynomial time Turing reducible to the problem of finding a tautology for a Boolean expression in disjunctive normal form (DNF), where this problem is CoNP-Complete. Then a whole array of other problems were shown to be NP-Complete in [4] via polynomial time many-one reductions to CNF satisfiability. The polynomial-time hierarchy, PH, was introduced in [8] as a hierarchy of complexity classes that are derived from complexity classes NP and CoNP when used as oracles. A more elaborate list of NP-Complete problems were presented in [32].

Researchers also examined versions of these NP-Complete problems with different constraints. For example, probabilistic polynomial time Turing machines and the corresponding PP-Complete problem Majority-SAT, which asks if a Boolean expression in CNF with variables have more than many satisfying truth assignments, was independently introduced in [6] and [10]. Complexity class CP was also introduced in [6], where the canonical CP-Complete problem asks if a Boolean expression in CNF with variables have exactly many satisfying truth assignments, and showed that CP PP. The complexity class #P was introduced in [11], where it’s complete problem #SAT asks to find the total number of satisfying truth assignments for a Boolean expression in CNF. It was also proven in [11] that calculating the permanent of a 0-1 matrix is polynomial time Turing reducible to calculating the total number of accepting paths of a NPTM. It was shown in [29] that complexity classes #P and PP are equivalent under polynomial time Turing reductions, that is P = P

. Later on, the problems that ask if a Boolean expression in CNF has a unique satisfying truth assignment, and odd number of satisfying truth assignments were examined in

[12] and [13], respectively. The complexity classes derived from these studies in [12] and [13] are US and P, respectively. It was proven in [18] that PH BPP P, where BPP is the bounded-error probabilistic polynomial time as defined in [10]. Some other intriguing complexity classes can be found in [21] and [25].

The study of categorical NPTM was initiated in [9] with the complexity class UP. Other widely used terms instead of categorical are bounded, restricted and semantic. These complexity classes are not believed to possess complete problems, but they rather have promise problems. The promise problem for UP is called Unambiguous-SAT and it asks the question that when promised to have a unique satisfying truth assignment or none, does the Boolean expression in CNF have a unique satisfying truth assignment? It was shown in [16] that NP RP, where RP is the randomized polynomial time as defined in [10]. The semantic version of CP was defined in [26] as Half_P. Another notable semantic complexity class is EP, which was defined in [27]. An EP machine has an acceptance criterion of power of two and a rejection criterion of zero. It was shown in [27] that the syntactic version of EP, called ES, equals CP. Various other interesting semantic complexity classes were introduced in [20] and [25].

In the next section, we review several reducibilities and establish what it means to be a semantic and syntactic complexity class. We also provide various examples of these complexity classes along with the proven relationships among them. In the section that follows, we define three new complexity classes, namely the semantic complexity classes MNP and FP and the syntactic complexity class MNS. The complexity classes MNP and MNS are associated with Mersenne numbers whereas the complexity class FP is closely related to the complexity class CP. Then in the subsequent sections, we examine the relationship between these new complexity classes and already known ones. More precisely, we prove the following:

FewP MNP

US MNS

PP NP

P NP

MNP P

CP MNS and MNS CP which implies that MNS = CP

MNP EP = UP

2 Definitions and Preliminaries

We are interested in polynomial time Turing reducibility (also called Cook reducibility), polynomial time Post reducibility (also called truth table reducibility), polynomial time conjunctive and disjunctive truth table reducibilities and polynomial time many-one reducibility (also called Karp reducibility) as defined below.

Definition 1

Let and be classes of languages.

  1. is Turing reducible to in polynomial time, , such that
    P.

  2. is Post reducible to in polynomial time, , such that .

  3. is conjunctive truth table reducible to in polynomial time, , such that .

  4. is disjunctive truth table reducible to in polynomial time, , such that .

  5. is many-one reducible to in polynomial time, , such that
    .

The following implications hold for all class of languages and :

Another important reduction is the parsimonious reduction between functions that preserve the number of solutions.

Definition 2

Let and be any functions.

  1. is parsimonious reducible to in polynomial time, , such that , where is a total function.

More detailed explanations about different types of reductions can be found in [7] and more peculiar ones are discussed in [28]. It is well known that if a complexity class is closed under some reduction then a class reduced to it under that reduction is a subset of it.

One way to generalize complexity classes is through leaf languages, where language . Then assume that leaf languages and have the property that = , where is the acceptance criterion and is the rejectance criterion of a leaf language class. [23]

Definition 3

A given complexity class is classified as a syntactic complexity class if and only if it has the property that

= .

Definition 4

A given complexity class is classified as a semantic complexity class if and only if it has the property that .

Definition 5

A language is in semantic complexity class UP, as defined in [9], if there exist a polynomial and a polynomial-time predicate such that, for each ,

Definition 6

A language is in semantic complexity class UP, as defined in [5], if there exist a constant , a polynomial and a polynomial-time predicate such that, for each ,

Definition 7

A language is in semantic complexity class FewP, as defined in [14], if there exist polynomials and and a polynomial-time predicate such that, for each ,

Definition 8

A language is in semantic complexity class EP, as defined in [27], if there exist a polynomial and a polynomial-time predicate such that, for each ,

, where

Definition 9

A language is in semantic complexity class Half_P , as defined in [26], if there exist a polynomial and a polynomial-time predicate such that, for each ,

It has been shown that P UP UP FewP EP NP and that P Half_P EP NP.

Definition 10

A language is in syntactic complexity class CP, as defined in [6], if there exist a polynomial and a polynomial-time predicate such that, for each ,

An alternate definition of CP was provided in [17], such that a language is in CP if there exist a FP such that if and only if the total number of accepting paths equals , for every .

Definition 11

A language is in syntactic complexity class ES, as defined in [27], if there exist a polynomial and a polynomial-time predicate such that, for each ,

, where

Definition 12

A language is in syntactic complexity class PP, as defined in [6], if there exist a polynomial and a polynomial-time predicate such that, for each ,

Definition 13

Functional complexity class #P, as defined in [11], counts the total number of accepting paths of a NPTM.

#P = a NPTM .

It was proven in [27, 6] that ES CP PP and in [15] that
P = P.

Definition 14

A language is in syntactic complexity class US, as defined in [12], if there exist a polynomial and a polynomial-time predicate such that, for each ,

Definition 15

A language is in syntactic complexity class P, as defined in [13], if there exist a polynomial and a polynomial-time predicate such that, for each ,

0 (Mod 2)

Definition 16

A language is in semantic complexity class RP, as defined in [10], if there exist a polynomial and a polynomial-time predicate such that, for each ,

where

Definition 17

A language is in semantic complexity class BPP, as defined in [10], if there exist a polynomial and a polynomial-time predicate such that, for each ,

where

where

It was shown that CoNP US CP and that Half_P RP BPP PP. It has been proven in [16] that NP RP.

Definition 18

Polynomial Hierarchy, as defined in [2], for is

,

,

,

,

where and
.

It has been proven in [18] that PH BPP P.

Definition 19

Functional complexity class GapP, as defined in [25], is the difference between total number of accepting and rejecting paths of a NPTM.

GapP = a NPTM .

It can be easily seen that #P GapP. Some complexity classes can also be defined using GapP functions. For example, language is in CP if there exist a GapP such that if and only if for every .

Definition 20

A language is in semantic complexity class SPP, as defined in [25], if there exist a GapP function such that, for each

The acceptance criterion is instead of because if the total number of computation paths are even then the difference between the total number of accepting and rejecting paths cannot be an odd number. SPP is the smallest complexity class that can be defined using GapP functions. It was shown in [25] that , . It was also proven in [25] that , and .

Definition 21

A language is in semantic complexity class WPP, as defined in [25], if there exist a GapP function and a FP function g such that, for each

It was shown in [25] that .

3 Even more complexity classes

3.1 Mersenne Number Satisfiability

Mersenne numbers are named after Marin Mersenne whom began the study of these numbers in the 17 century. A Mersenne number is a positive integer that is one less than a power of two, and consists of all 1 bits in its binary representation. It is well known that if is a prime number then is a prime number as well. The study of Mersenne primes has been an alluring field with the emergence of powerful computers, which can do calculations that would be very-hard for humans to do by hand. There have been 50 Mersenne primes discovered to date and the largest known Mersenne prime is .

Definition 22

A language is in syntactic complexity class MNS if there exist polynomial and a polynomial-time predicate such that, for each ,

, where

Definition 23

Mersenne-Number-SAT

Given a Boolean expression in CNF, is it true that it has Mersenne number of satisfying truth assignments?

Theorem 3.1

Mersenne-Number-SAT is MNS-complete

Proof

Mersenne-Number-SAT is clearly in MNS given the above definition. Completeness follows from the parsimonious reductions in [11] of any problem in #P to #SAT.

Definition 24

A language is in semantic complexity class MNP if there exist polynomial and a polynomial-time predicate such that, for each ,

, where

Definition 25

Promise-Mersenne-Number-SAT

Given a Boolean expression in CNF that is promised to have Mersenne number of satisfying truth assignments or none, does it have Mersenne number of satisfying truth assignments?

We obtain the following inclusions just from the above definitions:

MNP MNS

MNP NP

MNS P = P

3.2 A long lost semantic relative of

A perceptive reader would have noted that two out of the three alternate definitions of that employ #P functions have their own semantic versions, namely Half_P and EP. And by definition . It is not known whether they are equal, although their syntactic versions have been proven to be equal in [27]. We next define the semantic version of the third alternate definition of that also employ #P functions.

Definition 26

A language is in semantic complexity class FP if there exist a polynomial , a polynomial-time predicate and a polynomial time computable function , such that, for each ,

It is not hard to see that we would have still obtained the same complexity class if we had changed the GapP function in the definition of WPP to a # P function.

Definition 27

Promise-Exact-Number-SAT

Given a Boolean expression in CNF that is promised to have many satisfying truth assignments or none, does it have many satisfying truth assignments?

We obtain the following inclusions just from the above definitions:

FewP FP

FP CP

FP WPP

4 Relationship with complexity class FewP

Definition 28

Non-gappy [27]

Let be any set of positive integers. Then is non-gappy if and .

Definition 29

P-printable [31]

Let be any subset of . Then is P-printable if there is a deterministic Turing machine that runs in polynomial-time such that, for every nonnegative integer , prints out the set .

Furthermore, Theorem 3.4 in [27] states that, “Let T be any set of positive integers such that T has a non-gappy, P-printable subset. Then FewP is contained in any complexity class with the acceptance criterion of T and rejectance criterion of zero.”

Theorem 4.1

FewP MNP

Proof

The acceptance criterion of MNP is clearly Non-gappy and P-printable according to the above definitions. Then given Theorem 3.4 in [27], FewP is contained in MNP.

Therefore, FewP MNP.

5 Relationship with complexity class Us

Theorem 5.1

US MNS

Proof

Suppose we have a US machine . We construct machine , that originally has many paths. Then on each one of it’s accepting paths, machine non-deterministically decides to accept on many paths. Then we claim that machine will have a Mersenne number of accepting paths if and only if machine has a single accepting path. To observe that this is true, note that if the number of accepting paths of the original machine is , then must satisfy , where is a positive integer. Thus . The general solution of this equation for is , where is an imaginary number. The first two values of that make an integer (and in fact a real number) are and . Since , this means that will have a Mersenne number of accepting paths if and only if . As a result, machine is a MNS machine.

Therefore, US MNS.

We should note that there are two well known CoNP-complete problems, namely the CNF contradiction and the DNF tautology, where the former asks if no truth assignment satisfies a Boolean expression in CNF and the latter asks if all possible truth assignments satisfies a Boolean expression in DNF. When one was shown to be CoNP-complete, the other was easily shown to be CoNP-complete by simply reversing the accepting and rejecting states of a NPTM. Then by employing the same methodology, we can easily show that Maximum-Mersenne-Number SAT, which asks if a Boolean expression in DNF with variables has many satisfying truth assignments, is US-complete. Note that finding a unique satisfying truth assignment for a Boolean expression in DNF and finding a maximum Mersenne number of satisfying truth assignments for a Boolean expression in CNF are both computable in polynomial time.

6 Relationship with complexity class Pp

In order to prove the following result using a NPTM equipped with a MNS oracle to recognize Majority-SAT, we must overcome a technical difficulty that occurs if the input formula is unsatisfiable. We finesse this problem by initially running a standard NPTM for SAT. And we only begin a new simulation regime and make queries on accepting paths. In this way, we will never make queries if the input is unsatisfiable and we will reject outright.

Theorem 6.1

PP NP

Proof

We show that a NP machine with access to a MNS oracle solves the PP-complete problem Majority-SAT.

Assume that we have an NP machine so that the number of satisfying truth assignments to Boolean expression is equal to the number of accepting paths of on input . Also, assume that has variables and thus has many paths. Then we construct an NP machine with access to oracle MNS. Initially, machine simulates machine on input . If is unsatisfiable then all paths of will reject. On the other hand, if has at least one satisfying truth assignment then will reach a state where would have accepted. At this point, enters a query state to determine if would have accepted on more than half of the paths. Then non-deterministically selects a number from to . After that, for each choice of , we construct another machine that does the following. It non-deterministically chooses to accept on many paths and simulates on the other paths. Then we query the MNS oracle with the Boolean expression and accepts if the query answers .

Observation 1: The fact that we entered the query states implies that the Boolean expression has at least one satisfying truth assignment.

Observation 2: Let have many accepting paths on input . Then has at most many accepting paths by construction. Since by construction as well, then has at least many accepting paths.

Observation 3: has less than many accepting paths for any choice of . The maximum number of accepting paths that can have is when and the original input formula is a tautology. This results in many accepting paths, which equals and is clearly less than .

Observation 4: If then accepts on at most paths. If then for some choice of , will accept on exactly many paths.

From the observations above, the number of accepting paths of lies between and . The only Mersenne number of accepting paths that can have is , which is achieved when . Thus if one of these queries gives the answer then is in Majority-SAT.

Therefore, PP NP.

Lemma 1

P P

It follows from Theorem 4.

Lemma 2

PH P

It follows from Theorem 4 and Toda’s Theorem [18], PH P.

7 Relationship with complexity class P

Theorem 7.1

P NP

Proof

We show that a NP machine with access to a MNS oracle solves the P-complete problem Parity-SAT.

Assume that we have an NP machine so that the number of satisfying truth assignments to the Boolean expression is equal to the number of accepting paths of on input . Also, assume that has variables and thus has many paths. Then we construct an NP machine with access to oracle MNS that on input behaves as follows: It first non-deterministically selects an even number , where . Then we construct a machine that does the following. It non-deterministically chooses to accept on paths and simulates on the other path. Then we query the MNS oracle with the Boolean expression and accepts if the query answers .

If accepts on an even number of paths, then clearly all queries answer no and rejects. If accepts on some odd number of paths, say , then there exists an even , where , such that for some , and thus accepts on Mersenne number of paths. As a result, machine will accept on this query.

Therefore, P NP.

Lemma 3

BPP BPP

It follows from Theorem 5.

Lemma 4

PH BPP

It follows from Theorem 5 and Toda’s Theorem [18], which states that
PH BPP.

However, clearly Lemma 2 is a stronger result than Lemma 4 since
P BPP

Theorem 7.2

MNP P

Proof

We are given a machine that decides some MNP promise problem . If input should be accepted, then machine accepts on a Mersenne number of paths. If input should be rejected, then machine has no accepting paths. Clearly, machine satisfies the criterion for a P machine, since all Mersenne numbers are odd. Therefore, promise problem is in P.

8 Relationship with complexity class CP

It is easy to see that we can revise Theorem 4 and achieve CP NP. However, we can actually do much better.

Theorem 8.1

CP MNS

Proof

Suppose we have a CP machine . We design a MNS machine that accepts the same language as . Assume for ease of presentation that on input our machine has many total paths and thus accepts if and only if it accepts on exactly many paths. We also assume without loss of generality that is sufficiently large. Then machine on input immediately accepts on many paths and simulates the following way: 1) For each of ’s rejecting states, it accepts and 2) For each of ’s accepting states, it accepts on 2 many paths. We claim that accepts if and only if accepts on many paths. We show this with the following three lemmas.

Lemma 5

If accepts on many paths, then accepts on Mersenne number of paths.

If accepts on many paths then accepts on many paths. This expression evaluates to , which simplifies to . Therefore, will accept since is a Mersenne number.

Lemma 6

If accepts on less than many paths, then does not accept on Mersenne number of paths.

Machine will accept on greater than many paths by construction, since it also accepts on rejecting paths. Furthermore, will accept on less than many paths once again by construction. Thus the number of accepting paths of will fall in between two consecutive Mersenne numbers. Therefore, will reject.

Lemma 7

If accepts on more than many paths then does not accept on Mersenne number of paths.

Machine will accept on greater than many paths by construction. Then the maximum number of accepting paths is achieved for when accepts on many paths. In this case, will accept on many paths once again by construction. This expression equals which is less than . Thus the number of accepting paths of will fall in between two consecutive Mersenne numbers. Therefore, will reject.

As shown by the previous three lemmas that the MNS machine accepts if and only if the CP machine accepts.

Therefore, CP MNS.

Theorem 8.2

MNS CP

Proof

We provide a polynomial time disjunctive truth-table reduction from Mersenne-number-SAT to a language in CP. It is well-known that CP is closed under polynomial-time disjunctive truth table reductions, which was proven in [30]. Assume that we have a MNS machine that recognizes Mersenne-number-SAT. Let be an input with variables. We next show the disjunctive truth-table reduction to the canonical CP-complete problem Equal-SAT. Assume that we have a polynomial time machine that carries out the reduction. For each , machine constructs a machine that does the following. It immediately accepts on many paths and rejects on many paths, and also simulates machine . Then for each , we query the Equal-SAT oracle with the Boolean expression and accepts if any of these queries answer .

Therefore, MNS CP .

Corollary 1

MNS CP

Immediate consequence of Theorems 7 and 8.

9 Conclusion

We introduced two new semantic complexity classes and one new syntactic complexity class; and showed their location in the complexity hierarchy. It ended up being the case that MNS actually equals CP

. However, a simple padding argument would have not yielded the result in Theorem 7, that is

CP MNS. What our proof of Theorem 7 actually demonstrates is that given a Boolean expression in CNF with variables, one can in polynomial time construct with variables so that the number of satisfying truth assignments to is guaranteed to lie between and . In fact, will have exactly satisfying truth assignments if and only if was satisfied by exactly half of its assignments.

On the other hand, the relationship between EP and MNP is not so clear other than the fact that their intersection equals UP, that is EP MNP = UP. Although, we can change the acceptance criterion of a MNS machine to be some specific power of two using the methodology in Theorem 7, we cannot necessarily do the same thing with the acceptance criterion of a MNP machine. This is because we would also need to consider the rejection criterion of a MNP machine and the result in Theorem 7 does not yield zero accepting paths when the original machine has zero accepting paths. However, MNP can be viewed as the analog of EP that is contained in P, which EP is not known to be. In fact, a relativized world was shown in [27] such that .

Another interesting question arises with respect to the relationship between FP, and EP and MNP. There does not seem to be a straightforward proof to show any type of inclusion among them. However, it seems more likely that both EP and MNP are contained in FP. Also, is FP contained in P just like MNP; or does there exists a relativized world where FP is not contained in P, just like EP.

Finally, we would like to mention that we attempted to change the base machine in Theorem 5 from NP to RP with no success. We also tried to derive a result just like Theorem 7 between P and MNS, but once again we were not able to do better than NP. However, we do think strongly about the possibility of P RP or even P MNS.

References

  • [1]

    S. Cook, The complexity of theorem proving procedures, Proceedings of the Third Annual ACM Symposium on Theory of Computing, 151-158, 1971.

  • [2] A. Meyer and L. Stockmeyer, The equivalence problem for regular expressions with squaring requires exponential space, In Proceedings of the 13th IEEE Symposium on Switching and Automata Theory, 125-129, 1972.
  • [3] W. J. Savitch, Relationships between nondeterministic and deterministic tape complexities, Journal of Computer and Systems Sciences, 4, 177-192, 1970.
  • [4] R. M. Karp, Reducibility Among Combinatorial Problems, In Raymond E. Miller and James W. Thatcher (editors). Complexity of Computer Computations. New York: Plenum Press, 85-102, 1972.
  • [5] R. Beigel, On the relativized power of additional accepting paths, In the proceedings of the 4th Structure in Complexity Theory Conference, IEEE Computer Society Press, 216-224, 1989.
  • [6] J. Simon, On Some Central Problems of Computational Complexity, 1975, Cornell University Ithaca.
  • [7] R. Ladner and N. Lynch and A. Selman, A comparison of polynomial time reducibilities, Theoretical Computer Science, 103-124, 1975.
  • [8] L. J. Stockmeyer, The polynomial hierarchy, Theoretical Computer Science, 1-22, 1976.
  • [9] L. Valiant, The relative complexity of checking and evaluating, Information Processing Letters, 20-23, 1976.
  • [10] J. Gill, Computational complexity of probabilistic Turing machines, SIAM Journal of Computing, 675-695, 1977.
  • [11] L.G. Valiant, The complexity of computing the permanent, Theoretical Computer Science, 181-201, 1979.
  • [12] A. Blass and Y. Gurevich, On the unique satisfiability problem, Information and control, 80-88, 1982.
  • [13] C.H. Papadimitriou and S. Zachos, Two remarks on the power of Counting, Theoretical Computer Science, 269-275, 1983.
  • [14] E. Allender, The complexity of sparse sets in P, Structure in Complexity Theory, 1-11, 1986.
  • [15] J. Balcazar and R. Book and U. Schoning, The Polynomial-Time Hierarchy and Sparse Oracles, Journal of the Association for Computing Machinery, 603-617, 1986.
  • [16] L.G. Valiant and V. Vazirani, NP is as easy as detecting Unique Solutions, Theoretical Computer Science, 85-93, 1986.
  • [17] K. Wagner, The complexity of combinatorial problems with succinct input representations, Acta Informatica, 225-256, 1986.
  • [18] S. Toda, On the computational power of PP and Parity-P, IEEE FOCS, 514-519, 1989.
  • [19] R. Rubinstein, Structural Complexity Classes of Sparse Sets: Intractability, Data Compression and Printability, 1988, Northeastern University Boston.
  • [20] E. Allender and R. Rubinstein, P-printable sets, SIAM Journal on Computing, 1193-1202, 1988.
  • [21] J.-Y. Cai and L. A. Hemachandra, On the power of parity polynomial time, STACS, 229-240, 1989.
  • [22] R. Beigel and R. Chang and M. Ogiwara, Relationships between nondeterministic and deterministic tape complexities, Mathematical Systems Theory, 293-310, 1993.
  • [23] Christos H. Papadimitriou, Computational Complexity, Addison-Wesley Longman, 1994.
  • [24] R. Beigel and H. Buhrman and L. Fortnow, NP might not be as easy as detecting unique solutions, In Proceedings of the 30th ACM Symposium on Theory of Computing, 203-208, 1998.
  • [25] S. Fenner and L. Fortnow and S. Kurtz, Gap Definable counting classes, Journal of Computer and System Sciences, 116-148, 1994.
  • [26] A. Berthiaume and G. Brassard, The quantum challenge to structural complexity theory, Proceedings of Structure in Complexity Theory, 132-137, 1992.
  • [27] B. Borchert and L. Hemaspaandra and J. Rothe, Restrictive Acceptance Suffices for Equivalance Problems, LMS J Comput. Math, 86-95, 2000.
  • [28] Lane A. Hemaspaandra and Mitsunori Ogihara, The Complexity Theory Companion, Springer, 2002.
  • [29] J. Simon, On the difference between one and many, 4th Colloq. on Automata, Languages and Programming, 1977.
  • [30] R. Beigel and R. Chang and M. Ogiwara, A relationship between difference hierarchies and relativized polynomial hierarchies, Mathematical Systems Theory, 293-310, 1993.
  • [31] J. Hartmanis and Y. Yesha, Computation times of NP sets of different densities, Theoretical Computer Science, 17-32, 1984.
  • [32] M.R. Garey and D. S. Johnson, Computers and Intractability, 1979.