aa r X i v : . [ c s . CC ] J a n A Formal Axiomatization of Computation
Rasoul RamezanianFerdowsi University of Mashhad, Iran [email protected]
Abstract
We introduce an axiomatization for the notion of computation. Based on the idea ofBrouwer choice sequences, we construct a model, denoted by E , which satisfies our ax-ioms and E | = P = NP. In other words, regarding ”effective computability” in Brouwer’sintuitionism viewpoint, we show P = NP. Is the famous problem P = NP unprovable? To answer the question, we need an axiom-atization for the notion of computation. In sections 2 and 3, we propose our setting andaxiomatic system.To show that P = NP is not derivable from our axiomatic systems, we, in section 6,construct a model, denoted by E , which satisfies all of our axioms and does not satisfyP = NP.To construct our counter-model, E , in section 4 and 5, we introduce non-predeterminedfunctions (inspired by Brouwer choice sequences) and persistently evolutionary Turing ma-chines as an extension of Turing machines to compute non-predetermined functions.In computational complexity theory, the diagonal argument is used to show that twocomplexity classes are distinct. Nobody till now could be successful to use the diagonalargument to show P = NP.In classic mathematics, the diagonal argument is used to show that the size of the realnumbers is larger than the naturals. But in Brouwer intuitionism mathematics, instead ofthe diagonal argument, the principle of Bar induction [4] is used to show that there is noone-to-one correspondence between the natural numbers and the real numbers.Our argument to show that E | = P = NP is not the diagonal argument, and is in somesense similar to Bar induction principle.In section 7, we argue that our axiomatic system plausibly formalizes “natural compu-tation” similar to Peano axioms for “natural numbers”. A computation is a sequence of configurations that we transit from one to another byapplying some instructions. The transitions are continued until a desired (an accept) con-figuration is obtained. In the following, we formally describe the notion of computation.Our syntax, for explaining the notion of computation, consists of the followings INST is a nonempty set called the set of “instructions” , CONF is a nonempty set called the set of “configurations” such that to each string x ∈ { , } ∗ , 1 a unique configuration C ,x ∈ CONF is associated as “the start configuration ofthe string x ”, and – to each C ∈ CONF, a unique string y C ∈ { , } ∗ is associated as the string ofinvolved in the configuration C , and also we have y C ,x = x (see example 3.1). TENG, the “transition engine” , is a total function from CONF × INST to CONF ∪{⊥} . AENG, the “accepting engine” , is a total function from CONF to { Y ES, N O } .For an example of the above syntax, one may see example 3.1. Definition 2.1 i. Procedures . A procedure (an algorithm, a machine) is defined to be a finite set M ⊆ INST (a finite set of instructions) , satisfying the following condition-
The determination condition : for every C ∈ CONF , at most there exists only oneinstruction τ in M , denoted by notation Υ( M, C ) = τ , such that TENG(
C, τ ) ∈ CONF . If for all ι ∈ M , TENG(
C, ι ) = ⊥ , we denote Υ( M, C ) = ∅ .We refer to the set of all procedures by the symbol Ξ .ii. Languages . A string x ∈ { , } ∗ , is in the language of a procedure M , denoted by L ( M ) , whenever we can construct a sequence C C , ..., C n of configurations in CONF such that – C = C ,x , – each C i , i ≥ , is obtained by applying TENG on ( C i − , Υ( M, C i − )) , – the AENG outputs
Y ES for C n , and Υ( M, C n ) = ∅ .The sequence C C , ..., C n is called the “successful computation path” of M on x . Thelength of a computation path is the number of configurations appeared in. iii. Functions . A partial function f : Σ ∗ → Σ ∗ , Σ = { , } , is computed by a pro-cedure M ∈ Ξ , whenever for x ∈ Σ ∗ , we can construct a sequence C C , ..., C n ofconfigurations in CONF such that – C = C ,x , – each C i , i ≥ , is obtained by applying TENG on ( C i − , Υ( M, C i − )) , – the AENG outputs
Y ES for C n , and Υ( M, C n ) = ∅ , – y C n = f ( x ) . iv. Computation Path Length . The time complexity of computing a procedure M onan input string x , denoted by time M ( x ) , is n , for some n ∈ N , whenever we canconstruct a successful computation path of the procedure M on x with length n . ⊥ mean “undefined”. . Time Complexity . Let f : N → N and L ⊆ Σ ∗ . The time complexity of thecomputation of the language L is less than f whenever there exists a procedure M ∈ Ξ such that the language defined by the procedure M , i.e., L ( M ) , is equal to L , and forall x ∈ L , time M ( x ) < f ( | x | ) . vi. Complexity Classes.
We define the time complexity class P ⊆ Σ ∗ to be the set ofall languages that we can compute in polynomial time using TENG and
AENG . Wealso define the complexity class NP ⊆ Σ ∗ as follows: L ∈ NP iff there exists J ∈ P and a polynomial function q such that for all x ∈ Σ ∗ , x ∈ L ⇔ ∃ y ∈ Σ ∗ ( | y | ≤ q ( | x | ) ∧ ( x, y ) ∈ J ) . Remark 2.2
Definitions of computability and complexity classes stated in 2.1 are not newand they are the same definitions appeared in [1] and [3].
In this section, we introduce the axioms of our setting. We only have 3 axioms. A . Turing Computability and Complexity.
For every Turing machine T , there existsa procedure M ∈ Ξ such that L ( M ) = L ( T ) and the time complexity of L ( M ) is equalto the time complexity of L ( T ). A . Effective Computability of Engines . Both engines TENG and AENG are effec-tively computable (see 5.5). A . Time Complexity of Engines . Both engines TENG and AENG work in lineartime (see 5.6).In section 7, we argue that these 3 axioms plausibly express the notion of “natural compu-tation”. Axiom A A V , which satisfies axioms A A
2, and A Example 3.1
Let Q T = { h } ∪ { q i | i ∈ N ∪ { }} , Σ , Γ be two finite set with Σ ⊆ Γ and Γ has a symbol △ ∈ Γ − Σ .1) IN ST v = { [( q, a ) → ( p, b, D )] | p, q ∈ Q T , a, b ∈ Γ , D ∈ { R, L }} ,2) CON F v = { ( q, xaz ) | q ∈ Q T , x, z ∈ Γ ∗ , a ∈ Γ } , for each x ∈ Σ ∗ , C ,x = ( q , △ x ) ,and for each C = ( q, xaz ) ∈ CON F v , y C = xaz . ) Let C = ( q, xb ab y ) be an arbitrary configuration then – T EN G v ( C, [( q, a ) → ( p, c, R )]) is defined to be C ′ = ( p, xb cb y ) , – T EN G v ( C, [( q, a ) → ( p, c, L )]) is defined to be C ′ = ( p, xb cb y ) , and – for other cases T EN G v is defined to be ⊥ . T EN G v can be computed by a Turing machine in linear time.4- Let C ∈ CON F v be arbitrary – if C = ( h, △ x ) then AEN G v ( C ) is defined to be Y ES , – if C = ( h, x △ ) then AEN G v ( C ) is defined to be Y ES , and – otherwise AEN G v ( C ) is defined to be N O . AEN G v can be computed by a Turing machine in linear time.5- For each M ∈ Ξ v , and C = ( q, xay ) ∈ CON F v , if there exists [( q, a ) → ( p, b, D )] ∈ M for some p ∈ Q T , b ∈ Γ , and D ∈ { R, L } , then Υ( M, C ) = { [( q, a ) → ( p, b, D )] } elseit is defined to be ∅ . Remark 3.2
The model V (example 3.1) is the same model of standard Turing machinewhich is recalled and expressed by our proposed syntax. Every instruction τ ∈ INST v is atransition of Turing machines.Suppose T = h Q, δ, Σ , Γ , F i be a Truing machine, then in our syntax, the set δ is a procedurein the model V that its language in the model V is exactly the language of the Turing machine T . It is obvious that V satisfies axiom A A
2, and A
3, as both
T EN G v and AEN G v arelinear time Turing computable.By axioms A A
3, it is required that the engines be linear time effective computable.In section 4 and 5, we discuss that effective Computability is not restricted to TuringComputability and introduce persistently evolutionary Turing machines.
The most important and fundamental notion of mathematics is function. A function is aprocess associating each element x of a set X , to a single element f ( x ) of another set Y .Classically, we assumed that all functions in mathematics are pre-determined.In this section, we discuss functions that are not pre-determined and they are eventuallydetermined through the way we start to associate f ( x ) for every element x ∈ X .We introduce Persistently Evolutionary Turing machines that compute non-predeterminedfunctions.Let f be a process that associates elements of a set X to the elements of another set Y .If the process f works well-defined then we know f as a mathematical function. But beingwell-defined does not force the process f to be predetermined.4uppose that x and x are two different elements of X . I want to use the process f todetermine the value of f for x and x . It is up to me to first perform the process f on x or x .If f is predetermined the it does not matter to perform the process on ordering x x orordering x x . But if f is non-predetermined then different order of inputs causes different alternate functions which one of them is the function that we are constructing.Alternate functions are functions that could exist in place of our function (if we inter-acted with different ordering of inputs, those alternate could happen).For example, consider the following process g : • W is a set which is initially empty. • for a given natural number n , if there exists a pair ( n, z ) ∈ W then output g ( n ) = z ,else update W = W ∪ { ( n, | W | + 1) } and output g ( n ) = | W | + 1 . The function g is a non-predetermined function over natural numbers. I input 7 , , , g (7) = 1, g (9) = 2, g (1) = 3, and g (11) = 4.The value of other numbers are yet non-predetermined and as soon as I perform process g on each number the value is determined.- The function g is not predetermined. It is determined eventually, but it is alwaysundetermined for some numbers.- The function g is well-defined, and associates to each input a single output.- For every natural number, the function g is definable.- If I inputted 9 , , ,
11, I would have an alternate g which would associate: g (9) = 1, g (1) = 2, g (7) = 3, and g (11) = 4.The inspiration of non-predetermined functions are Browser choice sequences [4]. AChoice sequence is an unfinished objects where the value of the sequence are not necessarypredetermined.A choice sequence is begun at a particular moment in time, and then grows aswe choose further numbers. This process is generally open-ended and may becontinued forever. (page 89 of [2]) In this section, to have a formal computation model for non-predetermined functions, weintroduce the notion of Persistently Evolutionary Turing machines (we may also name themBrouwer-Turing machines) as an effective Computable method.Persistently Evolutionary Turing machines are an extension of the notion of Turingmachines in which the structure of the machine can evolve through each computation.A Turing machine consists of a set of states Q , and a table of transitions δ which bothare fixed and remain unchanged forever. In Persistently Evolutionary Turing machines, weallow the set of states and the table of transitions changes through each computation.5s a Persistently Evolutionary Turing Machine P T computes on an input string x ,the machine P T can add or remove some of its states and transitions, and thus after thecomputation on the input x is completed, the sets Q and δ have been changed.However, these changes are persistent. That is, if we already input a string x and themachine outputs y , then whenever we again input x the machine outputs the same y , andthe changes of states and transitions do not violate well-definedness.One may assume that we have a box and we set a Turing machine in the box with somerules of adding and removing of states and transitions. Then, We input strings to the boxand for each string, the box outputs a single string. The machine in the box changes itselfbased on the rules, however, the behavior of the box is well-defined.Persistently Evolutionary Turing Machines computes non-predetermined functions. Definition 5.1
An evolutionary Turing machine, M = h Q, δ, q , Σ = { , } , Γ = Σ ∪{△} , F i consists of the following: • The Initial Machine . M = h Q , δ , F i , initially M = M . • Updating Rules . There could be a finite set of updating rules. The following is thegeneric rule – If during the computation, the machine M on an input, say x , reached to aconfiguration, say C , with a specific property, say φ , then update ∗ δ = δ ∪ { t ( C ) } or δ = δ − { t ( C ) } , ∗ F = F ∪ { q ( C ) } or F = F − { q ( C ) } , ∗ Q = Q ∪ { q ( C ) } or Q = Q − { q ( C ) } ,where t ( C ) , is a generic transition, and q ( C ) is a generic state. • Persistent . Updating rules never violate well-definedness, and if M accepts (rejects)an string x , whenever we apply M on x in future, again M would accept (reject) x . In the following example, we introduce a persistently evolutionary nondeterministicfinite automate [3].
Example 5.2 (In the sequel of the paper, we will refer to the persistently evolutionarymachine introduced in this example by
P T ). Define
Evolve : NFA × Σ ∗ → NFA as follows :Let M ∈ NFA , M = h Q, q , Σ = { , } , δ : Q × Σ → Q, F ⊆ Q i , and x ∈ Σ ∗ . Suppose x = a a · · · a k where a i ∈ Σ . Applying the automata M on x , one of the three followingcases may happen:case1. The automata M reads all a , a · · · , a k successfully and stops in an accepting state.In this case, the structure of the automata does not change and let Evolve(
M, x ) = M . Q : the set of states, δ : the transition table, F : the set of accepting states NFA is the class of all nondeterministic finite automata M = h Q, Σ = { , } , δ, q , F i , where for eachstate q ∈ Q , and a ∈ Σ, there exists at most one transition from q with label a . F is the set of accepting states ase2. The automata M reads all a , a · · · , a k successfully and stops in a state p which isnot an accepting state. – If the automata M can transit from the state p to an accepting state by readingonly one alphabet, then let Evolve(
M, x ) = M . – If it cannot transit (from p to an accepting state) then let Evolve(
M, x ) to be anew automata M ′ = h Q, q ′ , Σ = { , } , δ ′ : Q ′ × Σ → Q ′ , F ′ ⊆ Q ′ i , where Q ′ = Q , δ ′ = δ , F ′ = F ∪ { p } .case3. The automata M cannot read all a , a · · · , a k successfully,and after reading a partof x , say a a · · · a i , ≤ i ≤ k , it crashes in a state q that δ ( q, a i +1 ) is not defined.In this case, we let Evolve(
M, x ) be a new automata M ′ = h Q, q ′ , Σ = { , } , δ ′ : Q ′ × Σ → Q ′ , F ′ ⊆ Q ′ i , where Q ′ = Q ∪ { s i +1 , s i +2 , · · · , s k } (all s i +1 , s i +2 , · · · , s k are new states that does not belong to Q ), δ ′ = δ ∪ { ( q, a i +1 , s i +1 ) , ( s i +1 , a i +2 , s i +2 ) , · · · , ( s k − , a k , s k ) } , and F ′ = F ∪ { s k } . The machine
P T persistently evolve, that is, if it (rejected) accepted a string x already,then it would (reject) accept the string x for any future trials as well. The language L ( M )is not predetermined and it eventually is determined.For example, assume that initially M is Q = { q } , F = ∅ , δ = ∅ . Now I input the string101 and according to case 3, the machine M evolves and new states q , q , q and transitions( q , , q ) , ( q , , q ) , ( q , , q ) are added and also F = F ∪ { q } . Now if I input the string10 then according to case 2, M rejects it. However, If at first I inputted 10 to the machinethen it would accept it. The time-complexity [1] of Persistent Evolutionary Turing Machines is defined similar tothe time-complexity of Turing machines except that for each (adding) removing of statesor transitions, we count one extra clock.
Definition 5.3
Let M = h Q, δ, q , Σ = { , } , Γ = Σ ∪ {△} , F i be a persistently evolution-ary Turing machine, x is an arbitrary string, and f : N → N is a function. We say that time M ( x ) < f ( | x | ) , whenever everytime we compute M on x , the sum of • the number of uses of transitions in δ , and • the number of uses of updating ruleshappened during the computation M on x , is less than f ( | x | ) . Proposition 5.4
The time complexity of the machine
P T in example 5.2 is linear. Proof.
It is straightforward. ⊣ .2 Effective Computability In axioms A A
3, we required that both TENG and AENG to be effectively computablein linear time. In two following definitions, we formally explain what we mean by an effectiveComputability.
Definition 5.5
A function is effectively computable if it is either Turing computable orPersistently Evolutionary Turing computable.
Definition 5.6
A function is computed in linear time whenever its corresponding Turingor Persistently Evolutionary Turing machine works in linear time.
In this section, we prove that P = NP is not derivable from Axioms A A A
3. To dothis, we construct a model E which satisfies A A A Definition 6.1
We introduce a model E as follows. • Two sets
IN ST e and CON F e are defined to be the same IN ST v and CON F v inexample 3.1 respectively, and consequently the set Ξ e is the same Ξ v . • The transition engine
T EN G e is also defined similarly to the transition engine T EN G v in example 3.1, and thus it is linear time computable by a Turing machine. • The accepting engine
AEN G e is defined as follows: let C ∈ CON F e be arbitrary – if C = ( h, △ x ) then AEN G e ( C ) = Y ES , – if C = ( h, x △ ) then the AEN G e works exactly similar to the the persistentlyevolutionary machine P T introduced in example 5.2. On input x , if P T outputs , the accepting engine outputs Y ES , and – otherwise AEN G e ( C ) = N O .By proposition 5.4, the engine
AEN G e is linear time computable by a persistentlyevolutionary Turing machine. Remark 6.2
The only difference between model E with model V (see example 3.1) is thatthe SBOX e is a persistently evolutionary Turing machine. Proposition 6.3
The model E satisfies axioms A , A , and A . Proof.
It is obvious by definition. ⊣ Note that the
AEN G e is a persistently evolutionary machine. The set of procedures(algorithms) in the model E is the same set of procedures in the model V (example 3.1),i.e Ξ v = Ξ e . However for some procedures, say M , the language L ( M ) is the model E could be different from the language L ( M ) in V . For some M ∈ Ξ e , we have L ( M ) isa non-predetermined language. The procedure M is fixed and does not change throughtime, but since the structure of AEN G e changes through time, the language L ( M ) is non-predetermined. 8 efinition 6.4 We say a function f : N → N is sub-exponential, whenever there exists t ∈ N such that for all n > t , f ( n ) < n . Theorem 6.5
We have E | = P = NP .We show that there exists a procedure M ∈ Ξ e such that • the language L ( M ) that the we compute through M is not predetermined, • the language L ( M ) belongs to the class P , • there exists no procedure M ′ ∈ Ξ e , such that L ( M ′ ) is equal to L ′ = { x ∈ Σ ∗ | ∃ y ( | y | = | x | ∧ y ∈ L ( M )) } , and for some k ∈ N , for all x ∈ L ( M ′ ) , if | x | > k then time M ( x ) ≤ f ( | x | ) where f : N → N is a sub-exponential function. In other world, L ′ is in NP but notin P . Proof.
Consider the following procedure M ∈ Ξ e Σ = { , } , Γ = { , , △} ,M = { [( q , △ ) → ( h, △ , R )] , [( h, → ( h, , R )] , [( h, → ( h, , R )] } .Using the T EN G e and AEN G e , we compute procedure M on an input x as follows:- Note C ,x = ( q , △ x ), and Υ( M, C ,x ) = [( q , △ ) → ( h, △ , R )].- We have T EN G e ( C ,x , [( q , △ ) → ( h, △ , R )]) = ( h, △ ax ′ ) where x = ax ′ for some a ∈ Sigma .- Continuing using the transition engine on the configurations, we reach to the config-uration ( h, x △ ) which Υ( M, ( h, x △ )) = ∅ .- Running the accepting engine, AEN G e ( M, ( h, x △ )), the persistently evolutionaryNFA inside the accepting engine works and provide ’Yes’ or ’No’ as output.The language of the procedure M , L ( M ), is not predetermined in model E . As we choosea string x ∈ Σ ∗ to compute whether x is an element of L ( M ), during the computation, theinner structure of the AEN G e may evolve, and depending on the ordering of strings, says x , x , ... , that we choose to compute whether x i ∈ L ( M ), the language L ( M ) eventually isdetermined.It is obvious that the language L ( M ) belongs to P (see the definition of time complexityin definition 2.1). 9et L ′ = { x ∈ Σ ∗ | ∃ y ( | y | = | x | ∧ y ∈ L ( M )) } . It is again obvious that L ′ belongs to NPby definition 2.1.We prove that L ′ cannot belong to P. Assume that L ′ ∈ P and thus there exists aprocedure M ′ ∈ Ξ e that we can compute L ′ by M ′ in time complexity less than a sub-exponential function f . Then for some k ∈ N , for all x with length greater than k , x belongs to L ′ wheneverwe construct a successful computation path C ,x C ,x , ..., C n,x of the procedure M ′ on x , for some n ≤ f ( | x | ).Let m ∈ N be the maximum length of those strings y ∈ Σ ∗ that until now are accepted bythe persistently evolutionary machine P T (see example 5.2) which is inside the AEN G e .Define m = max( m , k ).For every y ∈ Σ ∗ , let path ( y ) := C ,y C ,y , ..., C f ( | y | ) ,y be the computational path of theprocedure M ′ on the string y . The path ( y ) is generated by the transition engine (note thatit is possible that the length of path ( y ) is less that f ( | y | )). Let S ( y ) = { C j,y | C j,y ∈ path ( y ) ∧ ∃ x ∈ Σ ∗ ( C i,y = ( h, x △ )) } and H ( y ) = { x ∈ Σ ∗ | ∃ C j,y ∈ path ( y )( C j,y = ( h, x △ )) } The set S ( y ) is the set of all configurations that the accepting engine on them runs itspersistently evolutionary NFA, P T , during the computation M ′ on the input string y . If S ( y ) is empty then it means that the computation M ′ on y does not force the structure ofaccepting engine, AEN G e , to evolve.The set H ( y ) is the set of all strings, say z , that during the computation M ′ on y , thepersistently evolutionary NFA, P T inside the accepting engine, works on z as an input.We refer by | H ( y ) | to the number of elements of H ( y ), and obviously we have | H ( y ) | ≤ f ( | y | ) for y with | y | > k .Also let E ( y ) = H ( y ) ∩ { x ∈ Σ ∗ | | x | = | y |} , and D ( y ) = H ( y ) ∩ { x ∈ Σ ∗ | | x | = | y | + 2 } .Let w ∈ Σ ∗ with | w | > m be arbitrary. Two cases are possible: either S ( w ) = ∅ or S ( w ) = ∅ .Consider the first case. S ( w ) = ∅ .Since the set S ( w ) is empty, the execution of M ′ on w does not make the AEN G e evolve, and the value m remains unchanged. Here, we have also two cases:1) If, using T EN G e and AEN G e , we compute that w is a member of L ( M ′ ) = L ′ thenby definition of L ′ , there must exist a string, say v ∈ Σ ∗ , such that | v | = | w | and v ∈ L ( M ) ( ∗ ). Note that, since m is the maximum length of those strings y ∈ Σ ∗ that until now are accepted by thepersistently evolutionary machine P T , if we start to compute P T for an arbitrary string, say z , with lengthgreater than m then P T accepts z . , we first start to compute procedure M on all stringsin Σ ∗ with length | v | + 1 sequentially. As the length of v is greater than m , allstrings with length | v | + 1 are accepted by the persistently evolutionary Turingmachine P T (see item-3 of example 5.2) which is inside AEN G e .(ii) Then we compute that whether v is L ( M ). But because of the evolution of AEN G e happened in part (i), the AEN G e on computation of M on v outputs N O , and thus v is not an element of L ( M ) (see the item-2 of example 5.2). So v L ( M ), and it contradicts with ( ∗ ).2) If, using T EN G e and AEN G e , we compute that w L ( M ′ ) = L ′ then by definitionof L ′ , for all strings v ∈ Σ ∗ , | v | = | w | , we have v L ( M ). But it contradicts withthe free will again. As the length w is greater than m , we may choose a string z with | z | = | w | and by the item-3 of example 5.2, we have z ∈ L ( M ), contradiction.Consider the second case. S ( w ) = ∅ .Suppose that we, before computing M ′ on w , start to compute the procedure M on allstrings v v ∈ E ( w ), and then compute procedure M on all strings v v ∈ D ( w ) respectively.Since | w | > m , we have u ∈ L ( M ) for all u ∈ E ( w ) ∪ D ( w ), and AEN G e evolvesthrough computing M on u AEN G e outputs N o for allconfiguration in { C i,w ∈ S ( w ) | ∃ x ∈ E ( w ) ∪ D ( w ) s.t. C i,w = ( h, x △ ) } . After that, we start to compute M ′ on w . Either we finds w ∈ L ( M ′ ) or w L ( M ′ ). • Suppose the first case happens and w ∈ L ( M ′ ) = L ′ . It contradicts with the freewill of us. We compute M on all strings v | v | = | w | sequentially, and would make { v ∈ Σ ∗ | | v | = | w |} ⊆ L ( M ). Then the AEN G e evolves in the way that, it willoutput N o for all configurations ( h, v △ ), | v | = | w | , and thus there would exist no v ∈ L ( M ) ∩ { x ∈ Σ ∗ | | x | = | w |} which implies w L ( M ′ ), contradiction. • Suppose the second case happens and w L ( M ′ ) = L ′ . Since | H ( w ) | < f ( | w | ) < | w | ,during the computation of M ′ on w , only f ( | w | ) numbers of configurations of the form( h, x △ ), x ∈ { v | | v | = | w |} ∪ { v | | v | = | w |} are given as input to the AEN G e .Therefore there exists a string z ∈ { x ∈ Σ ∗ | | x | = | w |} such that none of its successorshave been input to the persistently evolutionary Turing machine P T , and if we choose z and computes M on it, then z ∈ L ( M ) which implies w ∈ L ′ . Contradiction.We showed that L ′ cannot be computed by any M ′ that its time complexity is less thana sub-exponential function. Thus L ′ does not belong to the class P. But because of theprocedure M , we have L ′ belongs to NP and therefore E | = P = NP. By free will, we mean that we are not forced to use TENG and AENG in any specific ordering. The above theorem simply says that if L ′ belongs to NP then it forces us to interactwith T EN G e and AEN G e in some certain orders, which conflicts with our free will. Theorem 6.6 { A1 , A2 , A3 } 6⊢ P = NP . Proof.
It is a consequence of proposition 6.3 and theorem 6.5. ⊣ For every mathematician, It is obvious that the set of “natural numbers” is different from“Peano axioms”. In the same way, we can talk of “natural computation” and our axioma-tization setting.So, one may ask • How much our setting with 3 axioms expresses the “natural computation”? • How the “natural transition engine” of the reality works? • How the “natural accepting engine” works? • Is our axiomatic system plausibly formalize the “natural computation”?The Church-Turing thesis states thata function on the natural numbers can be calculated by an effective method, ifand only if it is computable by a Turing machine.If we want to recall the Church-Turing thesis in our setting, it saysa function on the natural numbers can be calculated by an effective method, ifand only if it is computable by a procedure M in Ξ.When we perform a computation, we transit from a configuration to another configura-tion (using TENG of the reality) and also, we check whether a configuration is accepted ornot (using AENG of the reality).We do not know what is the inner structure of TENG and AENG of the reality, but webelieve that both TENG and AENG are physically plausible, and thus1. both TENG and AENG of the reality are effectively computable, and2. both TENG and AENG work in linear time.We state these two properties in axioms A A
3. We, inhabitants of reality, can neverfind out whether the reality persistently evolves or not. We can never discover that whetherthe TENG and AENG of the reality is a Turing machine or a Persistently EvolutionaryTuring machine.We believe that our setting and 3 axioms, plausibly formalize the “natural computation”similar to Peano axioms for natural numbers.We cannot derive P = NP from our 3 axioms which forces us to consider the engines ofthe reality to effectively compute in linear time.12
Conclusion
We proposed an axiomatic system for “natural computation”. We justified that our axiomsplausibly describe the “natural computation” similar to Peano axioms for natural numbers.We show that P = NP is not derivable from our axioms.We also show that regarding ”effective computability” from Brouwer’s intuitionism view-point, P = NP. Acknowledgment . I would like to thank Prof. Amir Daneshgar for his valuable comments.
References [1] S. Arora, B. Barak,
Computational Complexity, a modern approach . CambridgeUniversity Press, 2007.[2] M. van Atten,
Brouwer meets Husserl On the Phenomenology of Choice Se-quences , 2007.[3] A. Meduna,
Automata and Languages: Theory and Applications , Springer,2000.[4] A.S. Troelstra, and D. van Dalen,