P versus NP problem

src: i.ytimg.com

The problem P versus NP is a major unsolved problem in computer science. It asks if any problem whose solution can be quickly verified (technically, verified in polynomial time) can also be resolved quickly (again, in polynomial time).

The underlying issues were first discussed in the 1950s, in letters from John Forbes Nash Jr. to the National Security Agency, and from Kurt GÃÆ'¶del to John von Neumann. The exact statement of the problem of P versus NP was introduced in 1971 by Stephen Cook in his seminal paper "The complexity of the theorem that proves the procedure" (and independently by Leonid Levin in 1973) and is considered by many to be the most important open matter in the field. This is one of the seven Millennium Gift Issues selected by the Clay Mathematics Institute to bring the US $ 1,000,000 prize for the first true solution.

The informal term quickly , used above, means an algorithm that accomplishes a task that runs in polynomial time, so the time to complete the task varies as a polynomial function on the input size to the algorithm (as opposed to, say, exponential time ). The general class of questions that some algorithms can provide in polynomial time is called "class P " or just " P ". For some questions, there is no known way to find answers quickly, but if someone is given information that indicates the answer, it is possible to verify the answer quickly. The class of questions whose answers can be verified in polynomial time is called NP , which means "non-deterministic polynomial time".

Consider Sudoku, an example of a problem that is easily verified, but the answer may be difficult to quantify. With the partially filled network of Sudoku, of any size, is there at least one legal solution? The proposed solution is easy to verify, and the time to check the solution grows slowly (polynomial) when the grid gets bigger. However, all known algorithms for finding solutions take, for a difficult example, time that grows exponentially when the grid gets bigger. So Sudoku is on NP (quick to check) but it does not seem to exist in P (quickly solved). Thousands of other problems seem similar, quick to check but slow to solve. Researchers have shown that a quick solution to one of these problems can be used to build a quick solution for all the others, a property called NP -completeness. The decade of search has not produced a quick solution to these problems, so most scientists suspect that none of these problems can be solved quickly. This, however, was never proven.

The answer to the P Ã, = Ã, NP question will determine whether the problem that can be verified in polynomial time, such as Sudoku, can also be resolved in polynomial time. If it turns out P Ã,? NP , that means there is a problem in NP that is more difficult to compute than verify: they can not be resolved in polynomial time, but the answer can be verified in polynomial time.

In addition to being an important issue in computational theory, good evidence of the way will have profound implications for mathematics, cryptography, algorithmic research, artificial intelligence, game theory, multimedia processing, philosophy, economics and many other fields.

Video P versus NP problem

Histori

Although the P versus NP problem was formally defined in 1971, there were prior problems involving problems, evidentiary difficulties, and potential consequences. In 1955, mathematician John Nash wrote a letter to the NSA, where he speculated that a fairly complex code breakdown would require an exponential time in key lengths. If proven (and Nash is skeptical accordingly) this would imply what we would today call P Ã,? Ã, NP , since the proposed key can be easily verified in polynomial time. Another mention of the underlying problem occurred in a 1956 letter written by Kurt GÃÆ'¶del to John von Neumann. GÃÆ'¶del asks if proving the theorem (now known as co-NP-complete) can be completed in quadratic or linear time, and shows one of the most important consequences - that if so, then the discovery of mathematical proof can be automatic.

Maps P versus NP problem

Context

The relationship between the complexity classes P and NP is studied in the theory of computational complexity, part of computational theory related to the resources required during computation to solve a given problem. The most common resources are time (how many steps are needed to solve the problem) and space (how much memory is needed to solve the problem).

In the analysis, the computer model of which time should be analyzed is required. Usually the model assumes that the computer is deterministic (given the current state of the computer and any input, there is only one possible action computer might perform) and sequential (it performs a single action after another).

In this theory, the P class consists of all decision problems (defined below) that can be solved on a deterministic sequential machine in the amount of time that is polynomial in input size; the NP class consists of all decision issues whose positive solutions can be verified in polynomial time given exact, or equivalent, information whose solutions can be found in polynomial time on a non-deterministic machine. Obviously, P ? NP . Arguably the greatest open question in theoretical computer science concerns the relationship between two classes:

Is P the same as NP ?

In a 2002 poll of 100 researchers, 61 believed that no answer, 9 believed that the answer was yes, and 22 was not sure; 8 believes the question may be independent of the accepted axioms currently and therefore impossible to prove or not to prove.

In 2012, 10 years later, the same poll is repeated. The number of researchers who answered was 151: 126 (83%) believed the answer was no, 12 (9%) believed the answer was yes, 5 (3%) believed the question might be independent of the accepted axioms and therefore impossible to prove or disprove , 8 (5%) say either do not know or do not care or do not want the answer to be yes or problem to be solved.

src: i.ytimg.com

NP-completeness

To attack the P = NP , the NP -completeness is very useful. NP -a complete problem is a set of problems that each of the other NP issues can be reduced in polynomial time, and solutions that can still be verified in polynomial time. This means that any NP issue can be turned into a NP issue-any of the tools. Informally, the NP -complete problem is a NP problem that is at least as "difficult" like any other problem in NP .

NP - a tough problem is a problem that is as strong as NP , that is, all NP issues can be reduced (in polynomial time) to them. NP -not difficult to find in NP , i.e., they do not need to have a verifiable solution in polynomial time.

For example, Boolean satisfaction issues are NP -complete by the Cook-Levin theorem, so every example of any example can be mechanically changed to an instance of Boolean satisfaction problems in polynomial time. The problem of Boolean satisfaction is one of the many problems like NP . If there is a NP problem in P then it will follow P = NP . However, many important issues have been shown as NP -complete, and there is no fast algorithm for one that is known.

By definition alone it is not clear that there are problems that NP exists; however, the complicated and artificial problems of NP can be formulated as follows: given a description of the Turing M machine that is guaranteed to stop in polynomial time, is there an input of polynomial size to be received by M? It's in NP because (given input), it's easy to check whether M accepts inputs by simulating M; this NP -komplete because the verifier for each specific instance of the problem in NP can be encoded as a polynomial-time machine M that takes the solution to be verified as input. Then the question of whether the instance is a yes or no instance is determined by whether there is a valid input.

The first natural problem that proved NP -complete is a Boolean satisfaction issue. As mentioned above, this is the Cook-Levin theorem; the proof that satisfiability is NP -complete contains technical details about the Turing machine because they correspond to the NP definition. However, once the problem is proven NP -incomplete, the proof by reduction provides a simpler way to show that many other problems are also NP -incomplete, including the Sudoku discussed earlier. In this case, the evidence shows that the Sudoku solution in polynomial time, can also be used to solve the Latin box in polynomial time. This in turn provides a solution to the problem of partitioning tri-partite graphs into triangles, which can then be used to find solutions for 3-sat, which then provide solutions to common boolean satisfaction. Thus the polynomial time solution for Sudoku leads, by a series of mechanical transformations, to a satisfactory polynomial time solution, which in turn can be used to solve other NP-complete problems in polynomial time. Using transformations like this, large classes of seemingly unrelated problems can all be reduced to each other, and in the sense of "the same problem".

src: i.ytimg.com

A more difficult issue

Although it is not known whether P = NP , issues outside P are known. A number of concise problems (problems that do not operate on the normal input, but on computational descriptions of inputs) are known as EXPTIME -complete. Because it can be shown that P ? EXPTIME , this issue is outside P , so it takes more than polynomial time. In fact, at the time of the hierarchical theorem, they can not be solved significantly less than the exponential time. Examples include finding the perfect strategy for chess (on board N ÃÆ'â € " N ) and some other board games.

The problem of deciding the truth of the statement in the Presburger arithmetic takes more time. Fischer and Rabin proved in 1974 that any algorithm that decides the truth of a Presburger statement with a length of n has at least runtime ${\ displaystyle 2 ^ {2 ^ {cn}}}$ for some constants c . Therefore, known problems require more than exponential running time. Even more difficult is the problem that can not be decided, such as the problem of halting. They can not be completely resolved by any algorithm, in that for any given algorithm there is at least one input that the algorithm will not produce the correct answer; it will produce wrong answers, finish without giving conclusive answers, or otherwise run forever without producing an answer at all.

It is also possible to consider questions other than decision issues. One such class, which consists of counting problems, is called #P : while the problem NP asks "Is there a solution?", As appropriate #P problem asking "How many solutions are there?" Obviously, the #P problem should be at least as hard as the NP problem, since the solution count immediately notifies if at least one solution exists, if the count is greater than zero. Surprisingly, some #P issues are believed to be difficult according to an easy problem (eg linear-time) P . For this problem, it is very easy to know if the solution exists, but it is considered very difficult to say how much. Many of these problems are # P-complete , and therefore among the most difficult issues in #P , since polynomial time solutions to one of them will allow polynomial time solutions for all other #P issues.

src: i.ytimg.com

Issues in NP are not known on P or NP-complete

Is it shown by Ladner that if P ? NP then there is a problem in NP which is not in both P and NP -completion. Such a problem is called NP -integrate the issue. Graphic isomorphism problems, discrete logarithmic problems and integer factorization problems are examples of problems believed to be NP -intermediate. They are some of the very few NP unknown unknowns in P or being complete NP .

The problem of graph isomorphism is a computational problem to determine whether two finite graphs are isomorphic. An important problem that has not been resolved in the theory of complexity is whether the graph isomorphism problem in P , NP -komplete, or NP -intermediate. The answer is unknown, but it is believed that the problem is at least not NP -komplete. If the isomorphism graph is NP -komplete, the polynomial time hierarchy collapses to the second level. Because it is widely believed that the polynomial hierarchy does not collapse to a finite degree, it is believed that the graph isomorphism is not NP -komplete. The best algorithm for this problem, since LÃÆ'¡szlÃÆ'³ Babai and Eugene Luks, has run time 2 ^{O (? n log n )} for the graph with the n node.

The problem of integrating factorization is a computational problem for determining prime factorization of a given integer. Taken as a decision issue, it is a matter of deciding whether the input has a factor less than k . No efficient integer factorization algorithm is known, and this fact forms the basis of some modern cryptographic systems, such as the RSA algorithm. The integer factorization problem is in NP and in co-NP (and even in UP and co-UP ). If the problem is NP -complete, the polynomial time hierarchy will collapse to the first level (ie NP = co-NP ). The most well known algorithm for number factorization is the common field number filter, which takes the expected time

${\ displaystyle O \ left {\ exp \ left {\ left {{tfrac {64n} {9}} \ log (2) \ right) ^ {\ frac {1} {3}} \ left (\ log (n \ log (2)) \ right) ^ {\ frac {2} {3}} \ right) \ right)}$

src: shroud-physics.com

Logical characterization

P = NP problems can be restated in case certain classes are declared logical reports, as a result of work in descriptive complexity.

Consider all languages ​​of finite structure with fixed signatures including linear sequence relationships. Then, all such languages ​​in P can be expressed in first-order logic with the addition of a suitable fixed-point combiner. Effectively, this, in combination with the order, allows the definition of a recursive function. As long as the signature contains at least one predicate or function other than a distinguishable sequence relationship, so that the amount of space taken to store such finite structures is actually a large number in the number of elements in the structure, this precisely characterizes P .

Similarly, NP is a collection of languages ​​that can be expressed in the logic of the second existential order - that is, second-order logic is restricted to exclude the universal quantification of relationships, functions, and subsets. The language in the polynomial hierarchy, PH , corresponds to all second-order logic. Thus, the question "is P an appropriate subset of NP " can be reformulated as "is an existential second-order logic capable of describing language (structures that are linearly arranged and limited with nontrivial signatures) that first-order logic with a fixed point can at least be? ". The word "existential" can even be derived from the previous characterization, since P = NP if and only if P = PH (as before will specify that NP = co-NP , which in turn implies that NP = PH ).

src: i.ytimg.com

time-polynomial algorithm

There is no algorithm for any NP known problems running in polynomial time. However, there is a known algorithm for NP -problems with a property that if P = NP , then the algorithm runs in polynomial time at the receipt of an example though with a very large constellation, makes the algorithm impractical). However, this algorithm does not qualify as a polynomial time because their running time in rejecting the instance is not polynomial. The following algorithm, because Levin (without quotation), is an example below. This correctly accepts the NP -full SUBSET-SUM language. It runs in polynomial time at the input in SUBSET-SUM if and only if P = NP :

 //Algorithm that receives  NP  -full SUBSET-SUM language.   //   This is a polynomial algorithm if and only if  P  =  NP .   //  //"Polynomial-time" means restoring "yes" in polynomial time when   //the answer should be "yes", and runs forever when it is "no".   //  //Input: S = a set of unlimited integers   //Output: "yes" if any part of S adds up to 0.   //Run forever without output instead.   //Note: "Program number P" is a program obtained by   //write integer P in binary, then   //consider the bit string to be   //program. Every program might be   //is generated this way, though most do nothing   //because of syntax errors.   FOR N = 1...?  FOR P = 1... N  Â Â Â Â Run the program number P for step N with input S  Â Â Â Â IF program releases different integers list  Â Â Â Â Â Â Â AND integers all in S  Â Â Â Â Â Â AND number of integers to 0  Â Â Â Â THEN  Â Â Â Â Â Â OUTPUT "yes" and HALT  

If, and only if, P = NP , then this is a polynomial-time algorithm that receives a NP -faster language. "Receiving" means giving a "yes" answer in polynomial time, but being left forever when the answer is "no" (also known as semi-algorithm ).

This algorithm is not very practical, even if P = NP . If the shortest program that can complete SUBSET-SUM in polynomial time is b long bit, the above algorithm will try at least 2 ^b -1 other program first.

src: slideplayer.com

Formal definition

P and NP

Conceptually speaking, the decision problem is a problem that takes as input some strings w over the alphabet ?, and outputs "yes" or "no". If there is an algorithm (eg Turing machine, or computer program with unlimited memory) that can generate the correct answer for each input string with n the most cn ^k steps, where k and c are independent constants of the input string, then we say that the problem can be solved in polynomial time > and we placed it in P class. Formally, P is defined as the set of all languages ​​that can be decided by a deterministic time-polynomial Turing machine. It is,

${\ displaystyle \ mathbf {P} = \ {L: L = L (M) {\ text {for some polynomial-time deterministic Turing machines}} \}}$

dimana

${\ displaystyle L (M) = \ {w \ in \ Sigma ^ {*}: M {\ text {accepts}} w \}}  ÂÂ$

dan mesin Turing polinomial-deterministik-waktu adalah mesin Turing deterministik M yang memenuhi dua kondisi berikut:

1. M berhenti pada semua input w dan
2. ada ${\ displaystyle k \ in N}  ÂÂ$ sehingga ${\ displaystyle T_ {M} (n) \ dalam O (n ^ {k})}  ÂÂ$ , di mana O mengacu pada notasi O besar dan

${\ displaystyle T_ {M} (n) = \ max \ {t_ {M} (w): w \ in \ Sigma ^ {*}, | w | = n \}}  ÂÂ$

${\ displaystyle t_ {M} (w) = {\ teks {jumlah langkah}} M {\ text {dibutuhkan untuk berhenti pada input}} w.}  ÂÂ$

NP can be defined the same using a nondeterministic Turing machine (traditional way). However, the modern approach to defining NP is to use the certificate and verifier concepts. Formally, NP is defined as a collection of languages ​​over a finite alphabet that has verifiers running in polynomial time, where the idea of ​​"verifier" is defined as follows.

Let L be a language above a limited alphabet,?

The Turing machine that L _R is called verifier for L and y like that ( x , y )? R is called the membership certificate x at L .

In general, the verifier does not have to be a polynomial time. However, for L to be in NP , there must be a verifier running in polynomial time.

Example

Membiarkan

${\ displaystyle \ mathrm {COMPOSITE} = \ kiri \ {x \ dalam \ mathbb {N} \ mid x = pq {\ text {for integers}} p, q & gt; 1 \ right \}}  ÂÂ$

${\ displaystyle R = \ left \ {(x, y) \ in \ mathbb {N} \ times \ mathbb {N} \ mid 1 & lt; y \ leq {\ sqrt {x}} {\ text {and}} y {\ text {divides}} x \ right \}.}  ÂÂ$

Obviously, the question whether given x is composite is equivalent to the question whether x is a member of COMPOSITE. Can it be shown that COMPOSITE? NP by verifying that it meets the above definition (if we identify the original number with their binary representation).

COMPOSITE is also in P .

NP-completeness

There are many equal ways to describe a NP tool.

Let L be a language above a limited alphabet?

L adalah NP -lengkap jika, dan hanya jika, dua kondisi berikut dipenuhi:

1. L ? NP ; dan
2. sembarang L? dalam NP adalah polinomial-waktu yang dapat direduksi menjadi L (ditulis sebagai ${\ displaystyle L '\ leq _ {p} L}  ÂÂ$ ), di mana ${\ displaystyle L '\ leq _ {p} L}  ÂÂ$ jika, dan hanya jika, dua kondisi berikut dipenuhi:
   1. Ada f Â:? * ->? * seperti itu untuk semua w di? * yang kita miliki:                         (          w         ?                     L           ?                   <=>          f          (          w         )         ?          L         )                  {\ displaystyle (w \ in L '\ Leftrightarrow f (w) \ in L)}    ; dan
   2. ada mesin Turing polinomial-waktu yang berhenti dengan f ( w ) pada rekamannya pada input apa pun w .

Or, if L ? NP , and there is another problem NP -complete that can be reduced polynomial time to L , then L is NP - complete. This is a common way to prove some new issues are NP -complete.

Popular culture

Source of the article : Wikipedia