P versus NP Frank Vega

To cite this version:

Frank Vega. P versus NP. 2018. ￿hal-01925735￿

HAL Id: hal-01925735 https://hal.archives-ouvertes.fr/hal-01925735 Preprint submitted on 17 Nov 2018

HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. P versus NP

Frank Vega

Joysonic, Belgrade, Serbia [email protected]

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 in 1971 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 FP. We show a problem that is not in FP. Under the assumption of P = NP, we prove the membership of this problem in FP is also hold. In this way, we demonstrate the complexity class P is not equal to NP by the reduction ad absurdum rule.

Keywords: Complexity Classes · Minimum · Polynomial Time · Boolean Circuit · Function Problem.

1 Introduction

The P versus NP problem is a major unsolved problem in computer science [3]. This is considered by many to be the most important open problem in the field [3]. 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 [3]. 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 [3]. In 1936, Turing developed his theoretical computational model [9]. The de- terministic and nondeterministic Turing machines have become in two of the most important definitions related to this theoretical model for computation [9]. A deterministic Turing machine has only one next action for each step defined in its program or transition function [9]. 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 [9]. 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 [4]. A complexity class is a set of problems, which are represented as a language, grouped by measures such as the running time, memory, etc [4]. In the computational complexity theory, the class P contains those languages that can be decided in polynomial time by a deterministic Turing machine [7]. The class NP consists in those languages that can be decided in polynomial time by a nondeterministic Turing machine [7]. 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 [6]. It is fully expected that P 6= NP [1]. Indeed, if P = NP then there are stunning practical consequences [1]. For that reason, P = NP is considered as a very unlikely event [1]. Certainly, P versus NP is one of the greatest still 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]. In this work, we prove the complexity class P is not equal to NP .

2 Basic Definitions

Let Σ be a finite alphabet with at least two elements, and let Σ∗ be the set of finite strings over Σ [2]. A Turing machine M has an associated input alphabet Σ [2]. For each string w in Σ∗ 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 as- sociated alphabet Σ and is defined by

L(M) = {w ∈ Σ∗ : M(w) = “yes”}.

We denote by tM (w) the number of steps in the computation of M on input w [2]. For n ∈ N we denote by TM (n) the worst case running time of M; that is

n TM (n) = max{tM (w): w ∈ Σ } where Σn is the set of all strings over Σ of length n [2]. The notations we use to describe the asymptotic running time of an algorithm are defined in terms of functions whose domains are the set of natural numbers [4]. Such notations are convenient for describing the worst and better case running time functions, which is usually defined only on integer input sizes [4]. For a given function g(n), we denote by Ω(g(n)) the set of functions

Ω(g(n)) = {f(n): There exist positive constants c and n0 such that

0 ≤ c × g(n) ≤ f(n) for all n ≥ n0}. Ω-notation provides an asymptotic lower bound [4]. We say that M runs in k polynomial time if there is a constant k such that for all n, TM (n) ≤ n + k [2]. In other words, this means the language L(M) can be 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 [4]. A verifier for a language L is a deterministic Turing machine M, where

L = {w : M(w, c) = “yes” for some string c}.

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 [8]. If NP is the class of problems that have succinct certificates, then the complexity class coNP must contain those problems that have succinct disqualifications [8]. That is, a “no” instance of a problem in coNP possesses a short proof of its being a “no” instance [8]. The function problem associated with a language L, denoted FL, is the following computational problem: Given x, find a string y such that M(x, y) = “yes” if such string exists, otherwise return “no” where M is a verifier [8]. The class of all function problems associated in this way with languages in NP such that the verifier is a polynomial time verifier is called FNP [8]. FP is the subclass resulting if we only consider function problems in FNP that can be solved in polynomial time [8].

3 Results

Definition 1. MINIMUM INSTANCE: A natural number n = 2m and a function f : {0, 1, 2, . . . , n − + 1} → Z0 where m is a natural number. QUESTION: Find a positive integer 0 ≤ i ≤ n − 1 such that there is no a positive integer 0 ≤ j ≤ n − 1 where f(j) < f(i) and i 6= j.

Lemma 1. MINIMUM ∈ Ω(n − 1).

Proof. How many comparisons are necessary to determine the minimum of a set of n = 2m elements where m is a natural number? We can easily obtain an upper bound of n − 1 comparisons: Examine each element of the set in turn and keep track of the smallest element seen so far [4]. In this problem, we assume that the set resides in the function f. Our algorithm will be as follows:

1. min = f(0) 2. i = 0 3. for j ← 1 to n − 1 4. do if min > f(j) 5. then min = f(j) 6. i = j 7. return i.

Is this the best we can do? Yes, since we can obtain a lower bound of n − 1 comparisons for the problem of determining the minimum [4]. Think of any algorithm that determines the minimum as a tournament among the elements [4]. Each comparison is a match in the tournament in which the smaller of the two elements wins [4]. The key observation is that every element except the winner must lose at least one match [4]. Hence, n − 1 comparisons are necessary to determine the minimum, and the algorithm above is optimal with respect to the number of comparisons performed [4]. Finding the value of i, of course, be accomplished with n − 1 comparisons as well, since it is equivalent to find the minimum.

Definition 2. SUCCINCT–MINIMUM INSTANCE: A natural number n = 2m and a Boolean circuit C with m input gates and k arbitrary output gates which succinctly represents a function + f : {0, 1, 2, . . . , n − 1} → Z0 such that on the input 0 ≤ i ≤ n − 1 we obtain the output C(i) is equal to the positive integer f(i) where m and k are natural numbers. QUESTION: Find a positive integer 0 ≤ i ≤ n − 1 such that there is no a positive integer 0 ≤ j ≤ n − 1 where f(j) < f(i) and i 6= j.

Theorem 1. SUCCINCT–MINIMUM ∈/ FP .

Proof. By definition the Boolean circuit C is a succinct representation of a func- + m tion f : {0, 1, 2, . . . , n − 1} → Z0 where n = 2 and m is the number of input gates of C. We know by the Lemma 1, the problem MINIMUM complies with MINIMUM ∈ Ω(2m − 1). Since SUCCINCT–MINIMUM contains the instances of MINIMUM which are represented by succinct Boolean circuits, then SUCCINCT–MINIMUM ∈ Ω(2m − 1). However, the size of the Boolean circuit C is polynomially bounded by m for a feasible constant as exponent because of the definition of a succinct representation of the function f [8]. Cer- tainly, SUCCINCT–MINIMUM is nothing else but the instances of the language MINIMUM which can be represented by an exponentially more succinct input in relation to f [8]. Hence, we have SUCCINCT–MINIMUM ∈/ FP , because of the running time Ω(2m − 1) is not polynomially bounded by m for a feasible constant as exponent.

Theorem 2. If P = NP , then SUCCINCT–MINIMUM ∈ FP .

Proof. There is problem that belongs to coNP which consists of knowing given an instance SUCCINCT–MINIMUM whether a positive integer 0 ≤ i ≤ n − 1 complies with there is no a possible positive integer 0 ≤ j ≤ n − 1 where f(j) < f(i) and i 6= j. Certainly, we can check in polynomial time a disqualification that is a positive integer 0 ≤ j0 ≤ n − 1 where f(j0) < f(i) and i 6= j0. Indeed, we can find f(i) and f(j0) evaluating i and j0 in C and check later whether f(j0) < f(i) in polynomial time. If P = NP , then P = coNP [8]. In this way, there is a polynomial time verifier that checks given an instance SUCCINCT–MINIMUM and a positive integer 0 ≤ i ≤ n − 1 whether there is no a positive integer 0 ≤ j ≤ n−1 where f(j) < f(i) and i 6= j. Consequently, due to the existence of this polynomial time verifier we obtain SUCCINCT–MINIMUM ∈ FNP . If P = NP , then FP = FNP [8]. Hence, if P = NP then SUCCINCT–MINIMUM ∈ FP . Theorem 3. P 6= NP . Proof. This is a direct consequence of Theorems 1 and 2: Since by a contrapo- sition of Theorem 2 we have if SUCCINCT–MINIMUM ∈/ FP then P 6= NP and thus, this is confirmed by Theorem 1 which states that SUCCINCT–MINIMUM ∈/ FP is true.

4 Conclusions This proof explains why after decades of studying the NP problems no one has been able to find a polynomial time algorithm for any of more than 300 important known NP–complete problems [5]. Indeed, it shows in a formal way that many currently mathematically problems cannot be solved efficiently, so that the attention of researchers can be focused on partial solutions or solutions to other problems. Although this demonstration removes the practical computational benefits of a proof that P = NP , it would represent a very significant advance in computa- tional complexity theory and provide guidance for future research. In addition, it proves that could be safe most of the existing cryptosystems such as the public- key cryptography [7]. On the other hand, we will not be able to find a formal proof for every theorem which has a proof of a reasonable length by a feasible algorithm.

References 1. Aaronson, S.: P ? NP. Electronic Colloquium on Computational Complexity, Report No. 4 (2017) 2. Arora, S., Barak, B.: Computational complexity: a modern approach. Cambridge University Press (2009) 3. Cook, S.A.: The P versus NP Problem (April 2000), at http://www.claymath.org/ sites/default/files/pvsnp.pdf 4. Cormen, T.H., Leiserson, C.E., Rivest, R.L., Stein, C.: Introduction to Algorithms. The MIT Press, 3rd edn. (2009) 5. Garey, M.R., Johnson, D.S.: Computers and Intractability: A Guide to the Theory of NP-Completeness. San Francisco: W. H. Freeman and Company, 1 edn. (1979) 6. Gasarch, W.I.: Guest column: The second P ? NP poll. ACM SIGACT News 43(2), 53–77 (2012) 7. Goldreich, O.: P, NP, and NP-Completeness: The basics of computational complex- ity. Cambridge University Press (2010) 8. Papadimitriou, C.H.: Computational complexity. Addison-Wesley (1994) 9. Sipser, M.: Introduction to the Theory of Computation, vol. 2. Thomson Course Technology Boston (2006)