    Separation of P and NP

There have been many attempts to solve the P versus NP problem. However, with a new proof method, already used in arXiv:2104.14316, P not equal NP can be proved. A time limit is set for an arbitrary Turing machine and an input word is rejected on a timeout. The time limit goes toward infinity. Due to the halting problem, whether a word is accepted can only be determined at runtime. It can be shown by Rice's theorem, if a finite set of words are to be checked, they all have to be tested by brute force.

Authors

04/28/2021

Separation of PSPACE and EXP

This article shows that PSPACE not equal EXP. A simple but novel proof t...
04/30/2018

07/08/2019

Proof compression and NP versus PSPACE. Part 2

We upgrade  to a complete proof of the conjecture NP = PSPACE. :...
04/30/2020

A class of examples demonstrating that P is different from NP in the "P vs NP" problem

The CMI Millennium "P vs NP Problem" can be resolved e.g. if one shows a...
09/12/2018

A Simple Elementary Proof of P=NP based on the Relational Model of E. F. Codd

The P versus NP problem is studied under the relational model of E. F. C...
11/20/2017

Critique of Barbosa's "P != NP Proof"

We review André Luiz Barbosa's paper "P != NP Proof," in which the class...
03/19/2016

Philosophical Solution to P=?NP: P is Equal to NP

The P=?NP problem is philosophically solved by showing P is equal to NP ...
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

There have been many attempts to solve the versus problem. Since the Cook-Levin theorem ,  in the early 70s, the problem has been the most important unsolved problem in computer science. Unfortunately most conventional methods of proof have failed. Relativizing proof , natural proof  or algebrization could not solve the problem, and it was concluded that there is no simple proof for . However, this is a fallacy. There are many barriers to proofs of the P versus NP problem. But this does not mean that there is no simple proof.

In [10, page 24] is mentioned that the set
is -complete.A similar problem is considered in this paper. Does a deterministic TM accept any word with length within steps if and are unary coded?

 {(M,1n,1t)∣ TM M accepts some y∈{0,1}n % within t steps }

This set is -complete. We analyze what happens when . With Rice’s theorem we show that one has to test every in the worst case. It is undecidable which are accepted by . So it is also undecidable which will be accepted first for .

Although we use diagonalization indirectly via the halting problem, the proof is not relativizing. The proof is consistent with . It does not violate the relativization barrier.

1.1 Procedure

In this paper, the problem of determining whether a tuple in the set is considered:

 S={(M,1n,1t)∣ DTM M accepts some y∈{0,1}n% within t steps}

is contained. The problem is in .

Section 3 shows that for a given in worst case, there are steps to decide whether is accepted by .

Section 4 shows that in the worst case, all must be checked to decide whether . This means that the running time would be exponential.

2 Preliminaries

Let be a deterministic Turing machine with input alphabet . It is defined, that . In this paper, we investigate what happens when the running time of a TM is restricted. We additionally define:

 L(M,t):={x∣M accepted x within t steps}

Single-tape TMs are used as Turing machines, as described in  with input alphabet .

3 Time Complexity of L(M,t)

In this section, the running time is considered to compute . It is concluded that to check whether a TM in steps accepts a word, steps must be calculated in the worst case.

Definition 1.

Let be a TM and be an input word. Then, is the running time of on input if terminates with it. is a partial function. is total iff terminates on every . And

 TM(n):=max({tM(x)∣|x|≤n and x∈dom(tM)}∪{0})

see [12, Chapter 2.4]. The following lemma showing this is also proven in :

Lemma 1.

For an arbitrary multi-taped TM with input , it takes computation time in the worst case to find out whether is accepted by within steps, i.e., whether .

Proof.

Let be a fully time-constructible function. According to the time hierarchy theorem, there exists a TM with , but if [6, p. 112]. Let . Then .
Let with be a sequence with and . To check, if one need computation time. ∎

Remark.

Lemma 1 applies to both single-tape and multi-tape TMs.

4 Proof of \lx@paragraphsign≠\NP

Lemma 2.

Let be a finite set of words and be a TM. To find out if every is not accepted by within steps, i.e. , one need a running time of in worst case.

Proof.

Let be an arbitrary deterministic TM and be a finite set of of input words. Let be a sequence with . If , then there exists a with . Thus:

 ∀x∈W∃Tx∀t>Tx:x∈L(M)⇔x∈L(M,t)

Now let , where when . because is finite.

If , then there is a with . could be so large that it is not computable. For any , it is undecidable, according to the halting problem, whether . By Lemma 1, it takes steps to test whether in worst case. Let . As per Rice’s theorem, for any , it is undecidable, whether or any other subset of . Thus, in the worst case, every must be tested, especially, if no word from is accepted. This results in a runtime of . ∎

Remark.

That each must be tested independently of the other words from , can be seen especially if is a UTM and each is the code of a TM.

Consider the following set from Section 1.1:

 S={(M,1n,1t)∣ DTM M and ∃y∈{0,1}n % with y∈L(M,t)}

As can be easily seen, the problem is whether an arbitrary tuple contained in is in . An NTM can be constructed, which writes symbols from to the input tape of , then executes and stops steps. Moreover, it holds:

 (M,1n,1t)∈S⟺∃y∈{0,1}n:y∈\L(M,t)⟺{0,1}n∩L(M,t)≠∅

By Lemma 2, the computational cost in the worst case is thus:
.

5 Acknowledgments

I would like to thank Günter Rote for helping me make the paper smoother. He gave me many helpful tips. Furthermore, I thank Paul Spirakis, Hermann Vosseler, Gabriel Wolf and Martin Dietzfelbinger for helping me improve some formulations. I also thank Michael Sipser, Richard Borcherds, Martin Ritzert, Steven Cook, Valentin Pickel, David Wellner and Thomas Karbe for their valuable comments, which helped me craft the formulations more vividly. I would also like to thank everyone who proofread the paper.

The paper was partly translated with www.DeepL.com/Translator (free version)

References

•  S Aaronson and A Wigderson. Algebrization: A new barrier in complexity theory. In

Proceedings of the Fortieth Annual ACM Symposium on Theory of Computing

, pages 731–740, 2008.
•  Theodore Baker, John Gill, and Robert Solovay. Relativizations of the p=?np question. SIAM Journal on computing, 4(4):431–442, 1975.
•  Stephen Cook. The P versus NP problem. The millennium prize problems, pages 87–104, 2006.
•  Stephen A Cook. The complexity of theorem-proving procedures. In Proceedings of the third annual ACM symposium on Theory of computing, pages 151–158, 1971.
•  Reiner Czerwinski. Separation of PSPACE and EXP, 2021.
•  Steven Homer and Alan L. Selman. Computability and Complexity Theory, Second Edition. Texts in Computer Science. Springer, 2011.
•  Leonid A Levin. Universal sorting problem. Problemy Predaci Informacii, 9:265–266, 1973.