The Existence of One-Way Functions

. We assume there are one-way functions and obtain a contradiction following a solid argumentation, and therefore, one-way functions do not exist applying the reductio ad absurdum method. Indeed, for every language L that is in EXP and not in P , we show that any conﬁguration, which belongs to the accepting computation of x ∈ L and is at most polynomially longer or shorter than x , has always a non-polynomial time algorithm that ﬁnd it from the initial or the acceptance conﬁguration on a deterministic Turing Machine which decides L and has always a string in the acceptance computation that is at most polynomially longer or shorter than the input x ∈ L . Next, we prove the existence of one-way functions contradicts this fact, and thus, they should not exist. Hence, function problems such as the integer factorization of two large primes can be solved eﬃciently. In this way, this work proves that is not safe many of the encryption and authentication methods such as the public-key cryptography. It could be the case of P = NP or P (cid:54) = NP , even though there are no one-way functions. However, we prove that P = UP .


Introduction
The P versus N P problem is the major unsolved problem in computer science. It was introduced in 1971 by Stephen Cook [1]. Today is considered by many scientists as the most important open problem in this field [3]. A solution to this problem will have a great impact in other fields such as mathematics and biology.
During the first half of the twentieth century many investigations were focused on formalizes the knowledge about the algorithms using the theoretical model described by Turing Machines. On this time appeared the first computers and the mathematicians were able to model the capabilities and limitations of such devices appearing precisely what is now known as the science of computational complexity theory.
Since the beginning of computation, many tasks that man could not do, were done by computers, but sometimes some difficult and slow to resolve were not feasible for even the fastest computers. The only way to avoid the delay was to find a possible method that cannot do the exhaustive search that was accompanied by "brute force". Even today, there are problems which have not a known method to solve easily yet.
This property has been used in the security methods inside of practical computational applications using tools such as the suspected one-way functions. If one-way functions do not exist, then this would imply that some algorithms used in cryptography will be easy to break at some point. However, if some functions are one-way, they would ensure that there are hundreds of problems that have not a feasible solution. This is largely derived from this result that P = N P , so there will be a huge amount of problems that can be checked easily but without some practical solution [8]. It will remain the best option to use brute force or a heuristic algorithm in many cases.
We use in this work a method known as reductio ad absurdum which is a common form of argument which seeks to demonstrate that a statement is true by showing that a false or absurd result follows from its denial. This rule has formed the basis in formal fields like logic and mathematics. In this work, we assume there are one-way functions and obtain a contradiction following a solid argumentation, and therefore, one-way functions do not exist applying this method.

Theory
The argument made by Alan Turing in the twentieth century proves mathematically that for any computer program we can create an equivalent Turing Machine [9]. A Turing Machine M has a finite set of states K and a finite set of symbols A called the alphabet of M . The set of states has a special state s which is known as the initial state. The alphabet contains special symbols such as the start symbol and the blank symbol $. The operations of a Turing Machine are based on a transition function δ, which takes the initial state with a string of symbols of the alphabet that is known as the input. Then, it proceeds to reading the symbols on the cells contained in a tape, through a head or cursor. At the same time, the symbols on each step are erased and written by the transition function, and later moved to the left ←−, right −→ or remain in the same place − for each cell. Finally, this process is interrupted if it halts in a final state: the state of acceptance "yes", the rejection "no" or halting h [7].
A Turing Machine halts if it reaches a final state. If a Turing Machine M accepts or rejects a string x, then M (x) = "yes" or "no" is respectively written. If it reaches the halting state h , we write M (x) = y, where the string y is considered as the output string, i.e., the string remaining in M when this halts [7].
A transition function δ is also called the "program" of the Turing Machine and is represented as the triple δ(q, σ) = (p, ρ, D). For each current state q and current symbol σ of the alphabet, the Turing Machine will move to the next state p, overwriting the symbol σ by ρ, and moving the cursor in the direction D ∈ {←−, −→, −} [7]. When there is more than one tape, δ remains deciding the next state, but it can overwrite different symbols and move in different directions over each tape.
Operations by a Turing Machine are defined using a configuration that contains a complete description of the current state of the Machine. A configuration is a triple (q, w, u) where q is the current state and w, u are strings over the alphabet showing the string to the left of the cursor including the scanned symbol and the string to the right of the cursor respectively, during any instant in which there is a transition on δ [7]. The configuration definition can be extended to multiple tapes using the corresponding cursors. A deterministic Turing Machine is a Turing Machine that has only one next action for each step defined in the transition function [6], [4]. However, a nondeterministic Turing Machine can contain more than one action defined for each step of the program, where this program was no longer a function but a relation [6], [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 [2]. There are four complexity classes that have a close relationship with the previous concepts and are represented as P , U P , EXP and N P . In computational complexity theory, the class P contains the languages that are decided by a deterministic Turing Machine in polynomial time [6]. The class U P has all the languages that are decided in polynomial time by a non-deterministic Turing machines with at most one accepting computation for each input [10]. The complexity class EXP is the set of all decision problems solvable by a deterministic Turing machine in O(2 p(n) ) time, where p(n) is a polynomial function of n. The class N P contains the languages that are decided by a non-deterministic Turing Machines in polynomial time [4]. Problems that are EXP − complete might be thought of as the hardest problems in EXP . We do know that EXP − complete problems are not in P : it has been proven that these problems cannot be solved in polynomial time, by the time hierarchy theorem [7].
On the other hand, a language L ∈ N P if there is a polynomial-time decidable, polynomially balanced relation R L such that for all strings x: there is a string y with R L (x, y) if and only if x ∈ L [7]. The function problem associated with L is the following computational problem: given x, find a string y such that R L (x, y) if such a string exists; if no such string exists, return "no" [7]. The class of all function problems associated as above with languages in N P is called F N P [7]. The resulting class from F N P is the class F P which represents all function problems that can be solved in polynomial time [7]. We also could define F EXP as the complexity class of function problems associated with languages in EXP .
The P versus N P problem is to know whether P is equal to N P or not. This would be equivalent to prove whether F P is equal to F N P or not. A one-way function f is a function from strings to strings, one-to-one, for all input x we have | x | 1 k ≤| f (x) |≤| x | k for some k > 0 and f is in F P but f −1 is not [7]. It holds the following statement: P = U P if and only if there are no one-way functions [7]. If one-way functions exist, then P = N P [5]. The existence of one-way functions is still an open conjecture.

Results
Lemma 3.1. Every language L exp ∈ EXP is decided by a deterministic Turing Machine M exp that has only one tape and always accepts in the configuration ("yes", , x$z) when x ∈ L exp and z is another remaining string of the accepting computation that will be at most polynomially longer or shorter than the string x.
Every Turing Machine could be transformed into another Turing Machine of one tape which has a polynomial time in relation with the running time of the original [7]. Therefore, the deterministic Turing Machine that decides L exp could be of one tape. This one-tape deterministic Turing Machine can be transformed into two-tapes deterministic Turing Machine that receives the input in the first tape. This new Turing Machine will copy the input in the second tape and there, it will simulate the original Turing Machine of one tape. When the simulation of the original Turing Machine accepts, it will copy, concatenated with a blank symbol at the end of the first tape, the content of the second tape until a length which is at most polynomially longer or shorter with the size of x in a constant exponent and if the content is very short or empty, then we fill it with 1 symbols. Next, we remove the content in the second tape that was not copied on the first tape.
Finally, it will set the cursors in the start symbols of each tape and halt in the state of acceptance. In case of rejection, the two-tapes deterministic Turing Machine will reject too. This new Turing Machine can be transformed into a one-tape Turing Machine M exp complying with the Lemma 3.1.
Definition 3.2. For every language L exp ∈ EXP , we could invert the deterministic Turing Machine M exp of Lemma 3.1 changing the state of acceptance with the initial state and reversing the transition function of M exp . In this way, we would create a new non-deterministic Turing Machine N exp . We are going to define the rejection state in N exp in the following way: for every q state in the set of states of N exp and every σ symbol of its alphabet, then δ(q, σ) = ("no", σ, −), where δ will be the program of N exp . The non-deterministic Turing Machine N exp will simulate the behavior of M exp moving backwards.
We start executing N exp (x$z) from the initial configuration (s, , x$z) which corresponds to the configuration of acceptance ("yes", , x$z) on M exp .  If we obtain the configuration conf ig(x) by the execution of M exp (x) in a polynomial time, then that means from the configuration conf ig(x) until the state of acceptance there is an exponential amount of steps, because L exp ∈ EXP and is not in P . Therefore, any algorithm that runs backward from the acceptance configuration with the input x$z until the configuration conf ig(x) will be exponential due to z is at most polynomially longer or shorter than the strings x. If we obtain the configuration conf ig(x) by the execution of N exp (x$z) in a polynomial time, then that means from the configuration conf ig(x) until the state of acceptance on M exp with x there will be a polynomial amount of steps, because conf ig(x) is at most polynomially longer or shorter than the strings x and z. Therefore, there will not be any polynomial time algorithm that runs forward from the initial configuration with x until conf ig(x) due to L exp ∈ EXP and is not in P . We are going to assume the Hypothesis 3.5 is true until the end of this work where we prove that is false. Lemma 3.6. There are at least two one-way functions.
If we have at least one function f * that is one-way, then we could build for every function f , that is from strings to strings, one-to-one, for all input x we have | x | 1 k ≤| f (x) |≤| x | k for some k > 0 and f and f −1 are in F P , another function f * * that is one-way too. There are many functions such as the identity function which comply with the characteristics of f . The one-way function f * * will be defined by the composition of functions f * (f (x)) for any input x. We already know that f * (f (x)) is in F P , but to compute f −1 * * is necessary to execute f −1 * , because f (x)))). Therefore, f −1 * * is not in F P , and then, f * * complies with all the characteristics in the definition of a one-way function.
Definition 3.7. For each two one-way functions f * and f * * , we could define a new function problem F * * * , such that for every input x the function problem will return the result of f −1 * * (f * (x)). If x and f * (x) are not defined in the domains of f * and f −1 * * respectively, then F * * * returns "no". Lemma 3.8. F * * * ∈ F EXP and is not in F P . This is possible due to f −1 * * is not in F P . Lemma 3.9. The function problem F * * * has an associated language L * * * such that L * * * ∈ EXP and is not in P .
This result is a consequence of the definition of function problem that we explain in the Theory section. Important 3.10. With the language L * * * , we will put the remaining string z of the accepting computation in the configuration ("yes", , x$z) when x ∈ L * * * on the deterministic Turing Machine M exp of Lemma 3.1 as the output of F * * * for x.
This will be the key in our proof. The functions f * and f * * are in F P , and thus, following the arguments of Lemma 3.1, we could build any of these deterministic Turing Machines M * or M * * for each function in a similar way, that is creating a new input tape, removing the content of the other tapes at the end and changing the new Turing Machine into a one-tape deterministic Turing Machine. Lemma 3.12. In the language L * * * , we could have a configuration which belongs to the accepting computation of x ∈ L * * * on the deterministic Turing Machine M exp of Lemma 3.1 that is equal to the configuration in the halting state on M * in the execution of f * (x), but with a different state. We will denoted this configuration as conf ig * (x). This is an implication of the function problem F * * * associated with L * * * , because F * * * executes f * (x) = y and then f −1 * * (y). Hence, we could first simulate the execution of the one-tape deterministic Turing Machine M * with x for f * on M exp and later f −1 * * (y). Theorem 3.13. The Hypothesis 3.5 is false, and therefore, there are no one-way functions.
We show we could obtain conf ig * (x) on the deterministic Turing Machine M * with x for f * , but with a different state. Besides, we could obtain conf ig * (x) on the deterministic Turing Machine M * * with f −1 * * (f * (x)) for f * * , but with a different state. Indeed, the string f −1 * * (f * (x)) will be the output of F * * * for the input x that will be equal to the string z on the configuration of acceptance on M exp . However, the state of the configuration conf ig * (x) could be always the same, because we could delimit on M exp when we finish through f * (x) = y and start with f −1 * * (y) and then we could assign a single state for this step. For that reason, we could affirm that we can always obtain the configuration conf ig * (x) by a polynomial time algorithm in a forward and backward running way from the initial and acceptance configurations which belong to the deterministic Turing Machine M exp of Lemma 3.1 with an input x ∈ L * * * . Nevertheless, this is a contradiction with Theorem 3.4. In conclusion, if we apply the reductio ad absurdum method, we have the Hypothesis 3.5 is false, and therefore, there are no one-way functions.
Lemma 3.14. P = U P . This is a direct consequence of Theorem above.

Conclusions
This result shows in a formal way that many currently mathematically problems can be solved efficiently such as the integer factorization of two large primes. In this way, it proves that is not safe many of the encryption and authentication methods such as the public-key cryptography. It could be the case of P = N P or P = N P , even though there are no one-way functions. However, we prove that P = U P .