FRANK VEGA Computational Complextiy Sparse complete sets for coNP: Solution of the P versus NP problem Frank Vega March 4, 2019 Abstract: P versus NP is considered as one of the most important open problems in computer science. This consists in knowing the answer of the following question: Is P equal to NP? A precise statement of the P versus NP problem was introduced independently by Stephen Cook and Leonid Levin. Since that date, all efforts to find a proof for this problem have failed. Another major complexity class is coNP. Whether NP = coNP is another fundamental question that it is as important as it is unresolved. In 1979, Fortune showed that if any sparse language is coNP-complete, then P = NP. We prove there is a possible sparse language in coNP-complete. In this way, we demonstrate the complexity class P is equal to NP. 1 Introduction The P versus NP problem is a major unsolved problem in computer science [6]. This is considered by many to be the most important open problem in the field [6]. It is one of the seven Millennium Prize Problems selected by the Clay Mathematics Institute to carry a US$1,000,000 prize for the first correct solution [6]. It was essentially mentioned in 1955 from a letter written by John Nash to the United States National Security Agency [1]. However, the precise statement of the P = NP problem was introduced in 1971 by Stephen Cook in a seminal paper [6]. ACM Classification: F.1.3.3, F.1.3.2 AMS Classification: 68Q15, 68Q17 Key words and phrases: complexity classes, complement language, sparse, completeness, polynomial time FRANK VEGA In 1936, Turing developed his theoretical computational model [19]. The deterministic and nondeter- ministic Turing machines have become in two of the most important definitions related to this theoretical model for computation [19]. A deterministic Turing machine has only one next action for each step defined in its program or transition function [19]. A nondeterministic Turing machine could contain more than one action defined for each step of its program, where this one is no longer a function, but a relation [19]. Another relevant advance in the last century has been the definition of a complexity class. A language over an alphabet is any set of strings made up of symbols from that alphabet [7]. A complexity class is a set of problems, which are represented as a language, grouped by measures such as the running time, memory, etc [7]. In the computational complexity theory, the class P contains those languages that can be decided in polynomial time by a deterministic Turing machine [13]. The class NP consists in those languages that can be decided in polynomial time by a nondeterministic Turing machine [13]. The biggest open question in theoretical computer science concerns the relationship between these classes: Is P equal to NP? In 2012, a poll of 151 researchers showed that 126 (83%) believed the answer to be no, 12 (9%) believed the answer is yes, 5 (3%) believed the question may be independent of the currently accepted axioms and therefore impossible to prove or disprove, 8 (5%) said either do not know or do not care or don’t want the answer to be yes nor the problem to be resolved [12]. It is fully expected that P 6= NP [18]. Indeed, if P = NP then there are stunning practical consequences [18]. For that reason, P = NP is considered as a very unlikely event [18]. Certainly, P versus NP is one of the greatest open problems in science and a correct solution for this incognita will have a great impact not only for computer science, but for many other fields as well [1]. Whether P = NP or not is still a controversial and unsolved problem [1]. In this work, we proved the complexity class P is equal to NP. Hence, we solved one of the most important open problems in computer science. 2 Basic Definitions Let S be a finite alphabet with at least two elements, and let S∗ be the set of finite strings over S [2]. A Turing machine M has an associated input alphabet S [2]. For each string w in S∗ there is a computation associated with M on input w [2]. We say that M accepts w if this computation terminates in the accepting state, that is M(w) = “yes” [2]. Note that M fails to accept w either if this computation ends in the rejecting state, that is M(w) = “no”, or if the computation fails to terminate [2]. The language accepted by a Turing machine M, denoted L(M), has an associated alphabet S and is defined by L(M) = fw 2 S∗ : M(w) = “yes”g: We denote by tM(w) the number of steps in the computation of M on input w [2]. For n 2 N we denote by TM(n) the worst case run time of M; that is n TM(n) = maxftM(w) : w 2 S g where Sn is the set of all strings over S of length n [2]. We say that M runs in polynomial time if there is k a constant k such that for all n, TM(n) ≤ n + k [2]. In other words, this means the language L(M) can be FRANK VEGA 2 P VS NP accepted by the Turing machine M in polynomial time. Therefore, P is the complexity class of languages that can be accepted in polynomial time by deterministic Turing machines [7]. A verifier for a language L is a deterministic Turing machine M, where L = fw : M(w;c) = “yes” for some string cg: We measure the time of a verifier only in terms of the length of w, so a polynomial time verifier runs in polynomial time in the length of w [2]. A verifier uses additional information, represented by the symbol c, to verify that a string w is a member of L. This information is called certificate. NP is also the complexity class of languages defined by polynomial time verifiers [18]. If NP is the class of problems that have succinct certificates, then the complexity class coNP must contain those problems that have succinct disqualifications [18]. That is, a “no” instance of a problem in coNP possesses a short proof of its being a “no” instance [18]. A function f : S∗ ! S∗ is a polynomial time computable function if some deterministic Turing machine M, on every input w, halts in polynomial time with just f (w) on its tape [19]. Let f0;1g∗ be the ∗ infinite set of binary strings, we say that a language L1 ⊆ f0;1g is polynomial time reducible to a language ∗ ∗ ∗ L2 ⊆ f0;1g , written L1 ≤p L2, if there is a polynomial time computable function f : f0;1g ! f0;1g such that for all x 2 f0;1g∗, x 2 L1 if and only if f (x) 2 L2: An important complexity class is NP–complete [13]. A language L ⊆ f0;1g∗ is NP–complete if • L 2 NP, and 0 0 • L ≤p L for every L 2 NP. 0 0 If L is a language such that L ≤p L for some L 2 NP–complete, then L is NP–hard [13]. Moreover, if L 2 NP, then L 2 NP–complete [13]. A principal NP–complete problem is HAM–CYCLE [7]. A simple graph is an undirected graph without multiple edges or loops [7]. An instance of the language HAM–CYCLE is a simple graph G = (V;E) where V is the set of vertices and E is the set of edges, each edge being an unordered pair of vertices [7]. We say (u;v) 2 E is an edge in a simple graph G = (V;E) where u and v are vertices. For a simple graph G = (V;E) a simple cycle in G is a sequence of distinct vertices hv0;v1;v2;:::;vki such that (vk;v0) 2 E and (vi−1;vi) 2 E for i = 1;2;:::;k [7]. A Hamiltonian cycle is a simple cycle of the simple graph which contains all the vertices of the graph. A simple graph that contains a hamiltonian cycle is said to be hamiltonian; otherwise, it is nonhamiltonian [7]. The problem HAM–CYCLE asks whether a simple graph is hamiltonian [7]. 3 Summary In computational complexity theory, a sparse language is a formal language (a set of strings) such that the complexity function, counting the number of strings of length n in the language, is bounded by a polynomial function of n. The complexity class of all sparse languages is called SPARSE. SPARSE contains TALLY, the class of unary languages, since these have at most one string of any one length. FRANK VEGA 3 FRANK VEGA Fortune showed in 1979 that if any sparse language is coNP–complete, then P = NP (this is Fortune’s theorem) [10]. Mahaney used this to show in 1982 that if any sparse language is NP–complete, then P = NP [15]. A simpler proof of this based on left-sets was given by Ogihara and Watanabe in 1991 [17]. Mahaney’s argument does not actually require the sparse language to be in NP, so there is a sparse NP–hard set if and only if P = NP [15]. We create a class with the opposite definition, that is a class of languages that are dense instead of sparse. We show there is a sequence of languages that are in NP–complete, but their density grows as much as we go forward into the iteration of the sequence.