Separation of P and NP

08/19/2021
by   Reiner Czerwinski, et al.
0

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.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Two theorems about the P versus NP problem

Two theorems about the P versus NP problem be proved in this article (1)...
07/08/2019

Proof compression and NP versus PSPACE. Part 2

We upgrade [1] to a complete proof of the conjecture NP = PSPACE. [1]:...
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 [4], [7] 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 [2], natural proof [9] or algebrization[1] 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?

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:

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:

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

3 Time Complexity of

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

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

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[11], 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

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:

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:

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:

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

  • [1] 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.
  • [2] Theodore Baker, John Gill, and Robert Solovay. Relativizations of the p=?np question. SIAM Journal on computing, 4(4):431–442, 1975.
  • [3] Stephen Cook. The P versus NP problem. The millennium prize problems, pages 87–104, 2006.
  • [4] 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.
  • [5] Reiner Czerwinski. Separation of PSPACE and EXP, 2021.
  • [6] Steven Homer and Alan L. Selman. Computability and Complexity Theory, Second Edition. Texts in Computer Science. Springer, 2011.
  • [7] Leonid A Levin. Universal sorting problem. Problemy Predaci Informacii, 9:265–266, 1973.
  • [8] Christos H. Papadimitriou. Computational complexity. Addison-Wesley, 1994.
  • [9] Alexander A Razborov and Steven Rudich. Natural proofs. Journal of Computer and System Sciences, 55(1):24 – 35, 1997.
  • [10] Steven Rudich and Avi Wigderson. Computational Complexity Theory, volume 10. American Mathematical Soc., 2004.
  • [11] Richard Edwin Stearns, Juris Hartmanis, and Philip M. Lewis II. Hierarchies of memory limited computations. In 6th Annual Symposium on Switching Circuit Theory and Logical Design, Ann Arbor, Michigan, USA, October 6-8, 1965, pages 179–190. IEEE Computer Society, 1965.
  • [12] Ingo Wegener. Complexity Theory: Exploring the Limits of Efficient Algorithms. Springer Science & Business Media, 2005.