NP on Logarithmic Space

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 ? It was essentially mentioned in 1955 from a letter written by John Nash to the United States National Security Agency. However, 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 classes are L and NL . Whether L = NL is another fundamental question that it is as important as it is unresolved. We prove that NP ⊆ NSPACE (log 2 n ) just using logarithmic space reductions.


Introduction
In 1936, Turing developed his theoretical computational model [10]. The deterministic and nondeterministic Turing machines have become in two of the most important definitions related to this theoretical model for computation [10]. A deterministic Turing machine has only one next action for each step defined in its program or transition function [10]. 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 [10].
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, or the computation ends in the halting state with some output, that is M (w) = y (when M outputs the string y on the input w) [2].
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]. The language accepted by a Turing machine M , denoted L(M ), has an associated alphabet Σ and is defined by: Moreover, L(M ) is decided by M , when w / ∈ L(M ) if and only if M (w) = "no" [4]. We denote by t M (w) the number of steps in the computation of M on input w [2]. For n ∈ N we denote by T M (n) the worst case run time of M ; that is: where Σ n is the set of all strings over Σ of length n [2]. We say that M runs in polynomial time if there is a constant k such that for all n, T M (n) ≤ n k +k [2]. In other words, this means the language L(M ) can be decided by the Turing machine M in polynomial time. Therefore, P is the complexity class of languages that can be decided by deterministic Turing machines in polynomial time [4]. A verifier for a language L 1 is a deterministic Turing machine M , where: yes" for some string u}.
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 string u, to verify that a string w is a member of L 1 . This information is called certificate. N P is the complexity class of languages defined by polynomial time verifiers [8].
It is fully expected that P ̸ = N P [8]. Indeed, if P = N P then there are stunning practical consequences [8]. For that reason, P = N P is considered as a very unlikely event [8]. Certainly, P versus N P is one of the greatest open problems in science and a correct solution for this incognita will have a great impact not only in computer science, but for many other fields as well [3]. Whether P = N P or not is still a controversial and unsolved problem [1]. We provide an important step forward for this outstanding problem using the logarithmic space complexity.

The Hypothesis
A function f : Σ * → Σ * 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 [10]. Let {0, 1} * be the infinite set of binary strings, we say that a language An important complexity class is NP-complete [5]. If L 1 is a language such that L ′ ≤ p L 1 for some L ′ ∈ NP-complete, then L 1 is NP-hard [4]. Moreover, if L 1 ∈ N P , then L 1 ∈ NP-complete [4]. A principal NP-complete problem is SAT [5].
A logarithmic space Turing machine has a read-only input tape, a writeonly output tape, and read/write work tapes [10]. The work tapes may contain at most O(log n) symbols [10]. In computational complexity theory, L is the complexity class containing those decision problems that can be decided by a deterministic logarithmic space Turing machine [8]. N L is the complexity class containing the decision problems that can be decided by a nondeterministic logarithmic space Turing machine [8].
In general, DSP ACE(S(n)) and N SP ACE(S(n)) are complexity classes that are used to measure the amount of space used by a Turing machine to decide a language, where S(n) is a space-constructible function that maps the input size n to a non-negative integer [7]. The complexity class DSP ACE(S(n)) is the set of languages that can be decided by a deterministic Turing machine that uses O(S(n)) space [7]. The complexity class N SP ACE(S(n)) is the set of languages that can be decided by a nondeterministic Turing machine that uses O(S(n)) space [7].
A function f : Σ * → Σ * is a logarithmic space computable function if some deterministic Turing machine M , on every input w, halts using logarithmic space in its work tapes with just f (w) on its output tape [10]. Let {0, 1} * be the infinite set of binary strings, we say that a language L 1 ⊆ {0, 1} * is logarithmic space reducible to a language L 2 ⊆ {0, 1} * , written L 1 ≤ l L 2 , if there is a logarithmic space computable function f : {0, 1} * → {0, 1} * such that for all x ∈ {0, 1} * : The logarithmic space reduction is used for the completeness of the complexity classes L, N L and P among others.
We can give a certificate-based definition for N L [2]. The certificatebased definition of N L assumes that a logarithmic space Turing machine has another separated read-only tape, that is called "read-once", where the head never moves to the left on that special tape [2]. Definition 1.1. A language L 1 is in N L if there exists a deterministic logarithmic space Turing machine M with an additional special read-once input tape polynomial p : N → N such that for every x ∈ {0, 1} * : where by M (x, u) we denote the computation of M , x is placed on its input tape, the certificate string u is placed on its special read-once tape, and M uses at most O(log |x|) space on its read/write tapes for every input x where | . . . | is the bit-length function. The Turing machine M is called a logarithmic space verifier.
We state the following Hypothesis: There is an NP-complete language L 1 ∈ N SP ACE(log 2 n) which is closed under logarithmic space reductions in NP-complete.
We show the principal consequence of this Hypothesis: Theorem 1.3. If the Hypothesis 1.2 is true, then N P ⊆ N SP ACE(log 2 n).
Proof. Due to L 1 is closed under logarithmic space reductions in NP-complete, then every N P problem is logarithmic space reduced to L 1 . This implies that N P ⊆ N SP ACE(log 2 n) since N SP ACE(log 2 n) is closed under logarithmic space reductions as well.

The Problems
Now, we define the problems that we are going to use. REMARKS: We assume that every element of the list divides N . Besides, the prime factorization of every element in B and N is given as an additional data. SP ∈ NP-complete [5].

Results
In number theory, the p-adic order of an integer n is the exponent of the highest power of the prime number p that divides n. It is denoted ν p (n). Equivalently, ν p (n) is the exponent to which p appears in the prime factorization of n.
Proof. Given an instance (B, N ) of SP , then for every prime factor p of N we could create the instance 0 y , 0 y 1 , 0 y 1 , . . . , 0 yn for U K such that B = [B 1 , B 2 , . . . , B n ] is a list of n natural numbers and ν p (N ) = y, ν p (B 1 ) = y 1 , ν p (B 2 ) = y 2 , . . . , ν p (B n ) = y n (Do not confuse n with N ). Under the assumption that N has k prime factors, then we can output in logarithmic space each instance for U K such that these instances of U K appears in ascending order according to the ascending natural sort of the respective k prime factors. That means that the first U K instance in the output corresponds to the smallest prime factor of N and the last U K instance in the output would be defined by the greatest prime factor of N . Besides, in this logarithmic reduction we respect the order of the exponents according to the appearances of the n elements of B = [B 1 , B 2 , . . . , B n ] from left to right: i.e. every instance is written to the output tape as 0 z , 0 z 1 , 0 z 1 , . . . , 0 zn where ν q (N ) = z, ν q (B 1 ) = z 1 , ν q (B 2 ) = z 2 , . . . , ν q (B n ) = z n for every prime factor q of N . Finally, we generate a certificate that is a sequence of 0-1 valued variables x 1 , x 2 , . . . , x n using square logarithmic space such that for the first instance of U K we have and so on... We must store exactly the position on the tape and time of every point of the computation when we need to simulate the move to the left over the output tape based on the composition of logarithmic reduction [8]. We store these parameters for every k instance of U K where we update and use them when we need to reset the output tape for just simulating the move of the output tape to the left. Certainly, this is the same classic method that we use in the composition of logarithmic reduction, but this time we store k times the necessary logarithmic information [8].
We can simulate simultaneously k logarithmic space verifiers M j for each j th instance of U K. We can done this since the sequence certificate would be exactly the same for the k logarithmic space verifiers. Every logarithmic space verifiers M j uses O(log | (B, N ) |) space where | . . . | is the bit length function. So, we finally consume O(k · log | (B, N ) |) space exactly in the whole computation that would be square logarithmic because of k = O(log N ) and thus, the whole computation can be made O(log 2 | (B, N ) |) space.
To sum up, we can create this verifier that only uses a square logarithmic space in the work tapes such that the sequence of variables is placed on the special read-once tape due to we can read at once every valued variable x i . Hence, we only need to iterate from the variables of the sequence from left to right to verify whether is an appropriated certificate according to the described constraints of the problem U K to finally accept the verification of all the k instances otherwise we can reject.
In addition, we can simulate the reading of one symbol from the string sequence of 0-1 valued variables into the read-once tape just nondeterministically generating the same symbol in the work tapes using a square logarithmic space [2]. We could remove each symbol or a square logarithmic amount of symbols generated in the work tapes, when we try to generate the next symbol contiguous to the right on the string sequence of 0-1 valued variables. In this way, the generation will always be in square logarithmic space. This proves that SP is in N SP ACE(log 2 n).
Proof. This is a directed consequence of Theorems 1.3 and 2.1 because of the Hypothesis 1.2 is true. Certainly, SP is closed under logarithmic space reductions in NP-complete. Indeed, we can reduced SAT to SP in logarithmic space and every N P problem could be logarithmic space reduced to SAT by the Cook's Theorem Algorithm [5].
in O(2 poly(log n) ) time. Besides, we "believe" there must exist an evident proof of N SP ACE(log 2 n) ⊆ P and thus, we would obtain the outstanding result of P = N P .