A Formal Axiomatization of Computation

TL;DR

This paper presents an axiomatic framework for computation inspired by Brouwer choice sequences, constructing a model that demonstrates P does not equal NP within an intuitionistic viewpoint.

Contribution

It introduces a formal axiomatization of computation and constructs a model satisfying P ≠ NP based on Brouwer's intuitionism.

Findings

Constructs a model $E$ satisfying the axioms

Shows $E ot= P$ NP within the model

Supports the view that P ≠ NP in an intuitionistic context

Abstract

We introduce an axiomatization for the notion of computation. Based on the idea of Brouwer choice sequences, we construct a model, denoted by $E$, which satisfies our axioms and $E \models \mathrm{ P \neq NP}$. In other words, regarding "effective computability" in Brouwer intuitionism viewpoint, we show $\mathrm{ P \neq NP}$.

Equations

$$L^{\prime }=\{x\in {\Sigma }^{\ast }\mid \exists y(|y|=|x|\wedge y\in L(M))\},$$

$$\{C_{i,w}\in S(w)\mid \exists x\in E(w)\cup D(w)s.t.C_{i,w}=(h,x\underline{△})\}.$$

Full text

1 Introduction

Is the famous problem $\mathrm{P=NP}$ unprovable? To answer the question, we need an axiomatization for the notion of computation. In sections 2 and 3, we propose our setting and axiomatic system.

To show that $\mathrm{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 satisfy $\mathrm{P=NP}$.

To construct our counter-model, $E$, in section 4 and 5, we introduce non-predetermined functions (inspired by Brouwer choice sequences) and persistently evolutionary Turing machines as an extension of Turing machines to compute non-predetermined functions.

In computational complexity theory, the diagonal argument is used to show that two complexity classes are distinct. Nobody till now could be successful to use the diagonal argument to show $\mathrm{P\neq NP}$.

In classic mathematics, the diagonal argument is used to show that the size of the real numbers is larger than the naturals. But in Brouwer intuitionism mathematics, instead of the diagonal argument, the principle of Bar induction [4] is used to show that there is no one-to-one correspondence between the natural numbers and the real numbers.

Our argument to show that $E\models\mathrm{P\neq NP}$ is not the diagonal argument, and is in some sense similar to Bar induction principle.

In section 7, we argue that our axiomatic system plausibly formalizes “natural computation” similar to Peano axioms for “natural numbers”.

2 Syntax and Definitions

A computation is a sequence of configurations that we transit from one to another by applying some instructions. The transitions are continued until a desired (an accept) configuration is obtained. In the following, we formally describe the notion of computation.

Our syntax, for explaining the notion of computation, consists of the followings

• 1.

$\mathrm{INST}$ is a nonempty set called the set of “instructions”,

• 2.

$\mathrm{CONF}$ is a nonempty set called the set of “configurations” such that to each string $x\in\{0,1\}^{*}$,

• –

a unique configuration $C_{0,x}\in\mathrm{CONF}$ is associated as “the start configuration of the string $x$”, and

• –

to each $C\in\mathrm{CONF}$, a unique string $y_{C}\in\{0,1\}^{*}$ is associated as the string of involved in the configuration $C$, and also we have $y_{C_{0,x}}=x$ (see example 3.1).

• 3.

$\mathrm{TENG}$, the “transition engine”, is a total function from $\mathrm{CONF}\times\mathrm{INST}$ to $\mathrm{CONF}\cup\{\bot\}$111 $\bot$ mean “undefined”..

• 4.

$\mathrm{AENG}$, the “accepting engine”, is a total function from $\mathrm{CONF}$ to $\{YES,NO\}$.

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\subseteq\mathrm{INST}$ (a finite set of instructions), satisfying the following condition*

The determination condition*: for every $C\in\mathrm{CONF}$, at most there exists only one instruction $\tau$ in $M$, denoted by notation $\Upsilon(M,C)=\tau$, such that $\mathrm{TENG}(C,\tau)\in\mathrm{CONF}$. If for all $\iota\in M$, $\mathrm{TENG}(C,\iota)=\bot$, we denote $\Upsilon(M,C)=\emptyset$.*

We refer to the set of all procedures by the symbol $\Xi$.

• ii.

Languages*. A string $x\in\{0,1\}^{*}$, is in the language of a procedure $M$, denoted by $L(M)$, whenever we can construct a sequence $C_{0}C_{1},...,C_{n}$ of configurations in $\mathrm{CONF}$ such that*

• –

$C_{0}=C_{0,x}$,

• –

each $C_{i}$, $i\geq 1$, is obtained by applying $\mathrm{TENG}$ on $(C_{i-1},\Upsilon(M,C_{i-1}))$,

• –

the $\mathrm{AENG}$ outputs $YES$ for $C_{n}$, and $\Upsilon(M,C_{n})=\emptyset$.

The sequence $C_{0}C_{1},...,C_{n}$ is called the “successful computation path” of $M$ on $x$. The length of a computation path is the number of configurations appeared in.

• $iii.$

Functions*. A partial function $f:\Sigma^{*}\rightarrow\Sigma^{*}$, $\Sigma=\{0,1\}$, is computed by a procedure $M\in\Xi$, whenever for $x\in\Sigma^{*}$, we can construct a sequence $C_{0}C_{1},...,C_{n}$ of configurations in $\mathrm{CONF}$ such that*

• –

$C_{0}=C_{0,x}$,

• –

each $C_{i}$, $i\geq 1$, is obtained by applying $\mathrm{TENG}$ on $(C_{i-1},\Upsilon(M,C_{i-1}))$,

• –

the $\mathrm{AENG}$ outputs $YES$ for $C_{n}$, and $\Upsilon(M,C_{n})=\emptyset$,

• –

$y_{C_{n}}=f(x)$.

• $iv.$

Computation Path Length*. The time complexity of computing a procedure $M$ on an input string $x$, denoted by $time_{M}(x)$, is $n$, for some $n\in\mathbb{N}$, whenever we can construct a successful computation path of the procedure $M$ on $x$ with length $n$.*

• $v.$

Time Complexity*. Let $f:\mathbb{N}\rightarrow\mathbb{N}$ and $L\subseteq\Sigma^{*}$. The time complexity of the computation of the language $L$ is less than $f$ whenever there exists a procedure $M\in\Xi$ such that the language defined by the procedure $M$, i.e., $L(M)$, is equal to $L$, and for all $x\in L$, $time_{M}(x)<f(|x|)$.*

• $vi.$

Complexity Classes.* We define the time complexity class $\mathrm{P}\subseteq 2^{\Sigma^{*}}$ to be the set of all languages that we can compute in polynomial time using $\mathrm{TENG}$ and $\mathrm{AENG}$. We also define the complexity class $\mathrm{NP}\subseteq 2^{\Sigma^{*}}$ as follows:*

• $L\in\mathrm{NP}$* iff there exists $J\in\mathrm{P}$ and a polynomial function $q$ such that for all $x\in\Sigma^{*}$,*

$x\in L\Leftrightarrow\exists y\in\Sigma^{*}(|y|\leq q(|x|)\wedge(x,y)\in J)$.

Remark 2.2

Definitions of computability and complexity classes stated in 2.1 are not new and they are the same definitions appeared in [1] and [3].

3 Axioms

In this section, we introduce the axioms of our setting. We only have 3 axioms.

• $A1.$

Turing Computability and Complexity. For every Turing machine $T$, there exists a procedure $M\in\Xi$ such that $L(M)=L(T)$ and the time complexity of $L(M)$ is equal to the time complexity of $L(T)$.

• $A2.$

**Effective Computability of Engines **. Both engines $\mathrm{TENG}$ and $\mathrm{AENG}$ are effectively computable (see 5.5).

• $A3.$

Time Complexity of Engines. Both engines $\mathrm{TENG}$ and $\mathrm{AENG}$ work in linear time (see 5.6).

In section 7, we argue that these 3 axioms plausibly express the notion of “natural computation”. Axiom $A2$ and $A3$ reasonably express the attributes of the transition engine and the accepting engine. We expect that both $\mathrm{TENG}$ and $\mathrm{AENG}$ are physically plausible and effectively computable, and just use linear time (clock) on configurations to determine the next configuration or accepting configurations.

In example 3.1, we introduce a model, named $V$, which satisfies axioms $A1$, $A2$, and $A3$.

Example 3.1

Let

• $Q_{T}=\{h\}\cup\{q_{i}\mid i\in\mathbb{N}\cup\{0\}\}$,

• $\Sigma,\Gamma$* be two finite set with $\Sigma\subseteq\Gamma$ and*

• $\Gamma$* has a symbol $\triangle\in\Gamma-\Sigma$.*

$INST_{v}=\{[(q,a)\rightarrow(p,b,D)]\mid p,q\in Q_{T},a,b\in\Gamma,D\in\{R,L\}\}$,

• 2)

$CONF_{v}=\{(q,x\underline{a}z)\mid q\in Q_{T},x,z\in\Gamma^{*},a\in\Gamma\}$, for each $x\in\Sigma^{*}$, $C_{0,x}=(q_{0},\underline{\triangle}x)$, and for each $C=(q,x\underline{a}z)\in CONF_{v}$, $y_{C}=xaz$.

Let $C=(q,xb_{1}\underline{a}b_{2}y)$ be an arbitrary configuration then

• –

$TENG_{v}(C,[(q,a)\rightarrow(p,c,R)])$* is defined to be $C^{\prime}=(p,xb_{1}c\underline{b_{2}}y)$,*

• –

$TENG_{v}(C,[(q,a)\rightarrow(p,c,L)])$* is defined to be $C^{\prime}=(p,x\underline{b_{1}}cb_{2}y)$, and*

• –

for other cases $TENG_{v}$ is defined to be $\bot$.

$TENG_{v}$* can be computed by a Turing machine in linear time.*

• 4-

Let $C\in CONF_{v}$ be arbitrary

• –

if $C=(h,\underline{\triangle}x)$ then $AENG_{v}(C)$ is defined to be $YES$,

• –

if $C=(h,x\underline{\triangle})$ then $AENG_{v}(C)$ is defined to be $YES$, and

• –

otherwise $AENG_{v}(C)$ is defined to be $NO$.

$AENG_{v}$* can be computed by a Turing machine in linear time.*

• 5-

For each $M\in\Xi_{v}$, and $C=(q,x\underline{a}y)\in CONF_{v}$, if there exists $[(q,a)\rightarrow(p,b,D)]\in M$ for some $p\in Q_{T},b\in\Gamma$, and $D\in\{R,L\}$, then $\Upsilon(M,C)=\{[(q,a)\rightarrow(p,b,D)]\}$ else it is defined to be $\emptyset$.

Remark 3.2

The model $V$ (example 3.1) is the same model of standard Turing machine which is recalled and expressed by our proposed syntax. Every instruction $\tau\in\mathrm{INST_{v}}$ is a transition of Turing machines.

Suppose $T=\langle Q,\delta,\Sigma,\Gamma,F\rangle$ be a Truing machine, then in our syntax, the set $\delta$ is a procedure in 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 $A1$, $A2$, and $A3$, as both $TENG_{v}$ and $AENG_{v}$ are linear time Turing computable.

By axioms $A2$ and $A3$, 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 Turing Computability and introduce persistently evolutionary Turing machines.

4 Non-predetermined Functions

The most important and fundamental notion of mathematics is function. A function is a process 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 eventually determined through the way we start to associate $f(x)$ for every element $x\in X$.

We introduce Persistently Evolutionary Turing machines that compute non-predetermined functions.

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 being well-defined does not force the process $f$ to be predetermined.

Suppose that $x_{1}$ and $x_{2}$ are two different elements of $X$. I want to use the process $f$ to determine the value of $f$ for $x_{1}$ and $x_{2}$. It is up to me to first perform the process $f$ on $x_{1}$ or $x_{2}$.

If $f$ is predetermined the it does not matter to perform the process on ordering $x_{1}x_{2}$ or ordering $x_{2}x_{1}$. 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 interacted 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)\in W$ then output $g(n)=z$, else update $W=W\cup\{(n,|W|+1)\}$ and output $g(n)=|W|+1$.

The function $g$ is a non-predetermined function over natural numbers. I input $7,9,1,11$ and the process will associates the following: $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 always undetermined 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,1,7,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]. A Choice sequence is an unfinished objects where the value of the sequence are not necessary predetermined.

A choice sequence is begun at a particular moment in time, and then grows as we choose further numbers. This process is generally open-ended and may be continued forever. (page 89 of [2])

5 Persistently Evolutionary Turing machines

In this section, to have a formal computation model for non-predetermined functions, we introduce the notion of Persistently Evolutionary Turing machines (we may also name them Brouwer-Turing machines) as an effective Computable method.

Persistently Evolutionary Turing machines are an extension of the notion of Turing machines 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 $\delta$ which both are fixed and remain unchanged forever. In Persistently Evolutionary Turing machines, we allow the set of states and the table of transitions changes through each computation.

As a Persistently Evolutionary Turing Machine $PT$ computes on an input string $x$, the machine $PT$ can add or remove some of its states and transitions, and thus after the computation on the input $x$ is completed, the sets $Q$ and $\delta$ have been changed.

However, these changes are persistent. That is, if we already input a string $x$ and the machine outputs $y$, then whenever we again input $x$ the machine outputs the same $y$, and the 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 some rules of adding and removing of states and transitions. Then, We input strings to the box and for each string, the box outputs a single string. The machine in the box changes itself based 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=\langle Q,\delta,q_{0},\Sigma=\{0,1\},\Gamma=\Sigma\cup\{\bigtriangleup\},F\rangle$ 222$Q$: the set of states, $\delta$: the transition table, $F$: the set of accepting states consists of the following:

• •

The Initial Machine*. $M_{0}=\langle Q_{0},\delta_{0},F_{0}\rangle$, initially $M=M_{0}$.*

• •

Updating Rules*. There could be a finite set of updating rules. The following is the generic rule*

• –

If during the computation, the machine $M$ on an input, say $x$, reached to a configuration, say $C$, with a specific property, say $\phi$, then update

$\delta=\delta\cup\{t(C)\}$* or $\delta=\delta-\{t(C)\}$,*

• *

$F=F\cup\{q(C)\}$* or $F=F-\{q(C)\}$,*

• *

$Q=Q\cup\{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 nondeterministic finite automate [3].

Example 5.2

*(In the sequel of the paper, we will refer to the persistently evolutionary machine introduced in this example by $PT_{1}$). ***

Define $\mathrm{Evolve}:\mathrm{NFA}_{1}\times\Sigma^{*}\rightarrow\mathrm{NFA}_{1}$ as follows333$\mathrm{NFA}_{1}$ is the class of all nondeterministic finite automata $M=\langle Q,\Sigma=\{0,1\},\delta,q_{0},F\rangle$, where for each state $q\in Q$, and $a\in\Sigma$, there exists at most one transition from $q$ with label $a$.:

Let $M\in\mathrm{NFA}_{1}$, $M=\langle Q,q_{0},\Sigma=\{0,1\},\delta:Q\times\Sigma\rightarrow Q,F\subseteq Q\rangle$444F is the set of accepting states, and $x\in\Sigma^{*}$. Suppose $x=a_{0}a_{1}\cdots a_{k}$ where $a_{i}\in\Sigma$. Applying the automata $M$ on $x$, one of the three following cases may happen:

• case1.

The automata $M$ reads all $a_{0},a_{1}\cdots,a_{k}$ successfully and stops in an accepting state. In this case, the structure of the automata does not change and let $\mathrm{Evolve}(M,x)=M$.

• case2.

The automata $M$ reads all $a_{0},a_{1}\cdots,a_{k}$ successfully and stops in a state $p$ which is not an accepting state.

• –

If the automata $M$ can transit from the state $p$ to an accepting state by reading only one alphabet, then let $\mathrm{Evolve}(M,x)=M$.

• –

If it cannot transit (from $p$ to an accepting state) then let $\mathrm{Evolve}(M,x)$ to be a new automata $M^{\prime}=\langle Q,q^{\prime}_{0},\Sigma=\{0,1\},\delta^{\prime}:Q^{\prime}\times\Sigma\rightarrow Q^{\prime},F^{\prime}\subseteq Q^{\prime}\rangle$, where $Q^{\prime}=Q$, $\delta^{\prime}=\delta$, $F^{\prime}=F\cup\{p\}$.

• case3.

The automata $M$ cannot read all $a_{0},a_{1}\cdots,a_{k}$ successfully,and after reading a part of $x$, say $a_{0}a_{1}\cdots a_{i}$, $0\leq i\leq k$, it crashes in a state $q$ that $\delta(q,a_{i+1})$ is not defined. In this case, we let $\mathrm{Evolve}(M,x)$ be a new automata $M^{\prime}=\langle Q,q^{\prime}_{0},\Sigma=\{0,1\},\delta^{\prime}:Q^{\prime}\times\Sigma\rightarrow Q^{\prime},F^{\prime}\subseteq Q^{\prime}\rangle$, where $Q^{\prime}=Q\cup\{s_{i+1},s_{i+2},\cdots,s_{k}\}$ (all $s_{i+1},s_{i+2},\cdots,s_{k}$ are new states that does not belong to $Q$), $\delta^{\prime}=\delta\cup\{(q,a_{i+1},s_{i+1}),(s_{i+1},a_{i+2},s_{i+2}),$ $\cdots,(s_{k-1},a_{k},s_{k})\}$, and $F^{\prime}=F\cup\{s_{k}\}$.

The machine $PT_{1}$ 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_{0}\}$, $F=\emptyset$, $\delta=\emptyset$. Now I input the string $101$ and according to case 3, the machine $M$ evolves and new states $q_{1},q_{2},q_{3}$ and transitions $(q_{0},1,q_{1}),(q_{1},0,q_{2}),(q_{2},1,q_{3})$ are added and also $F=F\cup\{q_{3}\}$. Now if I input the string $10$ then according to case 2, $M$ rejects it. However, If at first I inputted $10$ to the machine then it would accept it.

5.1 Time complexity of Evolutionary Turing machines

The time-complexity [1] of Persistent Evolutionary Turing Machines is defined similar to the time-complexity of Turing machines except that for each (adding) removing of states or transitions, we count one extra clock.

Definition 5.3

Let $M=\langle Q,\delta,q_{0},\Sigma=\{0,1\},\Gamma=\Sigma\cup\{\bigtriangleup\},F\rangle$ be a persistently evolutionary Turing machine, $x$ is an arbitrary string, and $f:\mathbb{N}\rightarrow\mathbb{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 $\delta$, and

• •

the number of uses of updating rules

happened during the computation $M$ on $x$, is less than $f(|x|)$.

Proposition 5.4

The time complexity of the machine $PT_{1}$ in example 5.2 is linear.

Proof. It is straightforward. $\dashv$

5.2 Effective Computability

In axioms $A2$ and $A3$, we required that both $\mathrm{TENG}$ and $\mathrm{AENG}$ to be effectively computable in linear time. In two following definitions, we formally explain what we mean by an effective Computability.

Definition 5.5

A function is effectively computable if it is either Turing computable or Persistently Evolutionary Turing computable.

Definition 5.6

A function is computed in linear time whenever its corresponding Turing or Persistently Evolutionary Turing machine works in linear time.

6 A Counter-Model

In this section, we prove that $\mathrm{P=NP}$ is not derivable from Axioms $A1$, $A2$ and $A3$. To do this, we construct a model $E$ which satisfies $A1$, $A2$ and $A3$ but not $\mathrm{P=NP}$.

Definition 6.1

We introduce a model $E$ as follows.

• •

Two sets $INST_{e}$ and $CONF_{e}$ are defined to be the same $INST_{v}$ and $CONF_{v}$ in example 3.1 respectively, and consequently the set $\Xi_{e}$ is the same $\Xi_{v}$.

• •

The transition engine $TENG_{e}$ is also defined similarly to the transition engine $TENG_{v}$ in example 3.1, and thus it is linear time computable by a Turing machine.

• •

The accepting engine $AENG_{e}$ is defined as follows: let $C\in CONF_{e}$ be arbitrary

• –

if $C=(h,\underline{\triangle}x)$ then $AENG_{e}(C)=YES$,

• –

if $C=(h,x\underline{\triangle})$ then the $AENG_{e}$ works exactly similar to the the persistently evolutionary machine $PT_{1}$ introduced in example 5.2. On input $x$, if $PT_{1}$ outputs $1$, the accepting engine outputs $YES$, and

• –

otherwise $AENG_{e}(C)=NO$.

By proposition 5.4, the engine $AENG_{e}$ is linear time computable by a persistently evolutionary Turing machine.

Remark 6.2

The only difference between model $E$ with model $V$ (see example 3.1) is that the $SBOX_{e}$ is a persistently evolutionary Turing machine.

Proposition 6.3

The model $E$ satisfies axioms $A1$, $A2$, and $A3$.

Proof. It is obvious by definition. $\dashv$

Note that the $AENG_{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 $\Xi_{v}=\Xi_{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\in\Xi_{e}$, we have $L(M)$ is a non-predetermined language. The procedure $M$ is fixed and does not change through time, but since the structure of $AENG_{e}$ changes through time, the language $L(M)$ is non-predetermined.

Definition 6.4

We say a function $f:\mathbb{N}\rightarrow\mathbb{N}$ is sub-exponential, whenever there exists $t\in\mathbb{N}$ such that for all $n>t$, $f(n)<2^{n}$.

Theorem 6.5

We have

$E\models\mathrm{P\neq NP}$.

We show that there exists a procedure $M\in\Xi_{e}$ such that

• •

the language $L(M)$ that the we compute through $M$ is not predetermined,

• •

the language $L(M)$ belongs to the class $\mathrm{P}$,

• •

there exists no procedure $M^{\prime}\in\Xi_{e}$, such that $L(M^{\prime})$ is equal to

[TABLE]

and for some $k\in\mathbb{N}$, for all $x\in L(M^{\prime})$, if $|x|>k$ then

$time_{M}(x)\leq f(|x|)$**

where $f:\mathbb{N}\rightarrow\mathrm{N}$ is a sub-exponential function. In other world, $L^{\prime}$ is in $\mathrm{NP}$ but not in $\mathrm{P}$.

Proof. Consider the following procedure $M\in\Xi_{e}$

• $\Sigma=\{0,1\},\Gamma=\{0,1,\triangle\},$
• $M=\{[(q_{0},\triangle)\rightarrow(h,\triangle,R)],[(h,0)\rightarrow(h,0,R)],[(h,1)\rightarrow(h,1,R)]\}$.

Using the $TENG_{e}$ and $AENG_{e}$, we compute procedure $M$ on an input $x$ as follows:

Note $C_{0,x}=(q_{0},\underline{\triangle}x)$, and $\Upsilon(M,C_{0,x})=[(q_{0},\triangle)\rightarrow(h,\triangle,R)]$.

• -

We have $TENG_{e}(C_{0,x},[(q_{0},\triangle)\rightarrow(h,\triangle,R)])=(h,\triangle\underline{a}x^{\prime})$ where $x=ax^{\prime}$ for some $a\in Sigma$.

• -

Continuing using the transition engine on the configurations, we reach to the configuration $(h,x\underline{\triangle})$ which $\Upsilon(M,(h,x\underline{\triangle}))=\emptyset$.

• -

Running the accepting engine, $AENG_{e}(M,(h,x\underline{\triangle}))$, the persistently evolutionary NFA 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 choose a string $x\in\Sigma^{*}$ to compute whether $x$ is an element of $L(M)$, during the computation, the inner structure of the $AENG_{e}$ may evolve, and depending on the ordering of strings, says $x_{1},x_{2},...$, that we choose to compute whether $x_{i}\in L(M)$, the language $L(M)$ eventually is determined.

It is obvious that the language $L(M)$ belongs to $\mathrm{P}$ (see the definition of time complexity in definition 2.1).

Let $L^{\prime}=\{x\in\Sigma^{*}\mid\exists y(|y|=|x|\wedge y\in L(M))\}$. It is again obvious that $L^{\prime}$ belongs to $\mathrm{NP}$ by definition 2.1.

We prove that $L^{\prime}$ cannot belong to $\mathrm{P}$. Assume that $L^{\prime}\in\mathrm{P}$ and thus there exists a procedure $M^{\prime}\in\Xi_{e}$ that we can compute $L^{\prime}$ by $M^{\prime}$ in time complexity less than a sub-exponential function $f$. Then for some $k\in\mathbb{N}$, for all $x$ with length greater than $k$, $x$ belongs to $L^{\prime}$ whenever

• we construct a successful computation path $C_{0,x}C_{1,x},...,C_{n,x}$ of the procedure $M^{\prime}$ on $x$, for some $n\leq f(|x|)$.

Let $m_{1}\in\mathbb{N}$ be the maximum length of those strings $y\in\Sigma^{*}$ that until now are accepted by the persistently evolutionary machine $PT_{1}$ (see example 5.2) which is inside the $AENG_{e}$555Note that, since $m_{1}$ is the maximum length of those strings $y\in\Sigma^{*}$ that until now are accepted by the persistently evolutionary machine $PT_{1}$, if we start to compute $PT_{1}$ for an arbitrary string, say $z$, with length greater than $m_{1}$ then $PT_{1}$ accepts $z$..

Define $m=\max(m_{1},k)$.

For every $y\in\Sigma^{*}$, let $path(y):=C_{0,y}C_{1,y},...,C_{f(|y|),y}$ be the computational path of the procedure $M^{\prime}$ on the string $y$. The $path(y)$ is generated by the transition engine (note that it is possible that the length of $path(y)$ is less that $f(|y|)$). Let

$S(y)=\{C_{j,y}\mid C_{j,y}\in path(y)\wedge\exists x\in\Sigma^{*}(C_{i,y}=(h,x\underline{\triangle}))\}$

and

$H(y)=\{x\in\Sigma^{*}\mid\exists C_{j,y}\in path(y)(C_{j,y}=(h,x\underline{\triangle}))\}$

The set $S(y)$ is the set of all configurations that the accepting engine on them runs its persistently evolutionary NFA, $PT_{1}$, during the computation $M^{\prime}$ on the input string $y$. If $S(y)$ is empty then it means that the computation $M^{\prime}$ on $y$ does not force the structure of accepting engine, $AENG_{e}$, to evolve.

The set $H(y)$ is the set of all strings, say $z$, that during the computation $M^{\prime}$ on $y$, the persistently evolutionary NFA, $PT_{1}$ 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)|\leq f(|y|)$ for $y$ with $|y|>k$.

Also let $E(y)=H(y)\cap\{x\in\Sigma^{*}\mid|x|=|y|\}$, and $D(y)=H(y)\cap\{x\in\Sigma^{*}\mid|x|=|y|+2\}$.

Let $w\in\Sigma^{*}$ with $|w|>m$ be arbitrary. Two cases are possible: either $S(w)=\emptyset$ or $S(w)\neq\emptyset$.

Consider the first case. $S(w)=\emptyset$.

Since the set $S(w)$ is empty, the execution of $M^{\prime}$ on $w$ does not make the $AENG_{e}$ evolve, and the value $m_{1}$ remains unchanged. Here, we have also two cases:

If, using $TENG_{e}$ and $AENG_{e}$, we compute that $w$ is a member of $L(M^{\prime})=L^{\prime}$ then by definition of $L^{\prime}$, there must exist a string, say $v\in\Sigma^{*}$, such that

$|v|=|w|$ and $v\in L(M)$ $(*)$.

But is a contradiction.

• (i)

Since we have the free will 666By free will, we mean that we are not forced to use $\mathrm{TENG}$ and $\mathrm{AENG}$ in any specific ordering., we first start to compute procedure $M$ on all strings in $\Sigma^{*}$ with length $|v|+1$ sequentially. As the length of $v$ is greater than $m$, all strings with length $|v|+1$ are accepted by the persistently evolutionary Turing machine $PT_{1}$ (see item-3 of example 5.2) which is inside $AENG_{e}$.

• (ii)

Then we compute that whether $v$ is $L(M)$. But because of the evolution of $AENG_{e}$ happened in part (i), the $AENG_{e}$ on computation of $M$ on $v$ outputs $NO$, and thus $v$ is not an element of $L(M)$ (see the item-2 of example 5.2). So $v\not\in L(M)$, and it contradicts with $(*)$.

• 2)

If, using $TENG_{e}$ and $AENG_{e}$, we compute that $w\not\in L(M^{\prime})=L^{\prime}$ then by definition of $L^{\prime}$, for all strings $v\in\Sigma^{*}$, $|v|=|w|$, we have $v\not\in L(M)$. But it contradicts with the 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\in L(M)$, contradiction.

Consider the second case. $S(w)\neq\emptyset$.

Suppose that we, before computing $M^{\prime}$ on $w$, start to compute the procedure $M$ on all strings $v0$’s, for all $v\in E(w)$, and then compute procedure $M$ on all strings $v0$’s, for all $v\in D(w)$ respectively.

Since $|w|>m$, we have $u0\in L(M)$ for all $u\in E(w)\cup D(w)$, and $AENG_{e}$ evolves through computing $M$ on $u0$’s. It evolves in the way that $AENG_{e}$ outputs $No$ for all configuration in

[TABLE]

After that, we start to compute $M^{\prime}$ on $w$. Either we finds $w\in L(M^{\prime})$ or $w\not\in L(M^{\prime})$.

• •

Suppose the first case happens and $w\in L(M^{\prime})=L^{\prime}$. It contradicts with the free will of us. We compute $M$ on all strings $v0$, $|v|=|w|$ sequentially, and would make $\{v0\in\Sigma^{*}\mid|v|=|w|\}\subseteq L(M)$. Then the $AENG_{e}$ evolves in the way that, it will output $No$ for all configurations $(h,v\underline{\triangle})$, $|v|=|w|$, and thus there would exist no $v\in L(M)\cap\{x\in\Sigma^{*}\mid|x|=|w|\}$ which implies $w\not\in L(M^{\prime})$, contradiction.

• •

Suppose the second case happens and $w\not\in L(M^{\prime})=L^{\prime}$. Since $|H(w)|<f(|w|)<2^{|w|}$, during the computation of $M^{\prime}$ on $w$, only $f(|w|)$ numbers of configurations of the form $(h,x\underline{\triangle})$, $x\in\{v0\mid|v|=|w|\}\cup\{v1\mid|v|=|w|\}$ are given as input to the $AENG_{e}$. Therefore there exists a string $z\in\{x\in\Sigma^{*}\mid|x|=|w|\}$ such that none of its successors have been input to the persistently evolutionary Turing machine $PT_{1}$, and if we choose $z$ and computes $M$ on it, then $z\in L(M)$ which implies $w\in L^{\prime}$. Contradiction.

We showed that $L^{\prime}$ cannot be computed by any $M^{\prime}$ that its time complexity is less than a sub-exponential function. Thus $L^{\prime}$ does not belong to the class $\mathrm{P}$. But because of the procedure $M$, we have $L^{\prime}$ belongs to $\mathrm{NP}$ and therefore

$E\models\mathrm{P\neq NP}$.

$\dashv$

The above theorem simply says that if $L^{\prime}$ belongs to $\mathrm{NP}$ then it forces us to interact with $TENG_{e}$ and $AENG_{e}$ in some certain orders, which conflicts with our free will.

Theorem 6.6

$\mathrm{\{A1,A2,A3\}\not\vdash P=NP}$.

Proof.* It is a consequence of proposition 6.3 and theorem 6.5. $\dashv$*

7 Natural Computation

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 axiomatization 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 that

a function on the natural numbers can be calculated by an effective method, if and only if it is computable by a Turing machine.

If we want to recall the Church-Turing thesis in our setting, it says

a function on the natural numbers can be calculated by an effective method, if and only if it is computable by a procedure $M$ in $\Xi$.

When we perform a computation, we transit from a configuration to another configuration (using $\mathrm{TENG}$ of the reality) and also, we check whether a configuration is accepted or not (using $\mathrm{AENG}$ of the reality).

We do not know what is the inner structure of $\mathrm{TENG}$ and $\mathrm{AENG}$ of the reality, but we believe that both $\mathrm{TENG}$ and $\mathrm{AENG}$ are physically plausible, and thus

both $\mathrm{TENG}$ and $\mathrm{AENG}$ of the reality are effectively computable, and

• 2.

both $\mathrm{TENG}$ and $\mathrm{AENG}$ work in linear time.

We state these two properties in axioms $A2$ and $A3$. We, inhabitants of reality, can never find out whether the reality persistently evolves or not. We can never discover that whether the $\mathrm{TENG}$ and $\mathrm{AENG}$ of the reality is a Turing machine or a Persistently Evolutionary Turing machine.

We believe that our setting and 3 axioms, plausibly formalize the “natural computation” similar to Peano axioms for natural numbers.

We cannot derive $\mathrm{P=NP}$ from our 3 axioms which forces us to consider the engines of the reality to effectively compute in linear time.

8 Conclusion

We proposed an axiomatic system for “natural computation”. We justified that our axioms plausibly describe the “natural computation” similar to Peano axioms for natural numbers. We show that $\mathrm{P=NP}$ is not derivable from our axioms.

We also show that regarding ”effective computability” from Brouwer’s intuitionism viewpoint, $\mathrm{P\neq NP}$.

Acknowledgment. I would like to thank Prof. Amir Daneshgar for his valuable comments.